logo

utils-std

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

printf.c (14682B)

    

  1. /*-
  2.  * SPDX-License-Identifier: BSD-3-Clause
  3.  *
  4.  * Copyright 2018 Staysail Systems, Inc. <info@staysail.tech>
  5.  * Copyright 2014 Garrett D'Amore <garrett@damore.org>
  6.  * Copyright 2010 Nexenta Systems, Inc.  All rights reserved.
  7.  * Copyright (c) 1989, 1993
  8.  *	The Regents of the University of California.  All rights reserved.
  9.  *
  10.  * Redistribution and use in source and binary forms, with or without
  11.  * modification, are permitted provided that the following conditions
  12.  * are met:
  13.  * 1. Redistributions of source code must retain the above copyright
  14.  *    notice, this list of conditions and the following disclaimer.
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in the
  17.  *    documentation and/or other materials provided with the distribution.
  18.  * 3. Neither the name of the University nor the names of its contributors
  19.  *    may be used to endorse or promote products derived from this software
  20.  *    without specific prior written permission.
  21.  *
  22.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32.  * SUCH DAMAGE.
  33.  */
  34. /*
  35.  * Important: This file is used both as a standalone program /usr/bin/printf
  36.  * and as a builtin for /bin/sh (#define SHELL).
  37.  */
  39. #define _POSIX_C_SOURCE 200809L
  41. #include "../lib/err.h"
  43. #include <assert.h>
  44. #include <ctype.h>
  45. #include <errno.h>
  46. #include <inttypes.h>
  47. #include <limits.h>
  48. #include <locale.h>
  49. #include <stdio.h>
  50. #include <stdlib.h>
  51. #include <string.h>
  52. #include <sys/types.h>
  53. #include <unistd.h>
  54. #include <wchar.h>
  56. #define PF(f, func)                                                                                \
  57. 	do                                                                                               \
  58. 	{                                                                                                \
  59. 		if(havewidth)                                                                                  \
  60. 			if(haveprec)                                                                                 \
  61. 				(void)printf(f, fieldwidth, precision, func);                                              \
  62. 			else                                                                                         \
  63. 				(void)printf(f, fieldwidth, func);                                                         \
  64. 		else if(haveprec)                                                                              \
  65. 			(void)printf(f, precision, func);                                                            \
  66. 		else                                                                                           \
  67. 			(void)printf(f, func);                                                                       \
  68. 	} while(0)
  70. static int asciicode(void);
  71. static char *printf_doformat(char *, int *);
  72. static int escape(char *, int, size_t *);
  73. static int getchr(void);
  74. static int getfloating(long double *, int);
  75. static int getint(int *);
  76. static int getnum(intmax_t *, uintmax_t *, int);
  77. static const char *getstr(void);
  78. static char *mknum(char *, char);
  79. static void usage(void);
  81. static const char digits[] = "0123456789";
  83. static char end_fmt[1];
  85. static int myargc;
  86. static char **myargv;
  87. static char **gargv;
  88. static char **maxargv;
  90. const char *argv0 = "printf";
  92. int
  93. main(int argc, char *argv[])
  94. {
  95. 	size_t len;
  96. 	int end, rval;
  97. 	char *format, *fmt, *start;
  98. 	int ch;
  100. 	(void)setlocale(LC_ALL, "");
  102. 	while((ch = getopt(argc, argv, "")) != -1)
  103. 		switch(ch)
  104. 		{
  105. 		case '?':
  106. 		default:
  107. 			usage();
  108. 			return (1);
  109. 		}
  110. 	argc -= optind;
  111. 	argv += optind;
  113. 	if(argc < 1)
  114. 	{
  115. 		usage();
  116. 		return (1);
  117. 	}
  119. 	/*
  120. 	 * Basic algorithm is to scan the format string for conversion
  121. 	 * specifications -- once one is found, find out if the field
  122. 	 * width or precision is a '*'; if it is, gather up value.  Note,
  123. 	 * format strings are reused as necessary to use up the provided
  124. 	 * arguments, arguments of zero/null string are provided to use
  125. 	 * up the format string.
  126. 	 */
  127. 	fmt = format = *argv;
  128. 	escape(fmt, 1, &len); /* backslash interpretation */
  129. 	rval = end = 0;
  130. 	gargv = ++argv;
  132. 	for(;;)
  133. 	{
  134. 		maxargv = gargv;
  136. 		myargv = gargv;
  137. 		for(myargc = 0; gargv[myargc]; myargc++)
  138. 			/* nop */;
  139. 		start = fmt;
  140. 		while(fmt < format + len)
  141. 		{
  142. 			if(fmt[0] == '%')
  143. 			{
  144. 				fwrite(start, 1, fmt - start, stdout);
  145. 				if(fmt[1] == '%')
  146. 				{
  147. 					/* %% prints a % */
  148. 					putchar('%');
  149. 					fmt += 2;
  150. 				}
  151. 				else
  152. 				{
  153. 					fmt = printf_doformat(fmt, &rval);
  154. 					if(fmt == NULL || fmt == end_fmt)
  155. 					{
  156. 						return (fmt == NULL ? 1 : rval);
  157. 					}
  158. 					end = 0;
  159. 				}
  160. 				start = fmt;
  161. 			}
  162. 			else
  163. 				fmt++;
  164. 			if(gargv > maxargv) maxargv = gargv;
  165. 		}
  166. 		gargv = maxargv;
  168. 		if(end == 1)
  169. 		{
  170. 			utils_warnx("missing format character");
  171. 			return (1);
  172. 		}
  173. 		fwrite(start, 1, fmt - start, stdout);
  174. 		if(!*gargv)
  175. 		{
  176. 			return (rval);
  177. 		}
  178. 		/* Restart at the beginning of the format string. */
  179. 		fmt = format;
  180. 		end = 1;
  181. 	}
  182. 	/* NOTREACHED */
  183. }
  185. static char *
  186. printf_doformat(char *fmt, int *rval)
  187. {
  188. 	static const char skip1[] = "#'-+ 0";
  189. 	int fieldwidth, haveprec, havewidth, mod_ldbl, precision;
  190. 	char convch, nextch;
  191. 	char start[strlen(fmt) + 1];
  192. 	char **fargv;
  193. 	char *dptr;
  194. 	int l;
  196. 	dptr = start;
  197. 	*dptr++ = '%';
  198. 	*dptr = 0;
  200. 	fmt++;
  202. 	/* look for "n$" field index specifier */
  203. 	l = strspn(fmt, digits);
  204. 	if((l > 0) && (fmt[l] == '$'))
  205. 	{
  206. 		int idx = atoi(fmt);
  207. 		if(idx <= myargc)
  208. 		{
  209. 			gargv = &myargv[idx - 1];
  210. 		}
  211. 		else
  212. 		{
  213. 			gargv = &myargv[myargc];
  214. 		}
  215. 		if(gargv > maxargv) maxargv = gargv;
  216. 		fmt += l + 1;
  218. 		/* save format argument */
  219. 		fargv = gargv;
  220. 	}
  221. 	else
  222. 	{
  223. 		fargv = NULL;
  224. 	}
  226. 	/* skip to field width */
  227. 	while(*fmt && strchr(skip1, *fmt) != NULL)
  228. 	{
  229. 		*dptr++ = *fmt++;
  230. 		*dptr = 0;
  231. 	}
  233. 	if(*fmt == '*')
  234. 	{
  236. 		fmt++;
  237. 		l = strspn(fmt, digits);
  238. 		if((l > 0) && (fmt[l] == '$'))
  239. 		{
  240. 			int idx = atoi(fmt);
  241. 			if(fargv == NULL)
  242. 			{
  243. 				utils_warnx("incomplete use of n$");
  244. 				return (NULL);
  245. 			}
  246. 			if(idx <= myargc)
  247. 			{
  248. 				gargv = &myargv[idx - 1];
  249. 			}
  250. 			else
  251. 			{
  252. 				gargv = &myargv[myargc];
  253. 			}
  254. 			fmt += l + 1;
  255. 		}
  256. 		else if(fargv != NULL)
  257. 		{
  258. 			utils_warnx("incomplete use of n$");
  259. 			return (NULL);
  260. 		}
  262. 		if(getint(&fieldwidth)) return (NULL);
  263. 		if(gargv > maxargv) maxargv = gargv;
  264. 		havewidth = 1;
  266. 		*dptr++ = '*';
  267. 		*dptr = 0;
  268. 	}
  269. 	else
  270. 	{
  271. 		havewidth = 0;
  273. 		/* skip to possible '.', get following precision */
  274. 		while(isdigit(*fmt))
  275. 		{
  276. 			*dptr++ = *fmt++;
  277. 			*dptr = 0;
  278. 		}
  279. 	}
  281. 	if(*fmt == '.')
  282. 	{
  283. 		/* precision present? */
  284. 		fmt++;
  285. 		*dptr++ = '.';
  287. 		if(*fmt == '*')
  288. 		{
  290. 			fmt++;
  291. 			l = strspn(fmt, digits);
  292. 			if((l > 0) && (fmt[l] == '$'))
  293. 			{
  294. 				int idx = atoi(fmt);
  295. 				if(fargv == NULL)
  296. 				{
  297. 					utils_warnx("incomplete use of n$");
  298. 					return (NULL);
  299. 				}
  300. 				if(idx <= myargc)
  301. 				{
  302. 					gargv = &myargv[idx - 1];
  303. 				}
  304. 				else
  305. 				{
  306. 					gargv = &myargv[myargc];
  307. 				}
  308. 				fmt += l + 1;
  309. 			}
  310. 			else if(fargv != NULL)
  311. 			{
  312. 				utils_warnx("incomplete use of n$");
  313. 				return (NULL);
  314. 			}
  316. 			if(getint(&precision)) return (NULL);
  317. 			if(gargv > maxargv) maxargv = gargv;
  318. 			haveprec = 1;
  319. 			*dptr++ = '*';
  320. 			*dptr = 0;
  321. 		}
  322. 		else
  323. 		{
  324. 			haveprec = 0;
  326. 			/* skip to conversion char */
  327. 			while(isdigit(*fmt))
  328. 			{
  329. 				*dptr++ = *fmt++;
  330. 				*dptr = 0;
  331. 			}
  332. 		}
  333. 	}
  334. 	else
  335. 		haveprec = 0;
  336. 	if(!*fmt)
  337. 	{
  338. 		utils_warnx("missing format character");
  339. 		return (NULL);
  340. 	}
  341. 	*dptr++ = *fmt;
  342. 	*dptr = 0;
  344. 	/*
  345. 	 * Look for a length modifier.  POSIX doesn't have these, so
  346. 	 * we only support them for floating-point conversions, which
  347. 	 * are extensions.  This is useful because the L modifier can
  348. 	 * be used to gain extra range and precision, while omitting
  349. 	 * it is more likely to produce consistent results on different
  350. 	 * architectures.  This is not so important for integers
  351. 	 * because overflow is the only bad thing that can happen to
  352. 	 * them, but consider the command  printf %a 1.1
  353. 	 */
  354. 	if(*fmt == 'L')
  355. 	{
  356. 		mod_ldbl = 1;
  357. 		fmt++;
  358. 		if(!strchr("aAeEfFgG", *fmt))
  359. 		{
  360. 			utils_warnx("bad modifier L for %%%c", *fmt);
  361. 			return (NULL);
  362. 		}
  363. 	}
  364. 	else
  365. 	{
  366. 		mod_ldbl = 0;
  367. 	}
  369. 	/* save the current arg offset, and set to the format arg */
  370. 	if(fargv != NULL)
  371. 	{
  372. 		gargv = fargv;
  373. 	}
  375. 	convch = *fmt;
  376. 	nextch = *++fmt;
  378. 	*fmt = '\0';
  379. 	switch(convch)
  380. 	{
  381. 	case 'b':
  382. 	{
  383. 		size_t len;
  384. 		char *p;
  385. 		int getout;
  387. 		/* Convert "b" to "s" for output. */
  388. 		start[strlen(start) - 1] = 's';
  389. 		if((p = strdup(getstr())) == NULL)
  390. 		{
  391. 			utils_warnx("%s", strerror(ENOMEM));
  392. 			return (NULL);
  393. 		}
  394. 		getout = escape(p, 0, &len);
  395. 		PF(start, p);
  396. 		/* Restore format for next loop. */
  398. 		free(p);
  399. 		if(getout) return (end_fmt);
  400. 		break;
  401. 	}
  402. 	case 'c':
  403. 	{
  404. 		char p;
  406. 		p = getchr();
  407. 		if(p != '\0') PF(start, p);
  408. 		break;
  409. 	}
  410. 	case 's':
  411. 	{
  412. 		const char *p;
  414. 		p = getstr();
  415. 		PF(start, p);
  416. 		break;
  417. 	}
  418. 	case 'd':
  419. 	case 'i':
  420. 	case 'o':
  421. 	case 'u':
  422. 	case 'x':
  423. 	case 'X':
  424. 	{
  425. 		char *f;
  426. 		intmax_t val;
  427. 		uintmax_t uval;
  428. 		int signedconv;
  430. 		signedconv = (convch == 'd' || convch == 'i');
  431. 		if((f = mknum(start, convch)) == NULL) return (NULL);
  432. 		if(getnum(&val, &uval, signedconv)) *rval = 1;
  433. 		if(signedconv)
  434. 			PF(f, val);
  435. 		else
  436. 			PF(f, uval);
  437. 		break;
  438. 	}
  439. 	case 'e':
  440. 	case 'E':
  441. 	case 'f':
  442. 	case 'F':
  443. 	case 'g':
  444. 	case 'G':
  445. 	case 'a':
  446. 	case 'A':
  447. 	{
  448. 		long double p;
  450. 		if(getfloating(&p, mod_ldbl)) *rval = 1;
  451. 		if(mod_ldbl)
  452. 			PF(start, p);
  453. 		else
  454. 			PF(start, (double)p);
  455. 		break;
  456. 	}
  457. 	default:
  458. 		utils_warnx("illegal format character %c", convch);
  459. 		return (NULL);
  460. 	}
  461. 	*fmt = nextch;
  462. 	/* return the gargv to the next element */
  463. 	return (fmt);
  464. }
  466. static char *
  467. mknum(char *str, char ch)
  468. {
  469. 	static char *copy;
  470. 	static size_t copy_size;
  471. 	char *newcopy;
  472. 	size_t len, newlen;
  474. 	len = strlen(str) + 2;
  475. 	if(len > copy_size)
  476. 	{
  477. 		newlen = len + 1023;
  478. 		assert(newlen != 0);
  479. 		if((newcopy = realloc(copy, newlen)) == NULL)
  480. 		{
  481. 			utils_warnx("%s", strerror(ENOMEM));
  482. 			return (NULL);
  483. 		}
  484. 		copy = newcopy;
  485. 		copy_size = newlen;
  486. 	}
  488. 	memmove(copy, str, len - 3);
  489. 	copy[len - 3] = 'j';
  490. 	copy[len - 2] = ch;
  491. 	copy[len - 1] = '\0';
  492. 	return (copy);
  493. }
  495. static int
  496. escape(char *fmt, int percent, size_t *len)
  497. {
  498. 	char *save, *store, c;
  499. 	int value;
  501. 	for(save = store = fmt; ((c = *fmt) != 0); ++fmt, ++store)
  502. 	{
  503. 		if(c != '\\')
  504. 		{
  505. 			*store = c;
  506. 			continue;
  507. 		}
  508. 		switch(*++fmt)
  509. 		{
  510. 		case '\0': /* EOS, user error */
  511. 			*store = '\\';
  512. 			*++store = '\0';
  513. 			*len = store - save;
  514. 			return (0);
  515. 		case '\\': /* backslash */
  516. 		case '\'': /* single quote */
  517. 			*store = *fmt;
  518. 			break;
  519. 		case 'a': /* bell/alert */
  520. 			*store = '\a';
  521. 			break;
  522. 		case 'b': /* backspace */
  523. 			*store = '\b';
  524. 			break;
  525. 		case 'c':
  526. 			if(!percent)
  527. 			{
  528. 				*store = '\0';
  529. 				*len = store - save;
  530. 				return (1);
  531. 			}
  532. 			*store = 'c';
  533. 			break;
  534. 		case 'f': /* form-feed */
  535. 			*store = '\f';
  536. 			break;
  537. 		case 'n': /* newline */
  538. 			*store = '\n';
  539. 			break;
  540. 		case 'r': /* carriage-return */
  541. 			*store = '\r';
  542. 			break;
  543. 		case 't': /* horizontal tab */
  544. 			*store = '\t';
  545. 			break;
  546. 		case 'v': /* vertical tab */
  547. 			*store = '\v';
  548. 			break;
  549. 			/* octal constant */
  550. 		case 'x': /* hex */
  551. 			c = 2;
  552. 			fmt++;
  553. 			for(value = 0; c-- && isxdigit(*fmt); ++fmt)
  554. 			{
  555. 				value <<= 4;
  556. 				if(*fmt <= '9')
  557. 					value += *fmt - '0';
  558. 				else if(*fmt <= 'F')
  559. 					value += *fmt - 'A' + 10;
  560. 				else
  561. 					value += *fmt - 'a' + 10;
  562. 			}
  563. 			--fmt;
  564. 			*store = (char)value;
  565. 			break;
  566. 		case '0':
  567. 		case '1':
  568. 		case '2':
  569. 		case '3':
  570. 		case '4':
  571. 		case '5':
  572. 		case '6':
  573. 		case '7':
  574. 			c = (!percent && *fmt == '0') ? 4 : 3;
  575. 			for(value = 0; c-- && *fmt >= '0' && *fmt <= '7'; ++fmt)
  576. 			{
  577. 				value <<= 3;
  578. 				value += *fmt - '0';
  579. 			}
  580. 			--fmt;
  581. 			if(percent && value == '%')
  582. 			{
  583. 				*store++ = '%';
  584. 				*store = '%';
  585. 			}
  586. 			else
  587. 				*store = (char)value;
  588. 			break;
  589. 		default:
  590. 			*store = *fmt;
  591. 			break;
  592. 		}
  593. 	}
  594. 	*store = '\0';
  595. 	*len = store - save;
  596. 	return (0);
  597. }
  599. static int
  600. getchr(void)
  601. {
  602. 	if(!gargv || !*gargv) return ('\0');
  603. 	return ((int)**gargv++);
  604. }
  606. static const char *
  607. getstr(void)
  608. {
  609. 	if(!gargv || !*gargv) return ("");
  610. 	return (*gargv++);
  611. }
  613. static int
  614. getint(int *ip)
  615. {
  616. 	intmax_t val;
  617. 	uintmax_t uval;
  618. 	int rval;
  620. 	if(getnum(&val, &uval, 1)) return (1);
  621. 	rval = 0;
  622. 	if(val < INT_MIN || val > INT_MAX)
  623. 	{
  624. 		utils_warnx("%s: %s", *gargv, strerror(ERANGE));
  625. 		rval = 1;
  626. 	}
  627. 	*ip = (int)val;
  628. 	return (rval);
  629. }
  631. static int
  632. getnum(intmax_t *ip, uintmax_t *uip, int signedconv)
  633. {
  634. 	char *ep;
  635. 	int rval;
  637. 	if(!gargv || !*gargv)
  638. 	{
  639. 		*ip = *uip = 0;
  640. 		return (0);
  641. 	}
  642. 	if(**gargv == '"' || **gargv == '\'')
  643. 	{
  644. 		if(signedconv)
  645. 			*ip = asciicode();
  646. 		else
  647. 			*uip = asciicode();
  648. 		return (0);
  649. 	}
  650. 	rval = 0;
  651. 	errno = 0;
  652. 	if(signedconv)
  653. 		*ip = strtoimax(*gargv, &ep, 0);
  654. 	else
  655. 		*uip = strtoumax(*gargv, &ep, 0);
  656. 	if(ep == *gargv)
  657. 	{
  658. 		utils_warnx("%s: expected numeric value", *gargv);
  659. 		rval = 1;
  660. 	}
  661. 	else if(*ep != '\0')
  662. 	{
  663. 		utils_warnx("%s: not completely converted", *gargv);
  664. 		rval = 1;
  665. 	}
  666. 	if(errno == ERANGE)
  667. 	{
  668. 		utils_warnx("%s: %s", *gargv, strerror(ERANGE));
  669. 		rval = 1;
  670. 	}
  671. 	++gargv;
  672. 	return (rval);
  673. }
  675. static int
  676. getfloating(long double *dp, int mod_ldbl)
  677. {
  678. 	char *ep;
  679. 	int rval;
  681. 	if(!*gargv)
  682. 	{
  683. 		*dp = 0.0;
  684. 		return (0);
  685. 	}
  686. 	if(**gargv == '"' || **gargv == '\'')
  687. 	{
  688. 		*dp = asciicode();
  689. 		return (0);
  690. 	}
  691. 	rval = 0;
  692. 	errno = 0;
  693. 	if(mod_ldbl)
  694. 		*dp = strtold(*gargv, &ep);
  695. 	else
  696. 		*dp = strtod(*gargv, &ep);
  697. 	if(ep == *gargv)
  698. 	{
  699. 		utils_warnx("%s: expected numeric value", *gargv);
  700. 		rval = 1;
  701. 	}
  702. 	else if(*ep != '\0')
  703. 	{
  704. 		utils_warnx("%s: not completely converted", *gargv);
  705. 		rval = 1;
  706. 	}
  707. 	if(errno == ERANGE)
  708. 	{
  709. 		utils_warnx("%s: %s", *gargv, strerror(ERANGE));
  710. 		rval = 1;
  711. 	}
  712. 	++gargv;
  713. 	return (rval);
  714. }
  716. static int
  717. asciicode(void)
  718. {
  719. 	int ch;
  720. 	wchar_t wch;
  721. 	mbstate_t mbs;
  723. 	ch = (unsigned char)**gargv;
  724. 	if(ch == '\'' || ch == '"')
  725. 	{
  726. 		memset(&mbs, 0, sizeof(mbs));
  727. 		switch(mbrtowc(&wch, *gargv + 1, MB_LEN_MAX, &mbs))
  728. 		{
  729. 		case(size_t)-2:
  730. 		case(size_t)-1:
  731. 			wch = (unsigned char)gargv[0][1];
  732. 			break;
  733. 		case 0:
  734. 			wch = 0;
  735. 			break;
  736. 		}
  737. 		ch = wch;
  738. 	}
  739. 	++gargv;
  740. 	return (ch);
  741. }
  743. static void
  744. usage(void)
  745. {
  746. 	(void)fprintf(stderr, "usage: printf format [arguments ...]\n");
  747. }