1 files changed, 207 insertions, 39 deletions

diff --git a/gettext-tools/src/format-javascript.c b/gettext-tools/src/format-javascript.c
index c8602c0..9c5ee00 100644
--- a/gettext-tools/src/format-javascript.c
+++ b/gettext-tools/src/format-javascript.c
@@ -34,15 +34,15 @@
 
 #define _(str) gettext (str)
 
-/* Although JavaScript specification itself does not define any format
-   strings, many implementations provide printf-like functions.
-   We provide a permissive parser which accepts commonly used format
-   strings, where:
+/* JavaScript format strings are not in the language specification,
+   but there are several implementations which provide the printf-like
+   feature.  Here, we provide a permissive parser which at least accepts
+   format strings supported by Gjs version 1.40, where:
 
    A directive
-   - starts with '%',
+   - starts with '%' or '%m$' where m is a positive integer,
    - is optionally followed by any of the characters '0', '-', ' ',
-     or, each of which acts as a flag,
+     or 'I', each of which acts as a flag,
    - is optionally followed by a width specification: a nonempty digit
      sequence,
    - is optionally followed by '.' and a precision specification: a nonempty
@@ -65,12 +65,18 @@ enum format_arg_type
   FAT_FLOAT
 };
 
+struct numbered_arg
+{
+  unsigned int number;
+  enum format_arg_type type;
+};
+
 struct spec
 {
   unsigned int directives;
-  unsigned int format_args_count;
+  unsigned int numbered_arg_count;
   unsigned int allocated;
-  enum format_arg_type *format_args;
+  struct numbered_arg *numbered;
 };
 
 /* Locale independent test for a decimal digit.
@@ -80,32 +86,71 @@ struct spec
 #define isdigit(c) ((unsigned int) ((c) - '0') < 10)
 
 
+static int
+numbered_arg_compare (const void *p1, const void *p2)
+{
+  unsigned int n1 = ((const struct numbered_arg *) p1)->number;
+  unsigned int n2 = ((const struct numbered_arg *) p2)->number;
+
+  return (n1 > n2 ? 1 : n1 < n2 ? -1 : 0);
+}
+
 static void *
 format_parse (const char *format, bool translated, char *fdi,
               char **invalid_reason)
 {
   const char *const format_start = format;
   struct spec spec;
+  unsigned int unnumbered_arg_count;
   struct spec *result;
 
   spec.directives = 0;
-  spec.format_args_count = 0;
+  spec.numbered_arg_count = 0;
   spec.allocated = 0;
-  spec.format_args = NULL;
+  spec.numbered = NULL;
+  unnumbered_arg_count = 0;
 
   for (; *format != '\0';)
     if (*format++ == '%')
       {
         /* A directive.  */
+        unsigned int number = 0;
         enum format_arg_type type;
 
         FDI_SET (format - 1, FMTDIR_START);
         spec.directives++;
 
+        if (isdigit (*format))
+          {
+            const char *f = format;
+            unsigned int m = 0;
+
+            do
+              {
+                m = 10 * m + (*f - '0');
+                f++;
+              }
+            while (isdigit (*f));
+
+            if (*f == '$')
+              {
+                if (m == 0)
+                  {
+                    *invalid_reason = INVALID_ARGNO_0 (spec.directives);
+                    FDI_SET (f, FMTDIR_ERROR);
+                    goto bad_format;
+                  }
+                number = m;
+                format = ++f;
+              }
+          }
+
+        /* Parse flags.  */
         while (*format == '-' || *format == '+' || *format == ' '
                || *format == '0' || *format == 'I')
           format++;
 
+        /* Parse width.  */
         while (isdigit (*format))
           format++;
 
@@ -152,15 +197,50 @@ format_parse (const char *format, bool translated, char *fdi,
             goto bad_format;
           }
 
-        if (*format != '%')
+        if (type != FAT_NONE)
           {
-            if (spec.allocated == spec.format_args_count)
+            if (number)
+              {
+                /* Numbered argument.  */
+
+                /* Numbered and unnumbered specifications are exclusive.  */
+                if (unnumbered_arg_count > 0)
+                  {
+                    *invalid_reason = INVALID_MIXES_NUMBERED_UNNUMBERED ();
+                    FDI_SET (format, FMTDIR_ERROR);
+                    goto bad_format;
+                  }
+
+                if (spec.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));
+                  }
+                spec.numbered[spec.numbered_arg_count].number = number;
+                spec.numbered[spec.numbered_arg_count].type = type;
+                spec.numbered_arg_count++;
+              }
+            else
               {
-                spec.allocated = 2 * spec.allocated + 1;
-                spec.format_args = (enum format_arg_type *) xrealloc (spec.format_args, spec.allocated * sizeof (enum format_arg_type));
+                /* Unnumbered argument.  */
+
+                /* Numbered and unnumbered specifications are exclusive.  */
+                if (spec.numbered_arg_count > 0)
+                  {
+                    *invalid_reason = INVALID_MIXES_NUMBERED_UNNUMBERED ();
+                    FDI_SET (format, FMTDIR_ERROR);
+                    goto bad_format;
+                  }
+
+                if (spec.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));
+                  }
+                spec.numbered[unnumbered_arg_count].number = unnumbered_arg_count + 1;
+                spec.numbered[unnumbered_arg_count].type = type;
+                unnumbered_arg_count++;
               }
-            spec.format_args[spec.format_args_count] = type;
-            spec.format_args_count++;
           }
 
         FDI_SET (format, FMTDIR_END);
@@ -168,13 +248,63 @@ format_parse (const char *format, bool translated, char *fdi,
         format++;
       }
 
+  /* Convert the unnumbered argument array to numbered arguments.  */
+  if (unnumbered_arg_count > 0)
+    spec.numbered_arg_count = unnumbered_arg_count;
+  /* Sort the numbered argument array, and eliminate duplicates.  */
+  else if (spec.numbered_arg_count > 1)
+    {
+      unsigned int i, j;
+      bool err;
+
+      qsort (spec.numbered, spec.numbered_arg_count,
+             sizeof (struct numbered_arg), numbered_arg_compare);
+
+      /* Remove duplicates: Copy from i to j, keeping 0 <= j <= i.  */
+      err = false;
+      for (i = j = 0; i < spec.numbered_arg_count; i++)
+        if (j > 0 && spec.numbered[i].number == spec.numbered[j-1].number)
+          {
+            enum format_arg_type type1 = spec.numbered[i].type;
+            enum format_arg_type type2 = spec.numbered[j-1].type;
+            enum format_arg_type type_both;
+
+            if (type1 == type2)
+              type_both = type1;
+            else
+              {
+                /* Incompatible types.  */
+                type_both = FAT_NONE;
+                if (!err)
+                  *invalid_reason =
+                    INVALID_INCOMPATIBLE_ARG_TYPES (spec.numbered[i].number);
+                err = true;
+              }
+
+            spec.numbered[j-1].type = type_both;
+          }
+        else
+          {
+            if (j < i)
+              {
+                spec.numbered[j].number = spec.numbered[i].number;
+                spec.numbered[j].type = spec.numbered[i].type;
+              }
+            j++;
+          }
+      spec.numbered_arg_count = j;
+      if (err)
+        /* *invalid_reason has already been set above.  */
+        goto bad_format;
+    }
+
   result = XMALLOC (struct spec);
   *result = spec;
   return result;
 
  bad_format:
-  if (spec.format_args != NULL)
-    free (spec.format_args);
+  if (spec.numbered != NULL)
+    free (spec.numbered);
   return NULL;
 }
 
@@ -183,8 +313,8 @@ format_free (void *descr)
 {
   struct spec *spec = (struct spec *) descr;
 
-  if (spec->format_args != NULL)
-    free (spec->format_args);
+  if (spec->numbered != NULL)
+    free (spec->numbered);
   free (spec);
 }
 
@@ -205,30 +335,68 @@ format_check (void *msgid_descr, void *msgstr_descr, bool equality,
   struct spec *spec2 = (struct spec *) msgstr_descr;
   bool err = false;
 
-  if (spec1->format_args_count + spec2->format_args_count > 0)
+  if (spec1->numbered_arg_count + spec2->numbered_arg_count > 0)
     {
-      unsigned int i;
+      unsigned int i, j;
+      unsigned int n1 = spec1->numbered_arg_count;
+      unsigned int n2 = spec2->numbered_arg_count;
 
-      /* Check the argument types are the same.  */
-      if (spec1->format_args_count != spec2->format_args_count)
+      /* Check the argument names are the same.
+         Both arrays are sorted.  We search for the first difference.  */
+      for (i = 0; i < spec2->numbered_arg_count; i++)
         {
-          if (error_logger)
-            error_logger (_("number of format specifications in '%s' and '%s' does not match"),
-                          pretty_msgid, pretty_msgstr);
-          err = true;
-        }
-      else
-        for (i = 0; i < spec2->format_args_count; i++)
-          if (!(spec1->format_args[i] == spec2->format_args[i]
-                || (!equality
-                    && (spec1->format_args[i] == FAT_ANY
-                        || spec2->format_args[i] == FAT_ANY))))
+          int cmp = (i >= n1 ? 1 :
+                     j >= n2 ? -1 :
+                     spec1->numbered[i].number > spec2->numbered[j].number ? 1 :
+                     spec1->numbered[i].number < spec2->numbered[j].number ? -1 :
+                     0);
+          if (cmp > 0)
             {
               if (error_logger)
-                error_logger (_("format specifications in '%s' and '%s' for argument %u are not the same"),
-                              pretty_msgid, pretty_msgstr, i + 1);
+                error_logger (_("a format specification for argument %u, as in '%s', doesn't exist in '%s'"),
+                              spec2->numbered[j].number, pretty_msgstr,
+                              pretty_msgid);
               err = true;
+              break;
             }
+          else if (cmp < 0)
+            {
+              if (equality)
+                {
+                  if (error_logger)
+                    error_logger (_("a format specification for argument %u doesn't exist in '%s'"),
+                                  spec1->numbered[i].number, pretty_msgstr);
+                  err = true;
+                  break;
+                }
+              else
+                i++;
+            }
+          else
+            j++, i++;
+        }
+      /* Check the argument types are the same.  */
+      if (!err)
+        for (i = 0, j = 0; j < n2; )
+          {
+            if (spec1->numbered[i].number == spec2->numbered[j].number)
+              {
+                if (!equality
+                    && (spec1->numbered[i].type == FAT_ANY
+                        || spec2->numbered[i].type == FAT_ANY))
+                  {
+                    if (error_logger)
+                      error_logger (_("format specifications in '%s' and '%s' for argument %u are not the same"),
+                                    pretty_msgid, pretty_msgstr,
+                                    spec2->numbered[j].number);
+                    err = true;
+                    break;
+                  }
+                j++, i++;
+              }
+            else
+              i++;
+          }
     }
 
   return err;
@@ -265,11 +433,11 @@ format_print (void *descr)
     }
 
       printf ("(");
-      for (i = 0; i < spec->format_args_count; i++)
+      for (i = 0; i < spec->numbered_arg_count; i++)
         {
           if (i > 0)
             printf (" ");
-          switch (spec->format_args[i])
+          switch (spec->numbered[i].type)
             {
             case FAT_ANY:
               printf ("*");