logo

utils-std

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

printf.c (13897B)

    

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