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