Return to dump.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / awk

Annotation of 3BSD/cmd/awk/dump.c, revision 1.1

1.1     ! root        1: #include "awk.def"
        !             2: #include "stdio.h"
        !             3: #include "awk.h"
        !             4: #define printit(n) printf(printname[n-FIRSTTOKEN]);
        !             5: extern char *printname[];
        !             6: extern cell fldtab[];
        !             7: 
        !             8: dump(a,b) node *a, *b;
        !             9: {
        !            10: #ifdef DEBUG
        !            11:        node *x;
        !            12:        if(a==nullstat) return;
        !            13:        for(x=a;x!=NULL;x=x->nnext)
        !            14:        {
        !            15:        if(x==b) printf(" *** ");
        !            16:                if(x->ntype==NVALUE)
        !            17:                {       switch(x->subtype)
        !            18:                        {
        !            19:                        default: runerror();
        !            20:                        case CCON: case CVAR:
        !            21:                                printf("%s",x->nobj->nval);
        !            22:                                continue;
        !            23:                        case CFLD:
        !            24:                                if(x->nobj->nval==0) printf("$%d",x->nobj - fldtab);
        !            25:                                else printf("$0");
        !            26:                                continue;
        !            27:                        }
        !            28:                }
        !            29:                else if(x->ntype==PASTAT2)
        !            30:                {       pa2dump(x,b);
        !            31:                        continue;
        !            32:                }
        !            33:                switch(x->nobj)
        !            34:                {
        !            35:                default: runerror();
        !            36:                case LE: case LT: case EQ:
        !            37:                case NE: case GT: case GE:
        !            38:                case MATCH: case NOTMATCH:
        !            39:                case ADD: case MINUS: case MULT:
        !            40:                case DIVIDE: case MOD: case ASGNOP:
        !            41:                case BOR: case AND: case CAT:
        !            42:                        dump(x->narg[0], b);
        !            43:                        printit(x->nobj);
        !            44:                        if(x->nobj!=MATCH && x->nobj!=NOTMATCH)
        !            45:                                dump(x->narg[1]);
        !            46:                        else    printf("regex");
        !            47:                        break;
        !            48:                case UMINUS: case FNCN: case INCR:
        !            49:                case DECR: case INDIRECT:
        !            50:                        printit(x->nobj);
        !            51:                        dump(x->narg[0], b);
        !            52:                        break;
        !            53:                case PRINT: case PRINTF: case SPRINTF:
        !            54:                case SPLIT:
        !            55:                        printit(x->nobj);
        !            56:                        dump(x->narg[0], b);
        !            57:                        if(x->nobj==SPLIT || x->nobj==SPRINTF) break;
        !            58:                        if(x->narg[1]==0) break;
        !            59:                        printit((int)x->narg[1]);
        !            60:                        dump(x->narg[2], b);
        !            61:                        break;
        !            62:                case IF: case WHILE:
        !            63:                        printit(x->nobj);
        !            64:                        dump(x->narg[0], b);
        !            65:                        printf(") ");
        !            66:                        dump(x->narg[1], b);
        !            67:                        if(x->narg[2]==NULL) break;
        !            68:                        printit(ELSE);
        !            69:                        dump(x->narg[2], b);
        !            70:                        break;
        !            71:                case FOR:
        !            72:                        printit(x->nobj);
        !            73:                        dump(x->narg[0], b);
        !            74:                        putchar(';');
        !            75:                        dump(x->narg[1], b);
        !            76:                        putchar(';');
        !            77:                        dump(x->narg[2], b);
        !            78:                        printf(") ");
        !            79:                        dump(x->narg[3], b);
        !            80:                        break;
        !            81:                case NEXT: case EXIT: case BREAK: case CONTINUE:
        !            82:                        printit(x->nobj);
        !            83:                        break;
        !            84:                case PROGRAM:
        !            85:                        if(x->narg[0]!=NULL)
        !            86:                        {       printf("BEGIN {");
        !            87:                                dump(x->narg[0], b);
        !            88:                                printf("}\n");
        !            89:                        }
        !            90:                        dump(x->narg[1], b);
        !            91:                        if(x->narg[2]!=NULL)
        !            92:                        {       printf("END {");
        !            93:                                dump(x->narg[2], b);
        !            94:                                printf("}\n");
        !            95:                        }
        !            96:                        break;
        !            97:                case PASTAT:
        !            98:                        dump(x->narg[0], b);
        !            99:                        printf("{");
        !           100:                        dump(x->narg[1], b);
        !           101:                        printf("}\n");
        !           102:                        break;
        !           103:                case ARRAY:
        !           104:                        printf(x->nval);
        !           105:                        printf("[");
        !           106:                        dump(x->narg[1], b);
        !           107:                        printf("]");
        !           108:                        break;
        !           109:                case SUBSTR:
        !           110:                        printit(x->nobj);
        !           111:                        dump(x->narg[0], b);
        !           112:                        putchar(',');
        !           113:                        dump(x->narg[1], b);
        !           114:                        if(x->narg[2]!=NULL)
        !           115:                        {       putchar(',');
        !           116:                                dump(x->narg[2], b);
        !           117:                        }
        !           118:                        putchar(')');
        !           119:                        break;
        !           120:                }
        !           121:                if(x->ntype == NSTAT) putchar('\n');
        !           122:        }
        !           123: #endif
        !           124: }
        !           125: pa2dump(a, b) node *a, *b;
        !           126: {
        !           127: #ifdef DEBUG
        !           128:        dump(a->narg[0], b);
        !           129:        printf(", ");
        !           130:        dump(a->narg[1], b);
        !           131:        printf(" {");
        !           132:        dump(a->narg[2], b);
        !           133:        printf("}\n");
        !           134: #endif
        !           135: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.