arg.c

   1 /* $Header: arg.c,v 1.0.1.3 88/01/26 12:30:33 root Exp $
   2  *
   3  * $Log:        arg.c,v $
   4  * Revision 1.0.1.3  88/01/26  12:30:33  root
   5  * patch 6: sprintf didn't finish processing format string when out of args.
   6  *
   7  * Revision 1.0.1.2  88/01/24  03:52:34  root
   8  * patch 2: added STATBLKS dependencies.
   9  *
  10  * Revision 1.0.1.1  88/01/21  21:27:10  root
  11  * Now defines signal return values correctly using VOIDSIG.
  12  *
  13  * Revision 1.0  87/12/18  13:04:33  root
  14  * Initial revision
  15  *
  16  */
  17
  18 #include <signal.h>
  19 #include "handy.h"
  20 #include "EXTERN.h"
  21 #include "search.h"
  22 #include "util.h"
  23 #include "perl.h"
  24
  25 ARG *debarg;
  26
  27 bool
  28 do_match(s,arg)
  29 register char *s;
  30 register ARG *arg;
  31 {
  32     register SPAT *spat = arg[2].arg_ptr.arg_spat;
  33     register char *d;
  34     register char *t;
  35
  36     if (!spat || !s)
  37         fatal("panic: do_match\n");
  38     if (spat->spat_flags & SPAT_USED) {
  39 #ifdef DEBUGGING
  40         if (debug & 8)
  41             deb("2.SPAT USED\n");
  42 #endif
  43         return FALSE;
  44     }
  45     if (spat->spat_runtime) {
  46         t = str_get(eval(spat->spat_runtime,Null(STR***)));
  47 #ifdef DEBUGGING
  48         if (debug & 8)
  49             deb("2.SPAT /%s/\n",t);
  50 #endif
  51         if (d = compile(&spat->spat_compex,t,TRUE,FALSE)) {
  52 #ifdef DEBUGGING
  53             deb("/%s/: %s\n", t, d);
  54 #endif
  55             return FALSE;
  56         }
  57         if (spat->spat_compex.complen <= 1 && curspat)
  58             spat = curspat;
  59         if (execute(&spat->spat_compex, s, TRUE, 0)) {
  60             if (spat->spat_compex.numsubs)
  61                 curspat = spat;
  62             return TRUE;
  63         }
  64         else
  65             return FALSE;
  66     }
  67     else {
  68 #ifdef DEBUGGING
  69         if (debug & 8) {
  70             char ch;
  71
  72             if (spat->spat_flags & SPAT_USE_ONCE)
  73                 ch = '?';
  74             else
  75                 ch = '/';
  76             deb("2.SPAT %c%s%c\n",ch,spat->spat_compex.precomp,ch);
  77         }
  78 #endif
  79         if (spat->spat_compex.complen <= 1 && curspat)
  80             spat = curspat;
  81         if (spat->spat_first) {
  82             if (spat->spat_flags & SPAT_SCANFIRST) {
  83                 str_free(spat->spat_first);
  84                 spat->spat_first = Nullstr;     /* disable optimization */
  85             }
  86             else if (*spat->spat_first->str_ptr != *s ||
  87               strnNE(spat->spat_first->str_ptr, s, spat->spat_flen) )
  88                 return FALSE;
  89         }
  90         if (execute(&spat->spat_compex, s, TRUE, 0)) {
  91             if (spat->spat_compex.numsubs)
  92                 curspat = spat;
  93             if (spat->spat_flags & SPAT_USE_ONCE)
  94                 spat->spat_flags |= SPAT_USED;
  95             return TRUE;
  96         }
  97         else
  98             return FALSE;
  99     }
 100     /*NOTREACHED*/
 101 }
 102
 103 int
 104 do_subst(str,arg)
 105 STR *str;
 106 register ARG *arg;
 107 {
 108     register SPAT *spat;
 109     register STR *dstr;
 110     register char *s;
 111     register char *m;
 112
 113     spat = arg[2].arg_ptr.arg_spat;
 114     s = str_get(str);
 115     if (!spat || !s)
 116         fatal("panic: do_subst\n");
 117     else if (spat->spat_runtime) {
 118         char *d;
 119
 120         m = str_get(eval(spat->spat_runtime,Null(STR***)));
 121         if (d = compile(&spat->spat_compex,m,TRUE,FALSE)) {
 122 #ifdef DEBUGGING
 123             deb("/%s/: %s\n", m, d);
 124 #endif
 125             return 0;
 126         }
 127     }
 128 #ifdef DEBUGGING
 129     if (debug & 8) {
 130         deb("2.SPAT /%s/\n",spat->spat_compex.precomp);
 131     }
 132 #endif
 133     if (spat->spat_compex.complen <= 1 && curspat)
 134         spat = curspat;
 135     if (spat->spat_first) {
 136         if (spat->spat_flags & SPAT_SCANFIRST) {
 137             str_free(spat->spat_first);
 138             spat->spat_first = Nullstr; /* disable optimization */
 139         }
 140         else if (*spat->spat_first->str_ptr != *s ||
 141           strnNE(spat->spat_first->str_ptr, s, spat->spat_flen) )
 142             return 0;
 143     }
 144     if (m = execute(&spat->spat_compex, s, TRUE, 1)) {
 145         int iters = 0;
 146
 147         dstr = str_new(str_len(str));
 148         if (spat->spat_compex.numsubs)
 149             curspat = spat;
 150         do {
 151             if (iters++ > 10000)
 152                 fatal("Substitution loop?\n");
 153             if (spat->spat_compex.numsubs)
 154                 s = spat->spat_compex.subbase;
 155             str_ncat(dstr,s,m-s);
 156             s = spat->spat_compex.subend[0];
 157             str_scat(dstr,eval(spat->spat_repl,Null(STR***)));
 158             if (spat->spat_flags & SPAT_USE_ONCE)
 159                 break;
 160         } while (m = execute(&spat->spat_compex, s, FALSE, 1));
 161         str_cat(dstr,s);
 162         str_replace(str,dstr);
 163         STABSET(str);
 164         return iters;
 165     }
 166     return 0;
 167 }
 168
 169 int
 170 do_trans(str,arg)
 171 STR *str;
 172 register ARG *arg;
 173 {
 174     register char *tbl;
 175     register char *s;
 176     register int matches = 0;
 177     register int ch;
 178
 179     tbl = arg[2].arg_ptr.arg_cval;
 180     s = str_get(str);
 181     if (!tbl || !s)
 182         fatal("panic: do_trans\n");
 183 #ifdef DEBUGGING
 184     if (debug & 8) {
 185         deb("2.TBL\n");
 186     }
 187 #endif
 188     while (*s) {
 189         if (ch = tbl[*s & 0377]) {
 190             matches++;
 191             *s = ch;
 192         }
 193         s++;
 194     }
 195     STABSET(str);
 196     return matches;
 197 }
 198
 199 int
 200 do_split(s,spat,retary)
 201 register char *s;
 202 register SPAT *spat;
 203 STR ***retary;
 204 {
 205     register STR *dstr;
 206     register char *m;
 207     register ARRAY *ary;
 208     static ARRAY *myarray = Null(ARRAY*);
 209     int iters = 0;
 210     STR **sarg;
 211     register char *e;
 212     int i;
 213
 214     if (!spat || !s)
 215         fatal("panic: do_split\n");
 216     else if (spat->spat_runtime) {
 217         char *d;
 218
 219         m = str_get(eval(spat->spat_runtime,Null(STR***)));
 220         if (d = compile(&spat->spat_compex,m,TRUE,FALSE)) {
 221 #ifdef DEBUGGING
 222             deb("/%s/: %s\n", m, d);
 223 #endif
 224             return FALSE;
 225         }
 226     }
 227 #ifdef DEBUGGING
 228     if (debug & 8) {
 229         deb("2.SPAT /%s/\n",spat->spat_compex.precomp);
 230     }
 231 #endif
 232     if (retary)
 233         ary = myarray;
 234     else
 235         ary = spat->spat_repl[1].arg_ptr.arg_stab->stab_array;
 236     if (!ary)
 237         myarray = ary = anew();
 238     ary->ary_fill = -1;
 239     while (*s && (m = execute(&spat->spat_compex, s, (iters == 0), 1))) {
 240         if (spat->spat_compex.numsubs)
 241             s = spat->spat_compex.subbase;
 242         dstr = str_new(m-s);
 243         str_nset(dstr,s,m-s);
 244         astore(ary, iters++, dstr);
 245         if (iters > 10000)
 246             fatal("Substitution loop?\n");
 247         s = spat->spat_compex.subend[0];
 248     }
 249     if (*s) {                   /* ignore field after final "whitespace" */
 250         dstr = str_new(0);      /*   if they interpolate, it's null anyway */
 251         str_set(dstr,s);
 252         astore(ary, iters++, dstr);
 253     }
 254     else {
 255         while (iters > 0 && !*str_get(afetch(ary,iters-1)))
 256             iters--;
 257     }
 258     if (retary) {
 259         sarg = (STR**)safemalloc((iters+2)*sizeof(STR*));
 260
 261         sarg[0] = Nullstr;
 262         sarg[iters+1] = Nullstr;
 263         for (i = 1; i <= iters; i++)
 264             sarg[i] = afetch(ary,i-1);
 265         *retary = sarg;
 266     }
 267     return iters;
 268 }
 269
 270 void
 271 do_join(arg,delim,str)
 272 register ARG *arg;
 273 register char *delim;
 274 register STR *str;
 275 {
 276     STR **tmpary;       /* must not be register */
 277     register STR **elem;
 278
 279     (void)eval(arg[2].arg_ptr.arg_arg,&tmpary);
 280     elem = tmpary+1;
 281     if (*elem)
 282     str_sset(str,*elem++);
 283     for (; *elem; elem++) {
 284         str_cat(str,delim);
 285         str_scat(str,*elem);
 286     }
 287     STABSET(str);
 288     safefree((char*)tmpary);
 289 }
 290
 291 bool
 292 do_open(stab,name)
 293 STAB *stab;
 294 register char *name;
 295 {
 296     FILE *fp;
 297     int len = strlen(name);
 298     register STIO *stio = stab->stab_io;
 299
 300     while (len && isspace(name[len-1]))
 301         name[--len] = '\0';
 302     if (!stio)
 303         stio = stab->stab_io = stio_new();
 304     if (stio->fp) {
 305         if (stio->type == '|')
 306             pclose(stio->fp);
 307         else if (stio->type != '-')
 308             fclose(stio->fp);
 309         stio->fp = Nullfp;
 310     }
 311     stio->type = *name;
 312     if (*name == '|') {
 313         for (name++; isspace(*name); name++) ;
 314         fp = popen(name,"w");
 315     }
 316     else if (*name == '>' && name[1] == '>') {
 317         for (name += 2; isspace(*name); name++) ;
 318         fp = fopen(name,"a");
 319     }
 320     else if (*name == '>') {
 321         for (name++; isspace(*name); name++) ;
 322         if (strEQ(name,"-")) {
 323             fp = stdout;
 324             stio->type = '-';
 325         }
 326         else
 327             fp = fopen(name,"w");
 328     }
 329     else {
 330         if (*name == '<') {
 331             for (name++; isspace(*name); name++) ;
 332             if (strEQ(name,"-")) {
 333                 fp = stdin;
 334                 stio->type = '-';
 335             }
 336             else
 337                 fp = fopen(name,"r");
 338         }
 339         else if (name[len-1] == '|') {
 340             name[--len] = '\0';
 341             while (len && isspace(name[len-1]))
 342                 name[--len] = '\0';
 343             for (; isspace(*name); name++) ;
 344             fp = popen(name,"r");
 345             stio->type = '|';
 346         }
 347         else {
 348             stio->type = '<';
 349             for (; isspace(*name); name++) ;
 350             if (strEQ(name,"-")) {
 351                 fp = stdin;
 352                 stio->type = '-';
 353             }
 354             else
 355                 fp = fopen(name,"r");
 356         }
 357     }
 358     if (!fp)
 359         return FALSE;
 360     if (stio->type != '|' && stio->type != '-') {
 361         if (fstat(fileno(fp),&statbuf) < 0) {
 362             fclose(fp);
 363             return FALSE;
 364         }
 365         if ((statbuf.st_mode & S_IFMT) != S_IFREG &&
 366             (statbuf.st_mode & S_IFMT) != S_IFCHR) {
 367             fclose(fp);
 368             return FALSE;
 369         }
 370     }
 371     stio->fp = fp;
 372     return TRUE;
 373 }
 374
 375 FILE *
 376 nextargv(stab)
 377 register STAB *stab;
 378 {
 379     register STR *str;
 380     char *oldname;
 381
 382     while (alen(stab->stab_array) >= 0L) {
 383         str = ashift(stab->stab_array);
 384         str_sset(stab->stab_val,str);
 385         STABSET(stab->stab_val);
 386         oldname = str_get(stab->stab_val);
 387         if (do_open(stab,oldname)) {
 388             if (inplace) {
 389                 if (*inplace) {
 390                     str_cat(str,inplace);
 391 #ifdef RENAME
 392                     rename(oldname,str->str_ptr);
 393 #else
 394                     UNLINK(str->str_ptr);
 395                     link(oldname,str->str_ptr);
 396                     UNLINK(oldname);
 397 #endif
 398                 }
 399                 sprintf(tokenbuf,">%s",oldname);
 400                 do_open(argvoutstab,tokenbuf);
 401                 defoutstab = argvoutstab;
 402             }
 403             str_free(str);
 404             return stab->stab_io->fp;
 405         }
 406         else
 407             fprintf(stderr,"Can't open %s\n",str_get(str));
 408         str_free(str);
 409     }
 410     if (inplace) {
 411         do_close(argvoutstab,FALSE);
 412         defoutstab = stabent("stdout",TRUE);
 413     }
 414     return Nullfp;
 415 }
 416
 417 bool
 418 do_close(stab,explicit)
 419 STAB *stab;
 420 bool explicit;
 421 {
 422     bool retval = FALSE;
 423     register STIO *stio = stab->stab_io;
 424
 425     if (!stio)          /* never opened */
 426         return FALSE;
 427     if (stio->fp) {
 428         if (stio->type == '|')
 429             retval = (pclose(stio->fp) >= 0);
 430         else if (stio->type == '-')
 431             retval = TRUE;
 432         else
 433             retval = (fclose(stio->fp) != EOF);
 434         stio->fp = Nullfp;
 435     }
 436     if (explicit)
 437         stio->lines = 0;
 438     stio->type = ' ';
 439     return retval;
 440 }
 441
 442 bool
 443 do_eof(stab)
 444 STAB *stab;
 445 {
 446     register STIO *stio;
 447     int ch;
 448
 449     if (!stab)
 450         return TRUE;
 451
 452     stio = stab->stab_io;
 453     if (!stio)
 454         return TRUE;
 455
 456     while (stio->fp) {
 457
 458 #ifdef STDSTDIO                 /* (the code works without this) */
 459         if (stio->fp->_cnt)             /* cheat a little, since */
 460             return FALSE;               /* this is the most usual case */
 461 #endif
 462
 463         ch = getc(stio->fp);
 464         if (ch != EOF) {
 465             ungetc(ch, stio->fp);
 466             return FALSE;
 467         }
 468         if (stio->flags & IOF_ARGV) {   /* not necessarily a real EOF yet? */
 469             if (!nextargv(stab))        /* get another fp handy */
 470                 return TRUE;
 471         }
 472         else
 473             return TRUE;                /* normal fp, definitely end of file */
 474     }
 475     return TRUE;
 476 }
 477
 478 long
 479 do_tell(stab)
 480 STAB *stab;
 481 {
 482     register STIO *stio;
 483     int ch;
 484
 485     if (!stab)
 486         return -1L;
 487
 488     stio = stab->stab_io;
 489     if (!stio || !stio->fp)
 490         return -1L;
 491
 492     return ftell(stio->fp);
 493 }
 494
 495 bool
 496 do_seek(stab, pos, whence)
 497 STAB *stab;
 498 long pos;
 499 int whence;
 500 {
 501     register STIO *stio;
 502
 503     if (!stab)
 504         return FALSE;
 505
 506     stio = stab->stab_io;
 507     if (!stio || !stio->fp)
 508         return FALSE;
 509
 510     return fseek(stio->fp, pos, whence) >= 0;
 511 }
 512
 513 do_stat(arg,sarg,retary)
 514 register ARG *arg;
 515 register STR **sarg;
 516 STR ***retary;
 517 {
 518     register ARRAY *ary;
 519     static ARRAY *myarray = Null(ARRAY*);
 520     int max = 13;
 521     register int i;
 522
 523     ary = myarray;
 524     if (!ary)
 525         myarray = ary = anew();
 526     ary->ary_fill = -1;
 527     if (arg[1].arg_type == A_LVAL) {
 528         tmpstab = arg[1].arg_ptr.arg_stab;
 529         if (!tmpstab->stab_io ||
 530           fstat(fileno(tmpstab->stab_io->fp),&statbuf) < 0) {
 531             max = 0;
 532         }
 533     }
 534     else
 535         if (stat(str_get(sarg[1]),&statbuf) < 0)
 536             max = 0;
 537
 538     if (retary) {
 539         if (max) {
 540             apush(ary,str_nmake((double)statbuf.st_dev));
 541             apush(ary,str_nmake((double)statbuf.st_ino));
 542             apush(ary,str_nmake((double)statbuf.st_mode));
 543             apush(ary,str_nmake((double)statbuf.st_nlink));
 544             apush(ary,str_nmake((double)statbuf.st_uid));
 545             apush(ary,str_nmake((double)statbuf.st_gid));
 546             apush(ary,str_nmake((double)statbuf.st_rdev));
 547             apush(ary,str_nmake((double)statbuf.st_size));
 548             apush(ary,str_nmake((double)statbuf.st_atime));
 549             apush(ary,str_nmake((double)statbuf.st_mtime));
 550             apush(ary,str_nmake((double)statbuf.st_ctime));
 551 #ifdef STATBLOCKS
 552             apush(ary,str_nmake((double)statbuf.st_blksize));
 553             apush(ary,str_nmake((double)statbuf.st_blocks));
 554 #else
 555             apush(ary,str_make("");
 556             apush(ary,str_make("");
 557 #endif
 558         }
 559         sarg = (STR**)safemalloc((max+2)*sizeof(STR*));
 560         sarg[0] = Nullstr;
 561         sarg[max+1] = Nullstr;
 562         for (i = 1; i <= max; i++)
 563             sarg[i] = afetch(ary,i-1);
 564         *retary = sarg;
 565     }
 566     return max;
 567 }
 568
 569 do_tms(retary)
 570 STR ***retary;
 571 {
 572     register ARRAY *ary;
 573     static ARRAY *myarray = Null(ARRAY*);
 574     register STR **sarg;
 575     int max = 4;
 576     register int i;
 577
 578     ary = myarray;
 579     if (!ary)
 580         myarray = ary = anew();
 581     ary->ary_fill = -1;
 582     if (times(&timesbuf) < 0)
 583         max = 0;
 584
 585     if (retary) {
 586         if (max) {
 587             apush(ary,str_nmake(((double)timesbuf.tms_utime)/60.0));
 588             apush(ary,str_nmake(((double)timesbuf.tms_stime)/60.0));
 589             apush(ary,str_nmake(((double)timesbuf.tms_cutime)/60.0));
 590             apush(ary,str_nmake(((double)timesbuf.tms_cstime)/60.0));
 591         }
 592         sarg = (STR**)safemalloc((max+2)*sizeof(STR*));
 593         sarg[0] = Nullstr;
 594         sarg[max+1] = Nullstr;
 595         for (i = 1; i <= max; i++)
 596             sarg[i] = afetch(ary,i-1);
 597         *retary = sarg;
 598     }
 599     return max;
 600 }
 601
 602 do_time(tmbuf,retary)
 603 struct tm *tmbuf;
 604 STR ***retary;
 605 {
 606     register ARRAY *ary;
 607     static ARRAY *myarray = Null(ARRAY*);
 608     register STR **sarg;
 609     int max = 9;
 610     register int i;
 611     STR *str;
 612
 613     ary = myarray;
 614     if (!ary)
 615         myarray = ary = anew();
 616     ary->ary_fill = -1;
 617     if (!tmbuf)
 618         max = 0;
 619
 620     if (retary) {
 621         if (max) {
 622             apush(ary,str_nmake((double)tmbuf->tm_sec));
 623             apush(ary,str_nmake((double)tmbuf->tm_min));
 624             apush(ary,str_nmake((double)tmbuf->tm_hour));
 625             apush(ary,str_nmake((double)tmbuf->tm_mday));
 626             apush(ary,str_nmake((double)tmbuf->tm_mon));
 627             apush(ary,str_nmake((double)tmbuf->tm_year));
 628             apush(ary,str_nmake((double)tmbuf->tm_wday));
 629             apush(ary,str_nmake((double)tmbuf->tm_yday));
 630             apush(ary,str_nmake((double)tmbuf->tm_isdst));
 631         }
 632         sarg = (STR**)safemalloc((max+2)*sizeof(STR*));
 633         sarg[0] = Nullstr;
 634         sarg[max+1] = Nullstr;
 635         for (i = 1; i <= max; i++)
 636             sarg[i] = afetch(ary,i-1);
 637         *retary = sarg;
 638     }
 639     return max;
 640 }
 641
 642 void
 643 do_sprintf(str,len,sarg)
 644 register STR *str;
 645 register int len;
 646 register STR **sarg;
 647 {
 648     register char *s;
 649     register char *t;
 650     bool dolong;
 651     char ch;
 652     static STR *sargnull = &str_no;
 653
 654     str_set(str,"");
 655     len--;                      /* don't count pattern string */
 656     sarg++;
 657     for (s = str_get(*(sarg++)); *s; len--) {
 658         if (len <= 0 || !*sarg) {
 659             sarg = &sargnull;
 660             len = 0;
 661         }
 662         dolong = FALSE;
 663         for (t = s; *t && *t != '%'; t++) ;
 664         if (!*t)
 665             break;              /* not enough % patterns, oh well */
 666         for (t++; *sarg && *t && t != s; t++) {
 667             switch (*t) {
 668             case '\0':
 669                 break;
 670             case '%':
 671                 ch = *(++t);
 672                 *t = '\0';
 673                 sprintf(buf,s);
 674                 s = t;
 675                 *(t--) = ch;
 676                 break;
 677             case 'l':
 678                 dolong = TRUE;
 679                 break;
 680             case 'D': case 'X': case 'O':
 681                 dolong = TRUE;
 682                 /* FALL THROUGH */
 683             case 'd': case 'x': case 'o': case 'c':
 684                 ch = *(++t);
 685                 *t = '\0';
 686                 if (dolong)
 687                     sprintf(buf,s,(long)str_gnum(*(sarg++)));
 688                 else
 689                     sprintf(buf,s,(int)str_gnum(*(sarg++)));
 690                 s = t;
 691                 *(t--) = ch;
 692                 break;
 693             case 'E': case 'e': case 'f': case 'G': case 'g':
 694                 ch = *(++t);
 695                 *t = '\0';
 696                 sprintf(buf,s,str_gnum(*(sarg++)));
 697                 s = t;
 698                 *(t--) = ch;
 699                 break;
 700             case 's':
 701                 ch = *(++t);
 702                 *t = '\0';
 703                 sprintf(buf,s,str_get(*(sarg++)));
 704                 s = t;
 705                 *(t--) = ch;
 706                 break;
 707             }
 708         }
 709         str_cat(str,buf);
 710     }
 711     if (*s)
 712         str_cat(str,s);
 713     STABSET(str);
 714 }
 715
 716 bool
 717 do_print(s,fp)
 718 char *s;
 719 FILE *fp;
 720 {
 721     if (!fp || !s)
 722         return FALSE;
 723     fputs(s,fp);
 724     return TRUE;
 725 }
 726
 727 bool
 728 do_aprint(arg,fp)
 729 register ARG *arg;
 730 register FILE *fp;
 731 {
 732     STR **tmpary;       /* must not be register */
 733     register STR **elem;
 734     register bool retval;
 735     double value;
 736
 737     (void)eval(arg[1].arg_ptr.arg_arg,&tmpary);
 738     if (arg->arg_type == O_PRTF) {
 739         do_sprintf(arg->arg_ptr.arg_str,32767,tmpary);
 740         retval = do_print(str_get(arg->arg_ptr.arg_str),fp);
 741     }
 742     else {
 743         retval = FALSE;
 744         for (elem = tmpary+1; *elem; elem++) {
 745             if (retval && ofs)
 746                 do_print(ofs, fp);
 747             if (ofmt && fp) {
 748                 if ((*elem)->str_nok || str_gnum(*elem) != 0.0)
 749                     fprintf(fp, ofmt, str_gnum(*elem));
 750                 retval = TRUE;
 751             }
 752             else
 753                 retval = do_print(str_get(*elem), fp);
 754             if (!retval)
 755                 break;
 756         }
 757         if (ors)
 758             retval = do_print(ors, fp);
 759     }
 760     safefree((char*)tmpary);
 761     return retval;
 762 }
 763
 764 bool
 765 do_aexec(arg)
 766 register ARG *arg;
 767 {
 768     STR **tmpary;       /* must not be register */
 769     register STR **elem;
 770     register char **a;
 771     register int i;
 772     char **argv;
 773
 774     (void)eval(arg[1].arg_ptr.arg_arg,&tmpary);
 775     i = 0;
 776     for (elem = tmpary+1; *elem; elem++)
 777         i++;
 778     if (i) {
 779         argv = (char**)safemalloc((i+1)*sizeof(char*));
 780         a = argv;
 781         for (elem = tmpary+1; *elem; elem++) {
 782             *a++ = str_get(*elem);
 783         }
 784         *a = Nullch;
 785         execvp(argv[0],argv);
 786         safefree((char*)argv);
 787     }
 788     safefree((char*)tmpary);
 789     return FALSE;
 790 }
 791
 792 bool
 793 do_exec(cmd)
 794 char *cmd;
 795 {
 796     STR **tmpary;       /* must not be register */
 797     register char **a;
 798     register char *s;
 799     char **argv;
 800
 801     /* see if there are shell metacharacters in it */
 802
 803     for (s = cmd; *s; s++) {
 804         if (*s != ' ' && !isalpha(*s) && index("$&*(){}[]'\";\\|?<>~`",*s)) {
 805             execl("/bin/sh","sh","-c",cmd,0);
 806             return FALSE;
 807         }
 808     }
 809     argv = (char**)safemalloc(((s - cmd) / 2 + 2)*sizeof(char*));
 810
 811     a = argv;
 812     for (s = cmd; *s;) {
 813         while (isspace(*s)) s++;
 814         if (*s)
 815             *(a++) = s;
 816         while (*s && !isspace(*s)) s++;
 817         if (*s)
 818             *s++ = '\0';
 819     }
 820     *a = Nullch;
 821     if (argv[0])
 822         execvp(argv[0],argv);
 823     safefree((char*)argv);
 824     return FALSE;
 825 }
 826
 827 STR *
 828 do_push(arg,ary)
 829 register ARG *arg;
 830 register ARRAY *ary;
 831 {
 832     STR **tmpary;       /* must not be register */
 833     register STR **elem;
 834     register STR *str = &str_no;
 835
 836     (void)eval(arg[1].arg_ptr.arg_arg,&tmpary);
 837     for (elem = tmpary+1; *elem; elem++) {
 838         str = str_new(0);
 839         str_sset(str,*elem);
 840         apush(ary,str);
 841     }
 842     safefree((char*)tmpary);
 843     return str;
 844 }
 845
 846 do_unshift(arg,ary)
 847 register ARG *arg;
 848 register ARRAY *ary;
 849 {
 850     STR **tmpary;       /* must not be register */
 851     register STR **elem;
 852     register STR *str = &str_no;
 853     register int i;
 854
 855     (void)eval(arg[1].arg_ptr.arg_arg,&tmpary);
 856     i = 0;
 857     for (elem = tmpary+1; *elem; elem++)
 858         i++;
 859     aunshift(ary,i);
 860     i = 0;
 861     for (elem = tmpary+1; *elem; elem++) {
 862         str = str_new(0);
 863         str_sset(str,*elem);
 864         astore(ary,i++,str);
 865     }
 866     safefree((char*)tmpary);
 867 }
 868
 869 apply(type,arg,sarg)
 870 int type;
 871 register ARG *arg;
 872 STR **sarg;
 873 {
 874     STR **tmpary;       /* must not be register */
 875     register STR **elem;
 876     register int i;
 877     register int val;
 878     register int val2;
 879
 880     if (sarg)
 881         tmpary = sarg;
 882     else
 883         (void)eval(arg[1].arg_ptr.arg_arg,&tmpary);
 884     i = 0;
 885     for (elem = tmpary+1; *elem; elem++)
 886         i++;
 887     switch (type) {
 888     case O_CHMOD:
 889         if (--i > 0) {
 890             val = (int)str_gnum(tmpary[1]);
 891             for (elem = tmpary+2; *elem; elem++)
 892                 if (chmod(str_get(*elem),val))
 893                     i--;
 894         }
 895         break;
 896     case O_CHOWN:
 897         if (i > 2) {
 898             i -= 2;
 899             val = (int)str_gnum(tmpary[1]);
 900             val2 = (int)str_gnum(tmpary[2]);
 901             for (elem = tmpary+3; *elem; elem++)
 902                 if (chown(str_get(*elem),val,val2))
 903                     i--;
 904         }
 905         else
 906             i = 0;
 907         break;
 908     case O_KILL:
 909         if (--i > 0) {
 910             val = (int)str_gnum(tmpary[1]);
 911             if (val < 0)
 912                 val = -val;
 913             for (elem = tmpary+2; *elem; elem++)
 914                 if (kill(atoi(str_get(*elem)),val))
 915                     i--;
 916         }
 917         break;
 918     case O_UNLINK:
 919         for (elem = tmpary+1; *elem; elem++)
 920             if (UNLINK(str_get(*elem)))
 921                 i--;
 922         break;
 923     }
 924     if (!sarg)
 925         safefree((char*)tmpary);
 926     return i;
 927 }
 928
 929 STR *
 930 do_subr(arg,sarg)
 931 register ARG *arg;
 932 register char **sarg;
 933 {
 934     ARRAY *savearray;
 935     STR *str;
 936
 937     savearray = defstab->stab_array;
 938     defstab->stab_array = anew();
 939     if (arg[1].arg_flags & AF_SPECIAL)
 940         (void)do_push(arg,defstab->stab_array);
 941     else if (arg[1].arg_type != A_NULL) {
 942         str = str_new(0);
 943         str_sset(str,sarg[1]);
 944         apush(defstab->stab_array,str);
 945     }
 946     str = cmd_exec(arg[2].arg_ptr.arg_stab->stab_sub);
 947     afree(defstab->stab_array);  /* put back old $_[] */
 948     defstab->stab_array = savearray;
 949     return str;
 950 }
 951
 952 void
 953 do_assign(retstr,arg)
 954 STR *retstr;
 955 register ARG *arg;
 956 {
 957     STR **tmpary;       /* must not be register */
 958     register ARG *larg = arg[1].arg_ptr.arg_arg;
 959     register STR **elem;
 960     register STR *str;
 961     register ARRAY *ary;
 962     register int i;
 963     register int lasti;
 964     char *s;
 965
 966     (void)eval(arg[2].arg_ptr.arg_arg,&tmpary);
 967
 968     if (arg->arg_flags & AF_COMMON) {
 969         if (*(tmpary+1)) {
 970             for (elem=tmpary+2; *elem; elem++) {
 971                 *elem = str_static(*elem);
 972             }
 973         }
 974     }
 975     if (larg->arg_type == O_LIST) {
 976         lasti = larg->arg_len;
 977         for (i=1,elem=tmpary+1; i <= lasti; i++) {
 978             if (*elem)
 979                 s = str_get(*(elem++));
 980             else
 981                 s = "";
 982             switch (larg[i].arg_type) {
 983             case A_STAB:
 984             case A_LVAL:
 985                 str = STAB_STR(larg[i].arg_ptr.arg_stab);
 986                 break;
 987             case A_LEXPR:
 988                 str = eval(larg[i].arg_ptr.arg_arg,Null(STR***));
 989                 break;
 990             }
 991             str_set(str,s);
 992             STABSET(str);
 993         }
 994         i = elem - tmpary - 1;
 995     }
 996     else {                      /* should be an array name */
 997         ary = larg[1].arg_ptr.arg_stab->stab_array;
 998         for (i=0,elem=tmpary+1; *elem; i++) {
 999             str = str_new(0);
1000             if (*elem)
1001                 str_sset(str,*(elem++));
1002             astore(ary,i,str);
1003         }
1004         ary->ary_fill = i - 1;  /* they can get the extra ones back by */
1005     }                           /*   setting an element larger than old fill */
1006     str_numset(retstr,(double)i);
1007     STABSET(retstr);
1008     safefree((char*)tmpary);
1009 }
1010
1011 int
1012 do_kv(hash,kv,sarg,retary)
1013 HASH *hash;
1014 int kv;
1015 register STR **sarg;
1016 STR ***retary;
1017 {
1018     register ARRAY *ary;
1019     int max = 0;
1020     int i;
1021     static ARRAY *myarray = Null(ARRAY*);
1022     register HENT *entry;
1023
1024     ary = myarray;
1025     if (!ary)
1026         myarray = ary = anew();
1027     ary->ary_fill = -1;
1028
1029     hiterinit(hash);
1030     while (entry = hiternext(hash)) {
1031         max++;
1032         if (kv == O_KEYS)
1033             apush(ary,str_make(hiterkey(entry)));
1034         else
1035             apush(ary,str_make(str_get(hiterval(entry))));
1036     }
1037     if (retary) { /* array wanted */
1038         sarg = (STR**)saferealloc((char*)sarg,(max+2)*sizeof(STR*));
1039         sarg[0] = Nullstr;
1040         sarg[max+1] = Nullstr;
1041         for (i = 1; i <= max; i++)
1042             sarg[i] = afetch(ary,i-1);
1043         *retary = sarg;
1044     }
1045     return max;
1046 }
1047
1048 STR *
1049 do_each(hash,sarg,retary)
1050 HASH *hash;
1051 register STR **sarg;
1052 STR ***retary;
1053 {
1054     static STR *mystr = Nullstr;
1055     STR *retstr;
1056     HENT *entry = hiternext(hash);
1057
1058     if (mystr) {
1059         str_free(mystr);
1060         mystr = Nullstr;
1061     }
1062
1063     if (retary) { /* array wanted */
1064         if (entry) {
1065             sarg = (STR**)saferealloc((char*)sarg,4*sizeof(STR*));
1066             sarg[0] = Nullstr;
1067             sarg[3] = Nullstr;
1068             sarg[1] = mystr = str_make(hiterkey(entry));
1069             retstr = sarg[2] = hiterval(entry);
1070             *retary = sarg;
1071         }
1072         else {
1073             sarg = (STR**)saferealloc((char*)sarg,2*sizeof(STR*));
1074             sarg[0] = Nullstr;
1075             sarg[1] = retstr = Nullstr;
1076             *retary = sarg;
1077         }
1078     }
1079     else
1080         retstr = hiterval(entry);
1081
1082     return retstr;
1083 }
1084
1085 init_eval()
1086 {
1087     register int i;
1088
1089 #define A(e1,e2,e3) (e1+(e2<<1)+(e3<<2))
1090     opargs[O_ITEM] =            A(1,0,0);
1091     opargs[O_ITEM2] =           A(0,0,0);
1092     opargs[O_ITEM3] =           A(0,0,0);
1093     opargs[O_CONCAT] =          A(1,1,0);
1094     opargs[O_MATCH] =           A(1,0,0);
1095     opargs[O_NMATCH] =          A(1,0,0);
1096     opargs[O_SUBST] =           A(1,0,0);
1097     opargs[O_NSUBST] =          A(1,0,0);
1098     opargs[O_ASSIGN] =          A(1,1,0);
1099     opargs[O_MULTIPLY] =        A(1,1,0);
1100     opargs[O_DIVIDE] =          A(1,1,0);
1101     opargs[O_MODULO] =          A(1,1,0);
1102     opargs[O_ADD] =             A(1,1,0);
1103     opargs[O_SUBTRACT] =        A(1,1,0);
1104     opargs[O_LEFT_SHIFT] =      A(1,1,0);
1105     opargs[O_RIGHT_SHIFT] =     A(1,1,0);
1106     opargs[O_LT] =              A(1,1,0);
1107     opargs[O_GT] =              A(1,1,0);
1108     opargs[O_LE] =              A(1,1,0);
1109     opargs[O_GE] =              A(1,1,0);
1110     opargs[O_EQ] =              A(1,1,0);
1111     opargs[O_NE] =              A(1,1,0);
1112     opargs[O_BIT_AND] =         A(1,1,0);
1113     opargs[O_XOR] =             A(1,1,0);
1114     opargs[O_BIT_OR] =          A(1,1,0);
1115     opargs[O_AND] =             A(1,0,0);       /* don't eval arg 2 (yet) */
1116     opargs[O_OR] =              A(1,0,0);       /* don't eval arg 2 (yet) */
1117     opargs[O_COND_EXPR] =       A(1,0,0);       /* don't eval args 2 or 3 */
1118     opargs[O_COMMA] =           A(1,1,0);
1119     opargs[O_NEGATE] =          A(1,0,0);
1120     opargs[O_NOT] =             A(1,0,0);
1121     opargs[O_COMPLEMENT] =      A(1,0,0);
1122     opargs[O_WRITE] =           A(1,0,0);
1123     opargs[O_OPEN] =            A(1,1,0);
1124     opargs[O_TRANS] =           A(1,0,0);
1125     opargs[O_NTRANS] =          A(1,0,0);
1126     opargs[O_CLOSE] =           A(0,0,0);
1127     opargs[O_ARRAY] =           A(1,0,0);
1128     opargs[O_HASH] =            A(1,0,0);
1129     opargs[O_LARRAY] =          A(1,0,0);
1130     opargs[O_LHASH] =           A(1,0,0);
1131     opargs[O_PUSH] =            A(1,0,0);
1132     opargs[O_POP] =             A(0,0,0);
1133     opargs[O_SHIFT] =           A(0,0,0);
1134     opargs[O_SPLIT] =           A(1,0,0);
1135     opargs[O_LENGTH] =          A(1,0,0);
1136     opargs[O_SPRINTF] =         A(1,0,0);
1137     opargs[O_SUBSTR] =          A(1,1,1);
1138     opargs[O_JOIN] =            A(1,0,0);
1139     opargs[O_SLT] =             A(1,1,0);
1140     opargs[O_SGT] =             A(1,1,0);
1141     opargs[O_SLE] =             A(1,1,0);
1142     opargs[O_SGE] =             A(1,1,0);
1143     opargs[O_SEQ] =             A(1,1,0);
1144     opargs[O_SNE] =             A(1,1,0);
1145     opargs[O_SUBR] =            A(1,0,0);
1146     opargs[O_PRINT] =           A(1,0,0);
1147     opargs[O_CHDIR] =           A(1,0,0);
1148     opargs[O_DIE] =             A(1,0,0);
1149     opargs[O_EXIT] =            A(1,0,0);
1150     opargs[O_RESET] =           A(1,0,0);
1151     opargs[O_LIST] =            A(0,0,0);
1152     opargs[O_EOF] =             A(0,0,0);
1153     opargs[O_TELL] =            A(0,0,0);
1154     opargs[O_SEEK] =            A(0,1,1);
1155     opargs[O_LAST] =            A(1,0,0);
1156     opargs[O_NEXT] =            A(1,0,0);
1157     opargs[O_REDO] =            A(1,0,0);
1158     opargs[O_GOTO] =            A(1,0,0);
1159     opargs[O_INDEX] =           A(1,1,0);
1160     opargs[O_TIME] =            A(0,0,0);
1161     opargs[O_TMS] =             A(0,0,0);
1162     opargs[O_LOCALTIME] =       A(1,0,0);
1163     opargs[O_GMTIME] =          A(1,0,0);
1164     opargs[O_STAT] =            A(1,0,0);
1165     opargs[O_CRYPT] =           A(1,1,0);
1166     opargs[O_EXP] =             A(1,0,0);
1167     opargs[O_LOG] =             A(1,0,0);
1168     opargs[O_SQRT] =            A(1,0,0);
1169     opargs[O_INT] =             A(1,0,0);
1170     opargs[O_PRTF] =            A(1,0,0);
1171     opargs[O_ORD] =             A(1,0,0);
1172     opargs[O_SLEEP] =           A(1,0,0);
1173     opargs[O_FLIP] =            A(1,0,0);
1174     opargs[O_FLOP] =            A(0,1,0);
1175     opargs[O_KEYS] =            A(0,0,0);
1176     opargs[O_VALUES] =          A(0,0,0);
1177     opargs[O_EACH] =            A(0,0,0);
1178     opargs[O_CHOP] =            A(1,0,0);
1179     opargs[O_FORK] =            A(1,0,0);
1180     opargs[O_EXEC] =            A(1,0,0);
1181     opargs[O_SYSTEM] =          A(1,0,0);
1182     opargs[O_OCT] =             A(1,0,0);
1183     opargs[O_HEX] =             A(1,0,0);
1184     opargs[O_CHMOD] =           A(1,0,0);
1185     opargs[O_CHOWN] =           A(1,0,0);
1186     opargs[O_KILL] =            A(1,0,0);
1187     opargs[O_RENAME] =          A(1,1,0);
1188     opargs[O_UNLINK] =          A(1,0,0);
1189     opargs[O_UMASK] =           A(1,0,0);
1190     opargs[O_UNSHIFT] =         A(1,0,0);
1191     opargs[O_LINK] =            A(1,1,0);
1192     opargs[O_REPEAT] =          A(1,1,0);
1193 }
1194
1195 #ifdef VOIDSIG
1196 static void (*ihand)();
1197 static void (*qhand)();
1198 #else
1199 static int (*ihand)();
1200 static int (*qhand)();
1201 #endif
1202
1203 STR *
1204 eval(arg,retary)
1205 register ARG *arg;
1206 STR ***retary;          /* where to return an array to, null if nowhere */
1207 {
1208     register STR *str;
1209     register int anum;
1210     register int optype;
1211     register int maxarg;
1212     double value;
1213     STR *quicksarg[5];
1214     register STR **sarg = quicksarg;
1215     register char *tmps;
1216     char *tmps2;
1217     int argflags;
1218     long tmplong;
1219     FILE *fp;
1220     STR *tmpstr;
1221     FCMD *form;
1222     STAB *stab;
1223     ARRAY *ary;
1224     bool assigning = FALSE;
1225     double exp(), log(), sqrt(), modf();
1226     char *crypt(), *getenv();
1227
1228     if (!arg)
1229         return &str_no;
1230     str = arg->arg_ptr.arg_str;
1231     optype = arg->arg_type;
1232     maxarg = arg->arg_len;
1233     if (maxarg > 3 || retary) {
1234         sarg = (STR **)safemalloc((maxarg+2) * sizeof(STR*));
1235     }
1236 #ifdef DEBUGGING
1237     if (debug & 8) {
1238         deb("%s (%lx) %d args:\n",opname[optype],arg,maxarg);
1239     }
1240     debname[dlevel] = opname[optype][0];
1241     debdelim[dlevel++] = ':';
1242 #endif
1243     for (anum = 1; anum <= maxarg; anum++) {
1244         argflags = arg[anum].arg_flags;
1245         if (argflags & AF_SPECIAL)
1246             continue;
1247       re_eval:
1248         switch (arg[anum].arg_type) {
1249         default:
1250             sarg[anum] = &str_no;
1251 #ifdef DEBUGGING
1252             tmps = "NULL";
1253 #endif
1254             break;
1255         case A_EXPR:
1256 #ifdef DEBUGGING
1257             if (debug & 8) {
1258                 tmps = "EXPR";
1259                 deb("%d.EXPR =>\n",anum);
1260             }
1261 #endif
1262             sarg[anum] = eval(arg[anum].arg_ptr.arg_arg, Null(STR***));
1263             break;
1264         case A_CMD:
1265 #ifdef DEBUGGING
1266             if (debug & 8) {
1267                 tmps = "CMD";
1268                 deb("%d.CMD (%lx) =>\n",anum,arg[anum].arg_ptr.arg_cmd);
1269             }
1270 #endif
1271             sarg[anum] = cmd_exec(arg[anum].arg_ptr.arg_cmd);
1272             break;
1273         case A_STAB:
1274             sarg[anum] = STAB_STR(arg[anum].arg_ptr.arg_stab);
1275 #ifdef DEBUGGING
1276             if (debug & 8) {
1277                 sprintf(buf,"STAB $%s ==",arg[anum].arg_ptr.arg_stab->stab_name);
1278                 tmps = buf;
1279             }
1280 #endif
1281             break;
1282         case A_LEXPR:
1283 #ifdef DEBUGGING
1284             if (debug & 8) {
1285                 tmps = "LEXPR";
1286                 deb("%d.LEXPR =>\n",anum);
1287             }
1288 #endif
1289             str = eval(arg[anum].arg_ptr.arg_arg,Null(STR***));
1290             if (!str)
1291                 fatal("panic: A_LEXPR\n");
1292             goto do_crement;
1293         case A_LVAL:
1294 #ifdef DEBUGGING
1295             if (debug & 8) {
1296                 sprintf(buf,"LVAL $%s ==",arg[anum].arg_ptr.arg_stab->stab_name);
1297                 tmps = buf;
1298             }
1299 #endif
1300             str = STAB_STR(arg[anum].arg_ptr.arg_stab);
1301             if (!str)
1302                 fatal("panic: A_LVAL\n");
1303           do_crement:
1304             assigning = TRUE;
1305             if (argflags & AF_PRE) {
1306                 if (argflags & AF_UP)
1307                     str_inc(str);
1308                 else
1309                     str_dec(str);
1310                 STABSET(str);
1311                 sarg[anum] = str;
1312                 str = arg->arg_ptr.arg_str;
1313             }
1314             else if (argflags & AF_POST) {
1315                 sarg[anum] = str_static(str);
1316                 if (argflags & AF_UP)
1317                     str_inc(str);
1318                 else
1319                     str_dec(str);
1320                 STABSET(str);
1321                 str = arg->arg_ptr.arg_str;
1322             }
1323             else {
1324                 sarg[anum] = str;
1325             }
1326             break;
1327         case A_ARYLEN:
1328             sarg[anum] = str_static(&str_no);
1329             str_numset(sarg[anum],
1330                 (double)alen(arg[anum].arg_ptr.arg_stab->stab_array));
1331 #ifdef DEBUGGING
1332             tmps = "ARYLEN";
1333 #endif
1334             break;
1335         case A_SINGLE:
1336             sarg[anum] = arg[anum].arg_ptr.arg_str;
1337 #ifdef DEBUGGING
1338             tmps = "SINGLE";
1339 #endif
1340             break;
1341         case A_DOUBLE:
1342             (void) interp(str,str_get(arg[anum].arg_ptr.arg_str));
1343             sarg[anum] = str;
1344 #ifdef DEBUGGING
1345             tmps = "DOUBLE";
1346 #endif
1347             break;
1348         case A_BACKTICK:
1349             tmps = str_get(arg[anum].arg_ptr.arg_str);
1350             fp = popen(str_get(interp(str,tmps)),"r");
1351             tmpstr = str_new(80);
1352             str_set(str,"");
1353             if (fp) {
1354                 while (str_gets(tmpstr,fp) != Nullch) {
1355                     str_scat(str,tmpstr);
1356                 }
1357                 statusvalue = pclose(fp);
1358             }
1359             else
1360                 statusvalue = -1;
1361             str_free(tmpstr);
1362
1363             sarg[anum] = str;
1364 #ifdef DEBUGGING
1365             tmps = "BACK";
1366 #endif
1367             break;
1368         case A_READ:
1369             fp = Nullfp;
1370             last_in_stab = arg[anum].arg_ptr.arg_stab;
1371             if (last_in_stab->stab_io) {
1372                 fp = last_in_stab->stab_io->fp;
1373                 if (!fp && (last_in_stab->stab_io->flags & IOF_ARGV)) {
1374                     if (last_in_stab->stab_io->flags & IOF_START) {
1375                         last_in_stab->stab_io->flags &= ~IOF_START;
1376                         last_in_stab->stab_io->lines = 0;
1377                         if (alen(last_in_stab->stab_array) < 0L) {
1378                             tmpstr = str_make("-");     /* assume stdin */
1379                             apush(last_in_stab->stab_array, tmpstr);
1380                         }
1381                     }
1382                     fp = nextargv(last_in_stab);
1383                     if (!fp)    /* Note: fp != last_in_stab->stab_io->fp */
1384                         do_close(last_in_stab,FALSE);   /* now it does */
1385                 }
1386             }
1387           keepgoing:
1388             if (!fp)
1389                 sarg[anum] = &str_no;
1390             else if (!str_gets(str,fp)) {
1391                 if (last_in_stab->stab_io->flags & IOF_ARGV) {
1392                     fp = nextargv(last_in_stab);
1393                     if (fp)
1394                         goto keepgoing;
1395                     do_close(last_in_stab,FALSE);
1396                     last_in_stab->stab_io->flags |= IOF_START;
1397                 }
1398                 if (fp == stdin) {
1399                     clearerr(fp);
1400                 }
1401                 sarg[anum] = &str_no;
1402                 break;
1403             }
1404             else {
1405                 last_in_stab->stab_io->lines++;
1406                 sarg[anum] = str;
1407             }
1408 #ifdef DEBUGGING
1409             tmps = "READ";
1410 #endif
1411             break;
1412         }
1413 #ifdef DEBUGGING
1414         if (debug & 8)
1415             deb("%d.%s = '%s'\n",anum,tmps,str_peek(sarg[anum]));
1416 #endif
1417     }
1418     switch (optype) {
1419     case O_ITEM:
1420         if (str != sarg[1])
1421             str_sset(str,sarg[1]);
1422         STABSET(str);
1423         break;
1424     case O_ITEM2:
1425         if (str != sarg[2])
1426             str_sset(str,sarg[2]);
1427         STABSET(str);
1428         break;
1429     case O_ITEM3:
1430         if (str != sarg[3])
1431             str_sset(str,sarg[3]);
1432         STABSET(str);
1433         break;
1434     case O_CONCAT:
1435         if (str != sarg[1])
1436             str_sset(str,sarg[1]);
1437         str_scat(str,sarg[2]);
1438         STABSET(str);
1439         break;
1440     case O_REPEAT:
1441         if (str != sarg[1])
1442             str_sset(str,sarg[1]);
1443         anum = (long)str_gnum(sarg[2]);
1444         if (anum >= 1) {
1445             tmpstr = str_new(0);
1446             str_sset(tmpstr,str);
1447             for (anum--; anum; anum--)
1448                 str_scat(str,tmpstr);
1449         }
1450         else
1451             str_sset(str,&str_no);
1452         STABSET(str);
1453         break;
1454     case O_MATCH:
1455         str_set(str, do_match(str_get(sarg[1]),arg) ? Yes : No);
1456         STABSET(str);
1457         break;
1458     case O_NMATCH:
1459         str_set(str, do_match(str_get(sarg[1]),arg) ? No : Yes);
1460         STABSET(str);
1461         break;
1462     case O_SUBST:
1463         value = (double) do_subst(str, arg);
1464         str = arg->arg_ptr.arg_str;
1465         goto donumset;
1466     case O_NSUBST:
1467         str_set(arg->arg_ptr.arg_str, do_subst(str, arg) ? No : Yes);
1468         str = arg->arg_ptr.arg_str;
1469         break;
1470     case O_ASSIGN:
1471         if (arg[2].arg_flags & AF_SPECIAL)
1472             do_assign(str,arg);
1473         else {
1474             if (str != sarg[2])
1475                 str_sset(str, sarg[2]);
1476             STABSET(str);
1477         }
1478         break;
1479     case O_CHOP:
1480         tmps = str_get(str);
1481         tmps += str->str_cur - (str->str_cur != 0);
1482         str_set(arg->arg_ptr.arg_str,tmps);     /* remember last char */
1483         *tmps = '\0';                           /* wipe it out */
1484         str->str_cur = tmps - str->str_ptr;
1485         str->str_nok = 0;
1486         str = arg->arg_ptr.arg_str;
1487         break;
1488     case O_MULTIPLY:
1489         value = str_gnum(sarg[1]);
1490         value *= str_gnum(sarg[2]);
1491         goto donumset;
1492     case O_DIVIDE:
1493         value = str_gnum(sarg[1]);
1494         value /= str_gnum(sarg[2]);
1495         goto donumset;
1496     case O_MODULO:
1497         value = str_gnum(sarg[1]);
1498         value = (double)(((long)value) % (long)str_gnum(sarg[2]));
1499         goto donumset;
1500     case O_ADD:
1501         value = str_gnum(sarg[1]);
1502         value += str_gnum(sarg[2]);
1503         goto donumset;
1504     case O_SUBTRACT:
1505         value = str_gnum(sarg[1]);
1506         value -= str_gnum(sarg[2]);
1507         goto donumset;
1508     case O_LEFT_SHIFT:
1509         value = str_gnum(sarg[1]);
1510         value = (double)(((long)value) << (long)str_gnum(sarg[2]));
1511         goto donumset;
1512     case O_RIGHT_SHIFT:
1513         value = str_gnum(sarg[1]);
1514         value = (double)(((long)value) >> (long)str_gnum(sarg[2]));
1515         goto donumset;
1516     case O_LT:
1517         value = str_gnum(sarg[1]);
1518         value = (double)(value < str_gnum(sarg[2]));
1519         goto donumset;
1520     case O_GT:
1521         value = str_gnum(sarg[1]);
1522         value = (double)(value > str_gnum(sarg[2]));
1523         goto donumset;
1524     case O_LE:
1525         value = str_gnum(sarg[1]);
1526         value = (double)(value <= str_gnum(sarg[2]));
1527         goto donumset;
1528     case O_GE:
1529         value = str_gnum(sarg[1]);
1530         value = (double)(value >= str_gnum(sarg[2]));
1531         goto donumset;
1532     case O_EQ:
1533         value = str_gnum(sarg[1]);
1534         value = (double)(value == str_gnum(sarg[2]));
1535         goto donumset;
1536     case O_NE:
1537         value = str_gnum(sarg[1]);
1538         value = (double)(value != str_gnum(sarg[2]));
1539         goto donumset;
1540     case O_BIT_AND:
1541         value = str_gnum(sarg[1]);
1542         value = (double)(((long)value) & (long)str_gnum(sarg[2]));
1543         goto donumset;
1544     case O_XOR:
1545         value = str_gnum(sarg[1]);
1546         value = (double)(((long)value) ^ (long)str_gnum(sarg[2]));
1547         goto donumset;
1548     case O_BIT_OR:
1549         value = str_gnum(sarg[1]);
1550         value = (double)(((long)value) | (long)str_gnum(sarg[2]));
1551         goto donumset;
1552     case O_AND:
1553         if (str_true(sarg[1])) {
1554             anum = 2;
1555             optype = O_ITEM2;
1556             maxarg = 0;
1557             argflags = arg[anum].arg_flags;
1558             goto re_eval;
1559         }
1560         else {
1561             if (assigning) {
1562                 str_sset(str, sarg[1]);
1563                 STABSET(str);
1564             }
1565             else
1566                 str = sarg[1];
1567             break;
1568         }
1569     case O_OR:
1570         if (str_true(sarg[1])) {
1571             if (assigning) {
1572                 str_set(str, sarg[1]);
1573                 STABSET(str);
1574             }
1575             else
1576                 str = sarg[1];
1577             break;
1578         }
1579         else {
1580             anum = 2;
1581             optype = O_ITEM2;
1582             maxarg = 0;
1583             argflags = arg[anum].arg_flags;
1584             goto re_eval;
1585         }
1586     case O_COND_EXPR:
1587         anum = (str_true(sarg[1]) ? 2 : 3);
1588         optype = (anum == 2 ? O_ITEM2 : O_ITEM3);
1589         maxarg = 0;
1590         argflags = arg[anum].arg_flags;
1591         goto re_eval;
1592     case O_COMMA:
1593         str = sarg[2];
1594         break;
1595     case O_NEGATE:
1596         value = -str_gnum(sarg[1]);
1597         goto donumset;
1598     case O_NOT:
1599         value = (double) !str_true(sarg[1]);
1600         goto donumset;
1601     case O_COMPLEMENT:
1602         value = (double) ~(long)str_gnum(sarg[1]);
1603         goto donumset;
1604     case O_SELECT:
1605         if (arg[1].arg_type == A_LVAL)
1606             defoutstab = arg[1].arg_ptr.arg_stab;
1607         else
1608             defoutstab = stabent(str_get(sarg[1]),TRUE);
1609         if (!defoutstab->stab_io)
1610             defoutstab->stab_io = stio_new();
1611         curoutstab = defoutstab;
1612         str_set(str,curoutstab->stab_io->fp ? Yes : No);
1613         STABSET(str);
1614         break;
1615     case O_WRITE:
1616         if (maxarg == 0)
1617             stab = defoutstab;
1618         else if (arg[1].arg_type == A_LVAL)
1619             stab = arg[1].arg_ptr.arg_stab;
1620         else
1621             stab = stabent(str_get(sarg[1]),TRUE);
1622         if (!stab->stab_io) {
1623             str_set(str, No);
1624             STABSET(str);
1625             break;
1626         }
1627         curoutstab = stab;
1628         fp = stab->stab_io->fp;
1629         debarg = arg;
1630         if (stab->stab_io->fmt_stab)
1631             form = stab->stab_io->fmt_stab->stab_form;
1632         else
1633             form = stab->stab_form;
1634         if (!form || !fp) {
1635             str_set(str, No);
1636             STABSET(str);
1637             break;
1638         }
1639         format(&outrec,form);
1640         do_write(&outrec,stab->stab_io);
1641         if (stab->stab_io->flags & IOF_FLUSH)
1642             fflush(fp);
1643         str_set(str, Yes);
1644         STABSET(str);
1645         break;
1646     case O_OPEN:
1647         if (do_open(arg[1].arg_ptr.arg_stab,str_get(sarg[2]))) {
1648             str_set(str, Yes);
1649             arg[1].arg_ptr.arg_stab->stab_io->lines = 0;
1650         }
1651         else
1652             str_set(str, No);
1653         STABSET(str);
1654         break;
1655     case O_TRANS:
1656         value = (double) do_trans(str,arg);
1657         str = arg->arg_ptr.arg_str;
1658         goto donumset;
1659     case O_NTRANS:
1660         str_set(arg->arg_ptr.arg_str, do_trans(str,arg) == 0 ? Yes : No);
1661         str = arg->arg_ptr.arg_str;
1662         break;
1663     case O_CLOSE:
1664         str_set(str,
1665             do_close(arg[1].arg_ptr.arg_stab,TRUE) ? Yes : No );
1666         STABSET(str);
1667         break;
1668     case O_EACH:
1669         str_sset(str,do_each(arg[1].arg_ptr.arg_stab->stab_hash,sarg,retary));
1670         retary = Null(STR***);          /* do_each already did retary */
1671         STABSET(str);
1672         break;
1673     case O_VALUES:
1674     case O_KEYS:
1675         value = (double) do_kv(arg[1].arg_ptr.arg_stab->stab_hash,
1676           optype,sarg,retary);
1677         retary = Null(STR***);          /* do_keys already did retary */
1678         goto donumset;
1679     case O_ARRAY:
1680         if (maxarg == 1) {
1681             ary = arg[1].arg_ptr.arg_stab->stab_array;
1682             maxarg = ary->ary_fill;
1683             if (retary) { /* array wanted */
1684                 sarg =
1685                   (STR **)saferealloc((char*)sarg,(maxarg+3)*sizeof(STR*));
1686                 for (anum = 0; anum <= maxarg; anum++) {
1687                     sarg[anum+1] = str = afetch(ary,anum);
1688                 }
1689                 maxarg++;
1690             }
1691             else
1692                 str = afetch(ary,maxarg);
1693         }
1694         else
1695             str = afetch(arg[2].arg_ptr.arg_stab->stab_array,
1696                 ((int)str_gnum(sarg[1])) - arybase);
1697         if (!str)
1698             return &str_no;
1699         break;
1700     case O_HASH:
1701         tmpstab = arg[2].arg_ptr.arg_stab;              /* XXX */
1702         str = hfetch(tmpstab->stab_hash,str_get(sarg[1]));
1703         if (!str)
1704             return &str_no;
1705         break;
1706     case O_LARRAY:
1707         anum = ((int)str_gnum(sarg[1])) - arybase;
1708         str = afetch(arg[2].arg_ptr.arg_stab->stab_array,anum);
1709         if (!str || str == &str_no) {
1710             str = str_new(0);
1711             astore(arg[2].arg_ptr.arg_stab->stab_array,anum,str);
1712         }
1713         break;
1714     case O_LHASH:
1715         tmpstab = arg[2].arg_ptr.arg_stab;
1716         str = hfetch(tmpstab->stab_hash,str_get(sarg[1]));
1717         if (!str) {
1718             str = str_new(0);
1719             hstore(tmpstab->stab_hash,str_get(sarg[1]),str);
1720         }
1721         if (tmpstab == envstab) {       /* heavy wizardry going on here */
1722             str->str_link.str_magic = tmpstab;/* str is now magic */
1723             envname = savestr(str_get(sarg[1]));
1724                                         /* he threw the brick up into the air */
1725         }
1726         else if (tmpstab == sigstab) {  /* same thing, only different */
1727             str->str_link.str_magic = tmpstab;
1728             signame = savestr(str_get(sarg[1]));
1729         }
1730         break;
1731     case O_PUSH:
1732         if (arg[1].arg_flags & AF_SPECIAL)
1733             str = do_push(arg,arg[2].arg_ptr.arg_stab->stab_array);
1734         else {
1735             str = str_new(0);           /* must copy the STR */
1736             str_sset(str,sarg[1]);
1737             apush(arg[2].arg_ptr.arg_stab->stab_array,str);
1738         }
1739         break;
1740     case O_POP:
1741         str = apop(arg[1].arg_ptr.arg_stab->stab_array);
1742         if (!str)
1743             return &str_no;
1744 #ifdef STRUCTCOPY
1745         *(arg->arg_ptr.arg_str) = *str;
1746 #else
1747         bcopy((char*)str, (char*)arg->arg_ptr.arg_str, sizeof *str);
1748 #endif
1749         safefree((char*)str);
1750         str = arg->arg_ptr.arg_str;
1751         break;
1752     case O_SHIFT:
1753         str = ashift(arg[1].arg_ptr.arg_stab->stab_array);
1754         if (!str)
1755             return &str_no;
1756 #ifdef STRUCTCOPY
1757         *(arg->arg_ptr.arg_str) = *str;
1758 #else
1759         bcopy((char*)str, (char*)arg->arg_ptr.arg_str, sizeof *str);
1760 #endif
1761         safefree((char*)str);
1762         str = arg->arg_ptr.arg_str;
1763         break;
1764     case O_SPLIT:
1765         value = (double) do_split(str_get(sarg[1]),arg[2].arg_ptr.arg_spat,retary);
1766         retary = Null(STR***);          /* do_split already did retary */
1767         goto donumset;
1768     case O_LENGTH:
1769         value = (double) str_len(sarg[1]);
1770         goto donumset;
1771     case O_SPRINTF:
1772         sarg[maxarg+1] = Nullstr;
1773         do_sprintf(str,arg->arg_len,sarg);
1774         break;
1775     case O_SUBSTR:
1776         anum = ((int)str_gnum(sarg[2])) - arybase;
1777         for (tmps = str_get(sarg[1]); *tmps && anum > 0; tmps++,anum--) ;
1778         anum = (int)str_gnum(sarg[3]);
1779         if (anum >= 0 && strlen(tmps) > anum)
1780             str_nset(str, tmps, anum);
1781         else
1782             str_set(str, tmps);
1783         break;
1784     case O_JOIN:
1785         if (arg[2].arg_flags & AF_SPECIAL && arg[2].arg_type == A_EXPR)
1786             do_join(arg,str_get(sarg[1]),str);
1787         else
1788             ajoin(arg[2].arg_ptr.arg_stab->stab_array,str_get(sarg[1]),str);
1789         break;
1790     case O_SLT:
1791         tmps = str_get(sarg[1]);
1792         value = (double) strLT(tmps,str_get(sarg[2]));
1793         goto donumset;
1794     case O_SGT:
1795         tmps = str_get(sarg[1]);
1796         value = (double) strGT(tmps,str_get(sarg[2]));
1797         goto donumset;
1798     case O_SLE:
1799         tmps = str_get(sarg[1]);
1800         value = (double) strLE(tmps,str_get(sarg[2]));
1801         goto donumset;
1802     case O_SGE:
1803         tmps = str_get(sarg[1]);
1804         value = (double) strGE(tmps,str_get(sarg[2]));
1805         goto donumset;
1806     case O_SEQ:
1807         tmps = str_get(sarg[1]);
1808         value = (double) strEQ(tmps,str_get(sarg[2]));
1809         goto donumset;
1810     case O_SNE:
1811         tmps = str_get(sarg[1]);
1812         value = (double) strNE(tmps,str_get(sarg[2]));
1813         goto donumset;
1814     case O_SUBR:
1815         str_sset(str,do_subr(arg,sarg));
1816         STABSET(str);
1817         break;
1818     case O_PRTF:
1819     case O_PRINT:
1820         if (maxarg <= 1)
1821             stab = defoutstab;
1822         else {
1823             stab = arg[2].arg_ptr.arg_stab;
1824             if (!stab)
1825                 stab = defoutstab;
1826         }
1827         if (!stab->stab_io)
1828             value = 0.0;
1829         else if (arg[1].arg_flags & AF_SPECIAL)
1830             value = (double)do_aprint(arg,stab->stab_io->fp);
1831         else {
1832             value = (double)do_print(str_get(sarg[1]),stab->stab_io->fp);
1833             if (ors && optype == O_PRINT)
1834                 do_print(ors, stab->stab_io->fp);
1835         }
1836         if (stab->stab_io->flags & IOF_FLUSH)
1837             fflush(stab->stab_io->fp);
1838         goto donumset;
1839     case O_CHDIR:
1840         tmps = str_get(sarg[1]);
1841         if (!tmps || !*tmps)
1842             tmps = getenv("HOME");
1843         if (!tmps || !*tmps)
1844             tmps = getenv("LOGDIR");
1845         value = (double)(chdir(tmps) >= 0);
1846         goto donumset;
1847     case O_DIE:
1848         tmps = str_get(sarg[1]);
1849         if (!tmps || !*tmps)
1850             exit(1);
1851         fatal("%s\n",str_get(sarg[1]));
1852         value = 0.0;
1853         goto donumset;
1854     case O_EXIT:
1855         exit((int)str_gnum(sarg[1]));
1856         value = 0.0;
1857         goto donumset;
1858     case O_RESET:
1859         str_reset(str_get(sarg[1]));
1860         value = 1.0;
1861         goto donumset;
1862     case O_LIST:
1863         if (maxarg > 0)
1864             str = sarg[maxarg]; /* unwanted list, return last item */
1865         else
1866             str = &str_no;
1867         break;
1868     case O_EOF:
1869         str_set(str, do_eof(maxarg > 0 ? arg[1].arg_ptr.arg_stab : last_in_stab) ? Yes : No);
1870         STABSET(str);
1871         break;
1872     case O_TELL:
1873         value = (double)do_tell(maxarg > 0 ? arg[1].arg_ptr.arg_stab : last_in_stab);
1874         goto donumset;
1875         break;
1876     case O_SEEK:
1877         value = str_gnum(sarg[2]);
1878         str_set(str, do_seek(arg[1].arg_ptr.arg_stab,
1879           (long)value, (int)str_gnum(sarg[3]) ) ? Yes : No);
1880         STABSET(str);
1881         break;
1882     case O_REDO:
1883     case O_NEXT:
1884     case O_LAST:
1885         if (maxarg > 0) {
1886             tmps = str_get(sarg[1]);
1887             while (loop_ptr >= 0 && (!loop_stack[loop_ptr].loop_label ||
1888               strNE(tmps,loop_stack[loop_ptr].loop_label) )) {
1889 #ifdef DEBUGGING
1890                 if (debug & 4) {
1891                     deb("(Skipping label #%d %s)\n",loop_ptr,
1892                         loop_stack[loop_ptr].loop_label);
1893                 }
1894 #endif
1895                 loop_ptr--;
1896             }
1897 #ifdef DEBUGGING
1898             if (debug & 4) {
1899                 deb("(Found label #%d %s)\n",loop_ptr,
1900                     loop_stack[loop_ptr].loop_label);
1901             }
1902 #endif
1903         }
1904         if (loop_ptr < 0)
1905             fatal("Bad label: %s\n", maxarg > 0 ? tmps : "<null>");
1906         longjmp(loop_stack[loop_ptr].loop_env, optype);
1907     case O_GOTO:/* shudder */
1908         goto_targ = str_get(sarg[1]);
1909         longjmp(top_env, 1);
1910     case O_INDEX:
1911         tmps = str_get(sarg[1]);
1912         if (!(tmps2 = instr(tmps,str_get(sarg[2]))))
1913             value = (double)(-1 + arybase);
1914         else
1915             value = (double)(tmps2 - tmps + arybase);
1916         goto donumset;
1917     case O_TIME:
1918         value = (double) time(0);
1919         goto donumset;
1920     case O_TMS:
1921         value = (double) do_tms(retary);
1922         retary = Null(STR***);          /* do_tms already did retary */
1923         goto donumset;
1924     case O_LOCALTIME:
1925         tmplong = (long) str_gnum(sarg[1]);
1926         value = (double) do_time(localtime(&tmplong),retary);
1927         retary = Null(STR***);          /* do_localtime already did retary */
1928         goto donumset;
1929     case O_GMTIME:
1930         tmplong = (long) str_gnum(sarg[1]);
1931         value = (double) do_time(gmtime(&tmplong),retary);
1932         retary = Null(STR***);          /* do_gmtime already did retary */
1933         goto donumset;
1934     case O_STAT:
1935         value = (double) do_stat(arg,sarg,retary);
1936         retary = Null(STR***);          /* do_stat already did retary */
1937         goto donumset;
1938     case O_CRYPT:
1939         tmps = str_get(sarg[1]);
1940         str_set(str,crypt(tmps,str_get(sarg[2])));
1941         break;
1942     case O_EXP:
1943         value = exp(str_gnum(sarg[1]));
1944         goto donumset;
1945     case O_LOG:
1946         value = log(str_gnum(sarg[1]));
1947         goto donumset;
1948     case O_SQRT:
1949         value = sqrt(str_gnum(sarg[1]));
1950         goto donumset;
1951     case O_INT:
1952         modf(str_gnum(sarg[1]),&value);
1953         goto donumset;
1954     case O_ORD:
1955         value = (double) *str_get(sarg[1]);
1956         goto donumset;
1957     case O_SLEEP:
1958         tmps = str_get(sarg[1]);
1959         time(&tmplong);
1960         if (!tmps || !*tmps)
1961             sleep((32767<<16)+32767);
1962         else
1963             sleep(atoi(tmps));
1964         value = (double)tmplong;
1965         time(&tmplong);
1966         value = ((double)tmplong) - value;
1967         goto donumset;
1968     case O_FLIP:
1969         if (str_true(sarg[1])) {
1970             str_numset(str,0.0);
1971             anum = 2;
1972             arg->arg_type = optype = O_FLOP;
1973             maxarg = 0;
1974             arg[2].arg_flags &= ~AF_SPECIAL;
1975             arg[1].arg_flags |= AF_SPECIAL;
1976             argflags = arg[anum].arg_flags;
1977             goto re_eval;
1978         }
1979         str_set(str,"");
1980         break;
1981     case O_FLOP:
1982         str_inc(str);
1983         if (str_true(sarg[2])) {
1984             arg->arg_type = O_FLIP;
1985             arg[1].arg_flags &= ~AF_SPECIAL;
1986             arg[2].arg_flags |= AF_SPECIAL;
1987             str_cat(str,"E0");
1988         }
1989         break;
1990     case O_FORK:
1991         value = (double)fork();
1992         goto donumset;
1993     case O_SYSTEM:
1994         if (anum = vfork()) {
1995             ihand = signal(SIGINT, SIG_IGN);
1996             qhand = signal(SIGQUIT, SIG_IGN);
1997             while ((maxarg = wait(&argflags)) != anum && maxarg != -1)
1998                 ;
1999             if (maxarg == -1)
2000                 argflags = -1;
2001             signal(SIGINT, ihand);
2002             signal(SIGQUIT, qhand);
2003             value = (double)argflags;
2004             goto donumset;
2005         }
2006         /* FALL THROUGH */
2007     case O_EXEC:
2008         if (arg[1].arg_flags & AF_SPECIAL)
2009             value = (double)do_aexec(arg);
2010         else {
2011             value = (double)do_exec(str_get(sarg[1]));
2012         }
2013         goto donumset;
2014     case O_HEX:
2015         maxarg = 4;
2016         goto snarfnum;
2017
2018     case O_OCT:
2019         maxarg = 3;
2020
2021       snarfnum:
2022         anum = 0;
2023         tmps = str_get(sarg[1]);
2024         for (;;) {
2025             switch (*tmps) {
2026             default:
2027                 goto out;
2028             case '8': case '9':
2029                 if (maxarg != 4)
2030                     goto out;
2031                 /* FALL THROUGH */
2032             case '0': case '1': case '2': case '3': case '4':
2033             case '5': case '6': case '7':
2034                 anum <<= maxarg;
2035                 anum += *tmps++ & 15;
2036                 break;
2037             case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
2038             case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
2039                 if (maxarg != 4)
2040                     goto out;
2041                 anum <<= 4;
2042                 anum += (*tmps++ & 7) + 9;
2043                 break;
2044             case 'x':
2045                 maxarg = 4;
2046                 tmps++;
2047                 break;
2048             }
2049         }
2050       out:
2051         value = (double)anum;
2052         goto donumset;
2053     case O_CHMOD:
2054     case O_CHOWN:
2055     case O_KILL:
2056     case O_UNLINK:
2057         if (arg[1].arg_flags & AF_SPECIAL)
2058             value = (double)apply(optype,arg,Null(STR**));
2059         else {
2060             sarg[2] = Nullstr;
2061             value = (double)apply(optype,arg,sarg);
2062         }
2063         goto donumset;
2064     case O_UMASK:
2065         value = (double)umask((int)str_gnum(sarg[1]));
2066         goto donumset;
2067     case O_RENAME:
2068         tmps = str_get(sarg[1]);
2069 #ifdef RENAME
2070         value = (double)(rename(tmps,str_get(sarg[2])) >= 0);
2071 #else
2072         tmps2 = str_get(sarg[2]);
2073         UNLINK(tmps2);
2074         if (!(anum = link(tmps,tmps2)))
2075             anum = UNLINK(tmps);
2076         value = (double)(anum >= 0);
2077 #endif
2078         goto donumset;
2079     case O_LINK:
2080         tmps = str_get(sarg[1]);
2081         value = (double)(link(tmps,str_get(sarg[2])) >= 0);
2082         goto donumset;
2083     case O_UNSHIFT:
2084         ary = arg[2].arg_ptr.arg_stab->stab_array;
2085         if (arg[1].arg_flags & AF_SPECIAL)
2086             do_unshift(arg,ary);
2087         else {
2088             str = str_new(0);           /* must copy the STR */
2089             str_sset(str,sarg[1]);
2090             aunshift(ary,1);
2091             astore(ary,0,str);
2092         }
2093         value = (double)(ary->ary_fill + 1);
2094         break;
2095     }
2096 #ifdef DEBUGGING
2097     dlevel--;
2098     if (debug & 8)
2099         deb("%s RETURNS \"%s\"\n",opname[optype],str_get(str));
2100 #endif
2101     goto freeargs;
2102
2103 donumset:
2104     str_numset(str,value);
2105     STABSET(str);
2106 #ifdef DEBUGGING
2107     dlevel--;
2108     if (debug & 8)
2109         deb("%s RETURNS \"%f\"\n",opname[optype],value);
2110 #endif
2111
2112 freeargs:
2113     if (sarg != quicksarg) {
2114         if (retary) {
2115             if (optype == O_LIST)
2116                 sarg[0] = &str_no;
2117             else
2118                 sarg[0] = Nullstr;
2119             sarg[maxarg+1] = Nullstr;
2120             *retary = sarg;     /* up to them to free it */
2121         }
2122         else
2123             safefree(sarg);
2124     }
2125     return str;
2126
2127 nullarray:
2128     maxarg = 0;
2129 #ifdef DEBUGGING
2130     dlevel--;
2131     if (debug & 8)
2132         deb("%s RETURNS ()\n",opname[optype],value);
2133 #endif
2134     goto freeargs;
2135 }