← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/eggdrop/oneiric

« back to all changes in this revision

Viewing changes to src/compat/snprintf.c

  • Committer: Bazaar Package Importer
  • Author(s): Guilherme de S. Pastore
  • Date: 2004-06-17 09:15:28 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20040617091528-64rrw1sa33lkfhmh
Tags: 1.6.16-2
http://bugs.debian.org/254824
* Fixed typo on README.Debian
* Fixed hyphens in manual page
* Converted debian/rules to CDBS
* Set path to binary on example config file
* Changed LANGDIR on src/eggdrop.h (Closes: #254824)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/compat/snprintf.c
1
1
/*
2
2
 * snprintf.c - a portable implementation of snprintf and vsnprintf
3
3
 *
4
 
 * $Id: snprintf.c,v 1.5 2002/01/02 03:46:36 guppy Exp $
 
4
 * $Id: snprintf.c,v 1.20 2004/01/13 10:21:00 wcc Exp $
5
5
 */
6
6
/*
7
 
 * Portions Copyright (C) 2000, 2001, 2002 Eggheads Development Team
 
7
 * Portions Copyright (C) 2000, 2001, 2002, 2003, 2004 Eggheads Development Team
8
8
 *
9
9
 * This program is free software; you can redistribute it and/or
10
10
 * modify it under the terms of the GNU General Public License
98
98
#      include <std_args.h>
99
99
#    endif
100
100
#  endif
101
 
#  include <stdarg.h>
102
 
#  define HAVE_STDARGS          /* let's hope that works everywhere (mj) */
103
 
#  define VA_LOCAL_DECL va_list ap
104
 
#  define VA_START(f)   va_start(ap, f)
105
 
#  define VA_SHIFT(v,t) ;       /* no-op for ANSI */
106
 
#  define VA_END        va_end(ap)
 
101
#  define HAVE_STDARGS          /* let's hope that works everywhere (mj) */
 
102
#  define VA_LOCAL_DECL va_list ap
 
103
#  define VA_START(f)   va_start(ap, f)
 
104
#  define VA_SHIFT(v,t) ;       /* no-op for ANSI */
 
105
#  define VA_END        va_end(ap)
107
106
#else
108
107
#  include <varargs.h>
109
108
#  undef HAVE_STDARGS
110
 
#  define VA_LOCAL_DECL va_list ap
111
 
#  define VA_START(f)   va_start(ap)    /* f is ignored! */
112
 
#  define VA_SHIFT(v,t) v = va_arg(ap,t)
113
 
#  define VA_END        va_end(ap)
 
109
#  define VA_LOCAL_DECL va_list ap
 
110
#  define VA_START(f)   va_start(ap)    /* f is ignored! */
 
111
#  define VA_SHIFT(v,t) v = va_arg(ap,t)
 
112
#  define VA_END        va_end(ap)
114
113
#endif
115
114
 
116
115
#ifdef HAVE_LONG_DOUBLE
117
 
#define LDOUBLE long double
 
116
#define LDOUBLE long double
118
117
#else
119
 
#define LDOUBLE double
 
118
#define LDOUBLE double
120
119
#endif
121
120
 
122
 
static void dopr(char *buffer, size_t maxlen, const char *format,
123
 
                 va_list args);
124
 
static void fmtstr(char *buffer, size_t * currlen, size_t maxlen,
125
 
                   char *value, int flags, int min, int max);
126
 
static void fmtint(char *buffer, size_t * currlen, size_t maxlen,
127
 
                   long value, int base, int min, int max, int flags);
128
 
static void fmtfp(char *buffer, size_t * currlen, size_t maxlen,
129
 
                  LDOUBLE fvalue, int min, int max, int flags);
130
 
static void dopr_outch(char *buffer, size_t * currlen, size_t maxlen,
131
 
                       char c);
 
121
static void dopr(char *buffer, size_t maxlen, const char *format, va_list args);
 
122
static void fmtstr(char *buffer, size_t *currlen, size_t maxlen, char *value,
 
123
                   int flags, int min, int max);
 
124
static void fmtint(char *buffer, size_t *currlen, size_t maxlen, long value,
 
125
                   int base, int min, int max, int flags);
 
126
static void fmtfp(char *buffer, size_t *currlen, size_t maxlen, LDOUBLE fvalue,
 
127
                  int min, int max, int flags);
 
128
static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c);
132
129
 
133
130
/*
134
131
 * dopr(): poor man's version of doprintf
145
142
#define DP_S_DONE    7
146
143
 
147
144
/* format flags - Bits */
148
 
#define DP_F_MINUS      (1 << 0)
149
 
#define DP_F_PLUS       (1 << 1)
150
 
#define DP_F_SPACE      (1 << 2)
151
 
#define DP_F_NUM        (1 << 3)
152
 
#define DP_F_ZERO       (1 << 4)
153
 
#define DP_F_UP         (1 << 5)
154
 
#define DP_F_UNSIGNED   (1 << 6)
 
145
#define DP_F_MINUS      (1 << 0)
 
146
#define DP_F_PLUS       (1 << 1)
 
147
#define DP_F_SPACE      (1 << 2)
 
148
#define DP_F_NUM        (1 << 3)
 
149
#define DP_F_ZERO       (1 << 4)
 
150
#define DP_F_UP         (1 << 5)
 
151
#define DP_F_UNSIGNED   (1 << 6)
155
152
 
156
153
/* Conversion Flags */
157
154
#define DP_C_SHORT   1
159
156
#define DP_C_LDOUBLE 3
160
157
 
161
158
#define char_to_int(p) (p - '0')
 
159
 
 
160
#ifdef MAX
 
161
#  undef MAX
 
162
#endif
162
163
#define MAX(p,q) ((p >= q) ? p : q)
163
164
 
164
 
static void dopr(char *buffer, size_t maxlen, const char *format,
165
 
                 va_list args)
 
165
static void dopr(char *buffer, size_t maxlen, const char *format, va_list args)
166
166
{
167
167
  char ch;
168
168
  long value;
187
187
    switch (state) {
188
188
    case DP_S_DEFAULT:
189
189
      if (ch == '%')
190
 
        state = DP_S_FLAGS;
 
190
        state = DP_S_FLAGS;
191
191
      else
192
 
        dopr_outch(buffer, &currlen, maxlen, ch);
 
192
        dopr_outch(buffer, &currlen, maxlen, ch);
193
193
      ch = *format++;
194
194
      break;
195
195
    case DP_S_FLAGS:
196
196
      switch (ch) {
197
197
      case '-':
198
 
        flags |= DP_F_MINUS;
199
 
        ch = *format++;
200
 
        break;
 
198
        flags |= DP_F_MINUS;
 
199
        ch = *format++;
 
200
        break;
201
201
      case '+':
202
 
        flags |= DP_F_PLUS;
203
 
        ch = *format++;
204
 
        break;
 
202
        flags |= DP_F_PLUS;
 
203
        ch = *format++;
 
204
        break;
205
205
      case ' ':
206
 
        flags |= DP_F_SPACE;
207
 
        ch = *format++;
208
 
        break;
 
206
        flags |= DP_F_SPACE;
 
207
        ch = *format++;
 
208
        break;
209
209
      case '#':
210
 
        flags |= DP_F_NUM;
211
 
        ch = *format++;
212
 
        break;
 
210
        flags |= DP_F_NUM;
 
211
        ch = *format++;
 
212
        break;
213
213
      case '0':
214
 
        flags |= DP_F_ZERO;
215
 
        ch = *format++;
216
 
        break;
 
214
        flags |= DP_F_ZERO;
 
215
        ch = *format++;
 
216
        break;
217
217
      default:
218
 
        state = DP_S_MIN;
219
 
        break;
 
218
        state = DP_S_MIN;
 
219
        break;
220
220
      }
221
221
      break;
222
222
    case DP_S_MIN:
223
 
      if (isdigit(ch)) {
224
 
        min = 10 * min + char_to_int(ch);
225
 
        ch = *format++;
 
223
      if (egg_isdigit(ch)) {
 
224
        min = 10 * min + char_to_int(ch);
 
225
        ch = *format++;
226
226
      } else if (ch == '*') {
227
 
        min = va_arg(args, int);
228
 
        ch = *format++;
229
 
        state = DP_S_DOT;
 
227
        min = va_arg(args, int);
 
228
 
 
229
        ch = *format++;
 
230
        state = DP_S_DOT;
230
231
      } else
231
 
        state = DP_S_DOT;
 
232
        state = DP_S_DOT;
232
233
      break;
233
234
    case DP_S_DOT:
234
235
      if (ch == '.') {
235
 
        state = DP_S_MAX;
236
 
        ch = *format++;
 
236
        state = DP_S_MAX;
 
237
        ch = *format++;
237
238
      } else
238
 
        state = DP_S_MOD;
 
239
        state = DP_S_MOD;
239
240
      break;
240
241
    case DP_S_MAX:
241
 
      if (isdigit(ch)) {
242
 
        if (max < 0)
243
 
          max = 0;
244
 
        max = 10 * max + char_to_int(ch);
245
 
        ch = *format++;
 
242
      if (egg_isdigit(ch)) {
 
243
        if (max < 0)
 
244
          max = 0;
 
245
        max = 10 * max + char_to_int(ch);
 
246
        ch = *format++;
246
247
      } else if (ch == '*') {
247
 
        max = va_arg(args, int);
248
 
        ch = *format++;
249
 
        state = DP_S_MOD;
 
248
        max = va_arg(args, int);
 
249
 
 
250
        ch = *format++;
 
251
        state = DP_S_MOD;
250
252
      } else
251
 
        state = DP_S_MOD;
 
253
        state = DP_S_MOD;
252
254
      break;
253
255
    case DP_S_MOD:
254
256
      /* Currently, we don't support Long Long, bummer */
255
257
      switch (ch) {
256
258
      case 'h':
257
 
        cflags = DP_C_SHORT;
258
 
        ch = *format++;
259
 
        break;
 
259
        cflags = DP_C_SHORT;
 
260
        ch = *format++;
 
261
        break;
260
262
      case 'l':
261
 
        cflags = DP_C_LONG;
262
 
        ch = *format++;
263
 
        break;
 
263
        cflags = DP_C_LONG;
 
264
        ch = *format++;
 
265
        break;
264
266
      case 'L':
265
 
        cflags = DP_C_LDOUBLE;
266
 
        ch = *format++;
267
 
        break;
 
267
        cflags = DP_C_LDOUBLE;
 
268
        ch = *format++;
 
269
        break;
268
270
      default:
269
 
        break;
 
271
        break;
270
272
      }
271
273
      state = DP_S_CONV;
272
274
      break;
274
276
      switch (ch) {
275
277
      case 'd':
276
278
      case 'i':
277
 
        if (cflags == DP_C_SHORT)
278
 
          value = va_arg(args, short int);
279
 
        else if (cflags == DP_C_LONG)
280
 
          value = va_arg(args, long int);
281
 
        else
282
 
          value = va_arg(args, int);
283
 
        fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags);
284
 
        break;
 
279
        if (cflags == DP_C_SHORT)
 
280
          value = va_arg(args, short int);
 
281
 
 
282
        else if (cflags == DP_C_LONG)
 
283
          value = va_arg(args, long int);
 
284
 
 
285
        else
 
286
          value = va_arg(args, int);
 
287
 
 
288
        fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags);
 
289
        break;
285
290
      case 'o':
286
 
        flags |= DP_F_UNSIGNED;
287
 
        if (cflags == DP_C_SHORT)
288
 
          value = va_arg(args, unsigned short int);
289
 
        else if (cflags == DP_C_LONG)
290
 
          value = va_arg(args, unsigned long int);
291
 
        else
292
 
          value = va_arg(args, unsigned int);
293
 
        fmtint(buffer, &currlen, maxlen, value, 8, min, max, flags);
294
 
        break;
 
291
        flags |= DP_F_UNSIGNED;
 
292
        if (cflags == DP_C_SHORT)
 
293
          value = va_arg(args, unsigned short int);
 
294
 
 
295
        else if (cflags == DP_C_LONG)
 
296
          value = va_arg(args, unsigned long int);
 
297
 
 
298
        else
 
299
          value = va_arg(args, unsigned int);
 
300
 
 
301
        fmtint(buffer, &currlen, maxlen, value, 8, min, max, flags);
 
302
        break;
295
303
      case 'u':
296
 
        flags |= DP_F_UNSIGNED;
297
 
        if (cflags == DP_C_SHORT)
298
 
          value = va_arg(args, unsigned short int);
299
 
        else if (cflags == DP_C_LONG)
300
 
          value = va_arg(args, unsigned long int);
301
 
        else
302
 
          value = va_arg(args, unsigned int);
303
 
        fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags);
304
 
        break;
 
304
        flags |= DP_F_UNSIGNED;
 
305
        if (cflags == DP_C_SHORT)
 
306
          value = va_arg(args, unsigned short int);
 
307
 
 
308
        else if (cflags == DP_C_LONG)
 
309
          value = va_arg(args, unsigned long int);
 
310
 
 
311
        else
 
312
          value = va_arg(args, unsigned int);
 
313
 
 
314
        fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags);
 
315
        break;
305
316
      case 'X':
306
 
        flags |= DP_F_UP;
 
317
        flags |= DP_F_UP;
307
318
      case 'x':
308
 
        flags |= DP_F_UNSIGNED;
309
 
        if (cflags == DP_C_SHORT)
310
 
          value = va_arg(args, unsigned short int);
311
 
        else if (cflags == DP_C_LONG)
312
 
          value = va_arg(args, unsigned long int);
313
 
        else
314
 
          value = va_arg(args, unsigned int);
315
 
        fmtint(buffer, &currlen, maxlen, value, 16, min, max, flags);
316
 
        break;
 
319
        flags |= DP_F_UNSIGNED;
 
320
        if (cflags == DP_C_SHORT)
 
321
          value = va_arg(args, unsigned short int);
 
322
 
 
323
        else if (cflags == DP_C_LONG)
 
324
          value = va_arg(args, unsigned long int);
 
325
 
 
326
        else
 
327
          value = va_arg(args, unsigned int);
 
328
 
 
329
        fmtint(buffer, &currlen, maxlen, value, 16, min, max, flags);
 
330
        break;
317
331
      case 'f':
318
 
        if (cflags == DP_C_LDOUBLE)
319
 
          fvalue = va_arg(args, LDOUBLE);
320
 
        else
321
 
          fvalue = va_arg(args, double);
322
 
        /* um, floating point? */
323
 
        fmtfp(buffer, &currlen, maxlen, fvalue, min, max, flags);
324
 
        break;
 
332
        if (cflags == DP_C_LDOUBLE)
 
333
          fvalue = va_arg(args, LDOUBLE);
 
334
        else
 
335
          fvalue = va_arg(args, double);
 
336
 
 
337
        /* um, floating point? */
 
338
        fmtfp(buffer, &currlen, maxlen, fvalue, min, max, flags);
 
339
        break;
325
340
      case 'E':
326
 
        flags |= DP_F_UP;
 
341
        flags |= DP_F_UP;
327
342
      case 'e':
328
 
        if (cflags == DP_C_LDOUBLE)
329
 
          fvalue = va_arg(args, LDOUBLE);
330
 
        else
331
 
          fvalue = va_arg(args, double);
332
 
        break;
 
343
        if (cflags == DP_C_LDOUBLE)
 
344
          fvalue = va_arg(args, LDOUBLE);
 
345
        else
 
346
          fvalue = va_arg(args, double);
 
347
 
 
348
        break;
333
349
      case 'G':
334
 
        flags |= DP_F_UP;
 
350
        flags |= DP_F_UP;
335
351
      case 'g':
336
 
        if (cflags == DP_C_LDOUBLE)
337
 
          fvalue = va_arg(args, LDOUBLE);
338
 
        else
339
 
          fvalue = va_arg(args, double);
340
 
        break;
 
352
        if (cflags == DP_C_LDOUBLE)
 
353
          fvalue = va_arg(args, LDOUBLE);
 
354
        else
 
355
          fvalue = va_arg(args, double);
 
356
 
 
357
        break;
341
358
      case 'c':
342
 
        dopr_outch(buffer, &currlen, maxlen, va_arg(args, int));
343
 
        break;
 
359
        dopr_outch(buffer, &currlen, maxlen, va_arg(args, int));
 
360
 
 
361
        break;
344
362
      case 's':
345
 
        strvalue = va_arg(args, char *);
346
 
        if (max < 0)
347
 
          max = maxlen;         /* ie, no max */
348
 
        fmtstr(buffer, &currlen, maxlen, strvalue, flags, min, max);
349
 
        break;
 
363
        strvalue = va_arg(args, char *);
 
364
 
 
365
        if (max < 0)
 
366
          max = maxlen;         /* ie, no max */
 
367
        fmtstr(buffer, &currlen, maxlen, strvalue, flags, min, max);
 
368
        break;
350
369
      case 'p':
351
 
        strvalue = va_arg(args, void *);
352
 
        fmtint(buffer, &currlen, maxlen, (long) strvalue, 16, min, max,
353
 
               flags);
354
 
        break;
 
370
        strvalue = va_arg(args, void *);
 
371
 
 
372
        fmtint(buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
 
373
        break;
355
374
      case 'n':
356
 
        if (cflags == DP_C_SHORT) {
357
 
          short int *num;
358
 
          num = va_arg(args, short int *);
359
 
          *num = currlen;
360
 
        } else if (cflags == DP_C_LONG) {
361
 
          long int *num;
362
 
          num = va_arg(args, long int *);
363
 
          *num = currlen;
364
 
        } else {
365
 
          int *num;
366
 
          num = va_arg(args, int *);
367
 
          *num = currlen;
368
 
        }
369
 
        break;
 
375
        if (cflags == DP_C_SHORT) {
 
376
          short int *num;
 
377
          num = va_arg(args, short int *);
 
378
 
 
379
          *num = currlen;
 
380
        } else if (cflags == DP_C_LONG) {
 
381
          long int *num;
 
382
          num = va_arg(args, long int *);
 
383
 
 
384
          *num = currlen;
 
385
        } else {
 
386
          int *num;
 
387
          num = va_arg(args, int *);
 
388
 
 
389
          *num = currlen;
 
390
        }
 
391
        break;
370
392
      case '%':
371
 
        dopr_outch(buffer, &currlen, maxlen, ch);
372
 
        break;
 
393
        dopr_outch(buffer, &currlen, maxlen, ch);
 
394
        break;
373
395
      case 'w':
374
 
        /* not supported yet, treat as next char */
375
 
        ch = *format++;
376
 
        break;
 
396
        /* not supported yet, treat as next char */
 
397
        ch = *format++;
 
398
        break;
377
399
      default:
378
 
        /* Unknown, skip */
379
 
        break;
 
400
        /* Unknown, skip */
 
401
        break;
380
402
      }
381
403
      ch = *format++;
382
404
      state = DP_S_DEFAULT;
387
409
      break;
388
410
    default:
389
411
      /* hmm? */
390
 
      break;                    /* some picky compilers need this */
 
412
      break;                    /* some picky compilers need this */
391
413
    }
392
414
  }
393
415
  if (currlen < maxlen - 1)
396
418
    buffer[maxlen - 1] = '\0';
397
419
}
398
420
 
399
 
static void fmtstr(char *buffer, size_t * currlen, size_t maxlen,
400
 
                   char *value, int flags, int min, int max)
 
421
static void fmtstr(char *buffer, size_t *currlen, size_t maxlen,
 
422
                   char *value, int flags, int min, int max)
401
423
{
402
 
  int padlen,
403
 
      strln;                    /* amount to pad */
 
424
  int padlen, strln;            /* amount to pad */
404
425
  int cnt = 0;
405
426
 
406
427
  if (value == 0) {
407
428
    value = "<NULL>";
408
429
  }
409
430
 
410
 
  for (strln = 0; value[strln]; ++strln);       /* strlen */
 
431
  for (strln = 0; value[strln]; ++strln);       /* strlen */
411
432
  padlen = min - strln;
412
433
  if (padlen < 0)
413
434
    padlen = 0;
414
435
  if (flags & DP_F_MINUS)
415
 
    padlen = -padlen;           /* Left Justify */
 
436
    padlen = -padlen;           /* Left Justify */
416
437
 
417
438
  while ((padlen > 0) && (cnt < max)) {
418
439
    dopr_outch(buffer, currlen, maxlen, ' ');
432
453
 
433
454
/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
434
455
 
435
 
static void fmtint(char *buffer, size_t * currlen, size_t maxlen,
436
 
                   long value, int base, int min, int max, int flags)
 
456
static void fmtint(char *buffer, size_t *currlen, size_t maxlen,
 
457
                   long value, int base, int min, int max, int flags)
437
458
{
438
459
  int signvalue = 0;
439
460
  unsigned long uvalue;
440
461
  char convert[20];
441
462
  int place = 0;
442
 
  int spadlen = 0;              /* amount to space pad */
443
 
  int zpadlen = 0;              /* amount to zero pad */
 
463
  int spadlen = 0;              /* amount to space pad */
 
464
  int zpadlen = 0;              /* amount to zero pad */
444
465
  int caps = 0;
445
466
 
446
467
  if (max < 0)
452
473
    if (value < 0) {
453
474
      signvalue = '-';
454
475
      uvalue = -value;
455
 
    } else if (flags & DP_F_PLUS)       /* Do a sign (+/i) */
 
476
    } else if (flags & DP_F_PLUS) /* Do a sign (+/i) */
456
477
      signvalue = '+';
457
478
    else if (flags & DP_F_SPACE)
458
479
      signvalue = ' ';
459
480
  }
460
481
 
461
482
  if (flags & DP_F_UP)
462
 
    caps = 1;                   /* Should characters be upper case? */
 
483
    caps = 1;                   /* Should characters be upper case? */
463
484
 
464
485
  do {
465
486
    convert[place++] = (caps ? "0123456789ABCDEF" : "0123456789abcdef")
466
 
        [uvalue % (unsigned) base];
 
487
      [uvalue % (unsigned) base];
467
488
    uvalue = (uvalue / (unsigned) base);
468
489
  }
469
490
  while (uvalue && (place < 20));
482
503
    spadlen = 0;
483
504
  }
484
505
  if (flags & DP_F_MINUS)
485
 
    spadlen = -spadlen;         /* Left Justifty */
 
506
    spadlen = -spadlen;         /* Left Justifty */
486
507
 
487
508
#ifdef DEBUG_SNPRINTF
488
509
  dprint(1,
489
 
         (debugfile, "zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
490
 
          zpadlen, spadlen, min, max, place));
 
510
         (debugfile, "zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
 
511
          zpadlen, spadlen, min, max, place));
491
512
#endif
492
513
 
493
514
  /* Spaces */
553
574
  return intpart;
554
575
}
555
576
 
556
 
static void fmtfp(char *buffer, size_t * currlen, size_t maxlen,
557
 
                  LDOUBLE fvalue, int min, int max, int flags)
 
577
static void fmtfp(char *buffer, size_t *currlen, size_t maxlen,
 
578
                  LDOUBLE fvalue, int min, int max, int flags)
558
579
{
559
580
  int signvalue = 0;
560
581
  LDOUBLE ufvalue;
562
583
  char fconvert[20];
563
584
  int iplace = 0;
564
585
  int fplace = 0;
565
 
  int padlen = 0;               /* amount to pad */
 
586
  int padlen = 0;               /* amount to pad */
566
587
  int zpadlen = 0;
567
588
  int caps = 0;
568
589
  long intpart;
579
600
 
580
601
  if (fvalue < 0)
581
602
    signvalue = '-';
582
 
  else if (flags & DP_F_PLUS)   /* Do a sign (+/i) */
 
603
  else if (flags & DP_F_PLUS)   /* Do a sign (+/i) */
583
604
    signvalue = '+';
584
605
  else if (flags & DP_F_SPACE)
585
606
    signvalue = ' ';
586
607
 
587
608
#if 0
588
609
  if (flags & DP_F_UP)
589
 
    caps = 1;                   /* Should characters be upper case? */
 
610
    caps = 1;                   /* Should characters be upper case? */
590
611
#endif
591
612
 
592
613
  intpart = ufvalue;
611
632
  /* Convert integer part */
612
633
  do {
613
634
    iconvert[iplace++] =
614
 
        (caps ? "0123456789ABCDEF" : "0123456789abcdef")[intpart % 10];
 
635
      (caps ? "0123456789ABCDEF" : "0123456789abcdef")[intpart % 10];
615
636
    intpart = (intpart / 10);
616
637
  }
617
638
  while (intpart && (iplace < 20));
622
643
  /* Convert fractional part */
623
644
  do {
624
645
    fconvert[fplace++] =
625
 
        (caps ? "0123456789ABCDEF" : "0123456789abcdef")[fracpart % 10];
 
646
      (caps ? "0123456789ABCDEF" : "0123456789abcdef")[fracpart % 10];
626
647
    fracpart = (fracpart / 10);
627
648
  }
628
649
  while (fracpart && (fplace < 20));
638
659
  if (padlen < 0)
639
660
    padlen = 0;
640
661
  if (flags & DP_F_MINUS)
641
 
    padlen = -padlen;           /* Left Justifty */
 
662
    padlen = -padlen;           /* Left Justifty */
642
663
 
643
664
  if ((flags & DP_F_ZERO) && (padlen > 0)) {
644
665
    if (signvalue) {
683
704
  }
684
705
}
685
706
 
686
 
static void dopr_outch(char *buffer, size_t * currlen, size_t maxlen,
687
 
                       char c)
 
707
static void dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c)
688
708
{
689
709
  if (*currlen < maxlen)
690
710
    buffer[(*currlen)++] = c;
696
716
  dopr(str, count, fmt, args);
697
717
  return (strlen(str));
698
718
}
699
 
#endif                          /* !HAVE_VSNPRINTF */
 
719
#endif /* !HAVE_VSNPRINTF */
700
720
 
701
721
#ifndef HAVE_SNPRINTF
702
722
#  ifdef HAVE_STDARGS
703
723
int egg_snprintf(char *str, size_t count, const char *fmt, ...)
704
724
#  else
705
 
int egg_snprintf(va_alist) va_dcl
 
725
int egg_snprintf(va_alist)
 
726
va_dcl
706
727
#  endif
707
728
{
708
729
#  ifndef HAVE_STDARGS
714
735
 
715
736
  VA_START(fmt);
716
737
  VA_SHIFT(str, char *);
 
738
 
717
739
  VA_SHIFT(count, size_t);
718
740
  VA_SHIFT(fmt, char *);
 
741
 
719
742
  (void) egg_vsnprintf(str, count, fmt, ap);
720
743
  VA_END;
721
744
  return (strlen(str));
722
745
}
723
 
#endif                          /* !HAVE_SNPRINTF */
 
746
#endif /* !HAVE_SNPRINTF */