home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / cpm / cpm3 / cpmmake.ark / RULES.C < prev    next >
Encoding:
C/C++ Source or Header  |  1986-08-31  |  4.2 KB  |  202 lines
  1. /*
  2.  *    Control of the implicit suffix rules
  3.  */
  4.  
  5.  
  6. #include "h.h"
  7.  
  8. extern long ftime();
  9. extern long time();
  10. extern char *rindex();
  11. extern struct name *newname();
  12. extern char *setmacro();
  13.  
  14. /*
  15.  *    Return a pointer to the suffix of a name
  16.  */
  17. char *
  18. suffix(name)
  19. char *            name;
  20. {
  21.     return(rindex(name, '.'));
  22. }
  23.  
  24.  
  25. /*
  26.  *    Dynamic dependency.  This routine applies the suffix rules
  27.  *    to try and find a source and a set of rules for a missing
  28.  *    target.  If found, np is made into a target with the implicit
  29.  *    source name, and rules.  Returns TRUE if np was made into
  30.  *    a target.
  31.  */
  32. bool
  33. dyndep(np)
  34. struct name *        np;
  35. {
  36.     register char *        p;
  37.     register char *        q;
  38.     register char *        suff;        /*  Old suffix  */
  39.     register char *        basename;    /*  Name without suffix  */
  40.     struct name *        op;        /*  New dependent  */
  41.     struct name *        sp;        /*  Suffix  */
  42.     struct line *        lp;
  43.     struct depend *        dp;
  44.     char *            newsuff;
  45.  
  46.  
  47.     p = str1;
  48.     q = np->n_name;
  49.     suff = suffix(q);
  50.     while (q < suff)
  51.         *p++ = *q++;
  52.     *p = '\0';
  53.     basename = setmacro("*", str1)->m_val;
  54.  
  55.     if (!((sp = newname(".suffixes"))->n_flag & N_TARG))
  56.         return FALSE;
  57.  
  58.     for (lp = sp->n_line; lp; lp = lp->l_next)
  59.         for (dp = lp->l_dep; dp; dp = dp->d_next)
  60.         {
  61.             newsuff = dp->d_name->n_name;
  62.             if (strlen(suff)+strlen(newsuff)+1 >= LZ)
  63.                 fatal("Suffix rule too long");
  64.             p = str1;
  65.             q = newsuff;
  66.             while (*p++ = *q++)
  67.                 ;
  68.             p--;
  69.             q = suff;
  70.             while (*p++ = *q++)
  71.                 ;
  72.             sp = newname(str1);
  73.             if (sp->n_flag & N_TARG)
  74.             {
  75.                 p = str1;
  76.                 q = basename;
  77.                 if (strlen(basename) + strlen(newsuff)+1 >= LZ)
  78.                     fatal("Implicit name too long");
  79.                 while (*p++ = *q++)
  80.                     ;
  81.                 p--;
  82.                 q = newsuff;
  83.                 while (*p++ = *q++)
  84.                     ;
  85.                 op = newname(str1);
  86.                 if (!op->n_time)
  87.         op->n_time = ftime(op->n_name);/*  Gets modtime of this file*/
  88.                 if (op->n_time)
  89.                 {
  90.                     dp = newdep(op, 0);
  91.                     newline(np, dp, sp->n_line->l_cmd);
  92.                     setmacro("<", op->n_name);
  93.                     return TRUE;
  94.                 }
  95.             }
  96.         }
  97.     return FALSE;
  98. }
  99.  
  100.  
  101. /*
  102.  *    Make the default rules
  103.  */
  104. void
  105. makerules()
  106. {
  107.     struct cmd *        cp;
  108.     struct name *        np;
  109.     struct depend *        dp;
  110.  
  111.  
  112. #ifdef xyz123zzz
  113.  
  114.     /*
  115.      * Sure would have been nice if this had been documented as
  116.      * to exactly what was going on with the routine calls.
  117.      *
  118.      *                    -mdk
  119.      */
  120.     setmacro("BDSCC", "asm");
  121.     /*    setmacro("BDSCFLAGS", "");    */
  122.     cp = newcmd("$(BDSCC) $(BDSCFLAGS) -n $<", 0);
  123.     np = newname(".c.o");
  124.     newline(np, 0, cp);
  125.  
  126.     setmacro("CC", "c");
  127.     setmacro("CFLAGS", "-O");
  128.     cp = newcmd("$(CC) $(CFLAGS) -c $<", 0);
  129.     np = newname(".c.obj");
  130.     newline(np, 0, cp);
  131.  
  132.     setmacro("M80", "asm -n");
  133.     /*    setmacro("M80FLAGS", "");    */
  134.     cp = newcmd("$(M80) $(M80FLAGS) $<", 0);
  135.     np = newname(".mac.o");
  136.     newline(np, 0, cp);
  137.  
  138.     setmacro("AS", "zas");
  139.     /*    setmacro("ASFLAGS", "");    */
  140.     cp = newcmd("$(AS) $(ASFLAGS) -o $@ $<", 0);
  141.     np = newname(".as.obj");
  142.     newline(np, 0, cp);
  143.  
  144.     np = newname(".as");
  145.     dp = newdep(np, 0);
  146.     np = newname(".obj");
  147.     dp = newdep(np, dp);
  148.     np = newname(".c");
  149.     dp = newdep(np, dp);
  150.     np = newname(".o");
  151.     dp = newdep(np, dp);
  152.     np = newname(".mac");
  153.     dp = newdep(np, dp);
  154.     np = newname(".suffixes");
  155.     newline(np, dp, 0);
  156. #endif
  157.     
  158.  
  159.     /*
  160.      * C compilation.  I use cc-c.sub to do what unix cc -c does.
  161.      *
  162.      *     Macros can be overridden in makfile if I change and am
  163.      *    too lazy to recompile this make program's rules.
  164.         *
  165.      */
  166.     setmacro("ccc", "cc-c");
  167.     setmacro("cflags", "");
  168.     setmacro("cwhich", "$*");
  169.     cp = newcmd("$(ccc) $(cflags) $(cwhich)", 0);
  170.     np = newname(".c.o");
  171.     newline(np, 0, cp);
  172.  
  173.     /*
  174.      * Assembly using RMAC.
  175.      */
  176.     setmacro("asm", "rmac");
  177.     setmacro("asmflags", "$$PZ SZ");
  178.     setmacro("asmwhich", "$*");
  179.     cp = newcmd("$(asm) $(asmwhich) $(asmflags)", 0);
  180.     np = newname(".asm.rel");
  181.     newline(np, 0, cp);
  182.         
  183.     /*
  184.      * No point in my Z80 assembler or MAC.  Rules for
  185.      * non-linkable one-module language-tools makes no
  186.      * sense because it is a one-file process anyway.
  187.      */
  188.  
  189.  
  190.     np = newname(".asm");
  191.     dp = newdep(np, 0);
  192.     np = newname(".rel");
  193.     dp = newdep(np,dp);
  194.     np = newname(".c");
  195.     dp = newdep(np, dp);
  196.     np = newname(".o");
  197.     dp = newdep(np,dp);
  198.     np = newname(".suffixes");
  199.     newline(np, dp, 0);
  200.  
  201. }
  202.