/* $RCSfile: eval.c,v $$Revision: 4.0.1.4 $$Date: 92/06/08 13:20:20 $
* Copyright (c) 1991, Larry Wall
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
* Revision 4.0.1.4 92/06/08 13:20:20 lwall
* patch20: added explicit time_t support
* patch20: fixed confusion between a *var's real name and its effective name
* patch20: added Atari ST portability
* patch20: new warning for use of x with non-numeric right operand
* patch20: modulus with highest bit in left operand set didn't always work
* patch20: dbmclose(%array) didn't work
* patch20: added ... as variant on ..
* patch20: O_PIPE conflicted with Atari
* Revision 4.0.1.3 91/11/05 17:15:21 lwall
* patch11: prepared for ctype implementations that don't define isascii()
* patch11: various portability fixes
* patch11: added sort {} LIST
* patch11: sysread() in socket was substituting recv()
* patch11: a last statement outside any block caused occasional core dumps
* patch11: missing arguments caused core dump in -D8 code
* patch11: eval 'stuff' now optimized to eval {stuff}
* Revision 4.0.1.2 91/06/07 11:07:23 lwall
* patch4: new copyright notice
* patch4: length($`), length($&), length($') now optimized to avoid string copy
* patch4: assignment wasn't correctly de-tainting the assigned variable.
* patch4: default top-of-form format is now FILEHANDLE_TOP
* patch4: added $^P variable to control calling of perldb routines
* patch4: taintchecks could improperly modify parent in vfork()
* patch4: many, many itty-bitty portability fixes
* Revision 4.0.1.1 91/04/11 17:43:48 lwall
* patch1: fixed failed fork to return undef as documented
* patch1: reduced maximum branch distance in eval.c
* Revision 4.0 91/03/20 01:16:48 lwall
#if !defined(NSIG) || defined(M_UNIX) || defined(M_XENIX)
/* I_FCNTL *MUST* not be defined for MS-DOS and OS/2
but fcntl.h is required for O_BINARY */
static struct lstring
*lstr
;
double sin(), cos(), atan2(), pow();
int arglast
[8]; /* highest sp for arg--valid only for non-O_LIST args */
double exp(), log(), sqrt(), modf();
char *crypt(), *getenv();
extern void grow_dlevel();
str
= arg
->arg_ptr
.arg_str
;
if (sp
+ maxarg
> stack
->ary_max
)
astore(stack
, sp
+ maxarg
, Nullstr
);
deb("%s (%lx) %d args:\n",opname
[optype
],arg
,maxarg
);
debname
[dlevel
] = opname
[optype
][0];
for (anum
= 1; anum
<= maxarg
; anum
++) {
argflags
= arg
[anum
].arg_flags
;
argtype
= arg
[anum
].arg_type
;
argptr
= arg
[anum
].arg_ptr
;
deb("%d.EXPR =>\n",anum
);
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 */
deb("%d.CMD (%lx) =>\n",anum
,argptr
.arg_cmd
);
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 */
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
);
(void)sprintf(buf
,"LARYSTAB $%s[%d]",stab_name(argptr
.arg_stab
),
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
);
(void)sprintf(buf
,"ARYSTAB $%s[%d]",stab_name(argptr
.arg_stab
),
stab_io(stab
) = stio_new();
(void)sprintf(buf
,"STAR *%s -> *%s",
stab_name(argptr
.arg_stab
), stab_ename(argptr
.arg_stab
));
str
= st
[++sp
] = (STR
*)argptr
.arg_stab
;
(void)sprintf(buf
,"LSTAR *%s -> *%s",
stab_name(argptr
.arg_stab
), stab_ename(argptr
.arg_stab
));
st
[++sp
] = STAB_STR(argptr
.arg_stab
);
(void)sprintf(buf
,"STAB $%s",stab_name(argptr
.arg_stab
));
str_numset(str
, (double)STAB_LEN(argptr
.arg_stab
));
(void)sprintf(buf
,"LENSTAB $%s",stab_name(argptr
.arg_stab
));
deb("%d.LEXPR =>\n",anum
);
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 */
sp
= eval(argptr
.arg_arg
, G_SCALAR
, sp
);
st
= stack
->ary_array
; /* possibly reallocated */
(void)sprintf(buf
,"LVAL $%s",stab_name(argptr
.arg_stab
));
str
= STAB_STR(argptr
.arg_stab
);
str
= arg
->arg_ptr
.arg_str
;
else if (argflags
& AF_POST
) {
st
[sp
] = str_mortal(str
);
str
= arg
->arg_ptr
.arg_str
;
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
));
st
[++sp
] = stab_array(stab
)->ary_magic
;
str_numset(st
[sp
],(double)(stab_array(stab
)->ary_fill
+arybase
));
st
[++sp
] = argptr
.arg_str
;
(void) interp(str
,argptr
.arg_str
,sp
);
tmps
= str_get(interp(str
,argptr
.arg_str
,sp
));
taintproper("Insecure dependency in ``");
while (str_gets(str
,fp
,str
->str_cur
) != Nullch
)
if (++sp
> stack
->ary_max
) {
astore(stack
, sp
, Nullstr
);
str
= st
[sp
] = Str_new(56,80);
if (str_gets(str
,fp
,0) == Nullch
) {
if (str
->str_len
- str
->str_cur
> 20) {
str
->str_len
= str
->str_cur
+1;
Renew(str
->str_ptr
, str
->str_len
, char);
statusvalue
= mypclose(fp
);
if (curcsv
->wantarray
== G_ARRAY
)
last_in_stab
= stabent(str_get(STAB_STR(argptr
.arg_stab
)),TRUE
);
argflags
|= AF_POST
; /* enable newline chopping */
last_in_stab
= argptr
.arg_stab
;
last_in_stab
= argptr
.arg_stab
;
if (anum
> 1) /* assign to scalar */
gimme
= G_SCALAR
; /* force context to scalar */
if (stab_io(last_in_stab
)) {
fp
= stab_io(last_in_stab
)->ifp
;
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
);
str_set(tmpstr
, "perlglob ");
str_nset(tmpstr
,cshname
,cshlen
);
str_cat(tmpstr
," -cf 'set nonomatch; glob ");
str_set(tmpstr
, "echo ");
"|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
;
warn("Read on closed filehandle <%s>",stab_ename(last_in_stab
));
tmplen
= str
->str_len
; /* remember if already alloced */
Str_Grow(str
,80); /* try short-buffering it */
else if (!str_gets(str
,fp
, optype
== O_RCAT
? str
->str_cur
: 0)) {
if (stab_io(last_in_stab
)->flags
& IOF_ARGV
) {
fp
= nextargv(last_in_stab
);
(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
);
stab_io(last_in_stab
)->lines
++;
str
->str_tainted
= 1; /* Anything from the outside world...*/
if (argflags
& AF_POST
) {
if (str
->str_ptr
[str
->str_cur
] == rschar
)
str
->str_ptr
[str
->str_cur
] = '\0';
for (tmps
= str
->str_ptr
; *tmps
; tmps
++)
if (!isALPHA(*tmps
) && !isDIGIT(*tmps
) &&
index("$&*(){}[]'\";\\|?<>~`",*tmps
))
if (*tmps
&& stat(str
->str_ptr
,&statbuf
) < 0)
goto keepgoing
; /* unmatched wildcard? */
if (str
->str_len
- str
->str_cur
> 20) {
str
->str_len
= str
->str_cur
+1;
Renew(str
->str_ptr
, str
->str_len
, char);
if (++sp
> stack
->ary_max
) {
astore(stack
, sp
, Nullstr
);
else if (!tmplen
&& str
->str_len
- str
->str_cur
> 80) {
/* try to reclaim a bit of scalar space on 1st alloc */
str
->str_len
= str
->str_cur
+40; /* allow some slop */
Renew(str
->str_ptr
, str
->str_len
, char);
deb("%d.%s = '%s'\n",anum
,tmps
,str_peek(st
[sp
]));
STR_SSET(str
,st
[arglast
[anum
]-arglast
[0]]);
STR_SSET(str
,st
[arglast
[anum
]-arglast
[0]]);
if (gimme
== G_ARRAY
&& arg
[1].arg_flags
& AF_ARYOK
) {
sp
= do_repeatary(arglast
);
anum
= (int)str_gnum(st
[2]);
str_nset(tmpstr
,tmps
,str
->str_cur
);
tmps
= str_get(tmpstr
); /* force to be string */
STR_GROW(str
, (anum
* str
->str_cur
) + 1);
repeatcpy(str
->str_ptr
, tmps
, tmpstr
->str_cur
, anum
);
str
->str_ptr
[str
->str_cur
] = '\0';
if (dowarn
&& st
[2]->str_pok
&& !looks_like_number(st
[2]))
warn("Right operand of x is not numeric");
str_sset(str
, str_true(str
) ? &str_no
: &str_yes
);
sp
= do_subst(str
,arg
,arglast
[0]);
sp
= do_subst(str
,arg
,arglast
[0]);
str
= arg
->arg_ptr
.arg_str
;
str_set(str
, str_true(str
) ? No
: Yes
);
if (arg
[1].arg_flags
& AF_ARYOK
) {
arg
->arg_type
= O_AASSIGN
;
arg
->arg_type
= O_SASSIGN
;
arglast
[2] = arglast
[1]; /* push a null array */
if (tainted
&& !st
[2]->str_tainted
)
str
= arg
->arg_ptr
.arg_str
;
for (sp
= arglast
[0] + 1; sp
<= arglast
[1]; sp
++)
if (arg
[1].arg_type
& A_DONT
) {
else if (str
->str_pok
|| str
->str_nok
)
if (arg
[1].arg_type
& A_DONT
) {
else if (str
!= stab_val(defstab
)) {
if (str
->str_state
== SS_INCR
)
str
->str_pok
= str
->str_nok
= 0;
value
= pow(value
,str_gnum(st
[2]));
value
*= str_gnum(st
[2]);
if ((value
= str_gnum(st
[2])) == 0.0)
fatal("Illegal division by zero");
/* insure that 20./5. == 4. */
if ((double)(int)x
== x
&&
(double)(int)value
== value
&&
(k
= (int)x
/(int)value
)*(int)value
== (int)x
) {
value
= str_gnum(st
[1]) / value
;
tmpulong
= (unsigned long) str_gnum(st
[2]);
fatal("Illegal modulus zero");
value
= (double)(((unsigned long)value
) % tmpulong
);
value
= (double)(tmpulong
- ((-tmplong
- 1) % tmpulong
)) - 1;
value
+= str_gnum(st
[2]);
value
-= str_gnum(st
[2]);
anum
= (int)str_gnum(st
[2]);
value
= (double)(U_L(value
) << anum
);
anum
= (int)str_gnum(st
[2]);
value
= (double)(U_L(value
) >> anum
);
value
= (value
< str_gnum(st
[2])) ? 1.0 : 0.0;
value
= (value
> str_gnum(st
[2])) ? 1.0 : 0.0;
value
= (value
<= str_gnum(st
[2])) ? 1.0 : 0.0;
value
= (value
>= str_gnum(st
[2])) ? 1.0 : 0.0;
if ((!st
[1]->str_nok
&& !looks_like_number(st
[1])) ||
(!st
[2]->str_nok
&& !looks_like_number(st
[2])) )
warn("Possible use of == on string value");
value
= (value
== str_gnum(st
[2])) ? 1.0 : 0.0;
value
= (value
!= str_gnum(st
[2])) ? 1.0 : 0.0;
value
-= str_gnum(st
[2]);
if (!sawvec
|| st
[1]->str_nok
|| st
[2]->str_nok
) {
value
= (double)(U_L(value
) & U_L(str_gnum(st
[2])));
do_vop(optype
,str
,st
[1],st
[2]);
if (!sawvec
|| st
[1]->str_nok
|| st
[2]->str_nok
) {
value
= (double)(U_L(value
) ^ U_L(str_gnum(st
[2])));
do_vop(optype
,str
,st
[1],st
[2]);
if (!sawvec
|| st
[1]->str_nok
|| st
[2]->str_nok
) {
value
= (double)(U_L(value
) | U_L(str_gnum(st
[2])));
do_vop(optype
,str
,st
[1],st
[2]);
/* use register in evaluating str_true() */
argflags
= arg
[anum
].arg_flags
;
argtype
= arg
[anum
].arg_type
& A_MASK
;
argptr
= arg
[anum
].arg_ptr
;
argflags
= arg
[anum
].arg_flags
;
argtype
= arg
[anum
].arg_type
& A_MASK
;
argptr
= arg
[anum
].arg_ptr
;
anum
= (str_true(st
[1]) ? 2 : 3);
optype
= (anum
== 2 ? O_ITEM2
: O_ITEM3
);
argflags
= arg
[anum
].arg_flags
;
argtype
= arg
[anum
].arg_type
& A_MASK
;
argptr
= arg
[anum
].arg_ptr
;
value
= -str_gnum(st
[1]);
{ char xxx
= str_true(st
[1]); value
= (double) !xxx
; }
value
= (double) !str_true(st
[1]);
if (!sawvec
|| st
[1]->str_nok
) {
value
= (double) ~U_L(str_gnum(st
[1]));
for (anum
= str
->str_cur
; anum
; anum
--, tmps
++)
stab_efullname(str
,defoutstab
);
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
defoutstab
= arg
[1].arg_ptr
.arg_stab
;
defoutstab
= stabent(str_get(st
[1]),TRUE
);
if (!stab_io(defoutstab
))
stab_io(defoutstab
) = stio_new();
else if ((arg
[1].arg_type
& A_MASK
) == A_WORD
) {
if (!(stab
= arg
[1].arg_ptr
.arg_stab
))
stab
= stabent(str_get(st
[1]),TRUE
);
if (stab_io(stab
)->fmt_stab
)
form
= stab_form(stab_io(stab
)->fmt_stab
);
warn("No format for filehandle");
warn("Filehandle only opened for input");
warn("Write on closed filehandle");
do_write(&outrec
,stab
,sp
);
if (stab_io(stab
)->flags
& IOF_FLUSH
)
anum
= arg
[1].arg_type
& A_MASK
;
if (anum
== A_WORD
|| anum
== A_STAB
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
if (st
[3]->str_nok
|| st
[3]->str_pok
)
anum
= (int)str_gnum(st
[3]);
value
= (double)hdbmopen(stab_hash(stab
),str_get(st
[2]),anum
);
fatal("No dbm or ndbm on this machine");
anum
= arg
[1].arg_type
& A_MASK
;
if (anum
== A_WORD
|| anum
== A_STAB
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
hdbmclose(stab_hash(stab
));
fatal("No dbm or ndbm on this machine");
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
if (do_open(stab
,tmps
,st
[2]->str_cur
)) {
value
= (double)forkprocess
;
stab_io(stab
)->lines
= 0;
else if (forkprocess
== 0) /* we are a new child */
value
= (double) do_trans(str
,arg
);
str
= arg
->arg_ptr
.arg_str
;
str_set(arg
->arg_ptr
.arg_str
, do_trans(str
,arg
) == 0 ? Yes
: No
);
str
= arg
->arg_ptr
.arg_str
;
else if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
str_set(str
, do_close(stab
,TRUE
) ? Yes
: No
);
sp
= do_each(str
,stab_hash(arg
[1].arg_ptr
.arg_stab
),
sp
= do_kv(str
,stab_hash(arg
[1].arg_ptr
.arg_stab
), optype
,
str
->str_nok
= str
->str_pok
= 0;
str
->str_u
.str_stab
= arg
[1].arg_ptr
.arg_stab
;
ary
= stab_array(arg
[1].arg_ptr
.arg_stab
);
maxarg
= ary
->ary_fill
+ 1;
if (gimme
== G_ARRAY
) { /* array wanted */
if (maxarg
> 0 && sp
+ maxarg
> stack
->ary_max
) {
astore(stack
,sp
+ maxarg
, Nullstr
);
Copy(ary
->ary_array
, &st
[1], maxarg
, STR
*);
anum
= ((int)str_gnum(st
[2])) - arybase
;
str
= afetch(stab_array(arg
[1].arg_ptr
.arg_stab
),anum
,FALSE
);
tmpstab
= arg
[1].arg_ptr
.arg_stab
;
str
= hdelete(stab_hash(tmpstab
),tmps
,st
[2]->str_cur
);
str
->str_nok
= str
->str_pok
= 0;
str
->str_u
.str_stab
= arg
[1].arg_ptr
.arg_stab
;
str
->str_state
= SS_HASH
;
if (gimme
== G_ARRAY
) { /* array wanted */
sp
= do_kv(str
,stab_hash(arg
[1].arg_ptr
.arg_stab
), optype
,
tmpstab
= arg
[1].arg_ptr
.arg_stab
;
if (!stab_hash(tmpstab
)->tbl_fill
)
sprintf(buf
,"%d/%d",stab_hash(tmpstab
)->tbl_fill
,
stab_hash(tmpstab
)->tbl_max
+1);
tmpstab
= arg
[1].arg_ptr
.arg_stab
;
str
= hfetch(stab_hash(tmpstab
),tmps
,st
[2]->str_cur
,FALSE
);
anum
= ((int)str_gnum(st
[2])) - arybase
;
str
= afetch(stab_array(arg
[1].arg_ptr
.arg_stab
),anum
,TRUE
);
if (!str
|| str
== &str_undef
)
fatal("Assignment to non-creatable value, subscript %d",anum
);
tmpstab
= arg
[1].arg_ptr
.arg_stab
;
str
= hfetch(stab_hash(tmpstab
),tmps
,anum
,TRUE
);
if (!str
|| str
== &str_undef
)
fatal("Assignment to non-creatable value, subscript \"%s\"",tmps
);
if (tmpstab
== envstab
) /* heavy wizardry going on here */
str_magic(str
, tmpstab
, 'E', tmps
, anum
); /* str is now magic */
/* he threw the brick up into the air */
else if (tmpstab
== sigstab
)
str_magic(str
, tmpstab
, 'S', tmps
, anum
);
else if (stab_hash(tmpstab
)->tbl_dbm
)
str_magic(str
, tmpstab
, 'D', tmps
, anum
);
else if (tmpstab
== DBline
)
str_magic(str
, tmpstab
, 'L', tmps
, anum
);
sp
= do_slice(arg
[1].arg_ptr
.arg_stab
,str
,anum
,argtype
,
sp
= do_splice(stab_array(arg
[1].arg_ptr
.arg_stab
),gimme
,arglast
);
if (arglast
[2] - arglast
[1] != 1)
str
= do_push(stab_array(arg
[1].arg_ptr
.arg_stab
),arglast
);
str
= Str_new(51,0); /* must copy the STR */
(void)apush(stab_array(arg
[1].arg_ptr
.arg_stab
),str
);
str
= apop(ary
= stab_array(arg
[1].arg_ptr
.arg_stab
));
str
= ashift(ary
= stab_array(arg
[1].arg_ptr
.arg_stab
));
if (ary
->ary_flags
& ARF_REAL
)
sp
= do_unpack(str
,gimme
,arglast
);
sp
= do_split(str
, arg
[2].arg_ptr
.arg_spat
, (int)value
,
value
= (double)str_len(stab_val(defstab
));
value
= (double)str_len(st
[1]);
do_sprintf(str
, sp
-arglast
[0], st
+1);
anum
= ((int)str_gnum(st
[2])) - arybase
; /* anum=where to start*/
tmps
= str_get(st
[1]); /* force conversion to string */
if (argtype
= (str
== st
[1]))
str
= arg
->arg_ptr
.arg_str
;
anum
+= st
[1]->str_cur
+ arybase
;
if (anum
< 0 || anum
> st
[1]->str_cur
)
optype
= maxarg
< 3 ? st
[1]->str_cur
: (int)str_gnum(st
[3]);
anum
= st
[1]->str_cur
- anum
; /* anum=how many bytes left*/
str_nset(str
, tmps
, anum
);
if (argtype
) { /* it's an lvalue! */
lstr
= (struct lstring
*)str
;
lstr
->lstr_offset
= tmps
- str_get(st
[1]);
(void)do_pack(str
,arglast
);
sp
= do_grep(arg
,str
,gimme
,arglast
);
value
= (double) (str_cmp(st
[1],st
[2]) < 0);
value
= (double) (str_cmp(st
[1],st
[2]) > 0);
value
= (double) (str_cmp(st
[1],st
[2]) <= 0);
value
= (double) (str_cmp(st
[1],st
[2]) >= 0);
value
= (double) str_eq(st
[1],st
[2]);
value
= (double) !str_eq(st
[1],st
[2]);
value
= (double) str_cmp(st
[1],st
[2]);
sp
= do_subr(arg
,gimme
,arglast
);
st
= stack
->ary_array
+ arglast
[0]; /* maybe realloced */
sp
= do_subr(arg
,gimme
,arglast
);
st
= stack
->ary_array
+ arglast
[0]; /* maybe realloced */
sp
= do_caller(arg
,maxarg
,gimme
,arglast
);
st
= stack
->ary_array
+ arglast
[0]; /* maybe realloced */
sp
= do_reverse(arglast
);
sp
= do_sreverse(str
, arglast
);
if (arglast
[2] - arglast
[1] != 1) {
tmps
= "Warning: something's wrong";
if (arglast
[2] - arglast
[1] != 1) {
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
warn("Filehandle never opened");
if (!(fp
= stab_io(stab
)->ofp
)) {
warn("Filehandle opened only for input");
warn("Print on closed filehandle");
if (optype
== O_PRTF
|| arglast
[2] - arglast
[1] != 1)
value
= (double)do_aprint(arg
,fp
,arglast
);
value
= (double)do_print(st
[2],fp
);
if (orslen
&& optype
== O_PRINT
)
if (fwrite(ors
, 1, orslen
, fp
) == 0)
if (stab_io(stab
)->flags
& IOF_FLUSH
)
tmpstr
= hfetch(stab_hash(envstab
),"HOME",4,FALSE
);
tmpstr
= hfetch(stab_hash(envstab
),"LOGDIR",6,FALSE
);
taintproper("Insecure dependency in chdir");
value
= (double)(chdir(tmps
) >= 0);
anum
= (int)str_gnum(st
[1]);
str_reset(tmps
,curcmd
->c_stash
);
str
= st
[sp
- arglast
[0]]; /* unwanted list, return last item */
else if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
str_set(str
, do_eof(stab
) ? Yes
: No
);
else if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
if (!stab
|| do_eof(stab
)) /* make sure we have fp with something */
*str
->str_ptr
= getc(stab_io(stab
)->ifp
); /* should never be EOF */
else if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
value
= (double)do_tell(stab
);
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
anum
= (int)str_gnum(st
[3]);
maxarg
= sp
- arglast
[0];
warn("Too many args on read");
maxarg
= (int)str_gnum(st
[4]);
if (!stab_io(stab
) || !stab_io(stab
)->ifp
)
STR_GROW(st
[2], anum
+1), (tmps
= str_get(st
[2])); /* sneaky */
anum
= recvfrom(fileno(stab_io(stab
)->ifp
), tmps
, anum
, maxarg
,
st
[2]->str_ptr
[anum
] = '\0';
str_nset(str
,buf
,argtype
);
str_sset(str
,&str_undef
);
STR_GROW(st
[2], anum
+maxarg
+1), (tmps
= str_get(st
[2])); /* sneaky */
if (optype
== O_SYSREAD
) {
anum
= read(fileno(stab_io(stab
)->ifp
), tmps
+maxarg
, anum
);
if (stab_io(stab
)->type
== 's') {
anum
= recvfrom(fileno(stab_io(stab
)->ifp
), tmps
+maxarg
, anum
, 0,
anum
= fread(tmps
+maxarg
, 1, anum
, stab_io(stab
)->ifp
);
st
[2]->str_cur
= anum
+maxarg
;
st
[2]->str_ptr
[anum
+maxarg
] = '\0';
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
anum
= (int)str_gnum(st
[3]);
maxarg
= sp
- arglast
[0];
if (!stio
|| !stio
->ifp
) {
if (optype
== O_SYSWRITE
)
warn("Syswrite on closed filehandle");
warn("Send on closed socket");
else if (optype
== O_SYSWRITE
) {
warn("Too many args on syswrite");
optype
= (int)str_gnum(st
[4]);
anum
= write(fileno(stab_io(stab
)->ifp
), tmps
+optype
, anum
);
warn("Too many args on send");
anum
= sendto(fileno(stab_io(stab
)->ifp
), tmps
, st
[2]->str_cur
,
anum
, tmps2
, st
[4]->str_cur
);
anum
= send(fileno(stab_io(stab
)->ifp
), tmps
, st
[2]->str_cur
, anum
);
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
str_set(str
, do_seek(stab
,
(long)value
, (int)str_gnum(st
[3]) ) ? Yes
: No
);
tmps
= "_SUB_"; /* just fake up a "last _SUB_" */
if (curcsv
&& curcsv
->wantarray
== G_ARRAY
) {
lastsize
= arglast
[2] - arglast
[1];
lastretstr
= str_mortal(st
[arglast
[2] - arglast
[0]]);
tmps
= str_get(arg
[1].arg_ptr
.arg_str
);
while (loop_ptr
>= 0 && (!loop_stack
[loop_ptr
].loop_label
||
strNE(tmps
,loop_stack
[loop_ptr
].loop_label
) )) {
deb("(Skipping label #%d %s)\n",loop_ptr
,
loop_stack
[loop_ptr
].loop_label
);
deb("(Found label #%d %s)\n",loop_ptr
,
loop_stack
[loop_ptr
].loop_label
);
if (tmps
&& strEQ(tmps
, "_SUB_"))
fatal("Can't return outside a subroutine");
fatal("Bad label: %s", maxarg
> 0 ? tmps
: "<null>");
if (!lastretstr
&& optype
== O_LAST
&& lastsize
) {
optype
= loop_stack
[loop_ptr
].loop_sp
- lastspbase
; /* negative */
for (anum
= lastsize
; anum
> 0; anum
--,st
++)
st
[optype
] = str_mortal(st
[0]);
longjmp(loop_stack
[loop_ptr
].loop_env
, O_LAST
);
longjmp(loop_stack
[loop_ptr
].loop_env
, optype
);
case O_GOTO
:/* shudder */
goto_targ
= str_get(arg
[1].arg_ptr
.arg_str
);
goto_targ
= Nullch
; /* just restart from top */
anum
= (int) str_gnum(st
[3]) - arybase
;
else if (anum
> st
[1]->str_cur
)
if (!(tmps2
= fbminstr((unsigned char*)tmps
+ anum
,
(unsigned char*)tmps
+ st
[1]->str_cur
, st
[2])))
if (tmps2
= fbminstr(Null(unsigned char*),Null(unsigned char*),Nullstr
))
value
= (double)(-1 + arybase
);
value
= (double)(tmps2
- tmps
+ arybase
);
anum
= (int) str_gnum(st
[3]) - arybase
+ st
[2]->str_cur
;
else if (anum
> st
[1]->str_cur
)
if (!(tmps2
= rninstr(tmps
, tmps
+ anum
,
tmps2
, tmps2
+ st
[2]->str_cur
)))
if (tmps2
= rninstr(Nullch
,Nullch
,Nullch
,Nullch
))
value
= (double)(-1 + arybase
);
value
= (double)(tmps2
- tmps
+ arybase
);
value
= (double) time(Null(long*));
sp
= do_tms(str
,gimme
,arglast
);
when
= (time_t)str_gnum(st
[1]);
sp
= do_time(str
,localtime(&when
),
when
= (time_t)str_gnum(st
[1]);
sp
= do_time(str
,gmtime(&when
),
sp
= do_truncate(str
,arg
,
str_set(str
,fcrypt(tmps
,str_get(st
[2])));
str_set(str
,crypt(tmps
,str_get(st
[2])));
"The crypt() function is unimplemented due to excessive paranoia.");
value
= atan2(value
,str_gnum(st
[2]));
value
= str_gnum(stab_val(defstab
));
value
= str_gnum(stab_val(defstab
));
value
= rand() * value
/ 2147483648.0;
value
= rand() * value
/ 65536.0;
value
= rand() * value
/ 32768.0;
value
= rand() * value
/ (double)(((unsigned long)1) << RANDBITS
);
anum
= (int)str_gnum(st
[1]);
value
= str_gnum(stab_val(defstab
));
value
= str_gnum(stab_val(defstab
));
fatal("Can't take log of %g\n", value
);
value
= str_gnum(stab_val(defstab
));
fatal("Can't take sqrt of %g\n", value
);
value
= str_gnum(stab_val(defstab
));
(void)modf(value
,&value
);
(void)modf(-value
,&value
);
tmps
= str_get(stab_val(defstab
));
value
= (double) (*tmps
& 255);
value
= (double) (anum
& 255);
tmps
= str_get(stab_val(defstab
));
anum
= alarm((unsigned int)atoi(tmps
));
fatal("Unsupported function alarm");
sleep((32767<<16)+32767);
sleep((unsigned int)atoi(tmps
));
value
= ((double)when
) - value
;
sp
= do_range(gimme
,arglast
);
if (gimme
== G_ARRAY
) { /* it's a range */
/* can we optimize to constant array? */
if ((arg
[1].arg_type
& A_MASK
) == A_SINGLE
&&
(arg
[2].arg_type
& A_MASK
) == A_SINGLE
) {
st
[2] = arg
[2].arg_ptr
.arg_str
;
sp
= do_range(gimme
,arglast
);
maxarg
= sp
- arglast
[0];
str_free(arg
[1].arg_ptr
.arg_str
);
arg
[1].arg_ptr
.arg_str
= Nullstr
;
str_free(arg
[2].arg_ptr
.arg_str
);
arg
[2].arg_ptr
.arg_str
= Nullstr
;
arg
[1].arg_type
= A_STAB
|A_DONT
;
stab
= arg
[1].arg_ptr
.arg_stab
= aadd(genstab());
ary
->ary_array
[maxarg
] = str_smake(st
[maxarg
]);
arg
->arg_type
= optype
= O_RANGE
;
maxarg
= arg
->arg_len
= 2;
arg
[anum
].arg_flags
&= ~AF_ARYOK
;
argflags
= arg
[anum
].arg_flags
;
argtype
= arg
[anum
].arg_type
& A_MASK
;
arg
[anum
].arg_type
= argtype
;
argptr
= arg
[anum
].arg_ptr
;
if ((arg
[1].arg_type
& A_MASK
) == A_SINGLE
?
last_in_stab
&& (int)str_gnum(st
[1]) == stab_io(last_in_stab
)->lines
arg
[2].arg_type
&= ~A_DONT
;
arg
[1].arg_type
|= A_DONT
;
arg
->arg_type
= optype
= O_FLOP
;
if (arg
->arg_flags
& AF_COMMON
) {
argflags
= arg
[2].arg_flags
;
argtype
= arg
[2].arg_type
& A_MASK
;
if ((arg
[2].arg_type
& A_MASK
) == A_SINGLE
?
last_in_stab
&& (int)str_gnum(st
[2]) == stab_io(last_in_stab
)->lines
arg
[1].arg_type
&= ~A_DONT
;
arg
[2].arg_type
|= A_DONT
;
if (tmpstab
= stabent("$",allstabs
))
str_numset(STAB_STR(tmpstab
),(double)getpid());
hclear(pidstatus
, FALSE
); /* no kids, so don't wait for 'em */
fatal("Unsupported function fork");
statusvalue
= (unsigned short)argflags
;
fatal("Unsupported function wait");
anum
= (int)str_gnum(st
[1]);
optype
= (int)str_gnum(st
[2]);
anum
= wait4pid(anum
, &argflags
,optype
);
statusvalue
= (unsigned short)argflags
;
fatal("Unsupported function wait");
if (arglast
[2] - arglast
[1] == 1) {
tainted
|= st
[2]->str_tainted
;
taintproper("Insecure dependency in system");
while ((anum
= vfork()) == -1) {
ihand
= signal(SIGINT
, SIG_IGN
);
qhand
= signal(SIGQUIT
, SIG_IGN
);
argtype
= wait4pid(anum
, &argflags
, 0);
(void)signal(SIGINT
, ihand
);
(void)signal(SIGQUIT
, qhand
);
statusvalue
= (unsigned short)argflags
;
value
= (double)((unsigned int)argflags
& 0xffff);
do_execfree(); /* free any memory child malloced on vfork */
if ((arg
[1].arg_type
& A_MASK
) == A_STAB
)
value
= (double)do_aexec(st
[1],arglast
);
else if (arglast
[2] - arglast
[1] != 1)
value
= (double)do_aexec(Nullstr
,arglast
);
value
= (double)do_exec(str_get(str_mortal(st
[2])));
if ((arg
[1].arg_type
& A_MASK
) == A_STAB
)
value
= (double)do_aspawn(st
[1],arglast
);
else if (arglast
[2] - arglast
[1] != 1)
value
= (double)do_aspawn(Nullstr
,arglast
);
value
= (double)do_spawn(str_get(str_mortal(st
[2])));
if ((arg
[1].arg_type
& A_MASK
) == A_STAB
)
value
= (double)do_aexec(st
[1],arglast
);
else if (arglast
[2] - arglast
[1] != 1)
value
= (double)do_aexec(Nullstr
,arglast
);
tainted
|= st
[2]->str_tainted
;
taintproper("Insecure dependency in exec");
value
= (double)do_exec(str_get(str_mortal(st
[2])));
tmps
= str_get(stab_val(defstab
));
value
= (double)scanhex(tmps
, 99, &argtype
);
tmps
= str_get(stab_val(defstab
));
while (*tmps
&& (isSPACE(*tmps
) || *tmps
== '0'))
value
= (double)scanhex(++tmps
, 99, &argtype
);
value
= (double)scanoct(tmps
, 99, &argtype
);
/* These common exits are hidden here in the middle of the switches for the
benefit of those machines with limited branch addressing. Sigh. */
deb("%s RETURNS ()\n",opname
[optype
]);
deb("%s RETURNS (\"%s\")\n",opname
[optype
],
st
[1] ? str_get(st
[1]) : "");
tmps
= st
[1] ? str_get(st
[1]) : "";
deb("%s RETURNS %d ARGS (\"%s\",%s\"%s\")\n",opname
[optype
],
anum
,tmps
,anum
==2?"":"...,",
st
[anum
] ? str_get(st
[anum
]) : "");
deb("%s RETURNS \"%f\"\n",opname
[optype
],value
);
value
= (double)apply(optype
,arglast
);
fatal("Unsupported function chown");
value
= (double)apply(optype
,arglast
);
fatal("Unsupported function kill");
value
= (double)apply(optype
,arglast
);
anum
= umask((int)str_gnum(st
[1]));
taintproper("Insecure dependency in umask");
fatal("Unsupported function umask");
#if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
if ((anum
= do_ipcget(optype
, arglast
)) == -1)
anum
= do_ipcctl(optype
, arglast
);
str_set(str
,"0 but true");
value
= (double)(do_msgsnd(arglast
) >= 0);
value
= (double)(do_msgrcv(arglast
) >= 0);
value
= (double)(do_semop(arglast
) >= 0);
value
= (double)(do_shmio(optype
, arglast
) >= 0);
fatal("System V IPC is not implemented on this machine");
taintproper("Insecure dependency in rename");
value
= (double)(rename(tmps
,tmps2
) >= 0);
if (same_dirent(tmps2
, tmps
)) /* can always rename to same name */
if (euid
|| stat(tmps2
,&statbuf
) < 0 || !S_ISDIR(statbuf
.st_mode
))
if (!(anum
= link(tmps
,tmps2
)))
value
= (double)(anum
>= 0);
taintproper("Insecure dependency in link");
value
= (double)(link(tmps
,tmps2
) >= 0);
fatal("Unsupported function link");
anum
= (int)str_gnum(st
[2]);
taintproper("Insecure dependency in mkdir");
value
= (double)(mkdir(tmps
,anum
) >= 0);
(void)strcpy(buf
,"mkdir ");
#if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
for (tmps2
= buf
+6; *tmps
; ) {
(void)strcpy(tmps2
," 2>&1");
tmps2
= fgets(buf
,sizeof buf
,rsfp
);
for (errno
= 1; errno
< sys_nerr
; errno
++) {
if (instr(buf
,sys_errlist
[errno
])) /* you don't see this */
if (instr(buf
,"cannot make"))
else if (instr(buf
,"existing file"))
else if (instr(buf
,"ile exists"))
else if (instr(buf
,"non-exist"))
else if (instr(buf
,"does not exist"))
else if (instr(buf
,"not empty"))
else if (instr(buf
,"cannot access"))
else { /* some mkdirs return no failure indication */
anum
= (stat(tmps
,&statbuf
) >= 0);
errno
= EACCES
; /* a guess */
tmps
= str_get(stab_val(defstab
));
taintproper("Insecure dependency in rmdir");
value
= (double)(rmdir(tmps
) >= 0);
(void)strcpy(buf
,"rmdir ");
goto one_liner
; /* see above in HAS_MKDIR */
value
= (double)getppid();
fatal("Unsupported function getppid");
anum
= (int)str_gnum(st
[1]);
fatal("POSIX getpgrp can't take an argument");
value
= (double)getpgrp();
value
= (double)getpgrp(anum
);
fatal("The getpgrp() function is unimplemented on this machine");
argtype
= (int)str_gnum(st
[1]);
anum
= (int)str_gnum(st
[2]);
taintproper("Insecure dependency in setpgrp");
value
= (double)(setpgrp(argtype
,anum
) >= 0);
fatal("The setpgrp() function is unimplemented on this machine");
argtype
= (int)str_gnum(st
[1]);
anum
= (int)str_gnum(st
[2]);
value
= (double)getpriority(argtype
,anum
);
fatal("The getpriority() function is unimplemented on this machine");
argtype
= (int)str_gnum(st
[1]);
anum
= (int)str_gnum(st
[2]);
optype
= (int)str_gnum(st
[3]);
taintproper("Insecure dependency in setpriority");
value
= (double)(setpriority(argtype
,anum
,optype
) >= 0);
fatal("The setpriority() function is unimplemented on this machine");
tmps
= str_get(stab_val(defstab
));
taintproper("Insecure dependency in chroot");
value
= (double)(chroot(tmps
) >= 0);
fatal("Unsupported function chroot");
else if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
argtype
= U_I(str_gnum(st
[2]));
taintproper("Insecure dependency in ioctl");
anum
= do_ctl(optype
,stab
,argtype
,st
[3]);
str_set(str
,"0 but true");
else if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
if (stab
&& stab_io(stab
))
argtype
= (int)str_gnum(st
[2]);
value
= (double)(flock(fileno(fp
),argtype
) >= 0);
fatal("The flock() function is unimplemented on this machine");
ary
= stab_array(arg
[1].arg_ptr
.arg_stab
);
if (arglast
[2] - arglast
[1] != 1)
STR
*tmpstr
= Str_new(52,0); /* must copy the STR */
(void)astore(ary
,0,tmpstr
);
value
= (double)(ary
->ary_fill
+ 1);
sp
= do_try(arg
[1].arg_ptr
.arg_cmd
,
sp
= do_eval(st
[1], O_EVAL
, curcmd
->c_stash
, TRUE
,
str_free(arg
[1].arg_ptr
.arg_str
);
arg
[1].arg_ptr
.arg_cmd
= eval_root
;
arg
[1].arg_type
= (A_CMD
|A_DONT
);
tmpstr
= stab_val(defstab
);
(arg
[1].arg_type
& A_MASK
) != A_NULL
? st
[1] : stab_val(defstab
);
tainted
|= tmpstr
->str_tainted
;
taintproper("Insecure dependency in eval");
sp
= do_eval(tmpstr
, optype
, curcmd
->c_stash
, FALSE
,
if (mystat(arg
,st
[1]) < 0)
if (cando(anum
,argtype
,&statcache
))
if (mystat(arg
,st
[1]) < 0)
if (mystat(arg
,st
[1]) < 0)
if (statcache
.st_uid
== (optype
== O_FTEOWNED
? euid
: uid
) )
if (mystat(arg
,st
[1]) < 0)
if (mystat(arg
,st
[1]) < 0)
value
= (double)statcache
.st_size
;
if (mystat(arg
,st
[1]) < 0)
value
= (double)(basetime
- statcache
.st_mtime
) / 86400.0;
if (mystat(arg
,st
[1]) < 0)
value
= (double)(basetime
- statcache
.st_atime
) / 86400.0;
if (mystat(arg
,st
[1]) < 0)
value
= (double)(basetime
- statcache
.st_ctime
) / 86400.0;
if (mystat(arg
,st
[1]) < 0)
if (S_ISSOCK(statcache
.st_mode
))
if (mystat(arg
,st
[1]) < 0)
if (S_ISCHR(statcache
.st_mode
))
if (mystat(arg
,st
[1]) < 0)
if (S_ISBLK(statcache
.st_mode
))
if (mystat(arg
,st
[1]) < 0)
if (S_ISREG(statcache
.st_mode
))
if (mystat(arg
,st
[1]) < 0)
if (S_ISDIR(statcache
.st_mode
))
if (mystat(arg
,st
[1]) < 0)
if (S_ISFIFO(statcache
.st_mode
))
if (mylstat(arg
,st
[1]) < 0)
if (S_ISLNK(statcache
.st_mode
))
taintproper("Insecure dependency in symlink");
value
= (double)(symlink(tmps
,tmps2
) >= 0);
fatal("Unsupported function symlink");
tmps
= str_get(stab_val(defstab
));
anum
= readlink(tmps
,buf
,sizeof buf
);
goto say_undef
; /* just pretend it's a normal file */
if (mystat(arg
,st
[1]) < 0)
if (statcache
.st_mode
& anum
)
if (arg
[1].arg_type
& A_DONT
) {
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(tmps
= str_get(st
[1]),FALSE
);
if (stab
&& stab_io(stab
) && stab_io(stab
)->ifp
)
anum
= fileno(stab_io(stab
)->ifp
);
str
= do_fttext(arg
,st
[1]);
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
value
= (double)do_socket(stab
,arglast
);
(void)do_socket(stab
,arglast
);
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
value
= (double)do_bind(stab
,arglast
);
(void)do_bind(stab
,arglast
);
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
value
= (double)do_connect(stab
,arglast
);
(void)do_connect(stab
,arglast
);
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
value
= (double)do_listen(stab
,arglast
);
(void)do_listen(stab
,arglast
);
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
if ((arg
[2].arg_type
& A_MASK
) == A_WORD
)
stab2
= arg
[2].arg_ptr
.arg_stab
;
stab2
= stabent(str_get(st
[2]),TRUE
);
do_accept(str
,stab
,stab2
);
value
= (double) sethostent((int)str_gnum(st
[1]));
value
= (double) setnetent((int)str_gnum(st
[1]));
value
= (double) setprotoent((int)str_gnum(st
[1]));
value
= (double) setservent((int)str_gnum(st
[1]));
value
= (double) endhostent();
value
= (double) endnetent();
value
= (double) endprotoent();
value
= (double) endservent();
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
if ((arg
[2].arg_type
& A_MASK
) == A_WORD
)
stab2
= arg
[2].arg_ptr
.arg_stab
;
stab2
= stabent(str_get(st
[2]),TRUE
);
value
= (double)do_spair(stab
,stab2
,arglast
);
(void)do_spair(stab
,stab2
,arglast
);
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
value
= (double)do_shutdown(stab
,arglast
);
(void)do_shutdown(stab
,arglast
);
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
sp
= do_sopt(optype
,stab
,arglast
);
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
sp
= do_getsockname(optype
,stab
,arglast
);
#else /* HAS_SOCKET not defined */
fatal("Unsupported socket function");
sp
= do_select(gimme
,arglast
);
fatal("select not implemented");
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
if (!stab
|| !(stio
= stab_io(stab
)) || !(fp
= stio
->ifp
))
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
if (!stab
|| !(stio
= stab_io(stab
)) || !(fp
= stio
->ifp
))
str_set(str
, (setmode(fileno(fp
), O_BINARY
) != -1) ? Yes
: No
);
sp
= do_vec(str
== st
[1], arg
->arg_ptr
.arg_str
, arglast
);
value
= (double) setpwent();
value
= (double) endpwent();
fatal("Unsupported password function");
value
= (double) setgrent();
value
= (double) endgrent();
fatal("Unsupported group function");
if (!(tmps
= getlogin()))
fatal("Unsupported function getlogin");
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
sp
= do_dirop(optype
,stab
,gimme
,arglast
);
value
= (double)do_syscall(arglast
);
if ((arg
[1].arg_type
& A_MASK
) == A_WORD
)
stab
= arg
[1].arg_ptr
.arg_stab
;
stab
= stabent(str_get(st
[1]),TRUE
);
if ((arg
[2].arg_type
& A_MASK
) == A_WORD
)
stab2
= arg
[2].arg_ptr
.arg_stab
;
stab2
= stabent(str_get(st
[2]),TRUE
);
fatal("Unsupported function pipe");
deb("%s RETURNS \"%s\"\n",opname
[optype
],str_get(str
));