logo

utils-std

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

printf.c (14691B)

    

  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;
  99. 	(void)setlocale(LC_ALL, "");
  101. 	for(int c = -1; (c = getopt(argc, argv, "")) != -1;)
  102. 	{
  103. 		switch(c)
  104. 		{
  105. 		case '?':
  106. 		default:
  107. 			usage();
  108. 			return (1);
  109. 		}
  110. 	}
  112. 	argc -= optind;
  113. 	argv += optind;
  115. 	if(argc < 1)
  116. 	{
  117. 		usage();
  118. 		return (1);
  119. 	}
  121. 	/*
  122. 	 * Basic algorithm is to scan the format string for conversion
  123. 	 * specifications -- once one is found, find out if the field
  124. 	 * width or precision is a '*'; if it is, gather up value.  Note,
  125. 	 * format strings are reused as necessary to use up the provided
  126. 	 * arguments, arguments of zero/null string are provided to use
  127. 	 * up the format string.
  128. 	 */
  129. 	fmt = format = *argv;
  130. 	escape(fmt, 1, &len); /* backslash interpretation */
  131. 	rval = end = 0;
  132. 	gargv = ++argv;
  134. 	for(;;)
  135. 	{
  136. 		maxargv = gargv;
  138. 		myargv = gargv;
  139. 		for(myargc = 0; gargv[myargc]; myargc++)
  140. 			/* nop */;
  141. 		start = fmt;
  142. 		while(fmt < format + len)
  143. 		{
  144. 			if(fmt[0] == '%')
  145. 			{
  146. 				fwrite(start, 1, fmt - start, stdout);
  147. 				if(fmt[1] == '%')
  148. 				{
  149. 					/* %% prints a % */
  150. 					putchar('%');
  151. 					fmt += 2;
  152. 				}
  153. 				else
  154. 				{
  155. 					fmt = printf_doformat(fmt, &rval);
  156. 					if(fmt == NULL || fmt == end_fmt)
  157. 					{
  158. 						return (fmt == NULL ? 1 : rval);
  159. 					}
  160. 					end = 0;
  161. 				}
  162. 				start = fmt;
  163. 			}
  164. 			else
  165. 				fmt++;
  166. 			if(gargv > maxargv) maxargv = gargv;
  167. 		}
  168. 		gargv = maxargv;
  170. 		if(end == 1)
  171. 		{
  172. 			utils_warnx("missing format character");
  173. 			return (1);
  174. 		}
  175. 		fwrite(start, 1, fmt - start, stdout);
  176. 		if(!*gargv)
  177. 		{
  178. 			return (rval);
  179. 		}
  180. 		/* Restart at the beginning of the format string. */
  181. 		fmt = format;
  182. 		end = 1;
  183. 	}
  184. 	/* NOTREACHED */
  185. }
  187. static char *
  188. printf_doformat(char *fmt, int *rval)
  189. {
  190. 	static const char skip1[] = "#'-+ 0";
  191. 	int fieldwidth, haveprec, havewidth, mod_ldbl, precision;
  192. 	char convch, nextch;
  193. 	char start[strlen(fmt) + 1];
  194. 	char **fargv;
  195. 	char *dptr;
  196. 	int l;
  198. 	dptr = start;
  199. 	*dptr++ = '%';
  200. 	*dptr = 0;
  202. 	fmt++;
  204. 	/* look for "n$" field index specifier */
  205. 	l = strspn(fmt, digits);
  206. 	if((l > 0) && (fmt[l] == '$'))
  207. 	{
  208. 		int idx = atoi(fmt);
  209. 		if(idx <= myargc)
  210. 		{
  211. 			gargv = &myargv[idx - 1];
  212. 		}
  213. 		else
  214. 		{
  215. 			gargv = &myargv[myargc];
  216. 		}
  217. 		if(gargv > maxargv) maxargv = gargv;
  218. 		fmt += l + 1;
  220. 		/* save format argument */
  221. 		fargv = gargv;
  222. 	}
  223. 	else
  224. 	{
  225. 		fargv = NULL;
  226. 	}
  228. 	/* skip to field width */
  229. 	while(*fmt && strchr(skip1, *fmt) != NULL)
  230. 	{
  231. 		*dptr++ = *fmt++;
  232. 		*dptr = 0;
  233. 	}
  235. 	if(*fmt == '*')
  236. 	{
  238. 		fmt++;
  239. 		l = strspn(fmt, digits);
  240. 		if((l > 0) && (fmt[l] == '$'))
  241. 		{
  242. 			int idx = atoi(fmt);
  243. 			if(fargv == NULL)
  244. 			{
  245. 				utils_warnx("incomplete use of n$");
  246. 				return (NULL);
  247. 			}
  248. 			if(idx <= myargc)
  249. 			{
  250. 				gargv = &myargv[idx - 1];
  251. 			}
  252. 			else
  253. 			{
  254. 				gargv = &myargv[myargc];
  255. 			}
  256. 			fmt += l + 1;
  257. 		}
  258. 		else if(fargv != NULL)
  259. 		{
  260. 			utils_warnx("incomplete use of n$");
  261. 			return (NULL);
  262. 		}
  264. 		if(getint(&fieldwidth)) return (NULL);
  265. 		if(gargv > maxargv) maxargv = gargv;
  266. 		havewidth = 1;
  268. 		*dptr++ = '*';
  269. 		*dptr = 0;
  270. 	}
  271. 	else
  272. 	{
  273. 		havewidth = 0;
  275. 		/* skip to possible '.', get following precision */
  276. 		while(isdigit(*fmt))
  277. 		{
  278. 			*dptr++ = *fmt++;
  279. 			*dptr = 0;
  280. 		}
  281. 	}
  283. 	if(*fmt == '.')
  284. 	{
  285. 		/* precision present? */
  286. 		fmt++;
  287. 		*dptr++ = '.';
  289. 		if(*fmt == '*')
  290. 		{
  292. 			fmt++;
  293. 			l = strspn(fmt, digits);
  294. 			if((l > 0) && (fmt[l] == '$'))
  295. 			{
  296. 				int idx = atoi(fmt);
  297. 				if(fargv == NULL)
  298. 				{
  299. 					utils_warnx("incomplete use of n$");
  300. 					return (NULL);
  301. 				}
  302. 				if(idx <= myargc)
  303. 				{
  304. 					gargv = &myargv[idx - 1];
  305. 				}
  306. 				else
  307. 				{
  308. 					gargv = &myargv[myargc];
  309. 				}
  310. 				fmt += l + 1;
  311. 			}
  312. 			else if(fargv != NULL)
  313. 			{
  314. 				utils_warnx("incomplete use of n$");
  315. 				return (NULL);
  316. 			}
  318. 			if(getint(&precision)) return (NULL);
  319. 			if(gargv > maxargv) maxargv = gargv;
  320. 			haveprec = 1;
  321. 			*dptr++ = '*';
  322. 			*dptr = 0;
  323. 		}
  324. 		else
  325. 		{
  326. 			haveprec = 0;
  328. 			/* skip to conversion char */
  329. 			while(isdigit(*fmt))
  330. 			{
  331. 				*dptr++ = *fmt++;
  332. 				*dptr = 0;
  333. 			}
  334. 		}
  335. 	}
  336. 	else
  337. 		haveprec = 0;
  338. 	if(!*fmt)
  339. 	{
  340. 		utils_warnx("missing format character");
  341. 		return (NULL);
  342. 	}
  343. 	*dptr++ = *fmt;
  344. 	*dptr = 0;
  346. 	/*
  347. 	 * Look for a length modifier.  POSIX doesn't have these, so
  348. 	 * we only support them for floating-point conversions, which
  349. 	 * are extensions.  This is useful because the L modifier can
  350. 	 * be used to gain extra range and precision, while omitting
  351. 	 * it is more likely to produce consistent results on different
  352. 	 * architectures.  This is not so important for integers
  353. 	 * because overflow is the only bad thing that can happen to
  354. 	 * them, but consider the command  printf %a 1.1
  355. 	 */
  356. 	if(*fmt == 'L')
  357. 	{
  358. 		mod_ldbl = 1;
  359. 		fmt++;
  360. 		if(!strchr("aAeEfFgG", *fmt))
  361. 		{
  362. 			utils_warnx("bad modifier L for %%%c", *fmt);
  363. 			return (NULL);
  364. 		}
  365. 	}
  366. 	else
  367. 	{
  368. 		mod_ldbl = 0;
  369. 	}
  371. 	/* save the current arg offset, and set to the format arg */
  372. 	if(fargv != NULL)
  373. 	{
  374. 		gargv = fargv;
  375. 	}
  377. 	convch = *fmt;
  378. 	nextch = *++fmt;
  380. 	*fmt = '\0';
  381. 	switch(convch)
  382. 	{
  383. 	case 'b':
  384. 	{
  385. 		size_t len;
  386. 		char *p;
  387. 		int getout;
  389. 		/* Convert "b" to "s" for output. */
  390. 		start[strlen(start) - 1] = 's';
  391. 		if((p = strdup(getstr())) == NULL)
  392. 		{
  393. 			utils_warnx("%s", strerror(ENOMEM));
  394. 			return (NULL);
  395. 		}
  396. 		getout = escape(p, 0, &len);
  397. 		PF(start, p);
  398. 		/* Restore format for next loop. */
  400. 		free(p);
  401. 		if(getout) return (end_fmt);
  402. 		break;
  403. 	}
  404. 	case 'c':
  405. 	{
  406. 		char p;
  408. 		p = getchr();
  409. 		if(p != '\0') PF(start, p);
  410. 		break;
  411. 	}
  412. 	case 's':
  413. 	{
  414. 		const char *p;
  416. 		p = getstr();
  417. 		PF(start, p);
  418. 		break;
  419. 	}
  420. 	case 'd':
  421. 	case 'i':
  422. 	case 'o':
  423. 	case 'u':
  424. 	case 'x':
  425. 	case 'X':
  426. 	{
  427. 		char *f;
  428. 		intmax_t val;
  429. 		uintmax_t uval;
  430. 		int signedconv;
  432. 		signedconv = (convch == 'd' || convch == 'i');
  433. 		if((f = mknum(start, convch)) == NULL) return (NULL);
  434. 		if(getnum(&val, &uval, signedconv)) *rval = 1;
  435. 		if(signedconv)
  436. 			PF(f, val);
  437. 		else
  438. 			PF(f, uval);
  439. 		break;
  440. 	}
  441. 	case 'e':
  442. 	case 'E':
  443. 	case 'f':
  444. 	case 'F':
  445. 	case 'g':
  446. 	case 'G':
  447. 	case 'a':
  448. 	case 'A':
  449. 	{
  450. 		long double p;
  452. 		if(getfloating(&p, mod_ldbl)) *rval = 1;
  453. 		if(mod_ldbl)
  454. 			PF(start, p);
  455. 		else
  456. 			PF(start, (double)p);
  457. 		break;
  458. 	}
  459. 	default:
  460. 		utils_warnx("illegal format character '%c'", convch);
  461. 		return (NULL);
  462. 	}
  463. 	*fmt = nextch;
  464. 	/* return the gargv to the next element */
  465. 	return (fmt);
  466. }
  468. static char *
  469. mknum(char *str, char ch)
  470. {
  471. 	static char *copy;
  472. 	static size_t copy_size;
  473. 	char *newcopy;
  474. 	size_t len, newlen;
  476. 	len = strlen(str) + 2;
  477. 	if(len > copy_size)
  478. 	{
  479. 		newlen = len + 1023;
  480. 		assert(newlen != 0);
  481. 		if((newcopy = realloc(copy, newlen)) == NULL)
  482. 		{
  483. 			utils_warnx("%s", strerror(ENOMEM));
  484. 			return (NULL);
  485. 		}
  486. 		copy = newcopy;
  487. 		copy_size = newlen;
  488. 	}
  490. 	memmove(copy, str, len - 3);
  491. 	copy[len - 3] = 'j';
  492. 	copy[len - 2] = ch;
  493. 	copy[len - 1] = '\0';
  494. 	return (copy);
  495. }
  497. static int
  498. escape(char *fmt, int percent, size_t *len)
  499. {
  500. 	char *save, *store, c;
  501. 	int value;
  503. 	for(save = store = fmt; ((c = *fmt) != 0); ++fmt, ++store)
  504. 	{
  505. 		if(c != '\\')
  506. 		{
  507. 			*store = c;
  508. 			continue;
  509. 		}
  510. 		switch(*++fmt)
  511. 		{
  512. 		case '\0': /* EOS, user error */
  513. 			*store = '\\';
  514. 			*++store = '\0';
  515. 			*len = store - save;
  516. 			return (0);
  517. 		case '\\': /* backslash */
  518. 		case '\'': /* single quote */
  519. 			*store = *fmt;
  520. 			break;
  521. 		case 'a': /* bell/alert */
  522. 			*store = '\a';
  523. 			break;
  524. 		case 'b': /* backspace */
  525. 			*store = '\b';
  526. 			break;
  527. 		case 'c':
  528. 			if(!percent)
  529. 			{
  530. 				*store = '\0';
  531. 				*len = store - save;
  532. 				return (1);
  533. 			}
  534. 			*store = 'c';
  535. 			break;
  536. 		case 'f': /* form-feed */
  537. 			*store = '\f';
  538. 			break;
  539. 		case 'n': /* newline */
  540. 			*store = '\n';
  541. 			break;
  542. 		case 'r': /* carriage-return */
  543. 			*store = '\r';
  544. 			break;
  545. 		case 't': /* horizontal tab */
  546. 			*store = '\t';
  547. 			break;
  548. 		case 'v': /* vertical tab */
  549. 			*store = '\v';
  550. 			break;
  551. 			/* octal constant */
  552. 		case 'x': /* hex */
  553. 			c = 2;
  554. 			fmt++;
  555. 			for(value = 0; c-- && isxdigit(*fmt); ++fmt)
  556. 			{
  557. 				value <<= 4;
  558. 				if(*fmt <= '9')
  559. 					value += *fmt - '0';
  560. 				else if(*fmt <= 'F')
  561. 					value += *fmt - 'A' + 10;
  562. 				else
  563. 					value += *fmt - 'a' + 10;
  564. 			}
  565. 			--fmt;
  566. 			*store = (char)value;
  567. 			break;
  568. 		case '0':
  569. 		case '1':
  570. 		case '2':
  571. 		case '3':
  572. 		case '4':
  573. 		case '5':
  574. 		case '6':
  575. 		case '7':
  576. 			c = (!percent && *fmt == '0') ? 4 : 3;
  577. 			for(value = 0; c-- && *fmt >= '0' && *fmt <= '7'; ++fmt)
  578. 			{
  579. 				value <<= 3;
  580. 				value += *fmt - '0';
  581. 			}
  582. 			--fmt;
  583. 			if(percent && value == '%')
  584. 			{
  585. 				*store++ = '%';
  586. 				*store = '%';
  587. 			}
  588. 			else
  589. 				*store = (char)value;
  590. 			break;
  591. 		default:
  592. 			*store = *fmt;
  593. 			break;
  594. 		}
  595. 	}
  596. 	*store = '\0';
  597. 	*len = store - save;
  598. 	return (0);
  599. }
  601. static int
  602. getchr(void)
  603. {
  604. 	if(!gargv || !*gargv) return ('\0');
  605. 	return ((int)**gargv++);
  606. }
  608. static const char *
  609. getstr(void)
  610. {
  611. 	if(!gargv || !*gargv) return ("");
  612. 	return (*gargv++);
  613. }
  615. static int
  616. getint(int *ip)
  617. {
  618. 	intmax_t val;
  619. 	uintmax_t uval;
  620. 	int rval;
  622. 	if(getnum(&val, &uval, 1)) return (1);
  623. 	rval = 0;
  624. 	if(val < INT_MIN || val > INT_MAX)
  625. 	{
  626. 		utils_warnx("%s: %s", *gargv, strerror(ERANGE));
  627. 		rval = 1;
  628. 	}
  629. 	*ip = (int)val;
  630. 	return (rval);
  631. }
  633. static int
  634. getnum(intmax_t *ip, uintmax_t *uip, int signedconv)
  635. {
  636. 	char *ep;
  637. 	int rval;
  639. 	if(!gargv || !*gargv)
  640. 	{
  641. 		*ip = *uip = 0;
  642. 		return (0);
  643. 	}
  644. 	if(**gargv == '"' || **gargv == '\'')
  645. 	{
  646. 		if(signedconv)
  647. 			*ip = asciicode();
  648. 		else
  649. 			*uip = asciicode();
  650. 		return (0);
  651. 	}
  652. 	rval = 0;
  653. 	errno = 0;
  654. 	if(signedconv)
  655. 		*ip = strtoimax(*gargv, &ep, 0);
  656. 	else
  657. 		*uip = strtoumax(*gargv, &ep, 0);
  658. 	if(ep == *gargv)
  659. 	{
  660. 		utils_warnx("%s: expected numeric value", *gargv);
  661. 		rval = 1;
  662. 	}
  663. 	else if(*ep != '\0')
  664. 	{
  665. 		utils_warnx("%s: not completely converted", *gargv);
  666. 		rval = 1;
  667. 	}
  668. 	if(errno == ERANGE)
  669. 	{
  670. 		utils_warnx("%s: %s", *gargv, strerror(ERANGE));
  671. 		rval = 1;
  672. 	}
  673. 	++gargv;
  674. 	return (rval);
  675. }
  677. static int
  678. getfloating(long double *dp, int mod_ldbl)
  679. {
  680. 	char *ep;
  681. 	int rval;
  683. 	if(!*gargv)
  684. 	{
  685. 		*dp = 0.0;
  686. 		return (0);
  687. 	}
  688. 	if(**gargv == '"' || **gargv == '\'')
  689. 	{
  690. 		*dp = asciicode();
  691. 		return (0);
  692. 	}
  693. 	rval = 0;
  694. 	errno = 0;
  695. 	if(mod_ldbl)
  696. 		*dp = strtold(*gargv, &ep);
  697. 	else
  698. 		*dp = strtod(*gargv, &ep);
  699. 	if(ep == *gargv)
  700. 	{
  701. 		utils_warnx("%s: expected numeric value", *gargv);
  702. 		rval = 1;
  703. 	}
  704. 	else if(*ep != '\0')
  705. 	{
  706. 		utils_warnx("%s: not completely converted", *gargv);
  707. 		rval = 1;
  708. 	}
  709. 	if(errno == ERANGE)
  710. 	{
  711. 		utils_warnx("%s: %s", *gargv, strerror(ERANGE));
  712. 		rval = 1;
  713. 	}
  714. 	++gargv;
  715. 	return (rval);
  716. }
  718. static int
  719. asciicode(void)
  720. {
  721. 	int ch;
  722. 	wchar_t wch;
  723. 	mbstate_t mbs;
  725. 	ch = (unsigned char)**gargv;
  726. 	if(ch == '\'' || ch == '"')
  727. 	{
  728. 		memset(&mbs, 0, sizeof(mbs));
  729. 		switch(mbrtowc(&wch, *gargv + 1, MB_LEN_MAX, &mbs))
  730. 		{
  731. 		case(size_t)-2:
  732. 		case(size_t)-1:
  733. 			wch = (unsigned char)gargv[0][1];
  734. 			break;
  735. 		case 0:
  736. 			wch = 0;
  737. 			break;
  738. 		}
  739. 		ch = wch;
  740. 	}
  741. 	++gargv;
  742. 	return (ch);
  743. }
  745. static void
  746. usage(void)
  747. {
  748. 	(void)fprintf(stderr, "usage: printf format [arguments ...]\n");
  749. }