gl/printf-parse.c

   1 /* Formatted output to strings.
   2    Copyright (C) 1999-2000, 2002-2003, 2006-2012 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License along
  15    with this program; if not, see <http://www.gnu.org/licenses/>.  */
  16
  17 /* This file can be parametrized with the following macros:
  18      CHAR_T             The element type of the format string.
  19      CHAR_T_ONLY_ASCII  Set to 1 to enable verification that all characters
  20                         in the format string are ASCII.
  21      DIRECTIVE          Structure denoting a format directive.
  22                         Depends on CHAR_T.
  23      DIRECTIVES         Structure denoting the set of format directives of a
  24                         format string.  Depends on CHAR_T.
  25      PRINTF_PARSE       Function that parses a format string.
  26                         Depends on CHAR_T.
  27      STATIC             Set to 'static' to declare the function static.
  28      ENABLE_UNISTDIO    Set to 1 to enable the unistdio extensions.  */
  29
  30 #ifndef PRINTF_PARSE
  31 # include <config.h>
  32 #endif
  33
  34 /* Specification.  */
  35 #ifndef PRINTF_PARSE
  36 # include "printf-parse.h"
  37 #endif
  38
  39 /* Default parameters.  */
  40 #ifndef PRINTF_PARSE
  41 # define PRINTF_PARSE printf_parse
  42 # define CHAR_T char
  43 # define DIRECTIVE char_directive
  44 # define DIRECTIVES char_directives
  45 #endif
  46
  47 /* Get size_t, NULL.  */
  48 #include <stddef.h>
  49
  50 /* Get intmax_t.  */
  51 #if defined IN_LIBINTL || defined IN_LIBASPRINTF
  52 # if HAVE_STDINT_H_WITH_UINTMAX
  53 #  include <stdint.h>
  54 # endif
  55 # if HAVE_INTTYPES_H_WITH_UINTMAX
  56 #  include <inttypes.h>
  57 # endif
  58 #else
  59 # include <stdint.h>
  60 #endif
  61
  62 /* malloc(), realloc(), free().  */
  63 #include <stdlib.h>
  64
  65 /* memcpy().  */
  66 #include <string.h>
  67
  68 /* errno.  */
  69 #include <errno.h>
  70
  71 /* Checked size_t computations.  */
  72 #include "xsize.h"
  73
  74 #if CHAR_T_ONLY_ASCII
  75 /* c_isascii().  */
  76 # include "c-ctype.h"
  77 #endif
  78
  79 #ifdef STATIC
  80 STATIC
  81 #endif
  82 int
  83 PRINTF_PARSE (const CHAR_T *format, DIRECTIVES *d, arguments *a)
  84 {
  85   const CHAR_T *cp = format;    /* pointer into format */
  86   size_t arg_posn = 0;          /* number of regular arguments consumed */
  87   size_t d_allocated;           /* allocated elements of d->dir */
  88   size_t a_allocated;           /* allocated elements of a->arg */
  89   size_t max_width_length = 0;
  90   size_t max_precision_length = 0;
  91
  92   d->count = 0;
  93   d_allocated = N_DIRECT_ALLOC_DIRECTIVES;
  94   d->dir = d->direct_alloc_dir;
  95
  96   a->count = 0;
  97   a_allocated = N_DIRECT_ALLOC_ARGUMENTS;
  98   a->arg = a->direct_alloc_arg;
  99
 100 #define REGISTER_ARG(_index_,_type_) \
 101   {                                                                     \
 102     size_t n = (_index_);                                               \
 103     if (n >= a_allocated)                                               \
 104       {                                                                 \
 105         size_t memory_size;                                             \
 106         argument *memory;                                               \
 107                                                                         \
 108         a_allocated = xtimes (a_allocated, 2);                          \
 109         if (a_allocated <= n)                                           \
 110           a_allocated = xsum (n, 1);                                    \
 111         memory_size = xtimes (a_allocated, sizeof (argument));          \
 112         if (size_overflow_p (memory_size))                              \
 113           /* Overflow, would lead to out of memory.  */                 \
 114           goto out_of_memory;                                           \
 115         memory = (argument *) (a->arg != a->direct_alloc_arg            \
 116                                ? realloc (a->arg, memory_size)          \
 117                                : malloc (memory_size));                 \
 118         if (memory == NULL)                                             \
 119           /* Out of memory.  */                                         \
 120           goto out_of_memory;                                           \
 121         if (a->arg == a->direct_alloc_arg)                              \
 122           memcpy (memory, a->arg, a->count * sizeof (argument));        \
 123         a->arg = memory;                                                \
 124       }                                                                 \
 125     while (a->count <= n)                                               \
 126       a->arg[a->count++].type = TYPE_NONE;                              \
 127     if (a->arg[n].type == TYPE_NONE)                                    \
 128       a->arg[n].type = (_type_);                                        \
 129     else if (a->arg[n].type != (_type_))                                \
 130       /* Ambiguous type for positional argument.  */                    \
 131       goto error;                                                       \
 132   }
 133
 134   while (*cp != '\0')
 135     {
 136       CHAR_T c = *cp++;
 137       if (c == '%')
 138         {
 139           size_t arg_index = ARG_NONE;
 140           DIRECTIVE *dp = &d->dir[d->count]; /* pointer to next directive */
 141
 142           /* Initialize the next directive.  */
 143           dp->dir_start = cp - 1;
 144           dp->flags = 0;
 145           dp->width_start = NULL;
 146           dp->width_end = NULL;
 147           dp->width_arg_index = ARG_NONE;
 148           dp->precision_start = NULL;
 149           dp->precision_end = NULL;
 150           dp->precision_arg_index = ARG_NONE;
 151           dp->arg_index = ARG_NONE;
 152
 153           /* Test for positional argument.  */
 154           if (*cp >= '0' && *cp <= '9')
 155             {
 156               const CHAR_T *np;
 157
 158               for (np = cp; *np >= '0' && *np <= '9'; np++)
 159                 ;
 160               if (*np == '$')
 161                 {
 162                   size_t n = 0;
 163
 164                   for (np = cp; *np >= '0' && *np <= '9'; np++)
 165                     n = xsum (xtimes (n, 10), *np - '0');
 166                   if (n == 0)
 167                     /* Positional argument 0.  */
 168                     goto error;
 169                   if (size_overflow_p (n))
 170                     /* n too large, would lead to out of memory later.  */
 171                     goto error;
 172                   arg_index = n - 1;
 173                   cp = np + 1;
 174                 }
 175             }
 176
 177           /* Read the flags.  */
 178           for (;;)
 179             {
 180               if (*cp == '\'')
 181                 {
 182                   dp->flags |= FLAG_GROUP;
 183                   cp++;
 184                 }
 185               else if (*cp == '-')
 186                 {
 187                   dp->flags |= FLAG_LEFT;
 188                   cp++;
 189                 }
 190               else if (*cp == '+')
 191                 {
 192                   dp->flags |= FLAG_SHOWSIGN;
 193                   cp++;
 194                 }
 195               else if (*cp == ' ')
 196                 {
 197                   dp->flags |= FLAG_SPACE;
 198                   cp++;
 199                 }
 200               else if (*cp == '#')
 201                 {
 202                   dp->flags |= FLAG_ALT;
 203                   cp++;
 204                 }
 205               else if (*cp == '0')
 206                 {
 207                   dp->flags |= FLAG_ZERO;
 208                   cp++;
 209                 }
 210 #if __GLIBC__ >= 2 && !defined __UCLIBC__
 211               else if (*cp == 'I')
 212                 {
 213                   dp->flags |= FLAG_LOCALIZED;
 214                   cp++;
 215                 }
 216 #endif
 217               else
 218                 break;
 219             }
 220
 221           /* Parse the field width.  */
 222           if (*cp == '*')
 223             {
 224               dp->width_start = cp;
 225               cp++;
 226               dp->width_end = cp;
 227               if (max_width_length < 1)
 228                 max_width_length = 1;
 229
 230               /* Test for positional argument.  */
 231               if (*cp >= '0' && *cp <= '9')
 232                 {
 233                   const CHAR_T *np;
 234
 235                   for (np = cp; *np >= '0' && *np <= '9'; np++)
 236                     ;
 237                   if (*np == '$')
 238                     {
 239                       size_t n = 0;
 240
 241                       for (np = cp; *np >= '0' && *np <= '9'; np++)
 242                         n = xsum (xtimes (n, 10), *np - '0');
 243                       if (n == 0)
 244                         /* Positional argument 0.  */
 245                         goto error;
 246                       if (size_overflow_p (n))
 247                         /* n too large, would lead to out of memory later.  */
 248                         goto error;
 249                       dp->width_arg_index = n - 1;
 250                       cp = np + 1;
 251                     }
 252                 }
 253               if (dp->width_arg_index == ARG_NONE)
 254                 {
 255                   dp->width_arg_index = arg_posn++;
 256                   if (dp->width_arg_index == ARG_NONE)
 257                     /* arg_posn wrapped around.  */
 258                     goto error;
 259                 }
 260               REGISTER_ARG (dp->width_arg_index, TYPE_INT);
 261             }
 262           else if (*cp >= '0' && *cp <= '9')
 263             {
 264               size_t width_length;
 265
 266               dp->width_start = cp;
 267               for (; *cp >= '0' && *cp <= '9'; cp++)
 268                 ;
 269               dp->width_end = cp;
 270               width_length = dp->width_end - dp->width_start;
 271               if (max_width_length < width_length)
 272                 max_width_length = width_length;
 273             }
 274
 275           /* Parse the precision.  */
 276           if (*cp == '.')
 277             {
 278               cp++;
 279               if (*cp == '*')
 280                 {
 281                   dp->precision_start = cp - 1;
 282                   cp++;
 283                   dp->precision_end = cp;
 284                   if (max_precision_length < 2)
 285                     max_precision_length = 2;
 286
 287                   /* Test for positional argument.  */
 288                   if (*cp >= '0' && *cp <= '9')
 289                     {
 290                       const CHAR_T *np;
 291
 292                       for (np = cp; *np >= '0' && *np <= '9'; np++)
 293                         ;
 294                       if (*np == '$')
 295                         {
 296                           size_t n = 0;
 297
 298                           for (np = cp; *np >= '0' && *np <= '9'; np++)
 299                             n = xsum (xtimes (n, 10), *np - '0');
 300                           if (n == 0)
 301                             /* Positional argument 0.  */
 302                             goto error;
 303                           if (size_overflow_p (n))
 304                             /* n too large, would lead to out of memory
 305                                later.  */
 306                             goto error;
 307                           dp->precision_arg_index = n - 1;
 308                           cp = np + 1;
 309                         }
 310                     }
 311                   if (dp->precision_arg_index == ARG_NONE)
 312                     {
 313                       dp->precision_arg_index = arg_posn++;
 314                       if (dp->precision_arg_index == ARG_NONE)
 315                         /* arg_posn wrapped around.  */
 316                         goto error;
 317                     }
 318                   REGISTER_ARG (dp->precision_arg_index, TYPE_INT);
 319                 }
 320               else
 321                 {
 322                   size_t precision_length;
 323
 324                   dp->precision_start = cp - 1;
 325                   for (; *cp >= '0' && *cp <= '9'; cp++)
 326                     ;
 327                   dp->precision_end = cp;
 328                   precision_length = dp->precision_end - dp->precision_start;
 329                   if (max_precision_length < precision_length)
 330                     max_precision_length = precision_length;
 331                 }
 332             }
 333
 334           {
 335             arg_type type;
 336
 337             /* Parse argument type/size specifiers.  */
 338             {
 339               int flags = 0;
 340
 341               for (;;)
 342                 {
 343                   if (*cp == 'h')
 344                     {
 345                       flags |= (1 << (flags & 1));
 346                       cp++;
 347                     }
 348                   else if (*cp == 'L')
 349                     {
 350                       flags |= 4;
 351                       cp++;
 352                     }
 353                   else if (*cp == 'l')
 354                     {
 355                       flags += 8;
 356                       cp++;
 357                     }
 358                   else if (*cp == 'j')
 359                     {
 360                       if (sizeof (intmax_t) > sizeof (long))
 361                         {
 362                           /* intmax_t = long long */
 363                           flags += 16;
 364                         }
 365                       else if (sizeof (intmax_t) > sizeof (int))
 366                         {
 367                           /* intmax_t = long */
 368                           flags += 8;
 369                         }
 370                       cp++;
 371                     }
 372                   else if (*cp == 'z' || *cp == 'Z')
 373                     {
 374                       /* 'z' is standardized in ISO C 99, but glibc uses 'Z'
 375                          because the warning facility in gcc-2.95.2 understands
 376                          only 'Z' (see gcc-2.95.2/gcc/c-common.c:1784).  */
 377                       if (sizeof (size_t) > sizeof (long))
 378                         {
 379                           /* size_t = long long */
 380                           flags += 16;
 381                         }
 382                       else if (sizeof (size_t) > sizeof (int))
 383                         {
 384                           /* size_t = long */
 385                           flags += 8;
 386                         }
 387                       cp++;
 388                     }
 389                   else if (*cp == 't')
 390                     {
 391                       if (sizeof (ptrdiff_t) > sizeof (long))
 392                         {
 393                           /* ptrdiff_t = long long */
 394                           flags += 16;
 395                         }
 396                       else if (sizeof (ptrdiff_t) > sizeof (int))
 397                         {
 398                           /* ptrdiff_t = long */
 399                           flags += 8;
 400                         }
 401                       cp++;
 402                     }
 403 #if defined __APPLE__ && defined __MACH__
 404                   /* On Mac OS X 10.3, PRIdMAX is defined as "qd".
 405                      We cannot change it to "lld" because PRIdMAX must also
 406                      be understood by the system's printf routines.  */
 407                   else if (*cp == 'q')
 408                     {
 409                       if (64 / 8 > sizeof (long))
 410                         {
 411                           /* int64_t = long long */
 412                           flags += 16;
 413                         }
 414                       else
 415                         {
 416                           /* int64_t = long */
 417                           flags += 8;
 418                         }
 419                       cp++;
 420                     }
 421 #endif
 422 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
 423                   /* On native Windows, PRIdMAX is defined as "I64d".
 424                      We cannot change it to "lld" because PRIdMAX must also
 425                      be understood by the system's printf routines.  */
 426                   else if (*cp == 'I' && cp[1] == '6' && cp[2] == '4')
 427                     {
 428                       if (64 / 8 > sizeof (long))
 429                         {
 430                           /* __int64 = long long */
 431                           flags += 16;
 432                         }
 433                       else
 434                         {
 435                           /* __int64 = long */
 436                           flags += 8;
 437                         }
 438                       cp += 3;
 439                     }
 440 #endif
 441                   else
 442                     break;
 443                 }
 444
 445               /* Read the conversion character.  */
 446               c = *cp++;
 447               switch (c)
 448                 {
 449                 case 'd': case 'i':
 450 #if HAVE_LONG_LONG_INT
 451                   /* If 'long long' exists and is larger than 'long':  */
 452                   if (flags >= 16 || (flags & 4))
 453                     type = TYPE_LONGLONGINT;
 454                   else
 455 #endif
 456                   /* If 'long long' exists and is the same as 'long', we parse
 457                      "lld" into TYPE_LONGINT.  */
 458                   if (flags >= 8)
 459                     type = TYPE_LONGINT;
 460                   else if (flags & 2)
 461                     type = TYPE_SCHAR;
 462                   else if (flags & 1)
 463                     type = TYPE_SHORT;
 464                   else
 465                     type = TYPE_INT;
 466                   break;
 467                 case 'o': case 'u': case 'x': case 'X':
 468 #if HAVE_LONG_LONG_INT
 469                   /* If 'long long' exists and is larger than 'long':  */
 470                   if (flags >= 16 || (flags & 4))
 471                     type = TYPE_ULONGLONGINT;
 472                   else
 473 #endif
 474                   /* If 'unsigned long long' exists and is the same as
 475                      'unsigned long', we parse "llu" into TYPE_ULONGINT.  */
 476                   if (flags >= 8)
 477                     type = TYPE_ULONGINT;
 478                   else if (flags & 2)
 479                     type = TYPE_UCHAR;
 480                   else if (flags & 1)
 481                     type = TYPE_USHORT;
 482                   else
 483                     type = TYPE_UINT;
 484                   break;
 485                 case 'f': case 'F': case 'e': case 'E': case 'g': case 'G':
 486                 case 'a': case 'A':
 487                   if (flags >= 16 || (flags & 4))
 488                     type = TYPE_LONGDOUBLE;
 489                   else
 490                     type = TYPE_DOUBLE;
 491                   break;
 492                 case 'c':
 493                   if (flags >= 8)
 494 #if HAVE_WINT_T
 495                     type = TYPE_WIDE_CHAR;
 496 #else
 497                     goto error;
 498 #endif
 499                   else
 500                     type = TYPE_CHAR;
 501                   break;
 502 #if HAVE_WINT_T
 503                 case 'C':
 504                   type = TYPE_WIDE_CHAR;
 505                   c = 'c';
 506                   break;
 507 #endif
 508                 case 's':
 509                   if (flags >= 8)
 510 #if HAVE_WCHAR_T
 511                     type = TYPE_WIDE_STRING;
 512 #else
 513                     goto error;
 514 #endif
 515                   else
 516                     type = TYPE_STRING;
 517                   break;
 518 #if HAVE_WCHAR_T
 519                 case 'S':
 520                   type = TYPE_WIDE_STRING;
 521                   c = 's';
 522                   break;
 523 #endif
 524                 case 'p':
 525                   type = TYPE_POINTER;
 526                   break;
 527                 case 'n':
 528 #if HAVE_LONG_LONG_INT
 529                   /* If 'long long' exists and is larger than 'long':  */
 530                   if (flags >= 16 || (flags & 4))
 531                     type = TYPE_COUNT_LONGLONGINT_POINTER;
 532                   else
 533 #endif
 534                   /* If 'long long' exists and is the same as 'long', we parse
 535                      "lln" into TYPE_COUNT_LONGINT_POINTER.  */
 536                   if (flags >= 8)
 537                     type = TYPE_COUNT_LONGINT_POINTER;
 538                   else if (flags & 2)
 539                     type = TYPE_COUNT_SCHAR_POINTER;
 540                   else if (flags & 1)
 541                     type = TYPE_COUNT_SHORT_POINTER;
 542                   else
 543                     type = TYPE_COUNT_INT_POINTER;
 544                   break;
 545 #if ENABLE_UNISTDIO
 546                 /* The unistdio extensions.  */
 547                 case 'U':
 548                   if (flags >= 16)
 549                     type = TYPE_U32_STRING;
 550                   else if (flags >= 8)
 551                     type = TYPE_U16_STRING;
 552                   else
 553                     type = TYPE_U8_STRING;
 554                   break;
 555 #endif
 556                 case '%':
 557                   type = TYPE_NONE;
 558                   break;
 559                 default:
 560                   /* Unknown conversion character.  */
 561                   goto error;
 562                 }
 563             }
 564
 565             if (type != TYPE_NONE)
 566               {
 567                 dp->arg_index = arg_index;
 568                 if (dp->arg_index == ARG_NONE)
 569                   {
 570                     dp->arg_index = arg_posn++;
 571                     if (dp->arg_index == ARG_NONE)
 572                       /* arg_posn wrapped around.  */
 573                       goto error;
 574                   }
 575                 REGISTER_ARG (dp->arg_index, type);
 576               }
 577             dp->conversion = c;
 578             dp->dir_end = cp;
 579           }
 580
 581           d->count++;
 582           if (d->count >= d_allocated)
 583             {
 584               size_t memory_size;
 585               DIRECTIVE *memory;
 586
 587               d_allocated = xtimes (d_allocated, 2);
 588               memory_size = xtimes (d_allocated, sizeof (DIRECTIVE));
 589               if (size_overflow_p (memory_size))
 590                 /* Overflow, would lead to out of memory.  */
 591                 goto out_of_memory;
 592               memory = (DIRECTIVE *) (d->dir != d->direct_alloc_dir
 593                                       ? realloc (d->dir, memory_size)
 594                                       : malloc (memory_size));
 595               if (memory == NULL)
 596                 /* Out of memory.  */
 597                 goto out_of_memory;
 598               if (d->dir == d->direct_alloc_dir)
 599                 memcpy (memory, d->dir, d->count * sizeof (DIRECTIVE));
 600               d->dir = memory;
 601             }
 602         }
 603 #if CHAR_T_ONLY_ASCII
 604       else if (!c_isascii (c))
 605         {
 606           /* Non-ASCII character.  Not supported.  */
 607           goto error;
 608         }
 609 #endif
 610     }
 611   d->dir[d->count].dir_start = cp;
 612
 613   d->max_width_length = max_width_length;
 614   d->max_precision_length = max_precision_length;
 615   return 0;
 616
 617 error:
 618   if (a->arg != a->direct_alloc_arg)
 619     free (a->arg);
 620   if (d->dir != d->direct_alloc_dir)
 621     free (d->dir);
 622   errno = EINVAL;
 623   return -1;
 624
 625 out_of_memory:
 626   if (a->arg != a->direct_alloc_arg)
 627     free (a->arg);
 628   if (d->dir != d->direct_alloc_dir)
 629     free (d->dir);
 630   errno = ENOMEM;
 631   return -1;
 632 }
 633
 634 #undef PRINTF_PARSE
 635 #undef DIRECTIVES
 636 #undef DIRECTIVE
 637 #undef CHAR_T_ONLY_ASCII
 638 #undef CHAR_T