1 /* $Header: arg.c,v 1.0.1.7 88/02/02 11:22:19 root Exp $
4 * Revision 1.0.1.7 88/02/02 11:22:19 root
5 * patch13: fixed split(' ') to work right second time. Added CRYPT dependency.
7 * Revision 1.0.1.6 88/02/01 17:32:26 root
8 * patch12: made split(' ') behave like awk in ignoring leading white space.
10 * Revision 1.0.1.5 88/01/30 08:53:16 root
11 * patch9: fixed some missing right parens introduced (?) by patch 2
13 * Revision 1.0.1.4 88/01/28 10:22:06 root
14 * patch8: added eval operator.
16 * Revision 1.0.1.2 88/01/24 03:52:34 root
17 * patch 2: added STATBLKS dependencies.
19 * Revision 1.0.1.1 88/01/21 21:27:10 root
20 * Now defines signal return values correctly using VOIDSIG.
22 * Revision 1.0 87/12/18 13:04:33 root
41 register SPAT *spat = arg[2].arg_ptr.arg_spat;
46 fatal("panic: do_match\n");
47 if (spat->spat_flags & SPAT_USED) {
54 if (spat->spat_runtime) {
55 t = str_get(eval(spat->spat_runtime,Null(STR***)));
58 deb("2.SPAT /%s/\n",t);
60 if (d = compile(&spat->spat_compex,t,TRUE,FALSE)) {
62 deb("/%s/: %s\n", t, d);
66 if (spat->spat_compex.complen <= 1 && curspat)
68 if (execute(&spat->spat_compex, s, TRUE, 0)) {
69 if (spat->spat_compex.numsubs)
81 if (spat->spat_flags & SPAT_USE_ONCE)
85 deb("2.SPAT %c%s%c\n",ch,spat->spat_compex.precomp,ch);
88 if (spat->spat_compex.complen <= 1 && curspat)
90 if (spat->spat_first) {
91 if (spat->spat_flags & SPAT_SCANFIRST) {
92 str_free(spat->spat_first);
93 spat->spat_first = Nullstr; /* disable optimization */
95 else if (*spat->spat_first->str_ptr != *s ||
96 strnNE(spat->spat_first->str_ptr, s, spat->spat_flen) )
99 if (execute(&spat->spat_compex, s, TRUE, 0)) {
100 if (spat->spat_compex.numsubs)
102 if (spat->spat_flags & SPAT_USE_ONCE)
103 spat->spat_flags |= SPAT_USED;
122 spat = arg[2].arg_ptr.arg_spat;
125 fatal("panic: do_subst\n");
126 else if (spat->spat_runtime) {
129 m = str_get(eval(spat->spat_runtime,Null(STR***)));
130 if (d = compile(&spat->spat_compex,m,TRUE,FALSE)) {
132 deb("/%s/: %s\n", m, d);
139 deb("2.SPAT /%s/\n",spat->spat_compex.precomp);
142 if (spat->spat_compex.complen <= 1 && curspat)
144 if (spat->spat_first) {
145 if (spat->spat_flags & SPAT_SCANFIRST) {
146 str_free(spat->spat_first);
147 spat->spat_first = Nullstr; /* disable optimization */
149 else if (*spat->spat_first->str_ptr != *s ||
150 strnNE(spat->spat_first->str_ptr, s, spat->spat_flen) )
153 if (m = execute(&spat->spat_compex, s, TRUE, 1)) {
156 dstr = str_new(str_len(str));
157 if (spat->spat_compex.numsubs)
161 fatal("Substitution loop?\n");
162 if (spat->spat_compex.numsubs)
163 s = spat->spat_compex.subbase;
164 str_ncat(dstr,s,m-s);
165 s = spat->spat_compex.subend[0];
166 str_scat(dstr,eval(spat->spat_repl,Null(STR***)));
167 if (spat->spat_flags & SPAT_USE_ONCE)
169 } while (m = execute(&spat->spat_compex, s, FALSE, 1));
171 str_replace(str,dstr);
185 register int matches = 0;
188 tbl = arg[2].arg_ptr.arg_cval;
191 fatal("panic: do_trans\n");
198 if (ch = tbl[*s & 0377]) {
209 do_split(s,spat,retary)
217 static ARRAY *myarray = Null(ARRAY*);
224 fatal("panic: do_split\n");
225 else if (spat->spat_runtime) {
228 m = str_get(eval(spat->spat_runtime,Null(STR***)));
229 if (!*m || (*m == ' ' && !m[1])) {
231 spat->spat_flags |= SPAT_SKIPWHITE;
233 if (spat->spat_runtime->arg_type == O_ITEM &&
234 spat->spat_runtime[1].arg_type == A_SINGLE) {
235 arg_free(spat->spat_runtime); /* it won't change, so */
236 spat->spat_runtime = Nullarg; /* no point compiling again */
238 if (d = compile(&spat->spat_compex,m,TRUE,FALSE)) {
240 deb("/%s/: %s\n", m, d);
247 deb("2.SPAT /%s/\n",spat->spat_compex.precomp);
253 ary = spat->spat_repl[1].arg_ptr.arg_stab->stab_array;
255 myarray = ary = anew();
257 if (spat->spat_flags & SPAT_SKIPWHITE) {
261 while (*s && (m = execute(&spat->spat_compex, s, (iters == 0), 1))) {
262 if (spat->spat_compex.numsubs)
263 s = spat->spat_compex.subbase;
265 str_nset(dstr,s,m-s);
266 astore(ary, iters++, dstr);
268 fatal("Substitution loop?\n");
269 s = spat->spat_compex.subend[0];
271 if (*s) { /* ignore field after final "whitespace" */
272 dstr = str_new(0); /* if they interpolate, it's null anyway */
274 astore(ary, iters++, dstr);
277 while (iters > 0 && !*str_get(afetch(ary,iters-1)))
281 sarg = (STR**)safemalloc((iters+2)*sizeof(STR*));
284 sarg[iters+1] = Nullstr;
285 for (i = 1; i <= iters; i++)
286 sarg[i] = afetch(ary,i-1);
293 do_join(arg,delim,str)
295 register char *delim;
298 STR **tmpary; /* must not be register */
301 (void)eval(arg[2].arg_ptr.arg_arg,&tmpary);
304 str_sset(str,*elem++);
305 for (; *elem; elem++) {
310 safefree((char*)tmpary);
319 int len = strlen(name);
320 register STIO *stio = stab->stab_io;
322 while (len && isspace(name[len-1]))
325 stio = stab->stab_io = stio_new();
327 if (stio->type == '|')
329 else if (stio->type != '-')
335 for (name++; isspace(*name); name++) ;
336 fp = popen(name,"w");
338 else if (*name == '>' && name[1] == '>') {
339 for (name += 2; isspace(*name); name++) ;
340 fp = fopen(name,"a");
342 else if (*name == '>') {
343 for (name++; isspace(*name); name++) ;
344 if (strEQ(name,"-")) {
349 fp = fopen(name,"w");
353 for (name++; isspace(*name); name++) ;
354 if (strEQ(name,"-")) {
359 fp = fopen(name,"r");
361 else if (name[len-1] == '|') {
363 while (len && isspace(name[len-1]))
365 for (; isspace(*name); name++) ;
366 fp = popen(name,"r");
371 for (; isspace(*name); name++) ;
372 if (strEQ(name,"-")) {
377 fp = fopen(name,"r");
382 if (stio->type != '|' && stio->type != '-') {
383 if (fstat(fileno(fp),&statbuf) < 0) {
387 if ((statbuf.st_mode & S_IFMT) != S_IFREG &&
388 (statbuf.st_mode & S_IFMT) != S_IFCHR) {
404 while (alen(stab->stab_array) >= 0L) {
405 str = ashift(stab->stab_array);
406 str_sset(stab->stab_val,str);
407 STABSET(stab->stab_val);
408 oldname = str_get(stab->stab_val);
409 if (do_open(stab,oldname)) {
412 str_cat(str,inplace);
414 rename(oldname,str->str_ptr);
416 UNLINK(str->str_ptr);
417 link(oldname,str->str_ptr);
421 sprintf(tokenbuf,">%s",oldname);
422 do_open(argvoutstab,tokenbuf);
423 defoutstab = argvoutstab;
426 return stab->stab_io->fp;
429 fprintf(stderr,"Can't open %s\n",str_get(str));
433 do_close(argvoutstab,FALSE);
434 defoutstab = stabent("stdout",TRUE);
440 do_close(stab,explicit)
445 register STIO *stio = stab->stab_io;
447 if (!stio) /* never opened */
450 if (stio->type == '|')
451 retval = (pclose(stio->fp) >= 0);
452 else if (stio->type == '-')
455 retval = (fclose(stio->fp) != EOF);
474 stio = stab->stab_io;
480 #ifdef STDSTDIO /* (the code works without this) */
481 if (stio->fp->_cnt) /* cheat a little, since */
482 return FALSE; /* this is the most usual case */
487 ungetc(ch, stio->fp);
490 if (stio->flags & IOF_ARGV) { /* not necessarily a real EOF yet? */
491 if (!nextargv(stab)) /* get another fp handy */
495 return TRUE; /* normal fp, definitely end of file */
510 stio = stab->stab_io;
511 if (!stio || !stio->fp)
514 return ftell(stio->fp);
518 do_seek(stab, pos, whence)
528 stio = stab->stab_io;
529 if (!stio || !stio->fp)
532 return fseek(stio->fp, pos, whence) >= 0;
535 do_stat(arg,sarg,retary)
541 static ARRAY *myarray = Null(ARRAY*);
547 myarray = ary = anew();
549 if (arg[1].arg_type == A_LVAL) {
550 tmpstab = arg[1].arg_ptr.arg_stab;
551 if (!tmpstab->stab_io ||
552 fstat(fileno(tmpstab->stab_io->fp),&statbuf) < 0) {
557 if (stat(str_get(sarg[1]),&statbuf) < 0)
562 apush(ary,str_nmake((double)statbuf.st_dev));
563 apush(ary,str_nmake((double)statbuf.st_ino));
564 apush(ary,str_nmake((double)statbuf.st_mode));
565 apush(ary,str_nmake((double)statbuf.st_nlink));
566 apush(ary,str_nmake((double)statbuf.st_uid));
567 apush(ary,str_nmake((double)statbuf.st_gid));
568 apush(ary,str_nmake((double)statbuf.st_rdev));
569 apush(ary,str_nmake((double)statbuf.st_size));
570 apush(ary,str_nmake((double)statbuf.st_atime));
571 apush(ary,str_nmake((double)statbuf.st_mtime));
572 apush(ary,str_nmake((double)statbuf.st_ctime));
574 apush(ary,str_nmake((double)statbuf.st_blksize));
575 apush(ary,str_nmake((double)statbuf.st_blocks));
577 apush(ary,str_make(""));
578 apush(ary,str_make(""));
581 sarg = (STR**)safemalloc((max+2)*sizeof(STR*));
583 sarg[max+1] = Nullstr;
584 for (i = 1; i <= max; i++)
585 sarg[i] = afetch(ary,i-1);
595 static ARRAY *myarray = Null(ARRAY*);
602 myarray = ary = anew();
604 if (times(×buf) < 0)
609 apush(ary,str_nmake(((double)timesbuf.tms_utime)/60.0));
610 apush(ary,str_nmake(((double)timesbuf.tms_stime)/60.0));
611 apush(ary,str_nmake(((double)timesbuf.tms_cutime)/60.0));
612 apush(ary,str_nmake(((double)timesbuf.tms_cstime)/60.0));
614 sarg = (STR**)safemalloc((max+2)*sizeof(STR*));
616 sarg[max+1] = Nullstr;
617 for (i = 1; i <= max; i++)
618 sarg[i] = afetch(ary,i-1);
624 do_time(tmbuf,retary)
629 static ARRAY *myarray = Null(ARRAY*);
637 myarray = ary = anew();
644 apush(ary,str_nmake((double)tmbuf->tm_sec));
645 apush(ary,str_nmake((double)tmbuf->tm_min));
646 apush(ary,str_nmake((double)tmbuf->tm_hour));
647 apush(ary,str_nmake((double)tmbuf->tm_mday));
648 apush(ary,str_nmake((double)tmbuf->tm_mon));
649 apush(ary,str_nmake((double)tmbuf->tm_year));
650 apush(ary,str_nmake((double)tmbuf->tm_wday));
651 apush(ary,str_nmake((double)tmbuf->tm_yday));
652 apush(ary,str_nmake((double)tmbuf->tm_isdst));
654 sarg = (STR**)safemalloc((max+2)*sizeof(STR*));
656 sarg[max+1] = Nullstr;
657 for (i = 1; i <= max; i++)
658 sarg[i] = afetch(ary,i-1);
665 do_sprintf(str,len,sarg)
674 static STR *sargnull = &str_no;
677 len--; /* don't count pattern string */
679 for (s = str_get(*(sarg++)); *s; len--) {
680 if (len <= 0 || !*sarg) {
685 for (t = s; *t && *t != '%'; t++) ;
687 break; /* not enough % patterns, oh well */
688 for (t++; *sarg && *t && t != s; t++) {
702 case 'D': case 'X': case 'O':
705 case 'd': case 'x': case 'o': case 'c':
709 sprintf(buf,s,(long)str_gnum(*(sarg++)));
711 sprintf(buf,s,(int)str_gnum(*(sarg++)));
715 case 'E': case 'e': case 'f': case 'G': case 'g':
718 sprintf(buf,s,str_gnum(*(sarg++)));
725 sprintf(buf,s,str_get(*(sarg++)));
754 STR **tmpary; /* must not be register */
756 register bool retval;
759 (void)eval(arg[1].arg_ptr.arg_arg,&tmpary);
760 if (arg->arg_type == O_PRTF) {
761 do_sprintf(arg->arg_ptr.arg_str,32767,tmpary);
762 retval = do_print(str_get(arg->arg_ptr.arg_str),fp);
766 for (elem = tmpary+1; *elem; elem++) {
770 if ((*elem)->str_nok || str_gnum(*elem) != 0.0)
771 fprintf(fp, ofmt, str_gnum(*elem));
775 retval = do_print(str_get(*elem), fp);
780 retval = do_print(ors, fp);
782 safefree((char*)tmpary);
790 STR **tmpary; /* must not be register */
796 (void)eval(arg[1].arg_ptr.arg_arg,&tmpary);
798 for (elem = tmpary+1; *elem; elem++)
801 argv = (char**)safemalloc((i+1)*sizeof(char*));
803 for (elem = tmpary+1; *elem; elem++) {
804 *a++ = str_get(*elem);
807 execvp(argv[0],argv);
808 safefree((char*)argv);
810 safefree((char*)tmpary);
818 STR **tmpary; /* must not be register */
823 /* see if there are shell metacharacters in it */
825 for (s = cmd; *s; s++) {
826 if (*s != ' ' && !isalpha(*s) && index("$&*(){}[]'\";\\|?<>~`",*s)) {
827 execl("/bin/sh","sh","-c",cmd,0);
831 argv = (char**)safemalloc(((s - cmd) / 2 + 2)*sizeof(char*));
835 while (isspace(*s)) s++;
838 while (*s && !isspace(*s)) s++;
844 execvp(argv[0],argv);
845 safefree((char*)argv);
854 STR **tmpary; /* must not be register */
856 register STR *str = &str_no;
858 (void)eval(arg[1].arg_ptr.arg_arg,&tmpary);
859 for (elem = tmpary+1; *elem; elem++) {
864 safefree((char*)tmpary);
872 STR **tmpary; /* must not be register */
874 register STR *str = &str_no;
877 (void)eval(arg[1].arg_ptr.arg_arg,&tmpary);
879 for (elem = tmpary+1; *elem; elem++)
883 for (elem = tmpary+1; *elem; elem++) {
888 safefree((char*)tmpary);
896 STR **tmpary; /* must not be register */
905 (void)eval(arg[1].arg_ptr.arg_arg,&tmpary);
907 for (elem = tmpary+1; *elem; elem++)
912 val = (int)str_gnum(tmpary[1]);
913 for (elem = tmpary+2; *elem; elem++)
914 if (chmod(str_get(*elem),val))
921 val = (int)str_gnum(tmpary[1]);
922 val2 = (int)str_gnum(tmpary[2]);
923 for (elem = tmpary+3; *elem; elem++)
924 if (chown(str_get(*elem),val,val2))
932 val = (int)str_gnum(tmpary[1]);
935 for (elem = tmpary+2; *elem; elem++)
936 if (kill(atoi(str_get(*elem)),val))
941 for (elem = tmpary+1; *elem; elem++)
942 if (UNLINK(str_get(*elem)))
947 safefree((char*)tmpary);
954 register char **sarg;
959 savearray = defstab->stab_array;
960 defstab->stab_array = anew();
961 if (arg[1].arg_flags & AF_SPECIAL)
962 (void)do_push(arg,defstab->stab_array);
963 else if (arg[1].arg_type != A_NULL) {
965 str_sset(str,sarg[1]);
966 apush(defstab->stab_array,str);
968 str = cmd_exec(arg[2].arg_ptr.arg_stab->stab_sub);
969 afree(defstab->stab_array); /* put back old $_[] */
970 defstab->stab_array = savearray;
975 do_assign(retstr,arg)
979 STR **tmpary; /* must not be register */
980 register ARG *larg = arg[1].arg_ptr.arg_arg;
988 (void)eval(arg[2].arg_ptr.arg_arg,&tmpary);
990 if (arg->arg_flags & AF_COMMON) {
992 for (elem=tmpary+2; *elem; elem++) {
993 *elem = str_static(*elem);
997 if (larg->arg_type == O_LIST) {
998 lasti = larg->arg_len;
999 for (i=1,elem=tmpary+1; i <= lasti; i++) {
1001 s = str_get(*(elem++));
1004 switch (larg[i].arg_type) {
1007 str = STAB_STR(larg[i].arg_ptr.arg_stab);
1010 str = eval(larg[i].arg_ptr.arg_arg,Null(STR***));
1016 i = elem - tmpary - 1;
1018 else { /* should be an array name */
1019 ary = larg[1].arg_ptr.arg_stab->stab_array;
1020 for (i=0,elem=tmpary+1; *elem; i++) {
1023 str_sset(str,*(elem++));
1026 ary->ary_fill = i - 1; /* they can get the extra ones back by */
1027 } /* setting an element larger than old fill */
1028 str_numset(retstr,(double)i);
1030 safefree((char*)tmpary);
1034 do_kv(hash,kv,sarg,retary)
1037 register STR **sarg;
1040 register ARRAY *ary;
1043 static ARRAY *myarray = Null(ARRAY*);
1044 register HENT *entry;
1048 myarray = ary = anew();
1052 while (entry = hiternext(hash)) {
1055 apush(ary,str_make(hiterkey(entry)));
1057 apush(ary,str_make(str_get(hiterval(entry))));
1059 if (retary) { /* array wanted */
1060 sarg = (STR**)saferealloc((char*)sarg,(max+2)*sizeof(STR*));
1062 sarg[max+1] = Nullstr;
1063 for (i = 1; i <= max; i++)
1064 sarg[i] = afetch(ary,i-1);
1071 do_each(hash,sarg,retary)
1073 register STR **sarg;
1076 static STR *mystr = Nullstr;
1078 HENT *entry = hiternext(hash);
1085 if (retary) { /* array wanted */
1087 sarg = (STR**)saferealloc((char*)sarg,4*sizeof(STR*));
1090 sarg[1] = mystr = str_make(hiterkey(entry));
1091 retstr = sarg[2] = hiterval(entry);
1095 sarg = (STR**)saferealloc((char*)sarg,2*sizeof(STR*));
1097 sarg[1] = retstr = Nullstr;
1102 retstr = hiterval(entry);
1111 #define A(e1,e2,e3) (e1+(e2<<1)+(e3<<2))
1112 opargs[O_ITEM] = A(1,0,0);
1113 opargs[O_ITEM2] = A(0,0,0);
1114 opargs[O_ITEM3] = A(0,0,0);
1115 opargs[O_CONCAT] = A(1,1,0);
1116 opargs[O_MATCH] = A(1,0,0);
1117 opargs[O_NMATCH] = A(1,0,0);
1118 opargs[O_SUBST] = A(1,0,0);
1119 opargs[O_NSUBST] = A(1,0,0);
1120 opargs[O_ASSIGN] = A(1,1,0);
1121 opargs[O_MULTIPLY] = A(1,1,0);
1122 opargs[O_DIVIDE] = A(1,1,0);
1123 opargs[O_MODULO] = A(1,1,0);
1124 opargs[O_ADD] = A(1,1,0);
1125 opargs[O_SUBTRACT] = A(1,1,0);
1126 opargs[O_LEFT_SHIFT] = A(1,1,0);
1127 opargs[O_RIGHT_SHIFT] = A(1,1,0);
1128 opargs[O_LT] = A(1,1,0);
1129 opargs[O_GT] = A(1,1,0);
1130 opargs[O_LE] = A(1,1,0);
1131 opargs[O_GE] = A(1,1,0);
1132 opargs[O_EQ] = A(1,1,0);
1133 opargs[O_NE] = A(1,1,0);
1134 opargs[O_BIT_AND] = A(1,1,0);
1135 opargs[O_XOR] = A(1,1,0);
1136 opargs[O_BIT_OR] = A(1,1,0);
1137 opargs[O_AND] = A(1,0,0); /* don't eval arg 2 (yet) */
1138 opargs[O_OR] = A(1,0,0); /* don't eval arg 2 (yet) */
1139 opargs[O_COND_EXPR] = A(1,0,0); /* don't eval args 2 or 3 */
1140 opargs[O_COMMA] = A(1,1,0);
1141 opargs[O_NEGATE] = A(1,0,0);
1142 opargs[O_NOT] = A(1,0,0);
1143 opargs[O_COMPLEMENT] = A(1,0,0);
1144 opargs[O_WRITE] = A(1,0,0);
1145 opargs[O_OPEN] = A(1,1,0);
1146 opargs[O_TRANS] = A(1,0,0);
1147 opargs[O_NTRANS] = A(1,0,0);
1148 opargs[O_CLOSE] = A(0,0,0);
1149 opargs[O_ARRAY] = A(1,0,0);
1150 opargs[O_HASH] = A(1,0,0);
1151 opargs[O_LARRAY] = A(1,0,0);
1152 opargs[O_LHASH] = A(1,0,0);
1153 opargs[O_PUSH] = A(1,0,0);
1154 opargs[O_POP] = A(0,0,0);
1155 opargs[O_SHIFT] = A(0,0,0);
1156 opargs[O_SPLIT] = A(1,0,0);
1157 opargs[O_LENGTH] = A(1,0,0);
1158 opargs[O_SPRINTF] = A(1,0,0);
1159 opargs[O_SUBSTR] = A(1,1,1);
1160 opargs[O_JOIN] = A(1,0,0);
1161 opargs[O_SLT] = A(1,1,0);
1162 opargs[O_SGT] = A(1,1,0);
1163 opargs[O_SLE] = A(1,1,0);
1164 opargs[O_SGE] = A(1,1,0);
1165 opargs[O_SEQ] = A(1,1,0);
1166 opargs[O_SNE] = A(1,1,0);
1167 opargs[O_SUBR] = A(1,0,0);
1168 opargs[O_PRINT] = A(1,0,0);
1169 opargs[O_CHDIR] = A(1,0,0);
1170 opargs[O_DIE] = A(1,0,0);
1171 opargs[O_EXIT] = A(1,0,0);
1172 opargs[O_RESET] = A(1,0,0);
1173 opargs[O_LIST] = A(0,0,0);
1174 opargs[O_EOF] = A(0,0,0);
1175 opargs[O_TELL] = A(0,0,0);
1176 opargs[O_SEEK] = A(0,1,1);
1177 opargs[O_LAST] = A(1,0,0);
1178 opargs[O_NEXT] = A(1,0,0);
1179 opargs[O_REDO] = A(1,0,0);
1180 opargs[O_GOTO] = A(1,0,0);
1181 opargs[O_INDEX] = A(1,1,0);
1182 opargs[O_TIME] = A(0,0,0);
1183 opargs[O_TMS] = A(0,0,0);
1184 opargs[O_LOCALTIME] = A(1,0,0);
1185 opargs[O_GMTIME] = A(1,0,0);
1186 opargs[O_STAT] = A(1,0,0);
1187 opargs[O_CRYPT] = A(1,1,0);
1188 opargs[O_EXP] = A(1,0,0);
1189 opargs[O_LOG] = A(1,0,0);
1190 opargs[O_SQRT] = A(1,0,0);
1191 opargs[O_INT] = A(1,0,0);
1192 opargs[O_PRTF] = A(1,0,0);
1193 opargs[O_ORD] = A(1,0,0);
1194 opargs[O_SLEEP] = A(1,0,0);
1195 opargs[O_FLIP] = A(1,0,0);
1196 opargs[O_FLOP] = A(0,1,0);
1197 opargs[O_KEYS] = A(0,0,0);
1198 opargs[O_VALUES] = A(0,0,0);
1199 opargs[O_EACH] = A(0,0,0);
1200 opargs[O_CHOP] = A(1,0,0);
1201 opargs[O_FORK] = A(1,0,0);
1202 opargs[O_EXEC] = A(1,0,0);
1203 opargs[O_SYSTEM] = A(1,0,0);
1204 opargs[O_OCT] = A(1,0,0);
1205 opargs[O_HEX] = A(1,0,0);
1206 opargs[O_CHMOD] = A(1,0,0);
1207 opargs[O_CHOWN] = A(1,0,0);
1208 opargs[O_KILL] = A(1,0,0);
1209 opargs[O_RENAME] = A(1,1,0);
1210 opargs[O_UNLINK] = A(1,0,0);
1211 opargs[O_UMASK] = A(1,0,0);
1212 opargs[O_UNSHIFT] = A(1,0,0);
1213 opargs[O_LINK] = A(1,1,0);
1214 opargs[O_REPEAT] = A(1,1,0);
1215 opargs[O_EVAL] = A(1,0,0);
1219 static void (*ihand)();
1220 static void (*qhand)();
1222 static int (*ihand)();
1223 static int (*qhand)();
1229 STR ***retary; /* where to return an array to, null if nowhere */
1233 register int optype;
1234 register int maxarg;
1237 register STR **sarg = quicksarg;
1238 register char *tmps;
1247 bool assigning = FALSE;
1248 double exp(), log(), sqrt(), modf();
1249 char *crypt(), *getenv();
1253 str = arg->arg_ptr.arg_str;
1254 optype = arg->arg_type;
1255 maxarg = arg->arg_len;
1256 if (maxarg > 3 || retary) {
1257 sarg = (STR **)safemalloc((maxarg+2) * sizeof(STR*));
1261 deb("%s (%lx) %d args:\n",opname[optype],arg,maxarg);
1263 debname[dlevel] = opname[optype][0];
1264 debdelim[dlevel++] = ':';
1266 for (anum = 1; anum <= maxarg; anum++) {
1267 argflags = arg[anum].arg_flags;
1268 if (argflags & AF_SPECIAL)
1271 switch (arg[anum].arg_type) {
1273 sarg[anum] = &str_no;
1282 deb("%d.EXPR =>\n",anum);
1285 sarg[anum] = eval(arg[anum].arg_ptr.arg_arg, Null(STR***));
1291 deb("%d.CMD (%lx) =>\n",anum,arg[anum].arg_ptr.arg_cmd);
1294 sarg[anum] = cmd_exec(arg[anum].arg_ptr.arg_cmd);
1297 sarg[anum] = STAB_STR(arg[anum].arg_ptr.arg_stab);
1300 sprintf(buf,"STAB $%s ==",arg[anum].arg_ptr.arg_stab->stab_name);
1309 deb("%d.LEXPR =>\n",anum);
1312 str = eval(arg[anum].arg_ptr.arg_arg,Null(STR***));
1314 fatal("panic: A_LEXPR\n");
1319 sprintf(buf,"LVAL $%s ==",arg[anum].arg_ptr.arg_stab->stab_name);
1323 str = STAB_STR(arg[anum].arg_ptr.arg_stab);
1325 fatal("panic: A_LVAL\n");
1328 if (argflags & AF_PRE) {
1329 if (argflags & AF_UP)
1335 str = arg->arg_ptr.arg_str;
1337 else if (argflags & AF_POST) {
1338 sarg[anum] = str_static(str);
1339 if (argflags & AF_UP)
1344 str = arg->arg_ptr.arg_str;
1351 sarg[anum] = str_static(&str_no);
1352 str_numset(sarg[anum],
1353 (double)alen(arg[anum].arg_ptr.arg_stab->stab_array));
1359 sarg[anum] = arg[anum].arg_ptr.arg_str;
1365 (void) interp(str,str_get(arg[anum].arg_ptr.arg_str));
1372 tmps = str_get(arg[anum].arg_ptr.arg_str);
1373 fp = popen(str_get(interp(str,tmps)),"r");
1374 tmpstr = str_new(80);
1377 while (str_gets(tmpstr,fp) != Nullch) {
1378 str_scat(str,tmpstr);
1380 statusvalue = pclose(fp);
1393 last_in_stab = arg[anum].arg_ptr.arg_stab;
1394 if (last_in_stab->stab_io) {
1395 fp = last_in_stab->stab_io->fp;
1396 if (!fp && (last_in_stab->stab_io->flags & IOF_ARGV)) {
1397 if (last_in_stab->stab_io->flags & IOF_START) {
1398 last_in_stab->stab_io->flags &= ~IOF_START;
1399 last_in_stab->stab_io->lines = 0;
1400 if (alen(last_in_stab->stab_array) < 0L) {
1401 tmpstr = str_make("-"); /* assume stdin */
1402 apush(last_in_stab->stab_array, tmpstr);
1405 fp = nextargv(last_in_stab);
1406 if (!fp) /* Note: fp != last_in_stab->stab_io->fp */
1407 do_close(last_in_stab,FALSE); /* now it does */
1412 sarg[anum] = &str_no;
1413 else if (!str_gets(str,fp)) {
1414 if (last_in_stab->stab_io->flags & IOF_ARGV) {
1415 fp = nextargv(last_in_stab);
1418 do_close(last_in_stab,FALSE);
1419 last_in_stab->stab_io->flags |= IOF_START;
1424 sarg[anum] = &str_no;
1428 last_in_stab->stab_io->lines++;
1438 deb("%d.%s = '%s'\n",anum,tmps,str_peek(sarg[anum]));
1444 str_sset(str,sarg[1]);
1449 str_sset(str,sarg[2]);
1454 str_sset(str,sarg[3]);
1459 str_sset(str,sarg[1]);
1460 str_scat(str,sarg[2]);
1465 str_sset(str,sarg[1]);
1466 anum = (long)str_gnum(sarg[2]);
1468 tmpstr = str_new(0);
1469 str_sset(tmpstr,str);
1470 for (anum--; anum; anum--)
1471 str_scat(str,tmpstr);
1474 str_sset(str,&str_no);
1478 str_set(str, do_match(str_get(sarg[1]),arg) ? Yes : No);
1482 str_set(str, do_match(str_get(sarg[1]),arg) ? No : Yes);
1486 value = (double) do_subst(str, arg);
1487 str = arg->arg_ptr.arg_str;
1490 str_set(arg->arg_ptr.arg_str, do_subst(str, arg) ? No : Yes);
1491 str = arg->arg_ptr.arg_str;
1494 if (arg[2].arg_flags & AF_SPECIAL)
1498 str_sset(str, sarg[2]);
1503 tmps = str_get(str);
1504 tmps += str->str_cur - (str->str_cur != 0);
1505 str_set(arg->arg_ptr.arg_str,tmps); /* remember last char */
1506 *tmps = '\0'; /* wipe it out */
1507 str->str_cur = tmps - str->str_ptr;
1509 str = arg->arg_ptr.arg_str;
1512 value = str_gnum(sarg[1]);
1513 value *= str_gnum(sarg[2]);
1516 value = str_gnum(sarg[1]);
1517 value /= str_gnum(sarg[2]);
1520 value = str_gnum(sarg[1]);
1521 value = (double)(((long)value) % (long)str_gnum(sarg[2]));
1524 value = str_gnum(sarg[1]);
1525 value += str_gnum(sarg[2]);
1528 value = str_gnum(sarg[1]);
1529 value -= str_gnum(sarg[2]);
1532 value = str_gnum(sarg[1]);
1533 value = (double)(((long)value) << (long)str_gnum(sarg[2]));
1536 value = str_gnum(sarg[1]);
1537 value = (double)(((long)value) >> (long)str_gnum(sarg[2]));
1540 value = str_gnum(sarg[1]);
1541 value = (double)(value < str_gnum(sarg[2]));
1544 value = str_gnum(sarg[1]);
1545 value = (double)(value > str_gnum(sarg[2]));
1548 value = str_gnum(sarg[1]);
1549 value = (double)(value <= str_gnum(sarg[2]));
1552 value = str_gnum(sarg[1]);
1553 value = (double)(value >= str_gnum(sarg[2]));
1556 value = str_gnum(sarg[1]);
1557 value = (double)(value == str_gnum(sarg[2]));
1560 value = str_gnum(sarg[1]);
1561 value = (double)(value != str_gnum(sarg[2]));
1564 value = str_gnum(sarg[1]);
1565 value = (double)(((long)value) & (long)str_gnum(sarg[2]));
1568 value = str_gnum(sarg[1]);
1569 value = (double)(((long)value) ^ (long)str_gnum(sarg[2]));
1572 value = str_gnum(sarg[1]);
1573 value = (double)(((long)value) | (long)str_gnum(sarg[2]));
1576 if (str_true(sarg[1])) {
1580 argflags = arg[anum].arg_flags;
1585 str_sset(str, sarg[1]);
1593 if (str_true(sarg[1])) {
1595 str_set(str, sarg[1]);
1606 argflags = arg[anum].arg_flags;
1610 anum = (str_true(sarg[1]) ? 2 : 3);
1611 optype = (anum == 2 ? O_ITEM2 : O_ITEM3);
1613 argflags = arg[anum].arg_flags;
1619 value = -str_gnum(sarg[1]);
1622 value = (double) !str_true(sarg[1]);
1625 value = (double) ~(long)str_gnum(sarg[1]);
1628 if (arg[1].arg_type == A_LVAL)
1629 defoutstab = arg[1].arg_ptr.arg_stab;
1631 defoutstab = stabent(str_get(sarg[1]),TRUE);
1632 if (!defoutstab->stab_io)
1633 defoutstab->stab_io = stio_new();
1634 curoutstab = defoutstab;
1635 str_set(str,curoutstab->stab_io->fp ? Yes : No);
1641 else if (arg[1].arg_type == A_LVAL)
1642 stab = arg[1].arg_ptr.arg_stab;
1644 stab = stabent(str_get(sarg[1]),TRUE);
1645 if (!stab->stab_io) {
1651 fp = stab->stab_io->fp;
1653 if (stab->stab_io->fmt_stab)
1654 form = stab->stab_io->fmt_stab->stab_form;
1656 form = stab->stab_form;
1662 format(&outrec,form);
1663 do_write(&outrec,stab->stab_io);
1664 if (stab->stab_io->flags & IOF_FLUSH)
1670 if (do_open(arg[1].arg_ptr.arg_stab,str_get(sarg[2]))) {
1672 arg[1].arg_ptr.arg_stab->stab_io->lines = 0;
1679 value = (double) do_trans(str,arg);
1680 str = arg->arg_ptr.arg_str;
1683 str_set(arg->arg_ptr.arg_str, do_trans(str,arg) == 0 ? Yes : No);
1684 str = arg->arg_ptr.arg_str;
1688 do_close(arg[1].arg_ptr.arg_stab,TRUE) ? Yes : No );
1692 str_sset(str,do_each(arg[1].arg_ptr.arg_stab->stab_hash,sarg,retary));
1693 retary = Null(STR***); /* do_each already did retary */
1698 value = (double) do_kv(arg[1].arg_ptr.arg_stab->stab_hash,
1699 optype,sarg,retary);
1700 retary = Null(STR***); /* do_keys already did retary */
1704 ary = arg[1].arg_ptr.arg_stab->stab_array;
1705 maxarg = ary->ary_fill;
1706 if (retary) { /* array wanted */
1708 (STR **)saferealloc((char*)sarg,(maxarg+3)*sizeof(STR*));
1709 for (anum = 0; anum <= maxarg; anum++) {
1710 sarg[anum+1] = str = afetch(ary,anum);
1715 str = afetch(ary,maxarg);
1718 str = afetch(arg[2].arg_ptr.arg_stab->stab_array,
1719 ((int)str_gnum(sarg[1])) - arybase);
1724 tmpstab = arg[2].arg_ptr.arg_stab; /* XXX */
1725 str = hfetch(tmpstab->stab_hash,str_get(sarg[1]));
1730 anum = ((int)str_gnum(sarg[1])) - arybase;
1731 str = afetch(arg[2].arg_ptr.arg_stab->stab_array,anum);
1732 if (!str || str == &str_no) {
1734 astore(arg[2].arg_ptr.arg_stab->stab_array,anum,str);
1738 tmpstab = arg[2].arg_ptr.arg_stab;
1739 str = hfetch(tmpstab->stab_hash,str_get(sarg[1]));
1742 hstore(tmpstab->stab_hash,str_get(sarg[1]),str);
1744 if (tmpstab == envstab) { /* heavy wizardry going on here */
1745 str->str_link.str_magic = tmpstab;/* str is now magic */
1746 envname = savestr(str_get(sarg[1]));
1747 /* he threw the brick up into the air */
1749 else if (tmpstab == sigstab) { /* same thing, only different */
1750 str->str_link.str_magic = tmpstab;
1751 signame = savestr(str_get(sarg[1]));
1755 if (arg[1].arg_flags & AF_SPECIAL)
1756 str = do_push(arg,arg[2].arg_ptr.arg_stab->stab_array);
1758 str = str_new(0); /* must copy the STR */
1759 str_sset(str,sarg[1]);
1760 apush(arg[2].arg_ptr.arg_stab->stab_array,str);
1764 str = apop(arg[1].arg_ptr.arg_stab->stab_array);
1768 *(arg->arg_ptr.arg_str) = *str;
1770 bcopy((char*)str, (char*)arg->arg_ptr.arg_str, sizeof *str);
1772 safefree((char*)str);
1773 str = arg->arg_ptr.arg_str;
1776 str = ashift(arg[1].arg_ptr.arg_stab->stab_array);
1780 *(arg->arg_ptr.arg_str) = *str;
1782 bcopy((char*)str, (char*)arg->arg_ptr.arg_str, sizeof *str);
1784 safefree((char*)str);
1785 str = arg->arg_ptr.arg_str;
1788 value = (double) do_split(str_get(sarg[1]),arg[2].arg_ptr.arg_spat,retary);
1789 retary = Null(STR***); /* do_split already did retary */
1792 value = (double) str_len(sarg[1]);
1795 sarg[maxarg+1] = Nullstr;
1796 do_sprintf(str,arg->arg_len,sarg);
1799 anum = ((int)str_gnum(sarg[2])) - arybase;
1800 for (tmps = str_get(sarg[1]); *tmps && anum > 0; tmps++,anum--) ;
1801 anum = (int)str_gnum(sarg[3]);
1802 if (anum >= 0 && strlen(tmps) > anum)
1803 str_nset(str, tmps, anum);
1808 if (arg[2].arg_flags & AF_SPECIAL && arg[2].arg_type == A_EXPR)
1809 do_join(arg,str_get(sarg[1]),str);
1811 ajoin(arg[2].arg_ptr.arg_stab->stab_array,str_get(sarg[1]),str);
1814 tmps = str_get(sarg[1]);
1815 value = (double) strLT(tmps,str_get(sarg[2]));
1818 tmps = str_get(sarg[1]);
1819 value = (double) strGT(tmps,str_get(sarg[2]));
1822 tmps = str_get(sarg[1]);
1823 value = (double) strLE(tmps,str_get(sarg[2]));
1826 tmps = str_get(sarg[1]);
1827 value = (double) strGE(tmps,str_get(sarg[2]));
1830 tmps = str_get(sarg[1]);
1831 value = (double) strEQ(tmps,str_get(sarg[2]));
1834 tmps = str_get(sarg[1]);
1835 value = (double) strNE(tmps,str_get(sarg[2]));
1838 str_sset(str,do_subr(arg,sarg));
1846 stab = arg[2].arg_ptr.arg_stab;
1852 else if (arg[1].arg_flags & AF_SPECIAL)
1853 value = (double)do_aprint(arg,stab->stab_io->fp);
1855 value = (double)do_print(str_get(sarg[1]),stab->stab_io->fp);
1856 if (ors && optype == O_PRINT)
1857 do_print(ors, stab->stab_io->fp);
1859 if (stab->stab_io->flags & IOF_FLUSH)
1860 fflush(stab->stab_io->fp);
1863 tmps = str_get(sarg[1]);
1864 if (!tmps || !*tmps)
1865 tmps = getenv("HOME");
1866 if (!tmps || !*tmps)
1867 tmps = getenv("LOGDIR");
1868 value = (double)(chdir(tmps) >= 0);
1871 tmps = str_get(sarg[1]);
1872 if (!tmps || !*tmps)
1874 fatal("%s\n",str_get(sarg[1]));
1878 exit((int)str_gnum(sarg[1]));
1882 str_reset(str_get(sarg[1]));
1887 str = sarg[maxarg]; /* unwanted list, return last item */
1892 str_set(str, do_eof(maxarg > 0 ? arg[1].arg_ptr.arg_stab : last_in_stab) ? Yes : No);
1896 value = (double)do_tell(maxarg > 0 ? arg[1].arg_ptr.arg_stab : last_in_stab);
1900 value = str_gnum(sarg[2]);
1901 str_set(str, do_seek(arg[1].arg_ptr.arg_stab,
1902 (long)value, (int)str_gnum(sarg[3]) ) ? Yes : No);
1909 tmps = str_get(sarg[1]);
1910 while (loop_ptr >= 0 && (!loop_stack[loop_ptr].loop_label ||
1911 strNE(tmps,loop_stack[loop_ptr].loop_label) )) {
1914 deb("(Skipping label #%d %s)\n",loop_ptr,
1915 loop_stack[loop_ptr].loop_label);
1922 deb("(Found label #%d %s)\n",loop_ptr,
1923 loop_stack[loop_ptr].loop_label);
1928 fatal("Bad label: %s\n", maxarg > 0 ? tmps : "<null>");
1929 longjmp(loop_stack[loop_ptr].loop_env, optype);
1930 case O_GOTO:/* shudder */
1931 goto_targ = str_get(sarg[1]);
1932 longjmp(top_env, 1);
1934 tmps = str_get(sarg[1]);
1935 if (!(tmps2 = instr(tmps,str_get(sarg[2]))))
1936 value = (double)(-1 + arybase);
1938 value = (double)(tmps2 - tmps + arybase);
1941 value = (double) time(0);
1944 value = (double) do_tms(retary);
1945 retary = Null(STR***); /* do_tms already did retary */
1948 tmplong = (long) str_gnum(sarg[1]);
1949 value = (double) do_time(localtime(&tmplong),retary);
1950 retary = Null(STR***); /* do_localtime already did retary */
1953 tmplong = (long) str_gnum(sarg[1]);
1954 value = (double) do_time(gmtime(&tmplong),retary);
1955 retary = Null(STR***); /* do_gmtime already did retary */
1958 value = (double) do_stat(arg,sarg,retary);
1959 retary = Null(STR***); /* do_stat already did retary */
1963 tmps = str_get(sarg[1]);
1964 str_set(str,crypt(tmps,str_get(sarg[2])));
1967 "The crypt() function is unimplemented due to excessive paranoia.");
1971 value = exp(str_gnum(sarg[1]));
1974 value = log(str_gnum(sarg[1]));
1977 value = sqrt(str_gnum(sarg[1]));
1980 modf(str_gnum(sarg[1]),&value);
1983 value = (double) *str_get(sarg[1]);
1986 tmps = str_get(sarg[1]);
1988 if (!tmps || !*tmps)
1989 sleep((32767<<16)+32767);
1992 value = (double)tmplong;
1994 value = ((double)tmplong) - value;
1997 if (str_true(sarg[1])) {
1998 str_numset(str,0.0);
2000 arg->arg_type = optype = O_FLOP;
2002 arg[2].arg_flags &= ~AF_SPECIAL;
2003 arg[1].arg_flags |= AF_SPECIAL;
2004 argflags = arg[anum].arg_flags;
2011 if (str_true(sarg[2])) {
2012 arg->arg_type = O_FLIP;
2013 arg[1].arg_flags &= ~AF_SPECIAL;
2014 arg[2].arg_flags |= AF_SPECIAL;
2019 value = (double)fork();
2022 if (anum = vfork()) {
2023 ihand = signal(SIGINT, SIG_IGN);
2024 qhand = signal(SIGQUIT, SIG_IGN);
2025 while ((maxarg = wait(&argflags)) != anum && maxarg != -1)
2029 signal(SIGINT, ihand);
2030 signal(SIGQUIT, qhand);
2031 value = (double)argflags;
2036 if (arg[1].arg_flags & AF_SPECIAL)
2037 value = (double)do_aexec(arg);
2039 value = (double)do_exec(str_get(sarg[1]));
2051 tmps = str_get(sarg[1]);
2060 case '0': case '1': case '2': case '3': case '4':
2061 case '5': case '6': case '7':
2063 anum += *tmps++ & 15;
2065 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
2066 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
2070 anum += (*tmps++ & 7) + 9;
2079 value = (double)anum;
2085 if (arg[1].arg_flags & AF_SPECIAL)
2086 value = (double)apply(optype,arg,Null(STR**));
2089 value = (double)apply(optype,arg,sarg);
2093 value = (double)umask((int)str_gnum(sarg[1]));
2096 tmps = str_get(sarg[1]);
2098 value = (double)(rename(tmps,str_get(sarg[2])) >= 0);
2100 tmps2 = str_get(sarg[2]);
2102 if (!(anum = link(tmps,tmps2)))
2103 anum = UNLINK(tmps);
2104 value = (double)(anum >= 0);
2108 tmps = str_get(sarg[1]);
2109 value = (double)(link(tmps,str_get(sarg[2])) >= 0);
2112 ary = arg[2].arg_ptr.arg_stab->stab_array;
2113 if (arg[1].arg_flags & AF_SPECIAL)
2114 do_unshift(arg,ary);
2116 str = str_new(0); /* must copy the STR */
2117 str_sset(str,sarg[1]);
2121 value = (double)(ary->ary_fill + 1);
2125 do_eval(arg[1].arg_type != A_NULL ? sarg[1] : defstab->stab_val) );
2132 deb("%s RETURNS \"%s\"\n",opname[optype],str_get(str));
2137 str_numset(str,value);
2142 deb("%s RETURNS \"%f\"\n",opname[optype],value);
2146 if (sarg != quicksarg) {
2148 if (optype == O_LIST)
2152 sarg[maxarg+1] = Nullstr;
2153 *retary = sarg; /* up to them to free it */
2165 deb("%s RETURNS ()\n",opname[optype],value);