1 /* $Header: doarg.c,v 3.0.1.5 90/03/27 15:39:03 lwall Locked $
3 * Copyright (c) 1989, Larry Wall
5 * You may distribute under the terms of the GNU General Public License
6 * as specified in the README file that comes with the perl 3.0 kit.
9 * Revision 3.0.1.5 90/03/27 15:39:03 lwall
10 * patch16: MSDOS support
11 * patch16: support for machines that can't cast negative floats to unsigned ints
12 * patch16: sprintf($s,...,$s,...) didn't work
14 * Revision 3.0.1.4 90/03/12 16:28:42 lwall
15 * patch13: pack of ascii strings could call str_ncat() with negative length
16 * patch13: printf("%s", *foo) was busted
18 * Revision 3.0.1.3 90/02/28 16:56:58 lwall
19 * patch9: split now can split into more than 10000 elements
20 * patch9: sped up pack and unpack
21 * patch9: pack of unsigned ints and longs blew up some places
22 * patch9: sun3 can't cast negative float to unsigned int or long
23 * patch9: local($.) didn't work
24 * patch9: grep(s/foo/bar/, @abc = @xyz) modified @xyz rather than @abc
25 * patch9: syscall returned stack size rather than value of system call
27 * Revision 3.0.1.2 89/12/21 19:52:15 lwall
28 * patch7: a pattern wouldn't match a null string before the first character
29 * patch7: certain patterns didn't match correctly at end of string
31 * Revision 3.0.1.1 89/11/11 04:17:20 lwall
32 * patch2: printf %c, %D, %X and %O didn't work right
33 * patch2: printf of unsigned vs signed needed separate casts on some machines
35 * Revision 3.0 89/10/18 15:10:41 lwall
45 extern unsigned char fold[];
50 #pragma function(memcmp)
51 #endif /* BUGGY_MSC */
62 register char *s = str_get(str);
63 char *strend = s + str->str_cur;
69 int maxiters = (strend - s) + 10;
75 rspat = spat = arg[2].arg_ptr.arg_spat;
77 fatal("panic: do_subst");
78 else if (spat->spat_runtime) {
80 (void)eval(spat->spat_runtime,G_SCALAR,sp);
81 m = str_get(dstr = stack->ary_array[sp+1]);
83 if (spat->spat_regexp)
84 regfree(spat->spat_regexp);
85 spat->spat_regexp = regcomp(m,m+dstr->str_cur,
86 spat->spat_flags & SPAT_FOLD,1);
87 if (spat->spat_flags & SPAT_KEEP) {
88 arg_free(spat->spat_runtime); /* it won't change, so */
89 spat->spat_runtime = Nullarg; /* no point compiling again */
94 deb("2.SPAT /%s/\n",spat->spat_regexp->precomp);
97 safebase = ((!spat->spat_regexp || !spat->spat_regexp->nparens) &&
99 if (!*spat->spat_regexp->precomp && lastspat)
103 if (hint < s || hint > strend)
104 fatal("panic: hint in do_match");
107 if (spat->spat_regexp->regback >= 0) {
108 s -= spat->spat_regexp->regback;
115 else if (spat->spat_short) {
116 if (spat->spat_flags & SPAT_SCANFIRST) {
117 if (str->str_pok & SP_STUDIED) {
118 if (screamfirst[spat->spat_short->str_rare] < 0)
120 else if (!(s = screaminstr(str,spat->spat_short)))
124 else if (!(s = fbminstr((unsigned char*)s, (unsigned char*)strend,
128 if (s && spat->spat_regexp->regback >= 0) {
129 ++spat->spat_short->str_u.str_useful;
130 s -= spat->spat_regexp->regback;
137 else if (!multiline && (*spat->spat_short->str_ptr != *s ||
138 bcmp(spat->spat_short->str_ptr, s, spat->spat_slen) ))
140 if (--spat->spat_short->str_u.str_useful < 0) {
141 str_free(spat->spat_short);
142 spat->spat_short = Nullstr; /* opt is being useless */
145 once = ((rspat->spat_flags & SPAT_ONCE) != 0);
146 if (rspat->spat_flags & SPAT_CONST) { /* known replacement string? */
147 if ((rspat->spat_repl[1].arg_type & A_MASK) == A_SINGLE)
148 dstr = rspat->spat_repl[1].arg_ptr.arg_str;
149 else { /* constant over loop, anyway */
150 (void)eval(rspat->spat_repl,G_SCALAR,sp);
151 dstr = stack->ary_array[sp+1];
154 clen = dstr->str_cur;
155 if (clen <= spat->spat_slen + spat->spat_regexp->regback) {
156 /* can do inplace substitution */
157 if (regexec(spat->spat_regexp, s, strend, orig, 0,
158 str->str_pok & SP_STUDIED ? str : Nullstr, safebase)) {
159 if (spat->spat_regexp->subbase) /* oops, no we can't */
163 str->str_pok = SP_VALID; /* disable possible screamer */
165 m = spat->spat_regexp->startp[0];
166 d = spat->spat_regexp->endp[0];
168 if (m - s > strend - d) { /* faster to shorten from end */
170 (void)bcopy(c, m, clen);
175 (void)bcopy(d, m, i);
179 str->str_cur = m - s;
181 str_numset(arg->arg_ptr.arg_str, 1.0);
182 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
185 else if (i = m - s) { /* faster from front */
193 (void)bcopy(c, m, clen);
195 str_numset(arg->arg_ptr.arg_str, 1.0);
196 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
202 (void)bcopy(c,d,clen);
204 str_numset(arg->arg_ptr.arg_str, 1.0);
205 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
211 str_numset(arg->arg_ptr.arg_str, 1.0);
212 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
218 if (iters++ > maxiters)
219 fatal("Substitution loop");
220 m = spat->spat_regexp->startp[0];
227 (void)bcopy(c,d,clen);
230 s = spat->spat_regexp->endp[0];
231 } while (regexec(spat->spat_regexp, s, strend, orig, s == m,
232 Nullstr, TRUE)); /* (don't match same null twice) */
235 str->str_cur = d - str->str_ptr + i;
236 (void)bcopy(s,d,i+1); /* include the Null */
239 str_numset(arg->arg_ptr.arg_str, (double)iters);
240 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
243 str_numset(arg->arg_ptr.arg_str, 0.0);
244 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
250 if (regexec(spat->spat_regexp, s, strend, orig, 0,
251 str->str_pok & SP_STUDIED ? str : Nullstr, safebase)) {
253 dstr = Str_new(25,str_len(str));
254 str_nset(dstr,m,s-m);
255 if (spat->spat_regexp->subbase)
259 if (iters++ > maxiters)
260 fatal("Substitution loop");
261 if (spat->spat_regexp->subbase
262 && spat->spat_regexp->subbase != orig) {
265 orig = spat->spat_regexp->subbase;
267 strend = s + (strend - m);
269 m = spat->spat_regexp->startp[0];
270 str_ncat(dstr,s,m-s);
271 s = spat->spat_regexp->endp[0];
274 str_ncat(dstr,c,clen);
277 (void)eval(rspat->spat_repl,G_SCALAR,sp);
278 str_scat(dstr,stack->ary_array[sp+1]);
282 } while (regexec(spat->spat_regexp, s, strend, orig, s == m, Nullstr,
284 str_ncat(dstr,s,strend - s);
285 str_replace(str,dstr);
287 str_numset(arg->arg_ptr.arg_str, (double)iters);
288 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
291 str_numset(arg->arg_ptr.arg_str, 0.0);
292 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
296 ++spat->spat_short->str_u.str_useful;
297 str_numset(arg->arg_ptr.arg_str, 0.0);
298 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
302 #pragma intrinsic(memcmp)
303 #endif /* BUGGY_MSC */
312 register int matches = 0;
316 tbl = arg[2].arg_ptr.arg_cval;
318 send = s + str->str_cur;
320 fatal("panic: do_trans");
327 if (ch = tbl[*s & 0377]) {
342 register STR **st = stack->ary_array;
343 register int sp = arglast[1];
344 register int items = arglast[2] - sp;
345 register char *delim = str_get(st[sp]);
346 int delimlen = st[sp]->str_cur;
353 for (; items > 0; items--,st++) {
354 str_ncat(str,delim,delimlen);
365 register STR **st = stack->ary_array;
366 register int sp = arglast[1];
368 register char *pat = str_get(st[sp]);
369 register char *patend = pat + st[sp]->str_cur;
373 static char *null10 = "\0\0\0\0\0\0\0\0\0\0";
374 static char *space10 = " ";
376 /* These must not be in registers: */
382 unsigned long aulong;
385 items = arglast[2] - sp;
388 while (pat < patend) {
389 #define NEXTFROM (items-- > 0 ? *st++ : &str_no)
393 while (isdigit(*pat))
394 len = (len * 10) + (*pat++ - '0');
403 str_ncat(str,null10,10);
406 str_ncat(str,null10,len);
411 aptr = str_get(fromstr);
412 if (fromstr->str_cur > len)
413 str_ncat(str,aptr,len);
415 str_ncat(str,aptr,fromstr->str_cur);
416 len -= fromstr->str_cur;
417 if (datumtype == 'A') {
419 str_ncat(str,space10,10);
422 str_ncat(str,space10,len);
426 str_ncat(str,null10,10);
429 str_ncat(str,null10,len);
437 aint = (int)str_gnum(fromstr);
439 str_ncat(str,&achar,sizeof(char));
445 ashort = (short)str_gnum(fromstr);
447 ashort = htons(ashort);
449 str_ncat(str,(char*)&ashort,sizeof(short));
456 ashort = (short)str_gnum(fromstr);
457 str_ncat(str,(char*)&ashort,sizeof(short));
463 auint = U_I(str_gnum(fromstr));
464 str_ncat(str,(char*)&auint,sizeof(unsigned int));
470 aint = (int)str_gnum(fromstr);
471 str_ncat(str,(char*)&aint,sizeof(int));
477 along = (long)str_gnum(fromstr);
479 along = htonl(along);
481 str_ncat(str,(char*)&along,sizeof(long));
487 aulong = U_L(str_gnum(fromstr));
488 str_ncat(str,(char*)&aulong,sizeof(unsigned long));
494 along = (long)str_gnum(fromstr);
495 str_ncat(str,(char*)&along,sizeof(long));
501 aptr = str_get(fromstr);
502 str_ncat(str,(char*)&aptr,sizeof(char*));
512 do_sprintf(str,len,sarg)
521 static STR *sargnull = &str_no;
529 len--; /* don't count pattern string */
530 origs = s = str_get(*sarg);
531 send = s + (*sarg)->str_cur;
533 for ( ; s < send; len--) {
534 if (len <= 0 || !*sarg) {
539 for (t = s; t < send && *t != '%'; t++) ;
541 break; /* not enough % patterns, oh well */
542 for (t++; *sarg && t < send && t != s; t++) {
547 (void)sprintf(buf,s);
552 case '0': case '1': case '2': case '3': case '4':
553 case '5': case '6': case '7': case '8': case '9':
554 case '.': case '#': case '-': case '+':
562 xlen = (int)str_gnum(*(sarg++));
563 if (strEQ(t-2,"%c")) { /* some printfs fail on null chars */
565 str_ncat(str,s,t - s - 2);
566 str_ncat(str,buf,1); /* so handle simple case */
570 (void)sprintf(buf,s,xlen);
581 (void)sprintf(buf,s,(long)str_gnum(*(sarg++)));
583 (void)sprintf(buf,s,(int)str_gnum(*(sarg++)));
590 case 'x': case 'o': case 'u':
593 value = str_gnum(*(sarg++));
595 (void)sprintf(buf,s,U_L(value));
597 (void)sprintf(buf,s,U_I(value));
601 case 'E': case 'e': case 'f': case 'G': case 'g':
604 (void)sprintf(buf,s,str_gnum(*(sarg++)));
612 xlen = (*sarg)->str_cur;
613 if (*xs == 'S' && xs[1] == 't' && xs[2] == 'B'
614 && xlen == sizeof(STBP) && strlen(xs) < xlen) {
615 xs = stab_name(((STAB*)(*sarg))); /* a stab value! */
616 sprintf(tokenbuf,"*%s",xs); /* reformat to non-binary */
618 xlen = strlen(tokenbuf);
620 if (strEQ(t-2,"%s")) { /* some printfs fail on >128 chars */
622 str_ncat(str,s,t - s - 2);
624 str_ncat(str,xs,xlen); /* so handle simple case */
627 if (origs == xs) { /* sprintf($s,...$s...) */
628 strcpy(tokenbuf+64,s);
632 (void)sprintf(buf,s,xs);
640 if (s < t && t >= send) {
648 (void)sprintf(buf,s,0,0,0,0);
659 register STR **st = stack->ary_array;
660 register int sp = arglast[1];
661 register int items = arglast[2] - sp;
662 register STR *str = &str_undef;
664 for (st += ++sp; items > 0; items--,st++) {
668 (void)apush(ary,str);
674 do_unshift(ary,arglast)
678 register STR **st = stack->ary_array;
679 register int sp = arglast[1];
680 register int items = arglast[2] - sp;
686 for (st += ++sp; i < items; i++,st++) {
689 (void)astore(ary,i,str);
694 do_subr(arg,gimme,arglast)
699 register STR **st = stack->ary_array;
700 register int sp = arglast[1];
701 register int items = arglast[2] - sp;
705 char *oldfile = filename;
706 int oldsave = savestack->ary_fill;
707 int oldtmps_base = tmps_base;
709 if ((arg[1].arg_type & A_MASK) == A_WORD)
710 stab = arg[1].arg_ptr.arg_stab;
712 STR *tmpstr = stab_val(arg[1].arg_ptr.arg_stab);
715 stab = stabent(str_get(tmpstr),TRUE);
720 fatal("Undefined subroutine called");
721 sub = stab_sub(stab);
723 fatal("Undefined subroutine \"%s\" called", stab_name(stab));
724 if ((arg[2].arg_type & A_MASK) != A_NULL) {
725 savearray = stab_xarray(defstab);
726 stab_xarray(defstab) = afake(defstab, items, &st[sp+1]);
728 savelong(&sub->depth);
732 if (sub->depth >= 2) { /* save temporaries on recursion? */
733 if (sub->depth == 100 && dowarn)
734 warn("Deep recursion on subroutine \"%s\"",stab_name(stab));
735 savelist(sub->tosave->ary_array,sub->tosave->ary_fill);
737 filename = sub->filename;
738 tmps_base = tmps_max;
739 sp = cmd_exec(sub->cmd,gimme,--sp); /* so do it already */
740 st = stack->ary_array;
742 if ((arg[2].arg_type & A_MASK) != A_NULL) {
743 afree(stab_xarray(defstab)); /* put back old $_[] */
744 stab_xarray(defstab) = savearray;
747 tmps_base = oldtmps_base;
748 if (savestack->ary_fill > oldsave) {
749 for (items = arglast[0] + 1; items <= sp; items++)
750 st[items] = str_static(st[items]);
751 /* in case restore wipes old str */
752 restorelist(oldsave);
758 do_dbsubr(arg,gimme,arglast)
763 register STR **st = stack->ary_array;
764 register int sp = arglast[1];
765 register int items = arglast[2] - sp;
770 char *oldfile = filename;
771 int oldsave = savestack->ary_fill;
772 int oldtmps_base = tmps_base;
774 if ((arg[1].arg_type & A_MASK) == A_WORD)
775 stab = arg[1].arg_ptr.arg_stab;
777 STR *tmpstr = stab_val(arg[1].arg_ptr.arg_stab);
780 stab = stabent(str_get(tmpstr),TRUE);
785 fatal("Undefined subroutine called");
786 sub = stab_sub(stab);
788 fatal("Undefined subroutine \"%s\" called", stab_name(stab));
789 /* begin differences */
790 str = stab_val(DBsub);
792 str_set(str,stab_name(stab));
793 sub = stab_sub(DBsub);
795 fatal("No DBsub routine");
796 /* end differences */
797 if ((arg[2].arg_type & A_MASK) != A_NULL) {
798 savearray = stab_xarray(defstab);
799 stab_xarray(defstab) = afake(defstab, items, &st[sp+1]);
801 savelong(&sub->depth);
805 if (sub->depth >= 2) { /* save temporaries on recursion? */
806 if (sub->depth == 100 && dowarn)
807 warn("Deep recursion on subroutine \"%s\"",stab_name(stab));
808 savelist(sub->tosave->ary_array,sub->tosave->ary_fill);
810 filename = sub->filename;
811 tmps_base = tmps_max;
812 sp = cmd_exec(sub->cmd,gimme, --sp); /* so do it already */
813 st = stack->ary_array;
815 if ((arg[2].arg_type & A_MASK) != A_NULL) {
816 afree(stab_xarray(defstab)); /* put back old $_[] */
817 stab_xarray(defstab) = savearray;
820 tmps_base = oldtmps_base;
821 if (savestack->ary_fill > oldsave) {
822 for (items = arglast[0] + 1; items <= sp; items++)
823 st[items] = str_static(st[items]);
824 /* in case restore wipes old str */
825 restorelist(oldsave);
831 do_assign(arg,gimme,arglast)
837 register STR **st = stack->ary_array;
838 STR **firstrelem = st + arglast[1] + 1;
839 STR **firstlelem = st + arglast[0] + 1;
840 STR **lastrelem = st + arglast[2];
841 STR **lastlelem = st + arglast[1];
842 register STR **relem;
843 register STR **lelem;
847 register int makelocal;
851 makelocal = (arg->arg_flags & AF_LOCAL);
852 localizing = makelocal;
853 delaymagic = DM_DELAY; /* catch simultaneous items */
855 /* If there's a common identifier on both sides we have to take
856 * special care that assigning the identifier on the left doesn't
857 * clobber a value on the right that's used later in the list.
859 if (arg->arg_flags & AF_COMMON) {
860 for (relem = firstrelem; relem <= lastrelem; relem++) {
862 *relem = str_static(str);
869 while (lelem <= lastlelem) {
871 if (str->str_state >= SS_HASH) {
872 if (str->str_state == SS_ARY) {
874 ary = saveary(str->str_u.str_stab);
876 ary = stab_array(str->str_u.str_stab);
880 while (relem <= lastrelem) { /* gobble up all the rest */
883 str_sset(str,*relem);
885 (void)astore(ary,i++,str);
888 else if (str->str_state == SS_HASH) {
893 hash = savehash(str->str_u.str_stab);
895 hash = stab_hash(str->str_u.str_stab);
898 while (relem < lastrelem) { /* gobble up all the rest */
902 str = &str_no, relem++;
904 tmpstr = Str_new(29,0);
906 str_sset(tmpstr,*relem); /* value */
908 (void)hstore(hash,tmps,str->str_cur,tmpstr,0);
912 fatal("panic: do_assign");
917 if (relem <= lastrelem) {
918 str_sset(str, *relem);
922 str_nset(str, "", 0);
923 if (gimme == G_ARRAY) {
924 i = ++lastrelem - firstrelem;
925 relem++; /* tacky, I suppose */
927 if (st != stack->ary_array) {
928 st = stack->ary_array;
929 firstrelem = st + arglast[1] + 1;
930 firstlelem = st + arglast[0] + 1;
931 lastlelem = st + arglast[1];
933 relem = lastrelem + 1;
940 if (delaymagic > 1) {
942 if (delaymagic & DM_REUID)
946 if (delaymagic & DM_REGID)
952 if (gimme == G_ARRAY) {
953 i = lastrelem - firstrelem + 1;
955 Copy(firstrelem, firstlelem, i, STR*);
956 return arglast[0] + i;
959 str_numset(arg->arg_ptr.arg_str,(double)(arglast[2] - arglast[1]));
960 *firstlelem = arg->arg_ptr.arg_str;
961 return arglast[0] + 1;
966 do_study(str,arg,gimme,arglast)
972 register unsigned char *s;
973 register int pos = str->str_cur;
975 register int *sfirst;
977 static int maxscream = -1;
978 static STR *lastscream = Nullstr;
980 int retarg = arglast[0] + 1;
983 s = (unsigned char*)(str_get(str));
985 s = Null(unsigned char*);
988 lastscream->str_pok &= ~SP_STUDIED;
994 if (pos > maxscream) {
996 maxscream = pos + 80;
997 New(301,screamfirst, 256, int);
998 New(302,screamnext, maxscream, int);
1001 maxscream = pos + pos / 4;
1002 Renew(screamnext, maxscream, int);
1006 sfirst = screamfirst;
1009 if (!sfirst || !snext)
1010 fatal("do_study: out of memory");
1012 for (ch = 256; ch; --ch)
1016 while (--pos >= 0) {
1018 if (sfirst[ch] >= 0)
1019 snext[pos] = sfirst[ch] - pos;
1024 /* If there were any case insensitive searches, we must assume they
1025 * all are. This speeds up insensitive searches much more than
1026 * it slows down sensitive ones.
1029 sfirst[fold[ch]] = pos;
1032 str->str_pok |= SP_STUDIED;
1035 str_numset(arg->arg_ptr.arg_str,(double)retval);
1036 stack->ary_array[retarg] = arg->arg_ptr.arg_str;
1041 do_defined(str,arg,gimme,arglast)
1048 register int retarg = arglast[0] + 1;
1051 if ((arg[1].arg_type & A_MASK) != A_LEXPR)
1052 fatal("Illegal argument to defined()");
1053 arg = arg[1].arg_ptr.arg_arg;
1054 type = arg->arg_type;
1056 if (type == O_ARRAY || type == O_LARRAY)
1057 retval = stab_xarray(arg[1].arg_ptr.arg_stab) != 0;
1058 else if (type == O_HASH || type == O_LHASH)
1059 retval = stab_xhash(arg[1].arg_ptr.arg_stab) != 0;
1060 else if (type == O_SUBR || type == O_DBSUBR)
1061 retval = stab_sub(arg[1].arg_ptr.arg_stab) != 0;
1062 else if (type == O_ASLICE || type == O_LASLICE)
1063 retval = stab_xarray(arg[1].arg_ptr.arg_stab) != 0;
1064 else if (type == O_HSLICE || type == O_LHSLICE)
1065 retval = stab_xhash(arg[1].arg_ptr.arg_stab) != 0;
1068 str_numset(str,(double)retval);
1069 stack->ary_array[retarg] = str;
1074 do_undef(str,arg,gimme,arglast)
1081 register STAB *stab;
1082 int retarg = arglast[0] + 1;
1084 if ((arg[1].arg_type & A_MASK) != A_LEXPR)
1085 fatal("Illegal argument to undef()");
1086 arg = arg[1].arg_ptr.arg_arg;
1087 type = arg->arg_type;
1089 if (type == O_ARRAY || type == O_LARRAY) {
1090 stab = arg[1].arg_ptr.arg_stab;
1091 afree(stab_xarray(stab));
1092 stab_xarray(stab) = Null(ARRAY*);
1094 else if (type == O_HASH || type == O_LHASH) {
1095 stab = arg[1].arg_ptr.arg_stab;
1096 (void)hfree(stab_xhash(stab));
1097 stab_xhash(stab) = Null(HASH*);
1099 else if (type == O_SUBR || type == O_DBSUBR) {
1100 stab = arg[1].arg_ptr.arg_stab;
1101 cmd_free(stab_sub(stab)->cmd);
1102 afree(stab_sub(stab)->tosave);
1103 Safefree(stab_sub(stab));
1104 stab_sub(stab) = Null(SUBR*);
1107 fatal("Can't undefine that kind of object");
1108 str_numset(str,0.0);
1109 stack->ary_array[retarg] = str;
1114 do_vec(lvalue,astr,arglast)
1119 STR **st = stack->ary_array;
1120 int sp = arglast[0];
1121 register STR *str = st[++sp];
1122 register int offset = (int)str_gnum(st[++sp]);
1123 register int size = (int)str_gnum(st[++sp]);
1124 unsigned char *s = (unsigned char*)str_get(str);
1125 unsigned long retnum;
1129 offset *= size; /* turn into bit offset */
1130 len = (offset + size + 7) / 8;
1131 if (offset < 0 || size < 1)
1133 else if (!lvalue && len > str->str_cur)
1136 if (len > str->str_cur) {
1138 (void)bzero(str->str_ptr + str->str_cur, len - str->str_cur);
1141 s = (unsigned char*)str_get(str);
1143 retnum = (s[offset >> 3] >> (offset & 7)) & ((1 << size) - 1);
1148 else if (size == 16)
1149 retnum = (s[offset] << 8) + s[offset+1];
1150 else if (size == 32)
1151 retnum = (s[offset] << 24) + (s[offset + 1] << 16) +
1152 (s[offset + 2] << 8) + s[offset+3];
1155 if (lvalue) { /* it's an lvalue! */
1156 struct lstring *lstr = (struct lstring*)astr;
1158 astr->str_magic = str;
1159 st[sp]->str_rare = 'v';
1160 lstr->lstr_offset = offset;
1161 lstr->lstr_len = size;
1165 str_numset(astr,(double)retnum);
1175 struct lstring *lstr = (struct lstring*)str;
1176 register int offset;
1178 register unsigned char *s = (unsigned char*)mstr->str_ptr;
1179 register unsigned long lval = U_L(str_gnum(str));
1183 str->str_magic = Nullstr;
1184 offset = lstr->lstr_offset;
1185 size = lstr->lstr_len;
1187 mask = (1 << size) - 1;
1191 s[offset] &= ~(mask << size);
1192 s[offset] |= lval << size;
1196 s[offset] = lval & 255;
1197 else if (size == 16) {
1198 s[offset] = (lval >> 8) & 255;
1199 s[offset+1] = lval & 255;
1201 else if (size == 32) {
1202 s[offset] = (lval >> 24) & 255;
1203 s[offset+1] = (lval >> 16) & 255;
1204 s[offset+2] = (lval >> 8) & 255;
1205 s[offset+3] = lval & 255;
1214 register char *tmps;
1222 if (str->str_state == SS_ARY) {
1223 ary = stab_array(str->str_u.str_stab);
1224 for (i = 0; i <= ary->ary_fill; i++)
1225 do_chop(astr,ary->ary_array[i]);
1228 if (str->str_state == SS_HASH) {
1229 hash = stab_hash(str->str_u.str_stab);
1230 (void)hiterinit(hash);
1231 while (entry = hiternext(hash))
1232 do_chop(astr,hiterval(hash,entry));
1235 tmps = str_get(str);
1238 tmps += str->str_cur - (str->str_cur != 0);
1239 str_nset(astr,tmps,1); /* remember last char */
1240 *tmps = '\0'; /* wipe it out */
1241 str->str_cur = tmps - str->str_ptr;
1245 do_vop(optype,str,left,right)
1250 register char *s = str_get(str);
1251 register char *l = str_get(left);
1252 register char *r = str_get(right);
1255 len = left->str_cur;
1256 if (len > right->str_cur)
1257 len = right->str_cur;
1258 if (str->str_cur > len)
1260 else if (str->str_cur < len) {
1262 (void)bzero(str->str_ptr + str->str_cur, len - str->str_cur);
1280 if (right->str_cur > len)
1281 str_ncat(str,right->str_ptr+len,right->str_cur - len);
1282 else if (left->str_cur > len)
1283 str_ncat(str,left->str_ptr+len,left->str_cur - len);
1292 register STR **st = stack->ary_array;
1293 register int sp = arglast[1];
1294 register int items = arglast[2] - sp;
1301 for (st += ++sp; items--; st++)
1302 tainted |= (*st)->str_tainted;
1303 st = stack->ary_array;
1305 items = arglast[2] - sp;
1308 taintproper("Insecure dependency in syscall");
1310 /* This probably won't work on machines where sizeof(long) != sizeof(int)
1311 * or where sizeof(long) != sizeof(char*). But such machines will
1312 * not likely have syscall implemented either, so who cares?
1315 if (st[++sp]->str_nok || !i)
1316 arg[i++] = (long)str_gnum(st[sp]);
1319 arg[i++] = (long)st[sp]->str_ptr;
1323 items = arglast[2] - sp;
1326 fatal("Too few args to syscall");
1328 retval = syscall(arg[0]);
1331 retval = syscall(arg[0],arg[1]);
1334 retval = syscall(arg[0],arg[1],arg[2]);
1337 retval = syscall(arg[0],arg[1],arg[2],arg[3]);
1340 retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4]);
1343 retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5]);
1346 retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6]);
1349 retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6],
1355 fatal("syscall() unimplemented");