diff options
Diffstat (limited to 'libc/stdio/old_vfprintf.c')
| -rw-r--r-- | libc/stdio/old_vfprintf.c | 493 |
1 files changed, 493 insertions, 0 deletions
diff --git a/libc/stdio/old_vfprintf.c b/libc/stdio/old_vfprintf.c new file mode 100644 index 000000000..c7c07f34a --- /dev/null +++ b/libc/stdio/old_vfprintf.c @@ -0,0 +1,493 @@ +/* + * This file based on printf.c from 'Dlibs' on the atari ST (RdeBath) + * + * + * Dale Schumacher 399 Beacon Ave. + * (alias: Dalnefre') St. Paul, MN 55104 + * dal@syntel.UUCP United States of America + * "It's not reality that's important, but how you perceive things." + */ + +/* Altered to use stdarg, made the core function vfnprintf. + * Hooked into the stdio package using 'inside information' + * Altered sizeof() assumptions, now assumes all integers except chars + * will be either + * sizeof(xxx) == sizeof(long) or sizeof(xxx) == sizeof(short) + * + * -RDB + */ + +/* + * Manuel Novoa III Dec 2000 + * + * The previous vfnprintf routine was almost completely rewritten with the + * goal of fixing some shortcomings and reducing object size. + * + * The summary of changes: + * + * Converted print conversion specification parsing from one big switch + * to a method using string tables. This new method verifies that the + * conversion flags, field width, precision, qualifier, and specifier + * appear in the correct order. Many questionable specifications were + * accepted by the previous code. This new method also resulted in a + * substantial reduction in object size of about 330 bytes (20%) from + * the old version (1627 bytes) on i386, even with the following + * improvements. + * + * Implemented %n specifier as required by the standards. + * Implemented proper handling of precision for int types. + * Implemented # for hex and pointer, fixed error for octal rep of 0. + * Implemented return of -1 on stream error. + * + * Added optional support for the GNU extension %m which prints the string + * corresponding the errno. + * + * Added optional support for long long ints and unsigned long long ints + * using the conversion qualifiers "ll", "L", or "q" (like glibc). + * + * Added optional support for doubles in a very limited form. None of + * the formating options are obeyed. The string returned by __dtostr + * is printed directly. + * + * Converted to use my (un)signed long (long) to string routines, which are + * smaller than the previous functions and don't require static buffers. + * + * Other Modifications: + * Modified sprintf, snprintf, vsprintf, vsnprintf to share on fake-file. + */ + +/* + * Manuel Novoa III Jan 2001 + * + * Removed fake file from *s*printf functions because of possible problems + * if called recursively. Instead, have sprintf, snprintf, and vsprintf + * call vsnprintf which allocates a fake file on the stack. + * Removed WANT_FPUTC option. Always use standard putc macro to avoid + * problems with the fake file used by the *s*printf functions. + * Fixed bug parsing flags -- did not restart scan. + * Added function asprintf. + * Fixed 0-pad prefixing bug. + * Converted sizeof(int) == sizeof(long) tests to compile time vs run time. + * This saves 112 bytes of code on i386. + * Fixed precision bug -- when negative set to default. + * Added function fnprintf to support __dtostr. + * Added floating point support for doubles. Yeah! + * + * + * May 2001 Fixes from Johan Adolfsson (johan.adolfsson@axis.com) + * 1) printf("%c",0) returned 0 instead of 1. + * 2) unrolled loop in asprintf to reduce size and remove compile warning. + * + * + * June 2001 + * 1) fix %p so that "0x" is prepended to outputed hex val + * 2) fix %p so that "(nil)" is output for (void *)0 to match glibc + * + */ + +/*****************************************************************************/ +/* OPTIONS */ +/*****************************************************************************/ +/* The optional support for long longs and doubles comes in two forms. + * + * 1) Normal (or partial for doubles) output support. Set to 1 to turn on. + * Adds about 130 bytes for doubles, about 220 bytes for long longs, + * and about 275 for both to the base code size of 1163 on i386. + */ + +/* These are now set in uClibc_config.h based on Config. */ +/* +#define __UCLIBC_HAS_FLOATS__ 1 +*/ + +/* 2) An error message is inserted into the stream, an arg of the + * appropriate size is removed from the arglist, and processing + * continues. This is adds less code and may be useful in some + * cases. Set to 1 to turn on. Adds about 50 bytes for doubles, + * about 140 bytes for long longs, and about 175 bytes for both + * to the base code size of 1163 on i386. + */ + +#define WANT_FLOAT_ERROR 0 + +/* + * Set to support GNU extension of %m to print string corresponding to errno. + * + * Warning: This adds about 50 bytes (i386) to the code but it also pulls in + * strerror and the corresponding string table which together are about 3.8k. + */ + +#define WANT_GNU_ERRNO 0 + +/**************************************************************************/ + +#define _GNU_SOURCE /* for strnlen */ +#define _STDIO_UTILITY +#include <stdio.h> +#include <stdarg.h> +#include <limits.h> +#include <string.h> +#include <errno.h> + +#define __PRINTF_INFO_NO_BITFIELD +#include <printf.h> + +#ifdef __STDIO_THREADSAFE +#include <pthread.h> +#endif /* __STDIO_THREADSAFE */ + +/* #undef __UCLIBC_HAS_FLOATS__ */ +/* #undef WANT_FLOAT_ERROR */ +/* #define WANT_FLOAT_ERROR 1 */ + +#define __isdigit(c) (((unsigned int)(c - '0')) < 10) + +extern size_t _dtostr(FILE * fp, long double x, struct printf_info *info); + + +enum { + FLAG_PLUS = 0, + FLAG_MINUS_LJUSTIFY, + FLAG_HASH, + FLAG_0_PAD, + FLAG_SPACE, +}; + +/* layout 01234 */ +static const char spec[] = "+-#0 "; + +static const char qual[] = "hlLq"; + +#if !defined(__UCLIBC_HAS_FLOATS__) && WANT_FLOAT_ERROR +static const char dbl_err[] = "<DOUBLE>"; +#endif + +#if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR +/* layout 012345678901234567 */ +static const char u_spec[] = "%nbopxXudicsfgGeEaA"; +#else +/* layout 0123456789012 */ +static const char u_spec[] = "%nbopxXudics"; +#endif + +/* WARNING: u_spec and u_radix need to stay in agreement!!! */ +/* u_radix[i] <-> u_spec[i+2] for unsigned entries only */ +static const char u_radix[] = "\x02\x08\x10\x10\x10\x0a"; + +int vfprintf(FILE * __restrict op, register const char * __restrict fmt, + va_list ap) +{ + int i, cnt, lval, len; + char *p; + const char *fmt0; + int preci, width; +#define upcase i + int radix, dpoint /*, upcase*/; + char tmp[65]; /* TODO - determing needed size from headers */ + char flag[sizeof(spec)]; + + __STDIO_THREADLOCK(op); + + cnt = 0; + + while (*fmt) { + if (*fmt == '%') { + fmt0 = fmt; /* save our position in case of bad format */ + ++fmt; + width = -1; /* min field width */ + preci = -5; /* max string width or mininum digits */ + radix = 10; /* number base */ + dpoint = 0; /* found decimal point */ +#if INT_MAX != LONG_MAX + lval = 0; /* sizeof(int) != sizeof(long) */ +#else + lval = 1; /* sizeof(int) == sizeof(long) */ +#endif + + /* init flags */ + for (p =(char *) spec ; *p ; p++) { + flag[p-spec] = '\0'; + } + flag[FLAG_0_PAD] = ' '; + + /* process optional flags */ + for (p = (char *)spec ; *p ; ) { + if (*fmt == *p) { + flag[p-spec] = *fmt++; + p = (char *)spec; /* restart scan */ + } else { + p++; + } + } + + if (!flag[FLAG_PLUS]) { + flag[FLAG_PLUS] = flag[FLAG_SPACE]; + } + + /* process optional width and precision */ + do { + if (*fmt == '.') { + ++fmt; + dpoint = 1; + } + if (*fmt == '*') { /* parameter width value */ + ++fmt; + i = va_arg(ap, int); + } else { + for ( i = 0 ; (*fmt >= '0') && (*fmt <= '9') ; ++fmt ) { + i = (i * 10) + (*fmt - '0'); + } + } + + if (dpoint) { + preci = i; + if (i<0) { + preci = -5; + } + } else { + width = i; + if (i<0) { + width = -i; + flag[FLAG_MINUS_LJUSTIFY] = 1; + } + } + } while ((*fmt == '.') && !dpoint ); + + /* process optional qualifier */ + for (p = (char *) qual ; *p ; p++) { + if (*p == *fmt) { + lval = p - qual; + ++fmt; /* TODO - hh */ + if ((*p == 'l') && (*fmt == *p)) { + ++lval; + ++fmt; + } + } + } + +#if WANT_GNU_ERRNO + if (*fmt == 'm') { + flag[FLAG_PLUS] = '\0'; + flag[FLAG_0_PAD] = ' '; + p = strerror(errno); + goto print; + } +#endif + + /* process format specifier */ + for (p = (char *) u_spec ; *p ; p++) { + if (*fmt != *p) continue; + if (p-u_spec < 1) { /* print a % */ + goto charout; + } + if (p-u_spec < 2) { /* store output count in int ptr */ + *(va_arg(ap, int *)) = cnt; + goto nextfmt; + } + if (p-u_spec < 8) { /* unsigned conversion */ + radix = u_radix[p-u_spec-2]; + upcase = ((*p == 'x') ? __UIM_LOWER : __UIM_UPPER); + if (*p == 'p') { + lval = (sizeof(char *) == sizeof(long)); + upcase = __UIM_LOWER; + flag[FLAG_HASH] = 'p'; + } + + p = _uintmaxtostr((tmp + sizeof(tmp) - 1), + ((lval>1) /* TODO -- longlong/long/int/short/char */ + ? va_arg(ap, uintmax_t) + : (uintmax_t) + va_arg(ap, unsigned long)), + radix, upcase); + + flag[FLAG_PLUS] = '\0'; /* meaningless for unsigned */ + if (*p != '0') { /* non-zero */ + if (flag[FLAG_HASH]) { + if (radix == 8) { + *--p = '0'; /* add leadding zero */ + } else if (radix != 10) { /* either 2 or 16 */ + flag[FLAG_PLUS] = '0'; + *--p = 'b'; + if (radix == 16) { + *p = 'x'; + if (*fmt == 'X') { + *p = 'X'; + } + } + } + } + } else if (flag[FLAG_HASH] == 'p') { /* null pointer */ + p = "(nil)"; + } + } else if (p-u_spec < 10) { /* signed conversion */ + + p = _uintmaxtostr((tmp + sizeof(tmp) - 1), + ((lval>1) /* TODO -- longlong/long/int/short/char */ + ? va_arg(ap, uintmax_t) + : (uintmax_t) ((long long) /* sign-extend! */ + va_arg(ap, long))), + -radix, upcase); + + } else if (p-u_spec < 12) { /* character or string */ + flag[FLAG_PLUS] = '\0'; + flag[FLAG_0_PAD] = ' '; + if (*p == 'c') { /* character */ + p = tmp; + *p = va_arg(ap, int); + /* This takes care of the "%c",0 case */ + len = 1; + goto print_len_set; + } else { /* string */ + p = va_arg(ap, char *); + if (!p) { + p = "(null)"; + preci = 6; + } else { + if (preci < 0) { + preci = INT_MAX; + } + } + len = strnlen(p, preci); + goto print_len_set; + } +#if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR + } else if (p-u_spec < 27) { /* floating point */ +#endif /* defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR */ +#if defined(__UCLIBC_HAS_FLOATS__) + struct printf_info info; + if (preci < 0) { + preci = 6; + } + info.width = width; + info.prec = preci; + info.spec = *fmt; + info.pad = flag[FLAG_0_PAD]; + info._flags = 0; + if (flag[FLAG_PLUS] == '+') { + PRINT_INFO_SET_FLAG(&info,showsign); + } else if (flag[FLAG_PLUS] == ' ') { + PRINT_INFO_SET_FLAG(&info,space); + } + if (flag[FLAG_HASH]) { + PRINT_INFO_SET_FLAG(&info,alt); + } + if (flag[FLAG_MINUS_LJUSTIFY]) { + PRINT_INFO_SET_FLAG(&info,left); + } + cnt += _dtostr(op, + ((lval > 1) + ? va_arg(ap, long double) + : (long double) va_arg(ap, double)), + &info); + goto nextfmt; +#elif WANT_FLOAT_ERROR + (void) ((lval > 1) ? va_arg(ap, long double) + : va_arg(ap, double)); /* carry on */ + p = (char *) dbl_err; +#endif /* defined(__UCLIBC_HAS_FLOATS__) */ + } + +#if WANT_GNU_ERRNO + print: +#endif + { /* this used to be printfield */ + /* cheaper than strlen call */ +/* for ( len = 0 ; p[len] ; len++ ) { } */ + len = strnlen(p, SIZE_MAX); + print_len_set: + if ((*p == '-') +#if WANT_GNU_ERRNO + && (*fmt != 'm') +#endif + && (*fmt != 's')) { + flag[FLAG_PLUS] = *p++; + --len; + } + if (flag[FLAG_PLUS]) { + ++len; + ++preci; + if (flag[FLAG_PLUS] == '0') { /* base 16 */ + ++preci; /* account for x or X */ + } + } + + if (preci >= 0) { + if ((*fmt == 's') +#if WANT_GNU_ERRNO + || (*fmt == 'm') +#endif + ) { + if (len > preci) { + len = preci; + } else { + preci = len; + } + } + preci -= len; + if (preci < 0) { + preci = 0; + } + width -= preci; + } + + width -= len; + if (width < 0) { + width = 0; + } + + if (preci < 0) { + preci = 0; + if (!flag[FLAG_MINUS_LJUSTIFY] + /* && flag[FLAG_PLUS] */ + && (flag[FLAG_0_PAD] == '0')) { + preci = width; + width = 0; + } + } + + while (width + len + preci) { + unsigned char ch; + /* right padding || left padding */ + if ((!len && !preci) + || (width && !flag[FLAG_MINUS_LJUSTIFY])) { + ch = ' '; + --width; + } else if (flag[FLAG_PLUS]) { + ch = flag[FLAG_PLUS]; /* sign */ + if (flag[FLAG_PLUS]=='0') { /* base 16 case */ + flag[FLAG_PLUS] = *p++; /* get the x|X */ + } else { + flag[FLAG_PLUS] = '\0'; + } + --len; + } else if (preci) { + ch = '0'; + --preci; + } else { + ch = *p++; /* main field */ + --len; + } + ++cnt; + putc(ch, op); + } + } + goto nextfmt; + } + + fmt = fmt0; /* this was an illegal format */ + } + + charout: + ++cnt; + putc(*fmt, op); /* normal char out */ + + nextfmt: + ++fmt; + } + + i = (__FERROR(op)) ? -1 : cnt; + + __STDIO_THREADLOCK(op); + + return i; +} |