clang-10: use AFS_FALLTHROUGH for case fallthrough
[openafs.git] / src / tests / snprintf.c
1 /*
2  * Copyright (c) 1995-2000 Kungliga Tekniska Högskolan
3  * (Royal Institute of Technology, Stockholm, Sweden).
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  *
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * 3. Neither the name of the Institute nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  */
33
34 #include <afsconfig.h>
35 #ifdef HAVE_CONFIG_H
36 #include <config.h>
37 #endif
38 #include <stdio.h>
39 #include <stdarg.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <ctype.h>
43
44 #ifndef HAVE_VASNPRINTF
45 int vasnprintf(char **ret, size_t max_sz, const char *format, va_list args);
46 #endif
47 #ifndef HAVE_VASPRINTF
48 int vasprintf(char**ret, const char *format, va_list args);
49 #endif
50
51 #ifndef min
52 #define min(a, b)               ((a) > (b) ? (b) : (a))
53 #endif
54 #ifndef max
55 #define max(a, b)               ((a) < (b) ? (b) : (a))
56 #endif
57
58 enum format_flags {
59     minus_flag = 1,
60     plus_flag = 2,
61     space_flag = 4,
62     alternate_flag = 8,
63     zero_flag = 16
64 };
65
66 /*
67  * Common state
68  */
69
70 struct state {
71     unsigned char *str;
72     unsigned char *s;
73     unsigned char *theend;
74     size_t sz;
75     size_t max_sz;
76     int (*append_char) (struct state *, unsigned char);
77     int (*reserve) (struct state *, size_t);
78     /* XXX - methods */
79 };
80
81 #ifndef HAVE_VSNPRINTF
82 static int
83 sn_reserve(struct state *state, size_t n)
84 {
85     return state->s + n > state->theend;
86 }
87
88 static int
89 sn_append_char(struct state *state, unsigned char c)
90 {
91     if (sn_reserve(state, 1)) {
92         return 1;
93     } else {
94         *state->s++ = c;
95         return 0;
96     }
97 }
98 #endif
99
100 static int
101 as_reserve(struct state *state, size_t n)
102 {
103     if (state->s + n > state->theend) {
104         int off = state->s - state->str;
105         unsigned char *tmp;
106
107         if (state->max_sz && state->sz >= state->max_sz)
108             return 1;
109
110         state->sz = max(state->sz * 2, state->sz + n);
111         if (state->max_sz)
112             state->sz = min(state->sz, state->max_sz);
113         tmp = realloc(state->str, state->sz);
114         if (tmp == NULL)
115             return 1;
116         state->str = tmp;
117         state->s = state->str + off;
118         state->theend = state->str + state->sz - 1;
119     }
120     return 0;
121 }
122
123 static int
124 as_append_char(struct state *state, unsigned char c)
125 {
126     if (as_reserve(state, 1))
127         return 1;
128     else {
129         *state->s++ = c;
130         return 0;
131     }
132 }
133
134 static int
135 append_number(struct state *state, unsigned long num, unsigned base,
136               char *rep, int width, int prec, int flags, int minusp)
137 {
138     int len = 0;
139     int i;
140
141     /* given precision, ignore zero flag */
142     if (prec != -1)
143         flags &= ~zero_flag;
144     else
145         prec = 1;
146     /* zero value with zero precision -> "" */
147     if (prec == 0 && num == 0)
148         return 0;
149     do {
150         if ((*state->append_char) (state, rep[num % base]))
151             return 1;
152         len++;
153         num /= base;
154     } while (num);
155     prec -= len;
156     /* pad with prec zeros */
157     while (prec-- > 0) {
158         if ((*state->append_char) (state, '0'))
159             return 1;
160         len++;
161     }
162     /* add length of alternate prefix (added later) to len */
163     if (flags & alternate_flag && (base == 16 || base == 8))
164         len += base / 8;
165     /* pad with zeros */
166     if (flags & zero_flag) {
167         width -= len;
168         if (minusp || (flags & space_flag) || (flags & plus_flag))
169             width--;
170         while (width-- > 0) {
171             if ((*state->append_char) (state, '0'))
172                 return 1;
173             len++;
174         }
175     }
176     /* add alternate prefix */
177     if (flags & alternate_flag && (base == 16 || base == 8)) {
178         if (base == 16)
179             if ((*state->append_char) (state, rep[10] + 23))    /* XXX */
180                 return 1;
181         if ((*state->append_char) (state, '0'))
182             return 1;
183     }
184     /* add sign */
185     if (minusp) {
186         if ((*state->append_char) (state, '-'))
187             return 1;
188         len++;
189     } else if (flags & plus_flag) {
190         if ((*state->append_char) (state, '+'))
191             return 1;
192         len++;
193     } else if (flags & space_flag) {
194         if ((*state->append_char) (state, ' '))
195             return 1;
196         len++;
197     }
198     if (flags & minus_flag)
199         /* swap before padding with spaces */
200         for (i = 0; i < len / 2; i++) {
201             char c = state->s[-i - 1];
202             state->s[-i - 1] = state->s[-len + i];
203             state->s[-len + i] = c;
204         }
205     width -= len;
206     while (width-- > 0) {
207         if ((*state->append_char) (state, ' '))
208             return 1;
209         len++;
210     }
211     if (!(flags & minus_flag))
212         /* swap after padding with spaces */
213         for (i = 0; i < len / 2; i++) {
214             char c = state->s[-i - 1];
215             state->s[-i - 1] = state->s[-len + i];
216             state->s[-len + i] = c;
217         }
218
219     return 0;
220 }
221
222 static int
223 append_string(struct state *state, unsigned char *arg, int width, int prec,
224               int flags)
225 {
226     if (arg == NULL)
227         arg = (unsigned char *)"(null)";
228
229     if (prec != -1)
230         width -= prec;
231     else
232         width -= strlen((char *)arg);
233     if (!(flags & minus_flag))
234         while (width-- > 0)
235             if ((*state->append_char) (state, ' '))
236                 return 1;
237     if (prec != -1) {
238         while (*arg && prec--)
239             if ((*state->append_char) (state, *arg++))
240                 return 1;
241     } else {
242         while (*arg)
243             if ((*state->append_char) (state, *arg++))
244                 return 1;
245     }
246     if (flags & minus_flag)
247         while (width-- > 0)
248             if ((*state->append_char) (state, ' '))
249                 return 1;
250     return 0;
251 }
252
253 static int
254 append_char(struct state *state, unsigned char arg, int width, int flags)
255 {
256     while (!(flags & minus_flag) && --width > 0)
257         if ((*state->append_char) (state, ' '))
258             return 1;
259
260     if ((*state->append_char) (state, arg))
261         return 1;
262     while ((flags & minus_flag) && --width > 0)
263         if ((*state->append_char) (state, ' '))
264             return 1;
265
266     return 0;
267 }
268
269 /*
270  * This can't be made into a function...
271  */
272
273 #define PARSE_INT_FORMAT(res, arg, unsig) \
274 if (long_flag) \
275      res = (unsig long)va_arg(arg, unsig long); \
276 else if (short_flag) \
277      res = (unsig short)va_arg(arg, unsig int); \
278 else \
279      res = (unsig int)va_arg(arg, unsig int)
280
281 /*
282  * zyxprintf - return 0 or -1
283  */
284
285 static int
286 xyzprintf(struct state *state, const char *char_format, va_list ap)
287 {
288     const unsigned char *format = (const unsigned char *)char_format;
289     unsigned char c;
290
291     while ((c = *format++)) {
292         if (c == '%') {
293             int flags = 0;
294             int width = 0;
295             int prec = -1;
296             int long_flag = 0;
297             int short_flag = 0;
298
299             /* flags */
300             while ((c = *format++)) {
301                 if (c == '-')
302                     flags |= minus_flag;
303                 else if (c == '+')
304                     flags |= plus_flag;
305                 else if (c == ' ')
306                     flags |= space_flag;
307                 else if (c == '#')
308                     flags |= alternate_flag;
309                 else if (c == '0')
310                     flags |= zero_flag;
311                 else
312                     break;
313             }
314
315             if ((flags & space_flag) && (flags & plus_flag))
316                 flags ^= space_flag;
317
318             if ((flags & minus_flag) && (flags & zero_flag))
319                 flags ^= zero_flag;
320
321             /* width */
322             if (isdigit(c))
323                 do {
324                     width = width * 10 + c - '0';
325                     c = *format++;
326                 } while (isdigit(c));
327             else if (c == '*') {
328                 width = va_arg(ap, int);
329                 c = *format++;
330             }
331
332             /* precision */
333             if (c == '.') {
334                 prec = 0;
335                 c = *format++;
336                 if (isdigit(c))
337                     do {
338                         prec = prec * 10 + c - '0';
339                         c = *format++;
340                     } while (isdigit(c));
341                 else if (c == '*') {
342                     prec = va_arg(ap, int);
343                     c = *format++;
344                 }
345             }
346
347             /* size */
348
349             if (c == 'h') {
350                 short_flag = 1;
351                 c = *format++;
352             } else if (c == 'l') {
353                 long_flag = 1;
354                 c = *format++;
355             }
356
357             switch (c) {
358             case 'c':
359                 if (append_char(state, va_arg(ap, int), width, flags))
360                       return -1;
361                 break;
362             case 's':
363                 if (append_string
364                     (state, va_arg(ap, unsigned char *), width, prec, flags))
365                       return -1;
366                 break;
367             case 'd':
368             case 'i':{
369                     long arg;
370                     unsigned long num;
371                     int minusp = 0;
372
373                     PARSE_INT_FORMAT(arg, ap, signed);
374
375                     if (arg < 0) {
376                         minusp = 1;
377                         num = -arg;
378                     } else
379                         num = arg;
380
381                     if (append_number
382                         (state, num, 10, "0123456789", width, prec, flags,
383                          minusp))
384                         return -1;
385                     break;
386                 }
387             case 'u':{
388                     unsigned long arg;
389
390                     PARSE_INT_FORMAT(arg, ap, unsigned);
391
392                     if (append_number
393                         (state, arg, 10, "0123456789", width, prec, flags, 0))
394                         return -1;
395                     break;
396                 }
397             case 'o':{
398                     unsigned long arg;
399
400                     PARSE_INT_FORMAT(arg, ap, unsigned);
401
402                     if (append_number
403                         (state, arg, 010, "01234567", width, prec, flags, 0))
404                         return -1;
405                     break;
406                 }
407             case 'x':{
408                     unsigned long arg;
409
410                     PARSE_INT_FORMAT(arg, ap, unsigned);
411
412                     if (append_number
413                         (state, arg, 0x10, "0123456789abcdef", width, prec,
414                          flags, 0))
415                         return -1;
416                     break;
417                 }
418             case 'X':{
419                     unsigned long arg;
420
421                     PARSE_INT_FORMAT(arg, ap, unsigned);
422
423                     if (append_number
424                         (state, arg, 0x10, "0123456789ABCDEF", width, prec,
425                          flags, 0))
426                         return -1;
427                     break;
428                 }
429             case 'p':{
430                     unsigned long arg = (unsigned long)va_arg(ap, void *);
431
432                     if (append_number
433                         (state, arg, 0x10, "0123456789ABCDEF", width, prec,
434                          flags, 0))
435                         return -1;
436                     break;
437                 }
438             case 'n':{
439                     int *arg = va_arg(ap, int *);
440                     *arg = state->s - state->str;
441                     break;
442                 }
443             case '\0':
444                 --format;
445                 AFS_FALLTHROUGH;
446             case '%':
447                 if ((*state->append_char) (state, c))
448                     return -1;
449                 break;
450             default:
451                 if ((*state->append_char) (state, '%')
452                     || (*state->append_char) (state, c))
453                     return -1;
454                 break;
455             }
456         } else if ((*state->append_char) (state, c))
457             return -1;
458     }
459     return 0;
460 }
461
462 #ifndef HAVE_SNPRINTF
463 int
464 snprintf(char *str, size_t sz, const char *format, ...)
465 {
466     va_list args;
467     int ret;
468
469     va_start(args, format);
470     ret = vsnprintf(str, sz, format, args);
471
472 #ifdef PARANOIA
473     {
474         int ret2;
475         char *tmp;
476
477         tmp = malloc(sz);
478         if (tmp == NULL)
479             abort();
480
481         ret2 = vsprintf(tmp, format, args);
482         if (ret != ret2 || strcmp(str, tmp))
483             abort();
484         free(tmp);
485     }
486 #endif
487
488     va_end(args);
489     return ret;
490 }
491 #endif
492
493 #ifndef HAVE_ASPRINTF
494 int
495 asprintf(char **ret, const char *format, ...)
496 {
497     va_list args;
498     int val;
499
500     va_start(args, format);
501     val = vasprintf(ret, format, args);
502
503 #ifdef PARANOIA
504     {
505         int ret2;
506         char *tmp;
507         tmp = malloc(val + 1);
508         if (tmp == NULL)
509             abort();
510
511         ret2 = vsprintf(tmp, format, args);
512         if (val != ret2 || strcmp(*ret, tmp))
513             abort();
514         free(tmp);
515     }
516 #endif
517
518     va_end(args);
519     return val;
520 }
521 #endif
522
523 #ifndef HAVE_ASNPRINTF
524 int
525 asnprintf(char **ret, size_t max_sz, const char *format, ...)
526 {
527     va_list args;
528     int val;
529
530     va_start(args, format);
531     val = vasnprintf(ret, max_sz, format, args);
532
533 #ifdef PARANOIA
534     {
535         int ret2;
536         char *tmp;
537         tmp = malloc(val + 1);
538         if (tmp == NULL)
539             abort();
540
541         ret2 = vsprintf(tmp, format, args);
542         if (val != ret2 || strcmp(*ret, tmp))
543             abort();
544         free(tmp);
545     }
546 #endif
547
548     va_end(args);
549     return val;
550 }
551 #endif
552
553 #ifndef HAVE_VASPRINTF
554 int
555 vasprintf(char **ret, const char *format, va_list args)
556 {
557     return vasnprintf(ret, 0, format, args);
558 }
559 #endif
560
561
562 #ifndef HAVE_VASNPRINTF
563 int
564 vasnprintf(char **ret, size_t max_sz, const char *format, va_list args)
565 {
566     int st;
567     size_t len;
568     struct state state;
569
570     state.max_sz = max_sz;
571     state.sz = 1;
572     state.str = malloc(state.sz);
573     if (state.str == NULL) {
574         *ret = NULL;
575         return -1;
576     }
577     state.s = state.str;
578     state.theend = state.s + state.sz - 1;
579     state.append_char = as_append_char;
580     state.reserve = as_reserve;
581
582     st = xyzprintf(&state, format, args);
583     if (st) {
584         free(state.str);
585         *ret = NULL;
586         return -1;
587     } else {
588         char *tmp;
589
590         *state.s = '\0';
591         len = state.s - state.str;
592         tmp = realloc(state.str, len + 1);
593         if (tmp == NULL) {
594             free(state.str);
595             *ret = NULL;
596             return -1;
597         }
598         *ret = tmp;
599         return len;
600     }
601 }
602 #endif
603
604 #ifndef HAVE_VSNPRINTF
605 int
606 vsnprintf(char *str, size_t sz, const char *format, va_list args)
607 {
608     struct state state;
609     int ret;
610     unsigned char *ustr = (unsigned char *)str;
611
612     state.max_sz = 0;
613     state.sz = sz;
614     state.str = ustr;
615     state.s = ustr;
616     state.theend = ustr + sz - 1;
617     state.append_char = sn_append_char;
618     state.reserve = sn_reserve;
619
620     ret = xyzprintf(&state, format, args);
621     *state.s = '\0';
622     if (ret)
623         return sz;
624     else
625         return state.s - state.str;
626 }
627 #endif