logo

utils-std

Collection of commonly available Unix tools git clone https://anongit.hacktivis.me/git/utils-std.git/

printf.c (15264B)

    

  1. // utils-std: Collection of commonly available Unix tools
  2. // SPDX-FileCopyrightText: 2017 Haelwenn (lanodan) Monnier <contact+utils@hacktivis.me>
  3. // SPDX-License-Identifier: MPL-2.0
  5. #define _POSIX_C_SOURCE 200809L
  6. #include <errno.h>
  7. #include <stdbool.h>
  8. #include <stdio.h>  // printf
  9. #include <stdlib.h> // strtoul, strtod
  10. #include <string.h> // strlen, memchr
  12. #undef MAX
  13. #define MAX(a, b) (a > b) ? a : b
  15. // [1-9]
  16. static int
  17. isndigit(int c)
  18. {
  19. 	return c >= '1' && c <= '9';
  20. }
  22. // digits [0-9]
  23. static int
  24. isdigit(int c)
  25. {
  26. 	return c >= '0' && c <= '9';
  27. }
  29. // hex digits [0-9A-Fa-f]
  30. static int
  31. isxdigit(int c)
  32. {
  33. 	return isdigit(c) || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
  34. }
  36. static int
  37. iscntrl(int c)
  38. {
  39. 	return (unsigned)c < 0x20 || c == 0x7f;
  40. }
  42. // len parameter needed because of NULL escapes
  43. // returns 1 for handling '\c' early ends
  44. static int
  45. unescape(char *fmt, size_t *len, int percent)
  46. {
  47. 	char *start = fmt;
  48. 	char *store;
  49. 	char c = '\0';
  50. 	int value;
  52. 	/*
  53. 	 * Required by POSIX.1-2024 for printf(1): \\ \a \b \c \f \n \r \t \v \000
  54. 	 *
  55. 	 * As inspiration, required by POSIX.1-2024 for dollar-single-quote($'…'):
  56. 	 *    \" \' \\ \a \b \e \f \n\ r\ t\ \v \c0 \x00 \000
  57. 	 * <https://pubs.opengroup.org/onlinepubs/9799919799/utilities/V3_chap02.html#tag_19_02_04>
  58. 	 */
  59. 	for(store = fmt; ((c = *fmt) != '\0') && fmt < (start + *len); ++fmt, ++store)
  60. 	{
  61. 		if(c != '\\')
  62. 		{
  63. 			*store = c;
  64. 			continue;
  65. 		}
  67. 		switch(*++fmt)
  68. 		{
  69. 		case '\\': /* backslash; POSIX */
  70. 		case '\'': /* single quote */
  71. 		default:
  72. 			*store = *fmt;
  73. 			break;
  74. 		case 'a': /* bell/alert; POSIX */
  75. 			*store = '\a';
  76. 			break;
  77. 		case 'b': /* backspace; POSIX */
  78. 			*store = '\b';
  79. 			break;
  80. 		case 'c':
  81. 			if(!percent)
  82. 			{
  83. 				/* clear; POSIX */
  84. 				*store = '\0';
  85. 				*len = (size_t)(store - start);
  86. 				return 1;
  87. 			}
  89. 			/* Assumes ASCII */
  90. 			if(fmt[1] == '?')
  91. 			{
  92. 				fmt++;
  93. 				*store = '\177';
  94. 			}
  95. 			else if(fmt[1] >= 'a' && fmt[1] <= 'z')
  96. 			{
  97. 				fmt++;
  98. 				*store = (fmt[0] - 'a') + 1;
  99. 			}
  100. 			else if(fmt[1] >= '@' && fmt[1] <= '_')
  101. 			{
  102. 				fmt++;
  103. 				*store = (fmt[0] - '@');
  104. 			}
  105. 			else
  106. 			{
  107. 				*store = 'c';
  108. 			}
  109. 			break;
  110. 		case 'e': /* escape */
  111. 			*store = '\033';
  112. 			break;
  113. 		case 'f': /* form-feed; POSIX */
  114. 			*store = '\f';
  115. 			break;
  116. 		case 'n': /* newline; POSIX */
  117. 			*store = '\n';
  118. 			break;
  119. 		case 'r': /* carriage-return; POSIX */
  120. 			*store = '\r';
  121. 			break;
  122. 		case 't': /* horizontal tab; POSIX */
  123. 			*store = '\t';
  124. 			break;
  125. 		case 'v': /* vertical tab; POSIX */
  126. 			*store = '\v';
  127. 			break;
  128. 		case 'x': /* hex */
  129. 			c = 2;
  130. 			fmt++;
  131. 			for(value = 0; c-- && isxdigit(*fmt); ++fmt)
  132. 			{
  133. 				value <<= 4;
  134. 				if(*fmt <= '9')
  135. 					value += *fmt - '0';
  136. 				else if(*fmt <= 'F')
  137. 					value += *fmt - 'A' + 10;
  138. 				else
  139. 					value += *fmt - 'a' + 10;
  140. 			}
  141. 			--fmt;
  142. 			*store = (char)value;
  143. 			break;
  144. 		/* octal; POSIX */
  145. 		case '0':
  146. 		case '1':
  147. 		case '2':
  148. 		case '3':
  149. 		case '4':
  150. 		case '5':
  151. 		case '6':
  152. 		case '7':
  153. 			c = (!percent && *fmt == '0') ? 4 : 3;
  154. 			for(value = 0; c-- && *fmt >= '0' && *fmt <= '7'; ++fmt)
  155. 			{
  156. 				value <<= 3;
  157. 				value += *fmt - '0';
  158. 			}
  159. 			--fmt;
  160. 			*store = (percent && value == '%') ? '%' : (char)value;
  161. 			break;
  162. 		}
  163. 	}
  165. 	*store = '\0';
  166. 	*len = (size_t)(store - start);
  167. 	return 0;
  168. }
  170. static void
  171. usage(void)
  172. {
  173. 	(void)fputs("usage: printf format [arguments...]\n", stderr);
  174. }
  176. int
  177. main(int argc, char *argv[])
  178. {
  179. 	argc--;
  180. 	argv++;
  182. 	if(argc > 1 && strcmp("--", *argv) == 0)
  183. 	{
  184. 		argc--;
  185. 		argv++;
  186. 	}
  188. 	if(argc < 1)
  189. 	{
  190. 		usage();
  191. 		return 1;
  192. 	}
  194. 	char *fmt = argv[0];
  195. 	size_t fmtlen = strlen(fmt);
  197. 	if(unescape(fmt, &fmtlen, 1) != 0) return 1;
  199. 	argc--;
  200. 	argv++;
  202. 	// To keep argv intact for '%n$' format conversion specifiers
  203. 	char **fmt_argv = argv;
  205. 	if(!strchr(fmt, '%'))
  206. 	{
  207. 		fwrite(fmt, 1, fmtlen, stdout);
  208. 		return 0;
  209. 	}
  211. 	do
  212. 	{
  213. 		int fmt_argn = 0;
  215. 		for(char *fmt_idx = fmt; fmt_idx < (fmt + fmtlen); fmt_idx++)
  216. 		{
  217. 			// Field width provided for consistency with C printf
  218. 			int fwidth = 0;
  219. 			/* "negative precision is taken as if the precision were omitted." — POSIX.1-2008 fprintf() */
  220. 			int precision = -1;
  222. #define FMT_FLAGS "'-+ #0"
  223. #define FMT_BUF_SIZ sizeof("%" FMT_FLAGS "*.*d")
  224. 			size_t fmt_bufi = 0;
  225. 			static char fmt_buf[FMT_BUF_SIZ];
  226. 			fmt_buf[fmt_bufi++] = '%';
  228. 			char *fmt_arg = NULL;
  229. 			if(*fmt_idx != '%')
  230. 			{
  231. 				char *p = strchr(fmt_idx, '%');
  232. 				if(!p) p = fmt + fmtlen;
  234. 				fwrite(fmt_idx, 1, p - fmt_idx, stdout);
  235. 				fmt_idx = (p - 1);
  236. 				continue;
  237. 			}
  239. 			fmt_idx++;
  240. 			if(!(fmt_idx < (fmt + fmtlen))) return 0;
  242. 			// handle '%n$' if present
  243. 			if(isndigit(*fmt_idx) && argc > 0)
  244. 			{
  245. 				errno = 0;
  246. 				char *num_end = NULL;
  247. 				unsigned int num = strtoul(fmt_idx, &num_end, 10);
  248. 				if(errno == 0 && num != 0 && num_end && *num_end == '$')
  249. 				{
  250. 					if((int)num > argc)
  251. 					{
  252. 						fprintf(stderr,
  253. 						        "printf: error: (format position %d) argument '%d' does not exists, only got "
  254. 						        "%d arguments\n",
  255. 						        (int)(fmt_idx - fmt),
  256. 						        num,
  257. 						        argc);
  258. 						return 1;
  259. 					}
  260. 					fmt_argn = MAX(fmt_argn, (int)num);
  261. 					fmt_arg = fmt_argv[num - 1];
  262. 					fmt_idx = num_end + 1;
  263. 				}
  264. 			}
  266. 			/* flags */
  267. 			while(fmt_bufi < sizeof(FMT_FLAGS) && fmt_idx + 1 < (fmt + fmtlen) &&
  268. 			      strchr(FMT_FLAGS, *fmt_idx) != NULL)
  269. 			{
  270. 				if(memchr(fmt_buf, *fmt_idx, fmt_bufi + 1))
  271. 				{
  272. 					fprintf(stderr,
  273. 					        "printf: error: (format position %d) flag '%c' already set\n",
  274. 					        (int)(fmt_idx - fmt),
  275. 					        *fmt_idx);
  276. 					return 1;
  277. 				}
  279. 				fmt_buf[fmt_bufi++] = *fmt_idx;
  280. 				fmt_idx++;
  281. 			}
  283. 			// Field width from argument
  284. 			fmt_buf[fmt_bufi++] = '*';
  285. 			if(fmt_idx[0] == '*')
  286. 			{
  287. 				if(argc <= 0)
  288. 				{
  289. 					fprintf(stderr,
  290. 					        "printf: error: (format position %d) field-width argument without format "
  291. 					        "arguments\n",
  292. 					        (int)(fmt_idx - fmt));
  293. 					return 1;
  294. 				}
  296. 				char *fwidth_arg = NULL;
  297. 				fmt_idx++;
  298. 				if(isndigit(*fmt_idx))
  299. 				{
  300. 					if(!fmt_arg)
  301. 					{
  302. 						fprintf(stderr,
  303. 						        "printf: error: (format position %d) field-width positional argument usage "
  304. 						        "('*n$') also needs format data to be positional (via '%%n$')\n",
  305. 						        (int)(fmt_idx - fmt));
  306. 						return 1;
  307. 					}
  309. 					errno = 0;
  310. 					char *num_end = NULL;
  311. 					unsigned int num = strtoul(fmt_idx, &num_end, 10);
  312. 					if(errno != 0)
  313. 					{
  314. 						fprintf(
  315. 						    stderr,
  316. 						    "printf: error: (format position %d) Failed parsing field-width as a number: %s\n",
  317. 						    (int)(fmt_idx - fmt),
  318. 						    strerror(errno));
  319. 						return 1;
  320. 					}
  321. 					if(!num_end || *num_end != '$')
  322. 					{
  323. 						fprintf(stderr,
  324. 						        "printf: error: (format position %d) Expected to find '$' after field-width "
  325. 						        "digits\n",
  326. 						        (int)(fmt_idx - fmt));
  327. 						return 1;
  328. 					}
  329. 					if((int)num > argc)
  330. 					{
  331. 						fprintf(stderr,
  332. 						        "printf: error: (format position %d) argument '%d' does not exists, only got "
  333. 						        "%d arguments\n",
  334. 						        (int)(fmt_idx - fmt),
  335. 						        num,
  336. 						        argc);
  337. 						return 1;
  338. 					}
  340. 					fmt_argn = MAX(fmt_argn, (int)num);
  341. 					fwidth_arg = fmt_argv[num - 1];
  342. 					fmt_idx = num_end + 1;
  343. 				}
  344. 				else
  345. 				{
  346. 					if(fmt_argn < argc) fwidth_arg = fmt_argv[fmt_argn++];
  347. 					if(fmt_argn < argc) fmt_arg = fmt_argv[fmt_argn++];
  348. 				}
  350. 				if(fwidth_arg)
  351. 				{
  352. 					errno = 0;
  353. 					fwidth = strtoul(fwidth_arg, NULL, 0);
  354. 					if(errno != 0)
  355. 					{
  356. 						fprintf(stderr,
  357. 						        "printf: error: Failed parsing argument (%s) as a number for field width: %s\n",
  358. 						        fwidth_arg,
  359. 						        strerror(errno));
  360. 						return 1;
  361. 					}
  362. 				}
  363. 			}
  364. 			else if(isdigit(fmt_idx[0]))
  365. 			{
  366. 				errno = 0;
  367. 				char *num_end = NULL;
  368. 				fwidth = strtoul(fmt_idx, &num_end, 10);
  369. 				if(errno != 0)
  370. 				{
  371. 					fprintf(
  372. 					    stderr,
  373. 					    "printf: error: (format position %d) Failed parsing field-width as a number: %s\n",
  374. 					    (int)(fmt_idx - fmt),
  375. 					    strerror(errno));
  376. 					return 1;
  377. 				}
  378. 				if(!num_end)
  379. 				{
  380. 					fprintf(stderr,
  381. 					        "printf: error: (format position %d) No remaining characters after field-width "
  382. 					        "digits\n",
  383. 					        (int)(fmt_idx - fmt));
  384. 					return 1;
  385. 				}
  386. 				if(*num_end == '$')
  387. 				{
  388. 					fprintf(stderr,
  389. 					        "printf: error: (format position %d) Unexpectedly found '$' after '*'-less "
  390. 					        "field-width digits\n",
  391. 					        (int)(fmt_idx - fmt));
  392. 					return 1;
  393. 				}
  394. 				fmt_idx = num_end;
  395. 			}
  397. 			/* precision */
  398. 			fmt_buf[fmt_bufi++] = '.';
  399. 			fmt_buf[fmt_bufi++] = '*';
  400. 			if(*fmt_idx == '.')
  401. 			{
  402. 				fmt_idx++;
  404. 				if(*fmt_idx == '*')
  405. 				{
  406. 					fmt_idx++;
  408. 					if(argc <= 0)
  409. 					{
  410. 						fprintf(stderr,
  411. 						        "printf: error: (format position %d) precision argument without format "
  412. 						        "arguments\n",
  413. 						        (int)(fmt_idx - fmt));
  414. 						return 1;
  415. 					}
  417. 					char *prec_arg = NULL;
  418. 					if(isndigit(*fmt_idx))
  419. 					{
  420. 						if(!fmt_arg)
  421. 						{
  422. 							fprintf(stderr,
  423. 							        "printf: error: (format position %d) precision positional argument usage "
  424. 							        "('.*n$') also needs format data to be positional (via '%%n$')\n",
  425. 							        (int)(fmt_idx - fmt));
  426. 							return 1;
  427. 						}
  429. 						errno = 0;
  430. 						char *num_end = NULL;
  431. 						unsigned int num = strtoul(fmt_idx, &num_end, 10);
  432. 						if(errno != 0)
  433. 						{
  434. 							fprintf(
  435. 							    stderr,
  436. 							    "printf: error: (format position %d) Failed parsing precision as a number: %s\n",
  437. 							    (int)(fmt_idx - fmt),
  438. 							    strerror(errno));
  439. 							return 1;
  440. 						}
  441. 						if(!num_end || *num_end != '$')
  442. 						{
  443. 							fprintf(stderr,
  444. 							        "printf: error: (format position %d) Expected to find '$' after precision "
  445. 							        "digits\n",
  446. 							        (int)(fmt_idx - fmt));
  447. 							return 1;
  448. 						}
  449. 						if((int)num > argc)
  450. 						{
  451. 							fprintf(stderr,
  452. 							        "printf: error: (format position %d) argument '%d' does not exists, only got "
  453. 							        "%d arguments\n",
  454. 							        (int)(fmt_idx - fmt),
  455. 							        num,
  456. 							        argc);
  457. 							return 1;
  458. 						}
  460. 						fmt_argn = MAX(fmt_argn, (int)num);
  461. 						prec_arg = fmt_argv[num - 1];
  462. 						fmt_idx = num_end + 1;
  463. 					}
  464. 					else
  465. 					{
  466. 						if(fmt_argn < argc) prec_arg = fmt_argv[fmt_argn++];
  467. 					}
  469. 					if(prec_arg)
  470. 					{
  471. 						errno = 0;
  472. 						precision = strtoul(prec_arg, NULL, 0);
  473. 						if(errno != 0)
  474. 						{
  475. 							fprintf(stderr,
  476. 							        "printf: error: Failed parsing argument (%s) as a number for precision: %s\n",
  477. 							        prec_arg,
  478. 							        strerror(errno));
  479. 							return 1;
  480. 						}
  481. 					}
  482. 				}
  483. 				else if(isdigit(fmt_idx[0]))
  484. 				{
  485. 					errno = 0;
  486. 					char *num_end = NULL;
  487. 					precision = strtoul(fmt_idx, &num_end, 10);
  488. 					if(errno != 0)
  489. 					{
  490. 						fprintf(
  491. 						    stderr,
  492. 						    "printf: error: (format position %d) Failed parsing precision as a number: %s\n",
  493. 						    (int)(fmt_idx - fmt),
  494. 						    strerror(errno));
  495. 						return 1;
  496. 					}
  497. 					if(!num_end)
  498. 					{
  499. 						fprintf(stderr,
  500. 						        "printf: error: (format position %d) No remaining characters after precision's "
  501. 						        "digits\n",
  502. 						        (int)(fmt_idx - fmt));
  503. 						return 1;
  504. 					}
  505. 					if(*num_end == '$')
  506. 					{
  507. 						fprintf(stderr,
  508. 						        "printf: error: (format position %d) Unexpectedly found '$' after '*'-less "
  509. 						        "precision's digits\n",
  510. 						        (int)(fmt_idx - fmt));
  511. 						return 1;
  512. 					}
  513. 					fmt_idx = num_end;
  514. 				}
  515. 				else
  516. 				{
  517. 					fprintf(stderr,
  518. 					        "printf: error: (format position %d) Unknown precision format (char: '%c')\n",
  519. 					        (int)(fmt_idx - fmt),
  520. 					        *fmt_idx);
  521. 					return 1;
  522. 				}
  523. 			}
  525. 			/* BSD compatibility */
  526. 			if(*fmt_idx == 'L') fmt_idx++;
  528. 			fmt_buf[fmt_bufi++] = *fmt_idx;
  529. 			fmt_buf[fmt_bufi++] = '\0';
  531. 			if(!fmt_arg && fmt_argn < argc) fmt_arg = fmt_argv[fmt_argn++];
  533. 			switch(*fmt_idx)
  534. 			{
  535. 			case '%':
  536. 				putchar(*fmt_idx);
  537. 				break;
  538. 			/* strings */
  539. 			case 's':
  540. 				if(!fmt_arg) fmt_arg = (char *)"";
  541. 				printf(fmt_buf, fwidth, precision, fmt_arg);
  542. 				break;
  543. 			case 'b':
  544. 			{
  545. 				if(!fmt_arg) fmt_arg = (char *)"";
  546. 				size_t arglen = strlen(fmt_arg);
  548. 				int clear = unescape(fmt_arg, &arglen, 0);
  550. 				if(precision > 0 && arglen > (size_t)precision) arglen = precision;
  552. 				/* left-justify if there's a '-' flag */
  553. 				if(memchr(fmt_buf, '-', fmt_bufi + 1))
  554. 				{
  555. 					fwrite(fmt_arg, 1, arglen, stdout);
  557. 					for(int pad = fwidth - arglen; pad > 0; pad--)
  558. 						putchar(' ');
  559. 				}
  560. 				else
  561. 				{
  562. 					for(int pad = fwidth - arglen; pad > 0; pad--)
  563. 						putchar(' ');
  565. 					fwrite(fmt_arg, 1, arglen, stdout);
  566. 				}
  568. 				if(clear) return 0;
  570. 				break;
  571. 			}
  572. 			case 'q':
  573. 			{
  574. 				if(!fmt_arg) fmt_arg = (char *)"";
  575. 				if(fwidth != 0)
  576. 				{
  577. 					fprintf(
  578. 					    stderr,
  579. 					    "printf: error: (format position %d) field-width is unsupported with 'q' specifier\n",
  580. 					    (int)(fmt_idx - fmt));
  581. 					return 1;
  582. 				}
  584. 				if(precision != -1)
  585. 				{
  586. 					fprintf(
  587. 					    stderr,
  588. 					    "printf: error: (format position %d) precision is unsupported with 'q' specifier\n",
  589. 					    (int)(fmt_idx - fmt));
  590. 					return 1;
  591. 				}
  593. 				size_t arglen = strlen(fmt_arg);
  594. 				bool quoted = false;
  595. 				for(size_t i = 0; i < arglen; i++)
  596. 				{
  597. 					if(!(iscntrl(fmt_arg[i]) || fmt_arg[i] == '\'' || fmt_arg[i] == '"'))
  598. 					{
  599. 						putchar(fmt_arg[i]);
  600. 						continue;
  601. 					}
  603. 					if(!quoted)
  604. 					{
  605. 						quoted = true;
  606. 						fputs("$'", stdout);
  607. 					}
  609. 					switch(fmt_arg[i])
  610. 					{
  611. 					default:
  612. 					case 0x7F:
  613. 						/* for control chars */
  614. 						printf("\\c%c", fmt_arg[i] == 0x7F ? '?' : fmt_arg[i] + '@');
  615. 						break;
  616. 					case '\'':
  617. 						fputs("\\'", stdout);
  618. 						break;
  619. 					case '"':
  620. 						putchar(fmt_arg[i]);
  621. 						break;
  622. 					}
  623. 				}
  624. 				if(quoted) putchar('\'');
  625. 				break;
  626. 			}
  627. 			case 'c':
  628. 				if(!fmt_arg) fmt_arg = (char *)"";
  629. 				printf("%*c", fwidth, *fmt_arg);
  630. 				break;
  631. 			/* integers */
  632. 			case 'd':
  633. 			case 'i':
  634. 			case 'o':
  635. 			case 'u':
  636. 			case 'x':
  637. 			case 'X':
  638. 			{
  639. 				unsigned long int num = 0;
  640. 				if(fmt_arg)
  641. 				{
  642. 					errno = 0;
  643. 					num = strtoul(fmt_arg, NULL, 0);
  644. 					if(errno != 0)
  645. 					{
  646. 						fprintf(stderr,
  647. 						        "printf: error: Failed parsing argument (%s) as a number for format conversion "
  648. 						        "'%%%c': %s\n",
  649. 						        fmt_arg,
  650. 						        *fmt_idx,
  651. 						        strerror(errno));
  652. 						return 1;
  653. 					}
  654. 				}
  656. 				printf(fmt_buf, fwidth, precision, num);
  657. 				break;
  658. 			}
  659. 			/* floats */
  660. 			case 'a':
  661. 			case 'A':
  662. 			case 'e':
  663. 			case 'E':
  664. 			case 'f':
  665. 			case 'F':
  666. 			case 'g':
  667. 			case 'G':
  668. 			{
  669. 				double num = 0;
  670. 				if(fmt_arg)
  671. 				{
  672. 					num = strtod(fmt_arg, NULL);
  673. 					if(errno != 0)
  674. 					{
  675. 						fprintf(stderr,
  676. 						        "printf: error: Failed parsing argument (%s) as a number for format conversion "
  677. 						        "'%%%c': %s\n",
  678. 						        fmt_arg,
  679. 						        *fmt_idx,
  680. 						        strerror(errno));
  681. 						return 1;
  682. 					}
  683. 				}
  685. 				printf(fmt_buf, fwidth, precision, num);
  686. 				break;
  687. 			}
  688. 			default:
  689. 				fprintf(stderr, "printf: error: Unknown conversion specifier '%c'\n", *fmt_idx);
  690. 				return 1;
  691. 			}
  692. 		}
  694. 		fmt_argv += fmt_argn;
  695. 		argc -= fmt_argn;
  696. 	} while(argc > 0);
  697. }