Return to rule.c CVS log

Up to [Research Unix] / researchv10no / cmd / mk / src

Annotation of researchv10no/cmd/mk/src/rule.c, revision 1.1.1.1

1.1       root        1: #include       "mk.h"
                      2: 
                      3: static Rule *lr, *lmr;
                      4: static rcmp();
                      5: static int nrules = 0;
                      6: 
                      7: addrule(head, tail, body, ahead, attr, hline, override, prog)
                      8:        Word *tail, *ahead;
                      9:        char *head, *body, *prog;
                     10: {
                     11:        register Rule *r;
                     12:        Rule *rr;
                     13:        Symtab *sym;
                     14:        int reuse;
                     15: 
                     16:        if(sym = symlook(head, S_TARGET, (char *)0)){
                     17:                for(r = (Rule *)sym->value; r; r = r->chain)
                     18:                        if(rcmp(r, head, tail) == 0) break;
                     19:                if(r && !override)
                     20:                        return;
                     21:        } else
                     22:                r = 0;
                     23:        reuse = r != 0;
                     24:        if(r == 0)
                     25:                r = (Rule *)Malloc(sizeof(Rule));
                     26:        r->target = head;
                     27:        r->tail = tail;
                     28:        r->recipe = body;
                     29:        r->line = hline;
                     30:        r->file = infile;
                     31:        r->attr = attr;
                     32:        r->alltargets = ahead;
                     33:        r->prog = prog;
                     34:        r->rule = nrules++;
                     35:        if(!reuse){
                     36:                rr = (Rule *)symlook(head, S_TARGET, (char *)r)->value;
                     37:                if(rr != r){
                     38:                        r->chain = rr->chain;
                     39:                        rr->chain = r;
                     40:                } else
                     41:                        r->chain = 0;
                     42:        }
                     43:        if(strchr(head, '%') || strchr(head, '&') || (attr&REGEXP))
                     44:                goto meta;
                     45:        if(reuse)
                     46:                return;
                     47:        r->next = 0;
                     48:        r->pat = 0;
                     49:        if(rules == 0)
                     50:                rules = lr = r;
                     51:        else {
                     52:                lr->next = r;
                     53:                lr = r;
                     54:        }
                     55:        return;
                     56: meta:
                     57:        r->attr |= META;
                     58:        if(reuse)
                     59:                return;
                     60:        r->next = 0;
                     61:        if(r->attr&REGEXP){
                     62:                patrule = r;
                     63:                r->pat = regcomp(head);
                     64:        }
                     65:        if(metarules == 0)
                     66:                metarules = lmr = r;
                     67:        else {
                     68:                lmr->next = r;
                     69:                lmr = r;
                     70:        }
                     71: }
                     72: 
                     73: dumpr(s, r)
                     74:        char *s;
                     75:        register Rule *r;
                     76: {
                     77:        Fprint(1, "%s: start=%ld\n", s, r);
                     78:        for(; r; r = r->next){
                     79:                Fprint(1, "\tRule %ld: %s[%d] attr=%x next=%ld chain=%ld alltarget='%s'",
                     80:                        r, r->file, r->line, r->attr, r->next, r->chain, wtos(r->alltargets));
                     81:                if(r->prog)
                     82:                        Fprint(1, " prog='%s'", r->prog);
                     83:                Fprint(1, "\n\ttarget=%s: %s\n", r->target, wtos(r->tail));
                     84:                Fprint(1, "\trecipe@%ld='%s'\n", r->recipe, r->recipe);
                     85:        }
                     86: }
                     87: 
                     88: frule(w)
                     89:        Word *w;
                     90: {
                     91:        extern Word *target1;
                     92:        register Word *ww;
                     93:        register char *s;
                     94: 
                     95: #define        ADD(s)  {if(target1==0)target1=ww=newword(s);else ww=ww->next=newword(s);}
                     96: 
                     97:        for(ww = w; ww; ww = ww->next)
                     98:                if(strchr(w->s, '%') || strchr(w->s, '&'))
                     99:                        return; /* no metarule targets */
                    100:        while(w){
                    101:                if(s = strchr(w->s, '+')){
                    102:                        *s++ = 0;
                    103:                        if(*w->s)
                    104:                                ADD(w->s);
                    105:                        if(*s)
                    106:                                ADD(s);
                    107:                        s[-1] = '+';
                    108:                } else
                    109:                        ADD(w->s);
                    110:                w = w->next;
                    111:        }
                    112: }
                    113: 
                    114: static
                    115: rcmp(r, target, tail)
                    116:        register Rule *r;
                    117:        char *target;
                    118:        register Word *tail;
                    119: {
                    120:        register Word *w;
                    121: 
                    122:        if(strcmp(r->target, target))
                    123:                return(1);
                    124:        for(w = r->tail; w && tail; w = w->next, tail = tail->next)
                    125:                if(strcmp(w->s, tail->s))
                    126:                        return(1);
                    127:        return(w || tail);
                    128: }
                    129: 
                    130: char *
                    131: rulecnt()
                    132: {
                    133:        register char *s;
                    134: 
                    135:        s = Malloc(nrules);
                    136:        memset(s, 0, nrules);
                    137:        return(s);
                    138: }
                    139: 
                    140: ismeta(s)
                    141:        register char *s;
                    142: {
                    143:        for(; *s; s++)
                    144:                switch(*s)
                    145:                {
                    146:                case '\\':
                    147:                        if(s[1])
                    148:                                s++;
                    149:                        break;
                    150:                case '[':
                    151:                case '*':
                    152:                case '?':
                    153:                        return(1);
                    154:                        break;
                    155:                }
                    156:        return(0);
                    157: }

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