logo

utils-std

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

printf.c (15007B)

    

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