Return to tree.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / cmd / rc

Annotation of lucent/sys/src/cmd/rc/tree.c, revision 1.1.1.1

1.1       root        1: #include "rc.h"
                      2: #include "exec.h"
                      3: #include "io.h"
                      4: #include "fns.h"
                      5: tree *treenodes;
                      6: /*
                      7:  * create and clear a new tree node, and add it
                      8:  * to the node list.
                      9:  */
                     10: tree *newtree(void){
                     11:        tree *t=new(tree);
                     12:        t->iskw=0;
                     13:        t->str=0;
                     14:        t->child[0]=t->child[1]=t->child[2]=0;
                     15:        t->next=treenodes;
                     16:        treenodes=t;
                     17:        return t;
                     18: }
                     19: void freenodes(void){
                     20:        tree *t, *u;
                     21:        for(t=treenodes;t;t=u){
                     22:                u=t->next;
                     23:                if(t->str) efree(t->str);
                     24:                efree((char *)t);
                     25:        }
                     26:        treenodes=0;
                     27: }
                     28: tree *tree1(int type, tree *c0)
                     29: {
                     30:        return tree3(type, c0, (tree *)0, (tree *)0);
                     31: }
                     32: tree *tree2(int type, tree *c0, tree *c1)
                     33: {
                     34:        return tree3(type, c0, c1, (tree *)0);
                     35: }
                     36: tree *tree3(int type, tree *c0, tree *c1, tree *c2)
                     37: {
                     38:        tree *t;
                     39:        if(type==';'){
                     40:                if(c0==0) return c1;
                     41:                if(c1==0) return c0;
                     42:        }
                     43:        t=newtree();
                     44:        t->type=type;
                     45:        t->child[0]=c0;
                     46:        t->child[1]=c1;
                     47:        t->child[2]=c2;
                     48:        return t;
                     49: }
                     50: tree *mung1(tree *t, tree *c0)
                     51: {
                     52:        t->child[0]=c0;
                     53:        return t;
                     54: }
                     55: tree *mung2(tree *t, tree *c0, tree *c1)
                     56: {
                     57:        t->child[0]=c0;
                     58:        t->child[1]=c1;
                     59:        return t;
                     60: }
                     61: tree *mung3(tree *t, tree *c0, tree *c1, tree *c2)
                     62: {
                     63:        t->child[0]=c0;
                     64:        t->child[1]=c1;
                     65:        t->child[2]=c2;
                     66:        return t;
                     67: }
                     68: tree *epimung(tree *comp, tree *epi)
                     69: {
                     70:        tree *p;
                     71:        if(epi==0) return comp;
                     72:        for(p=epi;p->child[1];p=p->child[1]);
                     73:        p->child[1]=comp;
                     74:        return epi;
                     75: }
                     76: /*
                     77:  * Add a SIMPLE node at the root of t and percolate all the redirections
                     78:  * up to the root.
                     79:  */
                     80: tree *simplemung(tree *t)
                     81: {
                     82:        tree *u;
                     83:        struct io *s;
                     84:        t=tree1(SIMPLE, t);
                     85:        s=openstr();
                     86:        pfmt(s, "%t", t);
                     87:        t->str=strdup(s->strp);
                     88:        closeio(s);
                     89:        for(u=t->child[0];u->type==ARGLIST;u=u->child[0]){
                     90:                if(u->child[1]->type==DUP
                     91:                || u->child[1]->type==REDIR){
                     92:                        u->child[1]->child[1]=t;
                     93:                        t=u->child[1];
                     94:                        u->child[1]=0;
                     95:                }
                     96:        }
                     97:        return t;
                     98: }
                     99: tree *token(char *str, int type)
                    100: {
                    101:        tree *t=newtree();
                    102:        t->type=type;
                    103:        t->str=strdup(str);
                    104:        return t;
                    105: }
                    106: void freetree(tree *p)
                    107: {
                    108:        if(p==0) return;        
                    109:        freetree(p->child[0]);
                    110:        freetree(p->child[1]);
                    111:        freetree(p->child[2]);
                    112:        if(p->str) efree(p->str);
                    113:        efree((char *)p);
                    114: }

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