projects / u / mdw / putty / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Cleanups of the GSSAPI support. On Windows, standard GSS libraries
[u/mdw/putty] / mac / vsnprint.c
1
2 #include <limits.h>
3 #include <stdarg.h>
4
5 #include "putty.h"
6
7 #define __P(decl) decl
8
9 /* XXX */
10 typedef unsigned long u_quad_t;
11 typedef long quad_t;
12
13 typedef unsigned long u_long;
14 typedef unsigned int u_int;
15 typedef unsigned short u_short;
16 typedef long intmax_t;
17 typedef unsigned long uintmax_t;
18 typedef long intptr_t;
19 typedef unsigned long uintptr_t;
20 typedef int ssize_t;
21
22 #define NBBY CHAR_BIT
23
24 /*-
25 * Copyright (c) 1986, 1988, 1991, 1993
26 * The Regents of the University of California. All rights reserved.
27 * (c) UNIX System Laboratories, Inc.
28 * All or some portions of this file are derived from material licensed
29 * to the University of California by American Telephone and Telegraph
30 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
31 * the permission of UNIX System Laboratories, Inc.
32 *
33 * Redistribution and use in source and binary forms, with or without
34 * modification, are permitted provided that the following conditions
35 * are met:
36 * 1. Redistributions of source code must retain the above copyright
37 * notice, this list of conditions and the following disclaimer.
38 * 2. Redistributions in binary form must reproduce the above copyright
39 * notice, this list of conditions and the following disclaimer in the
40 * documentation and/or other materials provided with the distribution.
41 * 3. Neither the name of the University nor the names of its contributors
42 * may be used to endorse or promote products derived from this software
43 * without specific prior written permission.
44 *
45 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
46 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
49 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
50 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
51 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
52 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
53 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
54 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
55 * SUCH DAMAGE.
56 *
57 * From NetBSD: subr_prf.c,v 1.86 2002/11/02 07:25:22 perry Exp
58 * @(#)subr_prf.c 8.4 (Berkeley) 5/4/95
59 */
60
61 /* flags for kprintf */
62 #define TOCONS 0x01 /* to the console */
63 #define TOTTY 0x02 /* to the process' tty */
64 #define TOLOG 0x04 /* to the kernel message buffer */
65 #define TOBUFONLY 0x08 /* to the buffer (only) [for snprintf] */
66 #define TODDB 0x10 /* to ddb console */
67
68 /* max size buffer kprintf needs to print quad_t [size in base 8 + \0] */
69 #define KPRINTF_BUFSIZE (sizeof(quad_t) * NBBY / 3 + 2)
70
71
72 /*
73 * local prototypes
74 */
75
76 static int kprintf __P((const char *, int, void *,
77 char *, va_list));
78
79 /*
80 * vsnprintf: print a message to a buffer [already have va_alist]
81 */
82 int
83 vsnprintf(buf, size, fmt, ap)
84 char *buf;
85 size_t size;
86 const char *fmt;
87 va_list ap;
88 {
89 int retval;
90 char *p;
91
92 if (size < 1)
93 return (-1);
94 p = buf + size - 1;
95 retval = kprintf(fmt, TOBUFONLY, &p, buf, ap);
96 *(p) = 0; /* null terminate */
97 return(retval);
98 }
99
100
101 /*
102 * kprintf: scaled down version of printf(3).
103 *
104 * this version based on vfprintf() from libc which was derived from
105 * software contributed to Berkeley by Chris Torek.
106 *
107 * NOTE: The kprintf mutex must be held if we're going TOBUF or TOCONS!
108 */
109
110 /*
111 * macros for converting digits to letters and vice versa
112 */
113 #define to_digit(c) ((c) - '0')
114 #define is_digit(c) ((unsigned)to_digit(c) <= 9)
115 #define to_char(n) ((n) + '0')
116
117 /*
118 * flags used during conversion.
119 */
120 #define ALT 0x001 /* alternate form */
121 #define HEXPREFIX 0x002 /* add 0x or 0X prefix */
122 #define LADJUST 0x004 /* left adjustment */
123 #define LONGDBL 0x008 /* long double; unimplemented */
124 #define LONGINT 0x010 /* long integer */
125 #define QUADINT 0x020 /* quad integer */
126 #define SHORTINT 0x040 /* short integer */
127 #define MAXINT 0x080 /* intmax_t */
128 #define PTRINT 0x100 /* intptr_t */
129 #define SIZEINT 0x200 /* size_t */
130 #define ZEROPAD 0x400 /* zero (as opposed to blank) pad */
131 #define FPT 0x800 /* Floating point number */
132
133 /*
134 * To extend shorts properly, we need both signed and unsigned
135 * argument extraction methods.
136 */
137 #define SARG() \
138 (flags&MAXINT ? va_arg(ap, intmax_t) : \
139 flags&PTRINT ? va_arg(ap, intptr_t) : \
140 flags&SIZEINT ? va_arg(ap, ssize_t) : /* XXX */ \
141 flags&QUADINT ? va_arg(ap, quad_t) : \
142 flags&LONGINT ? va_arg(ap, long) : \
143 flags&SHORTINT ? (long)(short)va_arg(ap, int) : \
144 (long)va_arg(ap, int))
145 #define UARG() \
146 (flags&MAXINT ? va_arg(ap, uintmax_t) : \
147 flags&PTRINT ? va_arg(ap, uintptr_t) : \
148 flags&SIZEINT ? va_arg(ap, size_t) : \
149 flags&QUADINT ? va_arg(ap, u_quad_t) : \
150 flags&LONGINT ? va_arg(ap, u_long) : \
151 flags&SHORTINT ? (u_long)(u_short)va_arg(ap, int) : \
152 (u_long)va_arg(ap, u_int))
153
154 #define KPRINTF_PUTCHAR(C) { \
155 if (oflags == TOBUFONLY) { \
156 if ((vp != NULL) && (sbuf == tailp)) { \
157 ret += 1; /* indicate error */ \
158 goto overflow; \
159 } \
160 *sbuf++ = (C); \
161 } \
162 }
163
164 /*
165 * Guts of kernel printf. Note, we already expect to be in a mutex!
166 */
167 static int
168 kprintf(fmt0, oflags, vp, sbuf, ap)
169 const char *fmt0;
170 int oflags;
171 void *vp;
172 char *sbuf;
173 va_list ap;
174 {
175 char *fmt; /* format string */
176 int ch; /* character from fmt */
177 int n; /* handy integer (short term usage) */
178 char *cp; /* handy char pointer (short term usage) */
179 int flags; /* flags as above */
180 int ret; /* return value accumulator */
181 int width; /* width from format (%8d), or 0 */
182 int prec; /* precision from format (%.3d), or -1 */
183 char sign; /* sign prefix (' ', '+', '-', or \0) */
184
185 u_quad_t _uquad; /* integer arguments %[diouxX] */
186 enum { OCT, DEC, HEX } base;/* base for [diouxX] conversion */
187 int dprec; /* a copy of prec if [diouxX], 0 otherwise */
188 int realsz; /* field size expanded by dprec */
189 int size; /* size of converted field or string */
190 char *xdigs; /* digits for [xX] conversion */
191 char buf[KPRINTF_BUFSIZE]; /* space for %c, %[diouxX] */
192 char *tailp; /* tail pointer for snprintf */
193
194 tailp = NULL; /* XXX: shutup gcc */
195 if (oflags == TOBUFONLY && (vp != NULL))
196 tailp = *(char **)vp;
197
198 cp = NULL; /* XXX: shutup gcc */
199 size = 0; /* XXX: shutup gcc */
200
201 fmt = (char *)fmt0;
202 ret = 0;
203
204 xdigs = NULL; /* XXX: shut up gcc warning */
205
206 /*
207 * Scan the format for conversions (`%' character).
208 */
209 for (;;) {
210 while (*fmt != '%' && *fmt) {
211 ret++;
212 KPRINTF_PUTCHAR(*fmt++);
213 }
214 if (*fmt == 0)
215 goto done;
216
217 fmt++; /* skip over '%' */
218
219 flags = 0;
220 dprec = 0;
221 width = 0;
222 prec = -1;
223 sign = '\0';
224
225 rflag: ch = *fmt++;
226 reswitch: switch (ch) {
227 case ' ':
228 /*
229 * ``If the space and + flags both appear, the space
230 * flag will be ignored.''
231 * -- ANSI X3J11
232 */
233 if (!sign)
234 sign = ' ';
235 goto rflag;
236 case '#':
237 flags |= ALT;
238 goto rflag;
239 case '*':
240 /*
241 * ``A negative field width argument is taken as a
242 * - flag followed by a positive field width.''
243 * -- ANSI X3J11
244 * They don't exclude field widths read from args.
245 */
246 if ((width = va_arg(ap, int)) >= 0)
247 goto rflag;
248 width = -width;
249 /* FALLTHROUGH */
250 case '-':
251 flags |= LADJUST;
252 goto rflag;
253 case '+':
254 sign = '+';
255 goto rflag;
256 case '.':
257 if ((ch = *fmt++) == '*') {
258 n = va_arg(ap, int);
259 prec = n < 0 ? -1 : n;
260 goto rflag;
261 }
262 n = 0;
263 while (is_digit(ch)) {
264 n = 10 * n + to_digit(ch);
265 ch = *fmt++;
266 }
267 prec = n < 0 ? -1 : n;
268 goto reswitch;
269 case '0':
270 /*
271 * ``Note that 0 is taken as a flag, not as the
272 * beginning of a field width.''
273 * -- ANSI X3J11
274 */
275 flags |= ZEROPAD;
276 goto rflag;
277 case '1': case '2': case '3': case '4':
278 case '5': case '6': case '7': case '8': case '9':
279 n = 0;
280 do {
281 n = 10 * n + to_digit(ch);
282 ch = *fmt++;
283 } while (is_digit(ch));
284 width = n;
285 goto reswitch;
286 case 'h':
287 flags |= SHORTINT;
288 goto rflag;
289 case 'j':
290 flags |= MAXINT;
291 goto rflag;
292 case 'l':
293 if (*fmt == 'l') {
294 fmt++;
295 flags |= QUADINT;
296 } else {
297 flags |= LONGINT;
298 }
299 goto rflag;
300 case 'q':
301 flags |= QUADINT;
302 goto rflag;
303 case 't':
304 flags |= PTRINT;
305 goto rflag;
306 case 'z':
307 flags |= SIZEINT;
308 goto rflag;
309 case 'c':
310 *(cp = buf) = va_arg(ap, int);
311 size = 1;
312 sign = '\0';
313 break;
314 case 'D':
315 flags |= LONGINT;
316 /*FALLTHROUGH*/
317 case 'd':
318 case 'i':
319 _uquad = SARG();
320 if ((quad_t)_uquad < 0) {
321 _uquad = -_uquad;
322 sign = '-';
323 }
324 base = DEC;
325 goto number;
326 case 'n':
327 if (flags & MAXINT)
328 *va_arg(ap, intmax_t *) = ret;
329 else if (flags & PTRINT)
330 *va_arg(ap, intptr_t *) = ret;
331 else if (flags & SIZEINT)
332 *va_arg(ap, ssize_t *) = ret;
333 else if (flags & QUADINT)
334 *va_arg(ap, quad_t *) = ret;
335 else if (flags & LONGINT)
336 *va_arg(ap, long *) = ret;
337 else if (flags & SHORTINT)
338 *va_arg(ap, short *) = ret;
339 else
340 *va_arg(ap, int *) = ret;
341 continue; /* no output */
342 case 'O':
343 flags |= LONGINT;
344 /*FALLTHROUGH*/
345 case 'o':
346 _uquad = UARG();
347 base = OCT;
348 goto nosign;
349 case 'p':
350 /*
351 * ``The argument shall be a pointer to void. The
352 * value of the pointer is converted to a sequence
353 * of printable characters, in an implementation-
354 * defined manner.''
355 * -- ANSI X3J11
356 */
357 /* NOSTRICT */
358 _uquad = (u_long)va_arg(ap, void *);
359 base = HEX;
360 xdigs = "0123456789abcdef";
361 flags |= HEXPREFIX;
362 ch = 'x';
363 goto nosign;
364 case 's':
365 if ((cp = va_arg(ap, char *)) == NULL)
366 cp = "(null)";
367 if (prec >= 0) {
368 /*
369 * can't use strlen; can only look for the
370 * NUL in the first `prec' characters, and
371 * strlen() will go further.
372 */
373 char *p = memchr(cp, 0, prec);
374
375 if (p != NULL) {
376 size = p - cp;
377 if (size > prec)
378 size = prec;
379 } else
380 size = prec;
381 } else
382 size = strlen(cp);
383 sign = '\0';
384 break;
385 case 'U':
386 flags |= LONGINT;
387 /*FALLTHROUGH*/
388 case 'u':
389 _uquad = UARG();
390 base = DEC;
391 goto nosign;
392 case 'X':
393 xdigs = "0123456789ABCDEF";
394 goto hex;
395 case 'x':
396 xdigs = "0123456789abcdef";
397 hex: _uquad = UARG();
398 base = HEX;
399 /* leading 0x/X only if non-zero */
400 if (flags & ALT && _uquad != 0)
401 flags |= HEXPREFIX;
402
403 /* unsigned conversions */
404 nosign: sign = '\0';
405 /*
406 * ``... diouXx conversions ... if a precision is
407 * specified, the 0 flag will be ignored.''
408 * -- ANSI X3J11
409 */
410 number: if ((dprec = prec) >= 0)
411 flags &= ~ZEROPAD;
412
413 /*
414 * ``The result of converting a zero value with an
415 * explicit precision of zero is no characters.''
416 * -- ANSI X3J11
417 */
418 cp = buf + KPRINTF_BUFSIZE;
419 if (_uquad != 0 || prec != 0) {
420 /*
421 * Unsigned mod is hard, and unsigned mod
422 * by a constant is easier than that by
423 * a variable; hence this switch.
424 */
425 switch (base) {
426 case OCT:
427 do {
428 *--cp = to_char(_uquad & 7);
429 _uquad >>= 3;
430 } while (_uquad);
431 /* handle octal leading 0 */
432 if (flags & ALT && *cp != '0')
433 *--cp = '0';
434 break;
435
436 case DEC:
437 /* many numbers are 1 digit */
438 while (_uquad >= 10) {
439 *--cp = to_char(_uquad % 10);
440 _uquad /= 10;
441 }
442 *--cp = to_char(_uquad);
443 break;
444
445 case HEX:
446 do {
447 *--cp = xdigs[_uquad & 15];
448 _uquad >>= 4;
449 } while (_uquad);
450 break;
451
452 default:
453 cp = "bug in kprintf: bad base";
454 size = strlen(cp);
455 goto skipsize;
456 }
457 }
458 size = buf + KPRINTF_BUFSIZE - cp;
459 skipsize:
460 break;
461 default: /* "%?" prints ?, unless ? is NUL */
462 if (ch == '\0')
463 goto done;
464 /* pretend it was %c with argument ch */
465 cp = buf;
466 *cp = ch;
467 size = 1;
468 sign = '\0';
469 break;
470 }
471
472 /*
473 * All reasonable formats wind up here. At this point, `cp'
474 * points to a string which (if not flags&LADJUST) should be
475 * padded out to `width' places. If flags&ZEROPAD, it should
476 * first be prefixed by any sign or other prefix; otherwise,
477 * it should be blank padded before the prefix is emitted.
478 * After any left-hand padding and prefixing, emit zeroes
479 * required by a decimal [diouxX] precision, then print the
480 * string proper, then emit zeroes required by any leftover
481 * floating precision; finally, if LADJUST, pad with blanks.
482 *
483 * Compute actual size, so we know how much to pad.
484 * size excludes decimal prec; realsz includes it.
485 */
486 realsz = dprec > size ? dprec : size;
487 if (sign)
488 realsz++;
489 else if (flags & HEXPREFIX)
490 realsz+= 2;
491
492 /* adjust ret */
493 ret += width > realsz ? width : realsz;
494
495 /* right-adjusting blank padding */
496 if ((flags & (LADJUST|ZEROPAD)) == 0) {
497 n = width - realsz;
498 while (n-- > 0)
499 KPRINTF_PUTCHAR(' ');
500 }
501
502 /* prefix */
503 if (sign) {
504 KPRINTF_PUTCHAR(sign);
505 } else if (flags & HEXPREFIX) {
506 KPRINTF_PUTCHAR('0');
507 KPRINTF_PUTCHAR(ch);
508 }
509
510 /* right-adjusting zero padding */
511 if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD) {
512 n = width - realsz;
513 while (n-- > 0)
514 KPRINTF_PUTCHAR('0');
515 }
516
517 /* leading zeroes from decimal precision */
518 n = dprec - size;
519 while (n-- > 0)
520 KPRINTF_PUTCHAR('0');
521
522 /* the string or number proper */
523 while (size--)
524 KPRINTF_PUTCHAR(*cp++);
525 /* left-adjusting padding (always blank) */
526 if (flags & LADJUST) {
527 n = width - realsz;
528 while (n-- > 0)
529 KPRINTF_PUTCHAR(' ');
530 }
531 }
532
533 done:
534 if ((oflags == TOBUFONLY) && (vp != NULL))
535 *(char **)vp = sbuf;
536 overflow:
537 return (ret);
538 /* NOTREACHED */
539 }
Local modifications for Simon Tatham's `PuTTY' SSH client and terminal emulator