intl/printf-parse.c

   1 /* Formatted output to strings.
   2    Copyright (C) 1999-2000, 2002-2003 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify it
   5    under the terms of the GNU Library General Public License as published
   6    by the Free Software Foundation; either version 2, 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 GNU
  12    Library General Public License for more details.
  13
  14    You should have received a copy of the GNU Library General Public
  15    License along with this program; if not, write to the Free Software
  16    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  17    USA.  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 # include <config.h>
  21 #endif
  22
  23 /* Specification.  */
  24 #if WIDE_CHAR_VERSION
  25 # include "wprintf-parse.h"
  26 #else
  27 # include "printf-parse.h"
  28 #endif
  29
  30 /* Get size_t, NULL.  */
  31 #include <stddef.h>
  32
  33 /* Get intmax_t.  */
  34 #if HAVE_STDINT_H_WITH_UINTMAX
  35 # include <stdint.h>
  36 #endif
  37 #if HAVE_INTTYPES_H_WITH_UINTMAX
  38 # include <inttypes.h>
  39 #endif
  40
  41 /* malloc(), realloc(), free().  */
  42 #include <stdlib.h>
  43
  44 /* Checked size_t computations.  */
  45 #include "xsize.h"
  46
  47 #if WIDE_CHAR_VERSION
  48 # define PRINTF_PARSE wprintf_parse
  49 # define CHAR_T wchar_t
  50 # define DIRECTIVE wchar_t_directive
  51 # define DIRECTIVES wchar_t_directives
  52 #else
  53 # define PRINTF_PARSE printf_parse
  54 # define CHAR_T char
  55 # define DIRECTIVE char_directive
  56 # define DIRECTIVES char_directives
  57 #endif
  58
  59 #ifdef STATIC
  60 STATIC
  61 #endif
  62 int
  63 PRINTF_PARSE (const CHAR_T *format, DIRECTIVES *d, arguments *a)
  64 {
  65   const CHAR_T *cp = format;            /* pointer into format */
  66   size_t arg_posn = 0;          /* number of regular arguments consumed */
  67   size_t d_allocated;                   /* allocated elements of d->dir */
  68   size_t a_allocated;                   /* allocated elements of a->arg */
  69   size_t max_width_length = 0;
  70   size_t max_precision_length = 0;
  71
  72   d->count = 0;
  73   d_allocated = 1;
  74   d->dir = malloc (d_allocated * sizeof (DIRECTIVE));
  75   if (d->dir == NULL)
  76     /* Out of memory.  */
  77     return -1;
  78
  79   a->count = 0;
  80   a_allocated = 0;
  81   a->arg = NULL;
  82
  83 #define REGISTER_ARG(_index_,_type_) \
  84   {                                                                     \
  85     size_t n = (_index_);                                               \
  86     if (n >= a_allocated)                                               \
  87       {                                                                 \
  88         size_t memory_size;                                             \
  89         argument *memory;                                               \
  90                                                                         \
  91         a_allocated = xtimes (a_allocated, 2);                          \
  92         if (a_allocated <= n)                                           \
  93           a_allocated = xsum (n, 1);                                    \
  94         memory_size = xtimes (a_allocated, sizeof (argument));          \
  95         if (size_overflow_p (memory_size))                              \
  96           /* Overflow, would lead to out of memory.  */                 \
  97           goto error;                                                   \
  98         memory = (a->arg                                                \
  99                   ? realloc (a->arg, memory_size)                       \
 100                   : malloc (memory_size));                              \
 101         if (memory == NULL)                                             \
 102           /* Out of memory.  */                                         \
 103           goto error;                                                   \
 104         a->arg = memory;                                                \
 105       }                                                                 \
 106     while (a->count <= n)                                               \
 107       a->arg[a->count++].type = TYPE_NONE;                              \
 108     if (a->arg[n].type == TYPE_NONE)                                    \
 109       a->arg[n].type = (_type_);                                        \
 110     else if (a->arg[n].type != (_type_))                                \
 111       /* Ambiguous type for positional argument.  */                    \
 112       goto error;                                                       \
 113   }
 114
 115   while (*cp != '\0')
 116     {
 117       CHAR_T c = *cp++;
 118       if (c == '%')
 119         {
 120           size_t arg_index = ARG_NONE;
 121           DIRECTIVE *dp = &d->dir[d->count];/* pointer to next directive */
 122
 123           /* Initialize the next directive.  */
 124           dp->dir_start = cp - 1;
 125           dp->flags = 0;
 126           dp->width_start = NULL;
 127           dp->width_end = NULL;
 128           dp->width_arg_index = ARG_NONE;
 129           dp->precision_start = NULL;
 130           dp->precision_end = NULL;
 131           dp->precision_arg_index = ARG_NONE;
 132           dp->arg_index = ARG_NONE;
 133
 134           /* Test for positional argument.  */
 135           if (*cp >= '0' && *cp <= '9')
 136             {
 137               const CHAR_T *np;
 138
 139               for (np = cp; *np >= '0' && *np <= '9'; np++)
 140                 ;
 141               if (*np == '$')
 142                 {
 143                   size_t n = 0;
 144
 145                   for (np = cp; *np >= '0' && *np <= '9'; np++)
 146                     n = xsum (xtimes (n, 10), *np - '0');
 147                   if (n == 0)
 148                     /* Positional argument 0.  */
 149                     goto error;
 150                   if (size_overflow_p (n))
 151                     /* n too large, would lead to out of memory later.  */
 152                     goto error;
 153                   arg_index = n - 1;
 154                   cp = np + 1;
 155                 }
 156             }
 157
 158           /* Read the flags.  */
 159           for (;;)
 160             {
 161               if (*cp == '\'')
 162                 {
 163                   dp->flags |= FLAG_GROUP;
 164                   cp++;
 165                 }
 166               else if (*cp == '-')
 167                 {
 168                   dp->flags |= FLAG_LEFT;
 169                   cp++;
 170                 }
 171               else if (*cp == '+')
 172                 {
 173                   dp->flags |= FLAG_SHOWSIGN;
 174                   cp++;
 175                 }
 176               else if (*cp == ' ')
 177                 {
 178                   dp->flags |= FLAG_SPACE;
 179                   cp++;
 180                 }
 181               else if (*cp == '#')
 182                 {
 183                   dp->flags |= FLAG_ALT;
 184                   cp++;
 185                 }
 186               else if (*cp == '0')
 187                 {
 188                   dp->flags |= FLAG_ZERO;
 189                   cp++;
 190                 }
 191               else
 192                 break;
 193             }
 194
 195           /* Parse the field width.  */
 196           if (*cp == '*')
 197             {
 198               dp->width_start = cp;
 199               cp++;
 200               dp->width_end = cp;
 201               if (max_width_length < 1)
 202                 max_width_length = 1;
 203
 204               /* Test for positional argument.  */
 205               if (*cp >= '0' && *cp <= '9')
 206                 {
 207                   const CHAR_T *np;
 208
 209                   for (np = cp; *np >= '0' && *np <= '9'; np++)
 210                     ;
 211                   if (*np == '$')
 212                     {
 213                       size_t n = 0;
 214
 215                       for (np = cp; *np >= '0' && *np <= '9'; np++)
 216                         n = xsum (xtimes (n, 10), *np - '0');
 217                       if (n == 0)
 218                         /* Positional argument 0.  */
 219                         goto error;
 220                       if (size_overflow_p (n))
 221                         /* n too large, would lead to out of memory later.  */
 222                         goto error;
 223                       dp->width_arg_index = n - 1;
 224                       cp = np + 1;
 225                     }
 226                 }
 227               if (dp->width_arg_index == ARG_NONE)
 228                 {
 229                   dp->width_arg_index = arg_posn++;
 230                   if (dp->width_arg_index == ARG_NONE)
 231                     /* arg_posn wrapped around.  */
 232                     goto error;
 233                 }
 234               REGISTER_ARG (dp->width_arg_index, TYPE_INT);
 235             }
 236           else if (*cp >= '0' && *cp <= '9')
 237             {
 238               size_t width_length;
 239
 240               dp->width_start = cp;
 241               for (; *cp >= '0' && *cp <= '9'; cp++)
 242                 ;
 243               dp->width_end = cp;
 244               width_length = dp->width_end - dp->width_start;
 245               if (max_width_length < width_length)
 246                 max_width_length = width_length;
 247             }
 248
 249           /* Parse the precision.  */
 250           if (*cp == '.')
 251             {
 252               cp++;
 253               if (*cp == '*')
 254                 {
 255                   dp->precision_start = cp - 1;
 256                   cp++;
 257                   dp->precision_end = cp;
 258                   if (max_precision_length < 2)
 259                     max_precision_length = 2;
 260
 261                   /* Test for positional argument.  */
 262                   if (*cp >= '0' && *cp <= '9')
 263                     {
 264                       const CHAR_T *np;
 265
 266                       for (np = cp; *np >= '0' && *np <= '9'; np++)
 267                         ;
 268                       if (*np == '$')
 269                         {
 270                           size_t n = 0;
 271
 272                           for (np = cp; *np >= '0' && *np <= '9'; np++)
 273                             n = xsum (xtimes (n, 10), *np - '0');
 274                           if (n == 0)
 275                             /* Positional argument 0.  */
 276                             goto error;
 277                           if (size_overflow_p (n))
 278                             /* n too large, would lead to out of memory
 279                                later.  */
 280                             goto error;
 281                           dp->precision_arg_index = n - 1;
 282                           cp = np + 1;
 283                         }
 284                     }
 285                   if (dp->precision_arg_index == ARG_NONE)
 286                     {
 287                       dp->precision_arg_index = arg_posn++;
 288                       if (dp->precision_arg_index == ARG_NONE)
 289                         /* arg_posn wrapped around.  */
 290                         goto error;
 291                     }
 292                   REGISTER_ARG (dp->precision_arg_index, TYPE_INT);
 293                 }
 294               else
 295                 {
 296                   size_t precision_length;
 297
 298                   dp->precision_start = cp - 1;
 299                   for (; *cp >= '0' && *cp <= '9'; cp++)
 300                     ;
 301                   dp->precision_end = cp;
 302                   precision_length = dp->precision_end - dp->precision_start;
 303                   if (max_precision_length < precision_length)
 304                     max_precision_length = precision_length;
 305                 }
 306             }
 307
 308           {
 309             arg_type type;
 310
 311             /* Parse argument type/size specifiers.  */
 312             {
 313               int flags = 0;
 314
 315               for (;;)
 316                 {
 317                   if (*cp == 'h')
 318                     {
 319                       flags |= (1 << (flags & 1));
 320                       cp++;
 321                     }
 322                   else if (*cp == 'L')
 323                     {
 324                       flags |= 4;
 325                       cp++;
 326                     }
 327                   else if (*cp == 'l')
 328                     {
 329                       flags += 8;
 330                       cp++;
 331                     }
 332 #ifdef HAVE_INTMAX_T
 333                   else if (*cp == 'j')
 334                     {
 335                       if (sizeof (intmax_t) > sizeof (long))
 336                         {
 337                           /* intmax_t = long long */
 338                           flags += 16;
 339                         }
 340                       else if (sizeof (intmax_t) > sizeof (int))
 341                         {
 342                           /* intmax_t = long */
 343                           flags += 8;
 344                         }
 345                       cp++;
 346                     }
 347 #endif
 348                   else if (*cp == 'z' || *cp == 'Z')
 349                     {
 350                       /* 'z' is standardized in ISO C 99, but glibc uses 'Z'
 351                          because the warning facility in gcc-2.95.2 understands
 352                          only 'Z' (see gcc-2.95.2/gcc/c-common.c:1784).  */
 353                       if (sizeof (size_t) > sizeof (long))
 354                         {
 355                           /* size_t = long long */
 356                           flags += 16;
 357                         }
 358                       else if (sizeof (size_t) > sizeof (int))
 359                         {
 360                           /* size_t = long */
 361                           flags += 8;
 362                         }
 363                       cp++;
 364                     }
 365                   else if (*cp == 't')
 366                     {
 367                       if (sizeof (ptrdiff_t) > sizeof (long))
 368                         {
 369                           /* ptrdiff_t = long long */
 370                           flags += 16;
 371                         }
 372                       else if (sizeof (ptrdiff_t) > sizeof (int))
 373                         {
 374                           /* ptrdiff_t = long */
 375                           flags += 8;
 376                         }
 377                       cp++;
 378                     }
 379                   else
 380                     break;
 381                 }
 382
 383               /* Read the conversion character.  */
 384               c = *cp++;
 385               switch (c)
 386                 {
 387                 case 'd': case 'i':
 388 #ifdef HAVE_LONG_LONG
 389                   if (flags >= 16 || (flags & 4))
 390                     type = TYPE_LONGLONGINT;
 391                   else
 392 #endif
 393                   if (flags >= 8)
 394                     type = TYPE_LONGINT;
 395                   else if (flags & 2)
 396                     type = TYPE_SCHAR;
 397                   else if (flags & 1)
 398                     type = TYPE_SHORT;
 399                   else
 400                     type = TYPE_INT;
 401                   break;
 402                 case 'o': case 'u': case 'x': case 'X':
 403 #ifdef HAVE_LONG_LONG
 404                   if (flags >= 16 || (flags & 4))
 405                     type = TYPE_ULONGLONGINT;
 406                   else
 407 #endif
 408                   if (flags >= 8)
 409                     type = TYPE_ULONGINT;
 410                   else if (flags & 2)
 411                     type = TYPE_UCHAR;
 412                   else if (flags & 1)
 413                     type = TYPE_USHORT;
 414                   else
 415                     type = TYPE_UINT;
 416                   break;
 417                 case 'f': case 'F': case 'e': case 'E': case 'g': case 'G':
 418                 case 'a': case 'A':
 419 #ifdef HAVE_LONG_DOUBLE
 420                   if (flags >= 16 || (flags & 4))
 421                     type = TYPE_LONGDOUBLE;
 422                   else
 423 #endif
 424                   type = TYPE_DOUBLE;
 425                   break;
 426                 case 'c':
 427                   if (flags >= 8)
 428 #ifdef HAVE_WINT_T
 429                     type = TYPE_WIDE_CHAR;
 430 #else
 431                     goto error;
 432 #endif
 433                   else
 434                     type = TYPE_CHAR;
 435                   break;
 436 #ifdef HAVE_WINT_T
 437                 case 'C':
 438                   type = TYPE_WIDE_CHAR;
 439                   c = 'c';
 440                   break;
 441 #endif
 442                 case 's':
 443                   if (flags >= 8)
 444 #ifdef HAVE_WCHAR_T
 445                     type = TYPE_WIDE_STRING;
 446 #else
 447                     goto error;
 448 #endif
 449                   else
 450                     type = TYPE_STRING;
 451                   break;
 452 #ifdef HAVE_WCHAR_T
 453                 case 'S':
 454                   type = TYPE_WIDE_STRING;
 455                   c = 's';
 456                   break;
 457 #endif
 458                 case 'p':
 459                   type = TYPE_POINTER;
 460                   break;
 461                 case 'n':
 462 #ifdef HAVE_LONG_LONG
 463                   if (flags >= 16 || (flags & 4))
 464                     type = TYPE_COUNT_LONGLONGINT_POINTER;
 465                   else
 466 #endif
 467                   if (flags >= 8)
 468                     type = TYPE_COUNT_LONGINT_POINTER;
 469                   else if (flags & 2)
 470                     type = TYPE_COUNT_SCHAR_POINTER;
 471                   else if (flags & 1)
 472                     type = TYPE_COUNT_SHORT_POINTER;
 473                   else
 474                     type = TYPE_COUNT_INT_POINTER;
 475                   break;
 476                 case '%':
 477                   type = TYPE_NONE;
 478                   break;
 479                 default:
 480                   /* Unknown conversion character.  */
 481                   goto error;
 482                 }
 483             }
 484
 485             if (type != TYPE_NONE)
 486               {
 487                 dp->arg_index = arg_index;
 488                 if (dp->arg_index == ARG_NONE)
 489                   {
 490                     dp->arg_index = arg_posn++;
 491                     if (dp->arg_index == ARG_NONE)
 492                       /* arg_posn wrapped around.  */
 493                       goto error;
 494                   }
 495                 REGISTER_ARG (dp->arg_index, type);
 496               }
 497             dp->conversion = c;
 498             dp->dir_end = cp;
 499           }
 500
 501           d->count++;
 502           if (d->count >= d_allocated)
 503             {
 504               size_t memory_size;
 505               DIRECTIVE *memory;
 506
 507               d_allocated = xtimes (d_allocated, 2);
 508               memory_size = xtimes (d_allocated, sizeof (DIRECTIVE));
 509               if (size_overflow_p (memory_size))
 510                 /* Overflow, would lead to out of memory.  */
 511                 goto error;
 512               memory = realloc (d->dir, memory_size);
 513               if (memory == NULL)
 514                 /* Out of memory.  */
 515                 goto error;
 516               d->dir = memory;
 517             }
 518         }
 519     }
 520   d->dir[d->count].dir_start = cp;
 521
 522   d->max_width_length = max_width_length;
 523   d->max_precision_length = max_precision_length;
 524   return 0;
 525
 526 error:
 527   if (a->arg)
 528     free (a->arg);
 529   if (d->dir)
 530     free (d->dir);
 531   return -1;
 532 }
 533
 534 #undef DIRECTIVES
 535 #undef DIRECTIVE
 536 #undef CHAR_T
 537 #undef PRINTF_PARSE