expand.c revision 276363 
1/*-
2 * Copyright (c) 1991, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 * Copyright (c) 1997-2005
5 *	Herbert Xu <herbert@gondor.apana.org.au>.  All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * Kenneth Almquist.
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 * 4. 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#ifndef lint
36#if 0
37static char sccsid[] = "@(#)expand.c	8.5 (Berkeley) 5/15/95";
38#endif
39#endif /* not lint */
40#include <sys/cdefs.h>
41__FBSDID("$FreeBSD: stable/10/bin/sh/expand.c 276363 2014-12-29 15:11:07Z jilles $");
42
43#include <sys/types.h>
44#include <sys/time.h>
45#include <sys/stat.h>
46#include <dirent.h>
47#include <errno.h>
48#include <inttypes.h>
49#include <limits.h>
50#include <pwd.h>
51#include <stdio.h>
52#include <stdlib.h>
53#include <string.h>
54#include <unistd.h>
55#include <wchar.h>
56#include <wctype.h>
57
58/*
59 * Routines to expand arguments to commands.  We have to deal with
60 * backquotes, shell variables, and file metacharacters.
61 */
62
63#include "shell.h"
64#include "main.h"
65#include "nodes.h"
66#include "eval.h"
67#include "expand.h"
68#include "syntax.h"
69#include "parser.h"
70#include "jobs.h"
71#include "options.h"
72#include "var.h"
73#include "input.h"
74#include "output.h"
75#include "memalloc.h"
76#include "error.h"
77#include "mystring.h"
78#include "arith.h"
79#include "show.h"
80#include "builtins.h"
81
82/*
83 * Structure specifying which parts of the string should be searched
84 * for IFS characters.
85 */
86
87struct ifsregion {
88	struct ifsregion *next;	/* next region in list */
89	int begoff;		/* offset of start of region */
90	int endoff;		/* offset of end of region */
91	int inquotes;		/* search for nul bytes only */
92};
93
94
95static char *expdest;			/* output of current string */
96static struct nodelist *argbackq;	/* list of back quote expressions */
97static struct ifsregion ifsfirst;	/* first struct in list of ifs regions */
98static struct ifsregion *ifslastp;	/* last struct in list */
99static struct arglist exparg;		/* holds expanded arg list */
100
101static char *argstr(char *, int);
102static char *exptilde(char *, int);
103static char *expari(char *);
104static void expbackq(union node *, int, int);
105static int subevalvar(char *, char *, int, int, int, int, int);
106static char *evalvar(char *, int);
107static int varisset(const char *, int);
108static void varvalue(const char *, int, int, int);
109static void recordregion(int, int, int);
110static void removerecordregions(int);
111static void ifsbreakup(char *, struct arglist *);
112static void expandmeta(struct strlist *, int);
113static void expmeta(char *, char *);
114static void addfname(char *);
115static struct strlist *expsort(struct strlist *);
116static struct strlist *msort(struct strlist *, int);
117static int patmatch(const char *, const char *, int);
118static char *cvtnum(int, char *);
119static int collate_range_cmp(wchar_t, wchar_t);
120
121static int
122collate_range_cmp(wchar_t c1, wchar_t c2)
123{
124	static wchar_t s1[2], s2[2];
125
126	s1[0] = c1;
127	s2[0] = c2;
128	return (wcscoll(s1, s2));
129}
130
131static char *
132stputs_quotes(const char *data, const char *syntax, char *p)
133{
134	while (*data) {
135		CHECKSTRSPACE(2, p);
136		if (syntax[(int)*data] == CCTL)
137			USTPUTC(CTLESC, p);
138		USTPUTC(*data++, p);
139	}
140	return (p);
141}
142#define STPUTS_QUOTES(data, syntax, p) p = stputs_quotes((data), syntax, p)
143
144/*
145 * Perform expansions on an argument, placing the resulting list of arguments
146 * in arglist.  Parameter expansion, command substitution and arithmetic
147 * expansion are always performed; additional expansions can be requested
148 * via flag (EXP_*).
149 * The result is left in the stack string.
150 * When arglist is NULL, perform here document expansion.
151 *
152 * Caution: this function uses global state and is not reentrant.
153 * However, a new invocation after an interrupted invocation is safe
154 * and will reset the global state for the new call.
155 */
156void
157expandarg(union node *arg, struct arglist *arglist, int flag)
158{
159	struct strlist *sp;
160	char *p;
161
162	argbackq = arg->narg.backquote;
163	STARTSTACKSTR(expdest);
164	ifsfirst.next = NULL;
165	ifslastp = NULL;
166	argstr(arg->narg.text, flag);
167	if (arglist == NULL) {
168		STACKSTRNUL(expdest);
169		return;			/* here document expanded */
170	}
171	STPUTC('\0', expdest);
172	p = grabstackstr(expdest);
173	exparg.lastp = &exparg.list;
174	/*
175	 * TODO - EXP_REDIR
176	 */
177	if (flag & EXP_FULL) {
178		ifsbreakup(p, &exparg);
179		*exparg.lastp = NULL;
180		exparg.lastp = &exparg.list;
181		expandmeta(exparg.list, flag);
182	} else {
183		if (flag & EXP_REDIR) /*XXX - for now, just remove escapes */
184			rmescapes(p);
185		sp = (struct strlist *)stalloc(sizeof (struct strlist));
186		sp->text = p;
187		*exparg.lastp = sp;
188		exparg.lastp = &sp->next;
189	}
190	while (ifsfirst.next != NULL) {
191		struct ifsregion *ifsp;
192		INTOFF;
193		ifsp = ifsfirst.next->next;
194		ckfree(ifsfirst.next);
195		ifsfirst.next = ifsp;
196		INTON;
197	}
198	*exparg.lastp = NULL;
199	if (exparg.list) {
200		*arglist->lastp = exparg.list;
201		arglist->lastp = exparg.lastp;
202	}
203}
204
205
206
207/*
208 * Perform parameter expansion, command substitution and arithmetic
209 * expansion, and tilde expansion if requested via EXP_TILDE/EXP_VARTILDE.
210 * Processing ends at a CTLENDVAR or CTLENDARI character as well as '\0'.
211 * This is used to expand word in ${var+word} etc.
212 * If EXP_FULL, EXP_CASE or EXP_REDIR are set, keep and/or generate CTLESC
213 * characters to allow for further processing.
214 * If EXP_FULL is set, also preserve CTLQUOTEMARK characters.
215 */
216static char *
217argstr(char *p, int flag)
218{
219	char c;
220	int quotes = flag & (EXP_FULL | EXP_CASE | EXP_REDIR);	/* do CTLESC */
221	int firsteq = 1;
222	int split_lit;
223	int lit_quoted;
224
225	split_lit = flag & EXP_SPLIT_LIT;
226	lit_quoted = flag & EXP_LIT_QUOTED;
227	flag &= ~(EXP_SPLIT_LIT | EXP_LIT_QUOTED);
228	if (*p == '~' && (flag & (EXP_TILDE | EXP_VARTILDE)))
229		p = exptilde(p, flag);
230	for (;;) {
231		CHECKSTRSPACE(2, expdest);
232		switch (c = *p++) {
233		case '\0':
234			return (p - 1);
235		case CTLENDVAR:
236		case CTLENDARI:
237			return (p);
238		case CTLQUOTEMARK:
239			lit_quoted = 1;
240			/* "$@" syntax adherence hack */
241			if (p[0] == CTLVAR && p[2] == '@' && p[3] == '=')
242				break;
243			if ((flag & EXP_FULL) != 0)
244				USTPUTC(c, expdest);
245			break;
246		case CTLQUOTEEND:
247			lit_quoted = 0;
248			break;
249		case CTLESC:
250			if (quotes)
251				USTPUTC(c, expdest);
252			c = *p++;
253			USTPUTC(c, expdest);
254			if (split_lit && !lit_quoted)
255				recordregion(expdest - stackblock() -
256				    (quotes ? 2 : 1),
257				    expdest - stackblock(), 0);
258			break;
259		case CTLVAR:
260			p = evalvar(p, flag);
261			break;
262		case CTLBACKQ:
263		case CTLBACKQ|CTLQUOTE:
264			expbackq(argbackq->n, c & CTLQUOTE, flag);
265			argbackq = argbackq->next;
266			break;
267		case CTLARI:
268			p = expari(p);
269			break;
270		case ':':
271		case '=':
272			/*
273			 * sort of a hack - expand tildes in variable
274			 * assignments (after the first '=' and after ':'s).
275			 */
276			USTPUTC(c, expdest);
277			if (split_lit && !lit_quoted)
278				recordregion(expdest - stackblock() - 1,
279				    expdest - stackblock(), 0);
280			if (flag & EXP_VARTILDE && *p == '~' &&
281			    (c != '=' || firsteq)) {
282				if (c == '=')
283					firsteq = 0;
284				p = exptilde(p, flag);
285			}
286			break;
287		default:
288			USTPUTC(c, expdest);
289			if (split_lit && !lit_quoted)
290				recordregion(expdest - stackblock() - 1,
291				    expdest - stackblock(), 0);
292		}
293	}
294}
295
296/*
297 * Perform tilde expansion, placing the result in the stack string and
298 * returning the next position in the input string to process.
299 */
300static char *
301exptilde(char *p, int flag)
302{
303	char c, *startp = p;
304	struct passwd *pw;
305	char *home;
306	int quotes = flag & (EXP_FULL | EXP_CASE | EXP_REDIR);
307
308	while ((c = *p) != '\0') {
309		switch(c) {
310		case CTLESC: /* This means CTL* are always considered quoted. */
311		case CTLVAR:
312		case CTLBACKQ:
313		case CTLBACKQ | CTLQUOTE:
314		case CTLARI:
315		case CTLENDARI:
316		case CTLQUOTEMARK:
317			return (startp);
318		case ':':
319			if (flag & EXP_VARTILDE)
320				goto done;
321			break;
322		case '/':
323		case CTLENDVAR:
324			goto done;
325		}
326		p++;
327	}
328done:
329	*p = '\0';
330	if (*(startp+1) == '\0') {
331		if ((home = lookupvar("HOME")) == NULL)
332			goto lose;
333	} else {
334		if ((pw = getpwnam(startp+1)) == NULL)
335			goto lose;
336		home = pw->pw_dir;
337	}
338	if (*home == '\0')
339		goto lose;
340	*p = c;
341	if (quotes)
342		STPUTS_QUOTES(home, SQSYNTAX, expdest);
343	else
344		STPUTS(home, expdest);
345	return (p);
346lose:
347	*p = c;
348	return (startp);
349}
350
351
352static void
353removerecordregions(int endoff)
354{
355	if (ifslastp == NULL)
356		return;
357
358	if (ifsfirst.endoff > endoff) {
359		while (ifsfirst.next != NULL) {
360			struct ifsregion *ifsp;
361			INTOFF;
362			ifsp = ifsfirst.next->next;
363			ckfree(ifsfirst.next);
364			ifsfirst.next = ifsp;
365			INTON;
366		}
367		if (ifsfirst.begoff > endoff)
368			ifslastp = NULL;
369		else {
370			ifslastp = &ifsfirst;
371			ifsfirst.endoff = endoff;
372		}
373		return;
374	}
375
376	ifslastp = &ifsfirst;
377	while (ifslastp->next && ifslastp->next->begoff < endoff)
378		ifslastp=ifslastp->next;
379	while (ifslastp->next != NULL) {
380		struct ifsregion *ifsp;
381		INTOFF;
382		ifsp = ifslastp->next->next;
383		ckfree(ifslastp->next);
384		ifslastp->next = ifsp;
385		INTON;
386	}
387	if (ifslastp->endoff > endoff)
388		ifslastp->endoff = endoff;
389}
390
391/*
392 * Expand arithmetic expression.
393 * Note that flag is not required as digits never require CTLESC characters.
394 */
395static char *
396expari(char *p)
397{
398	char *q, *start;
399	arith_t result;
400	int begoff;
401	int quoted;
402	int adj;
403
404	quoted = *p++ == '"';
405	begoff = expdest - stackblock();
406	p = argstr(p, 0);
407	removerecordregions(begoff);
408	STPUTC('\0', expdest);
409	start = stackblock() + begoff;
410
411	q = grabstackstr(expdest);
412	result = arith(start);
413	ungrabstackstr(q, expdest);
414
415	start = stackblock() + begoff;
416	adj = start - expdest;
417	STADJUST(adj, expdest);
418
419	CHECKSTRSPACE((int)(DIGITS(result) + 1), expdest);
420	fmtstr(expdest, DIGITS(result), ARITH_FORMAT_STR, result);
421	adj = strlen(expdest);
422	STADJUST(adj, expdest);
423	if (!quoted)
424		recordregion(begoff, expdest - stackblock(), 0);
425	return p;
426}
427
428
429/*
430 * Perform command substitution.
431 */
432static void
433expbackq(union node *cmd, int quoted, int flag)
434{
435	struct backcmd in;
436	int i;
437	char buf[128];
438	char *p;
439	char *dest = expdest;
440	struct ifsregion saveifs, *savelastp;
441	struct nodelist *saveargbackq;
442	char lastc;
443	int startloc = dest - stackblock();
444	char const *syntax = quoted? DQSYNTAX : BASESYNTAX;
445	int quotes = flag & (EXP_FULL | EXP_CASE | EXP_REDIR);
446	size_t nnl;
447
448	INTOFF;
449	saveifs = ifsfirst;
450	savelastp = ifslastp;
451	saveargbackq = argbackq;
452	p = grabstackstr(dest);
453	evalbackcmd(cmd, &in);
454	ungrabstackstr(p, dest);
455	ifsfirst = saveifs;
456	ifslastp = savelastp;
457	argbackq = saveargbackq;
458
459	p = in.buf;
460	lastc = '\0';
461	nnl = 0;
462	/* Don't copy trailing newlines */
463	for (;;) {
464		if (--in.nleft < 0) {
465			if (in.fd < 0)
466				break;
467			while ((i = read(in.fd, buf, sizeof buf)) < 0 && errno == EINTR);
468			TRACE(("expbackq: read returns %d\n", i));
469			if (i <= 0)
470				break;
471			p = buf;
472			in.nleft = i - 1;
473		}
474		lastc = *p++;
475		if (lastc != '\0') {
476			if (lastc == '\n') {
477				nnl++;
478			} else {
479				CHECKSTRSPACE(nnl + 2, dest);
480				while (nnl > 0) {
481					nnl--;
482					USTPUTC('\n', dest);
483				}
484				if (quotes && syntax[(int)lastc] == CCTL)
485					USTPUTC(CTLESC, dest);
486				USTPUTC(lastc, dest);
487			}
488		}
489	}
490
491	if (in.fd >= 0)
492		close(in.fd);
493	if (in.buf)
494		ckfree(in.buf);
495	if (in.jp)
496		exitstatus = waitforjob(in.jp, (int *)NULL);
497	if (quoted == 0)
498		recordregion(startloc, dest - stackblock(), 0);
499	TRACE(("expbackq: size=%td: \"%.*s\"\n",
500		((dest - stackblock()) - startloc),
501		(int)((dest - stackblock()) - startloc),
502		stackblock() + startloc));
503	expdest = dest;
504	INTON;
505}
506
507
508
509static int
510subevalvar(char *p, char *str, int strloc, int subtype, int startloc,
511  int varflags, int quotes)
512{
513	char *startp;
514	char *loc = NULL;
515	char *q;
516	int c = 0;
517	struct nodelist *saveargbackq = argbackq;
518	int amount;
519
520	argstr(p, (subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX ||
521	    subtype == VSTRIMRIGHT || subtype == VSTRIMRIGHTMAX ?
522	    EXP_CASE : 0) | EXP_TILDE);
523	STACKSTRNUL(expdest);
524	argbackq = saveargbackq;
525	startp = stackblock() + startloc;
526	if (str == NULL)
527	    str = stackblock() + strloc;
528
529	switch (subtype) {
530	case VSASSIGN:
531		setvar(str, startp, 0);
532		amount = startp - expdest;
533		STADJUST(amount, expdest);
534		varflags &= ~VSNUL;
535		return 1;
536
537	case VSQUESTION:
538		if (*p != CTLENDVAR) {
539			outfmt(out2, "%s\n", startp);
540			error((char *)NULL);
541		}
542		error("%.*s: parameter %snot set", (int)(p - str - 1),
543		      str, (varflags & VSNUL) ? "null or "
544					      : nullstr);
545		return 0;
546
547	case VSTRIMLEFT:
548		for (loc = startp; loc < str; loc++) {
549			c = *loc;
550			*loc = '\0';
551			if (patmatch(str, startp, quotes)) {
552				*loc = c;
553				goto recordleft;
554			}
555			*loc = c;
556			if (quotes && *loc == CTLESC)
557				loc++;
558		}
559		return 0;
560
561	case VSTRIMLEFTMAX:
562		for (loc = str - 1; loc >= startp;) {
563			c = *loc;
564			*loc = '\0';
565			if (patmatch(str, startp, quotes)) {
566				*loc = c;
567				goto recordleft;
568			}
569			*loc = c;
570			loc--;
571			if (quotes && loc > startp && *(loc - 1) == CTLESC) {
572				for (q = startp; q < loc; q++)
573					if (*q == CTLESC)
574						q++;
575				if (q > loc)
576					loc--;
577			}
578		}
579		return 0;
580
581	case VSTRIMRIGHT:
582		for (loc = str - 1; loc >= startp;) {
583			if (patmatch(str, loc, quotes)) {
584				amount = loc - expdest;
585				STADJUST(amount, expdest);
586				return 1;
587			}
588			loc--;
589			if (quotes && loc > startp && *(loc - 1) == CTLESC) {
590				for (q = startp; q < loc; q++)
591					if (*q == CTLESC)
592						q++;
593				if (q > loc)
594					loc--;
595			}
596		}
597		return 0;
598
599	case VSTRIMRIGHTMAX:
600		for (loc = startp; loc < str - 1; loc++) {
601			if (patmatch(str, loc, quotes)) {
602				amount = loc - expdest;
603				STADJUST(amount, expdest);
604				return 1;
605			}
606			if (quotes && *loc == CTLESC)
607				loc++;
608		}
609		return 0;
610
611
612	default:
613		abort();
614	}
615
616recordleft:
617	amount = ((str - 1) - (loc - startp)) - expdest;
618	STADJUST(amount, expdest);
619	while (loc != str - 1)
620		*startp++ = *loc++;
621	return 1;
622}
623
624
625/*
626 * Expand a variable, and return a pointer to the next character in the
627 * input string.
628 */
629
630static char *
631evalvar(char *p, int flag)
632{
633	int subtype;
634	int varflags;
635	char *var;
636	const char *val;
637	int patloc;
638	int c;
639	int set;
640	int special;
641	int startloc;
642	int varlen;
643	int varlenb;
644	int easy;
645	int quotes = flag & (EXP_FULL | EXP_CASE | EXP_REDIR);
646
647	varflags = (unsigned char)*p++;
648	subtype = varflags & VSTYPE;
649	var = p;
650	special = 0;
651	if (! is_name(*p))
652		special = 1;
653	p = strchr(p, '=') + 1;
654again: /* jump here after setting a variable with ${var=text} */
655	if (varflags & VSLINENO) {
656		set = 1;
657		special = 1;
658		val = NULL;
659	} else if (special) {
660		set = varisset(var, varflags & VSNUL);
661		val = NULL;
662	} else {
663		val = bltinlookup(var, 1);
664		if (val == NULL || ((varflags & VSNUL) && val[0] == '\0')) {
665			val = NULL;
666			set = 0;
667		} else
668			set = 1;
669	}
670	varlen = 0;
671	startloc = expdest - stackblock();
672	if (!set && uflag && *var != '@' && *var != '*') {
673		switch (subtype) {
674		case VSNORMAL:
675		case VSTRIMLEFT:
676		case VSTRIMLEFTMAX:
677		case VSTRIMRIGHT:
678		case VSTRIMRIGHTMAX:
679		case VSLENGTH:
680			error("%.*s: parameter not set", (int)(p - var - 1),
681			    var);
682		}
683	}
684	if (set && subtype != VSPLUS) {
685		/* insert the value of the variable */
686		if (special) {
687			if (varflags & VSLINENO)
688				STPUTBIN(var, p - var - 1, expdest);
689			else
690				varvalue(var, varflags & VSQUOTE, subtype, flag);
691			if (subtype == VSLENGTH) {
692				varlenb = expdest - stackblock() - startloc;
693				varlen = varlenb;
694				if (localeisutf8) {
695					val = stackblock() + startloc;
696					for (;val != expdest; val++)
697						if ((*val & 0xC0) == 0x80)
698							varlen--;
699				}
700				STADJUST(-varlenb, expdest);
701			}
702		} else {
703			char const *syntax = (varflags & VSQUOTE) ? DQSYNTAX
704								  : BASESYNTAX;
705
706			if (subtype == VSLENGTH) {
707				for (;*val; val++)
708					if (!localeisutf8 ||
709					    (*val & 0xC0) != 0x80)
710						varlen++;
711			}
712			else {
713				if (quotes)
714					STPUTS_QUOTES(val, syntax, expdest);
715				else
716					STPUTS(val, expdest);
717
718			}
719		}
720	}
721
722	if (subtype == VSPLUS)
723		set = ! set;
724
725	easy = ((varflags & VSQUOTE) == 0 ||
726		(*var == '@' && shellparam.nparam != 1));
727
728
729	switch (subtype) {
730	case VSLENGTH:
731		expdest = cvtnum(varlen, expdest);
732		goto record;
733
734	case VSNORMAL:
735		if (!easy)
736			break;
737record:
738		recordregion(startloc, expdest - stackblock(),
739		    varflags & VSQUOTE || (ifsset() && ifsval()[0] == '\0' &&
740		    (*var == '@' || *var == '*')));
741		break;
742
743	case VSPLUS:
744	case VSMINUS:
745		if (!set) {
746			argstr(p, flag | (flag & EXP_FULL ? EXP_SPLIT_LIT : 0) |
747			    (varflags & VSQUOTE ? EXP_LIT_QUOTED : 0));
748			break;
749		}
750		if (easy)
751			goto record;
752		break;
753
754	case VSTRIMLEFT:
755	case VSTRIMLEFTMAX:
756	case VSTRIMRIGHT:
757	case VSTRIMRIGHTMAX:
758		if (!set)
759			break;
760		/*
761		 * Terminate the string and start recording the pattern
762		 * right after it
763		 */
764		STPUTC('\0', expdest);
765		patloc = expdest - stackblock();
766		if (subevalvar(p, NULL, patloc, subtype,
767		    startloc, varflags, quotes) == 0) {
768			int amount = (expdest - stackblock() - patloc) + 1;
769			STADJUST(-amount, expdest);
770		}
771		/* Remove any recorded regions beyond start of variable */
772		removerecordregions(startloc);
773		goto record;
774
775	case VSASSIGN:
776	case VSQUESTION:
777		if (!set) {
778			if (subevalvar(p, var, 0, subtype, startloc, varflags,
779			    quotes)) {
780				varflags &= ~VSNUL;
781				/*
782				 * Remove any recorded regions beyond
783				 * start of variable
784				 */
785				removerecordregions(startloc);
786				goto again;
787			}
788			break;
789		}
790		if (easy)
791			goto record;
792		break;
793
794	case VSERROR:
795		c = p - var - 1;
796		error("${%.*s%s}: Bad substitution", c, var,
797		    (c > 0 && *p != CTLENDVAR) ? "..." : "");
798
799	default:
800		abort();
801	}
802
803	if (subtype != VSNORMAL) {	/* skip to end of alternative */
804		int nesting = 1;
805		for (;;) {
806			if ((c = *p++) == CTLESC)
807				p++;
808			else if (c == CTLBACKQ || c == (CTLBACKQ|CTLQUOTE)) {
809				if (set)
810					argbackq = argbackq->next;
811			} else if (c == CTLVAR) {
812				if ((*p++ & VSTYPE) != VSNORMAL)
813					nesting++;
814			} else if (c == CTLENDVAR) {
815				if (--nesting == 0)
816					break;
817			}
818		}
819	}
820	return p;
821}
822
823
824
825/*
826 * Test whether a specialized variable is set.
827 */
828
829static int
830varisset(const char *name, int nulok)
831{
832
833	if (*name == '!')
834		return backgndpidset();
835	else if (*name == '@' || *name == '*') {
836		if (*shellparam.p == NULL)
837			return 0;
838
839		if (nulok) {
840			char **av;
841
842			for (av = shellparam.p; *av; av++)
843				if (**av != '\0')
844					return 1;
845			return 0;
846		}
847	} else if (is_digit(*name)) {
848		char *ap;
849		long num;
850
851		errno = 0;
852		num = strtol(name, NULL, 10);
853		if (errno != 0 || num > shellparam.nparam)
854			return 0;
855
856		if (num == 0)
857			ap = arg0;
858		else
859			ap = shellparam.p[num - 1];
860
861		if (nulok && (ap == NULL || *ap == '\0'))
862			return 0;
863	}
864	return 1;
865}
866
867static void
868strtodest(const char *p, int flag, int subtype, int quoted)
869{
870	if (flag & (EXP_FULL | EXP_CASE | EXP_REDIR) && subtype != VSLENGTH)
871		STPUTS_QUOTES(p, quoted ? DQSYNTAX : BASESYNTAX, expdest);
872	else
873		STPUTS(p, expdest);
874}
875
876/*
877 * Add the value of a specialized variable to the stack string.
878 */
879
880static void
881varvalue(const char *name, int quoted, int subtype, int flag)
882{
883	int num;
884	char *p;
885	int i;
886	char sep;
887	char **ap;
888
889	switch (*name) {
890	case '$':
891		num = rootpid;
892		goto numvar;
893	case '?':
894		num = oexitstatus;
895		goto numvar;
896	case '#':
897		num = shellparam.nparam;
898		goto numvar;
899	case '!':
900		num = backgndpidval();
901numvar:
902		expdest = cvtnum(num, expdest);
903		break;
904	case '-':
905		for (i = 0 ; i < NOPTS ; i++) {
906			if (optlist[i].val)
907				STPUTC(optlist[i].letter, expdest);
908		}
909		break;
910	case '@':
911		if (flag & EXP_FULL && quoted) {
912			for (ap = shellparam.p ; (p = *ap++) != NULL ; ) {
913				strtodest(p, flag, subtype, quoted);
914				if (*ap)
915					STPUTC('\0', expdest);
916			}
917			break;
918		}
919		/* FALLTHROUGH */
920	case '*':
921		if (ifsset())
922			sep = ifsval()[0];
923		else
924			sep = ' ';
925		for (ap = shellparam.p ; (p = *ap++) != NULL ; ) {
926			strtodest(p, flag, subtype, quoted);
927			if (!*ap)
928				break;
929			if (sep || (flag & EXP_FULL && !quoted && **ap != '\0'))
930				STPUTC(sep, expdest);
931		}
932		break;
933	case '0':
934		p = arg0;
935		strtodest(p, flag, subtype, quoted);
936		break;
937	default:
938		if (is_digit(*name)) {
939			num = atoi(name);
940			if (num > 0 && num <= shellparam.nparam) {
941				p = shellparam.p[num - 1];
942				strtodest(p, flag, subtype, quoted);
943			}
944		}
945		break;
946	}
947}
948
949
950
951/*
952 * Record the fact that we have to scan this region of the
953 * string for IFS characters.
954 */
955
956static void
957recordregion(int start, int end, int inquotes)
958{
959	struct ifsregion *ifsp;
960
961	INTOFF;
962	if (ifslastp == NULL) {
963		ifsp = &ifsfirst;
964	} else {
965		if (ifslastp->endoff == start
966		    && ifslastp->inquotes == inquotes) {
967			/* extend previous area */
968			ifslastp->endoff = end;
969			INTON;
970			return;
971		}
972		ifsp = (struct ifsregion *)ckmalloc(sizeof (struct ifsregion));
973		ifslastp->next = ifsp;
974	}
975	ifslastp = ifsp;
976	ifslastp->next = NULL;
977	ifslastp->begoff = start;
978	ifslastp->endoff = end;
979	ifslastp->inquotes = inquotes;
980	INTON;
981}
982
983
984
985/*
986 * Break the argument string into pieces based upon IFS and add the
987 * strings to the argument list.  The regions of the string to be
988 * searched for IFS characters have been stored by recordregion.
989 * CTLESC characters are preserved but have little effect in this pass
990 * other than escaping CTL* characters.  In particular, they do not escape
991 * IFS characters: that should be done with the ifsregion mechanism.
992 * CTLQUOTEMARK characters are used to preserve empty quoted strings.
993 * This pass treats them as a regular character, making the string non-empty.
994 * Later, they are removed along with the other CTL* characters.
995 */
996static void
997ifsbreakup(char *string, struct arglist *arglist)
998{
999	struct ifsregion *ifsp;
1000	struct strlist *sp;
1001	char *start;
1002	char *p;
1003	char *q;
1004	const char *ifs;
1005	const char *ifsspc;
1006	int had_param_ch = 0;
1007
1008	start = string;
1009
1010	if (ifslastp == NULL) {
1011		/* Return entire argument, IFS doesn't apply to any of it */
1012		sp = (struct strlist *)stalloc(sizeof *sp);
1013		sp->text = start;
1014		*arglist->lastp = sp;
1015		arglist->lastp = &sp->next;
1016		return;
1017	}
1018
1019	ifs = ifsset() ? ifsval() : " \t\n";
1020
1021	for (ifsp = &ifsfirst; ifsp != NULL; ifsp = ifsp->next) {
1022		p = string + ifsp->begoff;
1023		while (p < string + ifsp->endoff) {
1024			q = p;
1025			if (*p == CTLESC)
1026				p++;
1027			if (ifsp->inquotes) {
1028				/* Only NULs (should be from "$@") end args */
1029				had_param_ch = 1;
1030				if (*p != 0) {
1031					p++;
1032					continue;
1033				}
1034				ifsspc = NULL;
1035			} else {
1036				if (!strchr(ifs, *p)) {
1037					had_param_ch = 1;
1038					p++;
1039					continue;
1040				}
1041				ifsspc = strchr(" \t\n", *p);
1042
1043				/* Ignore IFS whitespace at start */
1044				if (q == start && ifsspc != NULL) {
1045					p++;
1046					start = p;
1047					continue;
1048				}
1049				had_param_ch = 0;
1050			}
1051
1052			/* Save this argument... */
1053			*q = '\0';
1054			sp = (struct strlist *)stalloc(sizeof *sp);
1055			sp->text = start;
1056			*arglist->lastp = sp;
1057			arglist->lastp = &sp->next;
1058			p++;
1059
1060			if (ifsspc != NULL) {
1061				/* Ignore further trailing IFS whitespace */
1062				for (; p < string + ifsp->endoff; p++) {
1063					q = p;
1064					if (*p == CTLESC)
1065						p++;
1066					if (strchr(ifs, *p) == NULL) {
1067						p = q;
1068						break;
1069					}
1070					if (strchr(" \t\n", *p) == NULL) {
1071						p++;
1072						break;
1073					}
1074				}
1075			}
1076			start = p;
1077		}
1078	}
1079
1080	/*
1081	 * Save anything left as an argument.
1082	 * Traditionally we have treated 'IFS=':'; set -- x$IFS' as
1083	 * generating 2 arguments, the second of which is empty.
1084	 * Some recent clarification of the Posix spec say that it
1085	 * should only generate one....
1086	 */
1087	if (had_param_ch || *start != 0) {
1088		sp = (struct strlist *)stalloc(sizeof *sp);
1089		sp->text = start;
1090		*arglist->lastp = sp;
1091		arglist->lastp = &sp->next;
1092	}
1093}
1094
1095
1096static char expdir[PATH_MAX];
1097#define expdir_end (expdir + sizeof(expdir))
1098
1099/*
1100 * Perform pathname generation and remove control characters.
1101 * At this point, the only control characters should be CTLESC and CTLQUOTEMARK.
1102 * The results are stored in the list exparg.
1103 */
1104static void
1105expandmeta(struct strlist *str, int flag __unused)
1106{
1107	char *p;
1108	struct strlist **savelastp;
1109	struct strlist *sp;
1110	char c;
1111	/* TODO - EXP_REDIR */
1112
1113	while (str) {
1114		if (fflag)
1115			goto nometa;
1116		p = str->text;
1117		for (;;) {			/* fast check for meta chars */
1118			if ((c = *p++) == '\0')
1119				goto nometa;
1120			if (c == '*' || c == '?' || c == '[')
1121				break;
1122		}
1123		savelastp = exparg.lastp;
1124		INTOFF;
1125		expmeta(expdir, str->text);
1126		INTON;
1127		if (exparg.lastp == savelastp) {
1128			/*
1129			 * no matches
1130			 */
1131nometa:
1132			*exparg.lastp = str;
1133			rmescapes(str->text);
1134			exparg.lastp = &str->next;
1135		} else {
1136			*exparg.lastp = NULL;
1137			*savelastp = sp = expsort(*savelastp);
1138			while (sp->next != NULL)
1139				sp = sp->next;
1140			exparg.lastp = &sp->next;
1141		}
1142		str = str->next;
1143	}
1144}
1145
1146
1147/*
1148 * Do metacharacter (i.e. *, ?, [...]) expansion.
1149 */
1150
1151static void
1152expmeta(char *enddir, char *name)
1153{
1154	const char *p;
1155	const char *q;
1156	const char *start;
1157	char *endname;
1158	int metaflag;
1159	struct stat statb;
1160	DIR *dirp;
1161	struct dirent *dp;
1162	int atend;
1163	int matchdot;
1164	int esc;
1165	int namlen;
1166
1167	metaflag = 0;
1168	start = name;
1169	for (p = name; esc = 0, *p; p += esc + 1) {
1170		if (*p == '*' || *p == '?')
1171			metaflag = 1;
1172		else if (*p == '[') {
1173			q = p + 1;
1174			if (*q == '!' || *q == '^')
1175				q++;
1176			for (;;) {
1177				while (*q == CTLQUOTEMARK)
1178					q++;
1179				if (*q == CTLESC)
1180					q++;
1181				if (*q == '/' || *q == '\0')
1182					break;
1183				if (*++q == ']') {
1184					metaflag = 1;
1185					break;
1186				}
1187			}
1188		} else if (*p == '\0')
1189			break;
1190		else if (*p == CTLQUOTEMARK)
1191			continue;
1192		else {
1193			if (*p == CTLESC)
1194				esc++;
1195			if (p[esc] == '/') {
1196				if (metaflag)
1197					break;
1198				start = p + esc + 1;
1199			}
1200		}
1201	}
1202	if (metaflag == 0) {	/* we've reached the end of the file name */
1203		if (enddir != expdir)
1204			metaflag++;
1205		for (p = name ; ; p++) {
1206			if (*p == CTLQUOTEMARK)
1207				continue;
1208			if (*p == CTLESC)
1209				p++;
1210			*enddir++ = *p;
1211			if (*p == '\0')
1212				break;
1213			if (enddir == expdir_end)
1214				return;
1215		}
1216		if (metaflag == 0 || lstat(expdir, &statb) >= 0)
1217			addfname(expdir);
1218		return;
1219	}
1220	endname = name + (p - name);
1221	if (start != name) {
1222		p = name;
1223		while (p < start) {
1224			while (*p == CTLQUOTEMARK)
1225				p++;
1226			if (*p == CTLESC)
1227				p++;
1228			*enddir++ = *p++;
1229			if (enddir == expdir_end)
1230				return;
1231		}
1232	}
1233	if (enddir == expdir) {
1234		p = ".";
1235	} else if (enddir == expdir + 1 && *expdir == '/') {
1236		p = "/";
1237	} else {
1238		p = expdir;
1239		enddir[-1] = '\0';
1240	}
1241	if ((dirp = opendir(p)) == NULL)
1242		return;
1243	if (enddir != expdir)
1244		enddir[-1] = '/';
1245	if (*endname == 0) {
1246		atend = 1;
1247	} else {
1248		atend = 0;
1249		*endname = '\0';
1250		endname += esc + 1;
1251	}
1252	matchdot = 0;
1253	p = start;
1254	while (*p == CTLQUOTEMARK)
1255		p++;
1256	if (*p == CTLESC)
1257		p++;
1258	if (*p == '.')
1259		matchdot++;
1260	while (! int_pending() && (dp = readdir(dirp)) != NULL) {
1261		if (dp->d_name[0] == '.' && ! matchdot)
1262			continue;
1263		if (patmatch(start, dp->d_name, 0)) {
1264			namlen = dp->d_namlen;
1265			if (enddir + namlen + 1 > expdir_end)
1266				continue;
1267			memcpy(enddir, dp->d_name, namlen + 1);
1268			if (atend)
1269				addfname(expdir);
1270			else {
1271				if (dp->d_type != DT_UNKNOWN &&
1272				    dp->d_type != DT_DIR &&
1273				    dp->d_type != DT_LNK)
1274					continue;
1275				if (enddir + namlen + 2 > expdir_end)
1276					continue;
1277				enddir[namlen] = '/';
1278				enddir[namlen + 1] = '\0';
1279				expmeta(enddir + namlen + 1, endname);
1280			}
1281		}
1282	}
1283	closedir(dirp);
1284	if (! atend)
1285		endname[-esc - 1] = esc ? CTLESC : '/';
1286}
1287
1288
1289/*
1290 * Add a file name to the list.
1291 */
1292
1293static void
1294addfname(char *name)
1295{
1296	char *p;
1297	struct strlist *sp;
1298	size_t len;
1299
1300	len = strlen(name);
1301	p = stalloc(len + 1);
1302	memcpy(p, name, len + 1);
1303	sp = (struct strlist *)stalloc(sizeof *sp);
1304	sp->text = p;
1305	*exparg.lastp = sp;
1306	exparg.lastp = &sp->next;
1307}
1308
1309
1310/*
1311 * Sort the results of file name expansion.  It calculates the number of
1312 * strings to sort and then calls msort (short for merge sort) to do the
1313 * work.
1314 */
1315
1316static struct strlist *
1317expsort(struct strlist *str)
1318{
1319	int len;
1320	struct strlist *sp;
1321
1322	len = 0;
1323	for (sp = str ; sp ; sp = sp->next)
1324		len++;
1325	return msort(str, len);
1326}
1327
1328
1329static struct strlist *
1330msort(struct strlist *list, int len)
1331{
1332	struct strlist *p, *q = NULL;
1333	struct strlist **lpp;
1334	int half;
1335	int n;
1336
1337	if (len <= 1)
1338		return list;
1339	half = len >> 1;
1340	p = list;
1341	for (n = half ; --n >= 0 ; ) {
1342		q = p;
1343		p = p->next;
1344	}
1345	q->next = NULL;			/* terminate first half of list */
1346	q = msort(list, half);		/* sort first half of list */
1347	p = msort(p, len - half);		/* sort second half */
1348	lpp = &list;
1349	for (;;) {
1350		if (strcmp(p->text, q->text) < 0) {
1351			*lpp = p;
1352			lpp = &p->next;
1353			if ((p = *lpp) == NULL) {
1354				*lpp = q;
1355				break;
1356			}
1357		} else {
1358			*lpp = q;
1359			lpp = &q->next;
1360			if ((q = *lpp) == NULL) {
1361				*lpp = p;
1362				break;
1363			}
1364		}
1365	}
1366	return list;
1367}
1368
1369
1370
1371static wchar_t
1372get_wc(const char **p)
1373{
1374	wchar_t c;
1375	int chrlen;
1376
1377	chrlen = mbtowc(&c, *p, 4);
1378	if (chrlen == 0)
1379		return 0;
1380	else if (chrlen == -1)
1381		c = 0;
1382	else
1383		*p += chrlen;
1384	return c;
1385}
1386
1387
1388/*
1389 * See if a character matches a character class, starting at the first colon
1390 * of "[:class:]".
1391 * If a valid character class is recognized, a pointer to the next character
1392 * after the final closing bracket is stored into *end, otherwise a null
1393 * pointer is stored into *end.
1394 */
1395static int
1396match_charclass(const char *p, wchar_t chr, const char **end)
1397{
1398	char name[20];
1399	const char *nameend;
1400	wctype_t cclass;
1401
1402	*end = NULL;
1403	p++;
1404	nameend = strstr(p, ":]");
1405	if (nameend == NULL || (size_t)(nameend - p) >= sizeof(name) ||
1406	    nameend == p)
1407		return 0;
1408	memcpy(name, p, nameend - p);
1409	name[nameend - p] = '\0';
1410	*end = nameend + 2;
1411	cclass = wctype(name);
1412	/* An unknown class matches nothing but is valid nevertheless. */
1413	if (cclass == 0)
1414		return 0;
1415	return iswctype(chr, cclass);
1416}
1417
1418
1419/*
1420 * Returns true if the pattern matches the string.
1421 */
1422
1423static int
1424patmatch(const char *pattern, const char *string, int squoted)
1425{
1426	const char *p, *q, *end;
1427	const char *bt_p, *bt_q;
1428	char c;
1429	wchar_t wc, wc2;
1430
1431	p = pattern;
1432	q = string;
1433	bt_p = NULL;
1434	bt_q = NULL;
1435	for (;;) {
1436		switch (c = *p++) {
1437		case '\0':
1438			if (*q != '\0')
1439				goto backtrack;
1440			return 1;
1441		case CTLESC:
1442			if (squoted && *q == CTLESC)
1443				q++;
1444			if (*q++ != *p++)
1445				goto backtrack;
1446			break;
1447		case CTLQUOTEMARK:
1448			continue;
1449		case '?':
1450			if (squoted && *q == CTLESC)
1451				q++;
1452			if (*q == '\0')
1453				return 0;
1454			if (localeisutf8) {
1455				wc = get_wc(&q);
1456				/*
1457				 * A '?' does not match invalid UTF-8 but a
1458				 * '*' does, so backtrack.
1459				 */
1460				if (wc == 0)
1461					goto backtrack;
1462			} else
1463				wc = (unsigned char)*q++;
1464			break;
1465		case '*':
1466			c = *p;
1467			while (c == CTLQUOTEMARK || c == '*')
1468				c = *++p;
1469			/*
1470			 * If the pattern ends here, we know the string
1471			 * matches without needing to look at the rest of it.
1472			 */
1473			if (c == '\0')
1474				return 1;
1475			/*
1476			 * First try the shortest match for the '*' that
1477			 * could work. We can forget any earlier '*' since
1478			 * there is no way having it match more characters
1479			 * can help us, given that we are already here.
1480			 */
1481			bt_p = p;
1482			bt_q = q;
1483			break;
1484		case '[': {
1485			const char *endp;
1486			int invert, found;
1487			wchar_t chr;
1488
1489			endp = p;
1490			if (*endp == '!' || *endp == '^')
1491				endp++;
1492			for (;;) {
1493				while (*endp == CTLQUOTEMARK)
1494					endp++;
1495				if (*endp == 0)
1496					goto dft;		/* no matching ] */
1497				if (*endp == CTLESC)
1498					endp++;
1499				if (*++endp == ']')
1500					break;
1501			}
1502			invert = 0;
1503			if (*p == '!' || *p == '^') {
1504				invert++;
1505				p++;
1506			}
1507			found = 0;
1508			if (squoted && *q == CTLESC)
1509				q++;
1510			if (*q == '\0')
1511				return 0;
1512			if (localeisutf8) {
1513				chr = get_wc(&q);
1514				if (chr == 0)
1515					goto backtrack;
1516			} else
1517				chr = (unsigned char)*q++;
1518			c = *p++;
1519			do {
1520				if (c == CTLQUOTEMARK)
1521					continue;
1522				if (c == '[' && *p == ':') {
1523					found |= match_charclass(p, chr, &end);
1524					if (end != NULL)
1525						p = end;
1526				}
1527				if (c == CTLESC)
1528					c = *p++;
1529				if (localeisutf8 && c & 0x80) {
1530					p--;
1531					wc = get_wc(&p);
1532					if (wc == 0) /* bad utf-8 */
1533						return 0;
1534				} else
1535					wc = (unsigned char)c;
1536				if (*p == '-' && p[1] != ']') {
1537					p++;
1538					while (*p == CTLQUOTEMARK)
1539						p++;
1540					if (*p == CTLESC)
1541						p++;
1542					if (localeisutf8) {
1543						wc2 = get_wc(&p);
1544						if (wc2 == 0) /* bad utf-8 */
1545							return 0;
1546					} else
1547						wc2 = (unsigned char)*p++;
1548					if (   collate_range_cmp(chr, wc) >= 0
1549					    && collate_range_cmp(chr, wc2) <= 0
1550					   )
1551						found = 1;
1552				} else {
1553					if (chr == wc)
1554						found = 1;
1555				}
1556			} while ((c = *p++) != ']');
1557			if (found == invert)
1558				goto backtrack;
1559			break;
1560		}
1561dft:	        default:
1562			if (squoted && *q == CTLESC)
1563				q++;
1564			if (*q == '\0')
1565				return 0;
1566			if (*q++ == c)
1567				break;
1568backtrack:
1569			/*
1570			 * If we have a mismatch (other than hitting the end
1571			 * of the string), go back to the last '*' seen and
1572			 * have it match one additional character.
1573			 */
1574			if (bt_p == NULL)
1575				return 0;
1576			if (squoted && *bt_q == CTLESC)
1577				bt_q++;
1578			if (*bt_q == '\0')
1579				return 0;
1580			bt_q++;
1581			p = bt_p;
1582			q = bt_q;
1583			break;
1584		}
1585	}
1586}
1587
1588
1589
1590/*
1591 * Remove any CTLESC and CTLQUOTEMARK characters from a string.
1592 */
1593
1594void
1595rmescapes(char *str)
1596{
1597	char *p, *q;
1598
1599	p = str;
1600	while (*p != CTLESC && *p != CTLQUOTEMARK && *p != CTLQUOTEEND) {
1601		if (*p++ == '\0')
1602			return;
1603	}
1604	q = p;
1605	while (*p) {
1606		if (*p == CTLQUOTEMARK || *p == CTLQUOTEEND) {
1607			p++;
1608			continue;
1609		}
1610		if (*p == CTLESC)
1611			p++;
1612		*q++ = *p++;
1613	}
1614	*q = '\0';
1615}
1616
1617
1618
1619/*
1620 * See if a pattern matches in a case statement.
1621 */
1622
1623int
1624casematch(union node *pattern, const char *val)
1625{
1626	struct stackmark smark;
1627	int result;
1628	char *p;
1629
1630	setstackmark(&smark);
1631	argbackq = pattern->narg.backquote;
1632	STARTSTACKSTR(expdest);
1633	ifslastp = NULL;
1634	argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
1635	STPUTC('\0', expdest);
1636	p = grabstackstr(expdest);
1637	result = patmatch(p, val, 0);
1638	popstackmark(&smark);
1639	return result;
1640}
1641
1642/*
1643 * Our own itoa().
1644 */
1645
1646static char *
1647cvtnum(int num, char *buf)
1648{
1649	char temp[32];
1650	int neg = num < 0;
1651	char *p = temp + 31;
1652
1653	temp[31] = '\0';
1654
1655	do {
1656		*--p = num % 10 + '0';
1657	} while ((num /= 10) != 0);
1658
1659	if (neg)
1660		*--p = '-';
1661
1662	STPUTS(p, buf);
1663	return buf;
1664}
1665
1666/*
1667 * Do most of the work for wordexp(3).
1668 */
1669
1670int
1671wordexpcmd(int argc, char **argv)
1672{
1673	size_t len;
1674	int i;
1675
1676	out1fmt("%08x", argc - 1);
1677	for (i = 1, len = 0; i < argc; i++)
1678		len += strlen(argv[i]);
1679	out1fmt("%08x", (int)len);
1680	for (i = 1; i < argc; i++)
1681		outbin(argv[i], strlen(argv[i]) + 1, out1);
1682        return (0);
1683}
1684