1b528cefcSMark Murray /*
2ae771770SStanislav Sedov * Copyright (c) 1995-2003 Kungliga Tekniska Högskolan
3b528cefcSMark Murray * (Royal Institute of Technology, Stockholm, Sweden).
4b528cefcSMark Murray * All rights reserved.
5b528cefcSMark Murray *
6b528cefcSMark Murray * Redistribution and use in source and binary forms, with or without
7b528cefcSMark Murray * modification, are permitted provided that the following conditions
8b528cefcSMark Murray * are met:
9b528cefcSMark Murray *
10b528cefcSMark Murray * 1. Redistributions of source code must retain the above copyright
11b528cefcSMark Murray * notice, this list of conditions and the following disclaimer.
12b528cefcSMark Murray *
13b528cefcSMark Murray * 2. Redistributions in binary form must reproduce the above copyright
14b528cefcSMark Murray * notice, this list of conditions and the following disclaimer in the
15b528cefcSMark Murray * documentation and/or other materials provided with the distribution.
16b528cefcSMark Murray *
17b528cefcSMark Murray * 3. Neither the name of the Institute nor the names of its contributors
18b528cefcSMark Murray * may be used to endorse or promote products derived from this software
19b528cefcSMark Murray * without specific prior written permission.
20b528cefcSMark Murray *
21b528cefcSMark Murray * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22b528cefcSMark Murray * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23b528cefcSMark Murray * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24b528cefcSMark Murray * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25b528cefcSMark Murray * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26b528cefcSMark Murray * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27b528cefcSMark Murray * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28b528cefcSMark Murray * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29b528cefcSMark Murray * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30b528cefcSMark Murray * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31b528cefcSMark Murray * SUCH DAMAGE.
32b528cefcSMark Murray */
33b528cefcSMark Murray
34b528cefcSMark Murray #include <config.h>
35b528cefcSMark Murray #include <stdio.h>
36b528cefcSMark Murray #include <stdarg.h>
37b528cefcSMark Murray #include <stdlib.h>
38b528cefcSMark Murray #include <string.h>
39b528cefcSMark Murray #include <ctype.h>
40c19800e8SDoug Rabson #include "roken.h"
41c19800e8SDoug Rabson #include <assert.h>
42b528cefcSMark Murray
43b528cefcSMark Murray enum format_flags {
44b528cefcSMark Murray minus_flag = 1,
45b528cefcSMark Murray plus_flag = 2,
46b528cefcSMark Murray space_flag = 4,
47b528cefcSMark Murray alternate_flag = 8,
48b528cefcSMark Murray zero_flag = 16
49b528cefcSMark Murray };
50b528cefcSMark Murray
51b528cefcSMark Murray /*
52b528cefcSMark Murray * Common state
53b528cefcSMark Murray */
54b528cefcSMark Murray
554137ff4cSJacques Vidrine struct snprintf_state {
56b528cefcSMark Murray unsigned char *str;
57b528cefcSMark Murray unsigned char *s;
58b528cefcSMark Murray unsigned char *theend;
59b528cefcSMark Murray size_t sz;
60b528cefcSMark Murray size_t max_sz;
614137ff4cSJacques Vidrine void (*append_char)(struct snprintf_state *, unsigned char);
62b528cefcSMark Murray /* XXX - methods */
63b528cefcSMark Murray };
64b528cefcSMark Murray
654137ff4cSJacques Vidrine #if !defined(HAVE_VSNPRINTF) || defined(TEST_SNPRINTF)
66b528cefcSMark Murray static int
sn_reserve(struct snprintf_state * state,size_t n)674137ff4cSJacques Vidrine sn_reserve (struct snprintf_state *state, size_t n)
68b528cefcSMark Murray {
69b528cefcSMark Murray return state->s + n > state->theend;
70b528cefcSMark Murray }
71b528cefcSMark Murray
724137ff4cSJacques Vidrine static void
sn_append_char(struct snprintf_state * state,unsigned char c)734137ff4cSJacques Vidrine sn_append_char (struct snprintf_state *state, unsigned char c)
74b528cefcSMark Murray {
754137ff4cSJacques Vidrine if (!sn_reserve (state, 1))
76b528cefcSMark Murray *state->s++ = c;
77b528cefcSMark Murray }
78b528cefcSMark Murray #endif
79b528cefcSMark Murray
80b528cefcSMark Murray static int
as_reserve(struct snprintf_state * state,size_t n)814137ff4cSJacques Vidrine as_reserve (struct snprintf_state *state, size_t n)
82b528cefcSMark Murray {
83b528cefcSMark Murray if (state->s + n > state->theend) {
84b528cefcSMark Murray int off = state->s - state->str;
85b528cefcSMark Murray unsigned char *tmp;
86b528cefcSMark Murray
87b528cefcSMark Murray if (state->max_sz && state->sz >= state->max_sz)
88b528cefcSMark Murray return 1;
89b528cefcSMark Murray
90b528cefcSMark Murray state->sz = max(state->sz * 2, state->sz + n);
91b528cefcSMark Murray if (state->max_sz)
92b528cefcSMark Murray state->sz = min(state->sz, state->max_sz);
93b528cefcSMark Murray tmp = realloc (state->str, state->sz);
94b528cefcSMark Murray if (tmp == NULL)
95b528cefcSMark Murray return 1;
96b528cefcSMark Murray state->str = tmp;
97b528cefcSMark Murray state->s = state->str + off;
98b528cefcSMark Murray state->theend = state->str + state->sz - 1;
99b528cefcSMark Murray }
100b528cefcSMark Murray return 0;
101b528cefcSMark Murray }
102b528cefcSMark Murray
1034137ff4cSJacques Vidrine static void
as_append_char(struct snprintf_state * state,unsigned char c)1044137ff4cSJacques Vidrine as_append_char (struct snprintf_state *state, unsigned char c)
105b528cefcSMark Murray {
1064137ff4cSJacques Vidrine if(!as_reserve (state, 1))
107b528cefcSMark Murray *state->s++ = c;
108b528cefcSMark Murray }
1094137ff4cSJacques Vidrine
1104137ff4cSJacques Vidrine /* longest integer types */
1114137ff4cSJacques Vidrine
1124137ff4cSJacques Vidrine #ifdef HAVE_LONG_LONG
1134137ff4cSJacques Vidrine typedef unsigned long long u_longest;
1144137ff4cSJacques Vidrine typedef long long longest;
1154137ff4cSJacques Vidrine #else
1164137ff4cSJacques Vidrine typedef unsigned long u_longest;
1174137ff4cSJacques Vidrine typedef long longest;
1184137ff4cSJacques Vidrine #endif
1194137ff4cSJacques Vidrine
1204137ff4cSJacques Vidrine
121c19800e8SDoug Rabson
122ae771770SStanislav Sedov static size_t
pad(struct snprintf_state * state,int width,char c)123c19800e8SDoug Rabson pad(struct snprintf_state *state, int width, char c)
124c19800e8SDoug Rabson {
125ae771770SStanislav Sedov size_t len = 0;
126c19800e8SDoug Rabson while(width-- > 0){
127c19800e8SDoug Rabson (*state->append_char)(state, c);
128c19800e8SDoug Rabson ++len;
129c19800e8SDoug Rabson }
130c19800e8SDoug Rabson return len;
131c19800e8SDoug Rabson }
132c19800e8SDoug Rabson
133c19800e8SDoug Rabson /* return true if we should use alternatve hex form */
1344137ff4cSJacques Vidrine static int
use_alternative(int flags,u_longest num,unsigned base)1354137ff4cSJacques Vidrine use_alternative (int flags, u_longest num, unsigned base)
1364137ff4cSJacques Vidrine {
137c19800e8SDoug Rabson return (flags & alternate_flag) && base == 16 && num != 0;
138b528cefcSMark Murray }
139b528cefcSMark Murray
140b528cefcSMark Murray static int
append_number(struct snprintf_state * state,u_longest num,unsigned base,const char * rep,int width,int prec,int flags,int minusp)1414137ff4cSJacques Vidrine append_number(struct snprintf_state *state,
1428373020dSJacques Vidrine u_longest num, unsigned base, const char *rep,
143b528cefcSMark Murray int width, int prec, int flags, int minusp)
144b528cefcSMark Murray {
145b528cefcSMark Murray int len = 0;
1464137ff4cSJacques Vidrine u_longest n = num;
147c19800e8SDoug Rabson char nstr[64]; /* enough for <192 bit octal integers */
148c19800e8SDoug Rabson int nstart, nlen;
149c19800e8SDoug Rabson char signchar;
150b528cefcSMark Murray
151b528cefcSMark Murray /* given precision, ignore zero flag */
152b528cefcSMark Murray if(prec != -1)
153b528cefcSMark Murray flags &= ~zero_flag;
154b528cefcSMark Murray else
155b528cefcSMark Murray prec = 1;
156c19800e8SDoug Rabson
157c19800e8SDoug Rabson /* format number as string */
158c19800e8SDoug Rabson nstart = sizeof(nstr);
159c19800e8SDoug Rabson nlen = 0;
160c19800e8SDoug Rabson nstr[--nstart] = '\0';
161b528cefcSMark Murray do {
162c19800e8SDoug Rabson assert(nstart > 0);
163c19800e8SDoug Rabson nstr[--nstart] = rep[n % base];
164c19800e8SDoug Rabson ++nlen;
1654137ff4cSJacques Vidrine n /= base;
1664137ff4cSJacques Vidrine } while(n);
167c19800e8SDoug Rabson
168c19800e8SDoug Rabson /* zero value with zero precision should produce no digits */
169c19800e8SDoug Rabson if(prec == 0 && num == 0) {
170c19800e8SDoug Rabson nlen--;
171c19800e8SDoug Rabson nstart++;
172b528cefcSMark Murray }
173c19800e8SDoug Rabson
174c19800e8SDoug Rabson /* figure out what char to use for sign */
175c19800e8SDoug Rabson if(minusp)
176c19800e8SDoug Rabson signchar = '-';
177c19800e8SDoug Rabson else if((flags & plus_flag))
178c19800e8SDoug Rabson signchar = '+';
179c19800e8SDoug Rabson else if((flags & space_flag))
180c19800e8SDoug Rabson signchar = ' ';
181c19800e8SDoug Rabson else
182c19800e8SDoug Rabson signchar = '\0';
183c19800e8SDoug Rabson
184c19800e8SDoug Rabson if((flags & alternate_flag) && base == 8) {
185c19800e8SDoug Rabson /* if necessary, increase the precision to
186c19800e8SDoug Rabson make first digit a zero */
187c19800e8SDoug Rabson
188c19800e8SDoug Rabson /* XXX C99 claims (regarding # and %o) that "if the value and
189c19800e8SDoug Rabson precision are both 0, a single 0 is printed", but there is
190c19800e8SDoug Rabson no such wording for %x. This would mean that %#.o would
191c19800e8SDoug Rabson output "0", but %#.x "". This does not make sense, and is
192c19800e8SDoug Rabson also not what other printf implementations are doing. */
193c19800e8SDoug Rabson
194c19800e8SDoug Rabson if(prec <= nlen && nstr[nstart] != '0' && nstr[nstart] != '\0')
195c19800e8SDoug Rabson prec = nlen + 1;
196c19800e8SDoug Rabson }
197c19800e8SDoug Rabson
198c19800e8SDoug Rabson /* possible formats:
199c19800e8SDoug Rabson pad | sign | alt | zero | digits
200c19800e8SDoug Rabson sign | alt | zero | digits | pad minus_flag
201c19800e8SDoug Rabson sign | alt | zero | digits zero_flag */
202c19800e8SDoug Rabson
203c19800e8SDoug Rabson /* if not right justifying or padding with zeros, we need to
204c19800e8SDoug Rabson compute the length of the rest of the string, and then pad with
205c19800e8SDoug Rabson spaces */
206c19800e8SDoug Rabson if(!(flags & (minus_flag | zero_flag))) {
207c19800e8SDoug Rabson if(prec > nlen)
208c19800e8SDoug Rabson width -= prec;
209c19800e8SDoug Rabson else
210c19800e8SDoug Rabson width -= nlen;
211c19800e8SDoug Rabson
2124137ff4cSJacques Vidrine if(use_alternative(flags, num, base))
213c19800e8SDoug Rabson width -= 2;
214c19800e8SDoug Rabson
215c19800e8SDoug Rabson if(signchar != '\0')
216b528cefcSMark Murray width--;
217c19800e8SDoug Rabson
218c19800e8SDoug Rabson /* pad to width */
219c19800e8SDoug Rabson len += pad(state, width, ' ');
220b528cefcSMark Murray }
221c19800e8SDoug Rabson if(signchar != '\0') {
222c19800e8SDoug Rabson (*state->append_char)(state, signchar);
223c19800e8SDoug Rabson ++len;
224b528cefcSMark Murray }
2254137ff4cSJacques Vidrine if(use_alternative(flags, num, base)) {
2264137ff4cSJacques Vidrine (*state->append_char)(state, '0');
227c19800e8SDoug Rabson (*state->append_char)(state, rep[10] + 23); /* XXX */
228c19800e8SDoug Rabson len += 2;
229b528cefcSMark Murray }
230c19800e8SDoug Rabson if(flags & zero_flag) {
231c19800e8SDoug Rabson /* pad to width with zeros */
232c19800e8SDoug Rabson if(prec - nlen > width - len - nlen)
233c19800e8SDoug Rabson len += pad(state, prec - nlen, '0');
234c19800e8SDoug Rabson else
235c19800e8SDoug Rabson len += pad(state, width - len - nlen, '0');
236c19800e8SDoug Rabson } else
237c19800e8SDoug Rabson /* pad to prec with zeros */
238c19800e8SDoug Rabson len += pad(state, prec - nlen, '0');
239c19800e8SDoug Rabson
240c19800e8SDoug Rabson while(nstr[nstart] != '\0') {
241c19800e8SDoug Rabson (*state->append_char)(state, nstr[nstart++]);
2424137ff4cSJacques Vidrine ++len;
243b528cefcSMark Murray }
244c19800e8SDoug Rabson
245b528cefcSMark Murray if(flags & minus_flag)
246c19800e8SDoug Rabson len += pad(state, width - len, ' ');
247c19800e8SDoug Rabson
2484137ff4cSJacques Vidrine return len;
249b528cefcSMark Murray }
250b528cefcSMark Murray
2514137ff4cSJacques Vidrine /*
2524137ff4cSJacques Vidrine * return length
2534137ff4cSJacques Vidrine */
2544137ff4cSJacques Vidrine
255ae771770SStanislav Sedov static size_t
append_string(struct snprintf_state * state,const unsigned char * arg,int width,int prec,int flags)2564137ff4cSJacques Vidrine append_string (struct snprintf_state *state,
2574137ff4cSJacques Vidrine const unsigned char *arg,
258b528cefcSMark Murray int width,
259b528cefcSMark Murray int prec,
260b528cefcSMark Murray int flags)
261b528cefcSMark Murray {
262ae771770SStanislav Sedov size_t len = 0;
2634137ff4cSJacques Vidrine
2645e9cd1aeSAssar Westerlund if(arg == NULL)
2654137ff4cSJacques Vidrine arg = (const unsigned char*)"(null)";
2665e9cd1aeSAssar Westerlund
267b528cefcSMark Murray if(prec != -1)
268b528cefcSMark Murray width -= prec;
269b528cefcSMark Murray else
2704137ff4cSJacques Vidrine width -= strlen((const char *)arg);
271b528cefcSMark Murray if(!(flags & minus_flag))
272c19800e8SDoug Rabson len += pad(state, width, ' ');
273c19800e8SDoug Rabson
274b528cefcSMark Murray if (prec != -1) {
2754137ff4cSJacques Vidrine while (*arg && prec--) {
2764137ff4cSJacques Vidrine (*state->append_char) (state, *arg++);
2774137ff4cSJacques Vidrine ++len;
2784137ff4cSJacques Vidrine }
279b528cefcSMark Murray } else {
2804137ff4cSJacques Vidrine while (*arg) {
2814137ff4cSJacques Vidrine (*state->append_char) (state, *arg++);
2824137ff4cSJacques Vidrine ++len;
2834137ff4cSJacques Vidrine }
284b528cefcSMark Murray }
285b528cefcSMark Murray if(flags & minus_flag)
286c19800e8SDoug Rabson len += pad(state, width, ' ');
2874137ff4cSJacques Vidrine return len;
288b528cefcSMark Murray }
289b528cefcSMark Murray
290b528cefcSMark Murray static int
append_char(struct snprintf_state * state,unsigned char arg,int width,int flags)2914137ff4cSJacques Vidrine append_char(struct snprintf_state *state,
292b528cefcSMark Murray unsigned char arg,
293b528cefcSMark Murray int width,
294b528cefcSMark Murray int flags)
295b528cefcSMark Murray {
2964137ff4cSJacques Vidrine int len = 0;
297b528cefcSMark Murray
2984137ff4cSJacques Vidrine while(!(flags & minus_flag) && --width > 0) {
2994137ff4cSJacques Vidrine (*state->append_char) (state, ' ') ;
3004137ff4cSJacques Vidrine ++len;
3014137ff4cSJacques Vidrine }
3024137ff4cSJacques Vidrine (*state->append_char) (state, arg);
3034137ff4cSJacques Vidrine ++len;
3044137ff4cSJacques Vidrine while((flags & minus_flag) && --width > 0) {
3054137ff4cSJacques Vidrine (*state->append_char) (state, ' ');
3064137ff4cSJacques Vidrine ++len;
3074137ff4cSJacques Vidrine }
308b528cefcSMark Murray return 0;
309b528cefcSMark Murray }
310b528cefcSMark Murray
311b528cefcSMark Murray /*
312b528cefcSMark Murray * This can't be made into a function...
313b528cefcSMark Murray */
314b528cefcSMark Murray
3154137ff4cSJacques Vidrine #ifdef HAVE_LONG_LONG
3164137ff4cSJacques Vidrine
3174137ff4cSJacques Vidrine #define PARSE_INT_FORMAT(res, arg, unsig) \
3184137ff4cSJacques Vidrine if (long_long_flag) \
3194137ff4cSJacques Vidrine res = (unsig long long)va_arg(arg, unsig long long); \
3204137ff4cSJacques Vidrine else if (long_flag) \
3214137ff4cSJacques Vidrine res = (unsig long)va_arg(arg, unsig long); \
322c19800e8SDoug Rabson else if (size_t_flag) \
323c19800e8SDoug Rabson res = (unsig long)va_arg(arg, size_t); \
3244137ff4cSJacques Vidrine else if (short_flag) \
3254137ff4cSJacques Vidrine res = (unsig short)va_arg(arg, unsig int); \
3264137ff4cSJacques Vidrine else \
3274137ff4cSJacques Vidrine res = (unsig int)va_arg(arg, unsig int)
3284137ff4cSJacques Vidrine
3294137ff4cSJacques Vidrine #else
3304137ff4cSJacques Vidrine
331b528cefcSMark Murray #define PARSE_INT_FORMAT(res, arg, unsig) \
332b528cefcSMark Murray if (long_flag) \
333b528cefcSMark Murray res = (unsig long)va_arg(arg, unsig long); \
334c19800e8SDoug Rabson else if (size_t_flag) \
335c19800e8SDoug Rabson res = (unsig long)va_arg(arg, size_t); \
336b528cefcSMark Murray else if (short_flag) \
337d61f1c79SMark Murray res = (unsig short)va_arg(arg, unsig int); \
338b528cefcSMark Murray else \
339b528cefcSMark Murray res = (unsig int)va_arg(arg, unsig int)
340b528cefcSMark Murray
3414137ff4cSJacques Vidrine #endif
3424137ff4cSJacques Vidrine
343b528cefcSMark Murray /*
3444137ff4cSJacques Vidrine * zyxprintf - return length, as snprintf
345b528cefcSMark Murray */
346b528cefcSMark Murray
347ae771770SStanislav Sedov static size_t
xyzprintf(struct snprintf_state * state,const char * char_format,va_list ap)3484137ff4cSJacques Vidrine xyzprintf (struct snprintf_state *state, const char *char_format, va_list ap)
349b528cefcSMark Murray {
350b528cefcSMark Murray const unsigned char *format = (const unsigned char *)char_format;
351b528cefcSMark Murray unsigned char c;
352ae771770SStanislav Sedov size_t len = 0;
353b528cefcSMark Murray
354b528cefcSMark Murray while((c = *format++)) {
355b528cefcSMark Murray if (c == '%') {
356b528cefcSMark Murray int flags = 0;
357b528cefcSMark Murray int width = 0;
358b528cefcSMark Murray int prec = -1;
359c19800e8SDoug Rabson int size_t_flag = 0;
3604137ff4cSJacques Vidrine int long_long_flag = 0;
361b528cefcSMark Murray int long_flag = 0;
362b528cefcSMark Murray int short_flag = 0;
363b528cefcSMark Murray
364b528cefcSMark Murray /* flags */
365b528cefcSMark Murray while((c = *format++)){
366b528cefcSMark Murray if(c == '-')
367b528cefcSMark Murray flags |= minus_flag;
368b528cefcSMark Murray else if(c == '+')
369b528cefcSMark Murray flags |= plus_flag;
370b528cefcSMark Murray else if(c == ' ')
371b528cefcSMark Murray flags |= space_flag;
372b528cefcSMark Murray else if(c == '#')
373b528cefcSMark Murray flags |= alternate_flag;
374b528cefcSMark Murray else if(c == '0')
375b528cefcSMark Murray flags |= zero_flag;
376bbd80c28SJacques Vidrine else if(c == '\'')
377bbd80c28SJacques Vidrine ; /* just ignore */
378b528cefcSMark Murray else
379b528cefcSMark Murray break;
380b528cefcSMark Murray }
381b528cefcSMark Murray
382b528cefcSMark Murray if((flags & space_flag) && (flags & plus_flag))
383b528cefcSMark Murray flags ^= space_flag;
384b528cefcSMark Murray
385b528cefcSMark Murray if((flags & minus_flag) && (flags & zero_flag))
386b528cefcSMark Murray flags ^= zero_flag;
387b528cefcSMark Murray
388b528cefcSMark Murray /* width */
389b528cefcSMark Murray if (isdigit(c))
390b528cefcSMark Murray do {
391b528cefcSMark Murray width = width * 10 + c - '0';
392b528cefcSMark Murray c = *format++;
393b528cefcSMark Murray } while(isdigit(c));
394b528cefcSMark Murray else if(c == '*') {
395b528cefcSMark Murray width = va_arg(ap, int);
396b528cefcSMark Murray c = *format++;
397b528cefcSMark Murray }
398b528cefcSMark Murray
399b528cefcSMark Murray /* precision */
400b528cefcSMark Murray if (c == '.') {
401b528cefcSMark Murray prec = 0;
402b528cefcSMark Murray c = *format++;
403b528cefcSMark Murray if (isdigit(c))
404b528cefcSMark Murray do {
405b528cefcSMark Murray prec = prec * 10 + c - '0';
406b528cefcSMark Murray c = *format++;
407b528cefcSMark Murray } while(isdigit(c));
408b528cefcSMark Murray else if (c == '*') {
409b528cefcSMark Murray prec = va_arg(ap, int);
410b528cefcSMark Murray c = *format++;
411b528cefcSMark Murray }
412b528cefcSMark Murray }
413b528cefcSMark Murray
414b528cefcSMark Murray /* size */
415b528cefcSMark Murray
416b528cefcSMark Murray if (c == 'h') {
417b528cefcSMark Murray short_flag = 1;
418b528cefcSMark Murray c = *format++;
419c19800e8SDoug Rabson } else if (c == 'z') {
420c19800e8SDoug Rabson size_t_flag = 1;
421c19800e8SDoug Rabson c = *format++;
422b528cefcSMark Murray } else if (c == 'l') {
423b528cefcSMark Murray long_flag = 1;
424b528cefcSMark Murray c = *format++;
4254137ff4cSJacques Vidrine if (c == 'l') {
4264137ff4cSJacques Vidrine long_long_flag = 1;
4274137ff4cSJacques Vidrine c = *format++;
4284137ff4cSJacques Vidrine }
429b528cefcSMark Murray }
430b528cefcSMark Murray
431c19800e8SDoug Rabson if(c != 'd' && c != 'i')
432c19800e8SDoug Rabson flags &= ~(plus_flag | space_flag);
433c19800e8SDoug Rabson
434b528cefcSMark Murray switch (c) {
435b528cefcSMark Murray case 'c' :
4364137ff4cSJacques Vidrine append_char(state, va_arg(ap, int), width, flags);
4374137ff4cSJacques Vidrine ++len;
438b528cefcSMark Murray break;
439b528cefcSMark Murray case 's' :
4404137ff4cSJacques Vidrine len += append_string(state,
441b528cefcSMark Murray va_arg(ap, unsigned char*),
442b528cefcSMark Murray width,
443b528cefcSMark Murray prec,
4444137ff4cSJacques Vidrine flags);
445b528cefcSMark Murray break;
446b528cefcSMark Murray case 'd' :
447b528cefcSMark Murray case 'i' : {
4484137ff4cSJacques Vidrine longest arg;
4494137ff4cSJacques Vidrine u_longest num;
450b528cefcSMark Murray int minusp = 0;
451b528cefcSMark Murray
452b528cefcSMark Murray PARSE_INT_FORMAT(arg, ap, signed);
453b528cefcSMark Murray
454b528cefcSMark Murray if (arg < 0) {
455b528cefcSMark Murray minusp = 1;
456b528cefcSMark Murray num = -arg;
457b528cefcSMark Murray } else
458b528cefcSMark Murray num = arg;
459b528cefcSMark Murray
4604137ff4cSJacques Vidrine len += append_number (state, num, 10, "0123456789",
4614137ff4cSJacques Vidrine width, prec, flags, minusp);
462b528cefcSMark Murray break;
463b528cefcSMark Murray }
464b528cefcSMark Murray case 'u' : {
4654137ff4cSJacques Vidrine u_longest arg;
466b528cefcSMark Murray
467b528cefcSMark Murray PARSE_INT_FORMAT(arg, ap, unsigned);
468b528cefcSMark Murray
4694137ff4cSJacques Vidrine len += append_number (state, arg, 10, "0123456789",
4704137ff4cSJacques Vidrine width, prec, flags, 0);
471b528cefcSMark Murray break;
472b528cefcSMark Murray }
473b528cefcSMark Murray case 'o' : {
4744137ff4cSJacques Vidrine u_longest arg;
475b528cefcSMark Murray
476b528cefcSMark Murray PARSE_INT_FORMAT(arg, ap, unsigned);
477b528cefcSMark Murray
4784137ff4cSJacques Vidrine len += append_number (state, arg, 010, "01234567",
4794137ff4cSJacques Vidrine width, prec, flags, 0);
480b528cefcSMark Murray break;
481b528cefcSMark Murray }
482b528cefcSMark Murray case 'x' : {
4834137ff4cSJacques Vidrine u_longest arg;
484b528cefcSMark Murray
485b528cefcSMark Murray PARSE_INT_FORMAT(arg, ap, unsigned);
486b528cefcSMark Murray
4874137ff4cSJacques Vidrine len += append_number (state, arg, 0x10, "0123456789abcdef",
4884137ff4cSJacques Vidrine width, prec, flags, 0);
489b528cefcSMark Murray break;
490b528cefcSMark Murray }
491b528cefcSMark Murray case 'X' :{
4924137ff4cSJacques Vidrine u_longest arg;
493b528cefcSMark Murray
494b528cefcSMark Murray PARSE_INT_FORMAT(arg, ap, unsigned);
495b528cefcSMark Murray
4964137ff4cSJacques Vidrine len += append_number (state, arg, 0x10, "0123456789ABCDEF",
4974137ff4cSJacques Vidrine width, prec, flags, 0);
498b528cefcSMark Murray break;
499b528cefcSMark Murray }
500b528cefcSMark Murray case 'p' : {
501e4456411SJohn Baldwin u_longest arg = (uintptr_t)va_arg(ap, void*);
502b528cefcSMark Murray
5034137ff4cSJacques Vidrine len += append_number (state, arg, 0x10, "0123456789ABCDEF",
5044137ff4cSJacques Vidrine width, prec, flags, 0);
505b528cefcSMark Murray break;
506b528cefcSMark Murray }
507b528cefcSMark Murray case 'n' : {
508b528cefcSMark Murray int *arg = va_arg(ap, int*);
509b528cefcSMark Murray *arg = state->s - state->str;
510b528cefcSMark Murray break;
511b528cefcSMark Murray }
512b528cefcSMark Murray case '\0' :
513b528cefcSMark Murray --format;
514b528cefcSMark Murray /* FALLTHROUGH */
515b528cefcSMark Murray case '%' :
5164137ff4cSJacques Vidrine (*state->append_char)(state, c);
5174137ff4cSJacques Vidrine ++len;
518b528cefcSMark Murray break;
519b528cefcSMark Murray default :
5204137ff4cSJacques Vidrine (*state->append_char)(state, '%');
5214137ff4cSJacques Vidrine (*state->append_char)(state, c);
5224137ff4cSJacques Vidrine len += 2;
523b528cefcSMark Murray break;
524b528cefcSMark Murray }
5254137ff4cSJacques Vidrine } else {
5264137ff4cSJacques Vidrine (*state->append_char) (state, c);
5274137ff4cSJacques Vidrine ++len;
528b528cefcSMark Murray }
5294137ff4cSJacques Vidrine }
5304137ff4cSJacques Vidrine return len;
531b528cefcSMark Murray }
532b528cefcSMark Murray
5334137ff4cSJacques Vidrine #if !defined(HAVE_SNPRINTF) || defined(TEST_SNPRINTF)
534ae771770SStanislav Sedov ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_snprintf(char * str,size_t sz,const char * format,...)535ae771770SStanislav Sedov rk_snprintf (char *str, size_t sz, const char *format, ...)
536b528cefcSMark Murray {
537b528cefcSMark Murray va_list args;
538b528cefcSMark Murray int ret;
539b528cefcSMark Murray
540b528cefcSMark Murray va_start(args, format);
541b528cefcSMark Murray ret = vsnprintf (str, sz, format, args);
5424137ff4cSJacques Vidrine va_end(args);
543b528cefcSMark Murray
544b528cefcSMark Murray #ifdef PARANOIA
545b528cefcSMark Murray {
546b528cefcSMark Murray int ret2;
547b528cefcSMark Murray char *tmp;
548b528cefcSMark Murray
549b528cefcSMark Murray tmp = malloc (sz);
550b528cefcSMark Murray if (tmp == NULL)
551b528cefcSMark Murray abort ();
552b528cefcSMark Murray
5534137ff4cSJacques Vidrine va_start(args, format);
554b528cefcSMark Murray ret2 = vsprintf (tmp, format, args);
5554137ff4cSJacques Vidrine va_end(args);
556b528cefcSMark Murray if (ret != ret2 || strcmp(str, tmp))
557b528cefcSMark Murray abort ();
558b528cefcSMark Murray free (tmp);
559b528cefcSMark Murray }
560b528cefcSMark Murray #endif
561b528cefcSMark Murray
562b528cefcSMark Murray return ret;
563b528cefcSMark Murray }
564b528cefcSMark Murray #endif
565b528cefcSMark Murray
5664137ff4cSJacques Vidrine #if !defined(HAVE_ASPRINTF) || defined(TEST_SNPRINTF)
567ae771770SStanislav Sedov ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_asprintf(char ** ret,const char * format,...)568ae771770SStanislav Sedov rk_asprintf (char **ret, const char *format, ...)
569b528cefcSMark Murray {
570b528cefcSMark Murray va_list args;
571b528cefcSMark Murray int val;
572b528cefcSMark Murray
573b528cefcSMark Murray va_start(args, format);
574b528cefcSMark Murray val = vasprintf (ret, format, args);
5754137ff4cSJacques Vidrine va_end(args);
576b528cefcSMark Murray
577b528cefcSMark Murray #ifdef PARANOIA
578b528cefcSMark Murray {
579b528cefcSMark Murray int ret2;
580b528cefcSMark Murray char *tmp;
581b528cefcSMark Murray tmp = malloc (val + 1);
582b528cefcSMark Murray if (tmp == NULL)
583b528cefcSMark Murray abort ();
584b528cefcSMark Murray
5854137ff4cSJacques Vidrine va_start(args, format);
586b528cefcSMark Murray ret2 = vsprintf (tmp, format, args);
5874137ff4cSJacques Vidrine va_end(args);
588b528cefcSMark Murray if (val != ret2 || strcmp(*ret, tmp))
589b528cefcSMark Murray abort ();
590b528cefcSMark Murray free (tmp);
591b528cefcSMark Murray }
592b528cefcSMark Murray #endif
593b528cefcSMark Murray
594b528cefcSMark Murray return val;
595b528cefcSMark Murray }
596b528cefcSMark Murray #endif
597b528cefcSMark Murray
5984137ff4cSJacques Vidrine #if !defined(HAVE_ASNPRINTF) || defined(TEST_SNPRINTF)
599ae771770SStanislav Sedov ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_asnprintf(char ** ret,size_t max_sz,const char * format,...)600ae771770SStanislav Sedov rk_asnprintf (char **ret, size_t max_sz, const char *format, ...)
601b528cefcSMark Murray {
602b528cefcSMark Murray va_list args;
603b528cefcSMark Murray int val;
604b528cefcSMark Murray
605b528cefcSMark Murray va_start(args, format);
606b528cefcSMark Murray val = vasnprintf (ret, max_sz, format, args);
607b528cefcSMark Murray
608b528cefcSMark Murray #ifdef PARANOIA
609b528cefcSMark Murray {
610b528cefcSMark Murray int ret2;
611b528cefcSMark Murray char *tmp;
612b528cefcSMark Murray tmp = malloc (val + 1);
613b528cefcSMark Murray if (tmp == NULL)
614b528cefcSMark Murray abort ();
615b528cefcSMark Murray
616b528cefcSMark Murray ret2 = vsprintf (tmp, format, args);
617b528cefcSMark Murray if (val != ret2 || strcmp(*ret, tmp))
618b528cefcSMark Murray abort ();
619b528cefcSMark Murray free (tmp);
620b528cefcSMark Murray }
621b528cefcSMark Murray #endif
622b528cefcSMark Murray
623b528cefcSMark Murray va_end(args);
624b528cefcSMark Murray return val;
625b528cefcSMark Murray }
626b528cefcSMark Murray #endif
627b528cefcSMark Murray
6284137ff4cSJacques Vidrine #if !defined(HAVE_VASPRINTF) || defined(TEST_SNPRINTF)
629ae771770SStanislav Sedov ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_vasprintf(char ** ret,const char * format,va_list args)630ae771770SStanislav Sedov rk_vasprintf (char **ret, const char *format, va_list args)
631b528cefcSMark Murray {
632b528cefcSMark Murray return vasnprintf (ret, 0, format, args);
633b528cefcSMark Murray }
634b528cefcSMark Murray #endif
635b528cefcSMark Murray
636b528cefcSMark Murray
6374137ff4cSJacques Vidrine #if !defined(HAVE_VASNPRINTF) || defined(TEST_SNPRINTF)
638ae771770SStanislav Sedov ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_vasnprintf(char ** ret,size_t max_sz,const char * format,va_list args)639ae771770SStanislav Sedov rk_vasnprintf (char **ret, size_t max_sz, const char *format, va_list args)
640b528cefcSMark Murray {
641ae771770SStanislav Sedov size_t st;
6424137ff4cSJacques Vidrine struct snprintf_state state;
643b528cefcSMark Murray
644b528cefcSMark Murray state.max_sz = max_sz;
645b528cefcSMark Murray state.sz = 1;
646b528cefcSMark Murray state.str = malloc(state.sz);
647b528cefcSMark Murray if (state.str == NULL) {
648b528cefcSMark Murray *ret = NULL;
649b528cefcSMark Murray return -1;
650b528cefcSMark Murray }
651b528cefcSMark Murray state.s = state.str;
652b528cefcSMark Murray state.theend = state.s + state.sz - 1;
653b528cefcSMark Murray state.append_char = as_append_char;
654b528cefcSMark Murray
655b528cefcSMark Murray st = xyzprintf (&state, format, args);
6564137ff4cSJacques Vidrine if (st > state.sz) {
657b528cefcSMark Murray free (state.str);
658b528cefcSMark Murray *ret = NULL;
659b528cefcSMark Murray return -1;
660b528cefcSMark Murray } else {
661b528cefcSMark Murray char *tmp;
662b528cefcSMark Murray
663b528cefcSMark Murray *state.s = '\0';
6644137ff4cSJacques Vidrine tmp = realloc (state.str, st+1);
665b528cefcSMark Murray if (tmp == NULL) {
666b528cefcSMark Murray free (state.str);
667b528cefcSMark Murray *ret = NULL;
668b528cefcSMark Murray return -1;
669b528cefcSMark Murray }
670b528cefcSMark Murray *ret = tmp;
6714137ff4cSJacques Vidrine return st;
672b528cefcSMark Murray }
673b528cefcSMark Murray }
674b528cefcSMark Murray #endif
675b528cefcSMark Murray
6764137ff4cSJacques Vidrine #if !defined(HAVE_VSNPRINTF) || defined(TEST_SNPRINTF)
677ae771770SStanislav Sedov ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL
rk_vsnprintf(char * str,size_t sz,const char * format,va_list args)678ae771770SStanislav Sedov rk_vsnprintf (char *str, size_t sz, const char *format, va_list args)
679b528cefcSMark Murray {
6804137ff4cSJacques Vidrine struct snprintf_state state;
681b528cefcSMark Murray int ret;
682b528cefcSMark Murray unsigned char *ustr = (unsigned char *)str;
683b528cefcSMark Murray
684b528cefcSMark Murray state.max_sz = 0;
685b528cefcSMark Murray state.sz = sz;
686b528cefcSMark Murray state.str = ustr;
687b528cefcSMark Murray state.s = ustr;
6884137ff4cSJacques Vidrine state.theend = ustr + sz - (sz > 0);
689b528cefcSMark Murray state.append_char = sn_append_char;
690b528cefcSMark Murray
691b528cefcSMark Murray ret = xyzprintf (&state, format, args);
692c19800e8SDoug Rabson if (state.s != NULL && sz != 0)
693b528cefcSMark Murray *state.s = '\0';
6944137ff4cSJacques Vidrine return ret;
695b528cefcSMark Murray }
696b528cefcSMark Murray #endif
697