x2p/walk.c

   1 /* $RCSfile: walk.c,v $$Revision: 4.1 $$Date: 92/08/07 18:29:31 $
   2  *
   3  *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1997, 1998, 1999,
   4  *    2000, 2001, 2002, by Larry Wall and others
   5  *
   6  *    You may distribute under the terms of either the GNU General Public
   7  *    License or the Artistic License, as specified in the README file.
   8  *
   9  * $Log:        walk.c,v $
  10  */
  11
  12 #include "EXTERN.h"
  13 #include "a2p.h"
  14 #include "util.h"
  15
  16 bool exitval = FALSE;
  17 bool realexit = FALSE;
  18 bool saw_getline = FALSE;
  19 bool subretnum = FALSE;
  20 bool saw_FNR = FALSE;
  21 bool saw_argv0 = FALSE;
  22 bool saw_fh = FALSE;
  23 int maxtmp = 0;
  24 char *lparen;
  25 char *rparen;
  26 char *limit;
  27 STR *subs;
  28 STR *curargs = Nullstr;
  29
  30 static void addsemi ( STR *str );
  31 static void emit_split ( STR *str, int level );
  32 static void fixtab ( STR *str, int lvl );
  33 static void numericize ( int node );
  34 static void tab ( STR *str, int lvl );
  35
  36 int prewalk ( int numit, int level, int node, int *numericptr );
  37 STR * walk ( int useval, int level, int node, int *numericptr, int minprec );
  38 #ifdef NETWARE
  39 char *savestr(char *str);
  40 char *cpytill(register char *to, register char *from, register int delim);
  41 char *instr(char *big, char *little);
  42 #endif
  43
  44 STR *
  45 walk(int useval, int level, register int node, int *numericptr, int minprec)
  46
  47
  48
  49
  50                                 /* minimum precedence without parens */
  51 {
  52     register int len;
  53     register STR *str;
  54     register int type;
  55     register int i;
  56     register STR *tmpstr;
  57     STR *tmp2str;
  58     STR *tmp3str;
  59     char *t;
  60     char *d, *s;
  61     int numarg;
  62     int numeric = FALSE;
  63     STR *fstr;
  64     int prec = P_MAX;           /* assume no parens needed */
  65
  66     if (!node) {
  67         *numericptr = 0;
  68         return str_make("");
  69     }
  70     type = ops[node].ival;
  71     len = type >> 8;
  72     type &= 255;
  73     switch (type) {
  74     case OPROG:
  75         arymax = 0;
  76         if (namelist) {
  77             while (isALPHA(*namelist)) {
  78                 for (d = tokenbuf,s=namelist;
  79                   isALPHA(*s) || isDIGIT(*s) || *s == '_';
  80                   *d++ = *s++) ;
  81                 *d = '\0';
  82                 while (*s && !isALPHA(*s)) s++;
  83                 namelist = s;
  84                 nameary[++arymax] = savestr(tokenbuf);
  85             }
  86         }
  87         if (maxfld < arymax)
  88             maxfld = arymax;
  89         opens = str_new(0);
  90         subs = str_new(0);
  91         str = walk(0,level,ops[node+1].ival,&numarg,P_MIN);
  92         if (do_split && need_entire && !absmaxfld)
  93             split_to_array = TRUE;
  94         if (do_split && split_to_array)
  95             set_array_base = TRUE;
  96         if (set_array_base) {
  97             str_cat(str,"$[ = 1;\t\t\t# set array base to 1\n");
  98         }
  99         if (fswitch && !const_FS)
 100             const_FS = fswitch;
 101         if (saw_FS > 1 || saw_RS)
 102             const_FS = 0;
 103         if (saw_ORS && need_entire)
 104             do_chop = TRUE;
 105         if (fswitch) {
 106             str_cat(str,"$FS = '");
 107             if (strchr("*+?.[]()|^$\\",fswitch))
 108                 str_cat(str,"\\");
 109             sprintf(tokenbuf,"%c",fswitch);
 110             str_cat(str,tokenbuf);
 111             str_cat(str,"';\t\t# field separator from -F switch\n");
 112         }
 113         else if (saw_FS && !const_FS) {
 114             str_cat(str,"$FS = ' ';\t\t# set field separator\n");
 115         }
 116         if (saw_OFS) {
 117             str_cat(str,"$, = ' ';\t\t# set output field separator\n");
 118         }
 119         if (saw_ORS) {
 120             str_cat(str,"$\\ = \"\\n\";\t\t# set output record separator\n");
 121         }
 122         if (saw_argv0) {
 123             str_cat(str,"$ARGV0 = $0;\t\t# remember what we ran as\n");
 124         }
 125         if (str->str_cur > 20)
 126             str_cat(str,"\n");
 127         if (ops[node+2].ival) {
 128             str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg,P_MIN));
 129             str_free(fstr);
 130             str_cat(str,"\n\n");
 131         }
 132         fstr = walk(0,level+1,ops[node+3].ival,&numarg,P_MIN);
 133         if (*fstr->str_ptr) {
 134             if (saw_line_op)
 135                 str_cat(str,"line: ");
 136             str_cat(str,"while (<>) {\n");
 137             tab(str,++level);
 138             if (saw_FS && !const_FS)
 139                 do_chop = TRUE;
 140             if (do_chop) {
 141                 str_cat(str,"chomp;\t# strip record separator\n");
 142                 tab(str,level);
 143             }
 144             if (do_split)
 145                 emit_split(str,level);
 146             str_scat(str,fstr);
 147             str_free(fstr);
 148             fixtab(str,--level);
 149             str_cat(str,"}\n");
 150             if (saw_FNR)
 151                 str_cat(str,"continue {\n    $FNRbase = $. if eof;\n}\n");
 152         }
 153         else if (old_awk)
 154             str_cat(str,"while (<>) { }         # (no line actions)\n");
 155         if (ops[node+4].ival) {
 156             realexit = TRUE;
 157             str_cat(str,"\n");
 158             tab(str,level);
 159             str_scat(str,fstr=walk(0,level,ops[node+4].ival,&numarg,P_MIN));
 160             str_free(fstr);
 161             str_cat(str,"\n");
 162         }
 163         if (exitval)
 164             str_cat(str,"exit $ExitValue;\n");
 165         if (subs->str_ptr) {
 166             str_cat(str,"\n");
 167             str_scat(str,subs);
 168         }
 169         if (saw_getline) {
 170             for (len = 0; len < 4; len++) {
 171                 if (saw_getline & (1 << len)) {
 172                     sprintf(tokenbuf,"\nsub Getline%d {\n",len);
 173                     str_cat(str, tokenbuf);
 174                     if (len & 2) {
 175                         if (do_fancy_opens)
 176                             str_cat(str,"    &Pick('',@_);\n");
 177                         else
 178                             str_cat(str,"    ($fh) = @_;\n");
 179                     }
 180                     else {
 181                         if (saw_FNR)
 182                             str_cat(str,"    $FNRbase = $. if eof;\n");
 183                     }
 184                     if (len & 1)
 185                         str_cat(str,"    local($_);\n");
 186                     if (len & 2)
 187                         str_cat(str,
 188                           "    if ($getline_ok = (($_ = <$fh>) ne ''))");
 189                     else
 190                         str_cat(str,
 191                           "    if ($getline_ok = (($_ = <>) ne ''))");
 192                     str_cat(str, " {\n");
 193                     level += 2;
 194                     tab(str,level);
 195                     i = 0;
 196                     if (do_chop) {
 197                         i++;
 198                         str_cat(str,"chomp;\t# strip record separator\n");
 199                         tab(str,level);
 200                     }
 201                     if (do_split && !(len & 1)) {
 202                         i++;
 203                         emit_split(str,level);
 204                     }
 205                     if (!i)
 206                         str_cat(str,";\n");
 207                     fixtab(str,--level);
 208                     str_cat(str,"}\n    $_;\n}\n");
 209                     --level;
 210                 }
 211             }
 212         }
 213         if (do_fancy_opens) {
 214             str_cat(str,"\n\
 215 sub Pick {\n\
 216     local($mode,$name,$pipe) = @_;\n\
 217     $fh = $name;\n\
 218     open($name,$mode.$name.$pipe) unless $opened{$name}++;\n\
 219 }\n\
 220 ");
 221         }
 222         break;
 223     case OHUNKS:
 224         str = walk(0,level,ops[node+1].ival,&numarg,P_MIN);
 225         str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg,P_MIN));
 226         str_free(fstr);
 227         if (len == 3) {
 228             str_scat(str,fstr=walk(0,level,ops[node+3].ival,&numarg,P_MIN));
 229             str_free(fstr);
 230         }
 231         else {
 232         }
 233         break;
 234     case ORANGE:
 235         prec = P_DOTDOT;
 236         str = walk(1,level,ops[node+1].ival,&numarg,prec+1);
 237         str_cat(str," .. ");
 238         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,prec+1));
 239         str_free(fstr);
 240         break;
 241     case OPAT:
 242         goto def;
 243     case OREGEX:
 244         str = str_new(0);
 245         str_set(str,"/");
 246         tmpstr=walk(0,level,ops[node+1].ival,&numarg,P_MIN);
 247         /* translate \nnn to [\nnn] */
 248         for (s = tmpstr->str_ptr, d = tokenbuf; *s; s++, d++) {
 249             if (*s == '\\' && isDIGIT(s[1]) && isDIGIT(s[2]) && isDIGIT(s[3])){
 250                 *d++ = '[';
 251                 *d++ = *s++;
 252                 *d++ = *s++;
 253                 *d++ = *s++;
 254                 *d++ = *s;
 255                 *d = ']';
 256             }
 257             else
 258                 *d = *s;
 259         }
 260         *d = '\0';
 261         for (d=tokenbuf; *d; d++)
 262            *d += (char)128;
 263         str_cat(str,tokenbuf);
 264         str_free(tmpstr);
 265         str_cat(str,"/");
 266         break;
 267     case OHUNK:
 268         if (len == 1) {
 269             str = str_new(0);
 270             str = walk(0,level,oper1(OPRINT,0),&numarg,P_MIN);
 271             str_cat(str," if ");
 272             str_scat(str,fstr=walk(0,level,ops[node+1].ival,&numarg,P_MIN));
 273             str_free(fstr);
 274             str_cat(str,";");
 275         }
 276         else {
 277             tmpstr = walk(0,level,ops[node+1].ival,&numarg,P_MIN);
 278             if (*tmpstr->str_ptr) {
 279                 str = str_new(0);
 280                 str_set(str,"if (");
 281                 str_scat(str,tmpstr);
 282                 str_cat(str,") {\n");
 283                 tab(str,++level);
 284                 str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg,P_MIN));
 285                 str_free(fstr);
 286                 fixtab(str,--level);
 287                 str_cat(str,"}\n");
 288                 tab(str,level);
 289             }
 290             else {
 291                 str = walk(0,level,ops[node+2].ival,&numarg,P_MIN);
 292             }
 293         }
 294         break;
 295     case OPPAREN:
 296         str = str_new(0);
 297         str_set(str,"(");
 298         str_scat(str,fstr=walk(useval != 0,level,ops[node+1].ival,&numarg,P_MIN));
 299         str_free(fstr);
 300         str_cat(str,")");
 301         break;
 302     case OPANDAND:
 303         prec = P_ANDAND;
 304         str = walk(1,level,ops[node+1].ival,&numarg,prec);
 305         str_cat(str," && ");
 306         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,prec+1));
 307         str_free(fstr);
 308         str_scat(str,fstr=walk(1,level,ops[node+3].ival,&numarg,prec+1));
 309         str_free(fstr);
 310         break;
 311     case OPOROR:
 312         prec = P_OROR;
 313         str = walk(1,level,ops[node+1].ival,&numarg,prec);
 314         str_cat(str," || ");
 315         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,prec+1));
 316         str_free(fstr);
 317         str_scat(str,fstr=walk(1,level,ops[node+3].ival,&numarg,prec+1));
 318         str_free(fstr);
 319         break;
 320     case OPNOT:
 321         prec = P_UNARY;
 322         str = str_new(0);
 323         str_set(str,"!");
 324         str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,prec));
 325         str_free(fstr);
 326         break;
 327     case OCOND:
 328         prec = P_COND;
 329         str = walk(1,level,ops[node+1].ival,&numarg,prec);
 330         str_cat(str," ? ");
 331         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,prec+1));
 332         str_free(fstr);
 333         str_cat(str," : ");
 334         str_scat(str,fstr=walk(1,level,ops[node+3].ival,&numarg,prec+1));
 335         str_free(fstr);
 336         break;
 337     case OCPAREN:
 338         str = str_new(0);
 339         str_set(str,"(");
 340         str_scat(str,fstr=walk(useval != 0,level,ops[node+1].ival,&numarg,P_MIN));
 341         str_free(fstr);
 342         numeric |= numarg;
 343         str_cat(str,")");
 344         break;
 345     case OCANDAND:
 346         prec = P_ANDAND;
 347         str = walk(1,level,ops[node+1].ival,&numarg,prec);
 348         numeric = 1;
 349         str_cat(str," && ");
 350         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,prec+1));
 351         str_free(fstr);
 352         str_scat(str,fstr=walk(1,level,ops[node+3].ival,&numarg,prec+1));
 353         str_free(fstr);
 354         break;
 355     case OCOROR:
 356         prec = P_OROR;
 357         str = walk(1,level,ops[node+1].ival,&numarg,prec);
 358         numeric = 1;
 359         str_cat(str," || ");
 360         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,prec+1));
 361         str_free(fstr);
 362         str_scat(str,fstr=walk(1,level,ops[node+3].ival,&numarg,prec+1));
 363         str_free(fstr);
 364         break;
 365     case OCNOT:
 366         prec = P_UNARY;
 367         str = str_new(0);
 368         str_set(str,"!");
 369         str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,prec));
 370         str_free(fstr);
 371         numeric = 1;
 372         break;
 373     case ORELOP:
 374         prec = P_REL;
 375         str = walk(1,level,ops[node+2].ival,&numarg,prec+1);
 376         numeric |= numarg;
 377         tmpstr = walk(0,level,ops[node+1].ival,&numarg,P_MIN);
 378         tmp2str = walk(1,level,ops[node+3].ival,&numarg,prec+1);
 379         numeric |= numarg;
 380         if (!numeric ||
 381          (!numarg && (*tmp2str->str_ptr == '"' || *tmp2str->str_ptr == '\''))) {
 382             t = tmpstr->str_ptr;
 383             if (strEQ(t,"=="))
 384                 str_set(tmpstr,"eq");
 385             else if (strEQ(t,"!="))
 386                 str_set(tmpstr,"ne");
 387             else if (strEQ(t,"<"))
 388                 str_set(tmpstr,"lt");
 389             else if (strEQ(t,"<="))
 390                 str_set(tmpstr,"le");
 391             else if (strEQ(t,">"))
 392                 str_set(tmpstr,"gt");
 393             else if (strEQ(t,">="))
 394                 str_set(tmpstr,"ge");
 395             if (!strchr(tmpstr->str_ptr,'\'') && !strchr(tmpstr->str_ptr,'"') &&
 396               !strchr(tmp2str->str_ptr,'\'') && !strchr(tmp2str->str_ptr,'"') )
 397                 numeric |= 2;
 398         }
 399         if (numeric & 2) {
 400             if (numeric & 1)            /* numeric is very good guess */
 401                 str_cat(str," ");
 402             else
 403                 str_cat(str,"\377");
 404             numeric = 1;
 405         }
 406         else
 407             str_cat(str," ");
 408         str_scat(str,tmpstr);
 409         str_free(tmpstr);
 410         str_cat(str," ");
 411         str_scat(str,tmp2str);
 412         str_free(tmp2str);
 413         numeric = 1;
 414         break;
 415     case ORPAREN:
 416         str = str_new(0);
 417         str_set(str,"(");
 418         str_scat(str,fstr=walk(useval != 0,level,ops[node+1].ival,&numarg,P_MIN));
 419         str_free(fstr);
 420         numeric |= numarg;
 421         str_cat(str,")");
 422         break;
 423     case OMATCHOP:
 424         prec = P_MATCH;
 425         str = walk(1,level,ops[node+2].ival,&numarg,prec+1);
 426         str_cat(str," ");
 427         tmpstr = walk(0,level,ops[node+1].ival,&numarg,P_MIN);
 428         if (strEQ(tmpstr->str_ptr,"~"))
 429             str_cat(str,"=~");
 430         else {
 431             str_scat(str,tmpstr);
 432             str_free(tmpstr);
 433         }
 434         str_cat(str," ");
 435         str_scat(str,fstr=walk(1,level,ops[node+3].ival,&numarg,prec+1));
 436         str_free(fstr);
 437         numeric = 1;
 438         break;
 439     case OMPAREN:
 440         str = str_new(0);
 441         str_set(str,"(");
 442         str_scat(str,
 443           fstr=walk(useval != 0,level,ops[node+1].ival,&numarg,P_MIN));
 444         str_free(fstr);
 445         numeric |= numarg;
 446         str_cat(str,")");
 447         break;
 448     case OCONCAT:
 449         prec = P_ADD;
 450         type = ops[ops[node+1].ival].ival & 255;
 451         str = walk(1,level,ops[node+1].ival,&numarg,prec+(type != OCONCAT));
 452         str_cat(str," . ");
 453         type = ops[ops[node+2].ival].ival & 255;
 454         str_scat(str,
 455           fstr=walk(1,level,ops[node+2].ival,&numarg,prec+(type != OCONCAT)));
 456         str_free(fstr);
 457         break;
 458     case OASSIGN:
 459         prec = P_ASSIGN;
 460         str = walk(0,level,ops[node+2].ival,&numarg,prec+1);
 461         str_cat(str," ");
 462         tmpstr = walk(0,level,ops[node+1].ival,&numarg,P_MIN);
 463         str_scat(str,tmpstr);
 464         if (str_len(tmpstr) > 1)
 465             numeric = 1;
 466         str_free(tmpstr);
 467         str_cat(str," ");
 468         str_scat(str,fstr=walk(1,level,ops[node+3].ival,&numarg,prec));
 469         str_free(fstr);
 470         numeric |= numarg;
 471         if (strEQ(str->str_ptr,"$/ = ''"))
 472             str_set(str, "$/ = \"\\n\\n\"");
 473         break;
 474     case OADD:
 475         prec = P_ADD;
 476         str = walk(1,level,ops[node+1].ival,&numarg,prec);
 477         str_cat(str," + ");
 478         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,prec+1));
 479         str_free(fstr);
 480         numeric = 1;
 481         break;
 482     case OSUBTRACT:
 483         prec = P_ADD;
 484         str = walk(1,level,ops[node+1].ival,&numarg,prec);
 485         str_cat(str," - ");
 486         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,prec+1));
 487         str_free(fstr);
 488         numeric = 1;
 489         break;
 490     case OMULT:
 491         prec = P_MUL;
 492         str = walk(1,level,ops[node+1].ival,&numarg,prec);
 493         str_cat(str," * ");
 494         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,prec+1));
 495         str_free(fstr);
 496         numeric = 1;
 497         break;
 498     case ODIV:
 499         prec = P_MUL;
 500         str = walk(1,level,ops[node+1].ival,&numarg,prec);
 501         str_cat(str," / ");
 502         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,prec+1));
 503         str_free(fstr);
 504         numeric = 1;
 505         break;
 506     case OPOW:
 507         prec = P_POW;
 508         str = walk(1,level,ops[node+1].ival,&numarg,prec+1);
 509         str_cat(str," ** ");
 510         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,prec));
 511         str_free(fstr);
 512         numeric = 1;
 513         break;
 514     case OMOD:
 515         prec = P_MUL;
 516         str = walk(1,level,ops[node+1].ival,&numarg,prec);
 517         str_cat(str," % ");
 518         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,prec+1));
 519         str_free(fstr);
 520         numeric = 1;
 521         break;
 522     case OPOSTINCR:
 523         prec = P_AUTO;
 524         str = walk(1,level,ops[node+1].ival,&numarg,prec+1);
 525         str_cat(str,"++");
 526         numeric = 1;
 527         break;
 528     case OPOSTDECR:
 529         prec = P_AUTO;
 530         str = walk(1,level,ops[node+1].ival,&numarg,prec+1);
 531         str_cat(str,"--");
 532         numeric = 1;
 533         break;
 534     case OPREINCR:
 535         prec = P_AUTO;
 536         str = str_new(0);
 537         str_set(str,"++");
 538         str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,prec+1));
 539         str_free(fstr);
 540         numeric = 1;
 541         break;
 542     case OPREDECR:
 543         prec = P_AUTO;
 544         str = str_new(0);
 545         str_set(str,"--");
 546         str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,prec+1));
 547         str_free(fstr);
 548         numeric = 1;
 549         break;
 550     case OUMINUS:
 551         prec = P_UNARY;
 552         str = str_new(0);
 553         str_set(str,"-");
 554         str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,prec));
 555         str_free(fstr);
 556         numeric = 1;
 557         break;
 558     case OUPLUS:
 559         numeric = 1;
 560         goto def;
 561     case OPAREN:
 562         str = str_new(0);
 563         str_set(str,"(");
 564         str_scat(str,
 565           fstr=walk(useval != 0,level,ops[node+1].ival,&numarg,P_MIN));
 566         str_free(fstr);
 567         str_cat(str,")");
 568         numeric |= numarg;
 569         break;
 570     case OGETLINE:
 571         str = str_new(0);
 572         if (useval)
 573             str_cat(str,"(");
 574         if (len > 0) {
 575             str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,P_MIN));
 576             if (!*fstr->str_ptr) {
 577                 str_cat(str,"$_");
 578                 len = 2;                /* a legal fiction */
 579             }
 580             str_free(fstr);
 581         }
 582         else
 583             str_cat(str,"$_");
 584         if (len > 1) {
 585             tmpstr=walk(1,level,ops[node+3].ival,&numarg,P_MIN);
 586             fstr=walk(1,level,ops[node+2].ival,&numarg,P_MIN);
 587             if (!do_fancy_opens) {
 588                 t = tmpstr->str_ptr;
 589                 if (*t == '"' || *t == '\'')
 590                     t = cpytill(tokenbuf,t+1,*t);
 591                 else
 592                     fatal("Internal error: OGETLINE %s", t);
 593                 d = savestr(t);
 594                 s = savestr(tokenbuf);
 595                 for (t = tokenbuf; *t; t++) {
 596                     *t &= 127;
 597                     if (isLOWER(*t))
 598                         *t = toUPPER(*t);
 599                     if (!isALPHA(*t) && !isDIGIT(*t))
 600                         *t = '_';
 601                 }
 602                 if (!strchr(tokenbuf,'_'))
 603                     strcpy(t,"_FH");
 604                 tmp3str = hfetch(symtab,tokenbuf);
 605                 if (!tmp3str) {
 606                     do_opens = TRUE;
 607                     str_cat(opens,"open(");
 608                     str_cat(opens,tokenbuf);
 609                     str_cat(opens,", ");
 610                     d[1] = '\0';
 611                     str_cat(opens,d);
 612                     str_cat(opens,tmpstr->str_ptr+1);
 613                     opens->str_cur--;
 614                     if (*fstr->str_ptr == '|')
 615                         str_cat(opens,"|");
 616                     str_cat(opens,d);
 617                     if (*fstr->str_ptr == '|')
 618                         str_cat(opens,") || die 'Cannot pipe from \"");
 619                     else
 620                         str_cat(opens,") || die 'Cannot open file \"");
 621                     if (*d == '"')
 622                         str_cat(opens,"'.\"");
 623                     str_cat(opens,s);
 624                     if (*d == '"')
 625                         str_cat(opens,"\".'");
 626                     str_cat(opens,"\".';\n");
 627                     hstore(symtab,tokenbuf,str_make("x"));
 628                 }
 629                 safefree(s);
 630                 safefree(d);
 631                 str_set(tmpstr,"'");
 632                 str_cat(tmpstr,tokenbuf);
 633                 str_cat(tmpstr,"'");
 634             }
 635             if (*fstr->str_ptr == '|')
 636                 str_cat(tmpstr,", '|'");
 637             str_free(fstr);
 638         }
 639         else
 640             tmpstr = str_make("");
 641         sprintf(tokenbuf," = &Getline%d(%s)",len,tmpstr->str_ptr);
 642         str_cat(str,tokenbuf);
 643         str_free(tmpstr);
 644         if (useval)
 645             str_cat(str,",$getline_ok)");
 646         saw_getline |= 1 << len;
 647         break;
 648     case OSPRINTF:
 649         str = str_new(0);
 650         str_set(str,"sprintf(");
 651         str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,P_MIN));
 652         str_free(fstr);
 653         str_cat(str,")");
 654         break;
 655     case OSUBSTR:
 656         str = str_new(0);
 657         str_set(str,"substr(");
 658         str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,P_COMMA+1));
 659         str_free(fstr);
 660         str_cat(str,", ");
 661         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,P_COMMA+1));
 662         str_free(fstr);
 663         str_cat(str,", ");
 664         if (len == 3) {
 665             str_scat(str,fstr=walk(1,level,ops[node+3].ival,&numarg,P_COMMA+1));
 666             str_free(fstr);
 667         }
 668         else
 669             str_cat(str,"999999");
 670         str_cat(str,")");
 671         break;
 672     case OSTRING:
 673         str = str_new(0);
 674         str_set(str,ops[node+1].cval);
 675         break;
 676     case OSPLIT:
 677         str = str_new(0);
 678         limit = ", 9999)";
 679         numeric = 1;
 680         tmpstr = walk(1,level,ops[node+2].ival,&numarg,P_MIN);
 681         if (useval)
 682             str_set(str,"(@");
 683         else
 684             str_set(str,"@");
 685         str_scat(str,tmpstr);
 686         str_cat(str," = split(");
 687         if (len == 3) {
 688             fstr = walk(1,level,ops[node+3].ival,&numarg,P_COMMA+1);
 689             if (str_len(fstr) == 3 && *fstr->str_ptr == '\'') {
 690                 i = fstr->str_ptr[1] & 127;
 691                 if (strchr("*+?.[]()|^$\\",i))
 692                     sprintf(tokenbuf,"/\\%c/",i);
 693                 else if (i == ' ')
 694                     sprintf(tokenbuf,"' '");
 695                 else
 696                     sprintf(tokenbuf,"/%c/",i);
 697                 str_cat(str,tokenbuf);
 698             }
 699             else
 700                 str_scat(str,fstr);
 701             str_free(fstr);
 702         }
 703         else if (const_FS) {
 704             sprintf(tokenbuf,"/[%c\\n]/",const_FS);
 705             str_cat(str,tokenbuf);
 706         }
 707         else if (saw_FS)
 708             str_cat(str,"$FS");
 709         else {
 710             str_cat(str,"' '");
 711             limit = ")";
 712         }
 713         str_cat(str,", ");
 714         str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,P_COMMA+1));
 715         str_free(fstr);
 716         str_cat(str,limit);
 717         if (useval) {
 718             str_cat(str,")");
 719         }
 720         str_free(tmpstr);
 721         break;
 722     case OINDEX:
 723         str = str_new(0);
 724         str_set(str,"index(");
 725         str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,P_COMMA+1));
 726         str_free(fstr);
 727         str_cat(str,", ");
 728         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,P_COMMA+1));
 729         str_free(fstr);
 730         str_cat(str,")");
 731         numeric = 1;
 732         break;
 733     case OMATCH:
 734         str = str_new(0);
 735         prec = P_ANDAND;
 736         str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,P_MATCH+1));
 737         str_free(fstr);
 738         str_cat(str," =~ ");
 739         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,P_MATCH+1));
 740         str_free(fstr);
 741         str_cat(str," && ($RLENGTH = length($&), $RSTART = length($`)+1)");
 742         numeric = 1;
 743         break;
 744     case OUSERDEF:
 745         str = str_new(0);
 746         subretnum = FALSE;
 747         fstr=walk(1,level-1,ops[node+2].ival,&numarg,P_MIN);
 748         curargs = str_new(0);
 749         str_sset(curargs,fstr);
 750         str_cat(curargs,",");
 751         tmp2str=walk(1,level,ops[node+5].ival,&numarg,P_MIN);
 752         str_free(curargs);
 753         curargs = Nullstr;
 754         level--;
 755         subretnum |= numarg;
 756         s = Nullch;
 757         t = tmp2str->str_ptr;
 758         while ((t = instr(t,"return ")))
 759             s = t++;
 760         if (s) {
 761             i = 0;
 762             for (t = s+7; *t; t++) {
 763                 if (*t == ';' || *t == '}')
 764                     i++;
 765             }
 766             if (i == 1) {
 767                 strcpy(s,s+7);
 768                 tmp2str->str_cur -= 7;
 769             }
 770         }
 771         str_set(str,"\n");
 772         tab(str,level);
 773         str_cat(str,"sub ");
 774         str_scat(str,tmpstr=walk(1,level,ops[node+1].ival,&numarg,P_MIN));
 775         str_cat(str," {\n");
 776         tab(str,++level);
 777         if (fstr->str_cur) {
 778             str_cat(str,"local(");
 779             str_scat(str,fstr);
 780             str_cat(str,") = @_;");
 781         }
 782         str_free(fstr);
 783         str_scat(str,fstr=walk(1,level,ops[node+3].ival,&numarg,P_MIN));
 784         str_free(fstr);
 785         fixtab(str,level);
 786         str_scat(str,fstr=walk(1,level,ops[node+4].ival,&numarg,P_MIN));
 787         str_free(fstr);
 788         fixtab(str,level);
 789         str_scat(str,tmp2str);
 790         str_free(tmp2str);
 791         fixtab(str,--level);
 792         str_cat(str,"}\n");
 793         tab(str,level);
 794         str_scat(subs,str);
 795         str_set(str,"");
 796         str_cat(tmpstr,"(");
 797         tmp2str = str_new(0);
 798         if (subretnum)
 799             str_set(tmp2str,"1");
 800         hstore(symtab,tmpstr->str_ptr,tmp2str);
 801         str_free(tmpstr);
 802         level++;
 803         break;
 804     case ORETURN:
 805         str = str_new(0);
 806         if (len > 0) {
 807             str_cat(str,"return ");
 808             str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,P_UNI+1));
 809             str_free(fstr);
 810             if (numarg)
 811                 subretnum = TRUE;
 812         }
 813         else
 814             str_cat(str,"return");
 815         break;
 816     case OUSERFUN:
 817         str = str_new(0);
 818         str_set(str,"&");
 819         str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,P_MIN));
 820         str_free(fstr);
 821         str_cat(str,"(");
 822         tmpstr = hfetch(symtab,str->str_ptr+3);
 823         if (tmpstr && tmpstr->str_ptr)
 824             numeric |= atoi(tmpstr->str_ptr);
 825         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,P_MIN));
 826         str_free(fstr);
 827         str_cat(str,")");
 828         break;
 829     case OGSUB:
 830     case OSUB: {
 831         int gsub = type == OGSUB ? 1 : 0;
 832         str = str_new(0);
 833         tmpstr = str_new(0);
 834         i = 0;
 835         if (len == 3) {
 836             tmpstr = walk(1,level,ops[node+3].ival,&numarg,P_MATCH+1);
 837             if (strNE(tmpstr->str_ptr,"$_")) {
 838                 str_cat(tmpstr, " =~ s");
 839                 i++;
 840             }
 841             else
 842                 str_set(tmpstr, "s");
 843         }
 844         else
 845             str_set(tmpstr, "s");
 846         type = ops[ops[node+2].ival].ival;
 847         len = type >> 8;
 848         type &= 255;
 849         tmp3str = str_new(0);
 850         if (type == OSTR) {
 851             tmp2str=walk(1,level,ops[ops[node+2].ival+1].ival,&numarg,P_MIN);
 852             for (t = tmp2str->str_ptr, d=tokenbuf; *t; d++,t++) {
 853                 if (*t == '&')
 854                    *d++ = '$' + (char)128;
 855                 else if (*t == '$')
 856                    *d++ = '\\' + (char)128;
 857                 *d = *t + 128;
 858             }
 859             *d = '\0';
 860             str_set(tmp2str,tokenbuf);
 861             s = gsub ? "/g" : "/";
 862         }
 863         else {
 864             tmp2str=walk(1,level,ops[node+2].ival,&numarg,P_MIN);
 865             str_set(tmp3str,"($s_ = '\"'.(");
 866             str_scat(tmp3str,tmp2str);
 867             str_cat(tmp3str,").'\"') =~ s/&/\\$&/g, ");
 868             str_set(tmp2str,"eval $s_");
 869             s = gsub ? "/ge" : "/e";
 870             i++;
 871         }
 872         str_cat(tmp2str,s);
 873         type = ops[ops[node+1].ival].ival;
 874         len = type >> 8;
 875         type &= 255;
 876         fstr=walk(1,level,ops[node+1].ival,&numarg,P_MIN);
 877         if (type == OREGEX) {
 878             if (useval && i)
 879                 str_cat(str,"(");
 880             str_scat(str,tmp3str);
 881             str_scat(str,tmpstr);
 882             str_scat(str,fstr);
 883             str_scat(str,tmp2str);
 884         }
 885         else if ((type == OFLD && !split_to_array) || (type == OVAR && len == 1)) {
 886             if (useval && i)
 887                 str_cat(str,"(");
 888             str_scat(str,tmp3str);
 889             str_scat(str,tmpstr);
 890             str_cat(str,"/");
 891             str_scat(str,fstr);
 892             str_cat(str,"/");
 893             str_scat(str,tmp2str);
 894         }
 895         else {
 896             i++;
 897             if (useval)
 898                 str_cat(str,"(");
 899             str_cat(str,"$s = ");
 900             str_scat(str,fstr);
 901             str_cat(str,", ");
 902             str_scat(str,tmp3str);
 903             str_scat(str,tmpstr);
 904             str_cat(str,"/$s/");
 905             str_scat(str,tmp2str);
 906         }
 907         if (useval && i)
 908             str_cat(str,")");
 909         str_free(fstr);
 910         str_free(tmpstr);
 911         str_free(tmp2str);
 912         str_free(tmp3str);
 913         numeric = 1;
 914         break; }
 915     case ONUM:
 916         str = walk(1,level,ops[node+1].ival,&numarg,P_MIN);
 917         numeric = 1;
 918         break;
 919     case OSTR:
 920         tmpstr = walk(1,level,ops[node+1].ival,&numarg,P_MIN);
 921         s = "'";
 922         for (t = tmpstr->str_ptr, d=tokenbuf; *t; d++,t++) {
 923             if (*t == '\'')
 924                 s = "\"";
 925             else if (*t == '\\') {
 926                 s = "\"";
 927                 *d++ = *t++ + 128;
 928                 switch (*t) {
 929                 case '\\': case '"': case 'n': case 't': case '$':
 930                     break;
 931                 default:        /* hide this from perl */
 932                    *d++ = '\\' + (char)128;
 933                 }
 934             }
 935             *d = *t + 128;
 936         }
 937         *d = '\0';
 938         str = str_new(0);
 939         str_set(str,s);
 940         str_cat(str,tokenbuf);
 941         str_free(tmpstr);
 942         str_cat(str,s);
 943         break;
 944     case ODEFINED:
 945         prec = P_UNI;
 946         str = str_new(0);
 947         str_set(str,"defined $");
 948         goto addvar;
 949     case ODELETE:
 950         str = str_new(0);
 951         str_set(str,"delete $");
 952         goto addvar;
 953     case OSTAR:
 954         str = str_new(0);
 955         str_set(str,"*");
 956         goto addvar;
 957     case OVAR:
 958         str = str_new(0);
 959         str_set(str,"$");
 960       addvar:
 961         str_scat(str,tmpstr=walk(1,level,ops[node+1].ival,&numarg,P_MIN));
 962         if (len == 1) {
 963             tmp2str = hfetch(symtab,tmpstr->str_ptr);
 964             if (tmp2str && atoi(tmp2str->str_ptr))
 965                 numeric = 2;
 966             if (strEQ(str->str_ptr,"$FNR")) {
 967                 numeric = 1;
 968                 saw_FNR++;
 969                 str_set(str,"($.-$FNRbase)");
 970             }
 971             else if (strEQ(str->str_ptr,"$NR")) {
 972                 numeric = 1;
 973                 str_set(str,"$.");
 974             }
 975             else if (strEQ(str->str_ptr,"$NF")) {
 976                 numeric = 1;
 977                 str_set(str,"$#Fld");
 978             }
 979             else if (strEQ(str->str_ptr,"$0"))
 980                 str_set(str,"$_");
 981             else if (strEQ(str->str_ptr,"$ARGC"))
 982                 str_set(str,"($#ARGV+1)");
 983         }
 984         else {
 985 #ifdef NOTDEF
 986             if (curargs) {
 987                 sprintf(tokenbuf,"$%s,",tmpstr->str_ptr);
 988         ???     if (instr(curargs->str_ptr,tokenbuf))
 989                     str_cat(str,"\377");        /* can't translate yet */
 990             }
 991 #endif
 992             str_cat(tmpstr,"[]");
 993             tmp2str = hfetch(symtab,tmpstr->str_ptr);
 994             if (tmp2str && atoi(tmp2str->str_ptr))
 995                 str_cat(str,"[");
 996             else
 997                 str_cat(str,"{");
 998             str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,P_MIN));
 999             str_free(fstr);
1000             if (strEQ(str->str_ptr,"$ARGV[0")) {
1001                 str_set(str,"$ARGV0");
1002                 saw_argv0++;
1003             }
1004             else {
1005                 if (tmp2str && atoi(tmp2str->str_ptr))
1006                     strcpy(tokenbuf,"]");
1007                 else
1008                     strcpy(tokenbuf,"}");
1009                *tokenbuf += (char)128;
1010                 str_cat(str,tokenbuf);
1011             }
1012         }
1013         str_free(tmpstr);
1014         break;
1015     case OFLD:
1016         str = str_new(0);
1017         if (split_to_array) {
1018             str_set(str,"$Fld");
1019             str_cat(str,"[");
1020             str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,P_MIN));
1021             str_free(fstr);
1022             str_cat(str,"]");
1023         }
1024         else {
1025             i = atoi(walk(1,level,ops[node+1].ival,&numarg,P_MIN)->str_ptr);
1026             if (i <= arymax)
1027                 sprintf(tokenbuf,"$%s",nameary[i]);
1028             else
1029                 sprintf(tokenbuf,"$Fld%d",i);
1030             str_set(str,tokenbuf);
1031         }
1032         break;
1033     case OVFLD:
1034         str = str_new(0);
1035         str_set(str,"$Fld[");
1036         i = ops[node+1].ival;
1037         if ((ops[i].ival & 255) == OPAREN)
1038             i = ops[i+1].ival;
1039         tmpstr=walk(1,level,i,&numarg,P_MIN);
1040         str_scat(str,tmpstr);
1041         str_free(tmpstr);
1042         str_cat(str,"]");
1043         break;
1044     case OJUNK:
1045         goto def;
1046     case OSNEWLINE:
1047         str = str_new(2);
1048         str_set(str,";\n");
1049         tab(str,level);
1050         break;
1051     case ONEWLINE:
1052         str = str_new(1);
1053         str_set(str,"\n");
1054         tab(str,level);
1055         break;
1056     case OSCOMMENT:
1057         str = str_new(0);
1058         str_set(str,";");
1059         tmpstr = walk(0,level,ops[node+1].ival,&numarg,P_MIN);
1060         for (s = tmpstr->str_ptr; *s && *s != '\n'; s++)
1061            *s += (char)128;
1062         str_scat(str,tmpstr);
1063         str_free(tmpstr);
1064         tab(str,level);
1065         break;
1066     case OCOMMENT:
1067         str = str_new(0);
1068         tmpstr = walk(0,level,ops[node+1].ival,&numarg,P_MIN);
1069         for (s = tmpstr->str_ptr; *s && *s != '\n'; s++)
1070            *s += (char)128;
1071         str_scat(str,tmpstr);
1072         str_free(tmpstr);
1073         tab(str,level);
1074         break;
1075     case OCOMMA:
1076         prec = P_COMMA;
1077         str = walk(1,level,ops[node+1].ival,&numarg,prec);
1078         str_cat(str,", ");
1079         str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg,P_MIN));
1080         str_free(fstr);
1081         str_scat(str,fstr=walk(1,level,ops[node+3].ival,&numarg,prec+1));
1082         str_free(fstr);
1083         break;
1084     case OSEMICOLON:
1085         str = str_new(1);
1086         str_set(str,";\n");
1087         tab(str,level);
1088         break;
1089     case OSTATES:
1090         str = walk(0,level,ops[node+1].ival,&numarg,P_MIN);
1091         str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg,P_MIN));
1092         str_free(fstr);
1093         break;
1094     case OSTATE:
1095         str = str_new(0);
1096         if (len >= 1) {
1097             str_scat(str,fstr=walk(0,level,ops[node+1].ival,&numarg,P_MIN));
1098             str_free(fstr);
1099             if (len >= 2) {
1100                 tmpstr = walk(0,level,ops[node+2].ival,&numarg,P_MIN);
1101                 if (*tmpstr->str_ptr == ';') {
1102                     addsemi(str);
1103                     str_cat(str,tmpstr->str_ptr+1);
1104                 }
1105                 str_free(tmpstr);
1106             }
1107         }
1108         break;
1109     case OCLOSE:
1110         str = str_make("close(");
1111         tmpstr = walk(1,level,ops[node+1].ival,&numarg,P_MIN);
1112         if (!do_fancy_opens) {
1113             t = tmpstr->str_ptr;
1114             if (*t == '"' || *t == '\'')
1115                 t = cpytill(tokenbuf,t+1,*t);
1116             else
1117                 fatal("Internal error: OCLOSE %s",t);
1118             s = savestr(tokenbuf);
1119             for (t = tokenbuf; *t; t++) {
1120                 *t &= 127;
1121                 if (isLOWER(*t))
1122                     *t = toUPPER(*t);
1123                 if (!isALPHA(*t) && !isDIGIT(*t))
1124                     *t = '_';
1125             }
1126             if (!strchr(tokenbuf,'_'))
1127                 strcpy(t,"_FH");
1128             str_free(tmpstr);
1129             safefree(s);
1130             str_set(str,"close ");
1131             str_cat(str,tokenbuf);
1132         }
1133         else {
1134             sprintf(tokenbuf,"delete $opened{%s} && close(%s)",
1135                tmpstr->str_ptr, tmpstr->str_ptr);
1136             str_free(tmpstr);
1137             str_set(str,tokenbuf);
1138         }
1139         break;
1140     case OPRINTF:
1141     case OPRINT:
1142         lparen = "";    /* set to parens if necessary */
1143         rparen = "";
1144         str = str_new(0);
1145         if (len == 3) {         /* output redirection */
1146             tmpstr = walk(1,level,ops[node+3].ival,&numarg,P_MIN);
1147             tmp2str = walk(1,level,ops[node+2].ival,&numarg,P_MIN);
1148             if (!do_fancy_opens) {
1149                 t = tmpstr->str_ptr;
1150                 if (*t == '"' || *t == '\'')
1151                     t = cpytill(tokenbuf,t+1,*t);
1152                 else
1153                     fatal("Internal error: OPRINT");
1154                 d = savestr(t);
1155                 s = savestr(tokenbuf);
1156                 for (t = tokenbuf; *t; t++) {
1157                     *t &= 127;
1158                     if (isLOWER(*t))
1159                         *t = toUPPER(*t);
1160                     if (!isALPHA(*t) && !isDIGIT(*t))
1161                         *t = '_';
1162                 }
1163                 if (!strchr(tokenbuf,'_'))
1164                     strcpy(t,"_FH");
1165                 tmp3str = hfetch(symtab,tokenbuf);
1166                 if (!tmp3str) {
1167                     str_cat(opens,"open(");
1168                     str_cat(opens,tokenbuf);
1169                     str_cat(opens,", ");
1170                     d[1] = '\0';
1171                     str_cat(opens,d);
1172                     str_scat(opens,tmp2str);
1173                     str_cat(opens,tmpstr->str_ptr+1);
1174                     if (*tmp2str->str_ptr == '|')
1175                         str_cat(opens,") || die 'Cannot pipe to \"");
1176                     else
1177                         str_cat(opens,") || die 'Cannot create file \"");
1178                     if (*d == '"')
1179                         str_cat(opens,"'.\"");
1180                     str_cat(opens,s);
1181                     if (*d == '"')
1182                         str_cat(opens,"\".'");
1183                     str_cat(opens,"\".';\n");
1184                     hstore(symtab,tokenbuf,str_make("x"));
1185                 }
1186                 str_free(tmpstr);
1187                 str_free(tmp2str);
1188                 safefree(s);
1189                 safefree(d);
1190             }
1191             else {
1192                 sprintf(tokenbuf,"&Pick('%s', %s) &&\n",
1193                    tmp2str->str_ptr, tmpstr->str_ptr);
1194                 str_cat(str,tokenbuf);
1195                 tab(str,level+1);
1196                 strcpy(tokenbuf,"$fh");
1197                 str_free(tmpstr);
1198                 str_free(tmp2str);
1199                 lparen = "(";
1200                 rparen = ")";
1201             }
1202         }
1203         else
1204             strcpy(tokenbuf,"");
1205         str_cat(str,lparen);    /* may be null */
1206         if (type == OPRINTF)
1207             str_cat(str,"printf");
1208         else
1209             str_cat(str,"print");
1210         saw_fh = 0;
1211         if (len == 3 || do_fancy_opens) {
1212             if (*tokenbuf) {
1213                 str_cat(str," ");
1214                 saw_fh = 1;
1215             }
1216             str_cat(str,tokenbuf);
1217         }
1218         tmpstr = walk(1+(type==OPRINT),level,ops[node+1].ival,&numarg,P_MIN);
1219         if (!*tmpstr->str_ptr && lval_field) {
1220             t = (char*)(saw_OFS ? "$," : "' '");
1221             if (split_to_array) {
1222                 sprintf(tokenbuf,"join(%s,@Fld)",t);
1223                 str_cat(tmpstr,tokenbuf);
1224             }
1225             else {
1226                 for (i = 1; i < maxfld; i++) {
1227                     if (i <= arymax)
1228                         sprintf(tokenbuf,"$%s, ",nameary[i]);
1229                     else
1230                         sprintf(tokenbuf,"$Fld%d, ",i);
1231                     str_cat(tmpstr,tokenbuf);
1232                 }
1233                 if (maxfld <= arymax)
1234                     sprintf(tokenbuf,"$%s",nameary[maxfld]);
1235                 else
1236                     sprintf(tokenbuf,"$Fld%d",maxfld);
1237                 str_cat(tmpstr,tokenbuf);
1238             }
1239         }
1240         if (*tmpstr->str_ptr) {
1241             str_cat(str," ");
1242             if (!saw_fh && *tmpstr->str_ptr == '(') {
1243                 str_cat(str,"(");
1244                 str_scat(str,tmpstr);
1245                 str_cat(str,")");
1246             }
1247             else
1248                 str_scat(str,tmpstr);
1249         }
1250         else {
1251             str_cat(str," $_");
1252         }
1253         str_cat(str,rparen);    /* may be null */
1254         str_free(tmpstr);
1255         break;
1256     case ORAND:
1257         str = str_make("rand(1)");
1258         break;
1259     case OSRAND:
1260         str = str_make("srand(");
1261         goto maybe0;
1262     case OATAN2:
1263         str = str_make("atan2(");
1264         goto maybe0;
1265     case OSIN:
1266         str = str_make("sin(");
1267         goto maybe0;
1268     case OCOS:
1269         str = str_make("cos(");
1270         goto maybe0;
1271     case OSYSTEM:
1272         str = str_make("system(");
1273         goto maybe0;
1274     case OLENGTH:
1275         str = str_make("length(");
1276         goto maybe0;
1277     case OLOG:
1278         str = str_make("log(");
1279         goto maybe0;
1280     case OEXP:
1281         str = str_make("exp(");
1282         goto maybe0;
1283     case OSQRT:
1284         str = str_make("sqrt(");
1285         goto maybe0;
1286     case OINT:
1287         str = str_make("int(");
1288       maybe0:
1289         numeric = 1;
1290         if (len > 0)
1291             tmpstr = walk(1,level,ops[node+1].ival,&numarg,P_MIN);
1292         else
1293             tmpstr = str_new(0);
1294         if (!tmpstr->str_ptr || !*tmpstr->str_ptr) {
1295             if (lval_field) {
1296                 t = (char*)(saw_OFS ? "$," : "' '");
1297                 if (split_to_array) {
1298                     sprintf(tokenbuf,"join(%s,@Fld)",t);
1299                     str_cat(tmpstr,tokenbuf);
1300                 }
1301                 else {
1302                     sprintf(tokenbuf,"join(%s, ",t);
1303                     str_cat(tmpstr,tokenbuf);
1304                     for (i = 1; i < maxfld; i++) {
1305                         if (i <= arymax)
1306                             sprintf(tokenbuf,"$%s,",nameary[i]);
1307                         else
1308                             sprintf(tokenbuf,"$Fld%d,",i);
1309                         str_cat(tmpstr,tokenbuf);
1310                     }
1311                     if (maxfld <= arymax)
1312                         sprintf(tokenbuf,"$%s)",nameary[maxfld]);
1313                     else
1314                         sprintf(tokenbuf,"$Fld%d)",maxfld);
1315                     str_cat(tmpstr,tokenbuf);
1316                 }
1317             }
1318             else
1319                 str_cat(tmpstr,"$_");
1320         }
1321         if (strEQ(tmpstr->str_ptr,"$_")) {
1322             if (type == OLENGTH && !do_chop) {
1323                 str = str_make("(length(");
1324                 str_cat(tmpstr,") - 1");
1325             }
1326         }
1327         str_scat(str,tmpstr);
1328         str_free(tmpstr);
1329         str_cat(str,")");
1330         break;
1331     case OBREAK:
1332         str = str_new(0);
1333         str_set(str,"last");
1334         break;
1335     case ONEXT:
1336         str = str_new(0);
1337         str_set(str,"next line");
1338         break;
1339     case OEXIT:
1340         str = str_new(0);
1341         if (realexit) {
1342             prec = P_UNI;
1343             str_set(str,"exit");
1344             if (len == 1) {
1345                 str_cat(str," ");
1346                 exitval = TRUE;
1347                 str_scat(str,
1348                   fstr=walk(1,level,ops[node+1].ival,&numarg,prec+1));
1349                 str_free(fstr);
1350             }
1351         }
1352         else {
1353             if (len == 1) {
1354                 str_set(str,"$ExitValue = ");
1355                 exitval = TRUE;
1356                 str_scat(str,
1357                   fstr=walk(1,level,ops[node+1].ival,&numarg,P_ASSIGN));
1358                 str_free(fstr);
1359                 str_cat(str,"; ");
1360             }
1361             str_cat(str,"last line");
1362         }
1363         break;
1364     case OCONTINUE:
1365         str = str_new(0);
1366         str_set(str,"next");
1367         break;
1368     case OREDIR:
1369         goto def;
1370     case OIF:
1371         str = str_new(0);
1372         str_set(str,"if (");
1373         str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,P_MIN));
1374         str_free(fstr);
1375         str_cat(str,") ");
1376         str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg,P_MIN));
1377         str_free(fstr);
1378         if (len == 3) {
1379             i = ops[node+3].ival;
1380             if (i) {
1381                 if ((ops[i].ival & 255) == OBLOCK) {
1382                     i = ops[i+1].ival;
1383                     if (i) {
1384                         if ((ops[i].ival & 255) != OIF)
1385                             i = 0;
1386                     }
1387                 }
1388                 else
1389                     i = 0;
1390             }
1391             if (i) {
1392                 str_cat(str,"els");
1393                 str_scat(str,fstr=walk(0,level,i,&numarg,P_MIN));
1394                 str_free(fstr);
1395             }
1396             else {
1397                 str_cat(str,"else ");
1398                 str_scat(str,fstr=walk(0,level,ops[node+3].ival,&numarg,P_MIN));
1399                 str_free(fstr);
1400             }
1401         }
1402         break;
1403     case OWHILE:
1404         str = str_new(0);
1405         str_set(str,"while (");
1406         str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,P_MIN));
1407         str_free(fstr);
1408         str_cat(str,") ");
1409         str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg,P_MIN));
1410         str_free(fstr);
1411         break;
1412     case ODO:
1413         str = str_new(0);
1414         str_set(str,"do ");
1415         str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg,P_MIN));
1416         str_free(fstr);
1417         if (str->str_ptr[str->str_cur - 1] == '\n')
1418             --str->str_cur;
1419         str_cat(str," while (");
1420         str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg,P_MIN));
1421         str_free(fstr);
1422         str_cat(str,");");
1423         break;
1424     case OFOR:
1425         str = str_new(0);
1426         str_set(str,"for (");
1427         str_scat(str,tmpstr=walk(1,level,ops[node+1].ival,&numarg,P_MIN));
1428         i = numarg;
1429         if (i) {
1430             t = s = tmpstr->str_ptr;
1431             while (isALPHA(*t) || isDIGIT(*t) || *t == '$' || *t == '_')
1432                 t++;
1433             i = t - s;
1434             if (i < 2)
1435                 i = 0;
1436         }
1437         str_cat(str,"; ");
1438         fstr=walk(1,level,ops[node+2].ival,&numarg,P_MIN);
1439         if (i && (t = strchr(fstr->str_ptr,0377))) {
1440             if (strnEQ(fstr->str_ptr,s,i))
1441                 *t = ' ';
1442         }
1443         str_scat(str,fstr);
1444         str_free(fstr);
1445         str_free(tmpstr);
1446         str_cat(str,"; ");
1447         str_scat(str,fstr=walk(1,level,ops[node+3].ival,&numarg,P_MIN));
1448         str_free(fstr);
1449         str_cat(str,") ");
1450         str_scat(str,fstr=walk(0,level,ops[node+4].ival,&numarg,P_MIN));
1451         str_free(fstr);
1452         break;
1453     case OFORIN:
1454         tmpstr = walk(0,level,ops[node+1].ival,&numarg,P_MIN);
1455         d = strchr(tmpstr->str_ptr,'$');
1456         if (!d)
1457             fatal("Illegal for loop: %s",tmpstr->str_ptr);
1458         s = strchr(d,'{');
1459         if (!s)
1460             s = strchr(d,'[');
1461         if (!s)
1462             fatal("Illegal for loop: %s",d);
1463         *s++ = '\0';
1464         for (t = s; (i = *t); t++) {
1465             i &= 127;
1466             if (i == '}' || i == ']')
1467                 break;
1468         }
1469         if (*t)
1470             *t = '\0';
1471         str = str_new(0);
1472         str_set(str,d+1);
1473         str_cat(str,"[]");
1474         tmp2str = hfetch(symtab,str->str_ptr);
1475         if (tmp2str && atoi(tmp2str->str_ptr)) {
1476             sprintf(tokenbuf,
1477               "foreach %s ($[ .. $#%s) ",
1478               s,
1479               d+1);
1480         }
1481         else {
1482             sprintf(tokenbuf,
1483               "foreach %s (keys %%%s) ",
1484               s,
1485               d+1);
1486         }
1487         str_set(str,tokenbuf);
1488         str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg,P_MIN));
1489         str_free(fstr);
1490         str_free(tmpstr);
1491         break;
1492     case OBLOCK:
1493         str = str_new(0);
1494         str_set(str,"{");
1495         if (len >= 2 && ops[node+2].ival) {
1496             str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg,P_MIN));
1497             str_free(fstr);
1498         }
1499         fixtab(str,++level);
1500         str_scat(str,fstr=walk(0,level,ops[node+1].ival,&numarg,P_MIN));
1501         str_free(fstr);
1502         addsemi(str);
1503         fixtab(str,--level);
1504         str_cat(str,"}\n");
1505         tab(str,level);
1506         if (len >= 3) {
1507             str_scat(str,fstr=walk(0,level,ops[node+3].ival,&numarg,P_MIN));
1508             str_free(fstr);
1509         }
1510         break;
1511     default:
1512       def:
1513         if (len) {
1514             if (len > 5)
1515                 fatal("Garbage length in walk");
1516             str = walk(0,level,ops[node+1].ival,&numarg,P_MIN);
1517             for (i = 2; i<= len; i++) {
1518                 str_scat(str,fstr=walk(0,level,ops[node+i].ival,&numarg,P_MIN));
1519                 str_free(fstr);
1520             }
1521         }
1522         else {
1523             str = Nullstr;
1524         }
1525         break;
1526     }
1527     if (!str)
1528         str = str_new(0);
1529
1530     if (useval && prec < minprec) {             /* need parens? */
1531         fstr = str_new(str->str_cur+2);
1532         str_nset(fstr,"(",1);
1533         str_scat(fstr,str);
1534         str_ncat(fstr,")",1);
1535         str_free(str);
1536         str = fstr;
1537     }
1538
1539     *numericptr = numeric;
1540 #ifdef DEBUGGING
1541     if (debug & 4) {
1542         printf("%3d %5d %15s %d %4d ",level,node,opname[type],len,str->str_cur);
1543         for (t = str->str_ptr; *t && t - str->str_ptr < 40; t++)
1544             if (*t == '\n')
1545                 printf("\\n");
1546             else if (*t == '\t')
1547                 printf("\\t");
1548             else
1549                 putchar(*t);
1550         putchar('\n');
1551     }
1552 #endif
1553     return str;
1554 }
1555
1556 static void
1557 tab(register STR *str, register int lvl)
1558 {
1559     while (lvl > 1) {
1560         str_cat(str,"\t");
1561         lvl -= 2;
1562     }
1563     if (lvl)
1564         str_cat(str,"    ");
1565 }
1566
1567 static void
1568 fixtab(register STR *str, register int lvl)
1569 {
1570     register char *s;
1571
1572     /* strip trailing white space */
1573
1574     s = str->str_ptr+str->str_cur - 1;
1575     while (s >= str->str_ptr && (*s == ' ' || *s == '\t' || *s == '\n'))
1576         s--;
1577     s[1] = '\0';
1578     str->str_cur = s + 1 - str->str_ptr;
1579     if (s >= str->str_ptr && *s != '\n')
1580         str_cat(str,"\n");
1581
1582     tab(str,lvl);
1583 }
1584
1585 static void
1586 addsemi(register STR *str)
1587 {
1588     register char *s;
1589
1590     s = str->str_ptr+str->str_cur - 1;
1591     while (s >= str->str_ptr && (*s == ' ' || *s == '\t' || *s == '\n'))
1592         s--;
1593     if (s >= str->str_ptr && *s != ';' && *s != '}')
1594         str_cat(str,";");
1595 }
1596
1597 static void
1598 emit_split(register STR *str, int level)
1599 {
1600     register int i;
1601
1602     if (split_to_array)
1603         str_cat(str,"@Fld");
1604     else {
1605         str_cat(str,"(");
1606         for (i = 1; i < maxfld; i++) {
1607             if (i <= arymax)
1608                 sprintf(tokenbuf,"$%s,",nameary[i]);
1609             else
1610                 sprintf(tokenbuf,"$Fld%d,",i);
1611             str_cat(str,tokenbuf);
1612         }
1613         if (maxfld <= arymax)
1614             sprintf(tokenbuf,"$%s)",nameary[maxfld]);
1615         else
1616             sprintf(tokenbuf,"$Fld%d)",maxfld);
1617         str_cat(str,tokenbuf);
1618     }
1619     if (const_FS) {
1620         sprintf(tokenbuf," = split(/[%c\\n]/, $_, 9999);\n",const_FS);
1621         str_cat(str,tokenbuf);
1622     }
1623     else if (saw_FS)
1624         str_cat(str," = split($FS, $_, 9999);\n");
1625     else
1626         str_cat(str," = split(' ', $_, 9999);\n");
1627     tab(str,level);
1628 }
1629
1630 int
1631 prewalk(int numit, int level, register int node, int *numericptr)
1632 {
1633     register int len;
1634     register int type;
1635     register int i;
1636     int numarg;
1637     int numeric = FALSE;
1638     STR *tmpstr;
1639     STR *tmp2str;
1640
1641     if (!node) {
1642         *numericptr = 0;
1643         return 0;
1644     }
1645     type = ops[node].ival;
1646     len = type >> 8;
1647     type &= 255;
1648     switch (type) {
1649     case OPROG:
1650         prewalk(0,level,ops[node+1].ival,&numarg);
1651         if (ops[node+2].ival) {
1652             prewalk(0,level,ops[node+2].ival,&numarg);
1653         }
1654         ++level;
1655         prewalk(0,level,ops[node+3].ival,&numarg);
1656         --level;
1657         if (ops[node+3].ival) {
1658             prewalk(0,level,ops[node+4].ival,&numarg);
1659         }
1660         break;
1661     case OHUNKS:
1662         prewalk(0,level,ops[node+1].ival,&numarg);
1663         prewalk(0,level,ops[node+2].ival,&numarg);
1664         if (len == 3) {
1665             prewalk(0,level,ops[node+3].ival,&numarg);
1666         }
1667         break;
1668     case ORANGE:
1669         prewalk(1,level,ops[node+1].ival,&numarg);
1670         prewalk(1,level,ops[node+2].ival,&numarg);
1671         break;
1672     case OPAT:
1673         goto def;
1674     case OREGEX:
1675         prewalk(0,level,ops[node+1].ival,&numarg);
1676         break;
1677     case OHUNK:
1678         if (len == 1) {
1679             prewalk(0,level,ops[node+1].ival,&numarg);
1680         }
1681         else {
1682             i = prewalk(0,level,ops[node+1].ival,&numarg);
1683             if (i) {
1684                 ++level;
1685                 prewalk(0,level,ops[node+2].ival,&numarg);
1686                 --level;
1687             }
1688             else {
1689                 prewalk(0,level,ops[node+2].ival,&numarg);
1690             }
1691         }
1692         break;
1693     case OPPAREN:
1694         prewalk(0,level,ops[node+1].ival,&numarg);
1695         break;
1696     case OPANDAND:
1697         prewalk(0,level,ops[node+1].ival,&numarg);
1698         prewalk(0,level,ops[node+2].ival,&numarg);
1699         break;
1700     case OPOROR:
1701         prewalk(0,level,ops[node+1].ival,&numarg);
1702         prewalk(0,level,ops[node+2].ival,&numarg);
1703         break;
1704     case OPNOT:
1705         prewalk(0,level,ops[node+1].ival,&numarg);
1706         break;
1707     case OCPAREN:
1708         prewalk(0,level,ops[node+1].ival,&numarg);
1709         numeric |= numarg;
1710         break;
1711     case OCANDAND:
1712         prewalk(0,level,ops[node+1].ival,&numarg);
1713         numeric = 1;
1714         prewalk(0,level,ops[node+2].ival,&numarg);
1715         break;
1716     case OCOROR:
1717         prewalk(0,level,ops[node+1].ival,&numarg);
1718         numeric = 1;
1719         prewalk(0,level,ops[node+2].ival,&numarg);
1720         break;
1721     case OCNOT:
1722         prewalk(0,level,ops[node+1].ival,&numarg);
1723         numeric = 1;
1724         break;
1725     case ORELOP:
1726         prewalk(0,level,ops[node+2].ival,&numarg);
1727         numeric |= numarg;
1728         prewalk(0,level,ops[node+1].ival,&numarg);
1729         prewalk(0,level,ops[node+3].ival,&numarg);
1730         numeric |= numarg;
1731         numeric = 1;
1732         break;
1733     case ORPAREN:
1734         prewalk(0,level,ops[node+1].ival,&numarg);
1735         numeric |= numarg;
1736         break;
1737     case OMATCHOP:
1738         prewalk(0,level,ops[node+2].ival,&numarg);
1739         prewalk(0,level,ops[node+1].ival,&numarg);
1740         prewalk(0,level,ops[node+3].ival,&numarg);
1741         numeric = 1;
1742         break;
1743     case OMPAREN:
1744         prewalk(0,level,ops[node+1].ival,&numarg);
1745         numeric |= numarg;
1746         break;
1747     case OCONCAT:
1748         prewalk(0,level,ops[node+1].ival,&numarg);
1749         prewalk(0,level,ops[node+2].ival,&numarg);
1750         break;
1751     case OASSIGN:
1752         prewalk(0,level,ops[node+2].ival,&numarg);
1753         prewalk(0,level,ops[node+1].ival,&numarg);
1754         prewalk(0,level,ops[node+3].ival,&numarg);
1755         if (numarg || strlen(ops[ops[node+1].ival+1].cval) > (Size_t)1) {
1756             numericize(ops[node+2].ival);
1757             if (!numarg)
1758                 numericize(ops[node+3].ival);
1759         }
1760         numeric |= numarg;
1761         break;
1762     case OADD:
1763         prewalk(1,level,ops[node+1].ival,&numarg);
1764         prewalk(1,level,ops[node+2].ival,&numarg);
1765         numeric = 1;
1766         break;
1767     case OSUBTRACT:
1768         prewalk(1,level,ops[node+1].ival,&numarg);
1769         prewalk(1,level,ops[node+2].ival,&numarg);
1770         numeric = 1;
1771         break;
1772     case OMULT:
1773         prewalk(1,level,ops[node+1].ival,&numarg);
1774         prewalk(1,level,ops[node+2].ival,&numarg);
1775         numeric = 1;
1776         break;
1777     case ODIV:
1778         prewalk(1,level,ops[node+1].ival,&numarg);
1779         prewalk(1,level,ops[node+2].ival,&numarg);
1780         numeric = 1;
1781         break;
1782     case OPOW:
1783         prewalk(1,level,ops[node+1].ival,&numarg);
1784         prewalk(1,level,ops[node+2].ival,&numarg);
1785         numeric = 1;
1786         break;
1787     case OMOD:
1788         prewalk(1,level,ops[node+1].ival,&numarg);
1789         prewalk(1,level,ops[node+2].ival,&numarg);
1790         numeric = 1;
1791         break;
1792     case OPOSTINCR:
1793         prewalk(1,level,ops[node+1].ival,&numarg);
1794         numeric = 1;
1795         break;
1796     case OPOSTDECR:
1797         prewalk(1,level,ops[node+1].ival,&numarg);
1798         numeric = 1;
1799         break;
1800     case OPREINCR:
1801         prewalk(1,level,ops[node+1].ival,&numarg);
1802         numeric = 1;
1803         break;
1804     case OPREDECR:
1805         prewalk(1,level,ops[node+1].ival,&numarg);
1806         numeric = 1;
1807         break;
1808     case OUMINUS:
1809         prewalk(1,level,ops[node+1].ival,&numarg);
1810         numeric = 1;
1811         break;
1812     case OUPLUS:
1813         prewalk(1,level,ops[node+1].ival,&numarg);
1814         numeric = 1;
1815         break;
1816     case OPAREN:
1817         prewalk(0,level,ops[node+1].ival,&numarg);
1818         numeric |= numarg;
1819         break;
1820     case OGETLINE:
1821         break;
1822     case OSPRINTF:
1823         prewalk(0,level,ops[node+1].ival,&numarg);
1824         break;
1825     case OSUBSTR:
1826         prewalk(0,level,ops[node+1].ival,&numarg);
1827         prewalk(1,level,ops[node+2].ival,&numarg);
1828         if (len == 3) {
1829             prewalk(1,level,ops[node+3].ival,&numarg);
1830         }
1831         break;
1832     case OSTRING:
1833         break;
1834     case OSPLIT:
1835         numeric = 1;
1836         prewalk(0,level,ops[node+2].ival,&numarg);
1837         if (len == 3)
1838             prewalk(0,level,ops[node+3].ival,&numarg);
1839         prewalk(0,level,ops[node+1].ival,&numarg);
1840         break;
1841     case OINDEX:
1842         prewalk(0,level,ops[node+1].ival,&numarg);
1843         prewalk(0,level,ops[node+2].ival,&numarg);
1844         numeric = 1;
1845         break;
1846     case OMATCH:
1847         prewalk(0,level,ops[node+1].ival,&numarg);
1848         prewalk(0,level,ops[node+2].ival,&numarg);
1849         numeric = 1;
1850         break;
1851     case OUSERDEF:
1852         subretnum = FALSE;
1853         --level;
1854         tmpstr = walk(0,level,ops[node+1].ival,&numarg,P_MIN);
1855         ++level;
1856         prewalk(0,level,ops[node+2].ival,&numarg);
1857         prewalk(0,level,ops[node+4].ival,&numarg);
1858         prewalk(0,level,ops[node+5].ival,&numarg);
1859         --level;
1860         str_cat(tmpstr,"(");
1861         tmp2str = str_new(0);
1862         if (subretnum || numarg)
1863             str_set(tmp2str,"1");
1864         hstore(symtab,tmpstr->str_ptr,tmp2str);
1865         str_free(tmpstr);
1866         level++;
1867         break;
1868     case ORETURN:
1869         if (len > 0) {
1870             prewalk(0,level,ops[node+1].ival,&numarg);
1871             if (numarg)
1872                 subretnum = TRUE;
1873         }
1874         break;
1875     case OUSERFUN:
1876         tmp2str = str_new(0);
1877         str_scat(tmp2str,tmpstr=walk(1,level,ops[node+1].ival,&numarg,P_MIN));
1878         fixrargs(tmpstr->str_ptr,ops[node+2].ival,0);
1879         str_free(tmpstr);
1880         str_cat(tmp2str,"(");
1881         tmpstr = hfetch(symtab,tmp2str->str_ptr);
1882         if (tmpstr && tmpstr->str_ptr)
1883             numeric |= atoi(tmpstr->str_ptr);
1884         prewalk(0,level,ops[node+2].ival,&numarg);
1885         str_free(tmp2str);
1886         break;
1887     case OGSUB:
1888     case OSUB:
1889         if (len >= 3)
1890             prewalk(0,level,ops[node+3].ival,&numarg);
1891         prewalk(0,level,ops[ops[node+2].ival+1].ival,&numarg);
1892         prewalk(0,level,ops[node+1].ival,&numarg);
1893         numeric = 1;
1894         break;
1895     case ONUM:
1896         prewalk(0,level,ops[node+1].ival,&numarg);
1897         numeric = 1;
1898         break;
1899     case OSTR:
1900         prewalk(0,level,ops[node+1].ival,&numarg);
1901         break;
1902     case ODEFINED:
1903     case ODELETE:
1904     case OSTAR:
1905     case OVAR:
1906         prewalk(0,level,ops[node+1].ival,&numarg);
1907         if (len == 1) {
1908             if (numit)
1909                 numericize(node);
1910         }
1911         else {
1912             prewalk(0,level,ops[node+2].ival,&numarg);
1913         }
1914         break;
1915     case OFLD:
1916         prewalk(0,level,ops[node+1].ival,&numarg);
1917         break;
1918     case OVFLD:
1919         i = ops[node+1].ival;
1920         prewalk(0,level,i,&numarg);
1921         break;
1922     case OJUNK:
1923         goto def;
1924     case OSNEWLINE:
1925         break;
1926     case ONEWLINE:
1927         break;
1928     case OSCOMMENT:
1929         break;
1930     case OCOMMENT:
1931         break;
1932     case OCOMMA:
1933         prewalk(0,level,ops[node+1].ival,&numarg);
1934         prewalk(0,level,ops[node+2].ival,&numarg);
1935         prewalk(0,level,ops[node+3].ival,&numarg);
1936         break;
1937     case OSEMICOLON:
1938         break;
1939     case OSTATES:
1940         prewalk(0,level,ops[node+1].ival,&numarg);
1941         prewalk(0,level,ops[node+2].ival,&numarg);
1942         break;
1943     case OSTATE:
1944         if (len >= 1) {
1945             prewalk(0,level,ops[node+1].ival,&numarg);
1946             if (len >= 2) {
1947                 prewalk(0,level,ops[node+2].ival,&numarg);
1948             }
1949         }
1950         break;
1951     case OCLOSE:
1952         prewalk(0,level,ops[node+1].ival,&numarg);
1953         break;
1954     case OPRINTF:
1955     case OPRINT:
1956         if (len == 3) {         /* output redirection */
1957             prewalk(0,level,ops[node+3].ival,&numarg);
1958             prewalk(0,level,ops[node+2].ival,&numarg);
1959         }
1960         prewalk(0+(type==OPRINT),level,ops[node+1].ival,&numarg);
1961         break;
1962     case ORAND:
1963         break;
1964     case OSRAND:
1965         goto maybe0;
1966     case OATAN2:
1967         goto maybe0;
1968     case OSIN:
1969         goto maybe0;
1970     case OCOS:
1971         goto maybe0;
1972     case OSYSTEM:
1973         goto maybe0;
1974     case OLENGTH:
1975         goto maybe0;
1976     case OLOG:
1977         goto maybe0;
1978     case OEXP:
1979         goto maybe0;
1980     case OSQRT:
1981         goto maybe0;
1982     case OINT:
1983       maybe0:
1984         numeric = 1;
1985         if (len > 0)
1986             prewalk(type != OLENGTH && type != OSYSTEM,
1987               level,ops[node+1].ival,&numarg);
1988         break;
1989     case OBREAK:
1990         break;
1991     case ONEXT:
1992         break;
1993     case OEXIT:
1994         if (len == 1) {
1995             prewalk(1,level,ops[node+1].ival,&numarg);
1996         }
1997         break;
1998     case OCONTINUE:
1999         break;
2000     case OREDIR:
2001         goto def;
2002     case OIF:
2003         prewalk(0,level,ops[node+1].ival,&numarg);
2004         prewalk(0,level,ops[node+2].ival,&numarg);
2005         if (len == 3) {
2006             prewalk(0,level,ops[node+3].ival,&numarg);
2007         }
2008         break;
2009     case OWHILE:
2010         prewalk(0,level,ops[node+1].ival,&numarg);
2011         prewalk(0,level,ops[node+2].ival,&numarg);
2012         break;
2013     case OFOR:
2014         prewalk(0,level,ops[node+1].ival,&numarg);
2015         prewalk(0,level,ops[node+2].ival,&numarg);
2016         prewalk(0,level,ops[node+3].ival,&numarg);
2017         prewalk(0,level,ops[node+4].ival,&numarg);
2018         break;
2019     case OFORIN:
2020         prewalk(0,level,ops[node+2].ival,&numarg);
2021         prewalk(0,level,ops[node+1].ival,&numarg);
2022         break;
2023     case OBLOCK:
2024         if (len == 2) {
2025             prewalk(0,level,ops[node+2].ival,&numarg);
2026         }
2027         ++level;
2028         prewalk(0,level,ops[node+1].ival,&numarg);
2029         --level;
2030         break;
2031     default:
2032       def:
2033         if (len) {
2034             if (len > 5)
2035                 fatal("Garbage length in prewalk");
2036             prewalk(0,level,ops[node+1].ival,&numarg);
2037             for (i = 2; i<= len; i++) {
2038                 prewalk(0,level,ops[node+i].ival,&numarg);
2039             }
2040         }
2041         break;
2042     }
2043     *numericptr = numeric;
2044     return 1;
2045 }
2046
2047 static void
2048 numericize(register int node)
2049 {
2050     register int len;
2051     register int type;
2052     STR *tmpstr;
2053     STR *tmp2str;
2054     int numarg;
2055
2056     type = ops[node].ival;
2057     len = type >> 8;
2058     type &= 255;
2059     if (type == OVAR && len == 1) {
2060         tmpstr=walk(0,0,ops[node+1].ival,&numarg,P_MIN);
2061         tmp2str = str_make("1");
2062         hstore(symtab,tmpstr->str_ptr,tmp2str);
2063     }
2064 }