home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 216.lha / PdMake / rules.c < prev   
Encoding:
C/C++ Source or Header  |  1996-02-15  |  5.5 KB  |  220 lines
  1. /*
  2.  *     Control of the implicit suffix rules
  3.  */
  4.  
  5. #include <stdio.h>
  6. #include "h.h"
  7.  
  8. /* function to added by DJ */
  9.  
  10. /* concat() - concatenate two strings into a third, null terminate,
  11.     with max length limit and status return.
  12. */
  13.  
  14. char *concat(dest,source1,source2,maxlen)
  15.     char        *source1,
  16.                 *source2,
  17.                 *dest;
  18.     long        maxlen;
  19. {    char        *result = dest;
  20.  
  21.     for (;;)
  22.     {    if (maxlen-- < 0) return NULL;
  23.         if (*source1) *dest++ = *source1++;
  24.         else if (*source2) *dest++ = *source2++;
  25.         else { *dest= 0; return result; }
  26.     }
  27. }
  28.  
  29. /*
  30.  *     Return a pointer to the suffix of a name
  31.  */
  32. char *suffix(name)
  33.     char *name;
  34. {    return rindex(name, '.');
  35. }
  36.  
  37. /*
  38.  *     Dynamic dependency.  This routine applies the suffix rules
  39.  *     to try and find a source and a set of rules for a missing
  40.  *     target.    If found, np is made into a target with the implicit
  41.  *     source name, and rules.    Returns TRUE if np was made into
  42.  *     a target.
  43.  */
  44.  
  45. #define FNAME_LENGTH        32
  46.  
  47. bool dyndep(np) struct name *np;
  48. {    register char        *p;
  49.     register char        *q;
  50.     register char        *suff;            /*  Old suffix  */
  51.     register char        *basename;        /*  Name without suffix    */
  52.     struct name            *op;            /*  New dependent  */
  53.     struct name            *sp;            /*  pointer to Suffix name record */
  54.     struct line            *lp;
  55.     struct depend        *dp;            /* dependancy pointer */
  56.     char                *newsuff;        /* pointer to new suffix string */
  57.     char                new_name[FNAME_LENGTH];    /* temp string buffer */
  58.  
  59.     p = new_name;
  60.     q = np->n_name;
  61.  
  62.     if (!(suff = suffix(q))) return FALSE;        /* No suffix */
  63.  
  64.     while (q < suff) *p++ = *q++;                /* copy base name to new_name */
  65.     *p = '\0';                                    /* and null terminate */
  66.  
  67.     basename = setmacro("*",new_name)->m_val;    /* set the macro '*' := basename */
  68.  
  69.     /* look for the '.SUFFIXES' entry. If no targets specified, then dynamic
  70.         dependancies are diabled.
  71.     */
  72.  
  73.     if (!((sp = newname(".SUFFIXES"))->n_flag & N_TARG))
  74.         return FALSE;
  75.  
  76.     /* else, look through the list of valid suffixes to find which one applies
  77.         to this file.
  78.         NOTE: Manx make does not need this, as it infers the valid suffxes from
  79.         the rules list.
  80.     */
  81.  
  82.     for (lp = sp->n_line; lp; lp = lp->l_next)        /* for each line of 'suffix' */
  83.         for (dp = lp->l_dep; dp; dp = dp->d_next)    /* for each dependancy spec'd */
  84.         {
  85.             newsuff = dp->d_name->n_name;            /* pointer to a new suffix */
  86.  
  87.                 /* new_name = newsuff + suff */
  88.             if (!concat(new_name,newsuff,suff,FNAME_LENGTH))
  89.                 fatal("Suffix rule too long");
  90.  
  91.             sp = newname(new_name);                    /* get that rule, if exists */
  92.             if (sp->n_flag & N_TARG)                /* if has targets */
  93.             {
  94.                 /* now append the new suffix to the name, result in new_name */
  95.  
  96.                 if (!concat(new_name,basename,newsuff,FNAME_LENGTH))
  97.                     fatal("Suffix rule too long");
  98.  
  99.                 /* special rule for PAMAKE, allows partial match... */
  100.                 /* (I'm not sure how good of an idea this is, but we'll see...
  101.                     I think I'd rather use things like FileOnly()
  102.                 */
  103.  
  104. /* deleted until we can get a strstr() */
  105. /*
  106.                 if (strstr(q=np->n_line->l_dep->d_name->n_name,str1))
  107.                     op=newname(q);
  108.                 else
  109. */
  110.                     op = newname(new_name);        /* make that a name */
  111.  
  112.                 if (null_time(&op->n_time))            /* if file note yet looked at */
  113.                     modtime(op);                    /* look for it */
  114.                 if (!null_time(&op->n_time))        /* if found */
  115.                 {    dp = newdep(op, 0);                /* make a new dependancy */
  116.                     newline(np, dp, sp->n_line->l_cmd, 0);    /* a new line entry */
  117.                     setmacro("<", op->n_name);        /* set the macro '<' to name */
  118.                     return TRUE;                    /* yup, we did it */
  119.                 }
  120.             }
  121.         }
  122.     return FALSE;
  123. }
  124.  
  125.  
  126. /*
  127.  *     Make the default rules
  128.  */
  129. void makerules()
  130. {    struct cmd            *cp;
  131.     struct name            *np;
  132.     struct depend        *dp;
  133.  
  134. /*
  135.  *     Some of the UNIX implicit rules
  136.  */
  137.  
  138. #ifdef unix
  139.     setmacro("CC", "cc");
  140.     setmacro("CFLAGS", "-O");
  141.     cp = newcmd("$(CC) $(CFLAGS) -c $<", 0);
  142.     np = newname(".c.o");
  143.     newline(np, 0, cp, 0);
  144.  
  145.     setmacro("AS", "as");
  146.     cp = newcmd("$(AS) -o $@ $<", 0);
  147.     np = newname(".s.o");
  148.     newline(np, 0, cp, 0);
  149.  
  150.     setmacro("YACC", "yacc");
  151.     /*      setmacro("YFLAGS", ""); */
  152.     cp = newcmd("$(YACC) $(YFLAGS) $<", 0);
  153.     cp = newcmd("mv y.tab.c $@", cp);
  154.     np = newname(".y.c");
  155.     newline(np, 0, cp, 0);
  156.  
  157.     cp = newcmd("$(YACC) $(YFLAGS) $<", 0);
  158.     cp = newcmd("$(CC) $(CFLAGS) -c y.tab.c", cp);
  159.     cp = newcmd("rm y.tab.c", cp);
  160.     cp = newcmd("mv y.tab.o $@", cp);
  161.     np = newname(".y.o");
  162.     newline(np, 0, cp, 0);
  163.  
  164.     np = newname(".s");
  165.     dp = newdep(np, 0);
  166.     np = newname(".o");
  167.     dp = newdep(np, dp);
  168.     np = newname(".c");
  169.     dp = newdep(np, dp);
  170.     np = newname(".y");
  171.     dp = newdep(np, dp);
  172.     np = newname(".SUFFIXES");
  173.     newline(np, dp, 0, 0);
  174. #endif
  175. #ifdef MCH_AMIGA
  176.  
  177.     /* default rule for .c files */
  178.  
  179.     setmacro("CC", "cc");
  180.     setmacro("CFLAGS", "-O");
  181.     cp = newcmd("$(CC) $(CFLAGS) $<", 0);
  182.     np = newname(".c.o");
  183.     newline(np, 0, cp, 0);
  184.  
  185.     /* default rule for .asm files */
  186.  
  187.     setmacro("AS", "as");
  188.     cp = newcmd("$(AS) -o $@ $<", 0);
  189.     np = newname(".asm.o");
  190.     newline(np, 0, cp, 0);
  191.  
  192.     /* default rule for .y files to .c and .o */
  193.  
  194.     setmacro("YACC", "yacc");
  195.     /*      setmacro("YFLAGS", ""); */
  196.     cp = newcmd("$(YACC) $(YFLAGS) $<", 0);
  197.     cp = newcmd("mv y.tab.c $@", cp);
  198.     np = newname(".y.c");
  199.     newline(np, 0, cp, 0);
  200.  
  201.     cp = newcmd("$(YACC) $(YFLAGS) $<", 0);
  202.     cp = newcmd("$(CC) $(CFLAGS) -c y.tab.c", cp);
  203.     cp = newcmd("rm y.tab.c", cp);
  204.     cp = newcmd("mv y.tab.o $@", cp);
  205.     np = newname(".y.o");
  206.     newline(np, 0, cp, 0);
  207.  
  208.     /* define valid suffixes: .asm .o .c .y */
  209.  
  210.     np = newname(".asm");        dp = newdep(np, 0);
  211.     np = newname(".o");            dp = newdep(np, dp);
  212.     np = newname(".c");            dp = newdep(np, dp);
  213.     np = newname(".y");            dp = newdep(np, dp);
  214.     np = newname(".SUFFIXES");    newline(np, dp, 0, 0);
  215.  
  216.     /* add lattice C, C++, whatever else, etc. */
  217.  
  218. #endif
  219. }
  220.