logo

utils-std

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

printf.c (15571B)

    

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