expand.c@ 623

Last change on this file since 623 was 622, checked in by bird, 18 years ago
Current libc code (based on NetBSD sh 2005-07-03).
File size: 32.1 KB

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

Note: See TracBrowser for help on using the repository browser.

source: kBuild/trunk/src/ash/expand.c@ 623

Download in other formats: