Return to prefix.mt CVS log

Up to [Research Unix] / researchv10no / cmd / twig / examples

Annotation of researchv10no/cmd/twig/examples/prefix.mt, revision 1.1.1.1

1.1       root        1: prologue {
                      2: #include <stdio.h>
                      3: #include <ctype.h>
                      4: typedef        struct node *   NODEPTR;
                      5: #define        COST            int
                      6: #define        INFINITY        1000000
                      7: #define DEFAULT_COST   0
                      8: #define COSTLESS(x,y)  ((x)<(y))
                      9: 
                     10: NODEPTR Root;
                     11: struct node {
                     12:        char op;                /* '\0' if node is a leaf */
                     13:        NODEPTR left, right;
                     14:        char id;
                     15:        int mark;
                     16: };
                     17: 
                     18: }; /* end of prologue */
                     19: 
                     20: node   nOp nIdent;
                     21: label  lExpr;
                     22: 
                     23: lExpr: nIdent
                     24:        = { putchar($$->id); };
                     25: 
                     26: lExpr: nOp(lExpr,lExpr)
                     27:        { TOPDOWN; }
                     28:        = {
                     29:                putchar($$->op);
                     30:                tDO($%1$); tDO($%2$);
                     31:        };
                     32: 
                     33: insert {
                     34: 
                     35: mtValue(root)
                     36:        NODEPTR root;
                     37: {
                     38:        if(root==NULL)
                     39:                return(0);
                     40:        if(root->op==0)
                     41:                return(nIdent);
                     42:        else
                     43:                return(nOp);
                     44: }
                     45: 
                     46: NODEPTR
                     47: mtGetNodes(r,n)
                     48:        NODEPTR r;
                     49:        int n;
                     50: {
                     51:        if(r==NULL)
                     52:                if(n==1)
                     53:                        return(Root);
                     54:                else
                     55:                        return(NULL);
                     56:        if(n==1)
                     57:                return(r->left);
                     58:        else if(n==2)
                     59:                return(r->right);
                     60:        else return(NULL);
                     61: }
                     62: 
                     63: mtSetNodes(r,n,c)
                     64:        NODEPTR r,c;
                     65:        int n;
                     66: {
                     67:        if(r==NULL && n==1) {
                     68:                Root = c;
                     69:                return;
                     70:        }
                     71:        if(n==1)
                     72:                r->left = c;
                     73:        else if(n==2)
                     74:                r->right = c;
                     75: }
                     76: 
                     77: syntax_error()
                     78: {
                     79:        printf("syntax error\n");
                     80:        exit(1);
                     81: }
                     82: 
                     83: /* allocated a node */
                     84: NODEPTR
                     85: getnode(op,id)
                     86:        char op,id;
                     87: {
                     88:        NODEPTR n;
                     89:        n = (NODEPTR) malloc(sizeof(struct node));
                     90:        n->op = op;
                     91:        n->left = n->right = NULL;
                     92:        n->id = id;
                     93:        return(n);
                     94: }
                     95: 
                     96: NODEPTR
                     97: gettree()
                     98: {
                     99:        char c;
                    100:        NODEPTR n = NULL;
                    101: 
                    102:        c = getchar();
                    103:        if(c==EOF) 
                    104:                syntax_error();
                    105: 
                    106:        n = getnode(0,0);
                    107: 
                    108:        /* build node for left operand */
                    109:        if(c=='(')
                    110:                n->left = gettree();
                    111:        else
                    112:                n->left = getnode(0,c);
                    113: 
                    114:        c = getchar();
                    115:        if(strchr("+-*/",c)==NULL)
                    116:                syntax_error();
                    117:        n->op = c;
                    118: 
                    119:        c = getchar();
                    120:        /* build node for right operand */
                    121:        if(c=='(')
                    122:                n->right = gettree();
                    123:        else
                    124:                n->right = getnode(0,c);
                    125: 
                    126:        c = getchar();
                    127:        if(c!=')') 
                    128:                syntax_error();
                    129: 
                    130:        return(n);
                    131: }
                    132: 
                    133: main()
                    134: {
                    135:        char c;
                    136:        _matchinit();           /* initialize the matcher */
                    137: 
                    138:        /* get the initial ( */
                    139:        c = getchar();
                    140:        if(c!='(')
                    141:                syntax_error();
                    142: 
                    143:        Root = gettree();
                    144:        _match();
                    145:        putchar('\n');
                    146: }
                    147: printTree(x)
                    148: {}
                    149: 
                    150: 
                    151: };     /* of insert */

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