home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / tools / make / make_pd / rules.c < prev   
Text File  |  1987-02-15  |  6KB  |  269 lines
  1. /*
  2.  *    Control of the implicit suffix rules
  3.  */
  4.  
  5.  
  6. #include "h.h"
  7.  
  8.  
  9. /*
  10.  *    Return a pointer to the suffix of a name
  11.  */
  12. char *
  13. suffix(name)
  14. char *            name;
  15. {
  16.     return rindex(name, '.');
  17. }
  18.  
  19.  
  20. /*
  21.  *    Dynamic dependency.  This routine applies the suffis rules
  22.  *    to try and find a source and a set of rules for a missing
  23.  *    target.  If found, np is made into a target with the implicit
  24.  *    source name, and rules.  Returns TRUE if np was made into
  25.  *    a target.
  26.  */
  27. bool
  28. dyndep(np)
  29. struct name *        np;
  30. {
  31.     register char *        p;
  32.     register char *        q;
  33.     register char *        suff;        /*  Old suffix  */
  34.     register char *        basename;    /*  Name without suffix  */
  35.     struct name *        op;        /*  New dependent  */
  36.     struct name *        sp;        /*  Suffix  */
  37.     struct line *        lp;
  38.     struct depend *        dp;
  39.     char *            newsuff;
  40.  
  41.  
  42.     p = str1;
  43.     q = np->n_name;
  44.     if (!(suff = suffix(q)))
  45.         return FALSE;        /* No suffix */
  46.     while (q < suff)
  47.         *p++ = *q++;
  48.     *p = '\0';
  49.     basename = setmacro("*", str1)->m_val;
  50.  
  51.     if (!((sp = newname(".SUFFIXES"))->n_flag & N_TARG))
  52.         return FALSE;
  53.  
  54.     for (lp = sp->n_line; lp; lp = lp->l_next)
  55.         for (dp = lp->l_dep; dp; dp = dp->d_next)
  56.         {
  57.             newsuff = dp->d_name->n_name;
  58.             if (strlen(suff)+strlen(newsuff)+1 >= LZ)
  59.                 fatal("Suffix rule too long");
  60.             p = str1;
  61.             q = newsuff;
  62.             while (*p++ = *q++)
  63.                 ;
  64.             p--;
  65.             q = suff;
  66.             while (*p++ = *q++)
  67.                 ;
  68.             sp = newname(str1);
  69.             if (sp->n_flag & N_TARG)
  70.             {
  71.                 p = str1;
  72.                 q = basename;
  73.                 if (strlen(basename) + strlen(newsuff)+1 >= LZ)
  74.                     fatal("Implicit name too long");
  75.                 while (*p++ = *q++)
  76.                     ;
  77.                 p--;
  78.                 q = newsuff;
  79.                 while (*p++ = *q++)
  80.                     ;
  81.                 op = newname(str1);
  82.                 if (!op->n_time)
  83.                     modtime(op);
  84.                 if (op->n_time)
  85.                 {
  86.                     dp = newdep(op, 0);
  87.                     newline(np, dp, sp->n_line->l_cmd, 0);
  88.                     setmacro("<", op->n_name);
  89.                     return TRUE;
  90.                 }
  91.             }
  92.         }
  93.     return FALSE;
  94. }
  95.  
  96.  
  97. /*
  98.  *    Make the default rules
  99.  */
  100. void
  101. makerules()
  102. {
  103.     struct cmd *        cp;
  104.     struct name *        np;
  105.     struct depend *        dp;
  106.  
  107.  
  108. #ifdef eon
  109.     setmacro("BDSCC", "asm");
  110.     /*    setmacro("BDSCFLAGS", "");    */
  111.     cp = newcmd("$(BDSCC) $(BDSCFLAGS) -n $<", 0);
  112.     np = newname(".c.o");
  113.     newline(np, 0, cp, 0);
  114.  
  115.     setmacro("CC", "c");
  116.     setmacro("CFLAGS", "-O");
  117.     cp = newcmd("$(CC) $(CFLAGS) -c $<", 0);
  118.     np = newname(".c.obj");
  119.     newline(np, 0, cp, 0);
  120.  
  121.     setmacro("M80", "asm -n");
  122.     /*    setmacro("M80FLAGS", "");    */
  123.     cp = newcmd("$(M80) $(M80FLAGS) $<", 0);
  124.     np = newname(".mac.o");
  125.     newline(np, 0, cp, 0);
  126.  
  127.     setmacro("AS", "zas");
  128.     /*    setmacro("ASFLAGS", "");    */
  129.     cp = newcmd("$(ZAS) $(ASFLAGS) -o $@ $<", 0);
  130.     np = newname(".as.obj");
  131.     newline(np, 0, cp, 0);
  132.  
  133.     np = newname(".as");
  134.     dp = newdep(np, 0);
  135.     np = newname(".obj");
  136.     dp = newdep(np, dp);
  137.     np = newname(".c");
  138.     dp = newdep(np, dp);
  139.     np = newname(".o");
  140.     dp = newdep(np, dp);
  141.     np = newname(".mac");
  142.     dp = newdep(np, dp);
  143.     np = newname(".SUFFIXES");
  144.     newline(np, dp, 0, 0);
  145. #endif
  146.  
  147. /*
  148.  *    Some of the UNIX implicit rules
  149.  */
  150. #ifdef unix
  151.     setmacro("CC", "cc");
  152.     setmacro("CFLAGS", "-O");
  153.     cp = newcmd("$(CC) $(CFLAGS) -c $<", 0);
  154.     np = newname(".c.o");
  155.     newline(np, 0, cp, 0);
  156.  
  157.     setmacro("AS", "as");
  158.     cp = newcmd("$(AS) -o $@ $<", 0);
  159.     np = newname(".s.o");
  160.     newline(np, 0, cp, 0);
  161.  
  162.     setmacro("YACC", "yacc");
  163.     /*    setmacro("YFLAGS", "");    */
  164.     cp = newcmd("$(YACC) $(YFLAGS) $<", 0);
  165.     cp = newcmd("mv y.tab.c $@", cp);
  166.     np = newname(".y.c");
  167.     newline(np, 0, cp, 0);
  168.  
  169.     cp = newcmd("$(YACC) $(YFLAGS) $<", 0);
  170.     cp = newcmd("$(CC) $(CFLAGS) -c y.tab.c", cp);
  171.     cp = newcmd("rm y.tab.c", cp);
  172.     cp = newcmd("mv y.tab.o $@", cp);
  173.     np = newname(".y.o");
  174.     newline(np, 0, cp, 0);
  175.  
  176.     np = newname(".s");
  177.     dp = newdep(np, 0);
  178.     np = newname(".o");
  179.     dp = newdep(np, dp);
  180.     np = newname(".c");
  181.     dp = newdep(np, dp);
  182.     np = newname(".y");
  183.     dp = newdep(np, dp);
  184.     np = newname(".SUFFIXES");
  185.     newline(np, dp, 0, 0);
  186. #endif
  187. #ifdef MSC
  188.     setmacro("CC", "cc");
  189.     setmacro("CFLAGS", "-O");
  190.     cp = newcmd("$(CC) $(CFLAGS) -c $<", 0);
  191.     np = newname(".c.obj");
  192.     newline(np, 0, cp, 0);
  193.  
  194.     setmacro("AS", "masm");
  195.     cp = newcmd("$(AS) $<;", 0);
  196.     np = newname(".asm.obj");
  197.     newline(np, 0, cp, 0);
  198. /*
  199.  * Handy, but needlessly presumptive!  (pjh)
  200.  *      
  201.     setmacro("CLIPPER", "clipper");
  202.     setmacro("CLFLAGS", "-m");
  203.     cp = newcmd("$(CLIPPER) $< $(CLFLAGS)", 0);
  204.     np = newname(".prg.obj");
  205.     newline(np, 0, cp, 0);
  206.  */
  207.  
  208.     np = newname(".obj");
  209.     dp = newdep(np, 0);
  210.     np = newname(".asm");
  211.     dp = newdep(np, dp);
  212.     np = newname(".c");
  213.     dp = newdep(np, dp);
  214. /*
  215.     np = newname(".prg");
  216.     dp = newdep(np, dp);
  217.  */
  218.     np = newname(".SUFFIXES");
  219.     newline(np, dp, 0, 0);
  220. #endif
  221. #ifdef os9
  222. /*
  223.  *    Fairlight use an enhanced version of the C sub-system.
  224.  *    They have a specialised macro pre-processor.
  225.  */
  226.     setmacro("CC", "cc");
  227.     setmacro("CFLAGS", "-z");
  228.     cp = newcmd("$(CC) $(CFLAGS) -r $<", 0);
  229.  
  230.     np = newname(".c.r");
  231.     newline(np, 0, cp, 0);
  232.     np = newname(".ca.r");
  233.     newline(np, 0, cp, 0);
  234.     np = newname(".a.r");
  235.     newline(np, 0, cp, 0);
  236.     np = newname(".o.r");
  237.     newline(np, 0, cp, 0);
  238.     np = newname(".mc.r");
  239.     newline(np, 0, cp, 0);
  240.     np = newname(".mca.r");
  241.     newline(np, 0, cp, 0);
  242.     np = newname(".ma.r");
  243.     newline(np, 0, cp, 0);
  244.     np = newname(".mo.r");
  245.     newline(np, 0, cp, 0);
  246.  
  247.     np = newname(".r");
  248.     dp = newdep(np, 0);
  249.     np = newname(".mc");
  250.     dp = newdep(np, dp);
  251.     np = newname(".mca");
  252.     dp = newdep(np, dp);
  253.     np = newname(".c");
  254.     dp = newdep(np, dp);
  255.     np = newname(".ca");
  256.     dp = newdep(np, dp);
  257.     np = newname(".ma");
  258.     dp = newdep(np, dp);
  259.     np = newname(".mo");
  260.     dp = newdep(np, dp);
  261.     np = newname(".o");
  262.     dp = newdep(np, dp);
  263.     np = newname(".a");
  264.     dp = newdep(np, dp);
  265.     np = newname(".SUFFIXES");
  266.     newline(np, dp, 0, 0);
  267. #endif
  268. }
  269.