Reduce heap allocation in format string parsers.

* gettext-tools/src/format-awk.c (struct spec): Remove 'allocated' field.
(format_parse): Use a local variable instead.
* gettext-tools/src/format-boost.c: Likewise.
* gettext-tools/src/format-elisp.c: Likewise.
* gettext-tools/src/format-gcc-internal.c: Likewise.
* gettext-tools/src/format-java-printf.c: Likewise.
* gettext-tools/src/format-javascript.c: Likewise.
* gettext-tools/src/format-kde.c: Likewise.
* gettext-tools/src/format-librep.c: Likewise.
* gettext-tools/src/format-lua.c: Likewise.
* gettext-tools/src/format-perl-brace.c: Likewise.
* gettext-tools/src/format-python.c: Likewise.
* gettext-tools/src/format-sh.c: Likewise.
* gettext-tools/src/format-tcl.c: Likewise.
* gettext-tools/src/format-c-parse.h (struct spec): Remove 'allocated' field.
(format_parse_entrails): Use a local variable instead.
* gettext-tools/src/format-pascal.c (struct spec): Remove 'allocated' field.
(format_parse): Rename a local variable.
* gettext-tools/src/format-perl.c: Likewise.
* gettext-tools/src/format-php.c: Likewise.
* gettext-tools/src/format-gfc-internal.c (format_parse): Rename a local
variable.

diff --git a/gettext-tools/src/format-awk.c b/gettext-tools/src/format-awk.c
index c6c1f44f736498c76bb286de429c40e3bf7a43bd..39d267b84fcee957e9fe179815993c284448ccfc 100644 (file)
--- a/gettext-tools/src/format-awk.c
+++ b/gettext-tools/src/format-awk.c
@@ -1,5 +1,5 @@
 /* awk format strings.
-   Copyright (C) 2001-2004, 2006-2007, 2009, 2019 Free Software Foundation, Inc.
+   Copyright (C) 2001-2004, 2006-2007, 2009, 2019-2020 Free Software Foundation, Inc.
    Written by Bruno Haible <haible@clisp.cons.org>, 2002.
 
    This program is free software: you can redistribute it and/or modify
@@ -72,7 +72,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
   struct numbered_arg *numbered;
 };
 
@@ -98,13 +97,14 @@ format_parse (const char *format, bool translated, char *fdi,
 {
   const char *const format_start = format;
   struct spec spec;
+  unsigned int numbered_allocated;
   unsigned int unnumbered_arg_count;
   struct spec *result;
 
   spec.directives = 0;
   spec.numbered_arg_count = 0;
-  spec.allocated = 0;
   spec.numbered = NULL;
+  numbered_allocated = 0;
   unnumbered_arg_count = 0;
 
   for (; *format != '\0';)
@@ -192,10 +192,10 @@ format_parse (const char *format, bool translated, char *fdi,
                     goto bad_format;
                   }
 
-                if (spec.allocated == spec.numbered_arg_count)
+                if (numbered_allocated == spec.numbered_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                    numbered_allocated = 2 * numbered_allocated + 1;
+                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                   }
                 spec.numbered[spec.numbered_arg_count].number = width_number;
                 spec.numbered[spec.numbered_arg_count].type = FAT_INTEGER;
@@ -213,10 +213,10 @@ format_parse (const char *format, bool translated, char *fdi,
                     goto bad_format;
                   }
 
-                if (spec.allocated == unnumbered_arg_count)
+                if (numbered_allocated == unnumbered_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                    numbered_allocated = 2 * numbered_allocated + 1;
+                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                   }
                 spec.numbered[unnumbered_arg_count].number = unnumbered_arg_count + 1;
                 spec.numbered[unnumbered_arg_count].type = FAT_INTEGER;
@@ -277,10 +277,10 @@ format_parse (const char *format, bool translated, char *fdi,
                         goto bad_format;
                       }
 
-                    if (spec.allocated == spec.numbered_arg_count)
+                    if (numbered_allocated == spec.numbered_arg_count)
                       {
-                        spec.allocated = 2 * spec.allocated + 1;
-                        spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                        numbered_allocated = 2 * numbered_allocated + 1;
+                        spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                       }
                     spec.numbered[spec.numbered_arg_count].number = precision_number;
                     spec.numbered[spec.numbered_arg_count].type = FAT_INTEGER;
@@ -298,10 +298,10 @@ format_parse (const char *format, bool translated, char *fdi,
                         goto bad_format;
                       }
 
-                    if (spec.allocated == unnumbered_arg_count)
+                    if (numbered_allocated == unnumbered_arg_count)
                       {
-                        spec.allocated = 2 * spec.allocated + 1;
-                        spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                        numbered_allocated = 2 * numbered_allocated + 1;
+                        spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                       }
                     spec.numbered[unnumbered_arg_count].number = unnumbered_arg_count + 1;
                     spec.numbered[unnumbered_arg_count].type = FAT_INTEGER;
@@ -363,10 +363,10 @@ format_parse (const char *format, bool translated, char *fdi,
                     goto bad_format;
                   }
 
-                if (spec.allocated == spec.numbered_arg_count)
+                if (numbered_allocated == spec.numbered_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                    numbered_allocated = 2 * numbered_allocated + 1;
+                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                   }
                 spec.numbered[spec.numbered_arg_count].number = number;
                 spec.numbered[spec.numbered_arg_count].type = type;
@@ -384,10 +384,10 @@ format_parse (const char *format, bool translated, char *fdi,
                     goto bad_format;
                   }
 
-                if (spec.allocated == unnumbered_arg_count)
+                if (numbered_allocated == unnumbered_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                    numbered_allocated = 2 * numbered_allocated + 1;
+                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                   }
                 spec.numbered[unnumbered_arg_count].number = unnumbered_arg_count + 1;
                 spec.numbered[unnumbered_arg_count].type = type;

diff --git a/gettext-tools/src/format-boost.c b/gettext-tools/src/format-boost.c
index 4b8b01d632d8729aad72e489ee7168660a810689..4cf023cee7ede4bb655a6b0e3752ec66d37d80d0 100644 (file)
--- a/gettext-tools/src/format-boost.c
+++ b/gettext-tools/src/format-boost.c
@@ -1,5 +1,5 @@
 /* Boost format strings.
-   Copyright (C) 2001-2004, 2006-2007, 2009, 2019 Free Software Foundation, Inc.
+   Copyright (C) 2001-2004, 2006-2007, 2009, 2019-2020 Free Software Foundation, Inc.
    Written by Bruno Haible <haible@clisp.cons.org>, 2006.
 
    This program is free software: you can redistribute it and/or modify
@@ -92,7 +92,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
   struct numbered_arg *numbered;
 };
 
@@ -118,13 +117,14 @@ format_parse (const char *format, bool translated, char *fdi,
 {
   const char *const format_start = format;
   struct spec spec;
+  unsigned int numbered_allocated;
   unsigned int unnumbered_arg_count;
   struct spec *result;
 
   spec.directives = 0;
   spec.numbered_arg_count = 0;
-  spec.allocated = 0;
   spec.numbered = NULL;
+  numbered_allocated = 0;
   unnumbered_arg_count = 0;
 
   for (; *format != '\0';)
@@ -240,10 +240,10 @@ format_parse (const char *format, bool translated, char *fdi,
                             goto bad_format;
                           }
 
-                        if (spec.allocated == spec.numbered_arg_count)
+                        if (numbered_allocated == spec.numbered_arg_count)
                           {
-                            spec.allocated = 2 * spec.allocated + 1;
-                            spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                            numbered_allocated = 2 * numbered_allocated + 1;
+                            spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                           }
                         spec.numbered[spec.numbered_arg_count].number = width_number;
                         spec.numbered[spec.numbered_arg_count].type = FAT_INTEGER;
@@ -263,10 +263,10 @@ format_parse (const char *format, bool translated, char *fdi,
                             goto bad_format;
                           }
 
-                        if (spec.allocated == unnumbered_arg_count)
+                        if (numbered_allocated == unnumbered_arg_count)
                           {
-                            spec.allocated = 2 * spec.allocated + 1;
-                            spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                            numbered_allocated = 2 * numbered_allocated + 1;
+                            spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                           }
                         spec.numbered[unnumbered_arg_count].number = unnumbered_arg_count + 1;
                         spec.numbered[unnumbered_arg_count].type = FAT_INTEGER;
@@ -329,10 +329,10 @@ format_parse (const char *format, bool translated, char *fdi,
                                 goto bad_format;
                               }
 
-                            if (spec.allocated == spec.numbered_arg_count)
+                            if (numbered_allocated == spec.numbered_arg_count)
                               {
-                                spec.allocated = 2 * spec.allocated + 1;
-                                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                                numbered_allocated = 2 * numbered_allocated + 1;
+                                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                               }
                             spec.numbered[spec.numbered_arg_count].number = precision_number;
                             spec.numbered[spec.numbered_arg_count].type = FAT_INTEGER;
@@ -352,10 +352,10 @@ format_parse (const char *format, bool translated, char *fdi,
                                 goto bad_format;
                               }
 
-                            if (spec.allocated == unnumbered_arg_count)
+                            if (numbered_allocated == unnumbered_arg_count)
                               {
-                                spec.allocated = 2 * spec.allocated + 1;
-                                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated  * sizeof (struct numbered_arg));
+                                numbered_allocated = 2 * numbered_allocated + 1;
+                                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated  * sizeof (struct numbered_arg));
                               }
                             spec.numbered[unnumbered_arg_count].number = unnumbered_arg_count + 1;
                             spec.numbered[unnumbered_arg_count].type = FAT_INTEGER;
@@ -470,10 +470,10 @@ format_parse (const char *format, bool translated, char *fdi,
                         goto bad_format;
                       }
 
-                    if (spec.allocated == spec.numbered_arg_count)
+                    if (numbered_allocated == spec.numbered_arg_count)
                       {
-                        spec.allocated = 2 * spec.allocated + 1;
-                        spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                        numbered_allocated = 2 * numbered_allocated + 1;
+                        spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                       }
                     spec.numbered[spec.numbered_arg_count].number = number;
                     spec.numbered[spec.numbered_arg_count].type = type;
@@ -491,10 +491,10 @@ format_parse (const char *format, bool translated, char *fdi,
                         goto bad_format;
                       }
 
-                    if (spec.allocated == unnumbered_arg_count)
+                    if (numbered_allocated == unnumbered_arg_count)
                       {
-                        spec.allocated = 2 * spec.allocated + 1;
-                        spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                        numbered_allocated = 2 * numbered_allocated + 1;
+                        spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                       }
                     spec.numbered[unnumbered_arg_count].number = unnumbered_arg_count + 1;
                     spec.numbered[unnumbered_arg_count].type = type;

diff --git a/gettext-tools/src/format-c-parse.h b/gettext-tools/src/format-c-parse.h
index c9148d87b4da552da2c57992a4801eb11820f2f8..a26a18425ab406f2243ceeab66369778d7ce6581 100644 (file)
--- a/gettext-tools/src/format-c-parse.h
+++ b/gettext-tools/src/format-c-parse.h
@@ -1,5 +1,5 @@
 /* Parsing C format strings.
-   Copyright (C) 2001-2004, 2006-2007, 2009-2010, 2018 Free Software
+   Copyright (C) 2001-2004, 2006-2007, 2009-2010, 2018, 2020 Free Software
    Foundation, Inc.
    Written by Bruno Haible <haible@clisp.cons.org>, 2001.
 
@@ -142,7 +142,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int unnumbered_arg_count;
-  unsigned int allocated;
   struct unnumbered_arg *unnumbered;
   bool unlikely_intentional;
   unsigned int sysdep_directives_count;
@@ -185,16 +184,17 @@ format_parse_entrails (const char *format, bool translated,
   struct spec spec;
   unsigned int numbered_arg_count;
   struct numbered_arg *numbered;
+  unsigned int allocated;
 
   spec.directives = 0;
-  numbered_arg_count = 0;
   spec.unnumbered_arg_count = 0;
-  spec.allocated = 0;
-  numbered = NULL;
   spec.unnumbered = NULL;
   spec.unlikely_intentional = false;
   spec.sysdep_directives_count = 0;
   spec.sysdep_directives = NULL;
+  numbered_arg_count = 0;
+  numbered = NULL;
+  allocated = 0;
 
   for (; *format != '\0';)
     if (*format++ == '%')
@@ -302,10 +302,10 @@ format_parse_entrails (const char *format, bool translated,
                     goto bad_format;
                   }
 
-                if (spec.allocated == numbered_arg_count)
+                if (allocated == numbered_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    numbered = (struct numbered_arg *) xrealloc (numbered, spec.allocated * sizeof (struct numbered_arg));
+                    allocated = 2 * allocated + 1;
+                    numbered = (struct numbered_arg *) xrealloc (numbered, allocated * sizeof (struct numbered_arg));
                     IF_OOM (numbered, goto bad_format;)
                   }
                 numbered[numbered_arg_count].number = width_number;
@@ -324,10 +324,10 @@ format_parse_entrails (const char *format, bool translated,
                     goto bad_format;
                   }
 
-                if (spec.allocated == spec.unnumbered_arg_count)
+                if (allocated == spec.unnumbered_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    spec.unnumbered = (struct unnumbered_arg *) xrealloc (spec.unnumbered, spec.allocated * sizeof (struct unnumbered_arg));
+                    allocated = 2 * allocated + 1;
+                    spec.unnumbered = (struct unnumbered_arg *) xrealloc (spec.unnumbered, allocated * sizeof (struct unnumbered_arg));
                     IF_OOM (spec.unnumbered, goto bad_format;)
                   }
                 spec.unnumbered[spec.unnumbered_arg_count].type = FAT_INTEGER;
@@ -388,10 +388,10 @@ format_parse_entrails (const char *format, bool translated,
                         goto bad_format;
                       }
 
-                    if (spec.allocated == numbered_arg_count)
+                    if (allocated == numbered_arg_count)
                       {
-                        spec.allocated = 2 * spec.allocated + 1;
-                        numbered = (struct numbered_arg *) xrealloc (numbered, spec.allocated * sizeof (struct numbered_arg));
+                        allocated = 2 * allocated + 1;
+                        numbered = (struct numbered_arg *) xrealloc (numbered, allocated * sizeof (struct numbered_arg));
                         IF_OOM (numbered, goto bad_format;)
                       }
                     numbered[numbered_arg_count].number = precision_number;
@@ -410,10 +410,10 @@ format_parse_entrails (const char *format, bool translated,
                         goto bad_format;
                       }
 
-                    if (spec.allocated == spec.unnumbered_arg_count)
+                    if (allocated == spec.unnumbered_arg_count)
                       {
-                        spec.allocated = 2 * spec.allocated + 1;
-                        spec.unnumbered = (struct unnumbered_arg *) xrealloc (spec.unnumbered, spec.allocated * sizeof (struct unnumbered_arg));
+                        allocated = 2 * allocated + 1;
+                        spec.unnumbered = (struct unnumbered_arg *) xrealloc (spec.unnumbered, allocated * sizeof (struct unnumbered_arg));
                         IF_OOM (spec.unnumbered, goto bad_format;)
                       }
                     spec.unnumbered[spec.unnumbered_arg_count].type = FAT_INTEGER;
@@ -731,10 +731,10 @@ format_parse_entrails (const char *format, bool translated,
                     goto bad_format;
                   }
 
-                if (spec.allocated == numbered_arg_count)
+                if (allocated == numbered_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    numbered = (struct numbered_arg *) xrealloc (numbered, spec.allocated * sizeof (struct numbered_arg));
+                    allocated = 2 * allocated + 1;
+                    numbered = (struct numbered_arg *) xrealloc (numbered, allocated * sizeof (struct numbered_arg));
                     IF_OOM (numbered, goto bad_format;)
                   }
                 numbered[numbered_arg_count].number = number;
@@ -753,10 +753,10 @@ format_parse_entrails (const char *format, bool translated,
                     goto bad_format;
                   }
 
-                if (spec.allocated == spec.unnumbered_arg_count)
+                if (allocated == spec.unnumbered_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    spec.unnumbered = (struct unnumbered_arg *) xrealloc (spec.unnumbered, spec.allocated * sizeof (struct unnumbered_arg));
+                    allocated = 2 * allocated + 1;
+                    spec.unnumbered = (struct unnumbered_arg *) xrealloc (spec.unnumbered, allocated * sizeof (struct unnumbered_arg));
                     IF_OOM (spec.unnumbered, goto bad_format;)
                   }
                 spec.unnumbered[spec.unnumbered_arg_count].type = type;
@@ -832,8 +832,8 @@ format_parse_entrails (const char *format, bool translated,
       /* So now the numbered arguments array is equivalent to a sequence
          of unnumbered arguments.  */
       spec.unnumbered_arg_count = numbered_arg_count;
-      spec.allocated = spec.unnumbered_arg_count;
-      spec.unnumbered = XNMALLOC (spec.allocated, struct unnumbered_arg);
+      allocated = spec.unnumbered_arg_count;
+      spec.unnumbered = XNMALLOC (allocated, struct unnumbered_arg);
       IF_OOM (spec.unnumbered, goto bad_format;)
       for (i = 0; i < spec.unnumbered_arg_count; i++)
         spec.unnumbered[i].type = numbered[i].type;

diff --git a/gettext-tools/src/format-elisp.c b/gettext-tools/src/format-elisp.c
index f820a2a71a69568b0a9ab82760235e07c73b6362..346c7f6635b6384ccbc56dd52dae92e88e237ac5 100644 (file)
--- a/gettext-tools/src/format-elisp.c
+++ b/gettext-tools/src/format-elisp.c
@@ -1,5 +1,5 @@
 /* Emacs Lisp format strings.
-   Copyright (C) 2001-2004, 2006-2007, 2009, 2019 Free Software Foundation, Inc.
+   Copyright (C) 2001-2004, 2006-2007, 2009, 2019-2020 Free Software Foundation, Inc.
    Written by Bruno Haible <haible@clisp.cons.org>, 2002.
 
    This program is free software: you can redistribute it and/or modify
@@ -73,7 +73,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
   struct numbered_arg *numbered;
 };
 
@@ -99,13 +98,14 @@ format_parse (const char *format, bool translated, char *fdi,
 {
   const char *const format_start = format;
   struct spec spec;
+  unsigned int numbered_allocated;
   struct spec *result;
   unsigned int number;
 
   spec.directives = 0;
   spec.numbered_arg_count = 0;
-  spec.allocated = 0;
   spec.numbered = NULL;
+  numbered_allocated = 0;
   number = 1;
 
   for (; *format != '\0';)
@@ -146,10 +146,10 @@ format_parse (const char *format, bool translated, char *fdi,
           {
             format++;
 
-            if (spec.allocated == spec.numbered_arg_count)
+            if (numbered_allocated == spec.numbered_arg_count)
               {
-                spec.allocated = 2 * spec.allocated + 1;
-                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                numbered_allocated = 2 * numbered_allocated + 1;
+                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
               }
             spec.numbered[spec.numbered_arg_count].number = number;
             spec.numbered[spec.numbered_arg_count].type = FAT_INTEGER;
@@ -171,10 +171,10 @@ format_parse (const char *format, bool translated, char *fdi,
               {
                 format++;
 
-                if (spec.allocated == spec.numbered_arg_count)
+                if (numbered_allocated == spec.numbered_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                    numbered_allocated = 2 * numbered_allocated + 1;
+                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                   }
                 spec.numbered[spec.numbered_arg_count].number = number;
                 spec.numbered[spec.numbered_arg_count].type = FAT_INTEGER;
@@ -225,10 +225,10 @@ format_parse (const char *format, bool translated, char *fdi,
 
         if (type != FAT_NONE)
           {
-            if (spec.allocated == spec.numbered_arg_count)
+            if (numbered_allocated == spec.numbered_arg_count)
               {
-                spec.allocated = 2 * spec.allocated + 1;
-                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                numbered_allocated = 2 * numbered_allocated + 1;
+                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
               }
             spec.numbered[spec.numbered_arg_count].number = number;
             spec.numbered[spec.numbered_arg_count].type = type;

diff --git a/gettext-tools/src/format-gcc-internal.c b/gettext-tools/src/format-gcc-internal.c
index 5eafedca71e773a9421c7fad68f9ced1596a1d79..18325cc81a42908b09504b7473bd0e92c37b6591 100644 (file)
--- a/gettext-tools/src/format-gcc-internal.c
+++ b/gettext-tools/src/format-gcc-internal.c
@@ -1,5 +1,5 @@
 /* GCC internal format strings.
-   Copyright (C) 2003-2009, 2019 Free Software Foundation, Inc.
+   Copyright (C) 2003-2009, 2019-2020 Free Software Foundation, Inc.
    Written by Bruno Haible <bruno@clisp.org>, 2003.
 
    This program is free software: you can redistribute it and/or modify
@@ -136,7 +136,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
   struct numbered_arg *numbered;
   bool uses_err_no;
 };
@@ -163,14 +162,15 @@ format_parse (const char *format, bool translated, char *fdi,
 {
   const char *const format_start = format;
   struct spec spec;
+  unsigned int numbered_allocated;
   unsigned int unnumbered_arg_count;
   struct spec *result;
 
   spec.directives = 0;
   spec.numbered_arg_count = 0;
-  spec.allocated = 0;
   spec.numbered = NULL;
   spec.uses_err_no = false;
+  numbered_allocated = 0;
   unnumbered_arg_count = 0;
 
   for (; *format != '\0';)
@@ -352,10 +352,10 @@ format_parse (const char *format, bool translated, char *fdi,
                             goto bad_format;
                           }
 
-                        if (spec.allocated == spec.numbered_arg_count)
+                        if (numbered_allocated == spec.numbered_arg_count)
                           {
-                            spec.allocated = 2 * spec.allocated + 1;
-                            spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                            numbered_allocated = 2 * numbered_allocated + 1;
+                            spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                           }
                         spec.numbered[spec.numbered_arg_count].number = precision_number;
                         spec.numbered[spec.numbered_arg_count].type = FAT_INTEGER;
@@ -373,10 +373,10 @@ format_parse (const char *format, bool translated, char *fdi,
                             goto bad_format;
                           }
 
-                        if (spec.allocated == unnumbered_arg_count)
+                        if (numbered_allocated == unnumbered_arg_count)
                           {
-                            spec.allocated = 2 * spec.allocated + 1;
-                            spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                            numbered_allocated = 2 * numbered_allocated + 1;
+                            spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                           }
                         spec.numbered[unnumbered_arg_count].number = unnumbered_arg_count + 1;
                         spec.numbered[unnumbered_arg_count].type = FAT_INTEGER;
@@ -481,10 +481,10 @@ format_parse (const char *format, bool translated, char *fdi,
                     goto bad_format;
                   }
 
-                if (spec.allocated == spec.numbered_arg_count)
+                if (numbered_allocated == spec.numbered_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                    numbered_allocated = 2 * numbered_allocated + 1;
+                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                   }
                 spec.numbered[spec.numbered_arg_count].number = number;
                 spec.numbered[spec.numbered_arg_count].type = type;
@@ -502,10 +502,10 @@ format_parse (const char *format, bool translated, char *fdi,
                     goto bad_format;
                   }
 
-                if (spec.allocated == unnumbered_arg_count)
+                if (numbered_allocated == unnumbered_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                    numbered_allocated = 2 * numbered_allocated + 1;
+                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                   }
                 spec.numbered[unnumbered_arg_count].number = unnumbered_arg_count + 1;
                 spec.numbered[unnumbered_arg_count].type = type;

diff --git a/gettext-tools/src/format-gfc-internal.c b/gettext-tools/src/format-gfc-internal.c
index d2f885af5ebd93f836ca73890d4fa328d599e9bb..bd4cb94ed0eeb270bc8551d6c40ed120635ea49f 100644 (file)
--- a/gettext-tools/src/format-gfc-internal.c
+++ b/gettext-tools/src/format-gfc-internal.c
@@ -1,5 +1,5 @@
 /* GFC (GNU Fortran Compiler) internal format strings.
-   Copyright (C) 2003-2009, 2019 Free Software Foundation, Inc.
+   Copyright (C) 2003-2009, 2019-2020 Free Software Foundation, Inc.
    Written by Bruno Haible <bruno@clisp.org>, 2009.
 
    This program is free software: you can redistribute it and/or modify
@@ -123,14 +123,14 @@ format_parse (const char *format, bool translated, char *fdi,
   const char *const format_start = format;
   struct spec spec;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
+  unsigned int numbered_allocated;
   struct numbered_arg *numbered;
   struct spec *result;
   unsigned int number;
 
   spec.directives = 0;
   numbered_arg_count = 0;
-  allocated = 0;
+  numbered_allocated = 0;
   numbered = NULL;
   spec.uses_currentloc = false;
   number = 1;
@@ -213,10 +213,10 @@ format_parse (const char *format, bool translated, char *fdi,
                   }
               }
 
-            if (allocated == numbered_arg_count)
+            if (numbered_allocated == numbered_arg_count)
               {
-                allocated = 2 * allocated + 1;
-                numbered = (struct numbered_arg *) xrealloc (numbered, allocated * sizeof (struct numbered_arg));
+                numbered_allocated = 2 * numbered_allocated + 1;
+                numbered = (struct numbered_arg *) xrealloc (numbered, numbered_allocated * sizeof (struct numbered_arg));
               }
             numbered[numbered_arg_count].number = number;
             numbered[numbered_arg_count].type = type;

diff --git a/gettext-tools/src/format-java-printf.c b/gettext-tools/src/format-java-printf.c
index d0f133c1aa30a0176aad52d0d4838c007183e2de..64452f8a331cb2968dc14362b3425c1e4cd2f8c9 100644 (file)
--- a/gettext-tools/src/format-java-printf.c
+++ b/gettext-tools/src/format-java-printf.c
@@ -1,5 +1,5 @@
 /* Java printf format strings.
-   Copyright (C) 2001-2004, 2006-2007, 2009-2010, 2018-2019 Free Software
+   Copyright (C) 2001-2004, 2006-2007, 2009-2010, 2018-2020 Free Software
    Foundation, Inc.
    Written by Bruno Haible <haible@clisp.cons.org>, 2001.
 
@@ -116,7 +116,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
   struct numbered_arg *numbered;
 };
 
@@ -162,14 +161,15 @@ format_parse (const char *format, bool translated, char *fdi,
 {
   const char *const format_start = format;
   struct spec spec;
+  unsigned int numbered_allocated;
   struct spec *result;
   unsigned int unnumbered_arg_count;
   unsigned int last_arg_number;
 
   spec.directives = 0;
   spec.numbered_arg_count = 0;
-  spec.allocated = 0;
   spec.numbered = NULL;
+  numbered_allocated = 0;
   unnumbered_arg_count = 0;
   last_arg_number = 0;
 
@@ -457,10 +457,10 @@ format_parse (const char *format, bool translated, char *fdi,
             if (number == 0)
               number = ++unnumbered_arg_count;
 
-            if (spec.allocated == spec.numbered_arg_count)
+            if (numbered_allocated == spec.numbered_arg_count)
               {
-                spec.allocated = 2 * spec.allocated + 1;
-                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                numbered_allocated = 2 * numbered_allocated + 1;
+                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
               }
             spec.numbered[spec.numbered_arg_count].number = number;
             spec.numbered[spec.numbered_arg_count].type = type;

diff --git a/gettext-tools/src/format-javascript.c b/gettext-tools/src/format-javascript.c
index 273d1cc5ff663195cfc11d092db240d856adcaff..c359c24755057ae7c7d540db37f26b00730c5437 100644 (file)
--- a/gettext-tools/src/format-javascript.c
+++ b/gettext-tools/src/format-javascript.c
@@ -1,5 +1,5 @@
 /* JavaScript format strings.
-   Copyright (C) 2001-2004, 2006-2010, 2013, 2016, 2019 Free Software Foundation, Inc.
+   Copyright (C) 2001-2004, 2006-2010, 2013, 2016, 2019-2020 Free Software Foundation, Inc.
    Written by Andreas Stricker <andy@knitter.ch>, 2010.
    It's based on python format module from Bruno Haible.
 
@@ -74,7 +74,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
   struct numbered_arg *numbered;
 };
 
@@ -100,13 +99,14 @@ format_parse (const char *format, bool translated, char *fdi,
 {
   const char *const format_start = format;
   struct spec spec;
+  unsigned int numbered_allocated;
   unsigned int unnumbered_arg_count;
   struct spec *result;
 
   spec.directives = 0;
   spec.numbered_arg_count = 0;
-  spec.allocated = 0;
   spec.numbered = NULL;
+  numbered_allocated = 0;
   unnumbered_arg_count = 0;
 
   for (; *format != '\0';)
@@ -210,10 +210,10 @@ format_parse (const char *format, bool translated, char *fdi,
                     goto bad_format;
                   }
 
-                if (spec.allocated == spec.numbered_arg_count)
+                if (numbered_allocated == spec.numbered_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                    numbered_allocated = 2 * numbered_allocated + 1;
+                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                   }
                 spec.numbered[spec.numbered_arg_count].number = number;
                 spec.numbered[spec.numbered_arg_count].type = type;
@@ -231,10 +231,10 @@ format_parse (const char *format, bool translated, char *fdi,
                     goto bad_format;
                   }
 
-                if (spec.allocated == unnumbered_arg_count)
+                if (numbered_allocated == unnumbered_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                    numbered_allocated = 2 * numbered_allocated + 1;
+                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                   }
                 spec.numbered[unnumbered_arg_count].number = unnumbered_arg_count + 1;
                 spec.numbered[unnumbered_arg_count].type = type;

diff --git a/gettext-tools/src/format-kde.c b/gettext-tools/src/format-kde.c
index 578c9a483f42d483fe2c53de3e6ba4eb1aa7173e..b8ad4f26cb604402ac0495a6fd5ae5655976a282 100644 (file)
--- a/gettext-tools/src/format-kde.c
+++ b/gettext-tools/src/format-kde.c
@@ -1,5 +1,5 @@
 /* KDE format strings.
-   Copyright (C) 2003-2004, 2006-2007, 2009, 2019 Free Software Foundation, Inc.
+   Copyright (C) 2003-2004, 2006-2007, 2009, 2019-2020 Free Software Foundation, Inc.
    Written by Bruno Haible <bruno@clisp.org>, 2007.
 
    This program is free software: you can redistribute it and/or modify
@@ -54,7 +54,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
   struct numbered_arg *numbered;
 };
 
@@ -74,12 +73,13 @@ format_parse (const char *format, bool translated, char *fdi,
 {
   const char *const format_start = format;
   struct spec spec;
+  unsigned int numbered_allocated;
   struct spec *result;
 
   spec.directives = 0;
   spec.numbered_arg_count = 0;
-  spec.allocated = 0;
   spec.numbered = NULL;
+  numbered_allocated = 0;
 
   for (; *format != '\0';)
     if (*format++ == '%')
@@ -101,10 +101,10 @@ format_parse (const char *format, bool translated, char *fdi,
                 format++;
               }
 
-            if (spec.allocated == spec.numbered_arg_count)
+            if (numbered_allocated == spec.numbered_arg_count)
               {
-                spec.allocated = 2 * spec.allocated + 1;
-                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                numbered_allocated = 2 * numbered_allocated + 1;
+                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
               }
             spec.numbered[spec.numbered_arg_count].number = number;
             spec.numbered_arg_count++;

diff --git a/gettext-tools/src/format-librep.c b/gettext-tools/src/format-librep.c
index ecfa06440d3f9e116b87b17516db098b93d201fb..ed2cb39c04cd7ff6a7bd56b1555a28be62b5951e 100644 (file)
--- a/gettext-tools/src/format-librep.c
+++ b/gettext-tools/src/format-librep.c
@@ -1,5 +1,5 @@
 /* librep format strings.
-   Copyright (C) 2001-2004, 2006-2007, 2009, 2019 Free Software Foundation, Inc.
+   Copyright (C) 2001-2004, 2006-2007, 2009, 2019-2020 Free Software Foundation, Inc.
    Written by Bruno Haible <haible@clisp.cons.org>, 2001.
 
    This program is free software: you can redistribute it and/or modify
@@ -70,7 +70,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
   struct numbered_arg *numbered;
 };
 
@@ -96,13 +95,14 @@ format_parse (const char *format, bool translated, char *fdi,
 {
   const char *const format_start = format;
   struct spec spec;
+  unsigned int numbered_allocated;
   struct spec *result;
   unsigned int number;
 
   spec.directives = 0;
   spec.numbered_arg_count = 0;
-  spec.allocated = 0;
   spec.numbered = NULL;
+  numbered_allocated = 0;
   number = 1;
 
   for (; *format != '\0';)
@@ -189,10 +189,10 @@ format_parse (const char *format, bool translated, char *fdi,
 
         if (type != FAT_NONE)
           {
-            if (spec.allocated == spec.numbered_arg_count)
+            if (numbered_allocated == spec.numbered_arg_count)
               {
-                spec.allocated = 2 * spec.allocated + 1;
-                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                numbered_allocated = 2 * numbered_allocated + 1;
+                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
               }
             spec.numbered[spec.numbered_arg_count].number = number;
             spec.numbered[spec.numbered_arg_count].type = type;

diff --git a/gettext-tools/src/format-lua.c b/gettext-tools/src/format-lua.c
index ff4fc641e0d94e3fcb7a82ca33121389d8b06586..ffd68c7f629d56fa9ce961073da70f15c78cfedf 100644 (file)
--- a/gettext-tools/src/format-lua.c
+++ b/gettext-tools/src/format-lua.c
@@ -1,5 +1,5 @@
 /* Lua format strings.
-   Copyright (C) 2012-2013, 2018-2019 Free Software Foundation, Inc.
+   Copyright (C) 2012-2013, 2018-2020 Free Software Foundation, Inc.
    Written by Ľubomír Remák <lubomirr@lubomirr.eu>, 2012.
 
    This program is free software: you can redistribute it and/or modify
@@ -69,7 +69,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int format_args_count;
-  unsigned int allocated;
   enum format_arg_type *format_args;
 };
 
@@ -89,12 +88,13 @@ format_parse (const char *format, bool translated, char *fdi,
   const char *format_start = format;
   const char *fatstr = format;
   struct spec *result = NULL;
+  unsigned int format_args_allocated;
+
   result = XMALLOC (struct spec);
   result->directives = 0;
-  result->allocated = 0;
   result->format_args_count = 0;
   result->format_args = NULL;
-
+  format_args_allocated = 0;
 
   for (; *fatstr != '\0';)
     {
@@ -165,12 +165,12 @@ format_parse (const char *format, bool translated, char *fdi,
                   goto fmt_error;
                 }
 
-              if (result->format_args_count == result->allocated)
+              if (result->format_args_count == format_args_allocated)
                 {
-                  result->allocated = 2 * result->allocated + 10;
+                  format_args_allocated = 2 * format_args_allocated + 10;
                   result->format_args =
                     xrealloc (result->format_args,
-                              result->allocated *
+                              format_args_allocated *
                               sizeof (enum format_arg_type));
                 }
               result->format_args[result->format_args_count++] = type;

diff --git a/gettext-tools/src/format-pascal.c b/gettext-tools/src/format-pascal.c
index 089d9dcbdb94184f9f8561e51d7e81eac2f6cfd2..a217afa1ff99dd99abeabd52d2fd72c1a5fde7db 100644 (file)
--- a/gettext-tools/src/format-pascal.c
+++ b/gettext-tools/src/format-pascal.c
@@ -1,5 +1,5 @@
 /* Object Pascal format strings.
-   Copyright (C) 2001-2004, 2006-2007, 2009-2010, 2018-2019 Free Software
+   Copyright (C) 2001-2004, 2006-2007, 2009-2010, 2018-2020 Free Software
    Foundation, Inc.
    Written by Bruno Haible <haible@clisp.cons.org>, 2001.
 
@@ -85,7 +85,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
   struct numbered_arg *numbered;
 };
 
@@ -112,8 +111,8 @@ format_parse (const char *format, bool translated, char *fdi,
   const char *const format_start = format;
   unsigned int directives;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
   struct numbered_arg *numbered;
+  unsigned int numbered_allocated;
   unsigned int unnumbered_arg_count;
   struct spec *result;
 
@@ -126,8 +125,8 @@ format_parse (const char *format, bool translated, char *fdi,
 
   directives = 0;
   numbered_arg_count = 0;
-  allocated = 0;
   numbered = NULL;
+  numbered_allocated = 0;
   unnumbered_arg_count = 0;
 
   for (; *format != '\0';)
@@ -185,10 +184,10 @@ format_parse (const char *format, bool translated, char *fdi,
             else if (*format == '*')
               {
                 /* Unnumbered argument of type FAT_INTEGER.   */
-                if (allocated == numbered_arg_count)
+                if (numbered_allocated == numbered_arg_count)
                   {
-                    allocated = 2 * allocated + 1;
-                    numbered = (struct numbered_arg *) xrealloc (numbered, allocated * sizeof (struct numbered_arg));
+                    numbered_allocated = 2 * numbered_allocated + 1;
+                    numbered = (struct numbered_arg *) xrealloc (numbered, numbered_allocated * sizeof (struct numbered_arg));
                   }
                 numbered[numbered_arg_count].number = unnumbered_arg_count;
                 numbered[numbered_arg_count].type = FAT_INTEGER;
@@ -212,10 +211,10 @@ format_parse (const char *format, bool translated, char *fdi,
                 else if (*format == '*')
                   {
                     /* Unnumbered argument of type FAT_INTEGER.   */
-                    if (allocated == unnumbered_arg_count)
+                    if (numbered_allocated == unnumbered_arg_count)
                       {
-                        allocated = 2 * allocated + 1;
-                        numbered = (struct numbered_arg *) xrealloc (numbered, allocated * sizeof (struct numbered_arg));
+                        numbered_allocated = 2 * numbered_allocated + 1;
+                        numbered = (struct numbered_arg *) xrealloc (numbered, numbered_allocated * sizeof (struct numbered_arg));
                       }
                     numbered[numbered_arg_count].number = unnumbered_arg_count;
                     numbered[numbered_arg_count].type = FAT_INTEGER;
@@ -257,10 +256,10 @@ format_parse (const char *format, bool translated, char *fdi,
                 goto bad_format;
               }
 
-            if (allocated == numbered_arg_count)
+            if (numbered_allocated == numbered_arg_count)
               {
-                allocated = 2 * allocated + 1;
-                numbered = (struct numbered_arg *) xrealloc (numbered, allocated * sizeof (struct numbered_arg));
+                numbered_allocated = 2 * numbered_allocated + 1;
+                numbered = (struct numbered_arg *) xrealloc (numbered, numbered_allocated * sizeof (struct numbered_arg));
               }
             switch (main_arg)
               {
@@ -339,7 +338,6 @@ format_parse (const char *format, bool translated, char *fdi,
   result = XMALLOC (struct spec);
   result->directives = directives;
   result->numbered_arg_count = numbered_arg_count;
-  result->allocated = allocated;
   result->numbered = numbered;
   return result;
 

diff --git a/gettext-tools/src/format-perl-brace.c b/gettext-tools/src/format-perl-brace.c
index 30ad945c5cfee0a19403e133220ba3e1d2b6b4f8..3e3b9d6bd6385e5d25285472909c7cad4482e6d9 100644 (file)
--- a/gettext-tools/src/format-perl-brace.c
+++ b/gettext-tools/src/format-perl-brace.c
@@ -1,5 +1,5 @@
 /* Perl brace format strings.
-   Copyright (C) 2004, 2006-2007, 2009, 2019 Free Software Foundation, Inc.
+   Copyright (C) 2004, 2006-2007, 2009, 2019-2020 Free Software Foundation, Inc.
    Written by Bruno Haible <bruno@clisp.org>, 2003.
 
    This program is free software: you can redistribute it and/or modify
@@ -46,7 +46,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int named_arg_count;
-  unsigned int allocated;
   struct named_arg *named;
 };
 
@@ -64,12 +63,13 @@ format_parse (const char *format, bool translated, char *fdi,
 {
   const char *const format_start = format;
   struct spec spec;
+  unsigned int named_allocated;
   struct spec *result;
 
   spec.directives = 0;
   spec.named_arg_count = 0;
-  spec.allocated = 0;
   spec.named = NULL;
+  named_allocated = 0;
 
   for (; *format != '\0';)
     if (*format++ == '{')
@@ -100,10 +100,10 @@ format_parse (const char *format, bool translated, char *fdi,
 
                 spec.directives++;
 
-                if (spec.allocated == spec.named_arg_count)
+                if (named_allocated == spec.named_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    spec.named = (struct named_arg *) xrealloc (spec.named, spec.allocated * sizeof (struct named_arg));
+                    named_allocated = 2 * named_allocated + 1;
+                    spec.named = (struct named_arg *) xrealloc (spec.named, named_allocated * sizeof (struct named_arg));
                   }
                 spec.named[spec.named_arg_count].name = name;
                 spec.named_arg_count++;

diff --git a/gettext-tools/src/format-perl.c b/gettext-tools/src/format-perl.c
index 35ef445a3a48bba5544ef57d1a39de4991dfd523..10bc82e4a102d3ad3612082336a0c6f8e86fdbc4 100644 (file)
--- a/gettext-tools/src/format-perl.c
+++ b/gettext-tools/src/format-perl.c
@@ -1,5 +1,5 @@
 /* Perl format strings.
-   Copyright (C) 2004, 2006-2007, 2009, 2019 Free Software Foundation, Inc.
+   Copyright (C) 2004, 2006-2007, 2009, 2019-2020 Free Software Foundation, Inc.
    Written by Bruno Haible <bruno@clisp.org>, 2003.
 
    This program is free software: you can redistribute it and/or modify
@@ -109,7 +109,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
   struct numbered_arg *numbered;
 };
 
@@ -139,16 +138,16 @@ format_parse (const char *format, bool translated, char *fdi,
   const char *const format_start = format;
   unsigned int directives;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
   struct numbered_arg *numbered;
+  unsigned int numbered_allocated;
   unsigned int unnumbered_arg_count;
   struct spec *result;
 
   directives = 0;
   numbered_arg_count = 0;
-  unnumbered_arg_count = 0;
-  allocated = 0;
   numbered = NULL;
+  numbered_allocated = 0;
+  unnumbered_arg_count = 0;
 
   for (; *format != '\0';)
     if (*format++ == '%')
@@ -203,10 +202,10 @@ format_parse (const char *format, bool translated, char *fdi,
                 vectorize = true;
 
                 /* Unnumbered argument.  */
-                if (allocated == numbered_arg_count)
+                if (numbered_allocated == numbered_arg_count)
                   {
-                    allocated = 2 * allocated + 1;
-                    numbered = (struct numbered_arg *) xrealloc (numbered, allocated * sizeof (struct numbered_arg));
+                    numbered_allocated = 2 * numbered_allocated + 1;
+                    numbered = (struct numbered_arg *) xrealloc (numbered, numbered_allocated * sizeof (struct numbered_arg));
                   }
                 numbered[numbered_arg_count].number = ++unnumbered_arg_count;
                 numbered[numbered_arg_count].type = FAT_SCALAR_VECTOR; /* or FAT_STRING? */
@@ -236,10 +235,10 @@ format_parse (const char *format, bool translated, char *fdi,
                         /* Numbered argument.  */
                         /* Note: As of perl-5.8.0, this is not correctly
                            implemented in perl's sv.c.  */
-                        if (allocated == numbered_arg_count)
+                        if (numbered_allocated == numbered_arg_count)
                           {
-                            allocated = 2 * allocated + 1;
-                            numbered = (struct numbered_arg *) xrealloc (numbered, allocated * sizeof (struct numbered_arg));
+                            numbered_allocated = 2 * numbered_allocated + 1;
+                            numbered = (struct numbered_arg *) xrealloc (numbered, numbered_allocated * sizeof (struct numbered_arg));
                           }
                         numbered[numbered_arg_count].number = vector_number;
                         numbered[numbered_arg_count].type = FAT_SCALAR_VECTOR; /* or FAT_STRING? */
@@ -252,10 +251,10 @@ format_parse (const char *format, bool translated, char *fdi,
         if (vectorize)
           {
             /* Numbered or unnumbered argument.  */
-            if (allocated == numbered_arg_count)
+            if (numbered_allocated == numbered_arg_count)
               {
-                allocated = 2 * allocated + 1;
-                numbered = (struct numbered_arg *) xrealloc (numbered, allocated * sizeof (struct numbered_arg));
+                numbered_allocated = 2 * numbered_allocated + 1;
+                numbered = (struct numbered_arg *) xrealloc (numbered, numbered_allocated * sizeof (struct numbered_arg));
               }
             numbered[numbered_arg_count].number = (number ? number : ++unnumbered_arg_count);
             numbered[numbered_arg_count].type = FAT_SCALAR_VECTOR;
@@ -291,10 +290,10 @@ format_parse (const char *format, bool translated, char *fdi,
             /* Numbered or unnumbered argument.  */
             /* Note: As of perl-5.8.0, this is not correctly
                implemented in perl's sv.c.  */
-            if (allocated == numbered_arg_count)
+            if (numbered_allocated == numbered_arg_count)
               {
-                allocated = 2 * allocated + 1;
-                numbered = (struct numbered_arg *) xrealloc (numbered, allocated * sizeof (struct numbered_arg));
+                numbered_allocated = 2 * numbered_allocated + 1;
+                numbered = (struct numbered_arg *) xrealloc (numbered, numbered_allocated * sizeof (struct numbered_arg));
               }
             numbered[numbered_arg_count].number = (width_number ? width_number : ++unnumbered_arg_count);
             numbered[numbered_arg_count].type = FAT_INTEGER;
@@ -336,10 +335,10 @@ format_parse (const char *format, bool translated, char *fdi,
                   }
 
                 /* Numbered or unnumbered argument.  */
-                if (allocated == numbered_arg_count)
+                if (numbered_allocated == numbered_arg_count)
                   {
-                    allocated = 2 * allocated + 1;
-                    numbered = (struct numbered_arg *) xrealloc (numbered, allocated * sizeof (struct numbered_arg));
+                    numbered_allocated = 2 * numbered_allocated + 1;
+                    numbered = (struct numbered_arg *) xrealloc (numbered, numbered_allocated * sizeof (struct numbered_arg));
                   }
                 numbered[numbered_arg_count].number = (precision_number ? precision_number : ++unnumbered_arg_count);
                 numbered[numbered_arg_count].type = FAT_INTEGER;
@@ -460,10 +459,10 @@ format_parse (const char *format, bool translated, char *fdi,
         if (type != FAT_NONE && !vectorize)
           {
             /* Numbered or unnumbered argument.  */
-            if (allocated == numbered_arg_count)
+            if (numbered_allocated == numbered_arg_count)
               {
-                allocated = 2 * allocated + 1;
-                numbered = (struct numbered_arg *) xrealloc (numbered, allocated * sizeof (struct numbered_arg));
+                numbered_allocated = 2 * numbered_allocated + 1;
+                numbered = (struct numbered_arg *) xrealloc (numbered, numbered_allocated * sizeof (struct numbered_arg));
               }
             numbered[numbered_arg_count].number = (number ? number : ++unnumbered_arg_count);
             numbered[numbered_arg_count].type = type;
@@ -525,7 +524,6 @@ format_parse (const char *format, bool translated, char *fdi,
   result = XMALLOC (struct spec);
   result->directives = directives;
   result->numbered_arg_count = numbered_arg_count;
-  result->allocated = allocated;
   result->numbered = numbered;
   return result;
 

diff --git a/gettext-tools/src/format-php.c b/gettext-tools/src/format-php.c
index dd9e23d1a8556278a6c41b7d33f4b0a28e641deb..6c07d2c2c719a63b8e45655b2d008083b9da7528 100644 (file)
--- a/gettext-tools/src/format-php.c
+++ b/gettext-tools/src/format-php.c
@@ -1,5 +1,5 @@
 /* PHP format strings.
-   Copyright (C) 2001-2004, 2006-2007, 2009, 2019 Free Software Foundation, Inc.
+   Copyright (C) 2001-2004, 2006-2007, 2009, 2019-2020 Free Software Foundation, Inc.
    Written by Bruno Haible <bruno@clisp.org>, 2002.
 
    This program is free software: you can redistribute it and/or modify
@@ -72,7 +72,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
   struct numbered_arg *numbered;
 };
 
@@ -99,15 +98,15 @@ format_parse (const char *format, bool translated, char *fdi,
   const char *const format_start = format;
   unsigned int directives;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
   struct numbered_arg *numbered;
+  unsigned int numbered_allocated;
   unsigned int unnumbered_arg_count;
   struct spec *result;
 
   directives = 0;
   numbered_arg_count = 0;
-  allocated = 0;
   numbered = NULL;
+  numbered_allocated = 0;
   unnumbered_arg_count = 0;
 
   for (; *format != '\0';)
@@ -226,10 +225,10 @@ format_parse (const char *format, bool translated, char *fdi,
                 goto bad_format;
               }
 
-            if (allocated == numbered_arg_count)
+            if (numbered_allocated == numbered_arg_count)
               {
-                allocated = 2 * allocated + 1;
-                numbered = (struct numbered_arg *) xrealloc (numbered, allocated * sizeof (struct numbered_arg));
+                numbered_allocated = 2 * numbered_allocated + 1;
+                numbered = (struct numbered_arg *) xrealloc (numbered, numbered_allocated * sizeof (struct numbered_arg));
               }
             numbered[numbered_arg_count].number = number;
             numbered[numbered_arg_count].type = type;
@@ -291,7 +290,6 @@ format_parse (const char *format, bool translated, char *fdi,
   result = XMALLOC (struct spec);
   result->directives = directives;
   result->numbered_arg_count = numbered_arg_count;
-  result->allocated = allocated;
   result->numbered = numbered;
   return result;
 

diff --git a/gettext-tools/src/format-python.c b/gettext-tools/src/format-python.c
index 63764ab6b804cfc2a0a8aee54073337187c93e94..e1499ea7e82d62a916941429028a1904a8e03b4b 100644 (file)
--- a/gettext-tools/src/format-python.c
+++ b/gettext-tools/src/format-python.c
@@ -1,5 +1,5 @@
 /* Python format strings.
-   Copyright (C) 2001-2004, 2006-2009, 2019 Free Software Foundation, Inc.
+   Copyright (C) 2001-2004, 2006-2009, 2019-2020 Free Software Foundation, Inc.
    Written by Bruno Haible <haible@clisp.cons.org>, 2001.
 
    This program is free software: you can redistribute it and/or modify
@@ -92,7 +92,6 @@ struct spec
   unsigned int directives;
   unsigned int named_arg_count;
   unsigned int unnamed_arg_count;
-  unsigned int allocated;
   struct named_arg *named;
   struct unnamed_arg *unnamed;
 };
@@ -120,14 +119,15 @@ format_parse (const char *format, bool translated, char *fdi,
 {
   const char *const format_start = format;
   struct spec spec;
+  unsigned int allocated;
   struct spec *result;
 
   spec.directives = 0;
   spec.named_arg_count = 0;
   spec.unnamed_arg_count = 0;
-  spec.allocated = 0;
   spec.named = NULL;
   spec.unnamed = NULL;
+  allocated = 0;
 
   for (; *format != '\0';)
     if (*format++ == '%')
@@ -191,10 +191,10 @@ format_parse (const char *format, bool translated, char *fdi,
                 goto bad_format;
               }
 
-            if (spec.allocated == spec.unnamed_arg_count)
+            if (allocated == spec.unnamed_arg_count)
               {
-                spec.allocated = 2 * spec.allocated + 1;
-                spec.unnamed = (struct unnamed_arg *) xrealloc (spec.unnamed, spec.allocated * sizeof (struct unnamed_arg));
+                allocated = 2 * allocated + 1;
+                spec.unnamed = (struct unnamed_arg *) xrealloc (spec.unnamed, allocated * sizeof (struct unnamed_arg));
               }
             spec.unnamed[spec.unnamed_arg_count].type = FAT_INTEGER;
             spec.unnamed_arg_count++;
@@ -220,10 +220,10 @@ format_parse (const char *format, bool translated, char *fdi,
                     goto bad_format;
                   }
 
-                if (spec.allocated == spec.unnamed_arg_count)
+                if (allocated == spec.unnamed_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    spec.unnamed = (struct unnamed_arg *) xrealloc (spec.unnamed, spec.allocated * sizeof (struct unnamed_arg));
+                    allocated = 2 * allocated + 1;
+                    spec.unnamed = (struct unnamed_arg *) xrealloc (spec.unnamed, allocated * sizeof (struct unnamed_arg));
                   }
                 spec.unnamed[spec.unnamed_arg_count].type = FAT_INTEGER;
                 spec.unnamed_arg_count++;
@@ -288,10 +288,10 @@ format_parse (const char *format, bool translated, char *fdi,
                 goto bad_format;
               }
 
-            if (spec.allocated == spec.named_arg_count)
+            if (allocated == spec.named_arg_count)
               {
-                spec.allocated = 2 * spec.allocated + 1;
-                spec.named = (struct named_arg *) xrealloc (spec.named, spec.allocated * sizeof (struct named_arg));
+                allocated = 2 * allocated + 1;
+                spec.named = (struct named_arg *) xrealloc (spec.named, allocated * sizeof (struct named_arg));
               }
             spec.named[spec.named_arg_count].name = name;
             spec.named[spec.named_arg_count].type = type;
@@ -309,10 +309,10 @@ format_parse (const char *format, bool translated, char *fdi,
                 goto bad_format;
               }
 
-            if (spec.allocated == spec.unnamed_arg_count)
+            if (allocated == spec.unnamed_arg_count)
               {
-                spec.allocated = 2 * spec.allocated + 1;
-                spec.unnamed = (struct unnamed_arg *) xrealloc (spec.unnamed, spec.allocated * sizeof (struct unnamed_arg));
+                allocated = 2 * allocated + 1;
+                spec.unnamed = (struct unnamed_arg *) xrealloc (spec.unnamed, allocated * sizeof (struct unnamed_arg));
               }
             spec.unnamed[spec.unnamed_arg_count].type = type;
             spec.unnamed_arg_count++;

diff --git a/gettext-tools/src/format-sh.c b/gettext-tools/src/format-sh.c
index 020757ad3c343d3eca549173aa8b02895350d6b1..640d3141277a7011fad7744741fc2797c8c3f20b 100644 (file)
--- a/gettext-tools/src/format-sh.c
+++ b/gettext-tools/src/format-sh.c
@@ -1,5 +1,5 @@
 /* Shell format strings.
-   Copyright (C) 2003-2004, 2006-2007, 2009, 2019 Free Software Foundation, Inc.
+   Copyright (C) 2003-2004, 2006-2007, 2009, 2019-2020 Free Software Foundation, Inc.
    Written by Bruno Haible <bruno@clisp.org>, 2003.
 
    This program is free software: you can redistribute it and/or modify
@@ -63,7 +63,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int named_arg_count;
-  unsigned int allocated;
   struct named_arg *named;
 };
 
@@ -90,12 +89,13 @@ format_parse (const char *format, bool translated, char *fdi,
 {
   const char *const format_start = format;
   struct spec spec;
+  unsigned int named_allocated;
   struct spec *result;
 
   spec.directives = 0;
   spec.named_arg_count = 0;
-  spec.allocated = 0;
   spec.named = NULL;
+  named_allocated = 0;
 
   for (; *format != '\0';)
     if (*format++ == '$')
@@ -198,10 +198,10 @@ format_parse (const char *format, bool translated, char *fdi,
           }
 
         /* Named argument.  */
-        if (spec.allocated == spec.named_arg_count)
+        if (named_allocated == spec.named_arg_count)
           {
-            spec.allocated = 2 * spec.allocated + 1;
-            spec.named = (struct named_arg *) xrealloc (spec.named, spec.allocated * sizeof (struct named_arg));
+            named_allocated = 2 * named_allocated + 1;
+            spec.named = (struct named_arg *) xrealloc (spec.named, named_allocated * sizeof (struct named_arg));
           }
         spec.named[spec.named_arg_count].name = name;
         spec.named_arg_count++;

diff --git a/gettext-tools/src/format-tcl.c b/gettext-tools/src/format-tcl.c
index 07da7fb8d7c60dd5c15bc79085df63109c7b549d..46630b2273368ec2c8534c6966abc68ddd13b403 100644 (file)
--- a/gettext-tools/src/format-tcl.c
+++ b/gettext-tools/src/format-tcl.c
@@ -1,5 +1,5 @@
 /* Tcl format strings.
-   Copyright (C) 2001-2004, 2006-2007, 2009, 2019 Free Software Foundation, Inc.
+   Copyright (C) 2001-2004, 2006-2007, 2009, 2019-2020 Free Software Foundation, Inc.
    Written by Bruno Haible <haible@clisp.cons.org>, 2002.
 
    This program is free software: you can redistribute it and/or modify
@@ -76,7 +76,6 @@ struct spec
 {
   unsigned int directives;
   unsigned int numbered_arg_count;
-  unsigned int allocated;
   struct numbered_arg *numbered;
 };
 
@@ -102,6 +101,7 @@ format_parse (const char *format, bool translated, char *fdi,
 {
   const char *const format_start = format;
   struct spec spec;
+  unsigned int numbered_allocated;
   struct spec *result;
   bool seen_numbered_arg;
   bool seen_unnumbered_arg;
@@ -109,8 +109,8 @@ format_parse (const char *format, bool translated, char *fdi,
 
   spec.directives = 0;
   spec.numbered_arg_count = 0;
-  spec.allocated = 0;
   spec.numbered = NULL;
+  numbered_allocated = 0;
   seen_numbered_arg = false;
   seen_unnumbered_arg = false;
   number = 1;
@@ -186,10 +186,10 @@ format_parse (const char *format, bool translated, char *fdi,
               {
                 format++;
 
-                if (spec.allocated == spec.numbered_arg_count)
+                if (numbered_allocated == spec.numbered_arg_count)
                   {
-                    spec.allocated = 2 * spec.allocated + 1;
-                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                    numbered_allocated = 2 * numbered_allocated + 1;
+                    spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                   }
                 spec.numbered[spec.numbered_arg_count].number = number;
                 spec.numbered[spec.numbered_arg_count].type = FAT_INTEGER;
@@ -211,10 +211,10 @@ format_parse (const char *format, bool translated, char *fdi,
                   {
                     format++;
 
-                    if (spec.allocated == spec.numbered_arg_count)
+                    if (numbered_allocated == spec.numbered_arg_count)
                       {
-                        spec.allocated = 2 * spec.allocated + 1;
-                        spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                        numbered_allocated = 2 * numbered_allocated + 1;
+                        spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
                       }
                     spec.numbered[spec.numbered_arg_count].number = number;
                     spec.numbered[spec.numbered_arg_count].type = FAT_INTEGER;
@@ -267,10 +267,10 @@ format_parse (const char *format, bool translated, char *fdi,
                 goto bad_format;
               }
 
-            if (spec.allocated == spec.numbered_arg_count)
+            if (numbered_allocated == spec.numbered_arg_count)
               {
-                spec.allocated = 2 * spec.allocated + 1;
-                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, spec.allocated * sizeof (struct numbered_arg));
+                numbered_allocated = 2 * numbered_allocated + 1;
+                spec.numbered = (struct numbered_arg *) xrealloc (spec.numbered, numbered_allocated * sizeof (struct numbered_arg));
               }
             spec.numbered[spec.numbered_arg_count].number = number;
             spec.numbered[spec.numbered_arg_count].type = type;