1: /* $Header: walk.c,v 1.0 87/12/18 13:07:40 root Exp $ 2: * 3: * $Log: walk.c,v $ 4: * Revision 1.0 87/12/18 13:07:40 root 5: * Initial revision 6: * 7: */ 8: 9: #include "handy.h" 10: #include "EXTERN.h" 11: #include "util.h" 12: #include "a2p.h" 13: 14: bool exitval = FALSE; 15: bool realexit = FALSE; 16: int maxtmp = 0; 17: 18: STR * 19: walk(useval,level,node,numericptr) 20: int useval; 21: int level; 22: register int node; 23: int *numericptr; 24: { 25: register int len; 26: register STR *str; 27: register int type; 28: register int i; 29: register STR *tmpstr; 30: STR *tmp2str; 31: char *t; 32: char *d, *s; 33: int numarg; 34: int numeric = FALSE; 35: STR *fstr; 36: char *index(); 37: 38: if (!node) { 39: *numericptr = 0; 40: return str_make(""); 41: } 42: type = ops[node].ival; 43: len = type >> 8; 44: type &= 255; 45: switch (type) { 46: case OPROG: 47: str = walk(0,level,ops[node+1].ival,&numarg); 48: opens = str_new(0); 49: if (do_split && need_entire && !absmaxfld) 50: split_to_array = TRUE; 51: if (do_split && split_to_array) 52: set_array_base = TRUE; 53: if (set_array_base) { 54: str_cat(str,"$[ = 1;\t\t\t# set array base to 1\n"); 55: } 56: if (fswitch && !const_FS) 57: const_FS = fswitch; 58: if (saw_FS > 1 || saw_RS) 59: const_FS = 0; 60: if (saw_ORS && need_entire) 61: do_chop = TRUE; 62: if (fswitch) { 63: str_cat(str,"$FS = '"); 64: if (index("*+?.[]()|^$\\",fswitch)) 65: str_cat(str,"\\"); 66: sprintf(tokenbuf,"%c",fswitch); 67: str_cat(str,tokenbuf); 68: str_cat(str,"';\t\t# field separator from -F switch\n"); 69: } 70: else if (saw_FS && !const_FS) { 71: str_cat(str,"$FS = '[ \\t\\n]+';\t\t# default field separator\n"); 72: } 73: if (saw_OFS) { 74: str_cat(str,"$, = ' ';\t\t# default output field separator\n"); 75: } 76: if (saw_ORS) { 77: str_cat(str,"$\\ = \"\\n\";\t\t# default output record separator\n"); 78: } 79: if (str->str_cur > 20) 80: str_cat(str,"\n"); 81: if (ops[node+2].ival) { 82: str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg)); 83: str_free(fstr); 84: str_cat(str,"\n\n"); 85: } 86: if (saw_line_op) 87: str_cat(str,"line: "); 88: str_cat(str,"while (<>) {\n"); 89: tab(str,++level); 90: if (saw_FS && !const_FS) 91: do_chop = TRUE; 92: if (do_chop) { 93: str_cat(str,"chop;\t# strip record separator\n"); 94: tab(str,level); 95: } 96: arymax = 0; 97: if (namelist) { 98: while (isalpha(*namelist)) { 99: for (d = tokenbuf,s=namelist; 100: isalpha(*s) || isdigit(*s) || *s == '_'; 101: *d++ = *s++) ; 102: *d = '\0'; 103: while (*s && !isalpha(*s)) s++; 104: namelist = s; 105: nameary[++arymax] = savestr(tokenbuf); 106: } 107: } 108: if (maxfld < arymax) 109: maxfld = arymax; 110: if (do_split) 111: emit_split(str,level); 112: str_scat(str,fstr=walk(0,level,ops[node+3].ival,&numarg)); 113: str_free(fstr); 114: fixtab(str,--level); 115: str_cat(str,"}\n"); 116: if (ops[node+4].ival) { 117: realexit = TRUE; 118: str_cat(str,"\n"); 119: tab(str,level); 120: str_scat(str,fstr=walk(0,level,ops[node+4].ival,&numarg)); 121: str_free(fstr); 122: str_cat(str,"\n"); 123: } 124: if (exitval) 125: str_cat(str,"exit ExitValue;\n"); 126: if (do_fancy_opens) { 127: str_cat(str,"\n\ 128: sub Pick {\n\ 129: ($name) = @_;\n\ 130: $fh = $opened{$name};\n\ 131: if (!$fh) {\n\ 132: $nextfh == 0 && open(fh_0,$name);\n\ 133: $nextfh == 1 && open(fh_1,$name);\n\ 134: $nextfh == 2 && open(fh_2,$name);\n\ 135: $nextfh == 3 && open(fh_3,$name);\n\ 136: $nextfh == 4 && open(fh_4,$name);\n\ 137: $nextfh == 5 && open(fh_5,$name);\n\ 138: $nextfh == 6 && open(fh_6,$name);\n\ 139: $nextfh == 7 && open(fh_7,$name);\n\ 140: $nextfh == 8 && open(fh_8,$name);\n\ 141: $nextfh == 9 && open(fh_9,$name);\n\ 142: $fh = $opened{$name} = 'fh_' . $nextfh++;\n\ 143: }\n\ 144: select($fh);\n\ 145: }\n\ 146: "); 147: } 148: break; 149: case OHUNKS: 150: str = walk(0,level,ops[node+1].ival,&numarg); 151: str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg)); 152: str_free(fstr); 153: if (len == 3) { 154: str_scat(str,fstr=walk(0,level,ops[node+3].ival,&numarg)); 155: str_free(fstr); 156: } 157: else { 158: } 159: break; 160: case ORANGE: 161: str = walk(1,level,ops[node+1].ival,&numarg); 162: str_cat(str," .. "); 163: str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg)); 164: str_free(fstr); 165: break; 166: case OPAT: 167: goto def; 168: case OREGEX: 169: str = str_new(0); 170: str_set(str,"/"); 171: tmpstr=walk(0,level,ops[node+1].ival,&numarg); 172: /* translate \nnn to [\nnn] */ 173: for (s = tmpstr->str_ptr, d = tokenbuf; *s; s++, d++) { 174: if (*s == '\\' && isdigit(s[1]) && isdigit(s[2]) && isdigit(s[3])) { 175: *d++ = '['; 176: *d++ = *s++; 177: *d++ = *s++; 178: *d++ = *s++; 179: *d++ = *s; 180: *d = ']'; 181: } 182: else 183: *d = *s; 184: } 185: *d = '\0'; 186: str_cat(str,tokenbuf); 187: str_free(tmpstr); 188: str_cat(str,"/"); 189: break; 190: case OHUNK: 191: if (len == 1) { 192: str = str_new(0); 193: str = walk(0,level,oper1(OPRINT,0),&numarg); 194: str_cat(str," if "); 195: str_scat(str,fstr=walk(0,level,ops[node+1].ival,&numarg)); 196: str_free(fstr); 197: str_cat(str,";"); 198: } 199: else { 200: tmpstr = walk(0,level,ops[node+1].ival,&numarg); 201: if (*tmpstr->str_ptr) { 202: str = str_new(0); 203: str_set(str,"if ("); 204: str_scat(str,tmpstr); 205: str_cat(str,") {\n"); 206: tab(str,++level); 207: str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg)); 208: str_free(fstr); 209: fixtab(str,--level); 210: str_cat(str,"}\n"); 211: tab(str,level); 212: } 213: else { 214: str = walk(0,level,ops[node+2].ival,&numarg); 215: } 216: } 217: break; 218: case OPPAREN: 219: str = str_new(0); 220: str_set(str,"("); 221: str_scat(str,fstr=walk(useval != 0,level,ops[node+1].ival,&numarg)); 222: str_free(fstr); 223: str_cat(str,")"); 224: break; 225: case OPANDAND: 226: str = walk(1,level,ops[node+1].ival,&numarg); 227: str_cat(str," && "); 228: str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg)); 229: str_free(fstr); 230: break; 231: case OPOROR: 232: str = walk(1,level,ops[node+1].ival,&numarg); 233: str_cat(str," || "); 234: str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg)); 235: str_free(fstr); 236: break; 237: case OPNOT: 238: str = str_new(0); 239: str_set(str,"!"); 240: str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg)); 241: str_free(fstr); 242: break; 243: case OCPAREN: 244: str = str_new(0); 245: str_set(str,"("); 246: str_scat(str,fstr=walk(useval != 0,level,ops[node+1].ival,&numarg)); 247: str_free(fstr); 248: numeric |= numarg; 249: str_cat(str,")"); 250: break; 251: case OCANDAND: 252: str = walk(1,level,ops[node+1].ival,&numarg); 253: numeric = 1; 254: str_cat(str," && "); 255: str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg)); 256: str_free(fstr); 257: break; 258: case OCOROR: 259: str = walk(1,level,ops[node+1].ival,&numarg); 260: numeric = 1; 261: str_cat(str," || "); 262: str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg)); 263: str_free(fstr); 264: break; 265: case OCNOT: 266: str = str_new(0); 267: str_set(str,"!"); 268: str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg)); 269: str_free(fstr); 270: numeric = 1; 271: break; 272: case ORELOP: 273: str = walk(1,level,ops[node+2].ival,&numarg); 274: numeric |= numarg; 275: tmpstr = walk(0,level,ops[node+1].ival,&numarg); 276: tmp2str = walk(1,level,ops[node+3].ival,&numarg); 277: numeric |= numarg; 278: if (!numeric) { 279: t = tmpstr->str_ptr; 280: if (strEQ(t,"==")) 281: str_set(tmpstr,"eq"); 282: else if (strEQ(t,"!=")) 283: str_set(tmpstr,"ne"); 284: else if (strEQ(t,"<")) 285: str_set(tmpstr,"lt"); 286: else if (strEQ(t,"<=")) 287: str_set(tmpstr,"le"); 288: else if (strEQ(t,">")) 289: str_set(tmpstr,"gt"); 290: else if (strEQ(t,">=")) 291: str_set(tmpstr,"ge"); 292: if (!index(tmpstr->str_ptr,'\'') && !index(tmpstr->str_ptr,'"') && 293: !index(tmp2str->str_ptr,'\'') && !index(tmp2str->str_ptr,'"') ) 294: numeric |= 2; 295: } 296: if (numeric & 2) { 297: if (numeric & 1) /* numeric is very good guess */ 298: str_cat(str," "); 299: else 300: str_cat(str,"\377"); 301: numeric = 1; 302: } 303: else 304: str_cat(str," "); 305: str_scat(str,tmpstr); 306: str_free(tmpstr); 307: str_cat(str," "); 308: str_scat(str,tmp2str); 309: str_free(tmp2str); 310: numeric = 1; 311: break; 312: case ORPAREN: 313: str = str_new(0); 314: str_set(str,"("); 315: str_scat(str,fstr=walk(useval != 0,level,ops[node+1].ival,&numarg)); 316: str_free(fstr); 317: numeric |= numarg; 318: str_cat(str,")"); 319: break; 320: case OMATCHOP: 321: str = walk(1,level,ops[node+2].ival,&numarg); 322: str_cat(str," "); 323: tmpstr = walk(0,level,ops[node+1].ival,&numarg); 324: if (strEQ(tmpstr->str_ptr,"~")) 325: str_cat(str,"=~"); 326: else { 327: str_scat(str,tmpstr); 328: str_free(tmpstr); 329: } 330: str_cat(str," "); 331: str_scat(str,fstr=walk(1,level,ops[node+3].ival,&numarg)); 332: str_free(fstr); 333: numeric = 1; 334: break; 335: case OMPAREN: 336: str = str_new(0); 337: str_set(str,"("); 338: str_scat(str,fstr=walk(useval != 0,level,ops[node+1].ival,&numarg)); 339: str_free(fstr); 340: numeric |= numarg; 341: str_cat(str,")"); 342: break; 343: case OCONCAT: 344: str = walk(1,level,ops[node+1].ival,&numarg); 345: str_cat(str," . "); 346: str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg)); 347: str_free(fstr); 348: break; 349: case OASSIGN: 350: str = walk(0,level,ops[node+2].ival,&numarg); 351: str_cat(str," "); 352: tmpstr = walk(0,level,ops[node+1].ival,&numarg); 353: str_scat(str,tmpstr); 354: if (str_len(tmpstr) > 1) 355: numeric = 1; 356: str_free(tmpstr); 357: str_cat(str," "); 358: str_scat(str,fstr=walk(1,level,ops[node+3].ival,&numarg)); 359: str_free(fstr); 360: numeric |= numarg; 361: if (strEQ(str->str_ptr,"$FS = '\240'")) 362: str_set(str,"$FS = '[\240\\n\\t]+'"); 363: break; 364: case OADD: 365: str = walk(1,level,ops[node+1].ival,&numarg); 366: str_cat(str," + "); 367: str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg)); 368: str_free(fstr); 369: numeric = 1; 370: break; 371: case OSUB: 372: str = walk(1,level,ops[node+1].ival,&numarg); 373: str_cat(str," - "); 374: str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg)); 375: str_free(fstr); 376: numeric = 1; 377: break; 378: case OMULT: 379: str = walk(1,level,ops[node+1].ival,&numarg); 380: str_cat(str," * "); 381: str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg)); 382: str_free(fstr); 383: numeric = 1; 384: break; 385: case ODIV: 386: str = walk(1,level,ops[node+1].ival,&numarg); 387: str_cat(str," / "); 388: str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg)); 389: str_free(fstr); 390: numeric = 1; 391: break; 392: case OMOD: 393: str = walk(1,level,ops[node+1].ival,&numarg); 394: str_cat(str," % "); 395: str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg)); 396: str_free(fstr); 397: numeric = 1; 398: break; 399: case OPOSTINCR: 400: str = walk(1,level,ops[node+1].ival,&numarg); 401: str_cat(str,"++"); 402: numeric = 1; 403: break; 404: case OPOSTDECR: 405: str = walk(1,level,ops[node+1].ival,&numarg); 406: str_cat(str,"--"); 407: numeric = 1; 408: break; 409: case OPREINCR: 410: str = str_new(0); 411: str_set(str,"++"); 412: str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg)); 413: str_free(fstr); 414: numeric = 1; 415: break; 416: case OPREDECR: 417: str = str_new(0); 418: str_set(str,"--"); 419: str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg)); 420: str_free(fstr); 421: numeric = 1; 422: break; 423: case OUMINUS: 424: str = str_new(0); 425: str_set(str,"-"); 426: str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg)); 427: str_free(fstr); 428: numeric = 1; 429: break; 430: case OUPLUS: 431: numeric = 1; 432: goto def; 433: case OPAREN: 434: str = str_new(0); 435: str_set(str,"("); 436: str_scat(str,fstr=walk(useval != 0,level,ops[node+1].ival,&numarg)); 437: str_free(fstr); 438: str_cat(str,")"); 439: numeric |= numarg; 440: break; 441: case OGETLINE: 442: str = str_new(0); 443: str_set(str,"$_ = <>;\n"); 444: tab(str,level); 445: if (do_chop) { 446: str_cat(str,"chop;\t# strip record separator\n"); 447: tab(str,level); 448: } 449: if (do_split) 450: emit_split(str,level); 451: break; 452: case OSPRINTF: 453: str = str_new(0); 454: str_set(str,"sprintf("); 455: str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg)); 456: str_free(fstr); 457: str_cat(str,")"); 458: break; 459: case OSUBSTR: 460: str = str_new(0); 461: str_set(str,"substr("); 462: str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg)); 463: str_free(fstr); 464: str_cat(str,", "); 465: str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg)); 466: str_free(fstr); 467: str_cat(str,", "); 468: if (len == 3) { 469: str_scat(str,fstr=walk(1,level,ops[node+3].ival,&numarg)); 470: str_free(fstr); 471: } 472: else 473: str_cat(str,"999999"); 474: str_cat(str,")"); 475: break; 476: case OSTRING: 477: str = str_new(0); 478: str_set(str,ops[node+1].cval); 479: break; 480: case OSPLIT: 481: str = str_new(0); 482: numeric = 1; 483: tmpstr = walk(1,level,ops[node+2].ival,&numarg); 484: if (useval) 485: str_set(str,"(@"); 486: else 487: str_set(str,"@"); 488: str_scat(str,tmpstr); 489: str_cat(str," = split("); 490: if (len == 3) { 491: fstr = walk(1,level,ops[node+3].ival,&numarg); 492: if (str_len(fstr) == 3 && *fstr->str_ptr == '\'') { 493: i = fstr->str_ptr[1] & 127; 494: if (index("*+?.[]()|^$\\",i)) 495: sprintf(tokenbuf,"/\\%c/",i); 496: else 497: sprintf(tokenbuf,"/%c/",i); 498: str_cat(str,tokenbuf); 499: } 500: else 501: str_scat(str,fstr); 502: str_free(fstr); 503: } 504: else if (const_FS) { 505: sprintf(tokenbuf,"/[%c\\n]/",const_FS); 506: str_cat(str,tokenbuf); 507: } 508: else if (saw_FS) 509: str_cat(str,"$FS"); 510: else 511: str_cat(str,"/[ \\t\\n]+/"); 512: str_cat(str,", "); 513: str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg)); 514: str_free(fstr); 515: str_cat(str,")"); 516: if (useval) { 517: str_cat(str,")"); 518: } 519: str_free(tmpstr); 520: break; 521: case OINDEX: 522: str = str_new(0); 523: str_set(str,"index("); 524: str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg)); 525: str_free(fstr); 526: str_cat(str,", "); 527: str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg)); 528: str_free(fstr); 529: str_cat(str,")"); 530: numeric = 1; 531: break; 532: case ONUM: 533: str = walk(1,level,ops[node+1].ival,&numarg); 534: numeric = 1; 535: break; 536: case OSTR: 537: tmpstr = walk(1,level,ops[node+1].ival,&numarg); 538: s = "'"; 539: for (t = tmpstr->str_ptr; *t; t++) { 540: if (*t == '\\' || *t == '\'') 541: s = "\""; 542: *t += 128; 543: } 544: str = str_new(0); 545: str_set(str,s); 546: str_scat(str,tmpstr); 547: str_free(tmpstr); 548: str_cat(str,s); 549: break; 550: case OVAR: 551: str = str_new(0); 552: str_set(str,"$"); 553: str_scat(str,tmpstr=walk(1,level,ops[node+1].ival,&numarg)); 554: if (len == 1) { 555: tmp2str = hfetch(symtab,tmpstr->str_ptr); 556: if (tmp2str && atoi(tmp2str->str_ptr)) 557: numeric = 2; 558: if (strEQ(str->str_ptr,"$NR")) { 559: numeric = 1; 560: str_set(str,"$."); 561: } 562: else if (strEQ(str->str_ptr,"$NF")) { 563: numeric = 1; 564: str_set(str,"$#Fld"); 565: } 566: else if (strEQ(str->str_ptr,"$0")) 567: str_set(str,"$_"); 568: } 569: else { 570: str_cat(tmpstr,"[]"); 571: tmp2str = hfetch(symtab,tmpstr->str_ptr); 572: if (tmp2str && atoi(tmp2str->str_ptr)) 573: str_cat(str,"["); 574: else 575: str_cat(str,"{"); 576: str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg)); 577: str_free(fstr); 578: if (tmp2str && atoi(tmp2str->str_ptr)) 579: strcpy(tokenbuf,"]"); 580: else 581: strcpy(tokenbuf,"}"); 582: *tokenbuf += 128; 583: str_cat(str,tokenbuf); 584: } 585: str_free(tmpstr); 586: break; 587: case OFLD: 588: str = str_new(0); 589: if (split_to_array) { 590: str_set(str,"$Fld"); 591: str_cat(str,"["); 592: str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg)); 593: str_free(fstr); 594: str_cat(str,"]"); 595: } 596: else { 597: i = atoi(walk(1,level,ops[node+1].ival,&numarg)->str_ptr); 598: if (i <= arymax) 599: sprintf(tokenbuf,"$%s",nameary[i]); 600: else 601: sprintf(tokenbuf,"$Fld%d",i); 602: str_set(str,tokenbuf); 603: } 604: break; 605: case OVFLD: 606: str = str_new(0); 607: str_set(str,"$Fld["); 608: i = ops[node+1].ival; 609: if ((ops[i].ival & 255) == OPAREN) 610: i = ops[i+1].ival; 611: tmpstr=walk(1,level,i,&numarg); 612: str_scat(str,tmpstr); 613: str_free(tmpstr); 614: str_cat(str,"]"); 615: break; 616: case OJUNK: 617: goto def; 618: case OSNEWLINE: 619: str = str_new(2); 620: str_set(str,";\n"); 621: tab(str,level); 622: break; 623: case ONEWLINE: 624: str = str_new(1); 625: str_set(str,"\n"); 626: tab(str,level); 627: break; 628: case OSCOMMENT: 629: str = str_new(0); 630: str_set(str,";"); 631: tmpstr = walk(0,level,ops[node+1].ival,&numarg); 632: for (s = tmpstr->str_ptr; *s && *s != '\n'; s++) 633: *s += 128; 634: str_scat(str,tmpstr); 635: str_free(tmpstr); 636: tab(str,level); 637: break; 638: case OCOMMENT: 639: str = str_new(0); 640: tmpstr = walk(0,level,ops[node+1].ival,&numarg); 641: for (s = tmpstr->str_ptr; *s && *s != '\n'; s++) 642: *s += 128; 643: str_scat(str,tmpstr); 644: str_free(tmpstr); 645: tab(str,level); 646: break; 647: case OCOMMA: 648: str = walk(1,level,ops[node+1].ival,&numarg); 649: str_cat(str,", "); 650: str_scat(str,fstr=walk(1,level,ops[node+2].ival,&numarg)); 651: str_free(fstr); 652: break; 653: case OSEMICOLON: 654: str = str_new(1); 655: str_set(str,"; "); 656: break; 657: case OSTATES: 658: str = walk(0,level,ops[node+1].ival,&numarg); 659: str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg)); 660: str_free(fstr); 661: break; 662: case OSTATE: 663: str = str_new(0); 664: if (len >= 1) { 665: str_scat(str,fstr=walk(0,level,ops[node+1].ival,&numarg)); 666: str_free(fstr); 667: if (len >= 2) { 668: tmpstr = walk(0,level,ops[node+2].ival,&numarg); 669: if (*tmpstr->str_ptr == ';') { 670: addsemi(str); 671: str_cat(str,tmpstr->str_ptr+1); 672: } 673: str_free(tmpstr); 674: } 675: } 676: break; 677: case OPRINTF: 678: case OPRINT: 679: str = str_new(0); 680: if (len == 3) { /* output redirection */ 681: tmpstr = walk(1,level,ops[node+3].ival,&numarg); 682: tmp2str = walk(1,level,ops[node+2].ival,&numarg); 683: if (!do_fancy_opens) { 684: t = tmpstr->str_ptr; 685: if (*t == '"' || *t == '\'') 686: t = cpytill(tokenbuf,t+1,*t); 687: else 688: fatal("Internal error: OPRINT"); 689: d = savestr(t); 690: s = savestr(tokenbuf); 691: for (t = tokenbuf; *t; t++) { 692: *t &= 127; 693: if (!isalpha(*t) && !isdigit(*t)) 694: *t = '_'; 695: } 696: if (!index(tokenbuf,'_')) 697: strcpy(t,"_fh"); 698: str_cat(opens,"open("); 699: str_cat(opens,tokenbuf); 700: str_cat(opens,", "); 701: d[1] = '\0'; 702: str_cat(opens,d); 703: str_scat(opens,tmp2str); 704: str_cat(opens,tmpstr->str_ptr+1); 705: if (*tmp2str->str_ptr == '|') 706: str_cat(opens,") || die 'Cannot pipe to \""); 707: else 708: str_cat(opens,") || die 'Cannot create file \""); 709: if (*d == '"') 710: str_cat(opens,"'.\""); 711: str_cat(opens,s); 712: if (*d == '"') 713: str_cat(opens,"\".'"); 714: str_cat(opens,"\".';\n"); 715: str_free(tmpstr); 716: str_free(tmp2str); 717: safefree(s); 718: safefree(d); 719: } 720: else { 721: sprintf(tokenbuf,"do Pick('%s' . (%s)) &&\n", 722: tmp2str->str_ptr, tmpstr->str_ptr); 723: str_cat(str,tokenbuf); 724: tab(str,level+1); 725: *tokenbuf = '\0'; 726: str_free(tmpstr); 727: str_free(tmp2str); 728: } 729: } 730: else 731: strcpy(tokenbuf,"stdout"); 732: if (type == OPRINTF) 733: str_cat(str,"printf"); 734: else 735: str_cat(str,"print"); 736: if (len == 3 || do_fancy_opens) { 737: if (*tokenbuf) 738: str_cat(str," "); 739: str_cat(str,tokenbuf); 740: } 741: tmpstr = walk(1+(type==OPRINT),level,ops[node+1].ival,&numarg); 742: if (!*tmpstr->str_ptr && lval_field) { 743: t = saw_OFS ? "$," : "' '"; 744: if (split_to_array) { 745: sprintf(tokenbuf,"join(%s,@Fld)",t); 746: str_cat(tmpstr,tokenbuf); 747: } 748: else { 749: for (i = 1; i < maxfld; i++) { 750: if (i <= arymax) 751: sprintf(tokenbuf,"$%s, ",nameary[i]); 752: else 753: sprintf(tokenbuf,"$Fld%d, ",i); 754: str_cat(tmpstr,tokenbuf); 755: } 756: if (maxfld <= arymax) 757: sprintf(tokenbuf,"$%s",nameary[maxfld]); 758: else 759: sprintf(tokenbuf,"$Fld%d",maxfld); 760: str_cat(tmpstr,tokenbuf); 761: } 762: } 763: if (*tmpstr->str_ptr) { 764: str_cat(str," "); 765: str_scat(str,tmpstr); 766: } 767: else { 768: str_cat(str," $_"); 769: } 770: str_free(tmpstr); 771: break; 772: case OLENGTH: 773: str = str_make("length("); 774: goto maybe0; 775: case OLOG: 776: str = str_make("log("); 777: goto maybe0; 778: case OEXP: 779: str = str_make("exp("); 780: goto maybe0; 781: case OSQRT: 782: str = str_make("sqrt("); 783: goto maybe0; 784: case OINT: 785: str = str_make("int("); 786: maybe0: 787: numeric = 1; 788: if (len > 0) 789: tmpstr = walk(1,level,ops[node+1].ival,&numarg); 790: else 791: tmpstr = str_new(0);; 792: if (!*tmpstr->str_ptr) { 793: if (lval_field) { 794: t = saw_OFS ? "$," : "' '"; 795: if (split_to_array) { 796: sprintf(tokenbuf,"join(%s,@Fld)",t); 797: str_cat(tmpstr,tokenbuf); 798: } 799: else { 800: sprintf(tokenbuf,"join(%s, ",t); 801: str_cat(tmpstr,tokenbuf); 802: for (i = 1; i < maxfld; i++) { 803: if (i <= arymax) 804: sprintf(tokenbuf,"$%s,",nameary[i]); 805: else 806: sprintf(tokenbuf,"$Fld%d,",i); 807: str_cat(tmpstr,tokenbuf); 808: } 809: if (maxfld <= arymax) 810: sprintf(tokenbuf,"$%s)",nameary[maxfld]); 811: else 812: sprintf(tokenbuf,"$Fld%d)",maxfld); 813: str_cat(tmpstr,tokenbuf); 814: } 815: } 816: else 817: str_cat(tmpstr,"$_"); 818: } 819: if (strEQ(tmpstr->str_ptr,"$_")) { 820: if (type == OLENGTH && !do_chop) { 821: str = str_make("(length("); 822: str_cat(tmpstr,") - 1"); 823: } 824: } 825: str_scat(str,tmpstr); 826: str_free(tmpstr); 827: str_cat(str,")"); 828: break; 829: case OBREAK: 830: str = str_new(0); 831: str_set(str,"last"); 832: break; 833: case ONEXT: 834: str = str_new(0); 835: str_set(str,"next line"); 836: break; 837: case OEXIT: 838: str = str_new(0); 839: if (realexit) { 840: str_set(str,"exit"); 841: if (len == 1) { 842: str_cat(str," "); 843: exitval = TRUE; 844: str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg)); 845: str_free(fstr); 846: } 847: } 848: else { 849: if (len == 1) { 850: str_set(str,"ExitValue = "); 851: exitval = TRUE; 852: str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg)); 853: str_free(fstr); 854: str_cat(str,"; "); 855: } 856: str_cat(str,"last line"); 857: } 858: break; 859: case OCONTINUE: 860: str = str_new(0); 861: str_set(str,"next"); 862: break; 863: case OREDIR: 864: goto def; 865: case OIF: 866: str = str_new(0); 867: str_set(str,"if ("); 868: str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg)); 869: str_free(fstr); 870: str_cat(str,") "); 871: str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg)); 872: str_free(fstr); 873: if (len == 3) { 874: i = ops[node+3].ival; 875: if (i) { 876: if ((ops[i].ival & 255) == OBLOCK) { 877: i = ops[i+1].ival; 878: if (i) { 879: if ((ops[i].ival & 255) != OIF) 880: i = 0; 881: } 882: } 883: else 884: i = 0; 885: } 886: if (i) { 887: str_cat(str,"els"); 888: str_scat(str,fstr=walk(0,level,i,&numarg)); 889: str_free(fstr); 890: } 891: else { 892: str_cat(str,"else "); 893: str_scat(str,fstr=walk(0,level,ops[node+3].ival,&numarg)); 894: str_free(fstr); 895: } 896: } 897: break; 898: case OWHILE: 899: str = str_new(0); 900: str_set(str,"while ("); 901: str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg)); 902: str_free(fstr); 903: str_cat(str,") "); 904: str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg)); 905: str_free(fstr); 906: break; 907: case OFOR: 908: str = str_new(0); 909: str_set(str,"for ("); 910: str_scat(str,tmpstr=walk(1,level,ops[node+1].ival,&numarg)); 911: i = numarg; 912: if (i) { 913: t = s = tmpstr->str_ptr; 914: while (isalpha(*t) || isdigit(*t) || *t == '$' || *t == '_') 915: t++; 916: i = t - s; 917: if (i < 2) 918: i = 0; 919: } 920: str_cat(str,"; "); 921: fstr=walk(1,level,ops[node+2].ival,&numarg); 922: if (i && (t = index(fstr->str_ptr,0377))) { 923: if (strnEQ(fstr->str_ptr,s,i)) 924: *t = ' '; 925: } 926: str_scat(str,fstr); 927: str_free(fstr); 928: str_free(tmpstr); 929: str_cat(str,"; "); 930: str_scat(str,fstr=walk(1,level,ops[node+3].ival,&numarg)); 931: str_free(fstr); 932: str_cat(str,") "); 933: str_scat(str,fstr=walk(0,level,ops[node+4].ival,&numarg)); 934: str_free(fstr); 935: break; 936: case OFORIN: 937: tmpstr=walk(0,level,ops[node+2].ival,&numarg); 938: str = str_new(0); 939: str_sset(str,tmpstr); 940: str_cat(str,"[]"); 941: tmp2str = hfetch(symtab,str->str_ptr); 942: if (tmp2str && atoi(tmp2str->str_ptr)) { 943: maxtmp++; 944: fstr=walk(1,level,ops[node+1].ival,&numarg); 945: sprintf(tokenbuf, 946: "for ($T_%d = 1; ($%s = $%s[$T_%d]) || $T_%d <= $#%s; $T_%d++)%c", 947: maxtmp, 948: fstr->str_ptr, 949: tmpstr->str_ptr, 950: maxtmp, 951: maxtmp, 952: tmpstr->str_ptr, 953: maxtmp, 954: 0377); 955: str_set(str,tokenbuf); 956: str_free(fstr); 957: str_scat(str,fstr=walk(0,level,ops[node+3].ival,&numarg)); 958: str_free(fstr); 959: } 960: else { 961: str_set(str,"while (($junkkey,$"); 962: str_scat(str,fstr=walk(1,level,ops[node+1].ival,&numarg)); 963: str_free(fstr); 964: str_cat(str,") = each("); 965: str_scat(str,tmpstr); 966: str_cat(str,")) "); 967: str_scat(str,fstr=walk(0,level,ops[node+3].ival,&numarg)); 968: str_free(fstr); 969: } 970: str_free(tmpstr); 971: break; 972: case OBLOCK: 973: str = str_new(0); 974: str_set(str,"{"); 975: if (len == 2) { 976: str_scat(str,fstr=walk(0,level,ops[node+2].ival,&numarg)); 977: str_free(fstr); 978: } 979: fixtab(str,++level); 980: str_scat(str,fstr=walk(0,level,ops[node+1].ival,&numarg)); 981: str_free(fstr); 982: addsemi(str); 983: fixtab(str,--level); 984: str_cat(str,"}\n"); 985: tab(str,level); 986: break; 987: default: 988: def: 989: if (len) { 990: if (len > 5) 991: fatal("Garbage length in walk"); 992: str = walk(0,level,ops[node+1].ival,&numarg); 993: for (i = 2; i<= len; i++) { 994: str_scat(str,fstr=walk(0,level,ops[node+i].ival,&numarg)); 995: str_free(fstr); 996: } 997: } 998: else { 999: str = Nullstr; 1000: } 1001: break; 1002: } 1003: if (!str) 1004: str = str_new(0); 1005: *numericptr = numeric; 1006: #ifdef DEBUGGING 1007: if (debug & 4) { 1008: printf("%3d %5d %15s %d %4d ",level,node,opname[type],len,str->str_cur); 1009: for (t = str->str_ptr; *t && t - str->str_ptr < 40; t++) 1010: if (*t == '\n') 1011: printf("\\n"); 1012: else if (*t == '\t') 1013: printf("\\t"); 1014: else 1015: putchar(*t); 1016: putchar('\n'); 1017: } 1018: #endif 1019: return str; 1020: } 1021: 1022: tab(str,lvl) 1023: register STR *str; 1024: register int lvl; 1025: { 1026: while (lvl > 1) { 1027: str_cat(str,"\t"); 1028: lvl -= 2; 1029: } 1030: if (lvl) 1031: str_cat(str," "); 1032: } 1033: 1034: fixtab(str,lvl) 1035: register STR *str; 1036: register int lvl; 1037: { 1038: register char *s; 1039: 1040: /* strip trailing white space */ 1041: 1042: s = str->str_ptr+str->str_cur - 1; 1043: while (s >= str->str_ptr && (*s == ' ' || *s == '\t')) 1044: s--; 1045: s[1] = '\0'; 1046: str->str_cur = s + 1 - str->str_ptr; 1047: if (s >= str->str_ptr && *s != '\n') 1048: str_cat(str,"\n"); 1049: 1050: tab(str,lvl); 1051: } 1052: 1053: addsemi(str) 1054: register STR *str; 1055: { 1056: register char *s; 1057: 1058: s = str->str_ptr+str->str_cur - 1; 1059: while (s >= str->str_ptr && (*s == ' ' || *s == '\t' || *s == '\n')) 1060: s--; 1061: if (s >= str->str_ptr && *s != ';' && *s != '}') 1062: str_cat(str,";"); 1063: } 1064: 1065: emit_split(str,level) 1066: register STR *str; 1067: int level; 1068: { 1069: register int i; 1070: 1071: if (split_to_array) 1072: str_cat(str,"@Fld"); 1073: else { 1074: str_cat(str,"("); 1075: for (i = 1; i < maxfld; i++) { 1076: if (i <= arymax) 1077: sprintf(tokenbuf,"$%s,",nameary[i]); 1078: else 1079: sprintf(tokenbuf,"$Fld%d,",i); 1080: str_cat(str,tokenbuf); 1081: } 1082: if (maxfld <= arymax) 1083: sprintf(tokenbuf,"$%s)",nameary[maxfld]); 1084: else 1085: sprintf(tokenbuf,"$Fld%d)",maxfld); 1086: str_cat(str,tokenbuf); 1087: } 1088: if (const_FS) { 1089: sprintf(tokenbuf," = split(/[%c\\n]/);\n",const_FS); 1090: str_cat(str,tokenbuf); 1091: } 1092: else if (saw_FS) 1093: str_cat(str," = split($FS);\n"); 1094: else 1095: str_cat(str," = split;\n"); 1096: tab(str,level); 1097: } 1098: 1099: prewalk(numit,level,node,numericptr) 1100: int numit; 1101: int level; 1102: register int node; 1103: int *numericptr; 1104: { 1105: register int len; 1106: register int type; 1107: register int i; 1108: char *t; 1109: char *d, *s; 1110: int numarg; 1111: int numeric = FALSE; 1112: 1113: if (!node) { 1114: *numericptr = 0; 1115: return 0; 1116: } 1117: type = ops[node].ival; 1118: len = type >> 8; 1119: type &= 255; 1120: switch (type) { 1121: case OPROG: 1122: prewalk(0,level,ops[node+1].ival,&numarg); 1123: if (ops[node+2].ival) { 1124: prewalk(0,level,ops[node+2].ival,&numarg); 1125: } 1126: ++level; 1127: prewalk(0,level,ops[node+3].ival,&numarg); 1128: --level; 1129: if (ops[node+3].ival) { 1130: prewalk(0,level,ops[node+4].ival,&numarg); 1131: } 1132: break; 1133: case OHUNKS: 1134: prewalk(0,level,ops[node+1].ival,&numarg); 1135: prewalk(0,level,ops[node+2].ival,&numarg); 1136: if (len == 3) { 1137: prewalk(0,level,ops[node+3].ival,&numarg); 1138: } 1139: break; 1140: case ORANGE: 1141: prewalk(1,level,ops[node+1].ival,&numarg); 1142: prewalk(1,level,ops[node+2].ival,&numarg); 1143: break; 1144: case OPAT: 1145: goto def; 1146: case OREGEX: 1147: prewalk(0,level,ops[node+1].ival,&numarg); 1148: break; 1149: case OHUNK: 1150: if (len == 1) { 1151: prewalk(0,level,ops[node+1].ival,&numarg); 1152: } 1153: else { 1154: i = prewalk(0,level,ops[node+1].ival,&numarg); 1155: if (i) { 1156: ++level; 1157: prewalk(0,level,ops[node+2].ival,&numarg); 1158: --level; 1159: } 1160: else { 1161: prewalk(0,level,ops[node+2].ival,&numarg); 1162: } 1163: } 1164: break; 1165: case OPPAREN: 1166: prewalk(0,level,ops[node+1].ival,&numarg); 1167: break; 1168: case OPANDAND: 1169: prewalk(0,level,ops[node+1].ival,&numarg); 1170: prewalk(0,level,ops[node+2].ival,&numarg); 1171: break; 1172: case OPOROR: 1173: prewalk(0,level,ops[node+1].ival,&numarg); 1174: prewalk(0,level,ops[node+2].ival,&numarg); 1175: break; 1176: case OPNOT: 1177: prewalk(0,level,ops[node+1].ival,&numarg); 1178: break; 1179: case OCPAREN: 1180: prewalk(0,level,ops[node+1].ival,&numarg); 1181: numeric |= numarg; 1182: break; 1183: case OCANDAND: 1184: prewalk(0,level,ops[node+1].ival,&numarg); 1185: numeric = 1; 1186: prewalk(0,level,ops[node+2].ival,&numarg); 1187: break; 1188: case OCOROR: 1189: prewalk(0,level,ops[node+1].ival,&numarg); 1190: numeric = 1; 1191: prewalk(0,level,ops[node+2].ival,&numarg); 1192: break; 1193: case OCNOT: 1194: prewalk(0,level,ops[node+1].ival,&numarg); 1195: numeric = 1; 1196: break; 1197: case ORELOP: 1198: prewalk(0,level,ops[node+2].ival,&numarg); 1199: numeric |= numarg; 1200: prewalk(0,level,ops[node+1].ival,&numarg); 1201: prewalk(0,level,ops[node+3].ival,&numarg); 1202: numeric |= numarg; 1203: numeric = 1; 1204: break; 1205: case ORPAREN: 1206: prewalk(0,level,ops[node+1].ival,&numarg); 1207: numeric |= numarg; 1208: break; 1209: case OMATCHOP: 1210: prewalk(0,level,ops[node+2].ival,&numarg); 1211: prewalk(0,level,ops[node+1].ival,&numarg); 1212: prewalk(0,level,ops[node+3].ival,&numarg); 1213: numeric = 1; 1214: break; 1215: case OMPAREN: 1216: prewalk(0,level,ops[node+1].ival,&numarg); 1217: numeric |= numarg; 1218: break; 1219: case OCONCAT: 1220: prewalk(0,level,ops[node+1].ival,&numarg); 1221: prewalk(0,level,ops[node+2].ival,&numarg); 1222: break; 1223: case OASSIGN: 1224: prewalk(0,level,ops[node+2].ival,&numarg); 1225: prewalk(0,level,ops[node+1].ival,&numarg); 1226: prewalk(0,level,ops[node+3].ival,&numarg); 1227: if (numarg || strlen(ops[ops[node+1].ival+1].cval) > 1) { 1228: numericize(ops[node+2].ival); 1229: if (!numarg) 1230: numericize(ops[node+3].ival); 1231: } 1232: numeric |= numarg; 1233: break; 1234: case OADD: 1235: prewalk(1,level,ops[node+1].ival,&numarg); 1236: prewalk(1,level,ops[node+2].ival,&numarg); 1237: numeric = 1; 1238: break; 1239: case OSUB: 1240: prewalk(1,level,ops[node+1].ival,&numarg); 1241: prewalk(1,level,ops[node+2].ival,&numarg); 1242: numeric = 1; 1243: break; 1244: case OMULT: 1245: prewalk(1,level,ops[node+1].ival,&numarg); 1246: prewalk(1,level,ops[node+2].ival,&numarg); 1247: numeric = 1; 1248: break; 1249: case ODIV: 1250: prewalk(1,level,ops[node+1].ival,&numarg); 1251: prewalk(1,level,ops[node+2].ival,&numarg); 1252: numeric = 1; 1253: break; 1254: case OMOD: 1255: prewalk(1,level,ops[node+1].ival,&numarg); 1256: prewalk(1,level,ops[node+2].ival,&numarg); 1257: numeric = 1; 1258: break; 1259: case OPOSTINCR: 1260: prewalk(1,level,ops[node+1].ival,&numarg); 1261: numeric = 1; 1262: break; 1263: case OPOSTDECR: 1264: prewalk(1,level,ops[node+1].ival,&numarg); 1265: numeric = 1; 1266: break; 1267: case OPREINCR: 1268: prewalk(1,level,ops[node+1].ival,&numarg); 1269: numeric = 1; 1270: break; 1271: case OPREDECR: 1272: prewalk(1,level,ops[node+1].ival,&numarg); 1273: numeric = 1; 1274: break; 1275: case OUMINUS: 1276: prewalk(1,level,ops[node+1].ival,&numarg); 1277: numeric = 1; 1278: break; 1279: case OUPLUS: 1280: prewalk(1,level,ops[node+1].ival,&numarg); 1281: numeric = 1; 1282: break; 1283: case OPAREN: 1284: prewalk(0,level,ops[node+1].ival,&numarg); 1285: numeric |= numarg; 1286: break; 1287: case OGETLINE: 1288: break; 1289: case OSPRINTF: 1290: prewalk(0,level,ops[node+1].ival,&numarg); 1291: break; 1292: case OSUBSTR: 1293: prewalk(0,level,ops[node+1].ival,&numarg); 1294: prewalk(1,level,ops[node+2].ival,&numarg); 1295: if (len == 3) { 1296: prewalk(1,level,ops[node+3].ival,&numarg); 1297: } 1298: break; 1299: case OSTRING: 1300: break; 1301: case OSPLIT: 1302: numeric = 1; 1303: prewalk(0,level,ops[node+2].ival,&numarg); 1304: if (len == 3) 1305: prewalk(0,level,ops[node+3].ival,&numarg); 1306: prewalk(0,level,ops[node+1].ival,&numarg); 1307: break; 1308: case OINDEX: 1309: prewalk(0,level,ops[node+1].ival,&numarg); 1310: prewalk(0,level,ops[node+2].ival,&numarg); 1311: numeric = 1; 1312: break; 1313: case ONUM: 1314: prewalk(0,level,ops[node+1].ival,&numarg); 1315: numeric = 1; 1316: break; 1317: case OSTR: 1318: prewalk(0,level,ops[node+1].ival,&numarg); 1319: break; 1320: case OVAR: 1321: prewalk(0,level,ops[node+1].ival,&numarg); 1322: if (len == 1) { 1323: if (numit) 1324: numericize(node); 1325: } 1326: else { 1327: prewalk(0,level,ops[node+2].ival,&numarg); 1328: } 1329: break; 1330: case OFLD: 1331: prewalk(0,level,ops[node+1].ival,&numarg); 1332: break; 1333: case OVFLD: 1334: i = ops[node+1].ival; 1335: prewalk(0,level,i,&numarg); 1336: break; 1337: case OJUNK: 1338: goto def; 1339: case OSNEWLINE: 1340: break; 1341: case ONEWLINE: 1342: break; 1343: case OSCOMMENT: 1344: break; 1345: case OCOMMENT: 1346: break; 1347: case OCOMMA: 1348: prewalk(0,level,ops[node+1].ival,&numarg); 1349: prewalk(0,level,ops[node+2].ival,&numarg); 1350: break; 1351: case OSEMICOLON: 1352: break; 1353: case OSTATES: 1354: prewalk(0,level,ops[node+1].ival,&numarg); 1355: prewalk(0,level,ops[node+2].ival,&numarg); 1356: break; 1357: case OSTATE: 1358: if (len >= 1) { 1359: prewalk(0,level,ops[node+1].ival,&numarg); 1360: if (len >= 2) { 1361: prewalk(0,level,ops[node+2].ival,&numarg); 1362: } 1363: } 1364: break; 1365: case OPRINTF: 1366: case OPRINT: 1367: if (len == 3) { /* output redirection */ 1368: prewalk(0,level,ops[node+3].ival,&numarg); 1369: prewalk(0,level,ops[node+2].ival,&numarg); 1370: } 1371: prewalk(0+(type==OPRINT),level,ops[node+1].ival,&numarg); 1372: break; 1373: case OLENGTH: 1374: goto maybe0; 1375: case OLOG: 1376: goto maybe0; 1377: case OEXP: 1378: goto maybe0; 1379: case OSQRT: 1380: goto maybe0; 1381: case OINT: 1382: maybe0: 1383: numeric = 1; 1384: if (len > 0) 1385: prewalk(type != OLENGTH,level,ops[node+1].ival,&numarg); 1386: break; 1387: case OBREAK: 1388: break; 1389: case ONEXT: 1390: break; 1391: case OEXIT: 1392: if (len == 1) { 1393: prewalk(1,level,ops[node+1].ival,&numarg); 1394: } 1395: break; 1396: case OCONTINUE: 1397: break; 1398: case OREDIR: 1399: goto def; 1400: case OIF: 1401: prewalk(0,level,ops[node+1].ival,&numarg); 1402: prewalk(0,level,ops[node+2].ival,&numarg); 1403: if (len == 3) { 1404: prewalk(0,level,ops[node+3].ival,&numarg); 1405: } 1406: break; 1407: case OWHILE: 1408: prewalk(0,level,ops[node+1].ival,&numarg); 1409: prewalk(0,level,ops[node+2].ival,&numarg); 1410: break; 1411: case OFOR: 1412: prewalk(0,level,ops[node+1].ival,&numarg); 1413: prewalk(0,level,ops[node+2].ival,&numarg); 1414: prewalk(0,level,ops[node+3].ival,&numarg); 1415: prewalk(0,level,ops[node+4].ival,&numarg); 1416: break; 1417: case OFORIN: 1418: prewalk(0,level,ops[node+2].ival,&numarg); 1419: prewalk(0,level,ops[node+1].ival,&numarg); 1420: prewalk(0,level,ops[node+3].ival,&numarg); 1421: break; 1422: case OBLOCK: 1423: if (len == 2) { 1424: prewalk(0,level,ops[node+2].ival,&numarg); 1425: } 1426: ++level; 1427: prewalk(0,level,ops[node+1].ival,&numarg); 1428: --level; 1429: break; 1430: default: 1431: def: 1432: if (len) { 1433: if (len > 5) 1434: fatal("Garbage length in prewalk"); 1435: prewalk(0,level,ops[node+1].ival,&numarg); 1436: for (i = 2; i<= len; i++) { 1437: prewalk(0,level,ops[node+i].ival,&numarg); 1438: } 1439: } 1440: break; 1441: } 1442: *numericptr = numeric; 1443: return 1; 1444: } 1445: 1446: numericize(node) 1447: register int node; 1448: { 1449: register int len; 1450: register int type; 1451: register int i; 1452: STR *tmpstr; 1453: STR *tmp2str; 1454: int numarg; 1455: 1456: type = ops[node].ival; 1457: len = type >> 8; 1458: type &= 255; 1459: if (type == OVAR && len == 1) { 1460: tmpstr=walk(0,0,ops[node+1].ival,&numarg); 1461: tmp2str = str_make("1"); 1462: hstore(symtab,tmpstr->str_ptr,tmp2str); 1463: } 1464: }
Defined functions
walk
defined in line 18; used 109 times
- in line 47, 82, 112, 120, 150-154(3), 161-163(2), 171, 193-200(3), 207, 214, 221-234(5), 240, 246, 252-262(4), 268-276(4), 315, 321-323(2), 331, 338, 344-352(4), 358, 365-405(12), 412, 419, 426, 436, 455, 462-469(3), 483, 491, 513, 524-527(2), 533-537(2), 553, 576, 592-597(2), 611, 631, 640, 648-650(2), 658-659(2), 665-668(2), 681-682(2), 741, 789, 844, 852, 868-871(2), 888-893(2), 901-904(2), 910, 921, 930-937(3), 944, 957-967(3), 976-980(2), 992-994(2), 1460
- in /usr/src/new/PORT/perl.1.0.0/x2p/a2py.c line 22, 115, 853
Defined variables
|
Last modified: 1988-01-31
Generated: 2016-12-26 |
Generated by src2html V0.67
page hit count: 6618 |
|