Commit | Line | Data |
---|---|---|
c4b681fd LC |
1 | /* Formatted output to strings. |
2 | Copyright (C) 1999-2000, 2002-2003, 2006-2008 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 Lesser General Public License as published by | |
6 | 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 | |
12 | GNU Lesser General Public License for more details. | |
13 | ||
14 | You should have received a copy of the GNU Lesser 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 |