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     ! 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.