diff options
-rw-r--r-- | NEWS | 9 | ||||
-rw-r--r-- | gettext-tools/src/ChangeLog | 11 | ||||
-rw-r--r-- | gettext-tools/src/format-gcc-internal.c | 557 | ||||
-rw-r--r-- | gettext-tools/tests/ChangeLog | 5 | ||||
-rwxr-xr-x | gettext-tools/tests/format-gcc-internal-1 | 42 | ||||
-rwxr-xr-x | gettext-tools/tests/format-gcc-internal-2 | 21 |
6 files changed, 510 insertions, 135 deletions
@@ -33,7 +33,7 @@ * msggrep has a new option -X/--extracted-comment that allows to search for a pattern in the extracted comments. -* xgettext's --keyword now allows to specify an extracted comment on the +* xgettext's --keyword option now allows to specify an extracted comment on the command line, rather than in program's source code. * msgmerge is much faster now, when using a large compendium. @@ -64,7 +64,12 @@ * The 'mkinstalldirs' shell script is no longer needed and no longer installed by gettextize. -* Portability to mingw. +* Updated the meaning of 'gcc-internal-format' to match GCC 4.1. + +* Portability: + - Building on mingw is now supported. + - Building shared libraries (--enable-shared) on Cygwin and mingw is now + supported. * Interoperability with expat version 2.0.0. diff --git a/gettext-tools/src/ChangeLog b/gettext-tools/src/ChangeLog index 3ce235d..9b91fe3 100644 --- a/gettext-tools/src/ChangeLog +++ b/gettext-tools/src/ChangeLog @@ -1,3 +1,14 @@ +2006-06-20 Bruno Haible <bruno@clisp.org> + + * format-gcc-internal.c (struct unnumbered_arg): Remove type. + (struct numbered_arg): New type. + (struct spec): Use it. + (isdigit): New macro. + (numbered_arg_compare): New function. + (format_parse, format_free, format_check, format_print): Update to + GCC 4.1 internal format strings. + Reported by Göran Uddeborg <goeran@uddeborg.se>. + 2006-06-04 Bruno Haible <bruno@clisp.org> * msgl-check.c (check_plural_eval): Declare 'distribution' as volatile, diff --git a/gettext-tools/src/format-gcc-internal.c b/gettext-tools/src/format-gcc-internal.c index c3842f1..a0137e9 100644 --- a/gettext-tools/src/format-gcc-internal.c +++ b/gettext-tools/src/format-gcc-internal.c @@ -33,56 +33,62 @@ #define _(str) gettext (str) /* GCC internal format strings consist of language frontend independent - format directives, implemented in gcc-4.0.0/gcc/pretty-print.c (function - pp_base_format_text), plus some frontend dependent extensions: + format directives, implemented in gcc-4.1.0/gcc/pretty-print.c (function + pp_base_format), plus some frontend dependent extensions: - for the C/ObjC frontend - in gcc-4.0.0/gcc/c-objc-common.c (function c_tree_printer) + in gcc-4.1.0/gcc/c-objc-common.c (function c_tree_printer) - for the C++ frontend - in gcc-4.0.0/gcc/cp/error.c (function cp_printer) + in gcc-4.1.0/gcc/cp/error.c (function cp_printer) Taking these together, GCC internal format strings are specified as follows. A directive - starts with '%', - - is optionally followed by 'q', - - is optionally followed by a size specifier 'l', 'll' or 'w', - - is optionally followed by '+' (only the specifiers of gcc/cp/error.c), - - is optionally followed by '#' (only the specifiers of gcc/cp/error.c), - - is finished by a specifier - + - either is finished by one of these: - '%', '<', '>', "'", that need no argument, - 'm', that needs no argument but looks at an err_no variable, - - 'c', that needs a character argument, - - 's', that needs a string argument, - - 'i', 'd', that need a signed integer argument of the specified size, - - 'o', 'u', 'x', that need an unsigned integer argument of the specified - size, - - '.*s', that needs a signed integer argument and a string argument, - - 'p', that needs a 'void *' argument, - - 'H', that needs a 'location_t *' argument, - [see gcc/pretty-print.c] - - - 'D', that needs a general declaration argument, - - 'F', that needs a function declaration argument, - - 'T', that needs a type argument, - - 'E', that needs an expression argument, - [see gcc/c-objc-common.c and gcc/cp/error.c] - - - 'A', that needs a function argument list argument, - - 'C', that needs a tree code argument, - - 'L', that needs a language argument, - - 'O', that needs a binary operator argument, - - 'P', that needs a function parameter argument, - - 'Q', that needs an assignment operator argument, - - 'V', that needs a const/volatile qualifier argument. - [see gcc/cp/error.c] - - Furthermore, some extra directives can occur only at the beginning of a - format string. Such a directive - - starts with '%', - - is finished by a specifier - - 'J', that needs a general declaration argument. - [see gcc/pretty-print.c (function pp_base_prepare_to_format)] - */ + - or is continued like this: + - optionally 'm$' where m is a positive integer, + - optionally any number of flags: + 'q' (once only), + 'l' (up to twice) or 'w' (once only) (exclusive), + '+' (once only), + '#' (once only), + - finished by a specifier + + - 'c', that needs a character argument, + - 's', that needs a string argument, + - '.NNNs', where NNN is a nonempty digit sequence, that needs a + string argument, + - '.*NNN$s' where NNN is a positive integer and NNN = m - 1, that + needs a signed integer argument at position NNN and a string + argument, + - '.*s', that needs a signed integer argument and a string argument, + - 'i', 'd', that need a signed integer argument of the specified + size, + - 'o', 'u', 'x', that need an unsigned integer argument of the + specified size, + - 'p', that needs a 'void *' argument, + - 'H', that needs a 'location_t *' argument, + - 'J', that needs a general declaration argument, + [see gcc/pretty-print.c] + + - 'D', that needs a general declaration argument, + - 'F', that needs a function declaration argument, + - 'T', that needs a type argument, + - 'E', that needs an expression argument, + [see gcc/c-objc-common.c and gcc/cp/error.c] + + - 'A', that needs a function argument list argument, + - 'C', that needs a tree code argument, + - 'L', that needs a language argument, + - 'O', that needs a binary operator argument, + - 'P', that needs a function parameter argument, + - 'Q', that needs an assignment operator argument, + - 'V', that needs a const/volatile qualifier argument. + [see gcc/cp/error.c] + + Numbered ('%m$' or '*m$') and unnumbered argument specifications cannot + be used in the same string. */ enum format_arg_type { @@ -114,65 +120,57 @@ enum format_arg_type FAT_SIZE_MASK = (FAT_SIZE_LONG | FAT_SIZE_LONGLONG | FAT_SIZE_WIDE) }; -struct unnumbered_arg +struct numbered_arg { + unsigned int number; enum format_arg_type type; }; struct spec { unsigned int directives; - unsigned int unnumbered_arg_count; + unsigned int numbered_arg_count; unsigned int allocated; - struct unnumbered_arg *unnumbered; + struct numbered_arg *numbered; bool uses_err_no; }; +/* Locale independent test for a decimal digit. + Argument can be 'char' or 'unsigned char'. (Whereas the argument of + <ctype.h> isdigit must be an 'unsigned char'.) */ +#undef isdigit +#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 **invalid_reason) { - const char *format_start; struct spec spec; + unsigned int unnumbered_arg_count; struct spec *result; - format_start = format; - spec.directives = 0; - spec.unnumbered_arg_count = 0; + spec.numbered_arg_count = 0; spec.allocated = 0; - spec.unnumbered = NULL; + spec.numbered = NULL; spec.uses_err_no = false; + unnumbered_arg_count = 0; for (; *format != '\0';) if (*format++ == '%') { /* A directive. */ - enum format_arg_type size; - spec.directives++; - if (*format == 'q') - format++; - - /* Parse size. */ - size = 0; - if (*format == 'l') - { - format++; - size = FAT_SIZE_LONG; - if (*format == 'l') - { - format++; - size = FAT_SIZE_LONGLONG; - } - } - else if (*format == 'w') - { - format++; - size = FAT_SIZE_WIDE; - } - if (*format == '%' || *format == '<' || *format == '>' || *format == '\'') ; @@ -180,50 +178,217 @@ format_parse (const char *format, bool translated, char **invalid_reason) spec.uses_err_no = true; else { + unsigned int number = 0; + unsigned int flag_q = 0; + unsigned int flag_l = 0; + unsigned int flag_w = 0; + unsigned int flag_plus = 0; + unsigned int flag_sharp = 0; + enum format_arg_type size; enum format_arg_type type; + 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); + goto bad_format; + } + number = m; + format = ++f; + } + } + + /* Parse flags and size. */ + for (;; format++) + { + switch (*format) + { + case 'q': + if (flag_q > 0) + goto invalid_flags; + flag_q = 1; + continue; + case 'l': + if (flag_l > 1 || flag_w) + goto invalid_flags; + flag_l++; + continue; + case 'w': + if (flag_w > 0 || flag_l) + goto invalid_flags; + flag_w = 1; + continue; + case '+': + if (flag_plus > 0) + goto invalid_flags; + flag_plus = 1; + continue; + case '#': + if (flag_sharp > 0) + goto invalid_flags; + flag_sharp = 1; + continue; + invalid_flags: + *invalid_reason = xasprintf (_("In the directive number %u, the flags combination is invalid."), spec.directives); + goto bad_format; + default: + break; + } + break; + } + size = (flag_l == 2 ? FAT_SIZE_LONGLONG : + flag_l == 1 ? FAT_SIZE_LONG : + flag_w ? FAT_SIZE_WIDE : + 0); + if (*format == 'c') type = FAT_CHAR; else if (*format == 's') type = FAT_STRING; - else if (*format == 'i' || *format == 'd') - type = FAT_INTEGER | size; - else if (*format == 'o' || *format == 'u' || *format == 'x') - type = FAT_INTEGER | FAT_UNSIGNED | size; - else if (*format == '.' && format[1] == '*' && format[2] == 's') + else if (*format == '.') { - if (spec.allocated == spec.unnumbered_arg_count) + format++; + + if (isdigit (*format)) { - spec.allocated = 2 * spec.allocated + 1; - spec.unnumbered = (struct unnumbered_arg *) xrealloc (spec.unnumbered, spec.allocated * sizeof (struct unnumbered_arg)); + do + format++; + while (isdigit (*format)); + + if (*format != 's') + { + *invalid_reason = + (*format == '\0' + ? INVALID_UNTERMINATED_DIRECTIVE () + : xasprintf (_("In the directive number %u, a precision is not allowed before '%c'."), spec.directives, *format)); + goto bad_format; + } + + type = FAT_STRING; + } + else if (*format == '*') + { + unsigned int precision_number = 0; + + format++; + + 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_WIDTH_ARGNO_0 (spec.directives); + goto bad_format; + } + if (unnumbered_arg_count > 0 || number == 0) + { + *invalid_reason = INVALID_MIXES_NUMBERED_UNNUMBERED (); + goto bad_format; + } + if (m != number - 1) + { + *invalid_reason = xasprintf (_("In the directive number %u, the argument number for the precision must be equal to %u."), spec.directives, number - 1); + goto bad_format; + } + precision_number = m; + format = ++f; + } + } + + if (precision_number) + { + /* Numbered argument. */ + + /* Numbered and unnumbered specifications are exclusive. */ + if (unnumbered_arg_count > 0) + { + *invalid_reason = INVALID_MIXES_NUMBERED_UNNUMBERED (); + 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 = precision_number; + spec.numbered[spec.numbered_arg_count].type = FAT_INTEGER; + spec.numbered_arg_count++; + } + else + { + /* Unnumbered argument. */ + + /* Numbered and unnumbered specifications are exclusive. */ + if (spec.numbered_arg_count > 0) + { + *invalid_reason = INVALID_MIXES_NUMBERED_UNNUMBERED (); + goto bad_format; + } + + if (spec.allocated == unnumbered_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 = FAT_INTEGER; + unnumbered_arg_count++; + } + + if (*format == 's') + type = FAT_STRING; + else + { + *invalid_reason = + (*format == '\0' + ? INVALID_UNTERMINATED_DIRECTIVE () + : xasprintf (_("In the directive number %u, a precision is not allowed before '%c'."), spec.directives, *format)); + goto bad_format; + } + } + else + { + *invalid_reason = xasprintf (_("In the directive number %u, the precision specification is invalid."), spec.directives); + goto bad_format; } - spec.unnumbered[spec.unnumbered_arg_count].type = FAT_INTEGER; - spec.unnumbered_arg_count++; - type = FAT_STRING; } + else if (*format == 'i' || *format == 'd') + type = FAT_INTEGER | size; + else if (*format == 'o' || *format == 'u' || *format == 'x') + type = FAT_INTEGER | FAT_UNSIGNED | size; else if (*format == 'p') type = FAT_POINTER; else if (*format == 'H') type = FAT_LOCATION; else if (*format == 'J') - { - if (format - format_start == 1) - type = FAT_TREE | FAT_TREE_DECL; - else - { - *invalid_reason = - (format[-1] == '%' - ? xasprintf (_("The %%J directive is only allowed at the beginning of the string.")) - : xasprintf (_("The %%J directive does not support flags."))); - goto bad_format; - } - } + type = FAT_TREE | FAT_TREE_DECL; else { - if (*format == '+') - format++; - if (*format == '#') - format++; if (*format == 'D') type = FAT_TREE | FAT_TREE_DECL; else if (*format == 'F') @@ -263,25 +428,108 @@ format_parse (const char *format, bool translated, char **invalid_reason) } } - if (spec.allocated == spec.unnumbered_arg_count) + if (number) + { + /* Numbered argument. */ + + /* Numbered and unnumbered specifications are exclusive. */ + if (unnumbered_arg_count > 0) + { + *invalid_reason = INVALID_MIXES_NUMBERED_UNNUMBERED (); + 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.unnumbered = (struct unnumbered_arg *) xrealloc (spec.unnumbered, spec.allocated * sizeof (struct unnumbered_arg)); + /* Unnumbered argument. */ + + /* Numbered and unnumbered specifications are exclusive. */ + if (spec.numbered_arg_count > 0) + { + *invalid_reason = INVALID_MIXES_NUMBERED_UNNUMBERED (); + goto bad_format; + } + + if (spec.allocated == unnumbered_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.unnumbered[spec.unnumbered_arg_count].type = type; - spec.unnumbered_arg_count++; } 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 = (struct spec *) xmalloc (sizeof (struct spec)); *result = spec; return result; bad_format: - if (spec.unnumbered != NULL) - free (spec.unnumbered); + if (spec.numbered != NULL) + free (spec.numbered); return NULL; } @@ -290,8 +538,8 @@ format_free (void *descr) { struct spec *spec = (struct spec *) descr; - if (spec->unnumbered != NULL) - free (spec->unnumbered); + if (spec->numbered != NULL) + free (spec->numbered); free (spec); } @@ -311,27 +559,67 @@ format_check (void *msgid_descr, void *msgstr_descr, bool equality, struct spec *spec1 = (struct spec *) msgid_descr; struct spec *spec2 = (struct spec *) msgstr_descr; bool err = false; - unsigned int i; - /* Check the argument types are the same. */ - if (equality - ? spec1->unnumbered_arg_count != spec2->unnumbered_arg_count - : spec1->unnumbered_arg_count < spec2->unnumbered_arg_count) + if (spec1->numbered_arg_count + spec2->numbered_arg_count > 0) { - if (error_logger) - error_logger (_("number of format specifications in 'msgid' and '%s' does not match"), - pretty_msgstr); - err = true; - } - else - for (i = 0; i < spec2->unnumbered_arg_count; i++) - if (spec1->unnumbered[i].type != spec2->unnumbered[i].type) + unsigned int i, j; + unsigned int n1 = spec1->numbered_arg_count; + unsigned int n2 = spec2->numbered_arg_count; + + /* Check the argument names are the same. + Both arrays are sorted. We search for the first difference. */ + for (i = 0, j = 0; i < n1 || j < n2; ) { - if (error_logger) - error_logger (_("format specifications in 'msgid' and '%s' for argument %u are not the same"), - pretty_msgstr, i + 1); - err = true; + 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 (_("a format specification for argument %u, as in '%s', doesn't exist in 'msgid'"), + spec2->numbered[j].number, pretty_msgstr); + 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 (spec1->numbered[i].type != spec2->numbered[j].type) + { + if (error_logger) + error_logger (_("format specifications in 'msgid' and '%s' for argument %u are not the same"), + pretty_msgstr, spec2->numbered[j].number); + err = true; + break; + } + j++, i++; + } + else + i++; + } + } /* Check that the use of err_no is the same. */ if (spec1->uses_err_no != spec2->uses_err_no) @@ -374,6 +662,7 @@ static void format_print (void *descr) { struct spec *spec = (struct spec *) descr; + unsigned int last; unsigned int i; if (spec == NULL) @@ -383,13 +672,20 @@ format_print (void *descr) } printf ("("); - for (i = 0; i < spec->unnumbered_arg_count; i++) + last = 1; + for (i = 0; i < spec->numbered_arg_count; i++) { + unsigned int number = spec->numbered[i].number; + if (i > 0) printf (" "); - if (spec->unnumbered[i].type & FAT_UNSIGNED) + if (number < last) + abort (); + for (; last < number; last++) + printf ("_ "); + if (spec->numbered[i].type & FAT_UNSIGNED) printf ("[unsigned]"); - switch (spec->unnumbered[i].type & FAT_SIZE_MASK) + switch (spec->numbered[i].type & FAT_SIZE_MASK) { case 0: break; @@ -405,7 +701,7 @@ format_print (void *descr) default: abort (); } - switch (spec->unnumbered[i].type & ~(FAT_UNSIGNED | FAT_SIZE_MASK)) + switch (spec->numbered[i].type & ~(FAT_UNSIGNED | FAT_SIZE_MASK)) { case FAT_INTEGER: printf ("i"); @@ -458,6 +754,7 @@ format_print (void *descr) default: abort (); } + last = number + 1; } printf (")"); if (spec->uses_err_no) diff --git a/gettext-tools/tests/ChangeLog b/gettext-tools/tests/ChangeLog index 35c3a20..c129eeb 100644 --- a/gettext-tools/tests/ChangeLog +++ b/gettext-tools/tests/ChangeLog @@ -1,3 +1,8 @@ +2006-06-20 Bruno Haible <bruno@clisp.org> + + * format-gcc-internal-1: Update to GCC 4.1 internal format strings. + * format-gcc-internal-2: Likewise. + 2006-06-17 Bruno Haible <bruno@clisp.org> * recode-sr-latin-2 (LOCALE_JA_EUCJP): Determine locale name depending diff --git a/gettext-tools/tests/format-gcc-internal-1 b/gettext-tools/tests/format-gcc-internal-1 index a64074c..da055e4 100755 --- a/gettext-tools/tests/format-gcc-internal-1 +++ b/gettext-tools/tests/format-gcc-internal-1 @@ -39,9 +39,9 @@ cat <<\EOF > f-gi-1.data "abc%H" # Valid: one pointer argument "%J" -# Invalid: %J not at start +# Valid: %J not at start "abc%J" -# Invalid: %J with flags +# Valid: %J with flags "%qJ" # Valid: one pointer argument "abc%D" @@ -87,8 +87,44 @@ cat <<\EOF > f-gi-1.data "abc%.*.*s" # Valid: three arguments "abc%d%u%u" -# Invalid: a numbered argument +# Valid: a numbered argument "abc%1$d" +# Invalid: zero +"abc%0$d" +# Valid: two-digit numbered arguments +"abc%11$def%10$dgh%9$dij%8$dkl%7$dmn%6$dop%5$dqr%4$dst%3$duv%2$dwx%1$dyz" +# Invalid: unterminated number +"abc%1" +# Invalid: flags before number +"abc%+1$d" +# Valid: three arguments, two with same number +"abc%1$x,%2$c,%1$u" +# Invalid: argument with conflicting types +"abc%1$x,%2$c,%1$s" +# Valid: no conflict +"abc%1$x,%2$c,%1$u" +# Invalid: mixing of numbered and unnumbered arguments +"abc%d%2$x" +# Valid: numbered argument with constant precision +"abc%1$.9s" +# Invalid: mixing of numbered and unnumbered arguments +"abc%1$.*s" +# Valid: missing non-final argument +"abc%2$x%3$s" +# Valid: permutation +"abc%2$ddef%1$d" +# Valid: multiple uses of same argument +"abc%2$xdef%1$sghi%2$x" +# Valid: one argument with precision +"abc%2$#.*1$s" +# Invalid: non-string argument with precision +"abc%2$#.*1$d" +# Invalid: one argument with width +"abc%2$#*1$s" +# Invalid: one argument with width and precision +"abc%3$*2$.*1$s" +# Invalid: zero +"abc%1$#.*0$s" EOF : ${XGETTEXT=xgettext} diff --git a/gettext-tools/tests/format-gcc-internal-2 b/gettext-tools/tests/format-gcc-internal-2 index bf0a2d2..55725d1 100755 --- a/gettext-tools/tests/format-gcc-internal-2 +++ b/gettext-tools/tests/format-gcc-internal-2 @@ -37,12 +37,33 @@ msgstr "xyz%qs%qH" # Valid: same arguments, with different widths msgid "abc%.*sdef" msgstr "xyz%i%s" +# Valid: same arguments but in numbered syntax +msgid "abc%s%ddef" +msgstr "xyz%1$s%2$d" +# Valid: permutation +msgid "abc%s%d%cdef" +msgstr "xyz%3$c%2$d%1$s" +# Valid: permutation with width +msgid "abc%c%.*sdef" +msgstr "xyz%3$.*2$s%1$c" # Invalid: too few arguments msgid "abc%sdef%u" msgstr "xyz%s" # Invalid: too many arguments msgid "abc%udef" msgstr "xyz%uvw%c" +# Valid: same numbered arguments, with different widths +msgid "abc%2$5s%1$4s" +msgstr "xyz%2$4s%1$5s" +# Invalid: missing argument +msgid "abc%2$sdef%1$u" +msgstr "xyz%1$u" +# Invalid: missing argument +msgid "abc%1$sdef%2$u" +msgstr "xyz%2$u" +# Invalid: added argument +msgid "abc%1$udef" +msgstr "xyz%1$uvw%2$c" # Valid: type compatibility msgid "abc%i" msgstr "xyz%d" |