← Back to branch summary

~ubuntu-branches/ubuntu/raring/workrave/raring

« back to all changes in this revision

Viewing changes to intl/printf-parse.c

  • Committer: Package Import Robot
  • Author(s): Francois Marier, Francois Marier, Jordi Mallach
  • Date: 2012-05-28 11:29:40 UTC
  • mfrom: (1.2.9)
  • Revision ID: package-import@ubuntu.com-20120528112940-bbbsjkk30fom9s8x
Tags: 1.9.909+abc941eb70-1
http://bugs.debian.org/642514
http://bugs.debian.org/666100
[ Francois Marier ]
* New upstream snapshot
  - Drop leak-fix patch (applied upstream)
  - Document how the tarball is built in README.source
* Build GNOME applets and use gsettings
* Massive update of Build-Depends as per configure.ac

* Update README.source with snapshot instructions
* Switch to machine-readable copyright file
* Update alioth git repo links
* Bump debhelper version to 9
* Bump Standards-Version to 3.9.3

[ Jordi Mallach ]
* Avoid references to GNU/Linux in manpage.
* Drop build dependency on libgnet-dev, it's obsolete and unneeded.
* Add myself to Uploaders.
* Rewrite d/rules into dh style.
  - Move all install tweaks to .install files.
  - Install manpages using dh_installman.
* As a side effect, the package installs arch-dependant data in the
  arch triplet directory; add the required Pre-Depends for m-a-support.
* Bring back GNOME Panel applet (for GNOME 3 fallback mode) and ship the
  new GNOME Shell extension (closes: #642514, #666100).
* Add private_dirs.patch: move libworkrave-private and GObject
  Introspection files to a private dir, so they are really out of the
  way, but disable it for now as it breaks the Shell extension.
* Move typelib out of the triplet dir as gobject-introspection is not
  M-A ready yet.
* Enable dh_autoreconf for the above patches.
* Add lintian overrides.
* Add necessary Breaks/Replaces as the xpm icon has moved to workrave-data.
* Prefix all debhelper files with package name.
* Suggest gnome-shell and gnome-panel.

Show diffs side-by-side

added added

removed removed

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