Minor corrections.
[openssl.git] / crypto / bio / b_print.c
1 /* crypto/bio/b_print.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  * 
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  * 
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  * 
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from 
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  * 
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  * 
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58
59 /* 
60  * Stolen from tjh's ssl/ssl_trc.c stuff.
61  */
62
63 #include <stdio.h>
64 #include <stdarg.h>
65 #include <string.h>
66 #include <ctype.h>
67 #include <assert.h>
68 #include <limits.h>
69 #include "cryptlib.h"
70 #ifndef NO_SYS_TYPES_H
71 #include <sys/types.h>
72 #endif
73 #include <openssl/bio.h>
74
75 #ifdef BN_LLONG
76 # ifndef HAVE_LONG_LONG
77 #  define HAVE_LONG_LONG 1
78 # endif
79 #endif
80
81 static void dopr (char *buffer, size_t maxlen, size_t *retlen,
82         const char *format, va_list args);
83 #ifdef USE_ALLOCATING_PRINT
84 static void doapr (char **buffer, size_t *retlen,
85         const char *format, va_list args);
86 #endif
87
88 int BIO_printf (BIO *bio, ...)
89         {
90         va_list args;
91         char *format;
92         int ret;
93         size_t retlen;
94 #ifdef USE_ALLOCATING_PRINT
95         char *hugebuf;
96 #else
97         MS_STATIC char hugebuf[1024*2]; /* 10k in one chunk is the limit */
98 #endif
99
100         va_start(args, bio);
101         format=va_arg(args, char *);
102
103 #ifndef USE_ALLOCATING_PRINT
104         hugebuf[0]='\0';
105         dopr(hugebuf, sizeof(hugebuf), &retlen, format, args);
106 #else
107         hugebuf = NULL;
108         CRYPTO_push_info("doapr()");
109         doapr(&hugebuf, &retlen, format, args);
110         if (hugebuf)
111                 {
112 #endif
113                 ret=BIO_write(bio, hugebuf, (int)retlen);
114
115 #ifdef USE_ALLOCATING_PRINT
116                 Free(hugebuf);
117                 }
118         CRYPTO_pop_info();
119 #endif
120         va_end(args);
121         return(ret);
122         }
123
124 /*
125  * Copyright Patrick Powell 1995
126  * This code is based on code written by Patrick Powell <papowell@astart.com>
127  * It may be used for any purpose as long as this notice remains intact
128  * on all source code distributions.
129  */
130
131 /*
132  * This code contains numerious changes and enhancements which were
133  * made by lots of contributors over the last years to Patrick Powell's
134  * original code:
135  *
136  * o Patrick Powell <papowell@astart.com>      (1995)
137  * o Brandon Long <blong@fiction.net>          (1996, for Mutt)
138  * o Thomas Roessler <roessler@guug.de>        (1998, for Mutt)
139  * o Michael Elkins <me@cs.hmc.edu>            (1998, for Mutt)
140  * o Andrew Tridgell <tridge@samba.org>        (1998, for Samba)
141  * o Luke Mewburn <lukem@netbsd.org>           (1999, for LukemFTP)
142  * o Ralf S. Engelschall <rse@engelschall.com> (1999, for Pth)
143  */
144
145 #if HAVE_LONG_DOUBLE
146 #define LDOUBLE long double
147 #else
148 #define LDOUBLE double
149 #endif
150
151 #if HAVE_LONG_LONG
152 #define LLONG long long
153 #else
154 #define LLONG long
155 #endif
156
157 static void fmtstr     (void (*)(char **, size_t *, size_t *, int),
158                         char **, size_t *, size_t *, const char *, int, int,
159                         int);
160 static void fmtint     (void (*)(char **, size_t *, size_t *, int),
161                         char **, size_t *, size_t *, LLONG, int, int, int, int);
162 static void fmtfp      (void (*)(char **, size_t *, size_t *, int),
163                         char **, size_t *, size_t *, LDOUBLE, int, int, int);
164 #ifndef USE_ALLOCATING_PRINT
165 static int dopr_isbig (size_t, size_t);
166 static int dopr_copy (size_t);
167 static void dopr_outch (char **, size_t *, size_t *, int);
168 #else
169 static int doapr_isbig (size_t, size_t);
170 static int doapr_copy (size_t);
171 static void doapr_outch (char **, size_t *, size_t *, int);
172 #endif
173 static void _dopr(void (*)(char **, size_t *, size_t *, int),
174                   int (*)(size_t, size_t), int (*)(size_t),
175                   char **buffer, size_t *maxlen, size_t *retlen,
176                   const char *format, va_list args);
177
178 /* format read states */
179 #define DP_S_DEFAULT    0
180 #define DP_S_FLAGS      1
181 #define DP_S_MIN        2
182 #define DP_S_DOT        3
183 #define DP_S_MAX        4
184 #define DP_S_MOD        5
185 #define DP_S_CONV       6
186 #define DP_S_DONE       7
187
188 /* format flags - Bits */
189 #define DP_F_MINUS      (1 << 0)
190 #define DP_F_PLUS       (1 << 1)
191 #define DP_F_SPACE      (1 << 2)
192 #define DP_F_NUM        (1 << 3)
193 #define DP_F_ZERO       (1 << 4)
194 #define DP_F_UP         (1 << 5)
195 #define DP_F_UNSIGNED   (1 << 6)
196
197 /* conversion flags */
198 #define DP_C_SHORT      1
199 #define DP_C_LONG       2
200 #define DP_C_LDOUBLE    3
201 #define DP_C_LLONG      4
202
203 /* some handy macros */
204 #define char_to_int(p) (p - '0')
205 #define MAX(p,q) ((p >= q) ? p : q)
206
207 #ifndef USE_ALLOCATING_PRINT
208 static void
209 dopr(
210     char *buffer,
211     size_t maxlen,
212     size_t *retlen,
213     const char *format,
214     va_list args)
215 {
216     _dopr(dopr_outch, dopr_isbig, dopr_copy,
217           &buffer, &maxlen, retlen, format, args);
218 }
219
220 #else
221 static void
222 doapr(
223     char **buffer,
224     size_t *retlen,
225     const char *format,
226     va_list args)
227 {
228     size_t dummy_maxlen = 0;
229     _dopr(doapr_outch, doapr_isbig, doapr_copy,
230           buffer, &dummy_maxlen, retlen, format, args);
231 }
232 #endif
233
234 static void
235 _dopr(
236     void (*outch_fn)(char **, size_t *, size_t *, int),
237     int (*isbig_fn)(size_t, size_t),
238     int (*copy_fn)(size_t),
239     char **buffer,
240     size_t *maxlen,
241     size_t *retlen,
242     const char *format,
243     va_list args)
244 {
245     char ch;
246     LLONG value;
247     LDOUBLE fvalue;
248     char *strvalue;
249     int min;
250     int max;
251     int state;
252     int flags;
253     int cflags;
254     size_t currlen;
255
256     state = DP_S_DEFAULT;
257     flags = currlen = cflags = min = 0;
258     max = -1;
259     ch = *format++;
260
261     while (state != DP_S_DONE) {
262         if ((ch == '\0') || (*isbig_fn)(currlen, *maxlen))
263             state = DP_S_DONE;
264
265         switch (state) {
266         case DP_S_DEFAULT:
267             if (ch == '%')
268                 state = DP_S_FLAGS;
269             else
270                 (*outch_fn)(buffer, &currlen, maxlen, ch);
271             ch = *format++;
272             break;
273         case DP_S_FLAGS:
274             switch (ch) {
275             case '-':
276                 flags |= DP_F_MINUS;
277                 ch = *format++;
278                 break;
279             case '+':
280                 flags |= DP_F_PLUS;
281                 ch = *format++;
282                 break;
283             case ' ':
284                 flags |= DP_F_SPACE;
285                 ch = *format++;
286                 break;
287             case '#':
288                 flags |= DP_F_NUM;
289                 ch = *format++;
290                 break;
291             case '0':
292                 flags |= DP_F_ZERO;
293                 ch = *format++;
294                 break;
295             default:
296                 state = DP_S_MIN;
297                 break;
298             }
299             break;
300         case DP_S_MIN:
301             if (isdigit((unsigned char)ch)) {
302                 min = 10 * min + char_to_int(ch);
303                 ch = *format++;
304             } else if (ch == '*') {
305                 min = va_arg(args, int);
306                 ch = *format++;
307                 state = DP_S_DOT;
308             } else
309                 state = DP_S_DOT;
310             break;
311         case DP_S_DOT:
312             if (ch == '.') {
313                 state = DP_S_MAX;
314                 ch = *format++;
315             } else
316                 state = DP_S_MOD;
317             break;
318         case DP_S_MAX:
319             if (isdigit((unsigned char)ch)) {
320                 if (max < 0)
321                     max = 0;
322                 max = 10 * max + char_to_int(ch);
323                 ch = *format++;
324             } else if (ch == '*') {
325                 max = va_arg(args, int);
326                 ch = *format++;
327                 state = DP_S_MOD;
328             } else
329                 state = DP_S_MOD;
330             break;
331         case DP_S_MOD:
332             switch (ch) {
333             case 'h':
334                 cflags = DP_C_SHORT;
335                 ch = *format++;
336                 break;
337             case 'l':
338                 if (*format == 'l') {
339                     cflags = DP_C_LLONG;
340                     format++;
341                 } else
342                     cflags = DP_C_LONG;
343                 ch = *format++;
344                 break;
345             case 'q':
346                 cflags = DP_C_LLONG;
347                 ch = *format++;
348                 break;
349             case 'L':
350                 cflags = DP_C_LDOUBLE;
351                 ch = *format++;
352                 break;
353             default:
354                 break;
355             }
356             state = DP_S_CONV;
357             break;
358         case DP_S_CONV:
359             switch (ch) {
360             case 'd':
361             case 'i':
362                 switch (cflags) {
363                 case DP_C_SHORT:
364                     value = (short int)va_arg(args, int);
365                     break;
366                 case DP_C_LONG:
367                     value = va_arg(args, long int);
368                     break;
369                 case DP_C_LLONG:
370                     value = va_arg(args, LLONG);
371                     break;
372                 default:
373                     value = va_arg(args, int);
374                     break;
375                 }
376                 fmtint(outch_fn, buffer, &currlen, maxlen,
377                        value, 10, min, max, flags);
378                 break;
379             case 'X':
380                 flags |= DP_F_UP;
381                 /* FALLTHROUGH */
382             case 'x':
383             case 'o':
384             case 'u':
385                 flags |= DP_F_UNSIGNED;
386                 switch (cflags) {
387                 case DP_C_SHORT:
388                     value = (unsigned short int)va_arg(args, unsigned int);
389                     break;
390                 case DP_C_LONG:
391                     value = (LLONG) va_arg(args,
392                         unsigned long int);
393                     break;
394                 case DP_C_LLONG:
395                     value = va_arg(args, unsigned LLONG);
396                     break;
397                 default:
398                     value = (LLONG) va_arg(args,
399                         unsigned int);
400                     break;
401                 }
402                 fmtint(outch_fn, buffer, &currlen, maxlen, value,
403                        ch == 'o' ? 8 : (ch == 'u' ? 10 : 16),
404                        min, max, flags);
405                 break;
406             case 'f':
407                 if (cflags == DP_C_LDOUBLE)
408                     fvalue = va_arg(args, LDOUBLE);
409                 else
410                     fvalue = va_arg(args, double);
411                 fmtfp(outch_fn, buffer, &currlen, maxlen,
412                       fvalue, min, max, flags);
413                 break;
414             case 'E':
415                 flags |= DP_F_UP;
416             case 'e':
417                 if (cflags == DP_C_LDOUBLE)
418                     fvalue = va_arg(args, LDOUBLE);
419                 else
420                     fvalue = va_arg(args, double);
421                 break;
422             case 'G':
423                 flags |= DP_F_UP;
424             case 'g':
425                 if (cflags == DP_C_LDOUBLE)
426                     fvalue = va_arg(args, LDOUBLE);
427                 else
428                     fvalue = va_arg(args, double);
429                 break;
430             case 'c':
431                 (*outch_fn)(buffer, &currlen, maxlen,
432                     va_arg(args, int));
433                 break;
434             case 's':
435                 strvalue = va_arg(args, char *);
436                 if (max < 0)
437                     max = (*copy_fn)(*maxlen);
438                 fmtstr(outch_fn, buffer, &currlen, maxlen, strvalue,
439                        flags, min, max);
440                 break;
441             case 'p':
442                 value = (long)va_arg(args, void *);
443                 fmtint(outch_fn, buffer, &currlen, maxlen,
444                     value, 16, min, max, flags);
445                 break;
446             case 'n': /* XXX */
447                 if (cflags == DP_C_SHORT) {
448                     short int *num;
449                     num = va_arg(args, short int *);
450                     *num = currlen;
451                 } else if (cflags == DP_C_LONG) { /* XXX */
452                     long int *num;
453                     num = va_arg(args, long int *);
454                     *num = (long int) currlen;
455                 } else if (cflags == DP_C_LLONG) { /* XXX */
456                     LLONG *num;
457                     num = va_arg(args, LLONG *);
458                     *num = (LLONG) currlen;
459                 } else {
460                     int    *num;
461                     num = va_arg(args, int *);
462                     *num = currlen;
463                 }
464                 break;
465             case '%':
466                 (*outch_fn)(buffer, &currlen, maxlen, ch);
467                 break;
468             case 'w':
469                 /* not supported yet, treat as next char */
470                 ch = *format++;
471                 break;
472             default:
473                 /* unknown, skip */
474                 break;
475             }
476             ch = *format++;
477             state = DP_S_DEFAULT;
478             flags = cflags = min = 0;
479             max = -1;
480             break;
481         case DP_S_DONE:
482             break;
483         default:
484             break;
485         }
486     }
487     if (currlen >= *maxlen - 1)
488         currlen = *maxlen - 1;
489     (*buffer)[currlen] = '\0';
490     *retlen = currlen;
491     return;
492 }
493
494 static void
495 fmtstr(
496     void (*outch_fn)(char **, size_t *, size_t *, int),
497     char **buffer,
498     size_t *currlen,
499     size_t *maxlen,
500     const char *value,
501     int flags,
502     int min,
503     int max)
504 {
505     int padlen, strln;
506     int cnt = 0;
507
508     if (value == 0)
509         value = "<NULL>";
510     for (strln = 0; value[strln]; ++strln)
511         ;
512     padlen = min - strln;
513     if (padlen < 0)
514         padlen = 0;
515     if (flags & DP_F_MINUS)
516         padlen = -padlen;
517
518     while ((padlen > 0) && (cnt < max)) {
519         (*outch_fn)(buffer, currlen, maxlen, ' ');
520         --padlen;
521         ++cnt;
522     }
523     while (*value && (cnt < max)) {
524         (*outch_fn)(buffer, currlen, maxlen, *value++);
525         ++cnt;
526     }
527     while ((padlen < 0) && (cnt < max)) {
528         (*outch_fn)(buffer, currlen, maxlen, ' ');
529         ++padlen;
530         ++cnt;
531     }
532 }
533
534 static void
535 fmtint(
536     void (*outch_fn)(char **, size_t *, size_t *, int),
537     char **buffer,
538     size_t *currlen,
539     size_t *maxlen,
540     LLONG value,
541     int base,
542     int min,
543     int max,
544     int flags)
545 {
546     int signvalue = 0;
547     unsigned LLONG uvalue;
548     char convert[20];
549     int place = 0;
550     int spadlen = 0;
551     int zpadlen = 0;
552     int caps = 0;
553
554     if (max < 0)
555         max = 0;
556     uvalue = value;
557     if (!(flags & DP_F_UNSIGNED)) {
558         if (value < 0) {
559             signvalue = '-';
560             uvalue = -value;
561         } else if (flags & DP_F_PLUS)
562             signvalue = '+';
563         else if (flags & DP_F_SPACE)
564             signvalue = ' ';
565     }
566     if (flags & DP_F_UP)
567         caps = 1;
568     do {
569         convert[place++] =
570             (caps ? "0123456789ABCDEF" : "0123456789abcdef")
571             [uvalue % (unsigned) base];
572         uvalue = (uvalue / (unsigned) base);
573     } while (uvalue && (place < 20));
574     if (place == 20)
575         place--;
576     convert[place] = 0;
577
578     zpadlen = max - place;
579     spadlen = min - MAX(max, place) - (signvalue ? 1 : 0);
580     if (zpadlen < 0)
581         zpadlen = 0;
582     if (spadlen < 0)
583         spadlen = 0;
584     if (flags & DP_F_ZERO) {
585         zpadlen = MAX(zpadlen, spadlen);
586         spadlen = 0;
587     }
588     if (flags & DP_F_MINUS)
589         spadlen = -spadlen;
590
591     /* spaces */
592     while (spadlen > 0) {
593         (*outch_fn)(buffer, currlen, maxlen, ' ');
594         --spadlen;
595     }
596
597     /* sign */
598     if (signvalue)
599         (*outch_fn)(buffer, currlen, maxlen, signvalue);
600
601     /* zeros */
602     if (zpadlen > 0) {
603         while (zpadlen > 0) {
604             (*outch_fn)(buffer, currlen, maxlen, '0');
605             --zpadlen;
606         }
607     }
608     /* digits */
609     while (place > 0)
610         (*outch_fn)(buffer, currlen, maxlen, convert[--place]);
611
612     /* left justified spaces */
613     while (spadlen < 0) {
614         (*outch_fn)(buffer, currlen, maxlen, ' ');
615         ++spadlen;
616     }
617     return;
618 }
619
620 static LDOUBLE
621 abs_val(LDOUBLE value)
622 {
623     LDOUBLE result = value;
624     if (value < 0)
625         result = -value;
626     return result;
627 }
628
629 static LDOUBLE
630 pow10(int exp)
631 {
632     LDOUBLE result = 1;
633     while (exp) {
634         result *= 10;
635         exp--;
636     }
637     return result;
638 }
639
640 static long
641 round(LDOUBLE value)
642 {
643     long intpart;
644     intpart = (long) value;
645     value = value - intpart;
646     if (value >= 0.5)
647         intpart++;
648     return intpart;
649 }
650
651 static void
652 fmtfp(
653     void (*outch_fn)(char **, size_t *, size_t *, int),
654     char **buffer,
655     size_t *currlen,
656     size_t *maxlen,
657     LDOUBLE fvalue,
658     int min,
659     int max,
660     int flags)
661 {
662     int signvalue = 0;
663     LDOUBLE ufvalue;
664     char iconvert[20];
665     char fconvert[20];
666     int iplace = 0;
667     int fplace = 0;
668     int padlen = 0;
669     int zpadlen = 0;
670     int caps = 0;
671     long intpart;
672     long fracpart;
673
674     if (max < 0)
675         max = 6;
676     ufvalue = abs_val(fvalue);
677     if (fvalue < 0)
678         signvalue = '-';
679     else if (flags & DP_F_PLUS)
680         signvalue = '+';
681     else if (flags & DP_F_SPACE)
682         signvalue = ' ';
683
684     intpart = (long)ufvalue;
685
686     /* sorry, we only support 9 digits past the decimal because of our
687        conversion method */
688     if (max > 9)
689         max = 9;
690
691     /* we "cheat" by converting the fractional part to integer by
692        multiplying by a factor of 10 */
693     fracpart = round((pow10(max)) * (ufvalue - intpart));
694
695     if (fracpart >= pow10(max)) {
696         intpart++;
697         fracpart -= (long)pow10(max);
698     }
699
700     /* convert integer part */
701     do {
702         iconvert[iplace++] =
703             (caps ? "0123456789ABCDEF"
704               : "0123456789abcdef")[intpart % 10];
705         intpart = (intpart / 10);
706     } while (intpart && (iplace < 20));
707     if (iplace == 20)
708         iplace--;
709     iconvert[iplace] = 0;
710
711     /* convert fractional part */
712     do {
713         fconvert[fplace++] =
714             (caps ? "0123456789ABCDEF"
715               : "0123456789abcdef")[fracpart % 10];
716         fracpart = (fracpart / 10);
717     } while (fracpart && (fplace < 20));
718     if (fplace == 20)
719         fplace--;
720     fconvert[fplace] = 0;
721
722     /* -1 for decimal point, another -1 if we are printing a sign */
723     padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
724     zpadlen = max - fplace;
725     if (zpadlen < 0)
726         zpadlen = 0;
727     if (padlen < 0)
728         padlen = 0;
729     if (flags & DP_F_MINUS)
730         padlen = -padlen;
731
732     if ((flags & DP_F_ZERO) && (padlen > 0)) {
733         if (signvalue) {
734             (*outch_fn)(buffer, currlen, maxlen, signvalue);
735             --padlen;
736             signvalue = 0;
737         }
738         while (padlen > 0) {
739             (*outch_fn)(buffer, currlen, maxlen, '0');
740             --padlen;
741         }
742     }
743     while (padlen > 0) {
744         (*outch_fn)(buffer, currlen, maxlen, ' ');
745         --padlen;
746     }
747     if (signvalue)
748         (*outch_fn)(buffer, currlen, maxlen, signvalue);
749
750     while (iplace > 0)
751         (*outch_fn)(buffer, currlen, maxlen, iconvert[--iplace]);
752
753     /*
754      * Decimal point. This should probably use locale to find the correct
755      * char to print out.
756      */
757     if (max > 0) {
758         (*outch_fn)(buffer, currlen, maxlen, '.');
759
760         while (fplace > 0)
761             (*outch_fn)(buffer, currlen, maxlen, fconvert[--fplace]);
762     }
763     while (zpadlen > 0) {
764         (*outch_fn)(buffer, currlen, maxlen, '0');
765         --zpadlen;
766     }
767
768     while (padlen < 0) {
769         (*outch_fn)(buffer, currlen, maxlen, ' ');
770         ++padlen;
771     }
772 }
773
774 static int
775 dopr_copy(
776     size_t len)
777 {
778     return len;
779 }
780
781 #ifdef USE_ALLOCATING_PRINT
782 static int
783 doapr_copy(
784     size_t len)
785 {
786     /* Return as high an integer as possible */
787     return INT_MAX;
788 }
789 #endif
790
791 static int
792 dopr_isbig(
793     size_t currlen,
794     size_t maxlen)
795 {
796     return currlen > maxlen;
797 }
798
799 #ifdef USE_ALLOCATING_PRINT
800 static int
801 doapr_isbig(
802     size_t currlen,
803     size_t maxlen)
804 {
805     return 0;
806 }
807 #endif
808
809 static void
810 dopr_outch(
811     char **buffer,
812     size_t *currlen,
813     size_t *maxlen,
814     int c)
815 {
816     if (*currlen < *maxlen)
817         (*buffer)[(*currlen)++] = (char)c;
818     return;
819 }
820
821 #ifdef USE_ALLOCATING_PRINT
822 static void
823 doapr_outch(
824     char **buffer,
825     size_t *currlen,
826     size_t *maxlen,
827     int c)
828 {
829     if (*buffer == NULL) {
830         if (*maxlen == 0)
831             *maxlen = 1024;
832         *buffer = Malloc(*maxlen);
833     }
834     while (*currlen >= *maxlen) {
835         *maxlen += 1024;
836         *buffer = Realloc(*buffer, *maxlen);
837     }
838     /* What to do if *buffer is NULL? */
839     assert(*buffer != NULL);
840
841     (*buffer)[(*currlen)++] = (char)c;
842     return;
843 }
844 #endif