Return to parse.c CVS log

Up to [CSRG BSD Unix] / 42BSD / bin / awk

Annotation of 42BSD/bin/awk/parse.c, revision 1.1.1.1

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

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