Commit | Line | Data |
---|---|---|
c4b681fd | 1 | /* Formatted output to strings. |
61cd9dc9 | 2 | Copyright (C) 1999-2000, 2002-2003, 2006-2010 Free Software Foundation, Inc. |
c4b681fd LC |
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 | { | |
1cd4fffc LC |
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 */ | |
c4b681fd LC |
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_) \ | |
1cd4fffc LC |
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; \ | |
c4b681fd LC |
131 | } |
132 | ||
133 | while (*cp != '\0') | |
134 | { | |
135 | CHAR_T c = *cp++; | |
136 | if (c == '%') | |
1cd4fffc LC |
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 | } | |
0f00f2c3 LC |
209 | #if __GLIBC__ >= 2 && !defined __UCLIBC__ |
210 | else if (*cp == 'I') | |
211 | { | |
212 | dp->flags |= FLAG_LOCALIZED; | |
213 | cp++; | |
214 | } | |
215 | #endif | |
1cd4fffc LC |
216 | else |
217 | break; | |
218 | } | |
219 | ||
220 | /* Parse the field width. */ | |
221 | if (*cp == '*') | |
222 | { | |
223 | dp->width_start = cp; | |
224 | cp++; | |
225 | dp->width_end = cp; | |
226 | if (max_width_length < 1) | |
227 | max_width_length = 1; | |
228 | ||
229 | /* Test for positional argument. */ | |
230 | if (*cp >= '0' && *cp <= '9') | |
231 | { | |
232 | const CHAR_T *np; | |
233 | ||
234 | for (np = cp; *np >= '0' && *np <= '9'; np++) | |
235 | ; | |
236 | if (*np == '$') | |
237 | { | |
238 | size_t n = 0; | |
239 | ||
240 | for (np = cp; *np >= '0' && *np <= '9'; np++) | |
241 | n = xsum (xtimes (n, 10), *np - '0'); | |
242 | if (n == 0) | |
243 | /* Positional argument 0. */ | |
244 | goto error; | |
245 | if (size_overflow_p (n)) | |
246 | /* n too large, would lead to out of memory later. */ | |
247 | goto error; | |
248 | dp->width_arg_index = n - 1; | |
249 | cp = np + 1; | |
250 | } | |
251 | } | |
252 | if (dp->width_arg_index == ARG_NONE) | |
253 | { | |
254 | dp->width_arg_index = arg_posn++; | |
255 | if (dp->width_arg_index == ARG_NONE) | |
256 | /* arg_posn wrapped around. */ | |
257 | goto error; | |
258 | } | |
259 | REGISTER_ARG (dp->width_arg_index, TYPE_INT); | |
260 | } | |
261 | else if (*cp >= '0' && *cp <= '9') | |
262 | { | |
263 | size_t width_length; | |
264 | ||
265 | dp->width_start = cp; | |
266 | for (; *cp >= '0' && *cp <= '9'; cp++) | |
267 | ; | |
268 | dp->width_end = cp; | |
269 | width_length = dp->width_end - dp->width_start; | |
270 | if (max_width_length < width_length) | |
271 | max_width_length = width_length; | |
272 | } | |
273 | ||
274 | /* Parse the precision. */ | |
275 | if (*cp == '.') | |
276 | { | |
277 | cp++; | |
278 | if (*cp == '*') | |
279 | { | |
280 | dp->precision_start = cp - 1; | |
281 | cp++; | |
282 | dp->precision_end = cp; | |
283 | if (max_precision_length < 2) | |
284 | max_precision_length = 2; | |
285 | ||
286 | /* Test for positional argument. */ | |
287 | if (*cp >= '0' && *cp <= '9') | |
288 | { | |
289 | const CHAR_T *np; | |
290 | ||
291 | for (np = cp; *np >= '0' && *np <= '9'; np++) | |
292 | ; | |
293 | if (*np == '$') | |
294 | { | |
295 | size_t n = 0; | |
296 | ||
297 | for (np = cp; *np >= '0' && *np <= '9'; np++) | |
298 | n = xsum (xtimes (n, 10), *np - '0'); | |
299 | if (n == 0) | |
300 | /* Positional argument 0. */ | |
301 | goto error; | |
302 | if (size_overflow_p (n)) | |
303 | /* n too large, would lead to out of memory | |
304 | later. */ | |
305 | goto error; | |
306 | dp->precision_arg_index = n - 1; | |
307 | cp = np + 1; | |
308 | } | |
309 | } | |
310 | if (dp->precision_arg_index == ARG_NONE) | |
311 | { | |
312 | dp->precision_arg_index = arg_posn++; | |
313 | if (dp->precision_arg_index == ARG_NONE) | |
314 | /* arg_posn wrapped around. */ | |
315 | goto error; | |
316 | } | |
317 | REGISTER_ARG (dp->precision_arg_index, TYPE_INT); | |
318 | } | |
319 | else | |
320 | { | |
321 | size_t precision_length; | |
322 | ||
323 | dp->precision_start = cp - 1; | |
324 | for (; *cp >= '0' && *cp <= '9'; cp++) | |
325 | ; | |
326 | dp->precision_end = cp; | |
327 | precision_length = dp->precision_end - dp->precision_start; | |
328 | if (max_precision_length < precision_length) | |
329 | max_precision_length = precision_length; | |
330 | } | |
331 | } | |
332 | ||
333 | { | |
334 | arg_type type; | |
335 | ||
336 | /* Parse argument type/size specifiers. */ | |
337 | { | |
338 | int flags = 0; | |
339 | ||
340 | for (;;) | |
341 | { | |
342 | if (*cp == 'h') | |
343 | { | |
344 | flags |= (1 << (flags & 1)); | |
345 | cp++; | |
346 | } | |
347 | else if (*cp == 'L') | |
348 | { | |
349 | flags |= 4; | |
350 | cp++; | |
351 | } | |
352 | else if (*cp == 'l') | |
353 | { | |
354 | flags += 8; | |
355 | cp++; | |
356 | } | |
357 | else if (*cp == 'j') | |
358 | { | |
359 | if (sizeof (intmax_t) > sizeof (long)) | |
360 | { | |
361 | /* intmax_t = long long */ | |
362 | flags += 16; | |
363 | } | |
364 | else if (sizeof (intmax_t) > sizeof (int)) | |
365 | { | |
366 | /* intmax_t = long */ | |
367 | flags += 8; | |
368 | } | |
369 | cp++; | |
370 | } | |
371 | else if (*cp == 'z' || *cp == 'Z') | |
372 | { | |
373 | /* 'z' is standardized in ISO C 99, but glibc uses 'Z' | |
374 | because the warning facility in gcc-2.95.2 understands | |
375 | only 'Z' (see gcc-2.95.2/gcc/c-common.c:1784). */ | |
376 | if (sizeof (size_t) > sizeof (long)) | |
377 | { | |
378 | /* size_t = long long */ | |
379 | flags += 16; | |
380 | } | |
381 | else if (sizeof (size_t) > sizeof (int)) | |
382 | { | |
383 | /* size_t = long */ | |
384 | flags += 8; | |
385 | } | |
386 | cp++; | |
387 | } | |
388 | else if (*cp == 't') | |
389 | { | |
390 | if (sizeof (ptrdiff_t) > sizeof (long)) | |
391 | { | |
392 | /* ptrdiff_t = long long */ | |
393 | flags += 16; | |
394 | } | |
395 | else if (sizeof (ptrdiff_t) > sizeof (int)) | |
396 | { | |
397 | /* ptrdiff_t = long */ | |
398 | flags += 8; | |
399 | } | |
400 | cp++; | |
401 | } | |
c4b681fd | 402 | #if defined __APPLE__ && defined __MACH__ |
1cd4fffc LC |
403 | /* On MacOS X 10.3, PRIdMAX is defined as "qd". |
404 | We cannot change it to "lld" because PRIdMAX must also | |
405 | be understood by the system's printf routines. */ | |
406 | else if (*cp == 'q') | |
407 | { | |
408 | if (64 / 8 > sizeof (long)) | |
409 | { | |
410 | /* int64_t = long long */ | |
411 | flags += 16; | |
412 | } | |
413 | else | |
414 | { | |
415 | /* int64_t = long */ | |
416 | flags += 8; | |
417 | } | |
418 | cp++; | |
419 | } | |
c4b681fd LC |
420 | #endif |
421 | #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__ | |
1cd4fffc LC |
422 | /* On native Win32, PRIdMAX is defined as "I64d". |
423 | We cannot change it to "lld" because PRIdMAX must also | |
424 | be understood by the system's printf routines. */ | |
425 | else if (*cp == 'I' && cp[1] == '6' && cp[2] == '4') | |
426 | { | |
427 | if (64 / 8 > sizeof (long)) | |
428 | { | |
429 | /* __int64 = long long */ | |
430 | flags += 16; | |
431 | } | |
432 | else | |
433 | { | |
434 | /* __int64 = long */ | |
435 | flags += 8; | |
436 | } | |
437 | cp += 3; | |
438 | } | |
c4b681fd | 439 | #endif |
1cd4fffc LC |
440 | else |
441 | break; | |
442 | } | |
443 | ||
444 | /* Read the conversion character. */ | |
445 | c = *cp++; | |
446 | switch (c) | |
447 | { | |
448 | case 'd': case 'i': | |
c4b681fd | 449 | #if HAVE_LONG_LONG_INT |
1cd4fffc LC |
450 | /* If 'long long' exists and is larger than 'long': */ |
451 | if (flags >= 16 || (flags & 4)) | |
452 | type = TYPE_LONGLONGINT; | |
453 | else | |
c4b681fd | 454 | #endif |
1cd4fffc LC |
455 | /* If 'long long' exists and is the same as 'long', we parse |
456 | "lld" into TYPE_LONGINT. */ | |
457 | if (flags >= 8) | |
458 | type = TYPE_LONGINT; | |
459 | else if (flags & 2) | |
460 | type = TYPE_SCHAR; | |
461 | else if (flags & 1) | |
462 | type = TYPE_SHORT; | |
463 | else | |
464 | type = TYPE_INT; | |
465 | break; | |
466 | case 'o': case 'u': case 'x': case 'X': | |
c4b681fd | 467 | #if HAVE_LONG_LONG_INT |
1cd4fffc LC |
468 | /* If 'long long' exists and is larger than 'long': */ |
469 | if (flags >= 16 || (flags & 4)) | |
470 | type = TYPE_ULONGLONGINT; | |
471 | else | |
c4b681fd | 472 | #endif |
1cd4fffc LC |
473 | /* If 'unsigned long long' exists and is the same as |
474 | 'unsigned long', we parse "llu" into TYPE_ULONGINT. */ | |
475 | if (flags >= 8) | |
476 | type = TYPE_ULONGINT; | |
477 | else if (flags & 2) | |
478 | type = TYPE_UCHAR; | |
479 | else if (flags & 1) | |
480 | type = TYPE_USHORT; | |
481 | else | |
482 | type = TYPE_UINT; | |
483 | break; | |
484 | case 'f': case 'F': case 'e': case 'E': case 'g': case 'G': | |
485 | case 'a': case 'A': | |
486 | if (flags >= 16 || (flags & 4)) | |
487 | type = TYPE_LONGDOUBLE; | |
488 | else | |
489 | type = TYPE_DOUBLE; | |
490 | break; | |
491 | case 'c': | |
492 | if (flags >= 8) | |
c4b681fd | 493 | #if HAVE_WINT_T |
1cd4fffc | 494 | type = TYPE_WIDE_CHAR; |
c4b681fd | 495 | #else |
1cd4fffc | 496 | goto error; |
c4b681fd | 497 | #endif |
1cd4fffc LC |
498 | else |
499 | type = TYPE_CHAR; | |
500 | break; | |
c4b681fd | 501 | #if HAVE_WINT_T |
1cd4fffc LC |
502 | case 'C': |
503 | type = TYPE_WIDE_CHAR; | |
504 | c = 'c'; | |
505 | break; | |
c4b681fd | 506 | #endif |
1cd4fffc LC |
507 | case 's': |
508 | if (flags >= 8) | |
c4b681fd | 509 | #if HAVE_WCHAR_T |
1cd4fffc | 510 | type = TYPE_WIDE_STRING; |
c4b681fd | 511 | #else |
1cd4fffc | 512 | goto error; |
c4b681fd | 513 | #endif |
1cd4fffc LC |
514 | else |
515 | type = TYPE_STRING; | |
516 | break; | |
c4b681fd | 517 | #if HAVE_WCHAR_T |
1cd4fffc LC |
518 | case 'S': |
519 | type = TYPE_WIDE_STRING; | |
520 | c = 's'; | |
521 | break; | |
c4b681fd | 522 | #endif |
1cd4fffc LC |
523 | case 'p': |
524 | type = TYPE_POINTER; | |
525 | break; | |
526 | case 'n': | |
c4b681fd | 527 | #if HAVE_LONG_LONG_INT |
1cd4fffc LC |
528 | /* If 'long long' exists and is larger than 'long': */ |
529 | if (flags >= 16 || (flags & 4)) | |
530 | type = TYPE_COUNT_LONGLONGINT_POINTER; | |
531 | else | |
c4b681fd | 532 | #endif |
1cd4fffc LC |
533 | /* If 'long long' exists and is the same as 'long', we parse |
534 | "lln" into TYPE_COUNT_LONGINT_POINTER. */ | |
535 | if (flags >= 8) | |
536 | type = TYPE_COUNT_LONGINT_POINTER; | |
537 | else if (flags & 2) | |
538 | type = TYPE_COUNT_SCHAR_POINTER; | |
539 | else if (flags & 1) | |
540 | type = TYPE_COUNT_SHORT_POINTER; | |
541 | else | |
542 | type = TYPE_COUNT_INT_POINTER; | |
543 | break; | |
c4b681fd | 544 | #if ENABLE_UNISTDIO |
1cd4fffc LC |
545 | /* The unistdio extensions. */ |
546 | case 'U': | |
547 | if (flags >= 16) | |
548 | type = TYPE_U32_STRING; | |
549 | else if (flags >= 8) | |
550 | type = TYPE_U16_STRING; | |
551 | else | |
552 | type = TYPE_U8_STRING; | |
553 | break; | |
c4b681fd | 554 | #endif |
1cd4fffc LC |
555 | case '%': |
556 | type = TYPE_NONE; | |
557 | break; | |
558 | default: | |
559 | /* Unknown conversion character. */ | |
560 | goto error; | |
561 | } | |
562 | } | |
563 | ||
564 | if (type != TYPE_NONE) | |
565 | { | |
566 | dp->arg_index = arg_index; | |
567 | if (dp->arg_index == ARG_NONE) | |
568 | { | |
569 | dp->arg_index = arg_posn++; | |
570 | if (dp->arg_index == ARG_NONE) | |
571 | /* arg_posn wrapped around. */ | |
572 | goto error; | |
573 | } | |
574 | REGISTER_ARG (dp->arg_index, type); | |
575 | } | |
576 | dp->conversion = c; | |
577 | dp->dir_end = cp; | |
578 | } | |
579 | ||
580 | d->count++; | |
581 | if (d->count >= d_allocated) | |
582 | { | |
583 | size_t memory_size; | |
584 | DIRECTIVE *memory; | |
585 | ||
586 | d_allocated = xtimes (d_allocated, 2); | |
587 | memory_size = xtimes (d_allocated, sizeof (DIRECTIVE)); | |
588 | if (size_overflow_p (memory_size)) | |
589 | /* Overflow, would lead to out of memory. */ | |
590 | goto out_of_memory; | |
591 | memory = (DIRECTIVE *) realloc (d->dir, memory_size); | |
592 | if (memory == NULL) | |
593 | /* Out of memory. */ | |
594 | goto out_of_memory; | |
595 | d->dir = memory; | |
596 | } | |
597 | } | |
c4b681fd LC |
598 | #if CHAR_T_ONLY_ASCII |
599 | else if (!c_isascii (c)) | |
1cd4fffc LC |
600 | { |
601 | /* Non-ASCII character. Not supported. */ | |
602 | goto error; | |
603 | } | |
c4b681fd LC |
604 | #endif |
605 | } | |
606 | d->dir[d->count].dir_start = cp; | |
607 | ||
608 | d->max_width_length = max_width_length; | |
609 | d->max_precision_length = max_precision_length; | |
610 | return 0; | |
611 | ||
612 | error: | |
613 | if (a->arg) | |
614 | free (a->arg); | |
615 | if (d->dir) | |
616 | free (d->dir); | |
617 | errno = EINVAL; | |
618 | return -1; | |
619 | ||
620 | out_of_memory: | |
621 | if (a->arg) | |
622 | free (a->arg); | |
623 | if (d->dir) | |
624 | free (d->dir); | |
625 | out_of_memory_1: | |
626 | errno = ENOMEM; | |
627 | return -1; | |
628 | } | |
629 | ||
630 | #undef PRINTF_PARSE | |
631 | #undef DIRECTIVES | |
632 | #undef DIRECTIVE | |
633 | #undef CHAR_T_ONLY_ASCII | |
634 | #undef CHAR_T |