# 2.11BSD#431 - /usr/src/new/PORT/perl.1.0.16/x2p/walk.c

##### Functions

    addsemi           X
    emit_split        X
    fixtab            X
    numericize        X
    prewalk           X
    tab               X
    walk              X

##### Variables

    maxtmp            X

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

#### Defined functions

addsemi defined in line 1060; used 2 times

- in line 677, 989

emit_split defined in line 1072; used 2 times

- in line 120, 457

fixtab defined in line 1041; used 4 times

- in line 123, 218, 986-990(2)

numericize defined in line 1453; used 3 times

- in line 1235-1237(2), 1331

prewalk defined in line 1106; used 99 times

- in line 1129-1233(39), 1242-1291(17), 1297-1303(4), 1310-1328(8), 1334-1342(3), 1355-1368(6), 1375-1378(3), 1392, 1400, 1408-1434(14), 1442-1444(2)
- in /usr/src/new/PORT/perl.1.0.16/x2p/a2py.c line 114

tab defined in line 1029; used 15 times

- in line 98-103(2), 128, 215-220(2), 451-454(2), 628-633(2), 643, 652, 731, 992, 1057, 1103

walk defined in line 27; used 109 times

- in line 56, 91, 121, 129, 159-163(3), 170-172(2), 180, 202-209(3), 216, 223, 230-243(5), 249, 255, 261-271(4), 277-285(4), 324, 330-332(2), 340, 347, 353-361(4), 367-412(13), 419, 426, 433, 443, 462, 469-476(3), 490, 498, 520, 531-534(2), 540-544(2), 560, 583, 599-604(2), 618, 638, 647, 655-657(2), 665-666(2), 672-675(2), 688-689(2), 748, 796, 851, 859, 875-878(2), 895-900(2), 908-911(2), 917, 928, 937-944(3), 951, 964-974(3), 983-987(2), 999-1001(2), 1467
- in /usr/src/new/PORT/perl.1.0.16/x2p/a2py.c line 25, 118, 860

#### Defined variables

maxtmp defined in line 25; used 5 times

- in line 950-960(5)

Last modified: 2002-12-19 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 4376 |