1 /* $Header: doarg.c,v 3.0.1.3 90/02/28 16:56:58 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.3 90/02/28 16:56:58 lwall
10 * patch9: split now can split into more than 10000 elements
11 * patch9: sped up pack and unpack
12 * patch9: pack of unsigned ints and longs blew up some places
13 * patch9: sun3 can't cast negative float to unsigned int or long
14 * patch9: local($.) didn't work
15 * patch9: grep(s/foo/bar/, @abc = @xyz) modified @xyz rather than @abc
16 * patch9: syscall returned stack size rather than value of system call
18 * Revision 3.0.1.2 89/12/21 19:52:15 lwall
19 * patch7: a pattern wouldn't match a null string before the first character
20 * patch7: certain patterns didn't match correctly at end of string
22 * Revision 3.0.1.1 89/11/11 04:17:20 lwall
23 * patch2: printf %c, %D, %X and %O didn't work right
24 * patch2: printf of unsigned vs signed needed separate casts on some machines
26 * Revision 3.0 89/10/18 15:10:41 lwall
36 extern unsigned char fold[];
49 register char *s = str_get(str);
50 char *strend = s + str->str_cur;
56 int maxiters = (strend - s) + 10;
62 rspat = spat = arg[2].arg_ptr.arg_spat;
64 fatal("panic: do_subst");
65 else if (spat->spat_runtime) {
67 (void)eval(spat->spat_runtime,G_SCALAR,sp);
68 m = str_get(dstr = stack->ary_array[sp+1]);
70 if (spat->spat_regexp)
71 regfree(spat->spat_regexp);
72 spat->spat_regexp = regcomp(m,m+dstr->str_cur,
73 spat->spat_flags & SPAT_FOLD,1);
74 if (spat->spat_flags & SPAT_KEEP) {
75 arg_free(spat->spat_runtime); /* it won't change, so */
76 spat->spat_runtime = Nullarg; /* no point compiling again */
81 deb("2.SPAT /%s/\n",spat->spat_regexp->precomp);
84 safebase = ((!spat->spat_regexp || !spat->spat_regexp->nparens) &&
86 if (!*spat->spat_regexp->precomp && lastspat)
90 if (hint < s || hint > strend)
91 fatal("panic: hint in do_match");
94 if (spat->spat_regexp->regback >= 0) {
95 s -= spat->spat_regexp->regback;
102 else if (spat->spat_short) {
103 if (spat->spat_flags & SPAT_SCANFIRST) {
104 if (str->str_pok & SP_STUDIED) {
105 if (screamfirst[spat->spat_short->str_rare] < 0)
107 else if (!(s = screaminstr(str,spat->spat_short)))
111 else if (!(s = fbminstr((unsigned char*)s, (unsigned char*)strend,
115 if (s && spat->spat_regexp->regback >= 0) {
116 ++spat->spat_short->str_u.str_useful;
117 s -= spat->spat_regexp->regback;
124 else if (!multiline && (*spat->spat_short->str_ptr != *s ||
125 bcmp(spat->spat_short->str_ptr, s, spat->spat_slen) ))
127 if (--spat->spat_short->str_u.str_useful < 0) {
128 str_free(spat->spat_short);
129 spat->spat_short = Nullstr; /* opt is being useless */
132 once = ((rspat->spat_flags & SPAT_ONCE) != 0);
133 if (rspat->spat_flags & SPAT_CONST) { /* known replacement string? */
134 if ((rspat->spat_repl[1].arg_type & A_MASK) == A_SINGLE)
135 dstr = rspat->spat_repl[1].arg_ptr.arg_str;
136 else { /* constant over loop, anyway */
137 (void)eval(rspat->spat_repl,G_SCALAR,sp);
138 dstr = stack->ary_array[sp+1];
141 clen = dstr->str_cur;
142 if (clen <= spat->spat_slen + spat->spat_regexp->regback) {
143 /* can do inplace substitution */
144 if (regexec(spat->spat_regexp, s, strend, orig, 0,
145 str->str_pok & SP_STUDIED ? str : Nullstr, safebase)) {
146 if (spat->spat_regexp->subbase) /* oops, no we can't */
150 str->str_pok = SP_VALID; /* disable possible screamer */
152 m = spat->spat_regexp->startp[0];
153 d = spat->spat_regexp->endp[0];
155 if (m - s > strend - d) { /* faster to shorten from end */
157 (void)bcopy(c, m, clen);
162 (void)bcopy(d, m, i);
166 str->str_cur = m - s;
168 str_numset(arg->arg_ptr.arg_str, 1.0);
169 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
172 else if (i = m - s) { /* faster from front */
180 (void)bcopy(c, m, clen);
182 str_numset(arg->arg_ptr.arg_str, 1.0);
183 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
189 (void)bcopy(c,d,clen);
191 str_numset(arg->arg_ptr.arg_str, 1.0);
192 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
198 str_numset(arg->arg_ptr.arg_str, 1.0);
199 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
205 if (iters++ > maxiters)
206 fatal("Substitution loop");
207 m = spat->spat_regexp->startp[0];
214 (void)bcopy(c,d,clen);
217 s = spat->spat_regexp->endp[0];
218 } while (regexec(spat->spat_regexp, s, strend, orig, s == m,
219 Nullstr, TRUE)); /* (don't match same null twice) */
222 str->str_cur = d - str->str_ptr + i;
223 (void)bcopy(s,d,i+1); /* include the Null */
226 str_numset(arg->arg_ptr.arg_str, (double)iters);
227 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
230 str_numset(arg->arg_ptr.arg_str, 0.0);
231 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
237 if (regexec(spat->spat_regexp, s, strend, orig, 0,
238 str->str_pok & SP_STUDIED ? str : Nullstr, safebase)) {
240 dstr = Str_new(25,str_len(str));
241 str_nset(dstr,m,s-m);
242 if (spat->spat_regexp->subbase)
246 if (iters++ > maxiters)
247 fatal("Substitution loop");
248 if (spat->spat_regexp->subbase
249 && spat->spat_regexp->subbase != orig) {
252 orig = spat->spat_regexp->subbase;
254 strend = s + (strend - m);
256 m = spat->spat_regexp->startp[0];
257 str_ncat(dstr,s,m-s);
258 s = spat->spat_regexp->endp[0];
261 str_ncat(dstr,c,clen);
264 (void)eval(rspat->spat_repl,G_SCALAR,sp);
265 str_scat(dstr,stack->ary_array[sp+1]);
269 } while (regexec(spat->spat_regexp, s, strend, orig, s == m, Nullstr,
271 str_ncat(dstr,s,strend - s);
272 str_replace(str,dstr);
274 str_numset(arg->arg_ptr.arg_str, (double)iters);
275 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
278 str_numset(arg->arg_ptr.arg_str, 0.0);
279 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
283 ++spat->spat_short->str_u.str_useful;
284 str_numset(arg->arg_ptr.arg_str, 0.0);
285 stack->ary_array[++sp] = arg->arg_ptr.arg_str;
296 register int matches = 0;
300 tbl = arg[2].arg_ptr.arg_cval;
302 send = s + str->str_cur;
304 fatal("panic: do_trans");
311 if (ch = tbl[*s & 0377]) {
326 register STR **st = stack->ary_array;
327 register int sp = arglast[1];
328 register int items = arglast[2] - sp;
329 register char *delim = str_get(st[sp]);
330 int delimlen = st[sp]->str_cur;
337 for (; items > 0; items--,st++) {
338 str_ncat(str,delim,delimlen);
349 register STR **st = stack->ary_array;
350 register int sp = arglast[1];
352 register char *pat = str_get(st[sp]);
353 register char *patend = pat + st[sp]->str_cur;
357 static char *null10 = "\0\0\0\0\0\0\0\0\0\0";
358 static char *space10 = " ";
360 /* These must not be in registers: */
366 unsigned long aulong;
369 items = arglast[2] - sp;
372 while (pat < patend) {
373 #define NEXTFROM (items-- > 0 ? *st++ : &str_no)
377 while (isdigit(*pat))
378 len = (len * 10) + (*pat++ - '0');
387 str_ncat(str,null10,10);
390 str_ncat(str,null10,len);
395 aptr = str_get(fromstr);
396 if (fromstr->str_cur > len)
397 str_ncat(str,aptr,len);
399 str_ncat(str,aptr,fromstr->str_cur);
400 len -= fromstr->str_cur;
401 if (datumtype == 'A') {
403 str_ncat(str,space10,10);
406 str_ncat(str,space10,len);
410 str_ncat(str,null10,10);
413 str_ncat(str,null10,len);
420 aint = (int)str_gnum(fromstr);
422 str_ncat(str,&achar,sizeof(char));
428 ashort = (short)str_gnum(fromstr);
430 ashort = htons(ashort);
432 str_ncat(str,(char*)&ashort,sizeof(short));
439 ashort = (short)str_gnum(fromstr);
440 str_ncat(str,(char*)&ashort,sizeof(short));
446 auint = (unsigned int)str_gnum(fromstr);
447 str_ncat(str,(char*)&auint,sizeof(unsigned int));
453 aint = (int)str_gnum(fromstr);
454 str_ncat(str,(char*)&aint,sizeof(int));
460 along = (long)str_gnum(fromstr);
462 along = htonl(along);
464 str_ncat(str,(char*)&along,sizeof(long));
470 aulong = (unsigned long)str_gnum(fromstr);
471 str_ncat(str,(char*)&aulong,sizeof(unsigned long));
477 along = (long)str_gnum(fromstr);
478 str_ncat(str,(char*)&along,sizeof(long));
484 aptr = str_get(fromstr);
485 str_ncat(str,(char*)&aptr,sizeof(char*));
495 do_sprintf(str,len,sarg)
504 static STR *sargnull = &str_no;
511 len--; /* don't count pattern string */
513 send = s + (*sarg)->str_cur;
515 for ( ; s < send; len--) {
516 if (len <= 0 || !*sarg) {
521 for (t = s; t < send && *t != '%'; t++) ;
523 break; /* not enough % patterns, oh well */
524 for (t++; *sarg && t < send && t != s; t++) {
529 (void)sprintf(buf,s);
534 case '0': case '1': case '2': case '3': case '4':
535 case '5': case '6': case '7': case '8': case '9':
536 case '.': case '#': case '-': case '+':
544 xlen = (int)str_gnum(*(sarg++));
545 if (strEQ(t-2,"%c")) { /* some printfs fail on null chars */
547 str_ncat(str,s,t - s - 2);
548 str_ncat(str,buf,1); /* so handle simple case */
552 (void)sprintf(buf,s,xlen);
563 (void)sprintf(buf,s,(long)str_gnum(*(sarg++)));
565 (void)sprintf(buf,s,(int)str_gnum(*(sarg++)));
572 case 'x': case 'o': case 'u':
575 value = str_gnum(*(sarg++));
576 #if defined(sun) && !defined(sparc)
577 if (value < 0.0) { /* sigh */
579 (void)sprintf(buf,s,(long)value);
581 (void)sprintf(buf,s,(int)value);
586 (void)sprintf(buf,s,(unsigned long)value);
588 (void)sprintf(buf,s,(unsigned int)value);
592 case 'E': case 'e': case 'f': case 'G': case 'g':
595 (void)sprintf(buf,s,str_gnum(*(sarg++)));
603 xlen = (*sarg)->str_cur;
604 if (*xs == 'S' && xs[1] == 't' && xs[2] == 'a' && xs[3] == 'b'
605 && xlen == sizeof(STBP) && strlen(xs) < xlen) {
606 xs = stab_name(((STAB*)(*sarg))); /* a stab value! */
607 sprintf(tokenbuf,"*%s",xs); /* reformat to non-binary */
609 xlen = strlen(tokenbuf);
611 if (strEQ(t-2,"%s")) { /* some printfs fail on >128 chars */
613 str_ncat(str,s,t - s - 2);
614 str_ncat(str,xs,xlen); /* so handle simple case */
617 (void)sprintf(buf,s,xs);
624 if (s < t && t >= send) {
632 (void)sprintf(buf,s,0,0,0,0);
643 register STR **st = stack->ary_array;
644 register int sp = arglast[1];
645 register int items = arglast[2] - sp;
646 register STR *str = &str_undef;
648 for (st += ++sp; items > 0; items--,st++) {
652 (void)apush(ary,str);
658 do_unshift(ary,arglast)
662 register STR **st = stack->ary_array;
663 register int sp = arglast[1];
664 register int items = arglast[2] - sp;
670 for (st += ++sp; i < items; i++,st++) {
673 (void)astore(ary,i,str);
678 do_subr(arg,gimme,arglast)
683 register STR **st = stack->ary_array;
684 register int sp = arglast[1];
685 register int items = arglast[2] - sp;
689 char *oldfile = filename;
690 int oldsave = savestack->ary_fill;
691 int oldtmps_base = tmps_base;
693 if ((arg[1].arg_type & A_MASK) == A_WORD)
694 stab = arg[1].arg_ptr.arg_stab;
696 STR *tmpstr = stab_val(arg[1].arg_ptr.arg_stab);
699 stab = stabent(str_get(tmpstr),TRUE);
704 fatal("Undefined subroutine called");
705 sub = stab_sub(stab);
707 fatal("Undefined subroutine \"%s\" called", stab_name(stab));
708 if ((arg[2].arg_type & A_MASK) != A_NULL) {
709 savearray = stab_xarray(defstab);
710 stab_xarray(defstab) = afake(defstab, items, &st[sp+1]);
712 savelong(&sub->depth);
716 if (sub->depth >= 2) { /* save temporaries on recursion? */
717 if (sub->depth == 100 && dowarn)
718 warn("Deep recursion on subroutine \"%s\"",stab_name(stab));
719 savelist(sub->tosave->ary_array,sub->tosave->ary_fill);
721 filename = sub->filename;
722 tmps_base = tmps_max;
723 sp = cmd_exec(sub->cmd,gimme,--sp); /* so do it already */
724 st = stack->ary_array;
726 if ((arg[2].arg_type & A_MASK) != A_NULL) {
727 afree(stab_xarray(defstab)); /* put back old $_[] */
728 stab_xarray(defstab) = savearray;
731 tmps_base = oldtmps_base;
732 if (savestack->ary_fill > oldsave) {
733 for (items = arglast[0] + 1; items <= sp; items++)
734 st[items] = str_static(st[items]);
735 /* in case restore wipes old str */
736 restorelist(oldsave);
742 do_dbsubr(arg,gimme,arglast)
747 register STR **st = stack->ary_array;
748 register int sp = arglast[1];
749 register int items = arglast[2] - sp;
754 char *oldfile = filename;
755 int oldsave = savestack->ary_fill;
756 int oldtmps_base = tmps_base;
758 if ((arg[1].arg_type & A_MASK) == A_WORD)
759 stab = arg[1].arg_ptr.arg_stab;
761 STR *tmpstr = stab_val(arg[1].arg_ptr.arg_stab);
764 stab = stabent(str_get(tmpstr),TRUE);
769 fatal("Undefined subroutine called");
770 sub = stab_sub(stab);
772 fatal("Undefined subroutine \"%s\" called", stab_name(stab));
773 /* begin differences */
774 str = stab_val(DBsub);
776 str_set(str,stab_name(stab));
777 sub = stab_sub(DBsub);
779 fatal("No DBsub routine");
780 /* end differences */
781 if ((arg[2].arg_type & A_MASK) != A_NULL) {
782 savearray = stab_xarray(defstab);
783 stab_xarray(defstab) = afake(defstab, items, &st[sp+1]);
785 savelong(&sub->depth);
789 if (sub->depth >= 2) { /* save temporaries on recursion? */
790 if (sub->depth == 100 && dowarn)
791 warn("Deep recursion on subroutine \"%s\"",stab_name(stab));
792 savelist(sub->tosave->ary_array,sub->tosave->ary_fill);
794 filename = sub->filename;
795 tmps_base = tmps_max;
796 sp = cmd_exec(sub->cmd,gimme, --sp); /* so do it already */
797 st = stack->ary_array;
799 if ((arg[2].arg_type & A_MASK) != A_NULL) {
800 afree(stab_xarray(defstab)); /* put back old $_[] */
801 stab_xarray(defstab) = savearray;
804 tmps_base = oldtmps_base;
805 if (savestack->ary_fill > oldsave) {
806 for (items = arglast[0] + 1; items <= sp; items++)
807 st[items] = str_static(st[items]);
808 /* in case restore wipes old str */
809 restorelist(oldsave);
815 do_assign(arg,gimme,arglast)
821 register STR **st = stack->ary_array;
822 STR **firstrelem = st + arglast[1] + 1;
823 STR **firstlelem = st + arglast[0] + 1;
824 STR **lastrelem = st + arglast[2];
825 STR **lastlelem = st + arglast[1];
826 register STR **relem;
827 register STR **lelem;
831 register int makelocal;
835 makelocal = (arg->arg_flags & AF_LOCAL);
836 localizing = makelocal;
837 delaymagic = DM_DELAY; /* catch simultaneous items */
839 /* If there's a common identifier on both sides we have to take
840 * special care that assigning the identifier on the left doesn't
841 * clobber a value on the right that's used later in the list.
843 if (arg->arg_flags & AF_COMMON) {
844 for (relem = firstrelem; relem <= lastrelem; relem++) {
846 *relem = str_static(str);
853 while (lelem <= lastlelem) {
855 if (str->str_state >= SS_HASH) {
856 if (str->str_state == SS_ARY) {
858 ary = saveary(str->str_u.str_stab);
860 ary = stab_array(str->str_u.str_stab);
864 while (relem <= lastrelem) { /* gobble up all the rest */
867 str_sset(str,*relem);
869 (void)astore(ary,i++,str);
872 else if (str->str_state == SS_HASH) {
877 hash = savehash(str->str_u.str_stab);
879 hash = stab_hash(str->str_u.str_stab);
882 while (relem < lastrelem) { /* gobble up all the rest */
886 str = &str_no, relem++;
888 tmpstr = Str_new(29,0);
890 str_sset(tmpstr,*relem); /* value */
892 (void)hstore(hash,tmps,str->str_cur,tmpstr,0);
896 fatal("panic: do_assign");
901 if (relem <= lastrelem) {
902 str_sset(str, *relem);
906 str_nset(str, "", 0);
907 if (gimme == G_ARRAY) {
908 i = ++lastrelem - firstrelem;
909 relem++; /* tacky, I suppose */
911 if (st != stack->ary_array) {
912 st = stack->ary_array;
913 firstrelem = st + arglast[1] + 1;
914 firstlelem = st + arglast[0] + 1;
915 lastlelem = st + arglast[1];
917 relem = lastrelem + 1;
924 if (delaymagic > 1) {
926 if (delaymagic & DM_REUID)
930 if (delaymagic & DM_REGID)
936 if (gimme == G_ARRAY) {
937 i = lastrelem - firstrelem + 1;
939 Copy(firstrelem, firstlelem, i, STR*);
940 return arglast[0] + i;
943 str_numset(arg->arg_ptr.arg_str,(double)(arglast[2] - arglast[1]));
944 *firstlelem = arg->arg_ptr.arg_str;
945 return arglast[0] + 1;
950 do_study(str,arg,gimme,arglast)
956 register unsigned char *s;
957 register int pos = str->str_cur;
959 register int *sfirst;
961 static int maxscream = -1;
962 static STR *lastscream = Nullstr;
964 int retarg = arglast[0] + 1;
967 s = (unsigned char*)(str_get(str));
969 s = Null(unsigned char*);
972 lastscream->str_pok &= ~SP_STUDIED;
978 if (pos > maxscream) {
980 maxscream = pos + 80;
981 New(301,screamfirst, 256, int);
982 New(302,screamnext, maxscream, int);
985 maxscream = pos + pos / 4;
986 Renew(screamnext, maxscream, int);
990 sfirst = screamfirst;
993 if (!sfirst || !snext)
994 fatal("do_study: out of memory");
996 for (ch = 256; ch; --ch)
1000 while (--pos >= 0) {
1002 if (sfirst[ch] >= 0)
1003 snext[pos] = sfirst[ch] - pos;
1008 /* If there were any case insensitive searches, we must assume they
1009 * all are. This speeds up insensitive searches much more than
1010 * it slows down sensitive ones.
1013 sfirst[fold[ch]] = pos;
1016 str->str_pok |= SP_STUDIED;
1019 str_numset(arg->arg_ptr.arg_str,(double)retval);
1020 stack->ary_array[retarg] = arg->arg_ptr.arg_str;
1025 do_defined(str,arg,gimme,arglast)
1032 register int retarg = arglast[0] + 1;
1035 if ((arg[1].arg_type & A_MASK) != A_LEXPR)
1036 fatal("Illegal argument to defined()");
1037 arg = arg[1].arg_ptr.arg_arg;
1038 type = arg->arg_type;
1040 if (type == O_ARRAY || type == O_LARRAY)
1041 retval = stab_xarray(arg[1].arg_ptr.arg_stab) != 0;
1042 else if (type == O_HASH || type == O_LHASH)
1043 retval = stab_xhash(arg[1].arg_ptr.arg_stab) != 0;
1044 else if (type == O_SUBR || type == O_DBSUBR)
1045 retval = stab_sub(arg[1].arg_ptr.arg_stab) != 0;
1046 else if (type == O_ASLICE || type == O_LASLICE)
1047 retval = stab_xarray(arg[1].arg_ptr.arg_stab) != 0;
1048 else if (type == O_HSLICE || type == O_LHSLICE)
1049 retval = stab_xhash(arg[1].arg_ptr.arg_stab) != 0;
1052 str_numset(str,(double)retval);
1053 stack->ary_array[retarg] = str;
1058 do_undef(str,arg,gimme,arglast)
1065 register STAB *stab;
1066 int retarg = arglast[0] + 1;
1068 if ((arg[1].arg_type & A_MASK) != A_LEXPR)
1069 fatal("Illegal argument to undef()");
1070 arg = arg[1].arg_ptr.arg_arg;
1071 type = arg->arg_type;
1073 if (type == O_ARRAY || type == O_LARRAY) {
1074 stab = arg[1].arg_ptr.arg_stab;
1075 afree(stab_xarray(stab));
1076 stab_xarray(stab) = Null(ARRAY*);
1078 else if (type == O_HASH || type == O_LHASH) {
1079 stab = arg[1].arg_ptr.arg_stab;
1080 (void)hfree(stab_xhash(stab));
1081 stab_xhash(stab) = Null(HASH*);
1083 else if (type == O_SUBR || type == O_DBSUBR) {
1084 stab = arg[1].arg_ptr.arg_stab;
1085 cmd_free(stab_sub(stab)->cmd);
1086 afree(stab_sub(stab)->tosave);
1087 Safefree(stab_sub(stab));
1088 stab_sub(stab) = Null(SUBR*);
1091 fatal("Can't undefine that kind of object");
1092 str_numset(str,0.0);
1093 stack->ary_array[retarg] = str;
1098 do_vec(lvalue,astr,arglast)
1103 STR **st = stack->ary_array;
1104 int sp = arglast[0];
1105 register STR *str = st[++sp];
1106 register int offset = (int)str_gnum(st[++sp]);
1107 register int size = (int)str_gnum(st[++sp]);
1108 unsigned char *s = (unsigned char*)str_get(str);
1109 unsigned long retnum;
1113 offset *= size; /* turn into bit offset */
1114 len = (offset + size + 7) / 8;
1115 if (offset < 0 || size < 1)
1117 else if (!lvalue && len > str->str_cur)
1120 if (len > str->str_cur) {
1122 (void)bzero(str->str_ptr + str->str_cur, len - str->str_cur);
1125 s = (unsigned char*)str_get(str);
1127 retnum = (s[offset >> 3] >> (offset & 7)) & ((1 << size) - 1);
1132 else if (size == 16)
1133 retnum = (s[offset] << 8) + s[offset+1];
1134 else if (size == 32)
1135 retnum = (s[offset] << 24) + (s[offset + 1] << 16) +
1136 (s[offset + 2] << 8) + s[offset+3];
1139 if (lvalue) { /* it's an lvalue! */
1140 struct lstring *lstr = (struct lstring*)astr;
1142 astr->str_magic = str;
1143 st[sp]->str_rare = 'v';
1144 lstr->lstr_offset = offset;
1145 lstr->lstr_len = size;
1149 str_numset(astr,(double)retnum);
1159 struct lstring *lstr = (struct lstring*)str;
1160 register int offset;
1162 register unsigned char *s = (unsigned char*)mstr->str_ptr;
1163 register unsigned long lval = (unsigned long)str_gnum(str);
1167 str->str_magic = Nullstr;
1168 offset = lstr->lstr_offset;
1169 size = lstr->lstr_len;
1171 mask = (1 << size) - 1;
1175 s[offset] &= ~(mask << size);
1176 s[offset] |= lval << size;
1180 s[offset] = lval & 255;
1181 else if (size == 16) {
1182 s[offset] = (lval >> 8) & 255;
1183 s[offset+1] = lval & 255;
1185 else if (size == 32) {
1186 s[offset] = (lval >> 24) & 255;
1187 s[offset+1] = (lval >> 16) & 255;
1188 s[offset+2] = (lval >> 8) & 255;
1189 s[offset+3] = lval & 255;
1198 register char *tmps;
1206 if (str->str_state == SS_ARY) {
1207 ary = stab_array(str->str_u.str_stab);
1208 for (i = 0; i <= ary->ary_fill; i++)
1209 do_chop(astr,ary->ary_array[i]);
1212 if (str->str_state == SS_HASH) {
1213 hash = stab_hash(str->str_u.str_stab);
1214 (void)hiterinit(hash);
1215 while (entry = hiternext(hash))
1216 do_chop(astr,hiterval(hash,entry));
1219 tmps = str_get(str);
1222 tmps += str->str_cur - (str->str_cur != 0);
1223 str_nset(astr,tmps,1); /* remember last char */
1224 *tmps = '\0'; /* wipe it out */
1225 str->str_cur = tmps - str->str_ptr;
1229 do_vop(optype,str,left,right)
1234 register char *s = str_get(str);
1235 register char *l = str_get(left);
1236 register char *r = str_get(right);
1239 len = left->str_cur;
1240 if (len > right->str_cur)
1241 len = right->str_cur;
1242 if (str->str_cur > len)
1244 else if (str->str_cur < len) {
1246 (void)bzero(str->str_ptr + str->str_cur, len - str->str_cur);
1264 if (right->str_cur > len)
1265 str_ncat(str,right->str_ptr+len,right->str_cur - len);
1266 else if (left->str_cur > len)
1267 str_ncat(str,left->str_ptr+len,left->str_cur - len);
1276 register STR **st = stack->ary_array;
1277 register int sp = arglast[1];
1278 register int items = arglast[2] - sp;
1285 for (st += ++sp; items--; st++)
1286 tainted |= (*st)->str_tainted;
1287 st = stack->ary_array;
1289 items = arglast[2] - sp;
1292 taintproper("Insecure dependency in syscall");
1294 /* This probably won't work on machines where sizeof(long) != sizeof(int)
1295 * or where sizeof(long) != sizeof(char*). But such machines will
1296 * not likely have syscall implemented either, so who cares?
1299 if (st[++sp]->str_nok || !i)
1300 arg[i++] = (long)str_gnum(st[sp]);
1303 arg[i++] = (long)st[sp]->str_ptr;
1307 items = arglast[2] - sp;
1310 fatal("Too few args to syscall");
1312 retval = syscall(arg[0]);
1315 retval = syscall(arg[0],arg[1]);
1318 retval = syscall(arg[0],arg[1],arg[2]);
1321 retval = syscall(arg[0],arg[1],arg[2],arg[3]);
1324 retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4]);
1327 retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5]);
1330 retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6]);
1333 retval = syscall(arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6],
1339 fatal("syscall() unimplemented");