summaryrefslogtreecommitdiff
path: root/openbsd-compat/bsd-snprintf.c
diff options
context:
space:
mode:
authorBen Lindstrom <mouring@eviladmin.org>2001-02-13 02:18:50 +0000
committerBen Lindstrom <mouring@eviladmin.org>2001-02-13 02:18:50 +0000
commit6c92dab9a1ab05426b42d7cc5dca2a9c5af52f1d (patch)
tree5eae8c7241792412ee31951e9404fe4f21770050 /openbsd-compat/bsd-snprintf.c
parentd8ab0d4a852e00ab9e46c7147d887b0b038d7d43 (diff)
- (bal) Cleaned out bsd-snprintf.c. VARARGS have been banished and
I did a base KNF over the whe whole file to make it more acceptable. (backed out of original patch and removed it from ChangeLog) This has been a long time coming. If we decide that we need VARARGS support we should do it at a higher level, since no where else do we support VARARGS in the code base.
Diffstat (limited to 'openbsd-compat/bsd-snprintf.c')
-rw-r--r--openbsd-compat/bsd-snprintf.c1290
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
49RCSID("$Id: bsd-snprintf.c,v 1.2 2001/02/09 01:55:36 djm Exp $"); 54RCSID("$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> 58static void
54# include <ctype.h> 59dopr(char *buffer, size_t maxlen, const char *format, va_list args);
55#include <sys/types.h> 60
56 61static void
57/* Define this as a fall through, HAVE_STDARG_H is probably already set */ 62fmtstr(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 65static void
61/* varargs declarations: */ 66fmtint(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> 69static void
65# define HAVE_STDARGS /* let's hope that works everywhere (mj) */ 70fmtfp(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
86static void dopr (char *buffer, size_t maxlen, const char *format,
87 va_list args);
88static void fmtstr (char *buffer, size_t *currlen, size_t maxlen,
89 char *value, int flags, int min, int max);
90static void fmtint (char *buffer, size_t *currlen, size_t maxlen,
91 long value, int base, int min, int max, int flags);
92static void fmtfp (char *buffer, size_t *currlen, size_t maxlen,
93 long double fvalue, int min, int max, int flags);
94static 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
130static void dopr (char *buffer, size_t maxlen, const char *format, va_list args) 105
106static void
107dopr(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
404static void fmtstr (char *buffer, size_t *currlen, size_t maxlen, 353static void
405 char *value, int flags, int min, int max) 354fmtstr(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
443static void fmtint (char *buffer, size_t *currlen, size_t maxlen, 388static void
444 long value, int base, int min, int max, int flags) 389fmtint(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
533static 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
543static long double pow10 (int exp) 471static long double
472pow10(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
556static long round (long double value) 484static long
485round(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
568static void fmtfp (char *buffer, size_t *currlen, size_t maxlen, 496static void
569 long double fvalue, int min, int max, int flags) 497fmtfp(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
704static void dopr_outch (char *buffer, size_t *currlen, size_t maxlen, char c) 618static void
619dopr_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
712int vsnprintf (char *str, size_t count, const char *fmt, va_list args) 627int
628vsnprintf(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 */ 638int
722#ifdef HAVE_STDARGS 639snprintf(char *str,size_t count,const char *fmt,...)
723int snprintf (char *str,size_t count,const char *fmt,...)
724#else
725int 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 651int
746#define LONG_STRING 1024 652main(void)
747#endif
748int 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
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-26 12:03:03 +0000