1da2e3ebdSchin /***********************************************************************
2da2e3ebdSchin *                                                                      *
3da2e3ebdSchin *               This software is part of the ast package               *
4b30d1939SAndy Fiddaman *          Copyright (c) 1982-2012 AT&T Intellectual Property          *
5da2e3ebdSchin *                      and is licensed under the                       *
6b30d1939SAndy Fiddaman *                 Eclipse Public License, Version 1.0                  *
77c2fbfb3SApril Chin *                    by AT&T Intellectual Property                     *
8da2e3ebdSchin *                                                                      *
9da2e3ebdSchin *                A copy of the License is available at                 *
10b30d1939SAndy Fiddaman *          http://www.eclipse.org/org/documents/epl-v10.html           *
11b30d1939SAndy Fiddaman *         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *
12da2e3ebdSchin *                                                                      *
13da2e3ebdSchin *              Information and Software Systems Research               *
14da2e3ebdSchin *                            AT&T Research                             *
15da2e3ebdSchin *                           Florham Park NJ                            *
16da2e3ebdSchin *                                                                      *
17da2e3ebdSchin *                  David Korn <dgk@research.att.com>                   *
18da2e3ebdSchin *                                                                      *
19da2e3ebdSchin ***********************************************************************/
20da2e3ebdSchin #pragma prototyped
21da2e3ebdSchin /*
22da2e3ebdSchin  * echo [arg...]
23da2e3ebdSchin  * print [-nrps] [-f format] [-u filenum] [arg...]
24*89af4c7bSAndy Fiddaman  * printf [--] format [arg...]
25da2e3ebdSchin  *
26da2e3ebdSchin  *   David Korn
27da2e3ebdSchin  *   AT&T Labs
28da2e3ebdSchin  */
29da2e3ebdSchin 
30da2e3ebdSchin #include	"defs.h"
31da2e3ebdSchin #include	<error.h>
32da2e3ebdSchin #include	<stak.h>
33da2e3ebdSchin #include	"io.h"
34da2e3ebdSchin #include	"name.h"
35da2e3ebdSchin #include	"history.h"
36da2e3ebdSchin #include	"builtins.h"
37da2e3ebdSchin #include	"streval.h"
38da2e3ebdSchin #include	<tmx.h>
39da2e3ebdSchin #include	<ccode.h>
40da2e3ebdSchin 
41da2e3ebdSchin union types_t
42da2e3ebdSchin {
43da2e3ebdSchin 	unsigned char	c;
44da2e3ebdSchin 	short		h;
45da2e3ebdSchin 	int		i;
46da2e3ebdSchin 	long		l;
47da2e3ebdSchin 	Sflong_t	ll;
48da2e3ebdSchin 	Sfdouble_t	ld;
49da2e3ebdSchin 	double		d;
50da2e3ebdSchin 	float		f;
51da2e3ebdSchin 	char		*s;
52da2e3ebdSchin 	int		*ip;
53da2e3ebdSchin 	char		**p;
54da2e3ebdSchin };
55da2e3ebdSchin 
56da2e3ebdSchin struct printf
57da2e3ebdSchin {
58da2e3ebdSchin 	Sffmt_t		hdr;
59da2e3ebdSchin 	int		argsize;
60da2e3ebdSchin 	int		intvar;
61da2e3ebdSchin 	char		**nextarg;
627c2fbfb3SApril Chin 	char		*lastarg;
63da2e3ebdSchin 	char		cescape;
64da2e3ebdSchin 	char		err;
65da2e3ebdSchin 	Shell_t		*sh;
66da2e3ebdSchin };
67da2e3ebdSchin 
68b30d1939SAndy Fiddaman struct printmap
69b30d1939SAndy Fiddaman {
70b30d1939SAndy Fiddaman 	size_t		size;
71b30d1939SAndy Fiddaman 	char		*name;
72b30d1939SAndy Fiddaman 	char		map[3];
73b30d1939SAndy Fiddaman 	const char	*description;
74b30d1939SAndy Fiddaman };
75b30d1939SAndy Fiddaman 
76b30d1939SAndy Fiddaman const struct printmap  Pmap[] =
77b30d1939SAndy Fiddaman {
78b30d1939SAndy Fiddaman 	3,	"csv",	"q+",	"Equivalent to %#q",
79b30d1939SAndy Fiddaman 	4,	"html",	"H",	"Equivalent to %H",
80b30d1939SAndy Fiddaman 	3,	"ere",	"R",	"Equivalent to %R",
81b30d1939SAndy Fiddaman 	7,	"pattern","P",	"Equivalent to %#P",
82b30d1939SAndy Fiddaman 	3,	"url",	"H+",	"Equivalent to %#H",
83b30d1939SAndy Fiddaman 	0,	0,	0,
84b30d1939SAndy Fiddaman };
85b30d1939SAndy Fiddaman 
86b30d1939SAndy Fiddaman 
87da2e3ebdSchin static int		extend(Sfio_t*,void*, Sffmt_t*);
88da2e3ebdSchin static const char   	preformat[] = "";
89da2e3ebdSchin static char		*genformat(char*);
90da2e3ebdSchin static int		fmtvecho(const char*, struct printf*);
917c2fbfb3SApril Chin static ssize_t		fmtbase64(Sfio_t*, char*, int);
92da2e3ebdSchin 
93da2e3ebdSchin struct print
94da2e3ebdSchin {
95da2e3ebdSchin 	Shell_t         *sh;
96da2e3ebdSchin 	const char	*options;
97da2e3ebdSchin 	char		raw;
98da2e3ebdSchin 	char		echon;
99da2e3ebdSchin };
100da2e3ebdSchin 
101da2e3ebdSchin static char* 	nullarg[] = { 0, 0 };
102da2e3ebdSchin 
103da2e3ebdSchin #if !SHOPT_ECHOPRINT
B_echo(int argc,char * argv[],Shbltin_t * context)104b30d1939SAndy Fiddaman    int    B_echo(int argc, char *argv[],Shbltin_t *context)
105da2e3ebdSchin    {
106da2e3ebdSchin 	static char bsd_univ;
107da2e3ebdSchin 	struct print prdata;
108da2e3ebdSchin 	prdata.options = sh_optecho+5;
109da2e3ebdSchin 	prdata.raw = prdata.echon = 0;
110b30d1939SAndy Fiddaman 	prdata.sh = context->shp;
111da2e3ebdSchin 	NOT_USED(argc);
112da2e3ebdSchin 	/* This mess is because /bin/echo on BSD is different */
113da2e3ebdSchin 	if(!prdata.sh->universe)
114da2e3ebdSchin 	{
115da2e3ebdSchin 		register char *universe;
116da2e3ebdSchin 		if(universe=astconf("UNIVERSE",0,0))
117da2e3ebdSchin 			bsd_univ = (strcmp(universe,"ucb")==0);
118da2e3ebdSchin 		prdata.sh->universe = 1;
119da2e3ebdSchin 	}
120da2e3ebdSchin 	if(!bsd_univ)
121b30d1939SAndy Fiddaman 		return(b_print(0,argv,(Shbltin_t*)&prdata));
122da2e3ebdSchin 	prdata.options = sh_optecho;
123da2e3ebdSchin 	prdata.raw = 1;
124da2e3ebdSchin 	while(argv[1] && *argv[1]=='-')
125da2e3ebdSchin 	{
126da2e3ebdSchin 		if(strcmp(argv[1],"-n")==0)
127da2e3ebdSchin 			prdata.echon = 1;
128da2e3ebdSchin #if !SHOPT_ECHOE
129da2e3ebdSchin 		else if(strcmp(argv[1],"-e")==0)
130da2e3ebdSchin 			prdata.raw = 0;
131da2e3ebdSchin 		else if(strcmp(argv[1],"-ne")==0 || strcmp(argv[1],"-en")==0)
132da2e3ebdSchin 		{
133da2e3ebdSchin 			prdata.raw = 0;
134da2e3ebdSchin 			prdata.echon = 1;
135da2e3ebdSchin 		}
136da2e3ebdSchin #endif /* SHOPT_ECHOE */
137da2e3ebdSchin 		else
138da2e3ebdSchin 			break;
139da2e3ebdSchin 		argv++;
140da2e3ebdSchin 	}
141b30d1939SAndy Fiddaman 	return(b_print(0,argv,(Shbltin_t*)&prdata));
142da2e3ebdSchin    }
143da2e3ebdSchin #endif /* SHOPT_ECHOPRINT */
144da2e3ebdSchin 
b_printf(int argc,char * argv[],Shbltin_t * context)145b30d1939SAndy Fiddaman int    b_printf(int argc, char *argv[],Shbltin_t *context)
146da2e3ebdSchin {
147da2e3ebdSchin 	struct print prdata;
148da2e3ebdSchin 	NOT_USED(argc);
149da2e3ebdSchin 	memset(&prdata,0,sizeof(prdata));
150b30d1939SAndy Fiddaman 	prdata.sh = context->shp;
151da2e3ebdSchin 	prdata.options = sh_optprintf;
152b30d1939SAndy Fiddaman 	return(b_print(-1,argv,(Shbltin_t*)&prdata));
153b30d1939SAndy Fiddaman }
154b30d1939SAndy Fiddaman 
infof(Opt_t * op,Sfio_t * sp,const char * s,Optdisc_t * dp)155b30d1939SAndy Fiddaman static int infof(Opt_t* op, Sfio_t* sp, const char* s, Optdisc_t* dp)
156b30d1939SAndy Fiddaman {
157b30d1939SAndy Fiddaman 	const struct printmap *pm;
158b30d1939SAndy Fiddaman 	char c='%';
159b30d1939SAndy Fiddaman 	for(pm=Pmap;pm->size>0;pm++)
160b30d1939SAndy Fiddaman 	{
161b30d1939SAndy Fiddaman 		sfprintf(sp, "[+%c(%s)q?%s.]",c,pm->name,pm->description);
162b30d1939SAndy Fiddaman 	}
163b30d1939SAndy Fiddaman 	return(1);
164da2e3ebdSchin }
165da2e3ebdSchin 
166da2e3ebdSchin /*
167da2e3ebdSchin  * argc==0 when called from echo
168da2e3ebdSchin  * argc==-1 when called from printf
169da2e3ebdSchin  */
170da2e3ebdSchin 
b_print(int argc,char * argv[],Shbltin_t * context)171b30d1939SAndy Fiddaman int    b_print(int argc, char *argv[], Shbltin_t *context)
172da2e3ebdSchin {
173da2e3ebdSchin 	register Sfio_t *outfile;
174da2e3ebdSchin 	register int exitval=0,n, fd = 1;
175b30d1939SAndy Fiddaman 	register Shell_t *shp = context->shp;
176da2e3ebdSchin 	const char *options, *msg = e_file+4;
177da2e3ebdSchin 	char *format = 0;
1787c2fbfb3SApril Chin 	int sflag = 0, nflag=0, rflag=0, vflag=0;
179b30d1939SAndy Fiddaman 	Optdisc_t disc;
180b30d1939SAndy Fiddaman 	disc.version = OPT_VERSION;
181b30d1939SAndy Fiddaman 	disc.infof = infof;
182b30d1939SAndy Fiddaman 	opt_info.disc = &disc;
183da2e3ebdSchin 	if(argc>0)
184da2e3ebdSchin 	{
185da2e3ebdSchin 		options = sh_optprint;
186da2e3ebdSchin 		nflag = rflag = 0;
187da2e3ebdSchin 		format = 0;
188da2e3ebdSchin 	}
189da2e3ebdSchin 	else
190da2e3ebdSchin 	{
191b30d1939SAndy Fiddaman 		struct print *pp = (struct print*)context;
192da2e3ebdSchin 		shp = pp->sh;
193da2e3ebdSchin 		options = pp->options;
194da2e3ebdSchin 		if(argc==0)
195da2e3ebdSchin 		{
196da2e3ebdSchin 			nflag = pp->echon;
197da2e3ebdSchin 			rflag = pp->raw;
198da2e3ebdSchin 			argv++;
199da2e3ebdSchin 			goto skip;
200da2e3ebdSchin 		}
201f9bbf53bSAndy Fiddaman 		argv++;
202*89af4c7bSAndy Fiddaman 		 /*
203*89af4c7bSAndy Fiddaman 		  * POSIX says: Standard utilities that do not accept options,
204*89af4c7bSAndy Fiddaman 		  * but that do accept operands, shall recognise "--" as a
205*89af4c7bSAndy Fiddaman 		  * first argument to be discarded.
206*89af4c7bSAndy Fiddaman 		  */
207*89af4c7bSAndy Fiddaman 		if (argv[0] != NULL && strcmp(argv[0], "--") == 0)
208*89af4c7bSAndy Fiddaman 			argv++;
209f9bbf53bSAndy Fiddaman 		goto printf;
210da2e3ebdSchin 	}
211da2e3ebdSchin 	while((n = optget(argv,options))) switch(n)
212da2e3ebdSchin 	{
213da2e3ebdSchin 		case 'n':
214da2e3ebdSchin 			nflag++;
215da2e3ebdSchin 			break;
216da2e3ebdSchin 		case 'p':
217da2e3ebdSchin 			fd = shp->coutpipe;
218da2e3ebdSchin 			msg = e_query;
219da2e3ebdSchin 			break;
220da2e3ebdSchin 		case 'f':
221da2e3ebdSchin 			format = opt_info.arg;
222da2e3ebdSchin 			break;
223da2e3ebdSchin 		case 's':
224da2e3ebdSchin 			/* print to history file */
2257c2fbfb3SApril Chin 			if(!sh_histinit((void*)shp))
226da2e3ebdSchin 				errormsg(SH_DICT,ERROR_system(1),e_history);
227b30d1939SAndy Fiddaman 			fd = sffileno(shp->gd->hist_ptr->histfp);
228da2e3ebdSchin 			sh_onstate(SH_HISTORY);
229da2e3ebdSchin 			sflag++;
230da2e3ebdSchin 			break;
231da2e3ebdSchin 		case 'e':
232da2e3ebdSchin 			rflag = 0;
233da2e3ebdSchin 			break;
234da2e3ebdSchin 		case 'r':
235da2e3ebdSchin 			rflag = 1;
236da2e3ebdSchin 			break;
237da2e3ebdSchin 		case 'u':
238da2e3ebdSchin 			fd = (int)strtol(opt_info.arg,&opt_info.arg,10);
239da2e3ebdSchin 			if(*opt_info.arg)
240da2e3ebdSchin 				fd = -1;
241b30d1939SAndy Fiddaman 			else if(!sh_iovalidfd(shp,fd))
242da2e3ebdSchin 				fd = -1;
243b30d1939SAndy Fiddaman 			else if(!(shp->inuse_bits&(1<<fd)) && (sh_inuse(shp,fd) || (shp->gd->hist_ptr && fd==sffileno(shp->gd->hist_ptr->histfp))))
244da2e3ebdSchin 
245da2e3ebdSchin 				fd = -1;
246da2e3ebdSchin 			break;
2477c2fbfb3SApril Chin 		case 'v':
24834f9b3eeSRoland Mainz 			vflag='v';
24934f9b3eeSRoland Mainz 			break;
25034f9b3eeSRoland Mainz 		case 'C':
25134f9b3eeSRoland Mainz 			vflag='C';
2527c2fbfb3SApril Chin 			break;
253da2e3ebdSchin 		case ':':
254da2e3ebdSchin 			/* The following is for backward compatibility */
255da2e3ebdSchin #if OPT_VERSION >= 19990123
256da2e3ebdSchin 			if(strcmp(opt_info.name,"-R")==0)
257da2e3ebdSchin #else
258da2e3ebdSchin 			if(strcmp(opt_info.option,"-R")==0)
259da2e3ebdSchin #endif
260da2e3ebdSchin 			{
261da2e3ebdSchin 				rflag = 1;
262da2e3ebdSchin 				if(error_info.errors==0)
263da2e3ebdSchin 				{
264da2e3ebdSchin 					argv += opt_info.index+1;
265da2e3ebdSchin 					/* special case test for -Rn */
266da2e3ebdSchin 					if(strchr(argv[-1],'n'))
267da2e3ebdSchin 						nflag++;
268da2e3ebdSchin 					if(*argv && strcmp(*argv,"-n")==0)
269da2e3ebdSchin 					{
270da2e3ebdSchin 
271da2e3ebdSchin 						nflag++;
272da2e3ebdSchin 						argv++;
273da2e3ebdSchin 					}
274da2e3ebdSchin 					goto skip2;
275da2e3ebdSchin 				}
276da2e3ebdSchin 			}
277da2e3ebdSchin 			else
278da2e3ebdSchin 				errormsg(SH_DICT,2, "%s", opt_info.arg);
279da2e3ebdSchin 			break;
280da2e3ebdSchin 		case '?':
281da2e3ebdSchin 			errormsg(SH_DICT,ERROR_usage(2), "%s", opt_info.arg);
282da2e3ebdSchin 			break;
283da2e3ebdSchin 	}
284da2e3ebdSchin 	argv += opt_info.index;
285f9bbf53bSAndy Fiddaman printf:
286da2e3ebdSchin 	if(error_info.errors || (argc<0 && !(format = *argv++)))
287da2e3ebdSchin 		errormsg(SH_DICT,ERROR_usage(2),"%s",optusage((char*)0));
2887c2fbfb3SApril Chin 	if(vflag && format)
28934f9b3eeSRoland Mainz 		errormsg(SH_DICT,ERROR_usage(2),"-%c and -f are mutually exclusive",vflag);
290da2e3ebdSchin skip:
291da2e3ebdSchin 	if(format)
292da2e3ebdSchin 		format = genformat(format);
293da2e3ebdSchin 	/* handle special case of '-' operand for print */
294da2e3ebdSchin 	if(argc>0 && *argv && strcmp(*argv,"-")==0 && strcmp(argv[-1],"--"))
295da2e3ebdSchin 		argv++;
296da2e3ebdSchin skip2:
297da2e3ebdSchin 	if(fd < 0)
298da2e3ebdSchin 	{
299da2e3ebdSchin 		errno = EBADF;
300da2e3ebdSchin 		n = 0;
301da2e3ebdSchin 	}
302da2e3ebdSchin 	else if(!(n=shp->fdstatus[fd]))
3037c2fbfb3SApril Chin 		n = sh_iocheckfd(shp,fd);
304da2e3ebdSchin 	if(!(n&IOWRITE))
305da2e3ebdSchin 	{
306da2e3ebdSchin 		/* don't print error message for stdout for compatibility */
307da2e3ebdSchin 		if(fd==1)
308da2e3ebdSchin 			return(1);
309da2e3ebdSchin 		errormsg(SH_DICT,ERROR_system(1),msg);
310da2e3ebdSchin 	}
311da2e3ebdSchin 	if(!(outfile=shp->sftable[fd]))
312da2e3ebdSchin 	{
313da2e3ebdSchin 		sh_onstate(SH_NOTRACK);
314da2e3ebdSchin 		n = SF_WRITE|((n&IOREAD)?SF_READ:0);
315da2e3ebdSchin 		shp->sftable[fd] = outfile = sfnew(NIL(Sfio_t*),shp->outbuff,IOBSIZE,fd,n);
316da2e3ebdSchin 		sh_offstate(SH_NOTRACK);
317da2e3ebdSchin 		sfpool(outfile,shp->outpool,SF_WRITE);
318da2e3ebdSchin 	}
319da2e3ebdSchin 	/* turn off share to guarantee atomic writes for printf */
320da2e3ebdSchin 	n = sfset(outfile,SF_SHARE|SF_PUBLIC,0);
321da2e3ebdSchin 	if(format)
322da2e3ebdSchin 	{
323da2e3ebdSchin 		/* printf style print */
324da2e3ebdSchin 		Sfio_t *pool;
325da2e3ebdSchin 		struct printf pdata;
326da2e3ebdSchin 		memset(&pdata, 0, sizeof(pdata));
327da2e3ebdSchin 		pdata.sh = shp;
328da2e3ebdSchin 		pdata.hdr.version = SFIO_VERSION;
329da2e3ebdSchin 		pdata.hdr.extf = extend;
330da2e3ebdSchin 		pdata.nextarg = argv;
331da2e3ebdSchin 		sh_offstate(SH_STOPOK);
332da2e3ebdSchin 		pool=sfpool(sfstderr,NIL(Sfio_t*),SF_WRITE);
333da2e3ebdSchin 		do
334da2e3ebdSchin 		{
335da2e3ebdSchin 			if(shp->trapnote&SH_SIGSET)
336da2e3ebdSchin 				break;
337da2e3ebdSchin 			pdata.hdr.form = format;
338da2e3ebdSchin 			sfprintf(outfile,"%!",&pdata);
339da2e3ebdSchin 		} while(*pdata.nextarg && pdata.nextarg!=argv);
340da2e3ebdSchin 		if(pdata.nextarg == nullarg && pdata.argsize>0)
341da2e3ebdSchin 			sfwrite(outfile,stakptr(staktell()),pdata.argsize);
34234f9b3eeSRoland Mainz 		if(sffileno(outfile)!=sffileno(sfstderr))
34334f9b3eeSRoland Mainz 			sfsync(outfile);
344da2e3ebdSchin 		sfpool(sfstderr,pool,SF_WRITE);
345da2e3ebdSchin 		exitval = pdata.err;
346da2e3ebdSchin 	}
3477c2fbfb3SApril Chin 	else if(vflag)
3487c2fbfb3SApril Chin 	{
3497c2fbfb3SApril Chin 		while(*argv)
35034f9b3eeSRoland Mainz 		{
35134f9b3eeSRoland Mainz 			fmtbase64(outfile,*argv++,vflag=='C');
35234f9b3eeSRoland Mainz 			if(!nflag)
35334f9b3eeSRoland Mainz 				sfputc(outfile,'\n');
35434f9b3eeSRoland Mainz 		}
3557c2fbfb3SApril Chin 	}
356da2e3ebdSchin 	else
357da2e3ebdSchin 	{
358da2e3ebdSchin 		/* echo style print */
3597c2fbfb3SApril Chin 		if(nflag && !argv[0])
3607c2fbfb3SApril Chin 			sfsync((Sfio_t*)0);
361b30d1939SAndy Fiddaman 		else if(sh_echolist(shp,outfile,rflag,argv) && !nflag)
362da2e3ebdSchin 			sfputc(outfile,'\n');
363da2e3ebdSchin 	}
364da2e3ebdSchin 	if(sflag)
365da2e3ebdSchin 	{
366b30d1939SAndy Fiddaman 		hist_flush(shp->gd->hist_ptr);
367da2e3ebdSchin 		sh_offstate(SH_HISTORY);
368da2e3ebdSchin 	}
369da2e3ebdSchin 	else if(n&SF_SHARE)
370da2e3ebdSchin 	{
371da2e3ebdSchin 		sfset(outfile,SF_SHARE|SF_PUBLIC,1);
372da2e3ebdSchin 		sfsync(outfile);
373da2e3ebdSchin 	}
374da2e3ebdSchin 	return(exitval);
375da2e3ebdSchin }
376da2e3ebdSchin 
377da2e3ebdSchin /*
378da2e3ebdSchin  * echo the argument list onto <outfile>
379da2e3ebdSchin  * if <raw> is non-zero then \ is not a special character.
380da2e3ebdSchin  * returns 0 for \c otherwise 1.
381da2e3ebdSchin  */
382da2e3ebdSchin 
sh_echolist(Shell_t * shp,Sfio_t * outfile,int raw,char * argv[])383b30d1939SAndy Fiddaman int sh_echolist(Shell_t *shp,Sfio_t *outfile, int raw, char *argv[])
384da2e3ebdSchin {
385da2e3ebdSchin 	register char	*cp;
386da2e3ebdSchin 	register int	n;
387da2e3ebdSchin 	struct printf pdata;
388da2e3ebdSchin 	pdata.cescape = 0;
389da2e3ebdSchin 	pdata.err = 0;
390da2e3ebdSchin 	while(!pdata.cescape && (cp= *argv++))
391da2e3ebdSchin 	{
392da2e3ebdSchin 		if(!raw  && (n=fmtvecho(cp,&pdata))>=0)
393da2e3ebdSchin 		{
394da2e3ebdSchin 			if(n)
395da2e3ebdSchin 				sfwrite(outfile,stakptr(staktell()),n);
396da2e3ebdSchin 		}
397da2e3ebdSchin 		else
398da2e3ebdSchin 			sfputr(outfile,cp,-1);
399da2e3ebdSchin 		if(*argv)
400da2e3ebdSchin 			sfputc(outfile,' ');
401b30d1939SAndy Fiddaman 		sh_sigcheck(shp);
402da2e3ebdSchin 	}
403da2e3ebdSchin 	return(!pdata.cescape);
404da2e3ebdSchin }
405da2e3ebdSchin 
406da2e3ebdSchin /*
407da2e3ebdSchin  * modified version of stresc for generating formats
408da2e3ebdSchin  */
strformat(char * s)409da2e3ebdSchin static char strformat(char *s)
410da2e3ebdSchin {
411da2e3ebdSchin         register char*  t;
412da2e3ebdSchin         register int    c;
413da2e3ebdSchin         char*           b;
414da2e3ebdSchin         char*           p;
415b30d1939SAndy Fiddaman #if SHOPT_MULTIBYTE && defined(FMT_EXP_WIDE)
416b30d1939SAndy Fiddaman 	int		w;
417b30d1939SAndy Fiddaman #endif
418da2e3ebdSchin 
419da2e3ebdSchin         b = t = s;
420da2e3ebdSchin         for (;;)
421da2e3ebdSchin         {
422da2e3ebdSchin                 switch (c = *s++)
423da2e3ebdSchin                 {
424da2e3ebdSchin                     case '\\':
425da2e3ebdSchin 			if(*s==0)
426da2e3ebdSchin 				break;
427b30d1939SAndy Fiddaman #if SHOPT_MULTIBYTE && defined(FMT_EXP_WIDE)
428b30d1939SAndy Fiddaman                         c = chrexp(s - 1, &p, &w, FMT_EXP_CHAR|FMT_EXP_LINE|FMT_EXP_WIDE);
429b30d1939SAndy Fiddaman #else
430da2e3ebdSchin                         c = chresc(s - 1, &p);
431b30d1939SAndy Fiddaman #endif
432da2e3ebdSchin                         s = p;
433da2e3ebdSchin #if SHOPT_MULTIBYTE
434b30d1939SAndy Fiddaman #if defined(FMT_EXP_WIDE)
435b30d1939SAndy Fiddaman 			if(w)
436b30d1939SAndy Fiddaman 			{
437b30d1939SAndy Fiddaman 				t += mbwide() ? mbconv(t, c) : wc2utf8(t, c);
438b30d1939SAndy Fiddaman 				continue;
439b30d1939SAndy Fiddaman 			}
440b30d1939SAndy Fiddaman #else
441da2e3ebdSchin 			if(c>UCHAR_MAX && mbwide())
442da2e3ebdSchin 			{
443b30d1939SAndy Fiddaman 				t += mbconv(t, c);
444da2e3ebdSchin 				continue;
445da2e3ebdSchin 			}
446b30d1939SAndy Fiddaman #endif /* FMT_EXP_WIDE */
447da2e3ebdSchin #endif /* SHOPT_MULTIBYTE */
448da2e3ebdSchin 			if(c=='%')
449da2e3ebdSchin 				*t++ = '%';
450da2e3ebdSchin 			else if(c==0)
451da2e3ebdSchin 			{
452da2e3ebdSchin 				*t++ = '%';
453da2e3ebdSchin 				c = 'Z';
454da2e3ebdSchin 			}
455da2e3ebdSchin                         break;
456da2e3ebdSchin                     case 0:
457da2e3ebdSchin                         *t = 0;
458da2e3ebdSchin                         return(t - b);
459da2e3ebdSchin                 }
460da2e3ebdSchin                 *t++ = c;
461da2e3ebdSchin         }
462da2e3ebdSchin }
463da2e3ebdSchin 
464da2e3ebdSchin 
genformat(char * format)465da2e3ebdSchin static char *genformat(char *format)
466da2e3ebdSchin {
467da2e3ebdSchin 	register char *fp;
468da2e3ebdSchin 	stakseek(0);
469da2e3ebdSchin 	stakputs(preformat);
470da2e3ebdSchin 	stakputs(format);
471da2e3ebdSchin 	fp = (char*)stakfreeze(1);
472da2e3ebdSchin 	strformat(fp+sizeof(preformat)-1);
473da2e3ebdSchin 	return(fp);
474da2e3ebdSchin }
475da2e3ebdSchin 
fmthtml(const char * string,int flags)476b30d1939SAndy Fiddaman static char *fmthtml(const char *string, int flags)
477da2e3ebdSchin {
478da2e3ebdSchin 	register const char *cp = string;
479da2e3ebdSchin 	register int c, offset = staktell();
480b30d1939SAndy Fiddaman 	if(!(flags&SFFMT_ALTER))
481da2e3ebdSchin 	{
482b30d1939SAndy Fiddaman 		while(c= *(unsigned char*)cp++)
483b30d1939SAndy Fiddaman 		{
484da2e3ebdSchin #if SHOPT_MULTIBYTE
485b30d1939SAndy Fiddaman 			register int s;
486b30d1939SAndy Fiddaman 			if((s=mbsize(cp-1)) > 1)
487b30d1939SAndy Fiddaman 			{
488b30d1939SAndy Fiddaman 				cp += (s-1);
489b30d1939SAndy Fiddaman 				continue;
490b30d1939SAndy Fiddaman 			}
491b30d1939SAndy Fiddaman #endif /* SHOPT_MULTIBYTE */
492b30d1939SAndy Fiddaman 			if(c=='<')
493b30d1939SAndy Fiddaman 				stakputs("&lt;");
494b30d1939SAndy Fiddaman 			else if(c=='>')
495b30d1939SAndy Fiddaman 				stakputs("&gt;");
496b30d1939SAndy Fiddaman 			else if(c=='&')
497b30d1939SAndy Fiddaman 				stakputs("&amp;");
498b30d1939SAndy Fiddaman 			else if(c=='"')
499b30d1939SAndy Fiddaman 				stakputs("&quot;");
500b30d1939SAndy Fiddaman 			else if(c=='\'')
501b30d1939SAndy Fiddaman 				stakputs("&apos;");
502b30d1939SAndy Fiddaman 			else if(c==' ')
503b30d1939SAndy Fiddaman 				stakputs("&nbsp;");
504b30d1939SAndy Fiddaman 			else if(!isprint(c) && c!='\n' && c!='\r')
505b30d1939SAndy Fiddaman 				sfprintf(stkstd,"&#%X;",CCMAPC(c,CC_NATIVE,CC_ASCII));
506b30d1939SAndy Fiddaman 			else
507b30d1939SAndy Fiddaman 				stakputc(c);
508b30d1939SAndy Fiddaman 		}
509b30d1939SAndy Fiddaman 	}
510b30d1939SAndy Fiddaman 	else
511b30d1939SAndy Fiddaman 	{
512b30d1939SAndy Fiddaman 		while(c= *(unsigned char*)cp++)
513da2e3ebdSchin 		{
514b30d1939SAndy Fiddaman 			if(strchr("!*'();@&+$,#[]<>~.\"{}|\\-`^% ",c) || (!isprint(c) && c!='\n' && c!='\r'))
515b30d1939SAndy Fiddaman 				sfprintf(stkstd,"%%%02X",CCMAPC(c,CC_NATIVE,CC_ASCII));
516b30d1939SAndy Fiddaman 			else
517b30d1939SAndy Fiddaman 				stakputc(c);
518da2e3ebdSchin 		}
519da2e3ebdSchin 	}
520da2e3ebdSchin 	stakputc(0);
521da2e3ebdSchin 	return(stakptr(offset));
522da2e3ebdSchin }
523da2e3ebdSchin 
5247c2fbfb3SApril Chin #if 1
fmtbase64(Sfio_t * iop,char * string,int alt)5257c2fbfb3SApril Chin static ssize_t fmtbase64(Sfio_t *iop, char *string, int alt)
5267c2fbfb3SApril Chin #else
5277c2fbfb3SApril Chin static void *fmtbase64(char *string, ssize_t *sz, int alt)
5287c2fbfb3SApril Chin #endif
529da2e3ebdSchin {
530da2e3ebdSchin 	char			*cp;
531da2e3ebdSchin 	Sfdouble_t		d;
5327c2fbfb3SApril Chin 	ssize_t			size;
533da2e3ebdSchin 	Namval_t		*np = nv_open(string, NiL, NV_VARNAME|NV_NOASSIGN|NV_NOADD);
534b30d1939SAndy Fiddaman 	Namarr_t		*ap;
535da2e3ebdSchin 	static union types_t	number;
5367c2fbfb3SApril Chin 	if(!np || nv_isnull(np))
5377c2fbfb3SApril Chin 	{
5387c2fbfb3SApril Chin 		if(sh_isoption(SH_NOUNSET))
5397c2fbfb3SApril Chin 			errormsg(SH_DICT,ERROR_exit(1),e_notset,string);
5407c2fbfb3SApril Chin 		return(0);
5417c2fbfb3SApril Chin 	}
542da2e3ebdSchin 	if(nv_isattr(np,NV_INTEGER))
543da2e3ebdSchin 	{
544da2e3ebdSchin 		d = nv_getnum(np);
545da2e3ebdSchin 		if(nv_isattr(np,NV_DOUBLE))
546da2e3ebdSchin 		{
547da2e3ebdSchin 			if(nv_isattr(np,NV_LONG))
548da2e3ebdSchin 			{
549da2e3ebdSchin 				size = sizeof(Sfdouble_t);
550da2e3ebdSchin 				number.ld = d;
551da2e3ebdSchin 			}
552da2e3ebdSchin 			else if(nv_isattr(np,NV_SHORT))
553da2e3ebdSchin 			{
554da2e3ebdSchin 				size = sizeof(float);
555da2e3ebdSchin 				number.f = (float)d;
556da2e3ebdSchin 			}
557da2e3ebdSchin 			else
558da2e3ebdSchin 			{
559da2e3ebdSchin 				size = sizeof(double);
560da2e3ebdSchin 				number.d = (double)d;
561da2e3ebdSchin 			}
562da2e3ebdSchin 		}
563da2e3ebdSchin 		else
564da2e3ebdSchin 		{
565da2e3ebdSchin 			if(nv_isattr(np,NV_LONG))
566da2e3ebdSchin 			{
567da2e3ebdSchin 				size =  sizeof(Sflong_t);
568da2e3ebdSchin 				number.ll = (Sflong_t)d;
569da2e3ebdSchin 			}
570da2e3ebdSchin 			else if(nv_isattr(np,NV_SHORT))
571da2e3ebdSchin 			{
572da2e3ebdSchin 				size =  sizeof(short);
573da2e3ebdSchin 				number.h = (short)d;
574da2e3ebdSchin 			}
575da2e3ebdSchin 			else
576da2e3ebdSchin 			{
577da2e3ebdSchin 				size =  sizeof(short);
578da2e3ebdSchin 				number.i = (int)d;
579da2e3ebdSchin 			}
580da2e3ebdSchin 		}
5817c2fbfb3SApril Chin #if 1
5827c2fbfb3SApril Chin 		return(sfwrite(iop, (void*)&number, size));
5837c2fbfb3SApril Chin #else
584da2e3ebdSchin 		if(sz)
585da2e3ebdSchin 			*sz = size;
586da2e3ebdSchin 		return((void*)&number);
5877c2fbfb3SApril Chin #endif
588da2e3ebdSchin 	}
589da2e3ebdSchin 	if(nv_isattr(np,NV_BINARY))
5907c2fbfb3SApril Chin #if 1
5917c2fbfb3SApril Chin 	{
5927c2fbfb3SApril Chin 		Namfun_t *fp;
5937c2fbfb3SApril Chin 		for(fp=np->nvfun; fp;fp=fp->next)
5947c2fbfb3SApril Chin 		{
5957c2fbfb3SApril Chin 			if(fp->disc && fp->disc->writef)
5967c2fbfb3SApril Chin 				break;
5977c2fbfb3SApril Chin 		}
5987c2fbfb3SApril Chin 		if(fp)
5997c2fbfb3SApril Chin 			return (*fp->disc->writef)(np, iop, 0, fp);
6007c2fbfb3SApril Chin 		else
6017c2fbfb3SApril Chin 		{
6027c2fbfb3SApril Chin 			int n = nv_size(np);
60334f9b3eeSRoland Mainz 			if(nv_isarray(np))
60434f9b3eeSRoland Mainz 			{
60534f9b3eeSRoland Mainz 				nv_onattr(np,NV_RAW);
60634f9b3eeSRoland Mainz 				cp = nv_getval(np);
60734f9b3eeSRoland Mainz 				nv_offattr(np,NV_RAW);
60834f9b3eeSRoland Mainz 			}
60934f9b3eeSRoland Mainz 			else
61034f9b3eeSRoland Mainz 				cp = (char*)np->nvalue.cp;
6117c2fbfb3SApril Chin 			if((size = n)==0)
6127c2fbfb3SApril Chin 				size = strlen(cp);
6137c2fbfb3SApril Chin 			size = sfwrite(iop, cp, size);
6147c2fbfb3SApril Chin 			return(n?n:size);
6157c2fbfb3SApril Chin 		}
6167c2fbfb3SApril Chin 	}
617b30d1939SAndy Fiddaman 	else if(nv_isarray(np) && (ap=nv_arrayptr(np)) && array_elem(ap) && (ap->nelem&(ARRAY_UNDEF|ARRAY_SCAN)))
6187c2fbfb3SApril Chin 	{
6197c2fbfb3SApril Chin 		nv_outnode(np,iop,(alt?-1:0),0);
6207c2fbfb3SApril Chin 		sfputc(iop,')');
6217c2fbfb3SApril Chin 		return(sftell(iop));
6227c2fbfb3SApril Chin 	}
6237c2fbfb3SApril Chin 	else
6247c2fbfb3SApril Chin 	{
6257c2fbfb3SApril Chin 		if(alt && nv_isvtree(np))
6267c2fbfb3SApril Chin 			nv_onattr(np,NV_EXPORT);
627b30d1939SAndy Fiddaman 		else
628b30d1939SAndy Fiddaman 			alt = 0;
629b30d1939SAndy Fiddaman 		cp = nv_getval(np);
630b30d1939SAndy Fiddaman 		if(alt)
631b30d1939SAndy Fiddaman 			nv_offattr(np,NV_EXPORT);
632b30d1939SAndy Fiddaman 		if(!cp)
6337c2fbfb3SApril Chin 			return(0);
6347c2fbfb3SApril Chin 		size = strlen(cp);
6357c2fbfb3SApril Chin 		return(sfwrite(iop,cp,size));
6367c2fbfb3SApril Chin 	}
6377c2fbfb3SApril Chin #else
638da2e3ebdSchin 		nv_onattr(np,NV_RAW);
639da2e3ebdSchin 	cp = nv_getval(np);
640da2e3ebdSchin 	if(nv_isattr(np,NV_BINARY))
641da2e3ebdSchin 		nv_offattr(np,NV_RAW);
642da2e3ebdSchin 	if((size = nv_size(np))==0)
643da2e3ebdSchin 		size = strlen(cp);
644da2e3ebdSchin 	if(sz)
645da2e3ebdSchin 		*sz = size;
646da2e3ebdSchin 	return((void*)cp);
6477c2fbfb3SApril Chin #endif
6487c2fbfb3SApril Chin }
6497c2fbfb3SApril Chin 
varname(const char * str,int n)6507c2fbfb3SApril Chin static int varname(const char *str, int n)
6517c2fbfb3SApril Chin {
6527c2fbfb3SApril Chin 	register int c,dot=1,len=1;
6537c2fbfb3SApril Chin 	if(n < 0)
6547c2fbfb3SApril Chin 	{
6557c2fbfb3SApril Chin 		if(*str=='.')
6567c2fbfb3SApril Chin 			str++;
6577c2fbfb3SApril Chin 		n = strlen(str);
6587c2fbfb3SApril Chin 	}
6597c2fbfb3SApril Chin 	for(;n > 0; n-=len)
6607c2fbfb3SApril Chin 	{
6617c2fbfb3SApril Chin #ifdef SHOPT_MULTIBYTE
6627c2fbfb3SApril Chin 		len = mbsize(str);
6637c2fbfb3SApril Chin 		c = mbchar(str);
6647c2fbfb3SApril Chin #else
6657c2fbfb3SApril Chin 		c = *(unsigned char*)str++;
6667c2fbfb3SApril Chin #endif
6677c2fbfb3SApril Chin 		if(dot && !(isalpha(c)||c=='_'))
6687c2fbfb3SApril Chin 			break;
6697c2fbfb3SApril Chin 		else if(dot==0 && !(isalnum(c) || c=='_' || c == '.'))
6707c2fbfb3SApril Chin 			break;
6717c2fbfb3SApril Chin 		dot = (c=='.');
6727c2fbfb3SApril Chin 	}
6737c2fbfb3SApril Chin 	return(n==0);
674da2e3ebdSchin }
675da2e3ebdSchin 
mapformat(Sffmt_t * fe)676b30d1939SAndy Fiddaman static const char *mapformat(Sffmt_t *fe)
677b30d1939SAndy Fiddaman {
678b30d1939SAndy Fiddaman 	const struct printmap *pm = Pmap;
679b30d1939SAndy Fiddaman 	while(pm->size>0)
680b30d1939SAndy Fiddaman 	{
681b30d1939SAndy Fiddaman 		if(pm->size==fe->n_str && memcmp(pm->name,fe->t_str,fe->n_str)==0)
682b30d1939SAndy Fiddaman 			return(pm->map);
683b30d1939SAndy Fiddaman 		pm++;
684b30d1939SAndy Fiddaman 	}
685b30d1939SAndy Fiddaman 	return(0);
686b30d1939SAndy Fiddaman }
687b30d1939SAndy Fiddaman 
extend(Sfio_t * sp,void * v,Sffmt_t * fe)688da2e3ebdSchin static int extend(Sfio_t* sp, void* v, Sffmt_t* fe)
689da2e3ebdSchin {
690da2e3ebdSchin 	char*		lastchar = "";
691da2e3ebdSchin 	register int	neg = 0;
692da2e3ebdSchin 	Sfdouble_t	d;
693da2e3ebdSchin 	Sfdouble_t	longmin = LDBL_LLONG_MIN;
694da2e3ebdSchin 	Sfdouble_t	longmax = LDBL_LLONG_MAX;
695da2e3ebdSchin 	int		format = fe->fmt;
696da2e3ebdSchin 	int		n;
697da2e3ebdSchin 	int		fold = fe->base;
698da2e3ebdSchin 	union types_t*	value = (union types_t*)v;
699da2e3ebdSchin 	struct printf*	pp = (struct printf*)fe;
700b30d1939SAndy Fiddaman 	Shell_t		*shp = pp->sh;
701da2e3ebdSchin 	register char*	argp = *pp->nextarg;
702b30d1939SAndy Fiddaman 	char		*w,*s;
703da2e3ebdSchin 
704b30d1939SAndy Fiddaman 	if(fe->n_str>0 && (format=='T'||format=='Q') && varname(fe->t_str,fe->n_str) && (!argp || varname(argp,-1)))
7057c2fbfb3SApril Chin 	{
7067c2fbfb3SApril Chin 		if(argp)
7077c2fbfb3SApril Chin 			pp->lastarg = argp;
7087c2fbfb3SApril Chin 		else
7097c2fbfb3SApril Chin 			argp = pp->lastarg;
7107c2fbfb3SApril Chin 		if(argp)
7117c2fbfb3SApril Chin 		{
7127c2fbfb3SApril Chin 			sfprintf(pp->sh->strbuf,"%s.%.*s%c",argp,fe->n_str,fe->t_str,0);
7137c2fbfb3SApril Chin 			argp = sfstruse(pp->sh->strbuf);
7147c2fbfb3SApril Chin 		}
7157c2fbfb3SApril Chin 	}
7167c2fbfb3SApril Chin 	else
7177c2fbfb3SApril Chin 		pp->lastarg = 0;
718da2e3ebdSchin 	fe->flags |= SFFMT_VALUE;
719da2e3ebdSchin 	if(!argp || format=='Z')
720da2e3ebdSchin 	{
721da2e3ebdSchin 		switch(format)
722da2e3ebdSchin 		{
723da2e3ebdSchin 		case 'c':
724da2e3ebdSchin 			value->c = 0;
725da2e3ebdSchin 			fe->flags &= ~SFFMT_LONG;
726da2e3ebdSchin 			break;
727da2e3ebdSchin 		case 'q':
728da2e3ebdSchin 			format = 's';
729da2e3ebdSchin 			/* FALL THROUGH */
730da2e3ebdSchin 		case 's':
731da2e3ebdSchin 		case 'H':
732da2e3ebdSchin 		case 'B':
733da2e3ebdSchin 		case 'P':
734da2e3ebdSchin 		case 'R':
735da2e3ebdSchin 		case 'Z':
736da2e3ebdSchin 		case 'b':
737da2e3ebdSchin 			fe->fmt = 's';
738da2e3ebdSchin 			fe->size = -1;
739da2e3ebdSchin 			fe->base = -1;
740da2e3ebdSchin 			value->s = "";
741da2e3ebdSchin 			fe->flags &= ~SFFMT_LONG;
742da2e3ebdSchin 			break;
743da2e3ebdSchin 		case 'a':
744da2e3ebdSchin 		case 'e':
745da2e3ebdSchin 		case 'f':
746da2e3ebdSchin 		case 'g':
747da2e3ebdSchin 		case 'A':
748da2e3ebdSchin 		case 'E':
749da2e3ebdSchin 		case 'F':
750da2e3ebdSchin 		case 'G':
751da2e3ebdSchin                         if(SFFMT_LDOUBLE)
752da2e3ebdSchin 				value->ld = 0.;
753da2e3ebdSchin 			else
754da2e3ebdSchin 				value->d = 0.;
755da2e3ebdSchin 			break;
756da2e3ebdSchin 		case 'n':
757da2e3ebdSchin 			value->ip = &pp->intvar;
758da2e3ebdSchin 			break;
759da2e3ebdSchin 		case 'Q':
760da2e3ebdSchin 			value->ll = 0;
761da2e3ebdSchin 			break;
762da2e3ebdSchin 		case 'T':
763da2e3ebdSchin 			fe->fmt = 'd';
764da2e3ebdSchin 			value->ll = tmxgettime();
765da2e3ebdSchin 			break;
766da2e3ebdSchin 		default:
767da2e3ebdSchin 			if(!strchr("DdXxoUu",format))
768da2e3ebdSchin 				errormsg(SH_DICT,ERROR_exit(1),e_formspec,format);
769da2e3ebdSchin 			fe->fmt = 'd';
770da2e3ebdSchin 			value->ll = 0;
771da2e3ebdSchin 			break;
772da2e3ebdSchin 		}
773da2e3ebdSchin 	}
774da2e3ebdSchin 	else
775da2e3ebdSchin 	{
776da2e3ebdSchin 		switch(format)
777da2e3ebdSchin 		{
778da2e3ebdSchin 		case 'p':
779da2e3ebdSchin 			value->p = (char**)strtol(argp,&lastchar,10);
780da2e3ebdSchin 			break;
781da2e3ebdSchin 		case 'n':
782da2e3ebdSchin 		{
783da2e3ebdSchin 			Namval_t *np;
784b30d1939SAndy Fiddaman 			np = nv_open(argp,shp->var_tree,NV_VARNAME|NV_NOASSIGN|NV_NOARRAY);
785b30d1939SAndy Fiddaman 			_nv_unset(np,0);
786da2e3ebdSchin 			nv_onattr(np,NV_INTEGER);
787da2e3ebdSchin 			if (np->nvalue.lp = new_of(int32_t,0))
788da2e3ebdSchin 				*np->nvalue.lp = 0;
789da2e3ebdSchin 			nv_setsize(np,10);
790da2e3ebdSchin 			if(sizeof(int)==sizeof(int32_t))
791da2e3ebdSchin 				value->ip = (int*)np->nvalue.lp;
792da2e3ebdSchin 			else
793da2e3ebdSchin 			{
794da2e3ebdSchin 				int32_t sl = 1;
795da2e3ebdSchin 				value->ip = (int*)(((char*)np->nvalue.lp) + (*((char*)&sl) ? 0 : sizeof(int)));
796da2e3ebdSchin 			}
797da2e3ebdSchin 			nv_close(np);
798da2e3ebdSchin 			break;
799da2e3ebdSchin 		}
800da2e3ebdSchin 		case 'q':
801b30d1939SAndy Fiddaman 			if(fe->n_str)
802b30d1939SAndy Fiddaman 			{
803b30d1939SAndy Fiddaman 				const char *fp = mapformat(fe);
804b30d1939SAndy Fiddaman 				if(fp)
805b30d1939SAndy Fiddaman 				{
806b30d1939SAndy Fiddaman 					format = *fp;
807b30d1939SAndy Fiddaman 					if(fp[1])
808b30d1939SAndy Fiddaman 						fe->flags |=SFFMT_ALTER;
809b30d1939SAndy Fiddaman 				}
810b30d1939SAndy Fiddaman 			}
811b30d1939SAndy Fiddaman 			/* FALLTHROUGH */
812da2e3ebdSchin 		case 'b':
813da2e3ebdSchin 		case 's':
814da2e3ebdSchin 		case 'B':
815da2e3ebdSchin 		case 'H':
816da2e3ebdSchin 		case 'P':
817da2e3ebdSchin 		case 'R':
818da2e3ebdSchin 			fe->fmt = 's';
819da2e3ebdSchin 			fe->size = -1;
820da2e3ebdSchin 			if(format=='s' && fe->base>=0)
821da2e3ebdSchin 			{
822da2e3ebdSchin 				value->p = pp->nextarg;
823da2e3ebdSchin 				pp->nextarg = nullarg;
824da2e3ebdSchin 			}
825da2e3ebdSchin 			else
826da2e3ebdSchin 			{
827da2e3ebdSchin 				fe->base = -1;
828da2e3ebdSchin 				value->s = argp;
829da2e3ebdSchin 			}
830da2e3ebdSchin 			fe->flags &= ~SFFMT_LONG;
831da2e3ebdSchin 			break;
832da2e3ebdSchin 		case 'c':
83334f9b3eeSRoland Mainz 			if(mbwide() && (n = mbsize(argp)) > 1)
83434f9b3eeSRoland Mainz 			{
83534f9b3eeSRoland Mainz 				fe->fmt = 's';
83634f9b3eeSRoland Mainz 				fe->size = n;
83734f9b3eeSRoland Mainz 				value->s = argp;
83834f9b3eeSRoland Mainz 			}
83934f9b3eeSRoland Mainz 			else if(fe->base >=0)
840da2e3ebdSchin 				value->s = argp;
841da2e3ebdSchin 			else
842da2e3ebdSchin 				value->c = *argp;
843da2e3ebdSchin 			fe->flags &= ~SFFMT_LONG;
844da2e3ebdSchin 			break;
845da2e3ebdSchin 		case 'o':
846da2e3ebdSchin 		case 'x':
847da2e3ebdSchin 		case 'X':
848da2e3ebdSchin 		case 'u':
849da2e3ebdSchin 		case 'U':
850da2e3ebdSchin 			longmax = LDBL_ULLONG_MAX;
8515ae8bd53SToomas Soome 			/* FALLTHROUGH */
852da2e3ebdSchin 		case '.':
853da2e3ebdSchin 			if(fe->size==2 && strchr("bcsqHPRQTZ",*fe->form))
854da2e3ebdSchin 			{
855da2e3ebdSchin 				value->ll = ((unsigned char*)argp)[0];
856da2e3ebdSchin 				break;
857da2e3ebdSchin 			}
8585ae8bd53SToomas Soome 			/* FALLTHROUGH */
859da2e3ebdSchin 		case 'd':
860da2e3ebdSchin 		case 'D':
861da2e3ebdSchin 		case 'i':
862da2e3ebdSchin 			switch(*argp)
863da2e3ebdSchin 			{
864da2e3ebdSchin 			case '\'':
865da2e3ebdSchin 			case '"':
86634f9b3eeSRoland Mainz 				w = argp + 1;
86734f9b3eeSRoland Mainz 				if(mbwide() && mbsize(w) > 1)
86834f9b3eeSRoland Mainz 					value->ll = mbchar(w);
86934f9b3eeSRoland Mainz 				else
87034f9b3eeSRoland Mainz 					value->ll = *(unsigned char*)w++;
87134f9b3eeSRoland Mainz 				if(w[0] && (w[0] != argp[0] || w[1]))
8727c2fbfb3SApril Chin 				{
8737c2fbfb3SApril Chin 					errormsg(SH_DICT,ERROR_warn(0),e_charconst,argp);
8747c2fbfb3SApril Chin 					pp->err = 1;
8757c2fbfb3SApril Chin 				}
876da2e3ebdSchin 				break;
877da2e3ebdSchin 			default:
878da2e3ebdSchin 				d = sh_strnum(argp,&lastchar,0);
879da2e3ebdSchin 				if(d<longmin)
880da2e3ebdSchin 				{
881da2e3ebdSchin 					errormsg(SH_DICT,ERROR_warn(0),e_overflow,argp);
882da2e3ebdSchin 					pp->err = 1;
883da2e3ebdSchin 					d = longmin;
884da2e3ebdSchin 				}
885da2e3ebdSchin 				else if(d>longmax)
886da2e3ebdSchin 				{
887da2e3ebdSchin 					errormsg(SH_DICT,ERROR_warn(0),e_overflow,argp);
888da2e3ebdSchin 					pp->err = 1;
889da2e3ebdSchin 					d = longmax;
890da2e3ebdSchin 				}
891da2e3ebdSchin 				value->ll = (Sflong_t)d;
892da2e3ebdSchin 				if(lastchar == *pp->nextarg)
893da2e3ebdSchin 				{
894da2e3ebdSchin 					value->ll = *argp;
895da2e3ebdSchin 					lastchar = "";
896da2e3ebdSchin 				}
897da2e3ebdSchin 				break;
898da2e3ebdSchin 			}
899da2e3ebdSchin 			if(neg)
900da2e3ebdSchin 				value->ll = -value->ll;
901da2e3ebdSchin 			fe->size = sizeof(value->ll);
902da2e3ebdSchin 			break;
903da2e3ebdSchin 		case 'a':
904da2e3ebdSchin 		case 'e':
905da2e3ebdSchin 		case 'f':
906da2e3ebdSchin 		case 'g':
907da2e3ebdSchin 		case 'A':
908da2e3ebdSchin 		case 'E':
909da2e3ebdSchin 		case 'F':
910da2e3ebdSchin 		case 'G':
911da2e3ebdSchin 			d = sh_strnum(*pp->nextarg,&lastchar,0);
9127c2fbfb3SApril Chin 			switch(*argp)
9137c2fbfb3SApril Chin 			{
9147c2fbfb3SApril Chin 			    case '\'':
9157c2fbfb3SApril Chin 			    case '"':
9167c2fbfb3SApril Chin 				d = ((unsigned char*)argp)[1];
9177c2fbfb3SApril Chin 				if(argp[2] && (argp[2] != argp[0] || argp[3]))
9187c2fbfb3SApril Chin 				{
9197c2fbfb3SApril Chin 					errormsg(SH_DICT,ERROR_warn(0),e_charconst,argp);
9207c2fbfb3SApril Chin 					pp->err = 1;
9217c2fbfb3SApril Chin 				}
9227c2fbfb3SApril Chin 				break;
9237c2fbfb3SApril Chin 			    default:
9247c2fbfb3SApril Chin 				d = sh_strnum(*pp->nextarg,&lastchar,0);
9257c2fbfb3SApril Chin 				break;
9267c2fbfb3SApril Chin 			}
927da2e3ebdSchin                         if(SFFMT_LDOUBLE)
928da2e3ebdSchin 			{
929da2e3ebdSchin 				value->ld = d;
930da2e3ebdSchin 				fe->size = sizeof(value->ld);
931da2e3ebdSchin 			}
932da2e3ebdSchin 			else
933da2e3ebdSchin 			{
934da2e3ebdSchin 				value->d = d;
935da2e3ebdSchin 				fe->size = sizeof(value->d);
936da2e3ebdSchin 			}
937da2e3ebdSchin 			break;
938da2e3ebdSchin 		case 'Q':
939da2e3ebdSchin 			value->ll = (Sflong_t)strelapsed(*pp->nextarg,&lastchar,1);
940da2e3ebdSchin 			break;
941da2e3ebdSchin 		case 'T':
942da2e3ebdSchin 			value->ll = (Sflong_t)tmxdate(*pp->nextarg,&lastchar,TMX_NOW);
943da2e3ebdSchin 			break;
944da2e3ebdSchin 		default:
945da2e3ebdSchin 			value->ll = 0;
946da2e3ebdSchin 			fe->fmt = 'd';
947da2e3ebdSchin 			fe->size = sizeof(value->ll);
948da2e3ebdSchin 			errormsg(SH_DICT,ERROR_exit(1),e_formspec,format);
949da2e3ebdSchin 			break;
950da2e3ebdSchin 		}
951da2e3ebdSchin 		if (format == '.')
952da2e3ebdSchin 			value->i = value->ll;
953da2e3ebdSchin 		if(*lastchar)
954da2e3ebdSchin 		{
955da2e3ebdSchin 			errormsg(SH_DICT,ERROR_warn(0),e_argtype,format);
956da2e3ebdSchin 			pp->err = 1;
957da2e3ebdSchin 		}
958da2e3ebdSchin 		pp->nextarg++;
959da2e3ebdSchin 	}
960da2e3ebdSchin 	switch(format)
961da2e3ebdSchin 	{
962da2e3ebdSchin 	case 'Z':
963da2e3ebdSchin 		fe->fmt = 'c';
964da2e3ebdSchin 		fe->base = -1;
965da2e3ebdSchin 		value->c = 0;
966da2e3ebdSchin 		break;
967da2e3ebdSchin 	case 'b':
968da2e3ebdSchin 		if((n=fmtvecho(value->s,pp))>=0)
969da2e3ebdSchin 		{
970da2e3ebdSchin 			if(pp->nextarg == nullarg)
971da2e3ebdSchin 			{
972da2e3ebdSchin 				pp->argsize = n;
973da2e3ebdSchin 				return -1;
974da2e3ebdSchin 			}
975da2e3ebdSchin 			value->s = stakptr(staktell());
976b30d1939SAndy Fiddaman 			fe->size = n;
977da2e3ebdSchin 		}
978da2e3ebdSchin 		break;
979da2e3ebdSchin 	case 'B':
980b30d1939SAndy Fiddaman 		if(!shp->strbuf2)
981b30d1939SAndy Fiddaman 			shp->strbuf2 = sfstropen();
982b30d1939SAndy Fiddaman 		fe->size = fmtbase64(shp->strbuf2,value->s, fe->flags&SFFMT_ALTER);
983b30d1939SAndy Fiddaman 		value->s = sfstruse(shp->strbuf2);
9847c2fbfb3SApril Chin 		fe->flags |= SFFMT_SHORT;
985da2e3ebdSchin 		break;
986da2e3ebdSchin 	case 'H':
987b30d1939SAndy Fiddaman 		value->s = fmthtml(value->s, fe->flags);
988da2e3ebdSchin 		break;
989da2e3ebdSchin 	case 'q':
990da2e3ebdSchin 		value->s = sh_fmtqf(value->s, !!(fe->flags & SFFMT_ALTER), fold);
991da2e3ebdSchin 		break;
992da2e3ebdSchin 	case 'P':
993b30d1939SAndy Fiddaman 		s = fmtmatch(value->s);
994da2e3ebdSchin 		if(!s || *s==0)
995da2e3ebdSchin 			errormsg(SH_DICT,ERROR_exit(1),e_badregexp,value->s);
996da2e3ebdSchin 		value->s = s;
997da2e3ebdSchin 		break;
998da2e3ebdSchin 	case 'R':
999b30d1939SAndy Fiddaman 		s = fmtre(value->s);
1000b30d1939SAndy Fiddaman 		if(!s || *s==0)
1001da2e3ebdSchin 			errormsg(SH_DICT,ERROR_exit(1),e_badregexp,value->s);
1002b30d1939SAndy Fiddaman 		value->s = s;
1003da2e3ebdSchin 		break;
1004da2e3ebdSchin 	case 'Q':
1005da2e3ebdSchin 		if (fe->n_str>0)
1006da2e3ebdSchin 		{
1007da2e3ebdSchin 			fe->fmt = 'd';
1008da2e3ebdSchin 			fe->size = sizeof(value->ll);
1009da2e3ebdSchin 		}
1010da2e3ebdSchin 		else
1011da2e3ebdSchin 		{
1012da2e3ebdSchin 			value->s = fmtelapsed(value->ll, 1);
1013da2e3ebdSchin 			fe->fmt = 's';
1014da2e3ebdSchin 			fe->size = -1;
1015da2e3ebdSchin 		}
1016da2e3ebdSchin 		break;
1017da2e3ebdSchin 	case 'T':
1018da2e3ebdSchin 		if(fe->n_str>0)
1019da2e3ebdSchin 		{
1020da2e3ebdSchin 			n = fe->t_str[fe->n_str];
1021da2e3ebdSchin 			fe->t_str[fe->n_str] = 0;
1022da2e3ebdSchin 			value->s = fmttmx(fe->t_str, value->ll);
1023da2e3ebdSchin 			fe->t_str[fe->n_str] = n;
1024da2e3ebdSchin 		}
1025da2e3ebdSchin 		else value->s = fmttmx(NIL(char*), value->ll);
1026da2e3ebdSchin 		fe->fmt = 's';
1027da2e3ebdSchin 		fe->size = -1;
1028da2e3ebdSchin 		break;
1029da2e3ebdSchin 	}
1030da2e3ebdSchin 	return 0;
1031da2e3ebdSchin }
1032da2e3ebdSchin 
1033da2e3ebdSchin /*
1034da2e3ebdSchin  * construct System V echo string out of <cp>
1035da2e3ebdSchin  * If there are not escape sequences, returns -1
1036da2e3ebdSchin  * Otherwise, puts null terminated result on stack, but doesn't freeze it
1037da2e3ebdSchin  * returns length of output.
1038da2e3ebdSchin  */
1039da2e3ebdSchin 
fmtvecho(const char * string,struct printf * pp)1040da2e3ebdSchin static int fmtvecho(const char *string, struct printf *pp)
1041da2e3ebdSchin {
1042da2e3ebdSchin 	register const char *cp = string, *cpmax;
1043da2e3ebdSchin 	register int c;
1044da2e3ebdSchin 	register int offset = staktell();
1045da2e3ebdSchin #if SHOPT_MULTIBYTE
1046da2e3ebdSchin 	int chlen;
1047da2e3ebdSchin 	if(mbwide())
1048da2e3ebdSchin 	{
1049da2e3ebdSchin 		while(1)
1050da2e3ebdSchin 		{
1051da2e3ebdSchin 			if ((chlen = mbsize(cp)) > 1)
1052da2e3ebdSchin 				/* Skip over multibyte characters */
1053da2e3ebdSchin 				cp += chlen;
1054da2e3ebdSchin 			else if((c= *cp++)==0 || c == '\\')
1055da2e3ebdSchin 				break;
1056da2e3ebdSchin 		}
1057da2e3ebdSchin 	}
1058da2e3ebdSchin 	else
1059da2e3ebdSchin #endif /* SHOPT_MULTIBYTE */
1060da2e3ebdSchin 	while((c= *cp++) && (c!='\\'));
1061da2e3ebdSchin 	if(c==0)
1062da2e3ebdSchin 		return(-1);
1063da2e3ebdSchin 	c = --cp - string;
1064da2e3ebdSchin 	if(c>0)
1065da2e3ebdSchin 		stakwrite((void*)string,c);
1066da2e3ebdSchin 	for(; c= *cp; cp++)
1067da2e3ebdSchin 	{
1068da2e3ebdSchin #if SHOPT_MULTIBYTE
1069da2e3ebdSchin 		if (mbwide() && ((chlen = mbsize(cp)) > 1))
1070da2e3ebdSchin 		{
1071da2e3ebdSchin 			stakwrite(cp,chlen);
1072da2e3ebdSchin 			cp +=  (chlen-1);
1073da2e3ebdSchin 			continue;
1074da2e3ebdSchin 		}
1075da2e3ebdSchin #endif /* SHOPT_MULTIBYTE */
1076da2e3ebdSchin 		if( c=='\\') switch(*++cp)
1077da2e3ebdSchin 		{
1078da2e3ebdSchin 			case 'E':
1079da2e3ebdSchin 				c = ('a'==97?'\033':39); /* ASCII/EBCDIC */
1080da2e3ebdSchin 				break;
1081da2e3ebdSchin 			case 'a':
1082da2e3ebdSchin 				c = '\a';
1083da2e3ebdSchin 				break;
1084da2e3ebdSchin 			case 'b':
1085da2e3ebdSchin 				c = '\b';
1086da2e3ebdSchin 				break;
1087da2e3ebdSchin 			case 'c':
1088da2e3ebdSchin 				pp->cescape++;
1089da2e3ebdSchin 				pp->nextarg = nullarg;
1090da2e3ebdSchin 				goto done;
1091da2e3ebdSchin 			case 'f':
1092da2e3ebdSchin 				c = '\f';
1093da2e3ebdSchin 				break;
1094da2e3ebdSchin 			case 'n':
1095da2e3ebdSchin 				c = '\n';
1096da2e3ebdSchin 				break;
1097da2e3ebdSchin 			case 'r':
1098da2e3ebdSchin 				c = '\r';
1099da2e3ebdSchin 				break;
1100da2e3ebdSchin 			case 'v':
1101da2e3ebdSchin 				c = '\v';
1102da2e3ebdSchin 				break;
1103da2e3ebdSchin 			case 't':
1104da2e3ebdSchin 				c = '\t';
1105da2e3ebdSchin 				break;
1106da2e3ebdSchin 			case '\\':
1107da2e3ebdSchin 				c = '\\';
1108da2e3ebdSchin 				break;
1109da2e3ebdSchin 			case '0':
1110da2e3ebdSchin 				c = 0;
1111da2e3ebdSchin 				cpmax = cp + 4;
1112da2e3ebdSchin 				while(++cp<cpmax && *cp>='0' && *cp<='7')
1113da2e3ebdSchin 				{
1114da2e3ebdSchin 					c <<= 3;
1115da2e3ebdSchin 					c |= (*cp-'0');
1116da2e3ebdSchin 				}
11175ae8bd53SToomas Soome 				/* FALLTHROUGH */
1118da2e3ebdSchin 			default:
1119da2e3ebdSchin 				cp--;
1120da2e3ebdSchin 		}
1121da2e3ebdSchin 		stakputc(c);
1122da2e3ebdSchin 	}
1123da2e3ebdSchin done:
1124da2e3ebdSchin 	c = staktell()-offset;
1125da2e3ebdSchin 	stakputc(0);
1126da2e3ebdSchin 	stakseek(offset);
1127da2e3ebdSchin 	return(c);
1128da2e3ebdSchin }
1129