Return to parse.c CVS log

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

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

1.1     ! root        1: #include "awk.def"
        !             2: #include "awk.h"
        !             3: #include "stdio.h"
        !             4: node *ALLOC(n)
        !             5: {      node *x;
        !             6:        x = (node *)malloc(sizeof(node)+n*sizeof(node *));
        !             7:        if (x == NULL)
        !             8:                error(FATAL, "out of space in ALLOC");
        !             9:        return(x);
        !            10: }
        !            11: node *exptostat(a) node *a;
        !            12: {
        !            13:        a->ntype = NSTAT;
        !            14:        return(a);
        !            15: }
        !            16: node   *nullstat;
        !            17: node *node0(a)
        !            18: {      node *x;
        !            19:        x=ALLOC(0);
        !            20:        x->nnext = NULL;
        !            21:        x->nobj=a;
        !            22:        return(x);
        !            23: }
        !            24: node *node1(a,b) node *b;
        !            25: {      node *x;
        !            26:        x=ALLOC(1);
        !            27:        x->nnext = NULL;
        !            28:        x->nobj=a;
        !            29:        x->narg[0]=b;
        !            30:        return(x);
        !            31: }
        !            32: node *node2(a,b,c) node *b, *c;
        !            33: {      node *x;
        !            34:        x = ALLOC(2);
        !            35:        x->nnext = NULL;
        !            36:        x->nobj = a;
        !            37:        x->narg[0] = b;
        !            38:        x->narg[1] = c;
        !            39:        return(x);
        !            40: }
        !            41: node *node3(a,b,c,d) node *b, *c, *d;
        !            42: {      node *x;
        !            43:        x = ALLOC(3);
        !            44:        x->nnext = NULL;
        !            45:        x->nobj = a;
        !            46:        x->narg[0] = b;
        !            47:        x->narg[1] = c;
        !            48:        x->narg[2] = d;
        !            49:        return(x);
        !            50: }
        !            51: node *node4(a,b,c,d,e) node *b, *c, *d, *e;
        !            52: {      node *x;
        !            53:        x = ALLOC(4);
        !            54:        x->nnext = NULL;
        !            55:        x->nobj = a;
        !            56:        x->narg[0] = b;
        !            57:        x->narg[1] = c;
        !            58:        x->narg[2] = d;
        !            59:        x->narg[3] = e;
        !            60:        return(x);
        !            61: }
        !            62: node *stat3(a,b,c,d) node *b, *c, *d;
        !            63: {      node *x;
        !            64:        x = node3(a,b,c,d);
        !            65:        x->ntype = NSTAT;
        !            66:        return(x);
        !            67: }
        !            68: node *op2(a,b,c) node *b, *c;
        !            69: {      node *x;
        !            70:        x = node2(a,b,c);
        !            71:        x->ntype = NEXPR;
        !            72:        return(x);
        !            73: }
        !            74: node *op1(a,b) node *b;
        !            75: {      node *x;
        !            76:        x = node1(a,b);
        !            77:        x->ntype = NEXPR;
        !            78:        return(x);
        !            79: }
        !            80: node *stat1(a,b) node *b;
        !            81: {      node *x;
        !            82:        x = node1(a,b);
        !            83:        x->ntype = NSTAT;
        !            84:        return(x);
        !            85: }
        !            86: node *op3(a,b,c,d) node *b, *c, *d;
        !            87: {      node *x;
        !            88:        x = node3(a,b,c,d);
        !            89:        x->ntype = NEXPR;
        !            90:        return(x);
        !            91: }
        !            92: node *stat2(a,b,c) node *b, *c;
        !            93: {      node *x;
        !            94:        x = node2(a,b,c);
        !            95:        x->ntype = NSTAT;
        !            96:        return(x);
        !            97: }
        !            98: node *stat4(a,b,c,d,e) node *b, *c, *d, *e;
        !            99: {      node *x;
        !           100:        x = node4(a,b,c,d,e);
        !           101:        x->ntype = NSTAT;
        !           102:        return(x);
        !           103: }
        !           104: node *valtonode(a, b) cell *a;
        !           105: {      node *x;
        !           106:        x = node0(a);
        !           107:        x->ntype = NVALUE;
        !           108:        x->subtype = b;
        !           109:        return(x);
        !           110: }
        !           111: node *genjump(a)
        !           112: {      node *x;
        !           113:        x = node0(a);
        !           114:        x->ntype = NSTAT;
        !           115:        return(x);
        !           116: }
        !           117: node *pa2stat(a,b,c) node *a, *b, *c;
        !           118: {      node *x;
        !           119:        x = node3(paircnt++, a, b, c);
        !           120:        x->ntype = NPA2;
        !           121:        return(x);
        !           122: }
        !           123: node *linkum(a,b) node *a, *b;
        !           124: {      node *c;
        !           125:        if(a == NULL) return(b);
        !           126:        else if(b == NULL) return(a);
        !           127:        for(c=a; c->nnext != NULL; c=c->nnext);
        !           128:        c->nnext = b;
        !           129:        return(a);
        !           130: }
        !           131: node *genprint()
        !           132: {      node *x;
        !           133:        x = stat2(PRINT,valtonode(lookup("$record", symtab), CFLD), nullstat);
        !           134:        return(x);
        !           135: }

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