diff options
Diffstat (limited to 'openbsd-compat/bsd-snprintf.c')
-rw-r--r-- | openbsd-compat/bsd-snprintf.c | 1290 |
1 files changed, 603 insertions, 687 deletions
diff --git a/openbsd-compat/bsd-snprintf.c b/openbsd-compat/bsd-snprintf.c index c75359c51..55d14284d 100644 --- a/openbsd-compat/bsd-snprintf.c +++ b/openbsd-compat/bsd-snprintf.c | |||
@@ -38,60 +38,37 @@ | |||
38 | * missing. Some systems only have snprintf() but not vsnprintf(), so | 38 | * missing. Some systems only have snprintf() but not vsnprintf(), so |
39 | * the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF. | 39 | * the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF. |
40 | * | 40 | * |
41 | * Ben Lindstrom <mouring@pconline.com> 09/27/00 for OpenSSH | 41 | * Ben Lindstrom <mouring@eviladmin.org> 09/27/00 for OpenSSH |
42 | * Welcome to the world of %lld and %qd support. With other | 42 | * Welcome to the world of %lld and %qd support. With other |
43 | * long long support. This is needed for sftp-server to work | 43 | * long long support. This is needed for sftp-server to work |
44 | * right. | 44 | * right. |
45 | * | ||
46 | * Ben Lindstrom <mouring@eviladmin.org> 02/12/01 for OpenSSH | ||
47 | * Removed all hint of VARARGS stuff and banished it to the void, | ||
48 | * and did a bit of KNF style work to make things a bit more | ||
49 | * acceptable. Consider stealing from mutt or enlightenment. | ||
45 | **************************************************************/ | 50 | **************************************************************/ |
46 | 51 | ||
47 | #include "includes.h" | 52 | #include "includes.h" |
48 | 53 | ||
49 | RCSID("$Id: bsd-snprintf.c,v 1.2 2001/02/09 01:55:36 djm Exp $"); | 54 | RCSID("$Id: bsd-snprintf.c,v 1.3 2001/02/13 02:18:50 mouring Exp $"); |
50 | 55 | ||
51 | #if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) | 56 | #if !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) |
52 | 57 | ||
53 | #include <string.h> | 58 | static void |
54 | # include <ctype.h> | 59 | dopr(char *buffer, size_t maxlen, const char *format, va_list args); |
55 | #include <sys/types.h> | 60 | |
56 | 61 | static void | |
57 | /* Define this as a fall through, HAVE_STDARG_H is probably already set */ | 62 | fmtstr(char *buffer, size_t *currlen, size_t maxlen, char *value, int flags, |
58 | 63 | int min, int max); | |
59 | #define HAVE_VARARGS_H | 64 | |
60 | 65 | static void | |
61 | /* varargs declarations: */ | 66 | fmtint(char *buffer, size_t *currlen, size_t maxlen, long value, int base, |
62 | 67 | int min, int max, int flags); | |
63 | #if defined(HAVE_STDARG_H) | 68 | |
64 | # include <stdarg.h> | 69 | static void |
65 | # define HAVE_STDARGS /* let's hope that works everywhere (mj) */ | 70 | fmtfp(char *buffer, size_t *currlen, size_t maxlen, long double fvalue, |
66 | # define VA_LOCAL_DECL va_list ap | 71 | int min, int max, int flags); |
67 | # define VA_START(f) va_start(ap, f) | ||
68 | # define VA_SHIFT(v,t) ; /* no-op for ANSI */ | ||
69 | # define VA_END va_end(ap) | ||
70 | #else | ||
71 | # if defined(HAVE_VARARGS_H) | ||
72 | # include <varargs.h> | ||
73 | # undef HAVE_STDARGS | ||
74 | # define VA_LOCAL_DECL va_list ap | ||
75 | # define VA_START(f) va_start(ap) /* f is ignored! */ | ||
76 | # define VA_SHIFT(v,t) v = va_arg(ap,t) | ||
77 | # define VA_END va_end(ap) | ||
78 | # else | ||
79 | /*XX ** NO VARARGS ** XX*/ | ||
80 | # endif | ||
81 | #endif | ||
82 | |||
83 | /*int snprintf (char *str, size_t count, const char *fmt, ...);*/ | ||
84 | /*int vsnprintf (char *str, size_t count, const char *fmt, va_list arg);*/ | ||
85 | |||
86 | static void dopr (char *buffer, size_t maxlen, const char *format, | ||
87 | va_list args); | ||
88 | static void fmtstr (char *buffer, size_t *currlen, size_t maxlen, | ||
89 | char *value, int flags, int min, int max); | ||
90 | static void fmtint (char *buffer, size_t *currlen, size_t maxlen, | ||
91 | long value, int base, int min, int max, int flags); | ||
92 | static void fmtfp (char *buffer, size_t *currlen, size_t maxlen, | ||
93 | long double fvalue, int min, int max, int flags); | ||
94 | static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c ); | ||
95 | 72 | ||
96 | /* | 73 | /* |
97 | * dopr(): poor man's version of doprintf | 74 | * dopr(): poor man's version of doprintf |
@@ -123,697 +100,636 @@ static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c ); | |||
123 | #define DP_C_LONG_LONG 4 | 100 | #define DP_C_LONG_LONG 4 |
124 | 101 | ||
125 | #define char_to_int(p) (p - '0') | 102 | #define char_to_int(p) (p - '0') |
126 | #ifndef MAX | 103 | #define abs_val(p) (p < 0 ? -p : p) |
127 | # define MAX(p,q) ((p >= q) ? p : q) | ||
128 | #endif | ||
129 | 104 | ||
130 | static void dopr (char *buffer, size_t maxlen, const char *format, va_list args) | 105 | |
106 | static void | ||
107 | dopr(char *buffer, size_t maxlen, const char *format, va_list args) | ||
131 | { | 108 | { |
132 | char ch; | 109 | char *strvalue; |
133 | long value; | 110 | char ch; |
134 | long double fvalue; | 111 | long value; |
135 | char *strvalue; | 112 | long double fvalue; |
136 | int min; | 113 | int min = 0; |
137 | int max; | 114 | int max = -1; |
138 | int state; | 115 | int state = DP_S_DEFAULT; |
139 | int flags; | 116 | int flags = 0; |
140 | int cflags; | 117 | int cflags = 0; |
141 | size_t currlen; | 118 | size_t currlen = 0; |
142 | 119 | ||
143 | state = DP_S_DEFAULT; | ||
144 | currlen = flags = cflags = min = 0; | ||
145 | max = -1; | ||
146 | ch = *format++; | ||
147 | |||
148 | while (state != DP_S_DONE) | ||
149 | { | ||
150 | if ((ch == '\0') || (currlen >= maxlen)) | ||
151 | state = DP_S_DONE; | ||
152 | |||
153 | switch(state) | ||
154 | { | ||
155 | case DP_S_DEFAULT: | ||
156 | if (ch == '%') | ||
157 | state = DP_S_FLAGS; | ||
158 | else | ||
159 | dopr_outch (buffer, &currlen, maxlen, ch); | ||
160 | ch = *format++; | ||
161 | break; | ||
162 | case DP_S_FLAGS: | ||
163 | switch (ch) | ||
164 | { | ||
165 | case '-': | ||
166 | flags |= DP_F_MINUS; | ||
167 | ch = *format++; | ||
168 | break; | ||
169 | case '+': | ||
170 | flags |= DP_F_PLUS; | ||
171 | ch = *format++; | ||
172 | break; | ||
173 | case ' ': | ||
174 | flags |= DP_F_SPACE; | ||
175 | ch = *format++; | ||
176 | break; | ||
177 | case '#': | ||
178 | flags |= DP_F_NUM; | ||
179 | ch = *format++; | ||
180 | break; | ||
181 | case '0': | ||
182 | flags |= DP_F_ZERO; | ||
183 | ch = *format++; | ||
184 | break; | ||
185 | default: | ||
186 | state = DP_S_MIN; | ||
187 | break; | ||
188 | } | ||
189 | break; | ||
190 | case DP_S_MIN: | ||
191 | if (isdigit((unsigned char)ch)) | ||
192 | { | ||
193 | min = 10*min + char_to_int (ch); | ||
194 | ch = *format++; | ||
195 | } | ||
196 | else if (ch == '*') | ||
197 | { | ||
198 | min = va_arg (args, int); | ||
199 | ch = *format++; | ||
200 | state = DP_S_DOT; | ||
201 | } | ||
202 | else | ||
203 | state = DP_S_DOT; | ||
204 | break; | ||
205 | case DP_S_DOT: | ||
206 | if (ch == '.') | ||
207 | { | ||
208 | state = DP_S_MAX; | ||
209 | ch = *format++; | 120 | ch = *format++; |
210 | } | 121 | |
211 | else | 122 | while (state != DP_S_DONE) { |
212 | state = DP_S_MOD; | 123 | if ((ch == '\0') || (currlen >= maxlen)) |
213 | break; | 124 | state = DP_S_DONE; |
214 | case DP_S_MAX: | 125 | |
215 | if (isdigit((unsigned char)ch)) | 126 | switch(state) { |
216 | { | 127 | case DP_S_DEFAULT: |
217 | if (max < 0) | 128 | if (ch == '%') |
218 | max = 0; | 129 | state = DP_S_FLAGS; |
219 | max = 10*max + char_to_int (ch); | 130 | else |
220 | ch = *format++; | 131 | dopr_outch(buffer, &currlen, maxlen, ch); |
221 | } | 132 | ch = *format++; |
222 | else if (ch == '*') | 133 | break; |
223 | { | 134 | case DP_S_FLAGS: |
224 | max = va_arg (args, int); | 135 | switch (ch) { |
225 | ch = *format++; | 136 | case '-': |
226 | state = DP_S_MOD; | 137 | flags |= DP_F_MINUS; |
227 | } | 138 | ch = *format++; |
228 | else | 139 | break; |
229 | state = DP_S_MOD; | 140 | case '+': |
230 | break; | 141 | flags |= DP_F_PLUS; |
231 | case DP_S_MOD: | 142 | ch = *format++; |
232 | switch (ch) | 143 | break; |
233 | { | 144 | case ' ': |
234 | case 'h': | 145 | flags |= DP_F_SPACE; |
235 | cflags = DP_C_SHORT; | 146 | ch = *format++; |
236 | ch = *format++; | 147 | break; |
237 | break; | 148 | case '#': |
238 | case 'l': | 149 | flags |= DP_F_NUM; |
239 | cflags = DP_C_LONG; | 150 | ch = *format++; |
240 | ch = *format++; | 151 | break; |
241 | if (ch == 'l') { | 152 | case '0': |
242 | cflags = DP_C_LONG_LONG; | 153 | flags |= DP_F_ZERO; |
243 | ch = *format++; | 154 | ch = *format++; |
244 | } | 155 | break; |
245 | break; | 156 | default: |
246 | case 'q': | 157 | state = DP_S_MIN; |
247 | cflags = DP_C_LONG_LONG; | 158 | break; |
248 | ch = *format++; | 159 | } |
249 | break; | 160 | break; |
250 | case 'L': | 161 | case DP_S_MIN: |
251 | cflags = DP_C_LDOUBLE; | 162 | if (isdigit((unsigned char)ch)) { |
252 | ch = *format++; | 163 | min = 10*min + char_to_int (ch); |
253 | break; | 164 | ch = *format++; |
254 | default: | 165 | } else if (ch == '*') { |
255 | break; | 166 | min = va_arg (args, int); |
256 | } | 167 | ch = *format++; |
257 | state = DP_S_CONV; | 168 | state = DP_S_DOT; |
258 | break; | 169 | } else |
259 | case DP_S_CONV: | 170 | state = DP_S_DOT; |
260 | switch (ch) | 171 | break; |
261 | { | 172 | case DP_S_DOT: |
262 | case 'd': | 173 | if (ch == '.') { |
263 | case 'i': | 174 | state = DP_S_MAX; |
264 | if (cflags == DP_C_SHORT) | 175 | ch = *format++; |
265 | value = va_arg (args, int); | 176 | } else |
266 | else if (cflags == DP_C_LONG) | 177 | state = DP_S_MOD; |
267 | value = va_arg (args, long int); | 178 | break; |
268 | else if (cflags == DP_C_LONG_LONG) | 179 | case DP_S_MAX: |
269 | value = va_arg (args, long long); | 180 | if (isdigit((unsigned char)ch)) { |
270 | else | 181 | if (max < 0) |
271 | value = va_arg (args, int); | 182 | max = 0; |
272 | fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags); | 183 | max = 10*max + char_to_int(ch); |
273 | break; | 184 | ch = *format++; |
274 | case 'o': | 185 | } else if (ch == '*') { |
275 | flags |= DP_F_UNSIGNED; | 186 | max = va_arg (args, int); |
276 | if (cflags == DP_C_SHORT) | 187 | ch = *format++; |
277 | value = va_arg (args, unsigned int); | 188 | state = DP_S_MOD; |
278 | else if (cflags == DP_C_LONG) | 189 | } else |
279 | value = va_arg (args, unsigned long int); | 190 | state = DP_S_MOD; |
280 | else if (cflags == DP_C_LONG_LONG) | 191 | break; |
281 | value = va_arg (args, unsigned long long); | 192 | case DP_S_MOD: |
282 | else | 193 | switch (ch) { |
283 | value = va_arg (args, unsigned int); | 194 | case 'h': |
284 | fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags); | 195 | cflags = DP_C_SHORT; |
285 | break; | 196 | ch = *format++; |
286 | case 'u': | 197 | break; |
287 | flags |= DP_F_UNSIGNED; | 198 | case 'l': |
288 | if (cflags == DP_C_SHORT) | 199 | cflags = DP_C_LONG; |
289 | value = va_arg (args, unsigned int); | 200 | ch = *format++; |
290 | else if (cflags == DP_C_LONG) | 201 | if (ch == 'l') { |
291 | value = va_arg (args, unsigned long int); | 202 | cflags = DP_C_LONG_LONG; |
292 | else if (cflags == DP_C_LONG_LONG) | 203 | ch = *format++; |
293 | value = va_arg (args, unsigned long long); | 204 | } |
294 | else | 205 | break; |
295 | value = va_arg (args, unsigned int); | 206 | case 'q': |
296 | fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags); | 207 | cflags = DP_C_LONG_LONG; |
297 | break; | 208 | ch = *format++; |
298 | case 'X': | 209 | break; |
299 | flags |= DP_F_UP; | 210 | case 'L': |
300 | case 'x': | 211 | cflags = DP_C_LDOUBLE; |
301 | flags |= DP_F_UNSIGNED; | 212 | ch = *format++; |
302 | if (cflags == DP_C_SHORT) | 213 | break; |
303 | value = va_arg (args, unsigned int); | 214 | default: |
304 | else if (cflags == DP_C_LONG) | 215 | break; |
305 | value = va_arg (args, unsigned long int); | 216 | } |
306 | else if (cflags == DP_C_LONG_LONG) | 217 | state = DP_S_CONV; |
307 | value = va_arg (args, unsigned long long); | 218 | break; |
308 | else | 219 | case DP_S_CONV: |
309 | value = va_arg (args, unsigned int); | 220 | switch (ch) { |
310 | fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags); | 221 | case 'd': |
311 | break; | 222 | case 'i': |
312 | case 'f': | 223 | if (cflags == DP_C_SHORT) |
313 | if (cflags == DP_C_LDOUBLE) | 224 | value = va_arg(args, int); |
314 | fvalue = va_arg (args, long double); | 225 | else if (cflags == DP_C_LONG) |
315 | else | 226 | value = va_arg(args, long int); |
316 | fvalue = va_arg (args, double); | 227 | else if (cflags == DP_C_LONG_LONG) |
317 | /* um, floating point? */ | 228 | value = va_arg (args, long long); |
318 | fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags); | 229 | else |
319 | break; | 230 | value = va_arg (args, int); |
320 | case 'E': | 231 | fmtint(buffer, &currlen, maxlen, value, 10, min, max, flags); |
321 | flags |= DP_F_UP; | 232 | break; |
322 | case 'e': | 233 | case 'o': |
323 | if (cflags == DP_C_LDOUBLE) | 234 | flags |= DP_F_UNSIGNED; |
324 | fvalue = va_arg (args, long double); | 235 | if (cflags == DP_C_SHORT) |
325 | else | 236 | value = va_arg(args, unsigned int); |
326 | fvalue = va_arg (args, double); | 237 | else if (cflags == DP_C_LONG) |
327 | break; | 238 | value = va_arg(args, unsigned long int); |
328 | case 'G': | 239 | else if (cflags == DP_C_LONG_LONG) |
329 | flags |= DP_F_UP; | 240 | value = va_arg(args, unsigned long long); |
330 | case 'g': | 241 | else |
331 | if (cflags == DP_C_LDOUBLE) | 242 | value = va_arg(args, unsigned int); |
332 | fvalue = va_arg (args, long double); | 243 | fmtint(buffer, &currlen, maxlen, value, 8, min, max, flags); |
333 | else | 244 | break; |
334 | fvalue = va_arg (args, double); | 245 | case 'u': |
335 | break; | 246 | flags |= DP_F_UNSIGNED; |
336 | case 'c': | 247 | if (cflags == DP_C_SHORT) |
337 | dopr_outch (buffer, &currlen, maxlen, va_arg (args, int)); | 248 | value = va_arg(args, unsigned int); |
338 | break; | 249 | else if (cflags == DP_C_LONG) |
339 | case 's': | 250 | value = va_arg(args, unsigned long int); |
340 | strvalue = va_arg (args, char *); | 251 | else if (cflags == DP_C_LONG_LONG) |
341 | if (max < 0) | 252 | value = va_arg(args, unsigned long long); |
342 | max = maxlen; /* ie, no max */ | 253 | else |
343 | fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max); | 254 | value = va_arg(args, unsigned int); |
344 | break; | 255 | fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags); |
345 | case 'p': | 256 | break; |
346 | strvalue = va_arg (args, void *); | 257 | case 'X': |
347 | fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags); | 258 | flags |= DP_F_UP; |
348 | break; | 259 | case 'x': |
349 | case 'n': | 260 | flags |= DP_F_UNSIGNED; |
350 | if (cflags == DP_C_SHORT) | 261 | if (cflags == DP_C_SHORT) |
351 | { | 262 | value = va_arg(args, unsigned int); |
352 | short int *num; | 263 | else if (cflags == DP_C_LONG) |
353 | num = va_arg (args, short int *); | 264 | value = va_arg(args, unsigned long int); |
354 | *num = currlen; | 265 | else if (cflags == DP_C_LONG_LONG) |
355 | } | 266 | value = va_arg(args, unsigned long long); |
356 | else if (cflags == DP_C_LONG) | 267 | else |
357 | { | 268 | value = va_arg(args, unsigned int); |
358 | long int *num; | 269 | fmtint(buffer, &currlen, maxlen, value, 16, min, max, flags); |
359 | num = va_arg (args, long int *); | 270 | break; |
360 | *num = currlen; | 271 | case 'f': |
361 | } | 272 | if (cflags == DP_C_LDOUBLE) |
362 | else if (cflags == DP_C_LONG_LONG) | 273 | fvalue = va_arg(args, long double); |
363 | { | 274 | else |
364 | long long *num; | 275 | fvalue = va_arg(args, double); |
365 | num = va_arg (args, long long *); | 276 | /* um, floating point? */ |
366 | *num = currlen; | 277 | fmtfp(buffer, &currlen, maxlen, fvalue, min, max, flags); |
367 | } | 278 | break; |
279 | case 'E': | ||
280 | flags |= DP_F_UP; | ||
281 | case 'e': | ||
282 | if (cflags == DP_C_LDOUBLE) | ||
283 | fvalue = va_arg(args, long double); | ||
284 | else | ||
285 | fvalue = va_arg(args, double); | ||
286 | break; | ||
287 | case 'G': | ||
288 | flags |= DP_F_UP; | ||
289 | case 'g': | ||
290 | if (cflags == DP_C_LDOUBLE) | ||
291 | fvalue = va_arg(args, long double); | ||
292 | else | ||
293 | fvalue = va_arg(args, double); | ||
294 | break; | ||
295 | case 'c': | ||
296 | dopr_outch(buffer, &currlen, maxlen, va_arg(args, int)); | ||
297 | break; | ||
298 | case 's': | ||
299 | strvalue = va_arg(args, char *); | ||
300 | if (max < 0) | ||
301 | max = maxlen; /* ie, no max */ | ||
302 | fmtstr(buffer, &currlen, maxlen, strvalue, flags, min, max); | ||
303 | break; | ||
304 | case 'p': | ||
305 | strvalue = va_arg(args, void *); | ||
306 | fmtint(buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags); | ||
307 | break; | ||
308 | case 'n': | ||
309 | if (cflags == DP_C_SHORT) { | ||
310 | short int *num; | ||
311 | num = va_arg(args, short int *); | ||
312 | *num = currlen; | ||
313 | } else if (cflags == DP_C_LONG) { | ||
314 | long int *num; | ||
315 | num = va_arg(args, long int *); | ||
316 | *num = currlen; | ||
317 | } else if (cflags == DP_C_LONG_LONG) { | ||
318 | long long *num; | ||
319 | num = va_arg(args, long long *); | ||
320 | *num = currlen; | ||
321 | } else { | ||
322 | int *num; | ||
323 | num = va_arg(args, int *); | ||
324 | *num = currlen; | ||
325 | } | ||
326 | break; | ||
327 | case '%': | ||
328 | dopr_outch(buffer, &currlen, maxlen, ch); | ||
329 | break; | ||
330 | case 'w': /* not supported yet, treat as next char */ | ||
331 | ch = *format++; | ||
332 | break; | ||
333 | default: /* Unknown, skip */ | ||
334 | break; | ||
335 | } | ||
336 | ch = *format++; | ||
337 | state = DP_S_DEFAULT; | ||
338 | flags = cflags = min = 0; | ||
339 | max = -1; | ||
340 | break; | ||
341 | case DP_S_DONE: | ||
342 | break; | ||
343 | default: /* hmm? */ | ||
344 | break; /* some picky compilers need this */ | ||
345 | } | ||
346 | } | ||
347 | if (currlen < maxlen - 1) | ||
348 | buffer[currlen] = '\0'; | ||
368 | else | 349 | else |
369 | { | 350 | buffer[maxlen - 1] = '\0'; |
370 | int *num; | ||
371 | num = va_arg (args, int *); | ||
372 | *num = currlen; | ||
373 | } | ||
374 | break; | ||
375 | case '%': | ||
376 | dopr_outch (buffer, &currlen, maxlen, ch); | ||
377 | break; | ||
378 | case 'w': | ||
379 | /* not supported yet, treat as next char */ | ||
380 | ch = *format++; | ||
381 | break; | ||
382 | default: | ||
383 | /* Unknown, skip */ | ||
384 | break; | ||
385 | } | ||
386 | ch = *format++; | ||
387 | state = DP_S_DEFAULT; | ||
388 | flags = cflags = min = 0; | ||
389 | max = -1; | ||
390 | break; | ||
391 | case DP_S_DONE: | ||
392 | break; | ||
393 | default: | ||
394 | /* hmm? */ | ||
395 | break; /* some picky compilers need this */ | ||
396 | } | ||
397 | } | ||
398 | if (currlen < maxlen - 1) | ||
399 | buffer[currlen] = '\0'; | ||
400 | else | ||
401 | buffer[maxlen - 1] = '\0'; | ||
402 | } | 351 | } |
403 | 352 | ||
404 | static void fmtstr (char *buffer, size_t *currlen, size_t maxlen, | 353 | static void |
405 | char *value, int flags, int min, int max) | 354 | fmtstr(char *buffer, size_t *currlen, size_t maxlen, |
355 | char *value, int flags, int min, int max) | ||
406 | { | 356 | { |
407 | int padlen, strln; /* amount to pad */ | 357 | int padlen, strln; /* amount to pad */ |
408 | int cnt = 0; | 358 | int cnt = 0; |
409 | 359 | ||
410 | if (value == 0) | 360 | if (value == 0) |
411 | { | 361 | value = "<NULL>"; |
412 | value = "<NULL>"; | 362 | |
413 | } | 363 | for (strln = 0; value[strln]; ++strln); /* strlen */ |
414 | 364 | padlen = min - strln; | |
415 | for (strln = 0; value[strln]; ++strln); /* strlen */ | 365 | if (padlen < 0) |
416 | padlen = min - strln; | 366 | padlen = 0; |
417 | if (padlen < 0) | 367 | if (flags & DP_F_MINUS) |
418 | padlen = 0; | 368 | padlen = -padlen; /* Left Justify */ |
419 | if (flags & DP_F_MINUS) | 369 | |
420 | padlen = -padlen; /* Left Justify */ | 370 | while ((padlen > 0) && (cnt < max)) { |
421 | 371 | dopr_outch(buffer, currlen, maxlen, ' '); | |
422 | while ((padlen > 0) && (cnt < max)) | 372 | --padlen; |
423 | { | 373 | ++cnt; |
424 | dopr_outch (buffer, currlen, maxlen, ' '); | 374 | } |
425 | --padlen; | 375 | while (*value && (cnt < max)) { |
426 | ++cnt; | 376 | dopr_outch(buffer, currlen, maxlen, *value++); |
427 | } | 377 | ++cnt; |
428 | while (*value && (cnt < max)) | 378 | } |
429 | { | 379 | while ((padlen < 0) && (cnt < max)) { |
430 | dopr_outch (buffer, currlen, maxlen, *value++); | 380 | dopr_outch(buffer, currlen, maxlen, ' '); |
431 | ++cnt; | 381 | ++padlen; |
432 | } | 382 | ++cnt; |
433 | while ((padlen < 0) && (cnt < max)) | 383 | } |
434 | { | ||
435 | dopr_outch (buffer, currlen, maxlen, ' '); | ||
436 | ++padlen; | ||
437 | ++cnt; | ||
438 | } | ||
439 | } | 384 | } |
440 | 385 | ||
441 | /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */ | 386 | /* Have to handle DP_F_NUM (ie 0x and 0 alternates) */ |
442 | 387 | ||
443 | static void fmtint (char *buffer, size_t *currlen, size_t maxlen, | 388 | static void |
444 | long value, int base, int min, int max, int flags) | 389 | fmtint(char *buffer, size_t *currlen, size_t maxlen, |
390 | long value, int base, int min, int max, int flags) | ||
445 | { | 391 | { |
446 | int signvalue = 0; | 392 | unsigned long uvalue; |
447 | unsigned long uvalue; | 393 | char convert[20]; |
448 | char convert[20]; | 394 | int signvalue = 0; |
449 | int place = 0; | 395 | int place = 0; |
450 | int spadlen = 0; /* amount to space pad */ | 396 | int spadlen = 0; /* amount to space pad */ |
451 | int zpadlen = 0; /* amount to zero pad */ | 397 | int zpadlen = 0; /* amount to zero pad */ |
452 | int caps = 0; | 398 | int caps = 0; |
453 | 399 | ||
454 | if (max < 0) | 400 | if (max < 0) |
455 | max = 0; | 401 | max = 0; |
456 | 402 | ||
457 | uvalue = value; | 403 | uvalue = value; |
458 | 404 | ||
459 | if(!(flags & DP_F_UNSIGNED)) | 405 | if (!(flags & DP_F_UNSIGNED)) { |
460 | { | 406 | if (value < 0) { |
461 | if( value < 0 ) { | 407 | signvalue = '-'; |
462 | signvalue = '-'; | 408 | uvalue = -value; |
463 | uvalue = -value; | 409 | } else if (flags & DP_F_PLUS) /* Do a sign (+/i) */ |
464 | } | 410 | signvalue = '+'; |
465 | else | 411 | else if (flags & DP_F_SPACE) |
466 | if (flags & DP_F_PLUS) /* Do a sign (+/i) */ | 412 | signvalue = ' '; |
467 | signvalue = '+'; | 413 | } |
468 | else | ||
469 | if (flags & DP_F_SPACE) | ||
470 | signvalue = ' '; | ||
471 | } | ||
472 | 414 | ||
473 | if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */ | 415 | if (flags & DP_F_UP) |
474 | 416 | caps = 1; /* Should characters be upper case? */ | |
475 | do { | 417 | |
476 | convert[place++] = | 418 | do { |
477 | (caps? "0123456789ABCDEF":"0123456789abcdef") | 419 | convert[place++] = |
478 | [uvalue % (unsigned)base ]; | 420 | (caps? "0123456789ABCDEF":"0123456789abcdef") |
479 | uvalue = (uvalue / (unsigned)base ); | 421 | [uvalue % (unsigned)base]; |
480 | } while(uvalue && (place < 20)); | 422 | uvalue = (uvalue / (unsigned)base ); |
481 | if (place == 20) place--; | 423 | } while (uvalue && (place < 20)); |
482 | convert[place] = 0; | 424 | if (place == 20) |
483 | 425 | place--; | |
484 | zpadlen = max - place; | 426 | convert[place] = 0; |
485 | spadlen = min - MAX (max, place) - (signvalue ? 1 : 0); | 427 | |
486 | if (zpadlen < 0) zpadlen = 0; | 428 | zpadlen = max - place; |
487 | if (spadlen < 0) spadlen = 0; | 429 | spadlen = min - MAX (max, place) - (signvalue ? 1 : 0); |
488 | if (flags & DP_F_ZERO) | 430 | if (zpadlen < 0) |
489 | { | 431 | zpadlen = 0; |
490 | zpadlen = MAX(zpadlen, spadlen); | 432 | if (spadlen < 0) |
491 | spadlen = 0; | 433 | spadlen = 0; |
492 | } | 434 | if (flags & DP_F_ZERO) { |
493 | if (flags & DP_F_MINUS) | 435 | zpadlen = MAX(zpadlen, spadlen); |
494 | spadlen = -spadlen; /* Left Justifty */ | 436 | spadlen = 0; |
495 | 437 | } | |
496 | #ifdef DEBUG_SNPRINTF | 438 | if (flags & DP_F_MINUS) |
497 | dprint (1, (debugfile, "zpad: %d, spad: %d, min: %d, max: %d, place: %d\n", | 439 | spadlen = -spadlen; /* Left Justifty */ |
498 | zpadlen, spadlen, min, max, place)); | 440 | |
499 | #endif | 441 | |
500 | 442 | /* Spaces */ | |
501 | /* Spaces */ | 443 | while (spadlen > 0) { |
502 | while (spadlen > 0) | 444 | dopr_outch(buffer, currlen, maxlen, ' '); |
503 | { | 445 | --spadlen; |
504 | dopr_outch (buffer, currlen, maxlen, ' '); | 446 | } |
505 | --spadlen; | 447 | |
506 | } | 448 | /* Sign */ |
507 | 449 | if (signvalue) | |
508 | /* Sign */ | 450 | dopr_outch(buffer, currlen, maxlen, signvalue); |
509 | if (signvalue) | 451 | |
510 | dopr_outch (buffer, currlen, maxlen, signvalue); | 452 | /* Zeros */ |
511 | 453 | if (zpadlen > 0) { | |
512 | /* Zeros */ | 454 | while (zpadlen > 0) { |
513 | if (zpadlen > 0) | 455 | dopr_outch(buffer, currlen, maxlen, '0'); |
514 | { | 456 | --zpadlen; |
515 | while (zpadlen > 0) | 457 | } |
516 | { | 458 | } |
517 | dopr_outch (buffer, currlen, maxlen, '0'); | 459 | |
518 | --zpadlen; | 460 | /* Digits */ |
519 | } | 461 | while (place > 0) |
520 | } | 462 | dopr_outch(buffer, currlen, maxlen, convert[--place]); |
521 | |||
522 | /* Digits */ | ||
523 | while (place > 0) | ||
524 | dopr_outch (buffer, currlen, maxlen, convert[--place]); | ||
525 | 463 | ||
526 | /* Left Justified spaces */ | 464 | /* Left Justified spaces */ |
527 | while (spadlen < 0) { | 465 | while (spadlen < 0) { |
528 | dopr_outch (buffer, currlen, maxlen, ' '); | 466 | dopr_outch (buffer, currlen, maxlen, ' '); |
529 | ++spadlen; | 467 | ++spadlen; |
530 | } | 468 | } |
531 | } | ||
532 | |||
533 | static long double abs_val (long double value) | ||
534 | { | ||
535 | long double result = value; | ||
536 | |||
537 | if (value < 0) | ||
538 | result = -value; | ||
539 | |||
540 | return result; | ||
541 | } | 469 | } |
542 | 470 | ||
543 | static long double pow10 (int exp) | 471 | static long double |
472 | pow10(int exp) | ||
544 | { | 473 | { |
545 | long double result = 1; | 474 | long double result = 1; |
546 | 475 | ||
547 | while (exp) | 476 | while (exp) { |
548 | { | 477 | result *= 10; |
549 | result *= 10; | 478 | exp--; |
550 | exp--; | 479 | } |
551 | } | ||
552 | 480 | ||
553 | return result; | 481 | return result; |
554 | } | 482 | } |
555 | 483 | ||
556 | static long round (long double value) | 484 | static long |
485 | round(long double value) | ||
557 | { | 486 | { |
558 | long intpart; | 487 | long intpart = value; |
559 | 488 | ||
560 | intpart = value; | 489 | value -= intpart; |
561 | value = value - intpart; | 490 | if (value >= 0.5) |
562 | if (value >= 0.5) | 491 | intpart++; |
563 | intpart++; | ||
564 | 492 | ||
565 | return intpart; | 493 | return intpart; |
566 | } | 494 | } |
567 | 495 | ||
568 | static void fmtfp (char *buffer, size_t *currlen, size_t maxlen, | 496 | static void |
569 | long double fvalue, int min, int max, int flags) | 497 | fmtfp(char *buffer, size_t *currlen, size_t maxlen, long double fvalue, |
498 | int min, int max, int flags) | ||
570 | { | 499 | { |
571 | int signvalue = 0; | 500 | char iconvert[20]; |
572 | long double ufvalue; | 501 | char fconvert[20]; |
573 | char iconvert[20]; | 502 | int signvalue = 0; |
574 | char fconvert[20]; | 503 | int iplace = 0; |
575 | int iplace = 0; | 504 | int fplace = 0; |
576 | int fplace = 0; | 505 | int padlen = 0; /* amount to pad */ |
577 | int padlen = 0; /* amount to pad */ | 506 | int zpadlen = 0; |
578 | int zpadlen = 0; | 507 | int caps = 0; |
579 | int caps = 0; | 508 | long intpart; |
580 | long intpart; | 509 | long fracpart; |
581 | long fracpart; | 510 | long double ufvalue; |
582 | 511 | ||
583 | /* | 512 | /* |
584 | * AIX manpage says the default is 0, but Solaris says the default | 513 | * AIX manpage says the default is 0, but Solaris says the default |
585 | * is 6, and sprintf on AIX defaults to 6 | 514 | * is 6, and sprintf on AIX defaults to 6 |
586 | */ | 515 | */ |
587 | if (max < 0) | 516 | if (max < 0) |
588 | max = 6; | 517 | max = 6; |
589 | 518 | ||
590 | ufvalue = abs_val (fvalue); | 519 | ufvalue = abs_val(fvalue); |
591 | 520 | ||
592 | if (fvalue < 0) | 521 | if (fvalue < 0) |
593 | signvalue = '-'; | 522 | signvalue = '-'; |
594 | else | 523 | else if (flags & DP_F_PLUS) /* Do a sign (+/i) */ |
595 | if (flags & DP_F_PLUS) /* Do a sign (+/i) */ | 524 | signvalue = '+'; |
596 | signvalue = '+'; | 525 | else if (flags & DP_F_SPACE) |
597 | else | 526 | signvalue = ' '; |
598 | if (flags & DP_F_SPACE) | 527 | |
599 | signvalue = ' '; | 528 | intpart = ufvalue; |
600 | 529 | ||
601 | #if 0 | 530 | /* |
602 | if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */ | 531 | * Sorry, we only support 9 digits past the decimal because of our |
603 | #endif | 532 | * conversion method |
604 | 533 | */ | |
605 | intpart = ufvalue; | 534 | if (max > 9) |
606 | 535 | max = 9; | |
607 | /* | 536 | |
608 | * Sorry, we only support 9 digits past the decimal because of our | 537 | /* We "cheat" by converting the fractional part to integer by |
609 | * conversion method | 538 | * multiplying by a factor of 10 |
610 | */ | 539 | */ |
611 | if (max > 9) | 540 | fracpart = round((pow10 (max)) * (ufvalue - intpart)); |
612 | max = 9; | 541 | |
613 | 542 | if (fracpart >= pow10 (max)) { | |
614 | /* We "cheat" by converting the fractional part to integer by | 543 | intpart++; |
615 | * multiplying by a factor of 10 | 544 | fracpart -= pow10 (max); |
616 | */ | 545 | } |
617 | fracpart = round ((pow10 (max)) * (ufvalue - intpart)); | 546 | |
618 | 547 | /* Convert integer part */ | |
619 | if (fracpart >= pow10 (max)) | 548 | do { |
620 | { | 549 | iconvert[iplace++] = |
621 | intpart++; | 550 | (caps? "0123456789ABCDEF":"0123456789abcdef")[intpart % 10]; |
622 | fracpart -= pow10 (max); | 551 | intpart = (intpart / 10); |
623 | } | 552 | } while(intpart && (iplace < 20)); |
624 | 553 | if (iplace == 20) | |
625 | #ifdef DEBUG_SNPRINTF | 554 | iplace--; |
626 | dprint (1, (debugfile, "fmtfp: %f =? %d.%d\n", fvalue, intpart, fracpart)); | 555 | iconvert[iplace] = 0; |
627 | #endif | 556 | |
628 | 557 | /* Convert fractional part */ | |
629 | /* Convert integer part */ | 558 | do { |
630 | do { | 559 | fconvert[fplace++] = |
631 | iconvert[iplace++] = | 560 | (caps? "0123456789ABCDEF":"0123456789abcdef")[fracpart % 10]; |
632 | (caps? "0123456789ABCDEF":"0123456789abcdef")[intpart % 10]; | 561 | fracpart = (fracpart / 10); |
633 | intpart = (intpart / 10); | 562 | } while(fracpart && (fplace < 20)); |
634 | } while(intpart && (iplace < 20)); | 563 | if (fplace == 20) |
635 | if (iplace == 20) iplace--; | 564 | fplace--; |
636 | iconvert[iplace] = 0; | 565 | fconvert[fplace] = 0; |
637 | 566 | ||
638 | /* Convert fractional part */ | 567 | /* -1 for decimal point, another -1 if we are printing a sign */ |
639 | do { | 568 | padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); |
640 | fconvert[fplace++] = | 569 | zpadlen = max - fplace; |
641 | (caps? "0123456789ABCDEF":"0123456789abcdef")[fracpart % 10]; | 570 | if (zpadlen < 0) |
642 | fracpart = (fracpart / 10); | 571 | zpadlen = 0; |
643 | } while(fracpart && (fplace < 20)); | 572 | if (padlen < 0) |
644 | if (fplace == 20) fplace--; | 573 | padlen = 0; |
645 | fconvert[fplace] = 0; | 574 | if (flags & DP_F_MINUS) |
646 | 575 | padlen = -padlen; /* Left Justifty */ | |
647 | /* -1 for decimal point, another -1 if we are printing a sign */ | 576 | |
648 | padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0); | 577 | if ((flags & DP_F_ZERO) && (padlen > 0)) { |
649 | zpadlen = max - fplace; | 578 | if (signvalue) { |
650 | if (zpadlen < 0) | 579 | dopr_outch(buffer, currlen, maxlen, signvalue); |
651 | zpadlen = 0; | 580 | --padlen; |
652 | if (padlen < 0) | 581 | signvalue = 0; |
653 | padlen = 0; | 582 | } |
654 | if (flags & DP_F_MINUS) | 583 | while (padlen > 0) { |
655 | padlen = -padlen; /* Left Justifty */ | 584 | dopr_outch(buffer, currlen, maxlen, '0'); |
656 | 585 | --padlen; | |
657 | if ((flags & DP_F_ZERO) && (padlen > 0)) | 586 | } |
658 | { | 587 | } |
659 | if (signvalue) | 588 | while (padlen > 0) { |
660 | { | 589 | dopr_outch(buffer, currlen, maxlen, ' '); |
661 | dopr_outch (buffer, currlen, maxlen, signvalue); | 590 | --padlen; |
662 | --padlen; | 591 | } |
663 | signvalue = 0; | 592 | if (signvalue) |
664 | } | 593 | dopr_outch(buffer, currlen, maxlen, signvalue); |
665 | while (padlen > 0) | 594 | |
666 | { | 595 | while (iplace > 0) |
667 | dopr_outch (buffer, currlen, maxlen, '0'); | 596 | dopr_outch(buffer, currlen, maxlen, iconvert[--iplace]); |
668 | --padlen; | 597 | |
669 | } | 598 | /* |
670 | } | 599 | * Decimal point. This should probably use locale to find the correct |
671 | while (padlen > 0) | 600 | * char to print out. |
672 | { | 601 | */ |
673 | dopr_outch (buffer, currlen, maxlen, ' '); | 602 | dopr_outch(buffer, currlen, maxlen, '.'); |
674 | --padlen; | 603 | |
675 | } | 604 | while (fplace > 0) |
676 | if (signvalue) | 605 | dopr_outch(buffer, currlen, maxlen, fconvert[--fplace]); |
677 | dopr_outch (buffer, currlen, maxlen, signvalue); | 606 | |
678 | 607 | while (zpadlen > 0) { | |
679 | while (iplace > 0) | 608 | dopr_outch(buffer, currlen, maxlen, '0'); |
680 | dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]); | 609 | --zpadlen; |
681 | 610 | } | |
682 | /* | 611 | |
683 | * Decimal point. This should probably use locale to find the correct | 612 | while (padlen < 0) { |
684 | * char to print out. | 613 | dopr_outch(buffer, currlen, maxlen, ' '); |
685 | */ | 614 | ++padlen; |
686 | dopr_outch (buffer, currlen, maxlen, '.'); | 615 | } |
687 | |||
688 | while (fplace > 0) | ||
689 | dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]); | ||
690 | |||
691 | while (zpadlen > 0) | ||
692 | { | ||
693 | dopr_outch (buffer, currlen, maxlen, '0'); | ||
694 | --zpadlen; | ||
695 | } | ||
696 | |||
697 | while (padlen < 0) | ||
698 | { | ||
699 | dopr_outch (buffer, currlen, maxlen, ' '); | ||
700 | ++padlen; | ||
701 | } | ||
702 | } | 616 | } |
703 | 617 | ||
704 | static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c) | 618 | static void |
619 | dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c) | ||
705 | { | 620 | { |
706 | if (*currlen < maxlen) | 621 | if (*currlen < maxlen) |
707 | buffer[(*currlen)++] = c; | 622 | buffer[(*currlen)++] = c; |
708 | } | 623 | } |
709 | #endif /* !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) */ | 624 | #endif /* !defined(HAVE_SNPRINTF) || !defined(HAVE_VSNPRINTF) */ |
710 | 625 | ||
711 | #ifndef HAVE_VSNPRINTF | 626 | #ifndef HAVE_VSNPRINTF |
712 | int vsnprintf (char *str, size_t count, const char *fmt, va_list args) | 627 | int |
628 | vsnprintf(char *str, size_t count, const char *fmt, va_list args) | ||
713 | { | 629 | { |
714 | str[0] = 0; | 630 | str[0] = 0; |
715 | dopr(str, count, fmt, args); | 631 | dopr(str, count, fmt, args); |
716 | return(strlen(str)); | 632 | |
633 | return(strlen(str)); | ||
717 | } | 634 | } |
718 | #endif /* !HAVE_VSNPRINTF */ | 635 | #endif /* !HAVE_VSNPRINTF */ |
719 | 636 | ||
720 | #ifndef HAVE_SNPRINTF | 637 | #ifndef HAVE_SNPRINTF |
721 | /* VARARGS3 */ | 638 | int |
722 | #ifdef HAVE_STDARGS | 639 | snprintf(char *str,size_t count,const char *fmt,...) |
723 | int snprintf (char *str,size_t count,const char *fmt,...) | ||
724 | #else | ||
725 | int snprintf (va_alist) va_dcl | ||
726 | #endif | ||
727 | { | 640 | { |
728 | #ifndef HAVE_STDARGS | 641 | va_list ap; |
729 | char *str; | 642 | |
730 | size_t count; | 643 | va_start(ap, fmt); |
731 | char *fmt; | 644 | (void) vsnprintf(str, count, fmt, ap); |
732 | #endif | 645 | va_end(ap); |
733 | VA_LOCAL_DECL; | 646 | |
734 | 647 | return(strlen(str)); | |
735 | VA_START (fmt); | ||
736 | VA_SHIFT (str, char *); | ||
737 | VA_SHIFT (count, size_t ); | ||
738 | VA_SHIFT (fmt, char *); | ||
739 | (void) vsnprintf(str, count, fmt, ap); | ||
740 | VA_END; | ||
741 | return(strlen(str)); | ||
742 | } | 648 | } |
743 | 649 | ||
744 | #ifdef TEST_SNPRINTF | 650 | #ifdef TEST_SNPRINTF |
745 | #ifndef LONG_STRING | 651 | int |
746 | #define LONG_STRING 1024 | 652 | main(void) |
747 | #endif | ||
748 | int main (void) | ||
749 | { | 653 | { |
750 | char buf1[LONG_STRING]; | 654 | #define LONG_STRING 1024 |
751 | char buf2[LONG_STRING]; | 655 | char buf1[LONG_STRING]; |
752 | char *fp_fmt[] = { | 656 | char buf2[LONG_STRING]; |
753 | "%-1.5f", | 657 | char *fp_fmt[] = { |
754 | "%1.5f", | 658 | "%-1.5f", |
755 | "%123.9f", | 659 | "%1.5f", |
756 | "%10.5f", | 660 | "%123.9f", |
757 | "% 10.5f", | 661 | "%10.5f", |
758 | "%+22.9f", | 662 | "% 10.5f", |
759 | "%+4.9f", | 663 | "%+22.9f", |
760 | "%01.3f", | 664 | "%+4.9f", |
761 | "%4f", | 665 | "%01.3f", |
762 | "%3.1f", | 666 | "%4f", |
763 | "%3.2f", | 667 | "%3.1f", |
764 | NULL | 668 | "%3.2f", |
765 | }; | 669 | NULL |
766 | double fp_nums[] = { -1.5, 134.21, 91340.2, 341.1234, 0203.9, 0.96, 0.996, | 670 | }; |
767 | 0.9996, 1.996, 4.136, 0}; | 671 | double fp_nums[] = { |
768 | char *int_fmt[] = { | 672 | -1.5, |
769 | "%-1.5d", | 673 | 134.21, |
770 | "%1.5d", | 674 | 91340.2, |
771 | "%123.9d", | 675 | 341.1234, |
772 | "%5.5d", | 676 | 0203.9, |
773 | "%10.5d", | 677 | 0.96, |
774 | "% 10.5d", | 678 | 0.996, |
775 | "%+22.33d", | 679 | 0.9996, |
776 | "%01.3d", | 680 | 1.996, |
777 | "%4d", | 681 | 4.136, |
778 | "%lld", | 682 | 0 |
779 | "%qd", | 683 | }; |
780 | NULL | 684 | char *int_fmt[] = { |
781 | }; | 685 | "%-1.5d", |
782 | long long int_nums[] = { -1, 134, 91340, 341, 0203, 0, 9999999 }; | 686 | "%1.5d", |
783 | int x, y; | 687 | "%123.9d", |
784 | int fail = 0; | 688 | "%5.5d", |
785 | int num = 0; | 689 | "%10.5d", |
786 | 690 | "% 10.5d", | |
787 | printf ("Testing snprintf format codes against system sprintf...\n"); | 691 | "%+22.33d", |
788 | 692 | "%01.3d", | |
789 | for (x = 0; fp_fmt[x] != NULL ; x++) | 693 | "%4d", |
790 | for (y = 0; fp_nums[y] != 0 ; y++) | 694 | "%lld", |
791 | { | 695 | "%qd", |
792 | snprintf (buf1, sizeof (buf1), fp_fmt[x], fp_nums[y]); | 696 | NULL |
793 | sprintf (buf2, fp_fmt[x], fp_nums[y]); | 697 | }; |
794 | if (strcmp (buf1, buf2)) | 698 | long long int_nums[] = { -1, 134, 91340, 341, 0203, 0, 9999999 }; |
795 | { | 699 | int x, y; |
796 | printf("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf = %s\n", | 700 | int fail = 0; |
797 | fp_fmt[x], buf1, buf2); | 701 | int num = 0; |
798 | fail++; | 702 | |
799 | } | 703 | printf("Testing snprintf format codes against system sprintf...\n"); |
800 | num++; | 704 | |
801 | } | 705 | for (x = 0; fp_fmt[x] != NULL ; x++) { |
802 | 706 | for (y = 0; fp_nums[y] != 0 ; y++) { | |
803 | for (x = 0; int_fmt[x] != NULL ; x++) | 707 | snprintf(buf1, sizeof (buf1), fp_fmt[x], fp_nums[y]); |
804 | for (y = 0; int_nums[y] != 0 ; y++) | 708 | sprintf (buf2, fp_fmt[x], fp_nums[y]); |
805 | { | 709 | if (strcmp (buf1, buf2)) { |
806 | snprintf (buf1, sizeof (buf1), int_fmt[x], int_nums[y]); | 710 | printf("snprintf doesn't match Format: %s\n\t" |
807 | sprintf (buf2, int_fmt[x], int_nums[y]); | 711 | "snprintf = %s\n\tsprintf = %s\n", |
808 | if (strcmp (buf1, buf2)) | 712 | fp_fmt[x], buf1, buf2); |
809 | { | 713 | fail++; |
810 | printf("snprintf doesn't match Format: %s\n\tsnprintf = %s\n\tsprintf = %s\n", | 714 | } |
811 | int_fmt[x], buf1, buf2); | 715 | num++; |
812 | fail++; | 716 | } |
813 | } | 717 | } |
814 | num++; | 718 | for (x = 0; int_fmt[x] != NULL ; x++) { |
815 | } | 719 | for (y = 0; int_nums[y] != 0 ; y++) { |
816 | printf ("%d tests failed out of %d.\n", fail, num); | 720 | snprintf(buf1, sizeof (buf1), int_fmt[x], int_nums[y]); |
721 | sprintf(buf2, int_fmt[x], int_nums[y]); | ||
722 | if (strcmp (buf1, buf2)) { | ||
723 | printf("snprintf doesn't match Format: %s\n\t" | ||
724 | "snprintf = %s\n\tsprintf = %s\n", | ||
725 | int_fmt[x], buf1, buf2); | ||
726 | fail++; | ||
727 | } | ||
728 | num++; | ||
729 | } | ||
730 | } | ||
731 | printf("%d tests failed out of %d.\n", fail, num); | ||
732 | return(0); | ||
817 | } | 733 | } |
818 | #endif /* SNPRINTF_TEST */ | 734 | #endif /* SNPRINTF_TEST */ |
819 | 735 | ||