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