logo

utils-std

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

printf.c (14827B)

    

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