home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume1 / 8712 / mkmf / 2 / src / misc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-07-13  |  6.9 KB  |  282 lines
  1. /* $Header: misc.c,v 1.6 85/06/27 08:15:57 nicklin Exp $ */
  2.  
  3. /*
  4.  * Author: Peter J. Nicklin
  5.  */
  6. #include <ctype.h>
  7. #include <stdio.h>
  8. #include "Mkmf.h"
  9. #include "hash.h"
  10. #include "macro.h"
  11. #include "null.h"
  12. #include "path.h"
  13. #include "target.h"
  14. #include "spms.h"
  15. #include "suffix.h"
  16. #include "system.h"
  17. #include "yesno.h"
  18.  
  19. /*
  20.  * answer() installs a line from stdin in the macro definition table.
  21.  * exit(1) is called if EOF, error, or out of memory.
  22.  */
  23. void
  24. answer(mdefkey, mdefval)
  25.     char *mdefkey;            /* macro definition key */
  26.     int mdefval;            /* macro definition value */
  27. {
  28.     extern HASH *MDEFTABLE;        /* macro definition table */
  29.     char answerbuf[ANSWERBUFSIZE];    /* answer from stdin */
  30.     char *gets();            /* get a line from stdin */
  31.     HASHBLK *htinstall();        /* install hash table entry */
  32.  
  33.     if (gets(answerbuf) == NULL)
  34.         exit(1);
  35.     if (*answerbuf != '\0')
  36.         if (htinstall(mdefkey, answerbuf, mdefval, MDEFTABLE) == NULL)
  37.             exit(1);
  38. }
  39.  
  40.  
  41.  
  42. /*
  43.  * fastcopy() copies file to stream fp. Returns integer YES if successful,
  44.  * otherwise NO.
  45.  */
  46. fastcopy(filename, ofp)
  47.     char *filename;            /* file to be copied */
  48.     register FILE *ofp;        /* output stream */
  49. {
  50.     register int ifd;        /* input file descriptor */
  51.     register int n;            /* byte count */
  52.     char buf[BUFSIZ];        /* I/O buffer */
  53.  
  54.     if ((ifd = OPEN(filename, 0, 0644)) == -1)
  55.         {
  56.         pperror("");
  57.         return(NO);
  58.         }
  59.     while ((n = read(ifd, buf, BUFSIZ)) > 0)
  60.         write(fileno(ofp), buf, n);
  61.     close(ifd);
  62.     return(YES);
  63. }
  64.  
  65.  
  66.  
  67. /*
  68.  * findmf() locates the makefile to be edited. The type of makefile
  69.  * is returned in target. The pathname to the makefile is returned
  70.  * in mfpath. Returns YES if makefile or makefile template can be
  71.  * opened, otherwise NO.
  72.  */
  73. findmf(mfname, mfpath, target)
  74.     char *mfname;            /* name of target makefile */
  75.     char *mfpath;            /* path to target makefile */
  76.     TARGET *target;            /* type of makefile target */
  77. {
  78.     extern int CFLAG;        /* makefile creation message */
  79.     char *strcpy();            /* string copy */
  80.     int readmf();            /* read makefile */
  81.     int targettype;            /* type of makefile requested */
  82.     void findmftemplate();        /* find makefile template */
  83.  
  84.     targettype = target->type;
  85.     if (FILEXIST(mfname))
  86.         {
  87.         if (!FILEWRITE(mfname))
  88.             {
  89.             pperror(mfname);
  90.             target->type = VERROR;
  91.             return(NO);
  92.             }
  93.         if (readmf(mfname, target) == VERROR)
  94.             return(NO);
  95.         if (targettype == VUNKNOWN || targettype == target->type)
  96.             {
  97.             strcpy(mfpath, mfname);
  98.             return(YES);
  99.             }
  100.         }
  101.     target->type = (targettype == VLIBRARY) ? VLIBRARY : VPROGRAM;
  102.     findmftemplate(mfpath, target);
  103.     if (readmf(mfpath, target) == VERROR)
  104.         return(NO);
  105.     else if (CFLAG == YES)
  106.         warn2("creating %s from template %s", mfname, mfpath);
  107.     return(YES);
  108. }
  109.  
  110.  
  111.  
  112. /*
  113.  * findmftemplate() returns the pathname of a makefile template in mfpath.
  114.  */
  115. void
  116. findmftemplate(mfpath, target)
  117.     char *mfpath;            /* path to target makefile */
  118.     TARGET *target;            /* type of makefile target */
  119. {
  120.     extern char *L_MAKEFILE;    /* library makefile template */
  121.     extern char *P_MAKEFILE;    /* program makefile template */
  122.     char *cwp;            /* current project pathname pointer */
  123.     char *getcwp();            /* get current project pathname */
  124.     char *pathcat();        /* pathname concatenation */
  125.     char *strcpy();            /* string copy */
  126.  
  127.     cwp = getcwp();
  128.     if (target->type == VPROGRAM)
  129.         {
  130.         if (*P_MAKEFILE == _RDIRC)
  131.             strcpy(mfpath, P_MAKEFILE);
  132.         else if (cwp == NULL ||
  133.              !FILEXIST(pathcat(mfpath, pathcat(mfpath, cwp, "lib"), P_MAKEFILE)))
  134.             pathcat(mfpath, SPMSLIB, P_MAKEFILE);
  135.         }
  136.     else if (target->type == VLIBRARY)
  137.         {
  138.         if (*L_MAKEFILE == _RDIRC)
  139.             strcpy(mfpath, L_MAKEFILE);
  140.         else if (cwp == NULL ||
  141.              !FILEXIST(pathcat(mfpath, pathcat(mfpath, cwp, "lib"), L_MAKEFILE)))
  142.             pathcat(mfpath, SPMSLIB, L_MAKEFILE);
  143.         }
  144.     else
  145.         warn("unknown template request");
  146. }
  147.  
  148.  
  149.  
  150. /*
  151.  * gettoken() copies the next token from token buffer to token. Returns a
  152.  * pointer to the first character after the token, or null upon reaching
  153.  * the end of the token buffer.
  154.  */
  155. char *
  156. gettoken(token, tp)
  157.     register char *token;        /* receiving token */
  158.     register char *tp;        /* token buffer pointer */
  159. {
  160.     while (isspace(*tp) && *tp != '\0')
  161.         tp++;
  162.     if (*tp == '\0')
  163.         {
  164.         *token = '\0';
  165.         return(NULL);
  166.         }
  167.     while (!isspace(*tp) && *tp != '\0')
  168.         *token++ = *tp++;
  169.     *token = '\0';
  170.     return(tp);
  171. }
  172.  
  173.  
  174.  
  175. /*
  176.  * putobj() converts a source file name to an object file name and then
  177.  * writes the file name to stream.
  178.  */
  179. void
  180. putobj(s, stream)
  181.     register char *s;        /* source file name */
  182.     register FILE *stream;        /* output stream */
  183. {
  184.     extern char OBJSFX[];        /* object file name suffix */
  185.     register char *dot;        /* pointer to suffix */
  186.     char *rindex();            /* last occurrence of character */
  187.  
  188.     dot = rindex(s, '.');
  189.     while (s != dot)
  190.         putc(*s++, stream);
  191.     fprintf(stream, "%s", OBJSFX);
  192. }
  193.  
  194.  
  195.  
  196. /*
  197.  * readmf() reads a makefile and loads CFLAGS, FFLAGS, and SUFFIX definitions
  198.  * into the macro definition table if they do not already exist. Returns
  199.  * integer VLIBRARY, VPROGRAM, or VUNKNOWN according to the type of makefile,
  200.  * or VERROR if cannot open makefile.
  201.  */
  202. readmf(mfname, target)
  203.     char *mfname;            /* name of makefile */
  204.     TARGET *target;            /* type of makefile target */
  205. {
  206.     register char *bp;        /* buffer pointer */
  207.     extern char IOBUF[];        /* I/O buffer line */
  208.     extern HASH *MDEFTABLE;        /* macro definition table */
  209.     char *findmacro();        /* is the line a macro definition? */
  210.     char *findrule();        /* is the line a rule definition? */
  211.     char *getlin();            /* get a line from input stream */
  212.     char *getmacro();        /* get macro def from input stream */
  213.     char macrodef[MACRODEFSIZE];    /* macro definition buffer */
  214.     char macroname[MACRONAMSIZE];    /* macro name buffer */
  215.     char rulename[2*SUFFIXSIZE+3];    /* transformation rule name */
  216.     FILE *fopen();            /* open file */
  217.     FILE *fp;            /* file pointer */
  218.     HASHBLK *htinstall();        /* install hash table entry */
  219.     HASHBLK *htlookup();        /* find hash table entry */
  220.     int storerule();        /* store transformation rule */
  221.  
  222.     target->type = target->dest = VUNKNOWN;
  223.     if ((fp = fopen(mfname, "r")) == NULL)
  224.         {
  225.         pperror(mfname);
  226.         target->type = VERROR;
  227.         return(target->type);
  228.         }
  229.     while (getlin(fp) != NULL)
  230.         {
  231.         if (EQUAL(IOBUF, DEPENDMARK))
  232.             break;
  233.         for (bp = IOBUF; *bp == ' '; bp++)
  234.             continue;
  235.         if (isalnum(*bp) && findmacro(macroname, bp) != NULL)
  236.             {
  237.             if (EQUAL(macroname, MPROGRAM))
  238.                 {
  239.                 target->type = VPROGRAM;
  240.                 continue;
  241.                 }
  242.             else if (EQUAL(macroname, MLIBRARY))
  243.                 {
  244.                 target->type = VLIBRARY;
  245.                 continue;
  246.                 }
  247.             else if (EQUAL(macroname, MDESTDIR))
  248.                 {
  249.                 target->dest = VDESTDIR;
  250.                 continue;
  251.                 }
  252.  
  253.             /* does macro definition already exist? */
  254.             if (htlookup(macroname, MDEFTABLE) != NULL)
  255.                 continue;
  256.  
  257.             if (EQUAL(macroname, MCFLAGS) ||
  258.                 EQUAL(macroname, MFFLAGS) ||
  259.                 EQUAL(macroname, MPFLAGS) ||
  260.                 EQUAL(macroname, MSUFFIX))
  261.                 {
  262.                 if (htinstall(macroname, getmacro(macrodef, fp),
  263.                           VREADONLY, MDEFTABLE) == NULL)
  264.                     {
  265.                     fclose(fp);
  266.                     return(NO);
  267.                     }
  268.                 }
  269.             }
  270.         else if (*bp == '.' && findrule(rulename, bp) != NULL)
  271.             {
  272.             if (storerule(rulename) == NO)
  273.                 {
  274.                 fclose(fp);
  275.                 return(NO);
  276.                 }
  277.             }
  278.         }
  279.     fclose(fp);
  280.     return(target->type);
  281. }
  282.