Context Navigation

source: mainline/uspace/app/ash/parser.c@ 8ccd2ea

Visit:

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export

Last change on this file since 8ccd2ea was c28a023, checked in by Josef Cejka <malyzelenyhnus@…>, 17 years ago
Initial commit of ash shell. It cannot be compiled yet.
Property mode set to `100644`
File size: 33.1 KB

Rev	Line
[c28a023]	1	/* $NetBSD: parser.c,v 1.45 2000/07/27 04:09:27 cgd 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. All advertising materials mentioning features or use of this software
	19	* must display the following acknowledgement:
	20	* This product includes software developed by the University of
	21	* California, Berkeley and its contributors.
	22	* 4. Neither the name of the University nor the names of its contributors
	23	* may be used to endorse or promote products derived from this software
	24	* without specific prior written permission.
	25	*
	26	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	27	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	28	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	29	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	30	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	31	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	32	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	33	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	34	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	35	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	36	* SUCH DAMAGE.
	37	*/
	38
	39	#include <sys/cdefs.h>
	40	#ifndef lint
	41	#if 0
	42	static char sccsid[] = "@(#)parser.c 8.7 (Berkeley) 5/16/95";
	43	#else
	44	__RCSID("$NetBSD: parser.c,v 1.45 2000/07/27 04:09:27 cgd Exp $");
	45	#endif
	46	#endif /* not lint */
	47
	48	#include <stdlib.h>
	49
	50	#include "shell.h"
	51	#include "parser.h"
	52	#include "nodes.h"
	53	#include "expand.h" /* defines rmescapes() */
	54	#include "redir.h" /* defines copyfd() */
	55	#include "syntax.h"
	56	#include "options.h"
	57	#include "input.h"
	58	#include "output.h"
	59	#include "var.h"
	60	#include "error.h"
	61	#include "memalloc.h"
	62	#include "mystring.h"
	63	#include "alias.h"
	64	#include "show.h"
	65	#ifndef SMALL
	66	#include "myhistedit.h"
	67	#endif
	68
	69	/*
	70	* Shell command parser.
	71	*/
	72
	73	#define EOFMARKLEN 79
	74
	75	/* values returned by readtoken */
	76	#include "token.h"
	77
	78
	79
	80	struct heredoc {
	81	struct heredoc next; / next here document in list */
	82	union node here; / redirection node */
	83	char eofmark; / string indicating end of input */
	84	int striptabs; /* if set, strip leading tabs */
	85	};
	86
	87
	88
	89	struct heredoc heredoclist; / list of here documents to read */
	90	int parsebackquote; /* nonzero if we are inside backquotes */
	91	int doprompt; /* if set, prompt the user */
	92	int needprompt; /* true if interactive and at start of line */
	93	int lasttoken; /* last token read */
	94	MKINIT int tokpushback; /* last token pushed back */
	95	char wordtext; / text of last word returned by readtoken */
	96	MKINIT int checkkwd; /* 1 == check for kwds, 2 == also eat newlines */
	97	struct nodelist *backquotelist;
	98	union node *redirnode;
	99	struct heredoc *heredoc;
	100	int quoteflag; /* set if (part of) last token was quoted */
	101	int startlinno; /* line # where last token started */
	102
	103
	104	STATIC union node *list (int);
	105	STATIC union node *andor (void);
	106	STATIC union node *pipeline (void);
	107	STATIC union node *command (void);
	108	STATIC union node simplecmd (union node , union node );
	109	STATIC union node *makename (void);
	110	STATIC void parsefname (void);
	111	STATIC void parseheredoc (void);
	112	STATIC int peektoken (void);
	113	STATIC int readtoken (void);
	114	STATIC int xxreadtoken (void);
	115	STATIC int readtoken1 (int, char const , char , int);
	116	STATIC int noexpand (char *);
	117	STATIC void synexpect (int) __attribute__((noreturn));
	118	STATIC void synerror (const char *) __attribute__((noreturn));
	119	STATIC void setprompt (int);
	120
	121
	122	/*
	123	* Read and parse a command. Returns NEOF on end of file. (NULL is a
	124	* valid parse tree indicating a blank line.)
	125	*/
	126
	127	union node *
	128	parsecmd(int interact)
	129	{
	130	int t;
	131
	132	doprompt = interact;
	133	if (doprompt)
	134	setprompt(1);
	135	else
	136	setprompt(0);
	137	needprompt = 0;
	138	t = readtoken();
	139	if (t == TEOF)
	140	return NEOF;
	141	if (t == TNL)
	142	return NULL;
	143	tokpushback++;
	144	return list(1);
	145	}
	146
	147
	148	STATIC union node *
	149	list(nlflag)
	150	int nlflag;
	151	{
	152	union node n1, n2, *n3;
	153	int tok;
	154
	155	checkkwd = 2;
	156	if (nlflag == 0 && tokendlist[peektoken()])
	157	return NULL;
	158	n1 = NULL;
	159	for (;;) {
	160	n2 = andor();
	161	tok = readtoken();
	162	if (tok == TBACKGND) {
	163	if (n2->type == NCMD \|\| n2->type == NPIPE) {
	164	n2->ncmd.backgnd = 1;
	165	} else if (n2->type == NREDIR) {
	166	n2->type = NBACKGND;
	167	} else {
	168	n3 = (union node *)stalloc(sizeof (struct nredir));
	169	n3->type = NBACKGND;
	170	n3->nredir.n = n2;
	171	n3->nredir.redirect = NULL;
	172	n2 = n3;
	173	}
	174	}
	175	if (n1 == NULL) {
	176	n1 = n2;
	177	}
	178	else {
	179	n3 = (union node *)stalloc(sizeof (struct nbinary));
	180	n3->type = NSEMI;
	181	n3->nbinary.ch1 = n1;
	182	n3->nbinary.ch2 = n2;
	183	n1 = n3;
	184	}
	185	switch (tok) {
	186	case TBACKGND:
	187	case TSEMI:
	188	tok = readtoken();
	189	/* fall through */
	190	case TNL:
	191	if (tok == TNL) {
	192	parseheredoc();
	193	if (nlflag)
	194	return n1;
	195	} else {
	196	tokpushback++;
	197	}
	198	checkkwd = 2;
	199	if (tokendlist[peektoken()])
	200	return n1;
	201	break;
	202	case TEOF:
	203	if (heredoclist)
	204	parseheredoc();
	205	else
	206	pungetc(); /* push back EOF on input */
	207	return n1;
	208	default:
	209	if (nlflag)
	210	synexpect(-1);
	211	tokpushback++;
	212	return n1;
	213	}
	214	}
	215	}
	216
	217
	218
	219	STATIC union node *
	220	andor() {
	221	union node n1, n2, *n3;
	222	int t;
	223
	224	checkkwd = 1;
	225	n1 = pipeline();
	226	for (;;) {
	227	if ((t = readtoken()) == TAND) {
	228	t = NAND;
	229	} else if (t == TOR) {
	230	t = NOR;
	231	} else {
	232	tokpushback++;
	233	return n1;
	234	}
	235	checkkwd = 2;
	236	n2 = pipeline();
	237	n3 = (union node *)stalloc(sizeof (struct nbinary));
	238	n3->type = t;
	239	n3->nbinary.ch1 = n1;
	240	n3->nbinary.ch2 = n2;
	241	n1 = n3;
	242	}
	243	}
	244
	245
	246
	247	STATIC union node *
	248	pipeline() {
	249	union node n1, n2, *pipenode;
	250	struct nodelist lp, prev;
	251	int negate;
	252
	253	negate = 0;
	254	TRACE(("pipeline: entered\n"));
	255	if (readtoken() == TNOT) {
	256	negate = !negate;
	257	checkkwd = 1;
	258	} else
	259	tokpushback++;
	260	n1 = command();
	261	if (readtoken() == TPIPE) {
	262	pipenode = (union node *)stalloc(sizeof (struct npipe));
	263	pipenode->type = NPIPE;
	264	pipenode->npipe.backgnd = 0;
	265	lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
	266	pipenode->npipe.cmdlist = lp;
	267	lp->n = n1;
	268	do {
	269	prev = lp;
	270	lp = (struct nodelist *)stalloc(sizeof (struct nodelist));
	271	checkkwd = 2;
	272	lp->n = command();
	273	prev->next = lp;
	274	} while (readtoken() == TPIPE);
	275	lp->next = NULL;
	276	n1 = pipenode;
	277	}
	278	tokpushback++;
	279	if (negate) {
	280	n2 = (union node *)stalloc(sizeof (struct nnot));
	281	n2->type = NNOT;
	282	n2->nnot.com = n1;
	283	return n2;
	284	} else
	285	return n1;
	286	}
	287
	288
	289
	290	STATIC union node *
	291	command() {
	292	union node n1, n2;
	293	union node ap, *app;
	294	union node cp, *cpp;
	295	union node redir, *rpp;
	296	int t;
	297
	298	redir = NULL;
	299	n1 = NULL;
	300	rpp = &redir;
	301
	302	/* Check for redirection which may precede command */
	303	while (readtoken() == TREDIR) {
	304	*rpp = n2 = redirnode;
	305	rpp = &n2->nfile.next;
	306	parsefname();
	307	}
	308	tokpushback++;
	309
	310	switch (readtoken()) {
	311	case TIF:
	312	n1 = (union node *)stalloc(sizeof (struct nif));
	313	n1->type = NIF;
	314	n1->nif.test = list(0);
	315	if (readtoken() != TTHEN)
	316	synexpect(TTHEN);
	317	n1->nif.ifpart = list(0);
	318	n2 = n1;
	319	while (readtoken() == TELIF) {
	320	n2->nif.elsepart = (union node *)stalloc(sizeof (struct nif));
	321	n2 = n2->nif.elsepart;
	322	n2->type = NIF;
	323	n2->nif.test = list(0);
	324	if (readtoken() != TTHEN)
	325	synexpect(TTHEN);
	326	n2->nif.ifpart = list(0);
	327	}
	328	if (lasttoken == TELSE)
	329	n2->nif.elsepart = list(0);
	330	else {
	331	n2->nif.elsepart = NULL;
	332	tokpushback++;
	333	}
	334	if (readtoken() != TFI)
	335	synexpect(TFI);
	336	checkkwd = 1;
	337	break;
	338	case TWHILE:
	339	case TUNTIL: {
	340	int got;
	341	n1 = (union node *)stalloc(sizeof (struct nbinary));
	342	n1->type = (lasttoken == TWHILE)? NWHILE : NUNTIL;
	343	n1->nbinary.ch1 = list(0);
	344	if ((got=readtoken()) != TDO) {
	345	TRACE(("expecting DO got %s %s\n", tokname[got], got == TWORD ? wordtext : ""));
	346	synexpect(TDO);
	347	}
	348	n1->nbinary.ch2 = list(0);
	349	if (readtoken() != TDONE)
	350	synexpect(TDONE);
	351	checkkwd = 1;
	352	break;
	353	}
	354	case TFOR:
	355	if (readtoken() != TWORD \|\| quoteflag \|\| ! goodname(wordtext))
	356	synerror("Bad for loop variable");
	357	n1 = (union node *)stalloc(sizeof (struct nfor));
	358	n1->type = NFOR;
	359	n1->nfor.var = wordtext;
	360	if (readtoken() == TWORD && ! quoteflag && equal(wordtext, "in")) {
	361	app = ≈
	362	while (readtoken() == TWORD) {
	363	n2 = (union node *)stalloc(sizeof (struct narg));
	364	n2->type = NARG;
	365	n2->narg.text = wordtext;
	366	n2->narg.backquote = backquotelist;
	367	*app = n2;
	368	app = &n2->narg.next;
	369	}
	370	*app = NULL;
	371	n1->nfor.args = ap;
	372	if (lasttoken != TNL && lasttoken != TSEMI)
	373	synexpect(-1);
	374	} else {
	375	static char argvars[5] = {CTLVAR, VSNORMAL\|VSQUOTE,
	376	'@', '=', '\0'};
	377	n2 = (union node *)stalloc(sizeof (struct narg));
	378	n2->type = NARG;
	379	n2->narg.text = argvars;
	380	n2->narg.backquote = NULL;
	381	n2->narg.next = NULL;
	382	n1->nfor.args = n2;
	383	/*
	384	* Newline or semicolon here is optional (but note
	385	* that the original Bourne shell only allowed NL).
	386	*/
	387	if (lasttoken != TNL && lasttoken != TSEMI)
	388	tokpushback++;
	389	}
	390	checkkwd = 2;
	391	if ((t = readtoken()) == TDO)
	392	t = TDONE;
	393	else if (t == TBEGIN)
	394	t = TEND;
	395	else
	396	synexpect(-1);
	397	n1->nfor.body = list(0);
	398	if (readtoken() != t)
	399	synexpect(t);
	400	checkkwd = 1;
	401	break;
	402	case TCASE:
	403	n1 = (union node *)stalloc(sizeof (struct ncase));
	404	n1->type = NCASE;
	405	if (readtoken() != TWORD)
	406	synexpect(TWORD);
	407	n1->ncase.expr = n2 = (union node *)stalloc(sizeof (struct narg));
	408	n2->type = NARG;
	409	n2->narg.text = wordtext;
	410	n2->narg.backquote = backquotelist;
	411	n2->narg.next = NULL;
	412	while (readtoken() == TNL);
	413	if (lasttoken != TWORD \|\| ! equal(wordtext, "in"))
	414	synerror("expecting \"in\"");
	415	cpp = &n1->ncase.cases;
	416	checkkwd = 2, readtoken();
	417	do {
	418	if (lasttoken == TLP)
	419	readtoken();
	420	cpp = cp = (union node )stalloc(sizeof (struct nclist));
	421	cp->type = NCLIST;
	422	app = &cp->nclist.pattern;
	423	for (;;) {
	424	app = ap = (union node )stalloc(sizeof (struct narg));
	425	ap->type = NARG;
	426	ap->narg.text = wordtext;
	427	ap->narg.backquote = backquotelist;
	428	if (checkkwd = 2, readtoken() != TPIPE)
	429	break;
	430	app = &ap->narg.next;
	431	readtoken();
	432	}
	433	ap->narg.next = NULL;
	434	if (lasttoken != TRP)
	435	synexpect(TRP);
	436	cp->nclist.body = list(0);
	437
	438	checkkwd = 2;
	439	if ((t = readtoken()) != TESAC) {
	440	if (t != TENDCASE)
	441	synexpect(TENDCASE);
	442	else
	443	checkkwd = 2, readtoken();
	444	}
	445	cpp = &cp->nclist.next;
	446	} while(lasttoken != TESAC);
	447	*cpp = NULL;
	448	checkkwd = 1;
	449	break;
	450	case TLP:
	451	n1 = (union node *)stalloc(sizeof (struct nredir));
	452	n1->type = NSUBSHELL;
	453	n1->nredir.n = list(0);
	454	n1->nredir.redirect = NULL;
	455	if (readtoken() != TRP)
	456	synexpect(TRP);
	457	checkkwd = 1;
	458	break;
	459	case TBEGIN:
	460	n1 = list(0);
	461	if (readtoken() != TEND)
	462	synexpect(TEND);
	463	checkkwd = 1;
	464	break;
	465	/* Handle an empty command like other simple commands. */
	466	case TSEMI:
	467	case TAND:
	468	case TOR:
	469	case TNL:
	470	case TEOF:
	471	case TRP:
	472	case TBACKGND:
	473	/*
	474	* An empty command before a ; doesn't make much sense, and
	475	* should certainly be disallowed in the case of `if ;'.
	476	*/
	477	if (!redir)
	478	synexpect(-1);
	479	case TWORD:
	480	tokpushback++;
	481	n1 = simplecmd(rpp, redir);
	482	return n1;
	483	default:
	484	synexpect(-1);
	485	/* NOTREACHED */
	486	}
	487
	488	/* Now check for redirection which may follow command */
	489	while (readtoken() == TREDIR) {
	490	*rpp = n2 = redirnode;
	491	rpp = &n2->nfile.next;
	492	parsefname();
	493	}
	494	tokpushback++;
	495	*rpp = NULL;
	496	if (redir) {
	497	if (n1->type != NSUBSHELL) {
	498	n2 = (union node *)stalloc(sizeof (struct nredir));
	499	n2->type = NREDIR;
	500	n2->nredir.n = n1;
	501	n1 = n2;
	502	}
	503	n1->nredir.redirect = redir;
	504	}
	505
	506	return n1;
	507	}
	508
	509
	510	STATIC union node *
	511	simplecmd(rpp, redir)
	512	union node *rpp, redir;
	513	{
	514	union node args, *app;
	515	union node **orig_rpp = rpp;
	516	union node *n = NULL;
	517
	518	/* If we don't have any redirections already, then we must reset */
	519	/* rpp to be the address of the local redir variable. */
	520	if (redir == 0)
	521	rpp = &redir;
	522
	523	args = NULL;
	524	app = &args;
	525	/*
	526	* We save the incoming value, because we need this for shell
	527	* functions. There can not be a redirect or an argument between
	528	* the function name and the open parenthesis.
	529	*/
	530	orig_rpp = rpp;
	531
	532	for (;;) {
	533	if (readtoken() == TWORD) {
	534	n = (union node *)stalloc(sizeof (struct narg));
	535	n->type = NARG;
	536	n->narg.text = wordtext;
	537	n->narg.backquote = backquotelist;
	538	*app = n;
	539	app = &n->narg.next;
	540	} else if (lasttoken == TREDIR) {
	541	*rpp = n = redirnode;
	542	rpp = &n->nfile.next;
	543	parsefname(); /* read name of redirection file */
	544	} else if (lasttoken == TLP && app == &args->narg.next
	545	&& rpp == orig_rpp) {
	546	/* We have a function */
	547	if (readtoken() != TRP)
	548	synexpect(TRP);
	549	#ifdef notdef
	550	if (! goodname(n->narg.text))
	551	synerror("Bad function name");
	552	#endif
	553	n->type = NDEFUN;
	554	checkkwd = 2;
	555	n->narg.next = command();
	556	return n;
	557	} else {
	558	tokpushback++;
	559	break;
	560	}
	561	}
	562	*app = NULL;
	563	*rpp = NULL;
	564	n = (union node *)stalloc(sizeof (struct ncmd));
	565	n->type = NCMD;
	566	n->ncmd.backgnd = 0;
	567	n->ncmd.args = args;
	568	n->ncmd.redirect = redir;
	569	return n;
	570	}
	571
	572	STATIC union node *
	573	makename() {
	574	union node *n;
	575
	576	n = (union node *)stalloc(sizeof (struct narg));
	577	n->type = NARG;
	578	n->narg.next = NULL;
	579	n->narg.text = wordtext;
	580	n->narg.backquote = backquotelist;
	581	return n;
	582	}
	583
	584	void fixredir(union node n, const char text, int err)
	585	{
	586	TRACE(("Fix redir %s %d\n", text, err));
	587	if (!err)
	588	n->ndup.vname = NULL;
	589
	590	if (is_digit(text[0]) && text[1] == '\0')
	591	n->ndup.dupfd = digit_val(text[0]);
	592	else if (text[0] == '-' && text[1] == '\0')
	593	n->ndup.dupfd = -1;
	594	else {
	595
	596	if (err)
	597	synerror("Bad fd number");
	598	else
	599	n->ndup.vname = makename();
	600	}
	601	}
	602
	603
	604	STATIC void
	605	parsefname() {
	606	union node *n = redirnode;
	607
	608	if (readtoken() != TWORD)
	609	synexpect(-1);
	610	if (n->type == NHERE) {
	611	struct heredoc *here = heredoc;
	612	struct heredoc *p;
	613	int i;
	614
	615	if (quoteflag == 0)
	616	n->type = NXHERE;
	617	TRACE(("Here document %d\n", n->type));
	618	if (here->striptabs) {
	619	while (*wordtext == '\t')
	620	wordtext++;
	621	}
	622	if (! noexpand(wordtext) \|\| (i = strlen(wordtext)) == 0 \|\| i > EOFMARKLEN)
	623	synerror("Illegal eof marker for << redirection");
	624	rmescapes(wordtext);
	625	here->eofmark = wordtext;
	626	here->next = NULL;
	627	if (heredoclist == NULL)
	628	heredoclist = here;
	629	else {
	630	for (p = heredoclist ; p->next ; p = p->next);
	631	p->next = here;
	632	}
	633	} else if (n->type == NTOFD \|\| n->type == NFROMFD) {
	634	fixredir(n, wordtext, 0);
	635	} else {
	636	n->nfile.fname = makename();
	637	}
	638	}
	639
	640
	641	/*
	642	* Input any here documents.
	643	*/
	644
	645	STATIC void
	646	parseheredoc() {
	647	struct heredoc *here;
	648	union node *n;
	649
	650	while (heredoclist) {
	651	here = heredoclist;
	652	heredoclist = here->next;
	653	if (needprompt) {
	654	setprompt(2);
	655	needprompt = 0;
	656	}
	657	readtoken1(pgetc(), here->here->type == NHERE? SQSYNTAX : DQSYNTAX,
	658	here->eofmark, here->striptabs);
	659	n = (union node *)stalloc(sizeof (struct narg));
	660	n->narg.type = NARG;
	661	n->narg.next = NULL;
	662	n->narg.text = wordtext;
	663	n->narg.backquote = backquotelist;
	664	here->here->nhere.doc = n;
	665	}
	666	}
	667
	668	STATIC int
	669	peektoken() {
	670	int t;
	671
	672	t = readtoken();
	673	tokpushback++;
	674	return (t);
	675	}
	676
	677	STATIC int
	678	readtoken() {
	679	int t;
	680	int savecheckkwd = checkkwd;
	681	struct alias *ap;
	682	#ifdef DEBUG
	683	int alreadyseen = tokpushback;
	684	#endif
	685
	686	top:
	687	t = xxreadtoken();
	688
	689	if (checkkwd) {
	690	/*
	691	* eat newlines
	692	*/
	693	if (checkkwd == 2) {
	694	checkkwd = 0;
	695	while (t == TNL) {
	696	parseheredoc();
	697	t = xxreadtoken();
	698	}
	699	} else
	700	checkkwd = 0;
	701	/*
	702	* check for keywords and aliases
	703	*/
	704	if (t == TWORD && !quoteflag)
	705	{
	706	const char const pp;
	707
	708	for (pp = parsekwd; *pp; pp++) {
	709	if (*pp == wordtext && equal(*pp, wordtext))
	710	{
	711	lasttoken = t = pp -
	712	parsekwd + KWDOFFSET;
	713	TRACE(("keyword %s recognized\n", tokname[t]));
	714	goto out;
	715	}
	716	}
	717	if ((ap = lookupalias(wordtext, 1)) != NULL) {
	718	pushstring(ap->val, strlen(ap->val), ap);
	719	checkkwd = savecheckkwd;
	720	goto top;
	721	}
	722	}
	723	out:
	724	checkkwd = 0;
	725	}
	726	#ifdef DEBUG
	727	if (!alreadyseen)
	728	TRACE(("token %s %s\n", tokname[t], t == TWORD ? wordtext : ""));
	729	else
	730	TRACE(("reread token %s %s\n", tokname[t], t == TWORD ? wordtext : ""));
	731	#endif
	732	return (t);
	733	}
	734
	735
	736	/*
	737	* Read the next input token.
	738	* If the token is a word, we set backquotelist to the list of cmds in
	739	* backquotes. We set quoteflag to true if any part of the word was
	740	* quoted.
	741	* If the token is TREDIR, then we set redirnode to a structure containing
	742	* the redirection.
	743	* In all cases, the variable startlinno is set to the number of the line
	744	* on which the token starts.
	745	*
	746	* [Change comment: here documents and internal procedures]
	747	* [Readtoken shouldn't have any arguments. Perhaps we should make the
	748	* word parsing code into a separate routine. In this case, readtoken
	749	* doesn't need to have any internal procedures, but parseword does.
	750	* We could also make parseoperator in essence the main routine, and
	751	* have parseword (readtoken1?) handle both words and redirection.]
	752	*/
	753
	754	#define RETURN(token) return lasttoken = token
	755
	756	STATIC int
	757	xxreadtoken() {
	758	int c;
	759
	760	if (tokpushback) {
	761	tokpushback = 0;
	762	return lasttoken;
	763	}
	764	if (needprompt) {
	765	setprompt(2);
	766	needprompt = 0;
	767	}
	768	startlinno = plinno;
	769	for (;;) { /* until token or start of word found */
	770	c = pgetc_macro();
	771	if (c == ' ' \|\| c == '\t')
	772	continue; /* quick check for white space first */
	773	switch (c) {
	774	case ' ': case '\t':
	775	continue;
	776	case '#':
	777	while ((c = pgetc()) != '\n' && c != PEOF);
	778	pungetc();
	779	continue;
	780	case '\\':
	781	if (pgetc() == '\n') {
	782	startlinno = ++plinno;
	783	if (doprompt)
	784	setprompt(2);
	785	else
	786	setprompt(0);
	787	continue;
	788	}
	789	pungetc();
	790	goto breakloop;
	791	case '\n':
	792	plinno++;
	793	needprompt = doprompt;
	794	RETURN(TNL);
	795	case PEOF:
	796	RETURN(TEOF);
	797	case '&':
	798	if (pgetc() == '&')
	799	RETURN(TAND);
	800	pungetc();
	801	RETURN(TBACKGND);
	802	case '\|':
	803	if (pgetc() == '\|')
	804	RETURN(TOR);
	805	pungetc();
	806	RETURN(TPIPE);
	807	case ';':
	808	if (pgetc() == ';')
	809	RETURN(TENDCASE);
	810	pungetc();
	811	RETURN(TSEMI);
	812	case '(':
	813	RETURN(TLP);
	814	case ')':
	815	RETURN(TRP);
	816	default:
	817	goto breakloop;
	818	}
	819	}
	820	breakloop:
	821	return readtoken1(c, BASESYNTAX, (char *)NULL, 0);
	822	#undef RETURN
	823	}
	824
	825
	826
	827	/*
	828	* If eofmark is NULL, read a word or a redirection symbol. If eofmark
	829	* is not NULL, read a here document. In the latter case, eofmark is the
	830	* word which marks the end of the document and striptabs is true if
	831	* leading tabs should be stripped from the document. The argument firstc
	832	* is the first character of the input token or document.
	833	*
	834	* Because C does not have internal subroutines, I have simulated them
	835	* using goto's to implement the subroutine linkage. The following macros
	836	* will run code that appears at the end of readtoken1.
	837	*/
	838
	839	#define CHECKEND() {goto checkend; checkend_return:;}
	840	#define PARSEREDIR() {goto parseredir; parseredir_return:;}
	841	#define PARSESUB() {goto parsesub; parsesub_return:;}
	842	#define PARSEBACKQOLD() {oldstyle = 1; goto parsebackq; parsebackq_oldreturn:;}
	843	#define PARSEBACKQNEW() {oldstyle = 0; goto parsebackq; parsebackq_newreturn:;}
	844	#define PARSEARITH() {goto parsearith; parsearith_return:;}
	845
	846	STATIC int
	847	readtoken1(firstc, syntax, eofmark, striptabs)
	848	int firstc;
	849	char const *syntax;
	850	char *eofmark;
	851	int striptabs;
	852	{
	853	int c = firstc;
	854	char *out;
	855	int len;
	856	char line[EOFMARKLEN + 1];
	857	struct nodelist *bqlist;
	858	int quotef;
	859	int dblquote;
	860	int varnest; /* levels of variables expansion */
	861	int arinest; /* levels of arithmetic expansion */
	862	int parenlevel; /* levels of parens in arithmetic */
	863	int dqvarnest; /* levels of variables expansion within double quotes */
	864	int oldstyle;
	865	char const prevsyntax; / syntax before arithmetic */
	866	#if __GNUC__
	867	/* Avoid longjmp clobbering */
	868	(void) &out;
	869	(void) &quotef;
	870	(void) &dblquote;
	871	(void) &varnest;
	872	(void) &arinest;
	873	(void) &parenlevel;
	874	(void) &dqvarnest;
	875	(void) &oldstyle;
	876	(void) &prevsyntax;
	877	(void) &syntax;
	878	#endif
	879
	880	startlinno = plinno;
	881	dblquote = 0;
	882	if (syntax == DQSYNTAX)
	883	dblquote = 1;
	884	quotef = 0;
	885	bqlist = NULL;
	886	varnest = 0;
	887	arinest = 0;
	888	parenlevel = 0;
	889	dqvarnest = 0;
	890
	891	STARTSTACKSTR(out);
	892	loop: { /* for each line, until end of word */
	893	#if ATTY
	894	if (c == '\034' && doprompt
	895	&& attyset() && ! equal(termval(), "emacs")) {
	896	attyline();
	897	if (syntax == BASESYNTAX)
	898	return readtoken();
	899	c = pgetc();
	900	goto loop;
	901	}
	902	#endif
	903	CHECKEND(); /* set c to PEOF if at end of here document */
	904	for (;;) { /* until end of line or end of word */
	905	CHECKSTRSPACE(3, out); /* permit 3 calls to USTPUTC */
	906	switch(syntax[c]) {
	907	case CNL: /* '\n' */
	908	if (syntax == BASESYNTAX)
	909	goto endword; /* exit outer loop */
	910	USTPUTC(c, out);
	911	plinno++;
	912	if (doprompt)
	913	setprompt(2);
	914	else
	915	setprompt(0);
	916	c = pgetc();
	917	goto loop; /* continue outer loop */
	918	case CWORD:
	919	USTPUTC(c, out);
	920	break;
	921	case CCTL:
	922	if ((eofmark == NULL \|\| dblquote) &&
	923	dqvarnest == 0)
	924	USTPUTC(CTLESC, out);
	925	USTPUTC(c, out);
	926	break;
	927	case CBACK: /* backslash */
	928	c = pgetc();
	929	if (c == PEOF) {
	930	USTPUTC('\\', out);
	931	pungetc();
	932	} else if (c == '\n') {
	933	if (doprompt)
	934	setprompt(2);
	935	else
	936	setprompt(0);
	937	} else {
	938	if (dblquote && c != '\\' && c != '`' && c != '$'
	939	&& (c != '"' \|\| eofmark != NULL))
	940	USTPUTC('\\', out);
	941	if (SQSYNTAX[c] == CCTL)
	942	USTPUTC(CTLESC, out);
	943	else if (eofmark == NULL)
	944	USTPUTC(CTLQUOTEMARK, out);
	945	USTPUTC(c, out);
	946	quotef++;
	947	}
	948	break;
	949	case CSQUOTE:
	950	if (eofmark == NULL)
	951	USTPUTC(CTLQUOTEMARK, out);
	952	syntax = SQSYNTAX;
	953	break;
	954	case CDQUOTE:
	955	if (eofmark == NULL)
	956	USTPUTC(CTLQUOTEMARK, out);
	957	syntax = DQSYNTAX;
	958	dblquote = 1;
	959	break;
	960	case CENDQUOTE:
	961	if (eofmark != NULL && arinest == 0 &&
	962	varnest == 0) {
	963	USTPUTC(c, out);
	964	} else {
	965	if (arinest) {
	966	syntax = ARISYNTAX;
	967	dblquote = 0;
	968	} else if (eofmark == NULL &&
	969	dqvarnest == 0) {
	970	syntax = BASESYNTAX;
	971	dblquote = 0;
	972	}
	973	quotef++;
	974	}
	975	break;
	976	case CVAR: /* '$' */
	977	PARSESUB(); /* parse substitution */
	978	break;
	979	case CENDVAR: /* '}' */
	980	if (varnest > 0) {
	981	varnest--;
	982	if (dqvarnest > 0) {
	983	dqvarnest--;
	984	}
	985	USTPUTC(CTLENDVAR, out);
	986	} else {
	987	USTPUTC(c, out);
	988	}
	989	break;
	990	case CLP: /* '(' in arithmetic */
	991	parenlevel++;
	992	USTPUTC(c, out);
	993	break;
	994	case CRP: /* ')' in arithmetic */
	995	if (parenlevel > 0) {
	996	USTPUTC(c, out);
	997	--parenlevel;
	998	} else {
	999	if (pgetc() == ')') {
	1000	if (--arinest == 0) {
	1001	USTPUTC(CTLENDARI, out);
	1002	syntax = prevsyntax;
	1003	if (syntax == DQSYNTAX)
	1004	dblquote = 1;
	1005	else
	1006	dblquote = 0;
	1007	} else
	1008	USTPUTC(')', out);
	1009	} else {
	1010	/*
	1011	* unbalanced parens
	1012	* (don't 2nd guess - no error)
	1013	*/
	1014	pungetc();
	1015	USTPUTC(')', out);
	1016	}
	1017	}
	1018	break;
	1019	case CBQUOTE: /* '`' */
	1020	PARSEBACKQOLD();
	1021	break;
	1022	case CEOF:
	1023	goto endword; /* exit outer loop */
	1024	default:
	1025	if (varnest == 0)
	1026	goto endword; /* exit outer loop */
	1027	USTPUTC(c, out);
	1028	}
	1029	c = pgetc_macro();
	1030	}
	1031	}
	1032	endword:
	1033	if (syntax == ARISYNTAX)
	1034	synerror("Missing '))'");
	1035	if (syntax != BASESYNTAX && ! parsebackquote && eofmark == NULL)
	1036	synerror("Unterminated quoted string");
	1037	if (varnest != 0) {
	1038	startlinno = plinno;
	1039	synerror("Missing '}'");
	1040	}
	1041	USTPUTC('\0', out);
	1042	len = out - stackblock();
	1043	out = stackblock();
	1044	if (eofmark == NULL) {
	1045	if ((c == '>' \|\| c == '<')
	1046	&& quotef == 0
	1047	&& len <= 2
	1048	&& (out == '\0' \|\| is_digit(out))) {
	1049	PARSEREDIR();
	1050	return lasttoken = TREDIR;
	1051	} else {
	1052	pungetc();
	1053	}
	1054	}
	1055	quoteflag = quotef;
	1056	backquotelist = bqlist;
	1057	grabstackblock(len);
	1058	wordtext = out;
	1059	return lasttoken = TWORD;
	1060	/* end of readtoken routine */
	1061
	1062
	1063
	1064	/*
	1065	* Check to see whether we are at the end of the here document. When this
	1066	* is called, c is set to the first character of the next input line. If
	1067	* we are at the end of the here document, this routine sets the c to PEOF.
	1068	*/
	1069
	1070	checkend: {
	1071	if (eofmark) {
	1072	if (striptabs) {
	1073	while (c == '\t')
	1074	c = pgetc();
	1075	}
	1076	if (c == *eofmark) {
	1077	if (pfgets(line, sizeof line) != NULL) {
	1078	char p, q;
	1079
	1080	p = line;
	1081	for (q = eofmark + 1 ; q && p == *q ; p++, q++);
	1082	if (p == '\n' && q == '\0') {
	1083	c = PEOF;
	1084	plinno++;
	1085	needprompt = doprompt;
	1086	} else {
	1087	pushstring(line, strlen(line), NULL);
	1088	}
	1089	}
	1090	}
	1091	}
	1092	goto checkend_return;
	1093	}
	1094
	1095
	1096	/*
	1097	* Parse a redirection operator. The variable "out" points to a string
	1098	* specifying the fd to be redirected. The variable "c" contains the
	1099	* first character of the redirection operator.
	1100	*/
	1101
	1102	parseredir: {
	1103	char fd = *out;
	1104	union node *np;
	1105
	1106	np = (union node *)stalloc(sizeof (struct nfile));
	1107	if (c == '>') {
	1108	np->nfile.fd = 1;
	1109	c = pgetc();
	1110	if (c == '>')
	1111	np->type = NAPPEND;
	1112	else if (c == '&')
	1113	np->type = NTOFD;
	1114	else if (c == '\|')
	1115	np->type = NTOOV;
	1116	else {
	1117	np->type = NTO;
	1118	pungetc();
	1119	}
	1120	} else { /* c == '<' */
	1121	np->nfile.fd = 0;
	1122	switch (c = pgetc()) {
	1123	case '<':
	1124	if (sizeof (struct nfile) != sizeof (struct nhere)) {
	1125	np = (union node *)stalloc(sizeof (struct nhere));
	1126	np->nfile.fd = 0;
	1127	}
	1128	np->type = NHERE;
	1129	heredoc = (struct heredoc *)stalloc(sizeof (struct heredoc));
	1130	heredoc->here = np;
	1131	if ((c = pgetc()) == '-') {
	1132	heredoc->striptabs = 1;
	1133	} else {
	1134	heredoc->striptabs = 0;
	1135	pungetc();
	1136	}
	1137	break;
	1138
	1139	case '&':
	1140	np->type = NFROMFD;
	1141	break;
	1142
	1143	case '>':
	1144	np->type = NFROMTO;
	1145	break;
	1146
	1147	default:
	1148	np->type = NFROM;
	1149	pungetc();
	1150	break;
	1151	}
	1152	}
	1153	if (fd != '\0')
	1154	np->nfile.fd = digit_val(fd);
	1155	redirnode = np;
	1156	goto parseredir_return;
	1157	}
	1158
	1159
	1160	/*
	1161	* Parse a substitution. At this point, we have read the dollar sign
	1162	* and nothing else.
	1163	*/
	1164
	1165	parsesub: {
	1166	int subtype;
	1167	int typeloc;
	1168	int flags;
	1169	char *p;
	1170	static const char types[] = "}-+?=";
	1171
	1172	c = pgetc();
	1173	if (c != '(' && c != '{' && !is_name(c) && !is_special(c)) {
	1174	USTPUTC('$', out);
	1175	pungetc();
	1176	} else if (c == '(') { /* $(command) or $((arith)) */
	1177	if (pgetc() == '(') {
	1178	PARSEARITH();
	1179	} else {
	1180	pungetc();
	1181	PARSEBACKQNEW();
	1182	}
	1183	} else {
	1184	USTPUTC(CTLVAR, out);
	1185	typeloc = out - stackblock();
	1186	USTPUTC(VSNORMAL, out);
	1187	subtype = VSNORMAL;
	1188	if (c == '{') {
	1189	c = pgetc();
	1190	if (c == '#') {
	1191	if ((c = pgetc()) == '}')
	1192	c = '#';
	1193	else
	1194	subtype = VSLENGTH;
	1195	}
	1196	else
	1197	subtype = 0;
	1198	}
	1199	if (is_name(c)) {
	1200	do {
	1201	STPUTC(c, out);
	1202	c = pgetc();
	1203	} while (is_in_name(c));
	1204	} else if (is_digit(c)) {
	1205	do {
	1206	USTPUTC(c, out);
	1207	c = pgetc();
	1208	} while (is_digit(c));
	1209	}
	1210	else if (is_special(c)) {
	1211	USTPUTC(c, out);
	1212	c = pgetc();
	1213	}
	1214	else
	1215	badsub: synerror("Bad substitution");
	1216
	1217	STPUTC('=', out);
	1218	flags = 0;
	1219	if (subtype == 0) {
	1220	switch (c) {
	1221	case ':':
	1222	flags = VSNUL;
	1223	c = pgetc();
	1224	/FALLTHROUGH/
	1225	default:
	1226	p = strchr(types, c);
	1227	if (p == NULL)
	1228	goto badsub;
	1229	subtype = p - types + VSNORMAL;
	1230	break;
	1231	case '%':
	1232	case '#':
	1233	{
	1234	int cc = c;
	1235	subtype = c == '#' ? VSTRIMLEFT :
	1236	VSTRIMRIGHT;
	1237	c = pgetc();
	1238	if (c == cc)
	1239	subtype++;
	1240	else
	1241	pungetc();
	1242	break;
	1243	}
	1244	}
	1245	} else {
	1246	pungetc();
	1247	}
	1248	if (dblquote \|\| arinest)
	1249	flags \|= VSQUOTE;
	1250	*(stackblock() + typeloc) = subtype \| flags;
	1251	if (subtype != VSNORMAL) {
	1252	varnest++;
	1253	if (dblquote) {
	1254	dqvarnest++;
	1255	}
	1256	}
	1257	}
	1258	goto parsesub_return;
	1259	}
	1260
	1261
	1262	/*
	1263	* Called to parse command substitutions. Newstyle is set if the command
	1264	* is enclosed inside $(...); nlpp is a pointer to the head of the linked
	1265	* list of commands (passed by reference), and savelen is the number of
	1266	* characters on the top of the stack which must be preserved.
	1267	*/
	1268
	1269	parsebackq: {
	1270	struct nodelist **nlpp;
	1271	int savepbq;
	1272	union node *n;
	1273	char *volatile str;
	1274	struct jmploc jmploc;
	1275	struct jmploc *volatile savehandler;
	1276	int savelen;
	1277	int saveprompt;
	1278	#ifdef __GNUC__
	1279	(void) &saveprompt;
	1280	#endif
	1281
	1282	savepbq = parsebackquote;
	1283	if (setjmp(jmploc.loc)) {
	1284	if (str)
	1285	ckfree(str);
	1286	parsebackquote = 0;
	1287	handler = savehandler;
	1288	longjmp(handler->loc, 1);
	1289	}
	1290	INTOFF;
	1291	str = NULL;
	1292	savelen = out - stackblock();
	1293	if (savelen > 0) {
	1294	str = ckmalloc(savelen);
	1295	memcpy(str, stackblock(), savelen);
	1296	}
	1297	savehandler = handler;
	1298	handler = &jmploc;
	1299	INTON;
	1300	if (oldstyle) {
	1301	/* We must read until the closing backquote, giving special
	1302	treatment to some slashes, and then push the string and
	1303	reread it as input, interpreting it normally. */
	1304	char *pout;
	1305	int pc;
	1306	int psavelen;
	1307	char *pstr;
	1308
	1309
	1310	STARTSTACKSTR(pout);
	1311	for (;;) {
	1312	if (needprompt) {
	1313	setprompt(2);
	1314	needprompt = 0;
	1315	}
	1316	switch (pc = pgetc()) {
	1317	case '`':
	1318	goto done;
	1319
	1320	case '\\':
	1321	if ((pc = pgetc()) == '\n') {
	1322	plinno++;
	1323	if (doprompt)
	1324	setprompt(2);
	1325	else
	1326	setprompt(0);
	1327	/*
	1328	* If eating a newline, avoid putting
	1329	* the newline into the new character
	1330	* stream (via the STPUTC after the
	1331	* switch).
	1332	*/
	1333	continue;
	1334	}
	1335	if (pc != '\\' && pc != '`' && pc != '$'
	1336	&& (!dblquote \|\| pc != '"'))
	1337	STPUTC('\\', pout);
	1338	break;
	1339
	1340	case '\n':
	1341	plinno++;
	1342	needprompt = doprompt;
	1343	break;
	1344
	1345	case PEOF:
	1346	startlinno = plinno;
	1347	synerror("EOF in backquote substitution");
	1348	break;
	1349
	1350	default:
	1351	break;
	1352	}
	1353	STPUTC(pc, pout);
	1354	}
	1355	done:
	1356	STPUTC('\0', pout);
	1357	psavelen = pout - stackblock();
	1358	if (psavelen > 0) {
	1359	pstr = grabstackstr(pout);
	1360	setinputstring(pstr, 1);
	1361	}
	1362	}
	1363	nlpp = &bqlist;
	1364	while (*nlpp)
	1365	nlpp = &(*nlpp)->next;
	1366	nlpp = (struct nodelist )stalloc(sizeof (struct nodelist));
	1367	(*nlpp)->next = NULL;
	1368	parsebackquote = oldstyle;
	1369
	1370	if (oldstyle) {
	1371	saveprompt = doprompt;
	1372	doprompt = 0;
	1373	}
	1374
	1375	n = list(0);
	1376
	1377	if (oldstyle)
	1378	doprompt = saveprompt;
	1379	else {
	1380	if (readtoken() != TRP)
	1381	synexpect(TRP);
	1382	}
	1383
	1384	(*nlpp)->n = n;
	1385	if (oldstyle) {
	1386	/*
	1387	* Start reading from old file again, ignoring any pushed back
	1388	* tokens left from the backquote parsing
	1389	*/
	1390	popfile();
	1391	tokpushback = 0;
	1392	}
	1393	while (stackblocksize() <= savelen)
	1394	growstackblock();
	1395	STARTSTACKSTR(out);
	1396	if (str) {
	1397	memcpy(out, str, savelen);
	1398	STADJUST(savelen, out);
	1399	INTOFF;
	1400	ckfree(str);
	1401	str = NULL;
	1402	INTON;
	1403	}
	1404	parsebackquote = savepbq;
	1405	handler = savehandler;
	1406	if (arinest \|\| dblquote)
	1407	USTPUTC(CTLBACKQ \| CTLQUOTE, out);
	1408	else
	1409	USTPUTC(CTLBACKQ, out);
	1410	if (oldstyle)
	1411	goto parsebackq_oldreturn;
	1412	else
	1413	goto parsebackq_newreturn;
	1414	}
	1415
	1416	/*
	1417	* Parse an arithmetic expansion (indicate start of one and set state)
	1418	*/
	1419	parsearith: {
	1420
	1421	if (++arinest == 1) {
	1422	prevsyntax = syntax;
	1423	syntax = ARISYNTAX;
	1424	USTPUTC(CTLARI, out);
	1425	if (dblquote)
	1426	USTPUTC('"',out);
	1427	else
	1428	USTPUTC(' ',out);
	1429	} else {
	1430	/*
	1431	* we collapse embedded arithmetic expansion to
	1432	* parenthesis, which should be equivalent
	1433	*/
	1434	USTPUTC('(', out);
	1435	}
	1436	goto parsearith_return;
	1437	}
	1438
	1439	} /* end of readtoken */
	1440
	1441
	1442
	1443	#ifdef mkinit
	1444	RESET {
	1445	tokpushback = 0;
	1446	checkkwd = 0;
	1447	}
	1448	#endif
	1449
	1450	/*
	1451	* Returns true if the text contains nothing to expand (no dollar signs
	1452	* or backquotes).
	1453	*/
	1454
	1455	STATIC int
	1456	noexpand(text)
	1457	char *text;
	1458	{
	1459	char *p;
	1460	char c;
	1461
	1462	p = text;
	1463	while ((c = *p++) != '\0') {
	1464	if (c == CTLQUOTEMARK)
	1465	continue;
	1466	if (c == CTLESC)
	1467	p++;
	1468	else if (BASESYNTAX[(int)c] == CCTL)
	1469	return 0;
	1470	}
	1471	return 1;
	1472	}
	1473
	1474
	1475	/*
	1476	* Return true if the argument is a legal variable name (a letter or
	1477	* underscore followed by zero or more letters, underscores, and digits).
	1478	*/
	1479
	1480	int
	1481	goodname(char *name)
	1482	{
	1483	char *p;
	1484
	1485	p = name;
	1486	if (! is_name(*p))
	1487	return 0;
	1488	while (*++p) {
	1489	if (! is_in_name(*p))
	1490	return 0;
	1491	}
	1492	return 1;
	1493	}
	1494
	1495
	1496	/*
	1497	* Called when an unexpected token is read during the parse. The argument
	1498	* is the token that is expected, or -1 if more than one type of token can
	1499	* occur at this point.
	1500	*/
	1501
	1502	STATIC void
	1503	synexpect(token)
	1504	int token;
	1505	{
	1506	char msg[64];
	1507
	1508	if (token >= 0) {
	1509	fmtstr(msg, 64, "%s unexpected (expecting %s)",
	1510	tokname[lasttoken], tokname[token]);
	1511	} else {
	1512	fmtstr(msg, 64, "%s unexpected", tokname[lasttoken]);
	1513	}
	1514	synerror(msg);
	1515	/* NOTREACHED */
	1516	}
	1517
	1518
	1519	STATIC void
	1520	synerror(msg)
	1521	const char *msg;
	1522	{
	1523	if (commandname)
	1524	outfmt(&errout, "%s: %d: ", commandname, startlinno);
	1525	outfmt(&errout, "Syntax error: %s\n", msg);
	1526	error((char *)NULL);
	1527	/* NOTREACHED */
	1528	}
	1529
	1530	STATIC void
	1531	setprompt(which)
	1532	int which;
	1533	{
	1534	whichprompt = which;
	1535
	1536	#ifndef SMALL
	1537	if (!el)
	1538	#endif
	1539	out2str(getprompt(NULL));
	1540	}
	1541
	1542	/*
	1543	* called by editline -- any expansions to the prompt
	1544	* should be added here.
	1545	*/
	1546	const char *
	1547	getprompt(void *unused)
	1548	{
	1549	switch (whichprompt) {
	1550	case 0:
	1551	return "";
	1552	case 1:
	1553	return ps1val();
	1554	case 2:
	1555	return ps2val();
	1556	default:
	1557	return "<internal prompt error>";
	1558	}
	1559	}

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

Download in other formats: