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