[p5sagit/p5-mst-13.2.git] / evalargs.xc

/* This file is included by eval.c.  It's separate from eval.c to keep
 * kit sizes from getting too big.
 */

/* $Header: evalargs.xc,v 3.0.1.1 89/10/26 23:12:55 lwall Locked $
 *
 * $Log:	evalargs.xc,v $
 * Revision 3.0.1.1  89/10/26  23:12:55  lwall
 * patch1: glob didn't free a temporary string
 * 
 * Revision 3.0  89/10/18  15:17:16  lwall
 * 3.0 baseline
 * 
 */

    for (anum = 1; anum <= maxarg; anum++) {
	argflags = arg[anum].arg_flags;
	argtype = arg[anum].arg_type;
	argptr = arg[anum].arg_ptr;
      re_eval:
	switch (argtype) {
	default:
	    st[++sp] = &str_undef;
#ifdef DEBUGGING
	    tmps = "NULL";
#endif
	    break;
	case A_EXPR:
#ifdef DEBUGGING
	    if (debug & 8) {
		tmps = "EXPR";
		deb("%d.EXPR =>\n",anum);
	    }
#endif
	    sp = eval(argptr.arg_arg,
		(argflags & AF_ARYOK) ? G_ARRAY : G_SCALAR, sp);
	    if (sp + (maxarg - anum) > stack->ary_max)
		astore(stack, sp + (maxarg - anum), Nullstr);
	    st = stack->ary_array;	/* possibly reallocated */
	    break;
	case A_CMD:
#ifdef DEBUGGING
	    if (debug & 8) {
		tmps = "CMD";
		deb("%d.CMD (%lx) =>\n",anum,argptr.arg_cmd);
	    }
#endif
	    sp = cmd_exec(argptr.arg_cmd, gimme, sp);
	    if (sp + (maxarg - anum) > stack->ary_max)
		astore(stack, sp + (maxarg - anum), Nullstr);
	    st = stack->ary_array;	/* possibly reallocated */
	    break;
	case A_LARYSTAB:
	    ++sp;
	    str = afetch(stab_array(argptr.arg_stab),
		arg[anum].arg_len - arybase, TRUE);
#ifdef DEBUGGING
	    if (debug & 8) {
		(void)sprintf(buf,"LARYSTAB $%s[%d]",stab_name(argptr.arg_stab),
		    arg[anum].arg_len);
		tmps = buf;
	    }
#endif
	    goto do_crement;
	case A_ARYSTAB:
	    st[++sp] = afetch(stab_array(argptr.arg_stab),
		arg[anum].arg_len - arybase, FALSE);
	    if (!st[sp])
		st[sp] = &str_undef;
#ifdef DEBUGGING
	    if (debug & 8) {
		(void)sprintf(buf,"ARYSTAB $%s[%d]",stab_name(argptr.arg_stab),
		    arg[anum].arg_len);
		tmps = buf;
	    }
#endif
	    break;
	case A_STAR:
	    st[++sp] = (STR*)argptr.arg_stab;
#ifdef DEBUGGING
	    if (debug & 8) {
		(void)sprintf(buf,"STAR *%s",stab_name(argptr.arg_stab));
		tmps = buf;
	    }
#endif
	    break;
	case A_LSTAR:
	    str = st[++sp] = (STR*)argptr.arg_stab;
#ifdef DEBUGGING
	    if (debug & 8) {
		(void)sprintf(buf,"LSTAR *%s",stab_name(argptr.arg_stab));
		tmps = buf;
	    }
#endif
	    break;
	case A_STAB:
	    st[++sp] = STAB_STR(argptr.arg_stab);
#ifdef DEBUGGING
	    if (debug & 8) {
		(void)sprintf(buf,"STAB $%s",stab_name(argptr.arg_stab));
		tmps = buf;
	    }
#endif
	    break;
	case A_LEXPR:
#ifdef DEBUGGING
	    if (debug & 8) {
		tmps = "LEXPR";
		deb("%d.LEXPR =>\n",anum);
	    }
#endif
	    if (argflags & AF_ARYOK) {
		sp = eval(argptr.arg_arg, G_ARRAY, sp);
		if (sp + (maxarg - anum) > stack->ary_max)
		    astore(stack, sp + (maxarg - anum), Nullstr);
		st = stack->ary_array;	/* possibly reallocated */
	    }
	    else {
		sp = eval(argptr.arg_arg, G_SCALAR, sp);
		st = stack->ary_array;	/* possibly reallocated */
		str = st[sp];
		goto do_crement;
	    }
	    break;
	case A_LVAL:
#ifdef DEBUGGING
	    if (debug & 8) {
		(void)sprintf(buf,"LVAL $%s",stab_name(argptr.arg_stab));
		tmps = buf;
	    }
#endif
	    ++sp;
	    str = STAB_STR(argptr.arg_stab);
	    if (!str)
		fatal("panic: A_LVAL");
	  do_crement:
	    assigning = TRUE;
	    if (argflags & AF_PRE) {
		if (argflags & AF_UP)
		    str_inc(str);
		else
		    str_dec(str);
		STABSET(str);
		st[sp] = str;
		str = arg->arg_ptr.arg_str;
	    }
	    else if (argflags & AF_POST) {
		st[sp] = str_static(str);
		if (argflags & AF_UP)
		    str_inc(str);
		else
		    str_dec(str);
		STABSET(str);
		str = arg->arg_ptr.arg_str;
	    }
	    else
		st[sp] = str;
	    break;
	case A_LARYLEN:
	    ++sp;
	    stab = argptr.arg_stab;
	    str = stab_array(argptr.arg_stab)->ary_magic;
	    if (argflags & (AF_PRE|AF_POST))
		str_numset(str,(double)(stab_array(stab)->ary_fill+arybase));
#ifdef DEBUGGING
	    tmps = "LARYLEN";
#endif
	    if (!str)
		fatal("panic: A_LEXPR");
	    goto do_crement;
	case A_ARYLEN:
	    stab = argptr.arg_stab;
	    st[++sp] = stab_array(stab)->ary_magic;
	    str_numset(st[sp],(double)(stab_array(stab)->ary_fill+arybase));
#ifdef DEBUGGING
	    tmps = "ARYLEN";
#endif
	    break;
	case A_SINGLE:
	    st[++sp] = argptr.arg_str;
#ifdef DEBUGGING
	    tmps = "SINGLE";
#endif
	    break;
	case A_DOUBLE:
	    (void) interp(str,argptr.arg_str,sp);
	    st = stack->ary_array;
	    st[++sp] = str;
#ifdef DEBUGGING
	    tmps = "DOUBLE";
#endif
	    break;
	case A_BACKTICK:
	    tmps = str_get(interp(str,argptr.arg_str,sp));
	    st = stack->ary_array;
#ifdef TAINT
	    taintproper("Insecure dependency in ``");
#endif
	    fp = mypopen(tmps,"r");
	    str_set(str,"");
	    if (fp) {
		while (str_gets(str,fp,str->str_cur) != Nullch)
		    ;
		statusvalue = mypclose(fp);
	    }
	    else
		statusvalue = -1;

	    st[++sp] = str;
#ifdef DEBUGGING
	    tmps = "BACK";
#endif
	    break;
	case A_WANTARRAY:
	    {
		extern int wantarray;

		if (wantarray == G_ARRAY)
		    st[++sp] = &str_yes;
		else
		    st[++sp] = &str_no;
	    }
#ifdef DEBUGGING
	    tmps = "WANTARRAY";
#endif
	    break;
	case A_INDREAD:
	    last_in_stab = stabent(str_get(STAB_STR(argptr.arg_stab)),TRUE);
	    old_record_separator = record_separator;
	    goto do_read;
	case A_GLOB:
	    argflags |= AF_POST;	/* enable newline chopping */
	    last_in_stab = argptr.arg_stab;
	    old_record_separator = record_separator;
	    if (csh > 0)
		record_separator = 0;
	    else
		record_separator = '\n';
	    goto do_read;
	case A_READ:
	    last_in_stab = argptr.arg_stab;
	    old_record_separator = record_separator;
	  do_read:
	    if (anum > 1)		/* assign to scalar */
		gimme = G_SCALAR;	/* force context to scalar */
	    ++sp;
	    fp = Nullfp;
	    if (stab_io(last_in_stab)) {
		fp = stab_io(last_in_stab)->ifp;
		if (!fp) {
		    if (stab_io(last_in_stab)->flags & IOF_ARGV) {
			if (stab_io(last_in_stab)->flags & IOF_START) {
			    stab_io(last_in_stab)->flags &= ~IOF_START;
			    stab_io(last_in_stab)->lines = 0;
			    if (alen(stab_array(last_in_stab)) < 0) {
				tmpstr = str_make("-",1); /* assume stdin */
				(void)apush(stab_array(last_in_stab), tmpstr);
			    }
			}
			fp = nextargv(last_in_stab);
			if (!fp)  /* Note: fp != stab_io(last_in_stab)->ifp */
			    (void)do_close(last_in_stab,FALSE); /* now it does*/
		    }
		    else if (argtype == A_GLOB) {
			(void) interp(str,stab_val(last_in_stab),sp);
			st = stack->ary_array;
			tmpstr = Str_new(55,0);
			if (csh > 0) {
			    str_set(tmpstr,"/bin/csh -cf 'set nonomatch; glob ");
			    str_scat(tmpstr,str);
			    str_cat(tmpstr,"'|");
			}
			else {
			    str_set(tmpstr, "echo ");
			    str_scat(tmpstr,str);
			    str_cat(tmpstr,
			      "|tr -s ' \t\f\r' '\\012\\012\\012\\012'|");
			}
			(void)do_open(last_in_stab,tmpstr->str_ptr);
			fp = stab_io(last_in_stab)->ifp;
			str_free(tmpstr);
		    }
		}
	    }
	    if (!fp && dowarn)
		warn("Read on closed filehandle <%s>",stab_name(last_in_stab));
	  keepgoing:
	    if (!fp)
		st[sp] = &str_undef;
	    else if (!str_gets(str,fp, optype == O_RCAT ? str->str_cur : 0)) {
		clearerr(fp);
		if (stab_io(last_in_stab)->flags & IOF_ARGV) {
		    fp = nextargv(last_in_stab);
		    if (fp)
			goto keepgoing;
		    (void)do_close(last_in_stab,FALSE);
		    stab_io(last_in_stab)->flags |= IOF_START;
		}
		else if (argflags & AF_POST) {
		    (void)do_close(last_in_stab,FALSE);
		}
		st[sp] = &str_undef;
		record_separator = old_record_separator;
		if (gimme == G_ARRAY) {
		    --sp;
		    goto array_return;
		}
		break;
	    }
	    else {
		stab_io(last_in_stab)->lines++;
		st[sp] = str;
#ifdef TAINT
		str->str_tainted = 1; /* Anything from the outside world...*/
#endif
		if (argflags & AF_POST) {
		    if (str->str_cur > 0)
			str->str_cur--;
		    if (str->str_ptr[str->str_cur] == record_separator)
			str->str_ptr[str->str_cur] = '\0';
		    else
			str->str_cur++;
		    for (tmps = str->str_ptr; *tmps; tmps++)
			if (!isalpha(*tmps) && !isdigit(*tmps) &&
			    index("$&*(){}[]'\";\\|?<>~`",*tmps))
				break;
		    if (*tmps && stat(str->str_ptr,&statbuf) < 0)
			goto keepgoing;		/* unmatched wildcard? */
		}
		if (gimme == G_ARRAY) {
		    st[sp] = str_static(st[sp]);
		    if (++sp > stack->ary_max) {
			astore(stack, sp, Nullstr);
			st = stack->ary_array;
		    }
		    goto keepgoing;
		}
	    }
	    record_separator = old_record_separator;
#ifdef DEBUGGING
	    tmps = "READ";
#endif
	    break;
	}
#ifdef DEBUGGING
	if (debug & 8)
	    deb("%d.%s = '%s'\n",anum,tmps,str_peek(st[sp]));
#endif
	if (anum < 8)
	    arglast[anum] = sp;
    }
Commit	Line	Data
a687059c	1	/* This file is included by eval.c. It's separate from eval.c to keep
	2	* kit sizes from getting too big.
	3	*/
	4
03a14243	5	/* $Header: evalargs.xc,v 3.0.1.1 89/10/26 23:12:55 lwall Locked $
a687059c	6	*
a687059c	7	* $Log: evalargs.xc,v $
03a14243	8	* Revision 3.0.1.1 89/10/26 23:12:55 lwall
	9	* patch1: glob didn't free a temporary string
	10	*
a687059c	11	* Revision 3.0 89/10/18 15:17:16 lwall
	12	* 3.0 baseline
	13	*
	14	*/
	15
	16	for (anum = 1; anum <= maxarg; anum++) {
	17	argflags = arg[anum].arg_flags;
	18	argtype = arg[anum].arg_type;
	19	argptr = arg[anum].arg_ptr;
	20	re_eval:
	21	switch (argtype) {
	22	default:
	23	st[++sp] = &str_undef;
	24	#ifdef DEBUGGING
	25	tmps = "NULL";
	26	#endif
	27	break;
	28	case A_EXPR:
	29	#ifdef DEBUGGING
	30	if (debug & 8) {
	31	tmps = "EXPR";
	32	deb("%d.EXPR =>\n",anum);
	33	}
	34	#endif
	35	sp = eval(argptr.arg_arg,
	36	(argflags & AF_ARYOK) ? G_ARRAY : G_SCALAR, sp);
	37	if (sp + (maxarg - anum) > stack->ary_max)
	38	astore(stack, sp + (maxarg - anum), Nullstr);
	39	st = stack->ary_array; /* possibly reallocated */
	40	break;
	41	case A_CMD:
	42	#ifdef DEBUGGING
	43	if (debug & 8) {
	44	tmps = "CMD";
	45	deb("%d.CMD (%lx) =>\n",anum,argptr.arg_cmd);
	46	}
	47	#endif
	48	sp = cmd_exec(argptr.arg_cmd, gimme, sp);
	49	if (sp + (maxarg - anum) > stack->ary_max)
	50	astore(stack, sp + (maxarg - anum), Nullstr);
	51	st = stack->ary_array; /* possibly reallocated */
	52	break;
	53	case A_LARYSTAB:
	54	++sp;
	55	str = afetch(stab_array(argptr.arg_stab),
	56	arg[anum].arg_len - arybase, TRUE);
	57	#ifdef DEBUGGING
	58	if (debug & 8) {
	59	(void)sprintf(buf,"LARYSTAB $%s[%d]",stab_name(argptr.arg_stab),
	60	arg[anum].arg_len);
	61	tmps = buf;
	62	}
	63	#endif
	64	goto do_crement;
	65	case A_ARYSTAB:
	66	st[++sp] = afetch(stab_array(argptr.arg_stab),
	67	arg[anum].arg_len - arybase, FALSE);
	68	if (!st[sp])
	69	st[sp] = &str_undef;
	70	#ifdef DEBUGGING
	71	if (debug & 8) {
	72	(void)sprintf(buf,"ARYSTAB $%s[%d]",stab_name(argptr.arg_stab),
	73	arg[anum].arg_len);
	74	tmps = buf;
75	}
76	#endif
77	break;
78	case A_STAR:
79	st[++sp] = (STR*)argptr.arg_stab;
80	#ifdef DEBUGGING
81	if (debug & 8) {
82	(void)sprintf(buf,"STAR *%s",stab_name(argptr.arg_stab));
83	tmps = buf;
84	}
85	#endif
86	break;
87	case A_LSTAR:
88	str = st[++sp] = (STR*)argptr.arg_stab;
89	#ifdef DEBUGGING
90	if (debug & 8) {
91	(void)sprintf(buf,"LSTAR *%s",stab_name(argptr.arg_stab));
92	tmps = buf;
93	}
94	#endif
95	break;
96	case A_STAB:
97	st[++sp] = STAB_STR(argptr.arg_stab);
98	#ifdef DEBUGGING
99	if (debug & 8) {
100	(void)sprintf(buf,"STAB $%s",stab_name(argptr.arg_stab));
101	tmps = buf;
102	}
103	#endif
104	break;
105	case A_LEXPR:
106	#ifdef DEBUGGING
107	if (debug & 8) {
108	tmps = "LEXPR";
109	deb("%d.LEXPR =>\n",anum);
110	}
111	#endif
112	if (argflags & AF_ARYOK) {
113	sp = eval(argptr.arg_arg, G_ARRAY, sp);
114	if (sp + (maxarg - anum) > stack->ary_max)
115	astore(stack, sp + (maxarg - anum), Nullstr);
116	st = stack->ary_array; /* possibly reallocated */
117	}
118	else {
119	sp = eval(argptr.arg_arg, G_SCALAR, sp);
120	st = stack->ary_array; /* possibly reallocated */
121	str = st[sp];
122	goto do_crement;
123	}
124	break;
125	case A_LVAL:
126	#ifdef DEBUGGING
127	if (debug & 8) {
128	(void)sprintf(buf,"LVAL $%s",stab_name(argptr.arg_stab));
129	tmps = buf;
130	}
131	#endif
132	++sp;
133	str = STAB_STR(argptr.arg_stab);
134	if (!str)
135	fatal("panic: A_LVAL");
136	do_crement:
137	assigning = TRUE;
138	if (argflags & AF_PRE) {
139	if (argflags & AF_UP)
140	str_inc(str);
141	else
142	str_dec(str);
143	STABSET(str);
144	st[sp] = str;
145	str = arg->arg_ptr.arg_str;
146	}
147	else if (argflags & AF_POST) {
148	st[sp] = str_static(str);
149	if (argflags & AF_UP)
150	str_inc(str);
151	else
152	str_dec(str);
153	STABSET(str);
154	str = arg->arg_ptr.arg_str;
155	}
156	else
157	st[sp] = str;
158	break;
159	case A_LARYLEN:
160	++sp;
161	stab = argptr.arg_stab;
162	str = stab_array(argptr.arg_stab)->ary_magic;
163	if (argflags & (AF_PRE\|AF_POST))
164	str_numset(str,(double)(stab_array(stab)->ary_fill+arybase));
165	#ifdef DEBUGGING
166	tmps = "LARYLEN";
167	#endif
168	if (!str)
169	fatal("panic: A_LEXPR");
170	goto do_crement;
171	case A_ARYLEN:
172	stab = argptr.arg_stab;
173	st[++sp] = stab_array(stab)->ary_magic;
174	str_numset(st[sp],(double)(stab_array(stab)->ary_fill+arybase));
175	#ifdef DEBUGGING
176	tmps = "ARYLEN";
177	#endif
178	break;
179	case A_SINGLE:
180	st[++sp] = argptr.arg_str;
181	#ifdef DEBUGGING
182	tmps = "SINGLE";
183	#endif
184	break;
185	case A_DOUBLE:
186	(void) interp(str,argptr.arg_str,sp);
187	st = stack->ary_array;
188	st[++sp] = str;
189	#ifdef DEBUGGING
190	tmps = "DOUBLE";
191	#endif
192	break;
193	case A_BACKTICK:
194	tmps = str_get(interp(str,argptr.arg_str,sp));
195	st = stack->ary_array;
196	#ifdef TAINT
197	taintproper("Insecure dependency in ``");
198	#endif
199	fp = mypopen(tmps,"r");
200	str_set(str,"");
201	if (fp) {
202	while (str_gets(str,fp,str->str_cur) != Nullch)
203	;
204	statusvalue = mypclose(fp);
205	}
206	else
207	statusvalue = -1;
208
209	st[++sp] = str;
210	#ifdef DEBUGGING
211	tmps = "BACK";
212	#endif
213	break;
214	case A_WANTARRAY:
215	{
216	extern int wantarray;
217
218	if (wantarray == G_ARRAY)
219	st[++sp] = &str_yes;
220	else
221	st[++sp] = &str_no;
222	}
223	#ifdef DEBUGGING
224	tmps = "WANTARRAY";
225	#endif
226	break;
227	case A_INDREAD:
228	last_in_stab = stabent(str_get(STAB_STR(argptr.arg_stab)),TRUE);
229	old_record_separator = record_separator;
230	goto do_read;
231	case A_GLOB:
232	argflags \|= AF_POST; /* enable newline chopping */
233	last_in_stab = argptr.arg_stab;
234	old_record_separator = record_separator;
235	if (csh > 0)
236	record_separator = 0;
237	else
238	record_separator = '\n';
239	goto do_read;
240	case A_READ:
241	last_in_stab = argptr.arg_stab;
242	old_record_separator = record_separator;
243	do_read:
244	if (anum > 1) /* assign to scalar */
245	gimme = G_SCALAR; /* force context to scalar */
246	++sp;
247	fp = Nullfp;
248	if (stab_io(last_in_stab)) {
249	fp = stab_io(last_in_stab)->ifp;
250	if (!fp) {
251	if (stab_io(last_in_stab)->flags & IOF_ARGV) {
252	if (stab_io(last_in_stab)->flags & IOF_START) {
253	stab_io(last_in_stab)->flags &= ~IOF_START;
254	stab_io(last_in_stab)->lines = 0;
255	if (alen(stab_array(last_in_stab)) < 0) {
256	tmpstr = str_make("-",1); /* assume stdin */
257	(void)apush(stab_array(last_in_stab), tmpstr);
258	}
259	}
260	fp = nextargv(last_in_stab);
261	if (!fp) /* Note: fp != stab_io(last_in_stab)->ifp */
262	(void)do_close(last_in_stab,FALSE); /* now it does*/
263	}
264	else if (argtype == A_GLOB) {
265	(void) interp(str,stab_val(last_in_stab),sp);
266	st = stack->ary_array;
267	tmpstr = Str_new(55,0);
268	if (csh > 0) {
269	str_set(tmpstr,"/bin/csh -cf 'set nonomatch; glob ");
270	str_scat(tmpstr,str);
271	str_cat(tmpstr,"'\|");
272	}
273	else {
274	str_set(tmpstr, "echo ");
275	str_scat(tmpstr,str);
276	str_cat(tmpstr,
277	"\|tr -s ' \t\f\r' '\\012\\012\\012\\012'\|");
278	}
279	(void)do_open(last_in_stab,tmpstr->str_ptr);
280	fp = stab_io(last_in_stab)->ifp;
03a14243	281	str_free(tmpstr);
a687059c	282	}
	283	}
	284	}
	285	if (!fp && dowarn)
	286	warn("Read on closed filehandle <%s>",stab_name(last_in_stab));
	287	keepgoing:
	288	if (!fp)
	289	st[sp] = &str_undef;
	290	else if (!str_gets(str,fp, optype == O_RCAT ? str->str_cur : 0)) {
	291	clearerr(fp);
	292	if (stab_io(last_in_stab)->flags & IOF_ARGV) {
	293	fp = nextargv(last_in_stab);
	294	if (fp)
	295	goto keepgoing;
	296	(void)do_close(last_in_stab,FALSE);
	297	stab_io(last_in_stab)->flags \|= IOF_START;
	298	}
	299	else if (argflags & AF_POST) {
	300	(void)do_close(last_in_stab,FALSE);
	301	}
	302	st[sp] = &str_undef;
	303	record_separator = old_record_separator;
	304	if (gimme == G_ARRAY) {
	305	--sp;
	306	goto array_return;
	307	}
	308	break;
	309	}
	310	else {
	311	stab_io(last_in_stab)->lines++;
	312	st[sp] = str;
	313	#ifdef TAINT
	314	str->str_tainted = 1; /* Anything from the outside world...*/
	315	#endif
	316	if (argflags & AF_POST) {
	317	if (str->str_cur > 0)
	318	str->str_cur--;
	319	if (str->str_ptr[str->str_cur] == record_separator)
	320	str->str_ptr[str->str_cur] = '\0';
	321	else
	322	str->str_cur++;
	323	for (tmps = str->str_ptr; *tmps; tmps++)
	324	if (!isalpha(tmps) && !isdigit(tmps) &&
	325	index("$&(){}[]'\";\\\|?<>~`",tmps))
	326	break;
	327	if (*tmps && stat(str->str_ptr,&statbuf) < 0)
	328	goto keepgoing; /* unmatched wildcard? */
	329	}
	330	if (gimme == G_ARRAY) {
	331	st[sp] = str_static(st[sp]);
	332	if (++sp > stack->ary_max) {
	333	astore(stack, sp, Nullstr);
	334	st = stack->ary_array;
	335	}
	336	goto keepgoing;
	337	}
	338	}
	339	record_separator = old_record_separator;
	340	#ifdef DEBUGGING
	341	tmps = "READ";
	342	#endif
	343	break;
	344	}
	345	#ifdef DEBUGGING
346	if (debug & 8)
347	deb("%d.%s = '%s'\n",anum,tmps,str_peek(st[sp]));
348	#endif
349	if (anum < 8)
350	arglast[anum] = sp;
351	}