gnu/dist/gettext/gettext-tools/src/format-php.c

   1 /* PHP format strings.
   2    Copyright (C) 2001-2004 Free Software Foundation, Inc.
   3    Written by Bruno Haible <bruno@clisp.org>, 2002.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2, or (at your option)
   8    any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software Foundation,
  17    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 # include <config.h>
  21 #endif
  22
  23 #include <stdbool.h>
  24 #include <stdlib.h>
  25
  26 #include "format.h"
  27 #include "c-ctype.h"
  28 #include "xalloc.h"
  29 #include "xerror.h"
  30 #include "format-invalid.h"
  31 #include "gettext.h"
  32
  33 #define _(str) gettext (str)
  34
  35 /* PHP format strings are described in phpdoc-4.0.6, file
  36    phpdoc/manual/function.sprintf.html, and are implemented in
  37    php-4.1.0/ext/standard/formatted_print.c.
  38    A directive
  39    - starts with '%' or '%m$' where m is a positive integer,
  40    - is optionally followed by any of the characters '0', '-', ' ', or
  41      "'<anychar>", each of which acts as a flag,
  42    - is optionally followed by a width specification: a nonempty digit
  43      sequence,
  44    - is optionally followed by '.' and a precision specification: a nonempty
  45      digit sequence,
  46    - is optionally followed by a size specifier 'l', which is ignored,
  47    - is finished by a specifier
  48        - 's', that needs a string argument,
  49        - 'b', 'd', 'u', 'o', 'x', 'X', that need an integer argument,
  50        - 'e', 'f', that need a floating-point argument,
  51        - 'c', that needs a character argument.
  52    Additionally there is the directive '%%', which takes no argument.
  53    Numbered and unnumbered argument specifications can be used in the same
  54    string.  Numbered argument specifications have no influence on the
  55    "current argument index", that is incremented each time an argument is read.
  56  */
  57
  58 enum format_arg_type
  59 {
  60   FAT_INTEGER,
  61   FAT_FLOAT,
  62   FAT_CHARACTER,
  63   FAT_STRING
  64 };
  65
  66 struct numbered_arg
  67 {
  68   unsigned int number;
  69   enum format_arg_type type;
  70 };
  71
  72 struct spec
  73 {
  74   unsigned int directives;
  75   unsigned int numbered_arg_count;
  76   unsigned int allocated;
  77   struct numbered_arg *numbered;
  78 };
  79
  80 /* Locale independent test for a decimal digit.
  81    Argument can be  'char' or 'unsigned char'.  (Whereas the argument of
  82    <ctype.h> isdigit must be an 'unsigned char'.)  */
  83 #undef isdigit
  84 #define isdigit(c) ((unsigned int) ((c) - '0') < 10)
  85
  86
  87 static int
  88 numbered_arg_compare (const void *p1, const void *p2)
  89 {
  90   unsigned int n1 = ((const struct numbered_arg *) p1)->number;
  91   unsigned int n2 = ((const struct numbered_arg *) p2)->number;
  92
  93   return (n1 > n2 ? 1 : n1 < n2 ? -1 : 0);
  94 }
  95
  96 static void *
  97 format_parse (const char *format, bool translated, char **invalid_reason)
  98 {
  99   unsigned int directives;
 100   unsigned int numbered_arg_count;
 101   unsigned int allocated;
 102   struct numbered_arg *numbered;
 103   unsigned int unnumbered_arg_count;
 104   struct spec *result;
 105
 106   directives = 0;
 107   numbered_arg_count = 0;
 108   allocated = 0;
 109   numbered = NULL;
 110   unnumbered_arg_count = 0;
 111
 112   for (; *format != '\0';)
 113     if (*format++ == '%')
 114       {
 115         /* A directive.  */
 116         directives++;
 117
 118         if (*format != '%')
 119           {
 120             /* A complex directive.  */
 121             unsigned int number;
 122             enum format_arg_type type;
 123
 124             number = ++unnumbered_arg_count;
 125             if (isdigit (*format))
 126               {
 127                 const char *f = format;
 128                 unsigned int m = 0;
 129
 130                 do
 131                   {
 132                     m = 10 * m + (*f - '0');
 133                     f++;
 134                   }
 135                 while (isdigit (*f));
 136
 137                 if (*f == '$')
 138                   {
 139                     if (m == 0)
 140                       {
 141                         *invalid_reason = INVALID_ARGNO_0 (directives);
 142                         goto bad_format;
 143                       }
 144                     number = m;
 145                     format = ++f;
 146                     --unnumbered_arg_count;
 147                   }
 148               }
 149
 150             /* Parse flags.  */
 151             for (;;)
 152               {
 153                 if (*format == '0' || *format == '-' || *format == ' ')
 154                   format++;
 155                 else if (*format == '\'')
 156                   {
 157                     format++;
 158                     if (*format == '\0')
 159                       {
 160                         *invalid_reason = INVALID_UNTERMINATED_DIRECTIVE ();
 161                         goto bad_format;
 162                       }
 163                     format++;
 164                   }
 165                 else
 166                   break;
 167               }
 168
 169             /* Parse width.  */
 170             if (isdigit (*format))
 171               {
 172                 do
 173                   format++;
 174                 while (isdigit (*format));
 175               }
 176
 177             /* Parse precision.  */
 178             if (*format == '.')
 179               {
 180                 format++;
 181
 182                 if (isdigit (*format))
 183                   {
 184                     do
 185                       format++;
 186                     while (isdigit (*format));
 187                   }
 188                 else
 189                   --format;     /* will jump to bad_format */
 190               }
 191
 192             /* Parse size.  */
 193             if (*format == 'l')
 194               format++;
 195
 196             switch (*format)
 197               {
 198               case 'b': case 'd': case 'u': case 'o': case 'x': case 'X':
 199                 type = FAT_INTEGER;
 200                 break;
 201               case 'e': case 'f':
 202                 type = FAT_FLOAT;
 203                 break;
 204               case 'c':
 205                 type = FAT_CHARACTER;
 206                 break;
 207               case 's':
 208                 type = FAT_STRING;
 209                 break;
 210               default:
 211                 *invalid_reason =
 212                   (*format == '\0'
 213                    ? INVALID_UNTERMINATED_DIRECTIVE ()
 214                    : INVALID_CONVERSION_SPECIFIER (directives, *format));
 215                 goto bad_format;
 216               }
 217
 218             if (allocated == numbered_arg_count)
 219               {
 220                 allocated = 2 * allocated + 1;
 221                 numbered = (struct numbered_arg *) xrealloc (numbered, allocated * sizeof (struct numbered_arg));
 222               }
 223             numbered[numbered_arg_count].number = number;
 224             numbered[numbered_arg_count].type = type;
 225             numbered_arg_count++;
 226           }
 227
 228         format++;
 229       }
 230
 231   /* Sort the numbered argument array, and eliminate duplicates.  */
 232   if (numbered_arg_count > 1)
 233     {
 234       unsigned int i, j;
 235       bool err;
 236
 237       qsort (numbered, numbered_arg_count,
 238              sizeof (struct numbered_arg), numbered_arg_compare);
 239
 240       /* Remove duplicates: Copy from i to j, keeping 0 <= j <= i.  */
 241       err = false;
 242       for (i = j = 0; i < numbered_arg_count; i++)
 243         if (j > 0 && numbered[i].number == numbered[j-1].number)
 244           {
 245             enum format_arg_type type1 = numbered[i].type;
 246             enum format_arg_type type2 = numbered[j-1].type;
 247             enum format_arg_type type_both;
 248
 249             if (type1 == type2)
 250               type_both = type1;
 251             else
 252               {
 253                 /* Incompatible types.  */
 254                 type_both = type1;
 255                 if (!err)
 256                   *invalid_reason =
 257                     INVALID_INCOMPATIBLE_ARG_TYPES (numbered[i].number);
 258                 err = true;
 259               }
 260
 261             numbered[j-1].type = type_both;
 262           }
 263         else
 264           {
 265             if (j < i)
 266               {
 267                 numbered[j].number = numbered[i].number;
 268                 numbered[j].type = numbered[i].type;
 269               }
 270             j++;
 271           }
 272       numbered_arg_count = j;
 273       if (err)
 274         /* *invalid_reason has already been set above.  */
 275         goto bad_format;
 276     }
 277
 278   result = (struct spec *) xmalloc (sizeof (struct spec));
 279   result->directives = directives;
 280   result->numbered_arg_count = numbered_arg_count;
 281   result->allocated = allocated;
 282   result->numbered = numbered;
 283   return result;
 284
 285  bad_format:
 286   if (numbered != NULL)
 287     free (numbered);
 288   return NULL;
 289 }
 290
 291 static void
 292 format_free (void *descr)
 293 {
 294   struct spec *spec = (struct spec *) descr;
 295
 296   if (spec->numbered != NULL)
 297     free (spec->numbered);
 298   free (spec);
 299 }
 300
 301 static int
 302 format_get_number_of_directives (void *descr)
 303 {
 304   struct spec *spec = (struct spec *) descr;
 305
 306   return spec->directives;
 307 }
 308
 309 static bool
 310 format_check (void *msgid_descr, void *msgstr_descr, bool equality,
 311               formatstring_error_logger_t error_logger,
 312               const char *pretty_msgstr)
 313 {
 314   struct spec *spec1 = (struct spec *) msgid_descr;
 315   struct spec *spec2 = (struct spec *) msgstr_descr;
 316   bool err = false;
 317
 318   if (spec1->numbered_arg_count + spec2->numbered_arg_count > 0)
 319     {
 320       unsigned int i, j;
 321       unsigned int n1 = spec1->numbered_arg_count;
 322       unsigned int n2 = spec2->numbered_arg_count;
 323
 324       /* Check the argument names are the same.
 325          Both arrays are sorted.  We search for the first difference.  */
 326       for (i = 0, j = 0; i < n1 || j < n2; )
 327         {
 328           int cmp = (i >= n1 ? 1 :
 329                      j >= n2 ? -1 :
 330                      spec1->numbered[i].number > spec2->numbered[j].number ? 1 :
 331                      spec1->numbered[i].number < spec2->numbered[j].number ? -1 :
 332                      0);
 333
 334           if (cmp > 0)
 335             {
 336               if (error_logger)
 337                 error_logger (_("a format specification for argument %u, as in '%s', doesn't exist in 'msgid'"),
 338                               spec2->numbered[j].number, pretty_msgstr);
 339               err = true;
 340               break;
 341             }
 342           else if (cmp < 0)
 343             {
 344               if (equality)
 345                 {
 346                   if (error_logger)
 347                     error_logger (_("a format specification for argument %u doesn't exist in '%s'"),
 348                                   spec1->numbered[i].number, pretty_msgstr);
 349                   err = true;
 350                   break;
 351                 }
 352               else
 353                 i++;
 354             }
 355           else
 356             j++, i++;
 357         }
 358       /* Check the argument types are the same.  */
 359       if (!err)
 360         for (i = 0, j = 0; j < n2; )
 361           {
 362             if (spec1->numbered[i].number == spec2->numbered[j].number)
 363               {
 364                 if (spec1->numbered[i].type != spec2->numbered[j].type)
 365                   {
 366                     if (error_logger)
 367                       error_logger (_("format specifications in 'msgid' and '%s' for argument %u are not the same"),
 368                                     pretty_msgstr, spec2->numbered[j].number);
 369                     err = true;
 370                     break;
 371                   }
 372                 j++, i++;
 373               }
 374             else
 375               i++;
 376           }
 377     }
 378
 379   return err;
 380 }
 381
 382
 383 struct formatstring_parser formatstring_php =
 384 {
 385   format_parse,
 386   format_free,
 387   format_get_number_of_directives,
 388   format_check
 389 };
 390
 391
 392 #ifdef TEST
 393
 394 /* Test program: Print the argument list specification returned by
 395    format_parse for strings read from standard input.  */
 396
 397 #include <stdio.h>
 398 #include "getline.h"
 399
 400 static void
 401 format_print (void *descr)
 402 {
 403   struct spec *spec = (struct spec *) descr;
 404   unsigned int last;
 405   unsigned int i;
 406
 407   if (spec == NULL)
 408     {
 409       printf ("INVALID");
 410       return;
 411     }
 412
 413   printf ("(");
 414   last = 1;
 415   for (i = 0; i < spec->numbered_arg_count; i++)
 416     {
 417       unsigned int number = spec->numbered[i].number;
 418
 419       if (i > 0)
 420         printf (" ");
 421       if (number < last)
 422         abort ();
 423       for (; last < number; last++)
 424         printf ("_ ");
 425       switch (spec->numbered[i].type)
 426         {
 427         case FAT_INTEGER:
 428           printf ("i");
 429           break;
 430         case FAT_FLOAT:
 431           printf ("f");
 432           break;
 433         case FAT_CHARACTER:
 434           printf ("c");
 435           break;
 436         case FAT_STRING:
 437           printf ("s");
 438           break;
 439         default:
 440           abort ();
 441         }
 442       last = number + 1;
 443     }
 444   printf (")");
 445 }
 446
 447 int
 448 main ()
 449 {
 450   for (;;)
 451     {
 452       char *line = NULL;
 453       size_t line_size = 0;
 454       int line_len;
 455       char *invalid_reason;
 456       void *descr;
 457
 458       line_len = getline (&line, &line_size, stdin);
 459       if (line_len < 0)
 460         break;
 461       if (line_len > 0 && line[line_len - 1] == '\n')
 462         line[--line_len] = '\0';
 463
 464       invalid_reason = NULL;
 465       descr = format_parse (line, false, &invalid_reason);
 466
 467       format_print (descr);
 468       printf ("\n");
 469       if (descr == NULL)
 470         printf ("%s\n", invalid_reason);
 471
 472       free (invalid_reason);
 473       free (line);
 474     }
 475
 476   return 0;
 477 }
 478
 479 /*
 480  * For Emacs M-x compile
 481  * Local Variables:
 482  * compile-command: "/bin/sh ../libtool --mode=link gcc -o a.out -static -O -g -Wall -I.. -I../lib -I../intl -DHAVE_CONFIG_H -DTEST format-php.c ../lib/libgettextlib.la"
 483  * End:
 484  */
 485
 486 #endif /* TEST */