stdio.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730
  1. /* Formatted output for the ring-3 libc.
  2. *
  3. * The formatting core is syscall-free; stdio_file.c supplies console streams
  4. * and read-only whole-file FILE objects. Float formatting uses the exact
  5. * decimal decomposition in dtoa.c, then rounds at the requested precision. */
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include <errno.h>
  10. #include <limits.h>
  11. #include <math.h>
  12. #include "dtoa.h"
  13. #define F_LEFT 0x01
  14. #define F_PLUS 0x02
  15. #define F_SPACE 0x04
  16. #define F_HASH 0x08
  17. #define F_ZERO 0x10
  18. struct out {
  19. char *buf;
  20. size_t cap;
  21. size_t len;
  22. };
  23. static void out_char(struct out *o, char c)
  24. {
  25. if (o->buf && o->len < o->cap)
  26. o->buf[o->len] = c;
  27. o->len++;
  28. }
  29. static void out_mem(struct out *o, const char *s, size_t n)
  30. {
  31. size_t i;
  32. for (i = 0; i < n; i++)
  33. out_char(o, s[i]);
  34. }
  35. static int utoa_base(unsigned long long v, unsigned int base, int upper,
  36. char *buf)
  37. {
  38. static const char low[] = "0123456789abcdef";
  39. static const char up[] = "0123456789ABCDEF";
  40. const char *digits = upper ? up : low;
  41. char tmp[66];
  42. int n = 0;
  43. int i;
  44. do {
  45. tmp[n++] = digits[v % base];
  46. v /= base;
  47. } while (v);
  48. for (i = 0; i < n; i++)
  49. buf[i] = tmp[n - 1 - i];
  50. buf[n] = '\0';
  51. return n;
  52. }
  53. static void emit_padded(struct out *o, const char *s, int len, int width,
  54. int flags, int numeric)
  55. {
  56. int pad = width > len ? width - len : 0;
  57. int i;
  58. int sign = 0;
  59. if (numeric && len > 0 && (s[0] == '-' || s[0] == '+' || s[0] == ' '))
  60. sign = 1;
  61. if (!(flags & F_LEFT)) {
  62. if ((flags & F_ZERO) && numeric) {
  63. for (i = 0; i < sign; i++)
  64. out_char(o, s[i]);
  65. for (i = 0; i < pad; i++)
  66. out_char(o, '0');
  67. out_mem(o, s + sign, (size_t)(len - sign));
  68. return;
  69. }
  70. for (i = 0; i < pad; i++)
  71. out_char(o, ' ');
  72. }
  73. out_mem(o, s, (size_t)len);
  74. if (flags & F_LEFT) {
  75. for (i = 0; i < pad; i++)
  76. out_char(o, ' ');
  77. }
  78. }
  79. /* Round a digit string to `keep` digits. Returns the new length and sets
  80. * *carry when a leading '1' was inserted. */
  81. static int round_digits(char *d, int n, int keep, int *carry)
  82. {
  83. int next;
  84. int up = 0;
  85. int i;
  86. *carry = 0;
  87. if (keep >= n)
  88. return n;
  89. if (keep < 0)
  90. keep = 0;
  91. next = d[keep];
  92. if (next > '5') {
  93. up = 1;
  94. } else if (next == '5') {
  95. int nonzero = 0;
  96. for (i = keep + 1; i < n; i++) {
  97. if (d[i] != '0') {
  98. nonzero = 1;
  99. break;
  100. }
  101. }
  102. if (nonzero)
  103. up = 1;
  104. else if (keep > 0 && ((d[keep - 1] - '0') & 1))
  105. up = 1;
  106. }
  107. n = keep;
  108. if (!up)
  109. return n;
  110. i = n - 1;
  111. while (i >= 0 && d[i] == '9') {
  112. d[i] = '0';
  113. i--;
  114. }
  115. if (i >= 0) {
  116. d[i]++;
  117. } else {
  118. memmove(d + 1, d, (size_t)n);
  119. d[0] = '1';
  120. n++;
  121. *carry = 1;
  122. }
  123. return n;
  124. }
  125. static void prepend_zeros(char *d, int *n, int count)
  126. {
  127. if (count <= 0)
  128. return;
  129. if (*n + count > LIBC_DTOA_MAX)
  130. count = LIBC_DTOA_MAX - *n;
  131. if (count <= 0)
  132. return;
  133. memmove(d + count, d, (size_t)*n);
  134. memset(d, '0', (size_t)count);
  135. *n += count;
  136. }
  137. static void format_fixed(const struct libc_dtoa *dt, int prec, int hash,
  138. char *body, int *blen)
  139. {
  140. char d[LIBC_DTOA_MAX];
  141. int n = dt->ndigits;
  142. int point = dt->point;
  143. int keep;
  144. int carry = 0;
  145. if (prec > LIBC_DTOA_MAX - 8)
  146. prec = LIBC_DTOA_MAX - 8;
  147. memcpy(d, dt->digits, (size_t)n);
  148. if (point < 0) {
  149. prepend_zeros(d, &n, -point);
  150. point = 0;
  151. }
  152. if (point > n) {
  153. if (point + prec > LIBC_DTOA_MAX)
  154. point = LIBC_DTOA_MAX - prec - 1;
  155. while (n < point)
  156. d[n++] = '0';
  157. }
  158. keep = point + prec;
  159. if (keep > LIBC_DTOA_MAX - 2)
  160. keep = LIBC_DTOA_MAX - 2;
  161. while (n < keep)
  162. d[n++] = '0';
  163. if (keep < n)
  164. n = round_digits(d, n, keep, &carry);
  165. if (carry)
  166. point++;
  167. {
  168. int i = 0;
  169. if (point == 0) {
  170. body[i++] = '0';
  171. } else {
  172. int j;
  173. for (j = 0; j < point; j++)
  174. body[i++] = (j < n) ? d[j] : '0';
  175. }
  176. if (prec > 0 || hash) {
  177. body[i++] = '.';
  178. for (int j = 0; j < prec; j++)
  179. body[i++] = (point + j < n) ? d[point + j] : '0';
  180. }
  181. body[i] = '\0';
  182. *blen = i;
  183. }
  184. }
  185. static void format_exp(const struct libc_dtoa *dt, int prec, int hash,
  186. char *body, int *blen)
  187. {
  188. char d[LIBC_DTOA_MAX];
  189. int n = dt->ndigits;
  190. int point = dt->point;
  191. int keep;
  192. int carry;
  193. int exp10 = point - 1;
  194. int i;
  195. char *p = body;
  196. if (prec < 0)
  197. prec = 0;
  198. if (prec > 900)
  199. prec = 900;
  200. keep = prec + 1;
  201. if (keep > LIBC_DTOA_MAX - 2)
  202. keep = LIBC_DTOA_MAX - 2;
  203. memcpy(d, dt->digits, (size_t)n);
  204. while (n < keep)
  205. d[n++] = '0';
  206. if (keep < n)
  207. n = round_digits(d, n, keep, &carry);
  208. else
  209. carry = 0;
  210. if (carry) {
  211. exp10++;
  212. n = keep;
  213. }
  214. *p++ = d[0];
  215. if (prec > 0 || hash) {
  216. *p++ = '.';
  217. for (i = 1; i <= prec; i++)
  218. *p++ = (i < n) ? d[i] : '0';
  219. }
  220. *p++ = 'e';
  221. {
  222. int e = exp10;
  223. if (e < 0) {
  224. *p++ = '-';
  225. e = -e;
  226. } else {
  227. *p++ = '+';
  228. }
  229. if (e >= 100) {
  230. *p++ = (char)('0' + (e / 100) % 10);
  231. *p++ = (char)('0' + (e / 10) % 10);
  232. *p++ = (char)('0' + e % 10);
  233. } else {
  234. *p++ = (char)('0' + (e / 10) % 10);
  235. *p++ = (char)('0' + e % 10);
  236. }
  237. }
  238. *p = '\0';
  239. *blen = (int)(p - body);
  240. }
  241. static void strip_float_zeros(char *body, int *len)
  242. {
  243. char *e = strchr(body, 'e');
  244. char *dot = strchr(body, '.');
  245. char *end = e ? e : body + *len;
  246. if (!dot)
  247. return;
  248. while (end > dot && end[-1] == '0')
  249. end--;
  250. if (end > body && end[-1] == '.')
  251. end--;
  252. if (e) {
  253. int tail = (int)(*len - (e - body));
  254. if (end != e)
  255. memmove(end, e, (size_t)tail + 1);
  256. *len = (int)(end - body) + tail;
  257. } else {
  258. *len = (int)(end - body);
  259. body[*len] = '\0';
  260. }
  261. }
  262. static int significant_exp10(const struct libc_dtoa *dt, int prec)
  263. {
  264. char d[LIBC_DTOA_MAX];
  265. int n = dt->ndigits;
  266. int carry;
  267. if (prec < 1)
  268. prec = 1;
  269. if (n > prec) {
  270. memcpy(d, dt->digits, (size_t)n);
  271. n = round_digits(d, n, prec, &carry);
  272. if (carry)
  273. return dt->point;
  274. }
  275. return dt->point - 1;
  276. }
  277. static void format_double(struct out *o, double value, char conv,
  278. int prec, int flags, int width)
  279. {
  280. struct libc_dtoa dt;
  281. char body[LIBC_DTOA_MAX + 96];
  282. char num[LIBC_DTOA_MAX + 100];
  283. int blen = 0;
  284. int n;
  285. int sign;
  286. int cls;
  287. int body_start;
  288. cls = libc_dtoa(value, &dt);
  289. if (cls == 1) {
  290. blen = 3;
  291. memcpy(body, "inf", 4);
  292. sign = dt.neg;
  293. } else if (cls == 2) {
  294. blen = 3;
  295. memcpy(body, "nan", 4);
  296. sign = dt.neg;
  297. } else {
  298. sign = dt.neg;
  299. if (prec < 0)
  300. prec = 6;
  301. if (prec > 900)
  302. prec = 900;
  303. if (conv == 'f' || conv == 'F') {
  304. format_fixed(&dt, prec, (flags & F_HASH) != 0, body, &blen);
  305. } else if (conv == 'e' || conv == 'E') {
  306. format_exp(&dt, prec, (flags & F_HASH) != 0, body, &blen);
  307. } else {
  308. int p = prec;
  309. int exp10;
  310. if (p == 0)
  311. p = 1;
  312. exp10 = significant_exp10(&dt, p);
  313. if (exp10 < -4 || exp10 >= p) {
  314. format_exp(&dt, p - 1, (flags & F_HASH) != 0,
  315. body, &blen);
  316. } else {
  317. int fp = p - (exp10 + 1);
  318. if (fp < 0)
  319. fp = 0;
  320. format_fixed(&dt, fp, (flags & F_HASH) != 0,
  321. body, &blen);
  322. }
  323. if (!(flags & F_HASH))
  324. strip_float_zeros(body, &blen);
  325. }
  326. }
  327. body_start = 0;
  328. if (sign) {
  329. num[0] = '-';
  330. body_start = 1;
  331. } else if (flags & F_PLUS) {
  332. num[0] = '+';
  333. body_start = 1;
  334. } else if (flags & F_SPACE) {
  335. num[0] = ' ';
  336. body_start = 1;
  337. }
  338. memcpy(num + body_start, body, (size_t)blen + 1);
  339. n = body_start + blen;
  340. /* Uppercase E/Inf/NaN for the uppercase conversions. */
  341. if (conv == 'E' || conv == 'F' || conv == 'G') {
  342. for (int i = body_start; i < n; i++) {
  343. if (num[i] == 'e')
  344. num[i] = 'E';
  345. else if (num[i] == 'n')
  346. num[i] = 'N';
  347. else if (num[i] == 'i')
  348. num[i] = 'I';
  349. }
  350. }
  351. emit_padded(o, num, n, width, flags, 1);
  352. }
  353. int vsnprintf(char *buf, size_t size, const char *format, va_list ap)
  354. {
  355. struct out o;
  356. const char *p;
  357. o.buf = (buf && size) ? buf : 0;
  358. o.cap = (buf && size) ? size : 0;
  359. o.len = 0;
  360. for (p = format; *p; p++) {
  361. int flags = 0;
  362. int width = 0;
  363. int prec = -1;
  364. int len = -1;
  365. char conv;
  366. if (*p != '%') {
  367. out_char(&o, *p);
  368. continue;
  369. }
  370. p++;
  371. for (;;) {
  372. if (*p == '-') flags |= F_LEFT;
  373. else if (*p == '+') flags |= F_PLUS;
  374. else if (*p == ' ') flags |= F_SPACE;
  375. else if (*p == '#') flags |= F_HASH;
  376. else if (*p == '0') flags |= F_ZERO;
  377. else break;
  378. p++;
  379. }
  380. if (*p == '*') {
  381. width = va_arg(ap, int);
  382. if (width < 0) {
  383. flags |= F_LEFT;
  384. width = -width;
  385. }
  386. p++;
  387. } else {
  388. while (*p >= '0' && *p <= '9') {
  389. width = width * 10 + (*p - '0');
  390. p++;
  391. }
  392. }
  393. if (*p == '.') {
  394. p++;
  395. if (*p == '*') {
  396. prec = va_arg(ap, int);
  397. if (prec < 0)
  398. prec = -1;
  399. p++;
  400. } else {
  401. prec = 0;
  402. while (*p >= '0' && *p <= '9') {
  403. prec = prec * 10 + (*p - '0');
  404. p++;
  405. }
  406. }
  407. }
  408. if (*p == 'h') {
  409. p++;
  410. if (*p == 'h') {
  411. len = 0;
  412. p++;
  413. } else {
  414. len = 1;
  415. }
  416. } else if (*p == 'l') {
  417. p++;
  418. if (*p == 'l') {
  419. len = 3;
  420. p++;
  421. } else {
  422. len = 2;
  423. }
  424. } else if (*p == 'z') {
  425. len = 4;
  426. p++;
  427. } else if (*p == 't') {
  428. len = 5;
  429. p++;
  430. } else if (*p == 'j') {
  431. len = 6;
  432. p++;
  433. } else if (*p == 'L') {
  434. len = 7;
  435. p++;
  436. }
  437. conv = *p;
  438. if (!conv)
  439. break;
  440. if (conv == '%') {
  441. out_char(&o, '%');
  442. continue;
  443. }
  444. if (conv == 'c') {
  445. char c = (char)va_arg(ap, int);
  446. char s[2];
  447. s[0] = c;
  448. s[1] = '\0';
  449. emit_padded(&o, s, 1, width, flags & ~F_ZERO, 0);
  450. continue;
  451. }
  452. if (conv == 's') {
  453. const char *s = va_arg(ap, const char *);
  454. int n = 0;
  455. if (!s)
  456. s = "(null)";
  457. while (s[n] && (prec < 0 || n < prec))
  458. n++;
  459. emit_padded(&o, s, n, width, flags & ~F_ZERO, 0);
  460. continue;
  461. }
  462. if (conv == 'n') {
  463. int *ip = va_arg(ap, int *);
  464. /* Do not write during vfprintf's sizing pass. */
  465. if (ip && o.buf)
  466. *ip = (int)o.len;
  467. continue;
  468. }
  469. if (conv == 'f' || conv == 'F' || conv == 'e' ||
  470. conv == 'E' || conv == 'g' || conv == 'G') {
  471. format_double(&o, va_arg(ap, double), conv, prec, flags,
  472. width);
  473. continue;
  474. }
  475. {
  476. int base = 10;
  477. int upper = 0;
  478. int is_signed = 0;
  479. int is_ptr = 0;
  480. long long sv = 0;
  481. unsigned long long uv = 0;
  482. char digits[80];
  483. char body[96];
  484. int nd;
  485. int bn = 0;
  486. int prefix = 0;
  487. int neg = 0;
  488. if (conv == 'd' || conv == 'i') {
  489. is_signed = 1;
  490. } else if (conv == 'u') {
  491. base = 10;
  492. } else if (conv == 'o') {
  493. base = 8;
  494. } else if (conv == 'x') {
  495. base = 16;
  496. } else if (conv == 'X') {
  497. base = 16;
  498. upper = 1;
  499. } else if (conv == 'p') {
  500. base = 16;
  501. is_ptr = 1;
  502. } else {
  503. out_char(&o, '%');
  504. out_char(&o, conv);
  505. continue;
  506. }
  507. if (is_ptr) {
  508. uv = (unsigned long)va_arg(ap, void *);
  509. } else if (is_signed) {
  510. switch (len) {
  511. case 0: sv = (signed char)va_arg(ap, int); break;
  512. case 1: sv = (short)va_arg(ap, int); break;
  513. case 2: sv = va_arg(ap, long); break;
  514. case 3: sv = va_arg(ap, long long); break;
  515. case 4: sv = (long)va_arg(ap, size_t); break;
  516. case 5: sv = (long)va_arg(ap, ptrdiff_t); break;
  517. case 6: sv = va_arg(ap, long long); break;
  518. default: sv = va_arg(ap, int); break;
  519. }
  520. if (sv < 0) {
  521. neg = 1;
  522. uv = (unsigned long long)(-(sv + 1)) + 1ULL;
  523. } else {
  524. uv = (unsigned long long)sv;
  525. }
  526. } else {
  527. switch (len) {
  528. case 0: uv = (unsigned char)va_arg(ap, unsigned int); break;
  529. case 1: uv = (unsigned short)va_arg(ap, unsigned int); break;
  530. case 2: uv = va_arg(ap, unsigned long); break;
  531. case 3: uv = va_arg(ap, unsigned long long); break;
  532. case 4: uv = va_arg(ap, size_t); break;
  533. case 5: uv = (unsigned long)va_arg(ap, ptrdiff_t); break;
  534. case 6: uv = va_arg(ap, unsigned long long); break;
  535. default: uv = va_arg(ap, unsigned int); break;
  536. }
  537. }
  538. if (prec > 64)
  539. prec = 64;
  540. if (is_ptr) {
  541. prefix = 2;
  542. } else if ((flags & F_HASH) && base == 16 && uv != 0) {
  543. prefix = 2;
  544. } else if ((flags & F_HASH) && base == 8) {
  545. prefix = 1;
  546. }
  547. nd = utoa_base(uv, (unsigned int)base, upper, digits);
  548. if (prec == 0 && uv == 0) {
  549. nd = 0;
  550. digits[0] = '\0';
  551. }
  552. while (nd < prec) {
  553. memmove(digits + 1, digits, (size_t)nd + 1);
  554. digits[0] = '0';
  555. nd++;
  556. }
  557. if (neg) {
  558. body[bn++] = '-';
  559. } else if (flags & F_PLUS) {
  560. body[bn++] = '+';
  561. } else if (flags & F_SPACE) {
  562. body[bn++] = ' ';
  563. }
  564. if (prefix == 2) {
  565. body[bn++] = '0';
  566. body[bn++] = upper ? 'X' : 'x';
  567. } else if (prefix == 1 && (nd == 0 || digits[0] != '0')) {
  568. body[bn++] = '0';
  569. }
  570. memcpy(body + bn, digits, (size_t)nd);
  571. bn += nd;
  572. body[bn] = '\0';
  573. emit_padded(&o, body, bn, width, flags, 1);
  574. }
  575. }
  576. if (o.cap) {
  577. size_t end = o.len < o.cap ? o.len : o.cap - 1;
  578. o.buf[end] = '\0';
  579. }
  580. if (o.len > INT_MAX)
  581. return -1;
  582. return (int)o.len;
  583. }
  584. int snprintf(char *buf, size_t size, const char *format, ...)
  585. {
  586. va_list ap;
  587. int n;
  588. va_start(ap, format);
  589. n = vsnprintf(buf, size, format, ap);
  590. va_end(ap);
  591. return n;
  592. }
  593. int vsprintf(char *buf, const char *format, va_list ap)
  594. {
  595. return vsnprintf(buf, (size_t)-1, format, ap);
  596. }
  597. int sprintf(char *buf, const char *format, ...)
  598. {
  599. va_list ap;
  600. int n;
  601. va_start(ap, format);
  602. n = vsprintf(buf, format, ap);
  603. va_end(ap);
  604. return n;
  605. }
  606. int vfprintf(FILE *stream, const char *format, va_list ap)
  607. {
  608. va_list cp;
  609. int n;
  610. char *buf;
  611. va_copy(cp, ap);
  612. n = vsnprintf(0, 0, format, cp);
  613. va_end(cp);
  614. if (n < 0)
  615. return n;
  616. buf = (char *)malloc((size_t)n + 1);
  617. if (!buf) {
  618. errno = ENOMEM;
  619. return -1;
  620. }
  621. vsnprintf(buf, (size_t)n + 1, format, ap);
  622. fwrite(buf, 1, (size_t)n, stream);
  623. free(buf);
  624. return n;
  625. }
  626. int fprintf(FILE *stream, const char *format, ...)
  627. {
  628. va_list ap;
  629. int n;
  630. va_start(ap, format);
  631. n = vfprintf(stream, format, ap);
  632. va_end(ap);
  633. return n;
  634. }
  635. int vprintf(const char *format, va_list ap)
  636. {
  637. return vfprintf(stdout, format, ap);
  638. }
  639. int printf(const char *format, ...)
  640. {
  641. va_list ap;
  642. int n;
  643. va_start(ap, format);
  644. n = vfprintf(stdout, format, ap);
  645. va_end(ap);
  646. return n;
  647. }
  648. int puts(const char *s)
  649. {
  650. if (fputs(s, stdout) < 0)
  651. return EOF;
  652. if (fputc('\n', stdout) < 0)
  653. return EOF;
  654. return 0;
  655. }
  656. int putchar(int c)
  657. {
  658. return fputc(c, stdout);
  659. }
  660. void perror(const char *s)
  661. {
  662. if (s && *s)
  663. fprintf(stderr, "%s: %s\n", s, strerror(errno));
  664. else
  665. fprintf(stderr, "%s\n", strerror(errno));
  666. }