old_vfprintf.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496
  1. /*
  2. * This file based on printf.c from 'Dlibs' on the atari ST (RdeBath)
  3. *
  4. *
  5. * Dale Schumacher 399 Beacon Ave.
  6. * (alias: Dalnefre') St. Paul, MN 55104
  7. * dal@syntel.UUCP United States of America
  8. * "It's not reality that's important, but how you perceive things."
  9. */
  10. /* Altered to use stdarg, made the core function vfnprintf.
  11. * Hooked into the stdio package using 'inside information'
  12. * Altered sizeof() assumptions, now assumes all integers except chars
  13. * will be either
  14. * sizeof(xxx) == sizeof(long) or sizeof(xxx) == sizeof(short)
  15. *
  16. * -RDB
  17. */
  18. /*
  19. * Manuel Novoa III Dec 2000
  20. *
  21. * The previous vfnprintf routine was almost completely rewritten with the
  22. * goal of fixing some shortcomings and reducing object size.
  23. *
  24. * The summary of changes:
  25. *
  26. * Converted print conversion specification parsing from one big switch
  27. * to a method using string tables. This new method verifies that the
  28. * conversion flags, field width, precision, qualifier, and specifier
  29. * appear in the correct order. Many questionable specifications were
  30. * accepted by the previous code. This new method also resulted in a
  31. * substantial reduction in object size of about 330 bytes (20%) from
  32. * the old version (1627 bytes) on i386, even with the following
  33. * improvements.
  34. *
  35. * Implemented %n specifier as required by the standards.
  36. * Implemented proper handling of precision for int types.
  37. * Implemented # for hex and pointer, fixed error for octal rep of 0.
  38. * Implemented return of -1 on stream error.
  39. *
  40. * Added optional support for the GNU extension %m which prints the string
  41. * corresponding the errno.
  42. *
  43. * Added optional support for long long ints and unsigned long long ints
  44. * using the conversion qualifiers "ll", "L", or "q" (like glibc).
  45. *
  46. * Added optional support for doubles in a very limited form. None of
  47. * the formating options are obeyed. The string returned by __dtostr
  48. * is printed directly.
  49. *
  50. * Converted to use my (un)signed long (long) to string routines, which are
  51. * smaller than the previous functions and don't require static buffers.
  52. *
  53. * Other Modifications:
  54. * Modified sprintf, snprintf, vsprintf, vsnprintf to share on fake-file.
  55. */
  56. /*
  57. * Manuel Novoa III Jan 2001
  58. *
  59. * Removed fake file from *s*printf functions because of possible problems
  60. * if called recursively. Instead, have sprintf, snprintf, and vsprintf
  61. * call vsnprintf which allocates a fake file on the stack.
  62. * Removed WANT_FPUTC option. Always use standard putc macro to avoid
  63. * problems with the fake file used by the *s*printf functions.
  64. * Fixed bug parsing flags -- did not restart scan.
  65. * Added function asprintf.
  66. * Fixed 0-pad prefixing bug.
  67. * Converted sizeof(int) == sizeof(long) tests to compile time vs run time.
  68. * This saves 112 bytes of code on i386.
  69. * Fixed precision bug -- when negative set to default.
  70. * Added function fnprintf to support __dtostr.
  71. * Added floating point support for doubles. Yeah!
  72. *
  73. *
  74. * May 2001 Fixes from Johan Adolfsson (johan.adolfsson@axis.com)
  75. * 1) printf("%c",0) returned 0 instead of 1.
  76. * 2) unrolled loop in asprintf to reduce size and remove compile warning.
  77. *
  78. *
  79. * June 2001
  80. * 1) fix %p so that "0x" is prepended to outputed hex val
  81. * 2) fix %p so that "(nil)" is output for (void *)0 to match glibc
  82. *
  83. */
  84. /*****************************************************************************/
  85. /* OPTIONS */
  86. /*****************************************************************************/
  87. /* The optional support for long longs and doubles comes in two forms.
  88. *
  89. * 1) Normal (or partial for doubles) output support. Set to 1 to turn on.
  90. * Adds about 130 bytes for doubles, about 220 bytes for long longs,
  91. * and about 275 for both to the base code size of 1163 on i386.
  92. */
  93. /* These are now set in uClibc_config.h based on Config. */
  94. /*
  95. #define __UCLIBC_HAS_FLOATS__ 1
  96. */
  97. /* 2) An error message is inserted into the stream, an arg of the
  98. * appropriate size is removed from the arglist, and processing
  99. * continues. This is adds less code and may be useful in some
  100. * cases. Set to 1 to turn on. Adds about 50 bytes for doubles,
  101. * about 140 bytes for long longs, and about 175 bytes for both
  102. * to the base code size of 1163 on i386.
  103. */
  104. #define WANT_FLOAT_ERROR 0
  105. /*
  106. * Set to support GNU extension of %m to print string corresponding to errno.
  107. *
  108. * Warning: This adds about 50 bytes (i386) to the code but it also pulls in
  109. * strerror and the corresponding string table which together are about 3.8k.
  110. */
  111. #define WANT_GNU_ERRNO 0
  112. /**************************************************************************/
  113. #define _GNU_SOURCE /* for strnlen */
  114. #define _STDIO_UTILITY
  115. #include <stdio.h>
  116. #include <stdarg.h>
  117. #include <limits.h>
  118. #include <string.h>
  119. #include <errno.h>
  120. #include <ctype.h>
  121. #define __PRINTF_INFO_NO_BITFIELD
  122. #include <printf.h>
  123. #ifdef __STDIO_THREADSAFE
  124. #include <pthread.h>
  125. #endif /* __STDIO_THREADSAFE */
  126. /* #undef __UCLIBC_HAS_FLOATS__ */
  127. /* #undef WANT_FLOAT_ERROR */
  128. /* #define WANT_FLOAT_ERROR 1 */
  129. /* #define __isdigit(c) (((unsigned int)(c - '0')) < 10) */
  130. #if defined(__UCLIBC_HAS_FLOATS__)
  131. extern size_t _dtostr(FILE * fp, long double x, struct printf_info *info);
  132. #endif
  133. enum {
  134. FLAG_PLUS = 0,
  135. FLAG_MINUS_LJUSTIFY,
  136. FLAG_HASH,
  137. FLAG_0_PAD,
  138. FLAG_SPACE,
  139. };
  140. /* layout 01234 */
  141. static const char spec[] = "+-#0 ";
  142. static const char qual[] = "hlLq";
  143. #if !defined(__UCLIBC_HAS_FLOATS__) && WANT_FLOAT_ERROR
  144. static const char dbl_err[] = "<DOUBLE>";
  145. #endif
  146. #if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR
  147. /* layout 012345678901234567 */
  148. static const char u_spec[] = "%nbopxXudicsfgGeEaA";
  149. #else
  150. /* layout 0123456789012 */
  151. static const char u_spec[] = "%nbopxXudics";
  152. #endif
  153. /* WARNING: u_spec and u_radix need to stay in agreement!!! */
  154. /* u_radix[i] <-> u_spec[i+2] for unsigned entries only */
  155. static const char u_radix[] = "\x02\x08\x10\x10\x10\x0a";
  156. int vfprintf(FILE * __restrict op, register const char * __restrict fmt,
  157. va_list ap)
  158. {
  159. int i, cnt, lval, len;
  160. register char *p;
  161. const char *fmt0;
  162. int preci, width;
  163. #define upcase i
  164. int radix, dpoint /*, upcase*/;
  165. char tmp[65]; /* TODO - determing needed size from headers */
  166. char flag[sizeof(spec)];
  167. __STDIO_THREADLOCK(op);
  168. cnt = 0;
  169. while (*fmt) {
  170. if (*fmt == '%') {
  171. fmt0 = fmt; /* save our position in case of bad format */
  172. ++fmt;
  173. width = -1; /* min field width */
  174. preci = -5; /* max string width or mininum digits */
  175. radix = 10; /* number base */
  176. dpoint = 0; /* found decimal point */
  177. #if INT_MAX != LONG_MAX
  178. lval = 0; /* sizeof(int) != sizeof(long) */
  179. #else
  180. lval = 1; /* sizeof(int) == sizeof(long) */
  181. #endif
  182. /* init flags */
  183. for (p =(char *) spec ; *p ; p++) {
  184. flag[p-spec] = '\0';
  185. }
  186. flag[FLAG_0_PAD] = ' ';
  187. /* process optional flags */
  188. for (p = (char *)spec ; *p ; ) {
  189. if (*fmt == *p) {
  190. flag[p-spec] = *fmt++;
  191. p = (char *)spec; /* restart scan */
  192. } else {
  193. p++;
  194. }
  195. }
  196. if (!flag[FLAG_PLUS]) {
  197. flag[FLAG_PLUS] = flag[FLAG_SPACE];
  198. }
  199. /* process optional width and precision */
  200. do {
  201. if (*fmt == '.') {
  202. ++fmt;
  203. dpoint = 1;
  204. }
  205. if (*fmt == '*') { /* parameter width value */
  206. ++fmt;
  207. i = va_arg(ap, int);
  208. } else {
  209. for ( i = 0 ; (*fmt >= '0') && (*fmt <= '9') ; ++fmt ) {
  210. i = (i * 10) + (*fmt - '0');
  211. }
  212. }
  213. if (dpoint) {
  214. preci = i;
  215. if (i<0) {
  216. preci = -5;
  217. }
  218. } else {
  219. width = i;
  220. if (i<0) {
  221. width = -i;
  222. flag[FLAG_MINUS_LJUSTIFY] = 1;
  223. }
  224. }
  225. } while ((*fmt == '.') && !dpoint );
  226. /* process optional qualifier */
  227. for (p = (char *) qual ; *p ; p++) {
  228. if (*p == *fmt) {
  229. lval = p - qual;
  230. ++fmt; /* TODO - hh */
  231. if ((*p == 'l') && (*fmt == *p)) {
  232. ++lval;
  233. ++fmt;
  234. }
  235. }
  236. }
  237. #if WANT_GNU_ERRNO
  238. if (*fmt == 'm') {
  239. flag[FLAG_PLUS] = '\0';
  240. flag[FLAG_0_PAD] = ' ';
  241. p = _glibc_strerror_r(errno, tmp, sizeof(tmp));
  242. goto print;
  243. }
  244. #endif
  245. /* process format specifier */
  246. for (p = (char *) u_spec ; *p ; p++) {
  247. if (*fmt != *p) continue;
  248. if (p-u_spec < 1) { /* print a % */
  249. goto charout;
  250. }
  251. if (p-u_spec < 2) { /* store output count in int ptr */
  252. *(va_arg(ap, int *)) = cnt;
  253. goto nextfmt;
  254. }
  255. if (p-u_spec < 8) { /* unsigned conversion */
  256. radix = u_radix[p-u_spec-2];
  257. upcase = ((*p == 'x') ? __UIM_LOWER : __UIM_UPPER);
  258. if (*p == 'p') {
  259. lval = (sizeof(char *) == sizeof(long));
  260. upcase = __UIM_LOWER;
  261. flag[FLAG_HASH] = 'p';
  262. }
  263. p = _uintmaxtostr((tmp + sizeof(tmp) - 1),
  264. ((lval>1) /* TODO -- longlong/long/int/short/char */
  265. ? va_arg(ap, uintmax_t)
  266. : (uintmax_t)
  267. va_arg(ap, unsigned long)),
  268. radix, upcase);
  269. flag[FLAG_PLUS] = '\0'; /* meaningless for unsigned */
  270. if (*p != '0') { /* non-zero */
  271. if (flag[FLAG_HASH]) {
  272. if (radix == 8) {
  273. *--p = '0'; /* add leadding zero */
  274. } else if (radix != 10) { /* either 2 or 16 */
  275. flag[FLAG_PLUS] = '0';
  276. *--p = 'b';
  277. if (radix == 16) {
  278. *p = 'x';
  279. if (*fmt == 'X') {
  280. *p = 'X';
  281. }
  282. }
  283. }
  284. }
  285. } else if (flag[FLAG_HASH] == 'p') { /* null pointer */
  286. p = "(nil)";
  287. }
  288. } else if (p-u_spec < 10) { /* signed conversion */
  289. p = _uintmaxtostr((tmp + sizeof(tmp) - 1),
  290. ((lval>1) /* TODO -- longlong/long/int/short/char */
  291. ? va_arg(ap, uintmax_t)
  292. : (uintmax_t) ((intmax_t) /* sign-extend! */
  293. va_arg(ap, long))),
  294. -radix, upcase);
  295. } else if (p-u_spec < 12) { /* character or string */
  296. flag[FLAG_PLUS] = '\0';
  297. flag[FLAG_0_PAD] = ' ';
  298. if (*p == 'c') { /* character */
  299. p = tmp;
  300. *p = va_arg(ap, int);
  301. /* This takes care of the "%c",0 case */
  302. len = 1;
  303. goto print_len_set;
  304. } else { /* string */
  305. p = va_arg(ap, char *);
  306. if (!p) {
  307. p = "(null)";
  308. preci = 6;
  309. } else {
  310. if (preci < 0) {
  311. preci = INT_MAX;
  312. }
  313. }
  314. len = strnlen(p, preci);
  315. goto print_len_set;
  316. }
  317. #if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR
  318. } else if (p-u_spec < 27) { /* floating point */
  319. #endif /* defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR */
  320. #if defined(__UCLIBC_HAS_FLOATS__)
  321. struct printf_info info;
  322. if (preci < 0) {
  323. preci = 6;
  324. }
  325. info.width = width;
  326. info.prec = preci;
  327. info.spec = *fmt;
  328. info.pad = flag[FLAG_0_PAD];
  329. info._flags = 0;
  330. if (flag[FLAG_PLUS] == '+') {
  331. PRINT_INFO_SET_FLAG(&info,showsign);
  332. } else if (flag[FLAG_PLUS] == ' ') {
  333. PRINT_INFO_SET_FLAG(&info,space);
  334. }
  335. if (flag[FLAG_HASH]) {
  336. PRINT_INFO_SET_FLAG(&info,alt);
  337. }
  338. if (flag[FLAG_MINUS_LJUSTIFY]) {
  339. PRINT_INFO_SET_FLAG(&info,left);
  340. }
  341. cnt += _dtostr(op,
  342. ((lval > 1)
  343. ? va_arg(ap, long double)
  344. : (long double) va_arg(ap, double)),
  345. &info);
  346. goto nextfmt;
  347. #elif WANT_FLOAT_ERROR
  348. (void) ((lval > 1) ? va_arg(ap, long double)
  349. : va_arg(ap, double)); /* carry on */
  350. p = (char *) dbl_err;
  351. #endif /* defined(__UCLIBC_HAS_FLOATS__) */
  352. }
  353. #if WANT_GNU_ERRNO
  354. print:
  355. #endif
  356. { /* this used to be printfield */
  357. /* cheaper than strlen call */
  358. /* for ( len = 0 ; p[len] ; len++ ) { } */
  359. len = strnlen(p, SIZE_MAX);
  360. print_len_set:
  361. if ((*p == '-')
  362. #if WANT_GNU_ERRNO
  363. && (*fmt != 'm')
  364. #endif
  365. && (*fmt != 's')) {
  366. flag[FLAG_PLUS] = *p++;
  367. --len;
  368. }
  369. if (flag[FLAG_PLUS]) {
  370. ++len;
  371. ++preci;
  372. if (flag[FLAG_PLUS] == '0') { /* base 16 */
  373. ++preci; /* account for x or X */
  374. }
  375. }
  376. if (preci >= 0) {
  377. if ((*fmt == 's')
  378. #if WANT_GNU_ERRNO
  379. || (*fmt == 'm')
  380. #endif
  381. ) {
  382. if (len > preci) {
  383. len = preci;
  384. } else {
  385. preci = len;
  386. }
  387. }
  388. preci -= len;
  389. if (preci < 0) {
  390. preci = 0;
  391. }
  392. width -= preci;
  393. }
  394. width -= len;
  395. if (width < 0) {
  396. width = 0;
  397. }
  398. if (preci < 0) {
  399. preci = 0;
  400. if (!flag[FLAG_MINUS_LJUSTIFY]
  401. /* && flag[FLAG_PLUS] */
  402. && (flag[FLAG_0_PAD] == '0')) {
  403. preci = width;
  404. width = 0;
  405. }
  406. }
  407. while (width + len + preci) {
  408. unsigned char ch;
  409. /* right padding || left padding */
  410. if ((!len && !preci)
  411. || (width && !flag[FLAG_MINUS_LJUSTIFY])) {
  412. ch = ' ';
  413. --width;
  414. } else if (flag[FLAG_PLUS]) {
  415. ch = flag[FLAG_PLUS]; /* sign */
  416. if (flag[FLAG_PLUS]=='0') { /* base 16 case */
  417. flag[FLAG_PLUS] = *p++; /* get the x|X */
  418. } else {
  419. flag[FLAG_PLUS] = '\0';
  420. }
  421. --len;
  422. } else if (preci) {
  423. ch = '0';
  424. --preci;
  425. } else {
  426. ch = *p++; /* main field */
  427. --len;
  428. }
  429. ++cnt;
  430. putc(ch, op);
  431. }
  432. }
  433. goto nextfmt;
  434. }
  435. fmt = fmt0; /* this was an illegal format */
  436. }
  437. charout:
  438. ++cnt;
  439. putc(*fmt, op); /* normal char out */
  440. nextfmt:
  441. ++fmt;
  442. }
  443. i = (__FERROR(op)) ? -1 : cnt;
  444. __STDIO_THREADLOCK(op);
  445. return i;
  446. }