Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

expand.c

Last change on this file was 3598, checked in by bird, 2 years ago
kash: Fixed bugs in cvtnum and cvtnum64 regarding the conversion of negative numbers.
Property svn:eol-style set to `LF` Property svn:keywords set to `Id`
File size: 34.0 KB

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

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

Context Navigation

source: trunk/src/kash/expand.c

Download in other formats: