Mercurial > hg-old > index.cgi

comparison lib/printf-parse.c @ 434:b8bf63962a99 3.0

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