Return to dyndep.c CVS log

Up to [Research Unix] / researchv10no / cmd / usgmake

Annotation of researchv10no/cmd/usgmake/dyndep.c, revision 1.1.1.1

1.1       root        1: /*      @(#)/usr/src/cmd/make/dyndep.c  3.4     */
                      2: /*      @(#)dyndep.c    3.3     */
                      3: #include "defs"
                      4: /*
                      5:  *      Dynamicdep() checks each dependency by calling runtime().
                      6:  *      Runtime() determines if a dependent line contains "$@"
                      7:  *      or "$(@F)" or "$(@D)". If so, it makes a new dependent line
                      8:  *      and insert it into the dependency chain of the input name, p.
                      9:  *      Here, "$@" gets translated to p->namep. That is
                     10:  *      the current name on the left of the colon in the
                     11:  *      makefile.  Thus,
                     12:  *              xyz:    [email protected]
                     13:  *      translates into
                     14:  *              xyz:    s.xyz.c
                     15:  *
                     16:  *      Also, "$(@F)" translates to the same thing without a prededing
                     17:  *      directory path (if one exists).
                     18:  *      Note, to enter "$@" on a dependency line in a makefile
                     19:  *      "$$@" must be typed. This is because `make' expands
                     20:  *      macros upon reading them.
                     21:  */
                     22: 
                     23: #define is_dyn(a)               (any( (a), DOLLAR) )
                     24: 
                     25: 
                     26: dynamicdep(p)
                     27: register NAMEBLOCK p;
                     28: {
                     29:         register LINEBLOCK lp, nlp;
                     30:         LINEBLOCK backlp=0;
                     31: 
                     32:         p->rundep = 1;
                     33: 
                     34:         for(lp = p->linep; lp != 0; lp = lp->nextline)
                     35:         {
                     36:                 if( (nlp=runtime(p, lp)) != 0)
                     37:                         if(backlp)
                     38:                                 backlp->nextline = nlp;
                     39:                         else
                     40:                                 p->linep = nlp;
                     41: 
                     42:                 backlp = (nlp == 0) ? lp : nlp;
                     43:         }
                     44: }
                     45: 
                     46: 
                     47: LINEBLOCK runtime(p, lp)
                     48: NAMEBLOCK p;
                     49: register LINEBLOCK lp;
                     50: {
                     51:         register union
                     52:         {
                     53:                 int u_i;
                     54:                 NAMEBLOCK u_nam;
                     55:         } temp;
                     56:         register DEPBLOCK q, nq;
                     57:         LINEBLOCK nlp;
                     58:         NAMEBLOCK pc;
                     59:         CHARSTAR pc1;
                     60:         char c;
                     61:         CHARSTAR pbuf;
                     62:         char buf[128];
                     63: 
                     64:         temp.u_i = NO;
                     65:         for(q = lp->depp; q != 0; q = q->nextdep)
                     66:         {
                     67:                 if((pc=q->depname) != 0)
                     68:                 {
                     69:                         if(is_dyn(pc->namep))
                     70:                         {
                     71:                                 temp.u_i = YES;
                     72:                                 break;
                     73:                         }
                     74:                 }
                     75:         }
                     76: 
                     77:         if(temp.u_i == NO)
                     78:         {
                     79:                 return(0);
                     80:         }
                     81: 
                     82:         nlp = ALLOC(lineblock);
                     83:         nq  = ALLOC(depblock);
                     84: 
                     85:         nlp->nextline = lp->nextline;
                     86:         nlp->shp   = lp->shp;
                     87:         nlp->depp  = nq;
                     88: 
                     89:         for(q = lp->depp; q != 0; q = q->nextdep)
                     90:         {
                     91:                 pc1 = q->depname->namep;
                     92:                 if(is_dyn(pc1))
                     93:                 {
                     94:                         subst(pc1, buf);
                     95:                         temp.u_nam = srchname(buf);
                     96:                         if(temp.u_nam == 0)
                     97:                                 temp.u_nam = makename(copys(buf));
                     98:                         nq->depname = temp.u_nam;
                     99:                 }
                    100:                 else
                    101:                 {
                    102:                         nq->depname = q->depname;
                    103:                 }
                    104: 
                    105:                 if(q->nextdep == 0)
                    106:                         nq->nextdep = 0;
                    107:                 else
                    108:                         nq->nextdep = ALLOC(depblock);
                    109: 
                    110:                 nq = nq->nextdep;
                    111:         }
                    112:         return(nlp);
                    113: }

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