navit/intl/printf-parse.c

/* Formatted output to strings.
   Copyright (C) 1999-2000, 2002-2003 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU Library General Public License as published
   by the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA.  */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

/* Specification.  */
#if WIDE_CHAR_VERSION
# include "wprintf-parse.h"
#else
# include "printf-parse.h"
#endif

/* Get size_t, NULL.  */
#include <stddef.h>

/* Get intmax_t.  */
#if HAVE_STDINT_H_WITH_UINTMAX
# include <stdint.h>
#endif
#if HAVE_INTTYPES_H_WITH_UINTMAX
# include <inttypes.h>
#endif

/* malloc(), realloc(), free().  */
#include <stdlib.h>

/* Checked size_t computations.  */
#include "xsize.h"

#if WIDE_CHAR_VERSION
# define PRINTF_PARSE wprintf_parse
# define CHAR_T wchar_t
# define DIRECTIVE wchar_t_directive
# define DIRECTIVES wchar_t_directives
#else
# define PRINTF_PARSE printf_parse
# define CHAR_T char
# define DIRECTIVE char_directive
# define DIRECTIVES char_directives
#endif

#ifdef STATIC
STATIC
#endif
int
PRINTF_PARSE (const CHAR_T *format, DIRECTIVES *d, arguments *a)
{
  const CHAR_T *cp = format;            /* pointer into format */
  size_t arg_posn = 0;          /* number of regular arguments consumed */
  size_t d_allocated;                   /* allocated elements of d->dir */
  size_t a_allocated;                   /* allocated elements of a->arg */
  size_t max_width_length = 0;
  size_t max_precision_length = 0;

  d->count = 0;
  d_allocated = 1;
  d->dir = malloc (d_allocated * sizeof (DIRECTIVE));
  if (d->dir == NULL)
    /* Out of memory.  */
    return -1;

  a->count = 0;
  a_allocated = 0;
  a->arg = NULL;

#define REGISTER_ARG(_index_,_type_) \
  {                                                                     \
    size_t n = (_index_);                                               \
    if (n >= a_allocated)                                               \
      {                                                                 \
        size_t memory_size;                                             \
        argument *memory;                                               \
                                                                        \
        a_allocated = xtimes (a_allocated, 2);                          \
        if (a_allocated <= n)                                           \
          a_allocated = xsum (n, 1);                                    \
        memory_size = xtimes (a_allocated, sizeof (argument));          \
        if (size_overflow_p (memory_size))                              \
          /* Overflow, would lead to out of memory.  */                 \
          goto error;                                                   \
        memory = (a->arg                                                \
                  ? realloc (a->arg, memory_size)                       \
                  : malloc (memory_size));                              \
        if (memory == NULL)                                             \
          /* Out of memory.  */                                         \
          goto error;                                                   \
        a->arg = memory;                                                \
      }                                                                 \
    while (a->count <= n)                                               \
      a->arg[a->count++].type = TYPE_NONE;                              \
    if (a->arg[n].type == TYPE_NONE)                                    \
      a->arg[n].type = (_type_);                                        \
    else if (a->arg[n].type != (_type_))                                \
      /* Ambiguous type for positional argument.  */                    \
      goto error;                                                       \
  }

  while (*cp != '\0')
    {
      CHAR_T c = *cp++;
      if (c == '%')
        {
          size_t arg_index = ARG_NONE;
          DIRECTIVE *dp = &d->dir[d->count];/* pointer to next directive */

          /* Initialize the next directive.  */
          dp->dir_start = cp - 1;
          dp->flags = 0;
          dp->width_start = NULL;
          dp->width_end = NULL;
          dp->width_arg_index = ARG_NONE;
          dp->precision_start = NULL;
          dp->precision_end = NULL;
          dp->precision_arg_index = ARG_NONE;
          dp->arg_index = ARG_NONE;

          /* Test for positional argument.  */
          if (*cp >= '0' && *cp <= '9')
            {
              const CHAR_T *np;

              for (np = cp; *np >= '0' && *np <= '9'; np++)
                ;
              if (*np == '$')
                {
                  size_t n = 0;

                  for (np = cp; *np >= '0' && *np <= '9'; np++)
                    n = xsum (xtimes (n, 10), *np - '0');
                  if (n == 0)
                    /* Positional argument 0.  */
                    goto error;
                  if (size_overflow_p (n))
                    /* n too large, would lead to out of memory later.  */
                    goto error;
                  arg_index = n - 1;
                  cp = np + 1;
                }
            }

          /* Read the flags.  */
          for (;;)
            {
              if (*cp == '\'')
                {
                  dp->flags |= FLAG_GROUP;
                  cp++;
                }
              else if (*cp == '-')
                {
                  dp->flags |= FLAG_LEFT;
                  cp++;
                }
              else if (*cp == '+')
                {
                  dp->flags |= FLAG_SHOWSIGN;
                  cp++;
                }
              else if (*cp == ' ')
                {
                  dp->flags |= FLAG_SPACE;
                  cp++;
                }
              else if (*cp == '#')
                {
                  dp->flags |= FLAG_ALT;
                  cp++;
                }
              else if (*cp == '0')
                {
                  dp->flags |= FLAG_ZERO;
                  cp++;
                }
              else
                break;
            }

          /* Parse the field width.  */
          if (*cp == '*')
            {
              dp->width_start = cp;
              cp++;
              dp->width_end = cp;
              if (max_width_length < 1)
                max_width_length = 1;

              /* Test for positional argument.  */
              if (*cp >= '0' && *cp <= '9')
                {
                  const CHAR_T *np;

                  for (np = cp; *np >= '0' && *np <= '9'; np++)
                    ;
                  if (*np == '$')
                    {
                      size_t n = 0;

                      for (np = cp; *np >= '0' && *np <= '9'; np++)
                        n = xsum (xtimes (n, 10), *np - '0');
                      if (n == 0)
                        /* Positional argument 0.  */
                        goto error;
                      if (size_overflow_p (n))
                        /* n too large, would lead to out of memory later.  */
                        goto error;
                      dp->width_arg_index = n - 1;
                      cp = np + 1;
                    }
                }
              if (dp->width_arg_index == ARG_NONE)
                {
                  dp->width_arg_index = arg_posn++;
                  if (dp->width_arg_index == ARG_NONE)
                    /* arg_posn wrapped around.  */
                    goto error;
                }
              REGISTER_ARG (dp->width_arg_index, TYPE_INT);
            }
          else if (*cp >= '0' && *cp <= '9')
            {
              size_t width_length;

              dp->width_start = cp;
              for (; *cp >= '0' && *cp <= '9'; cp++)
                ;
              dp->width_end = cp;
              width_length = dp->width_end - dp->width_start;
              if (max_width_length < width_length)
                max_width_length = width_length;
            }

          /* Parse the precision.  */
          if (*cp == '.')
            {
              cp++;
              if (*cp == '*')
                {
                  dp->precision_start = cp - 1;
                  cp++;
                  dp->precision_end = cp;
                  if (max_precision_length < 2)
                    max_precision_length = 2;

                  /* Test for positional argument.  */
                  if (*cp >= '0' && *cp <= '9')
                    {
                      const CHAR_T *np;

                      for (np = cp; *np >= '0' && *np <= '9'; np++)
                        ;
                      if (*np == '$')
                        {
                          size_t n = 0;

                          for (np = cp; *np >= '0' && *np <= '9'; np++)
                            n = xsum (xtimes (n, 10), *np - '0');
                          if (n == 0)
                            /* Positional argument 0.  */
                            goto error;
                          if (size_overflow_p (n))
                            /* n too large, would lead to out of memory
                               later.  */
                            goto error;
                          dp->precision_arg_index = n - 1;
                          cp = np + 1;
                        }
                    }
                  if (dp->precision_arg_index == ARG_NONE)
                    {
                      dp->precision_arg_index = arg_posn++;
                      if (dp->precision_arg_index == ARG_NONE)
                        /* arg_posn wrapped around.  */
                        goto error;
                    }
                  REGISTER_ARG (dp->precision_arg_index, TYPE_INT);
                }
              else
                {
                  size_t precision_length;

                  dp->precision_start = cp - 1;
                  for (; *cp >= '0' && *cp <= '9'; cp++)
                    ;
                  dp->precision_end = cp;
                  precision_length = dp->precision_end - dp->precision_start;
                  if (max_precision_length < precision_length)
                    max_precision_length = precision_length;
                }
            }

          {
            arg_type type;

            /* Parse argument type/size specifiers.  */
            {
              int flags = 0;

              for (;;)
                {
                  if (*cp == 'h')
                    {
                      flags |= (1 << (flags & 1));
                      cp++;
                    }
                  else if (*cp == 'L')
                    {
                      flags |= 4;
                      cp++;
                    }
                  else if (*cp == 'l')
                    {
                      flags += 8;
                      cp++;
                    }
#ifdef HAVE_INTMAX_T
                  else if (*cp == 'j')
                    {
                      if (sizeof (intmax_t) > sizeof (long))
                        {
                          /* intmax_t = long long */
                          flags += 16;
                        }
                      else if (sizeof (intmax_t) > sizeof (int))
                        {
                          /* intmax_t = long */
                          flags += 8;
                        }
                      cp++;
                    }
#endif
                  else if (*cp == 'z' || *cp == 'Z')
                    {
                      /* 'z' is standardized in ISO C 99, but glibc uses 'Z'
                         because the warning facility in gcc-2.95.2 understands
                         only 'Z' (see gcc-2.95.2/gcc/c-common.c:1784).  */
                      if (sizeof (size_t) > sizeof (long))
                        {
                          /* size_t = long long */
                          flags += 16;
                        }
                      else if (sizeof (size_t) > sizeof (int))
                        {
                          /* size_t = long */
                          flags += 8;
                        }
                      cp++;
                    }
                  else if (*cp == 't')
                    {
                      if (sizeof (ptrdiff_t) > sizeof (long))
                        {
                          /* ptrdiff_t = long long */
                          flags += 16;
                        }
                      else if (sizeof (ptrdiff_t) > sizeof (int))
                        {
                          /* ptrdiff_t = long */
                          flags += 8;
                        }
                      cp++;
                    }
                  else
                    break;
                }

              /* Read the conversion character.  */
              c = *cp++;
              switch (c)
                {
                case 'd': case 'i':
#ifdef HAVE_LONG_LONG
                  if (flags >= 16 || (flags & 4))
                    type = TYPE_LONGLONGINT;
                  else
#endif
                  if (flags >= 8)
                    type = TYPE_LONGINT;
                  else if (flags & 2)
                    type = TYPE_SCHAR;
                  else if (flags & 1)
                    type = TYPE_SHORT;
                  else
                    type = TYPE_INT;
                  break;
                case 'o': case 'u': case 'x': case 'X':
#ifdef HAVE_LONG_LONG
                  if (flags >= 16 || (flags & 4))
                    type = TYPE_ULONGLONGINT;
                  else
#endif
                  if (flags >= 8)
                    type = TYPE_ULONGINT;
                  else if (flags & 2)
                    type = TYPE_UCHAR;
                  else if (flags & 1)
                    type = TYPE_USHORT;
                  else
                    type = TYPE_UINT;
                  break;
                case 'f': case 'F': case 'e': case 'E': case 'g': case 'G':
                case 'a': case 'A':
#ifdef HAVE_LONG_DOUBLE
                  if (flags >= 16 || (flags & 4))
                    type = TYPE_LONGDOUBLE;
                  else
#endif
                  type = TYPE_DOUBLE;
                  break;
                case 'c':
                  if (flags >= 8)
#ifdef HAVE_WINT_T
                    type = TYPE_WIDE_CHAR;
#else
                    goto error;
#endif
                  else
                    type = TYPE_CHAR;
                  break;
#ifdef HAVE_WINT_T
                case 'C':
                  type = TYPE_WIDE_CHAR;
                  c = 'c';
                  break;
#endif
                case 's':
                  if (flags >= 8)
#ifdef HAVE_WCHAR_T
                    type = TYPE_WIDE_STRING;
#else
                    goto error;
#endif
                  else
                    type = TYPE_STRING;
                  break;
#ifdef HAVE_WCHAR_T
                case 'S':
                  type = TYPE_WIDE_STRING;
                  c = 's';
                  break;
#endif
                case 'p':
                  type = TYPE_POINTER;
                  break;
                case 'n':
#ifdef HAVE_LONG_LONG
                  if (flags >= 16 || (flags & 4))
                    type = TYPE_COUNT_LONGLONGINT_POINTER;
                  else
#endif
                  if (flags >= 8)
                    type = TYPE_COUNT_LONGINT_POINTER;
                  else if (flags & 2)
                    type = TYPE_COUNT_SCHAR_POINTER;
                  else if (flags & 1)
                    type = TYPE_COUNT_SHORT_POINTER;
                  else
                    type = TYPE_COUNT_INT_POINTER;
                  break;
                case '%':
                  type = TYPE_NONE;
                  break;
                default:
                  /* Unknown conversion character.  */
                  goto error;
                }
            }

            if (type != TYPE_NONE)
              {
                dp->arg_index = arg_index;
                if (dp->arg_index == ARG_NONE)
                  {
                    dp->arg_index = arg_posn++;
                    if (dp->arg_index == ARG_NONE)
                      /* arg_posn wrapped around.  */
                      goto error;
                  }
                REGISTER_ARG (dp->arg_index, type);
              }
            dp->conversion = c;
            dp->dir_end = cp;
          }

          d->count++;
          if (d->count >= d_allocated)
            {
              size_t memory_size;
              DIRECTIVE *memory;

              d_allocated = xtimes (d_allocated, 2);
              memory_size = xtimes (d_allocated, sizeof (DIRECTIVE));
              if (size_overflow_p (memory_size))
                /* Overflow, would lead to out of memory.  */
                goto error;
              memory = realloc (d->dir, memory_size);
              if (memory == NULL)
                /* Out of memory.  */
                goto error;
              d->dir = memory;
            }
        }
    }
  d->dir[d->count].dir_start = cp;

  d->max_width_length = max_width_length;
  d->max_precision_length = max_precision_length;
  return 0;

error:
  if (a->arg)
    free (a->arg);
  if (d->dir)
    free (d->dir);
  return -1;
}

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