+/*
+ * Copyright (c) 1983, 1985, 1991, 1993 Peter J. Nicklin.
+ * Copyright (c) 1991, 1993 Version Technology.
+ * All Rights Reserved.
+ *
+ * $License: VT.1.1 $
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met: (1) Redistributions of source code must retain the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer. (2) Redistributions in binary form must reproduce the
+ * above copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution. (3) All advertising materials mentioning
+ * features or use of this software must display the following
+ * acknowledgement: ``This product includes software developed by
+ * Version Technology.'' Neither the name of Version Technology nor
+ * the name of Peter J. Nicklin may be used to endorse or promote
+ * products derived from this software without specific prior written
+ * permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY VERSION TECHNOLOGY ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL VERSION TECHNOLOGY BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+ * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ * Report problems and direct questions to nicklin@netcom.com
+ *
+ * $Header: depend.c,v 4.10 93/05/25 21:17:49 nicklin Exp $
+ *
+ * Author: Peter J. Nicklin
+ */
+#include <ctype.h>
+#include <stdio.h>
+#include "Mkmf.h"
+#include "config.h"
+#include "dlist.h"
+#include "hash.h"
+#include "macro.h"
+#include "null.h"
+#include "path.h"
+#include "slist.h"
+#include "stringx.h"
+#include "yesno.h"
+
+#define CURINCLUDE "./"
+#define TOLOWER(c) (isupper(c) ? tolower(c) : (c))
+#define ISWHITESPACE(c) (c == ' ' || c == '\t')
+#define SKIPWHITESPACE(c, f) while ((c = getc(f))==' ' || c=='\t'); ungetc(c,f);
+#define USRINCLUDE "/usr/include/"
+#define USRINCLUDECC "/usr/include/CC/"
+
+/*
+ * Include file state
+ */
+#define NOTFOUND 0 /* not found anywhere */
+#define EXTERNAL 1 /* not found in current directory */
+#define INTERNAL 2 /* found in current directory */
+#define FROMRULE 3 /* derived from tranformation rule */
+#define SYSTEM 4 /* a system header file */
+
+static char SYSINCLUDE[PATHSIZE]; /* /usr/include pathname buffer */
+static char SYSINCLUDECC[PATHSIZE]; /* /usr/include/CC pathname buffer */
+static int SYSINCLUDELEN; /* length of SYSINCLUDE */
+/*
+ * Include files are stored in hash tables by direct chaining (See
+ * p. 134 in `The C Programming Language' by Kernighan and Ritchie).
+ * Included include files are also added to a singly-linked list
+ * attached to the hash table entry for the include file.
+ */
+static HASH *C_INCLUDETABLE = NULL; /* C include file hash table */
+static HASH *CXX_INCLUDETABLE = NULL; /* C++ include file hash table */
+static HASH *F_INCLUDETABLE = NULL; /* Fortran include file hash table */
+static HASH *P_INCLUDETABLE = NULL; /* Pascal include file hash table */
+/*
+ * Additional include directories are specified via the -I compiler
+ * command line option. These directories are stored in singly-linked lists.
+ * We also assume that the last look-up directory is "/usr/include".
+ */
+static SLIST *C_INCDIR; /* C include directories */
+static SLIST *CXX_INCDIR; /* C++ include directories */
+static SLIST *F_INCDIR; /* Fortran include directories */
+static SLIST *P_INCDIR; /* Pascal include directories */
+
+SLIST *EXTLIST; /* external header file name list */
+SLIST *SYSLIST; /* system header file name list */
+
+extern char *PGN; /* program name */
+extern int SYSHDRS; /* search system header files? */
+extern HASH *MDEFTABLE; /* macro definition table */
+
+/*
+ * addincdir() adds directories containing include files to the
+ * appropriate singly-linked list. The pathnames to the directories
+ * are derived from makefile macro definitions.
+ */
+void
+addincdir()
+{
+ char *slappend(); /* append to singly-linked list */
+ HASHBLK *htb; /* hash table entry block */
+ HASHBLK *htlookup(); /* find hash table entry */
+ int cleanup(); /* remove temporary makefile and exit */
+ void getI(); /* get include directory pathnames */
+
+ /* initialize system include pathnames */
+ initsysinclude();
+
+ /* C CFLAGS macro */
+ if ((htb = htlookup(MCFLAGS, MDEFTABLE)) != NULL)
+ getI(htb->h_key, htb->h_def, C_INCDIR);
+ if (slappend(SYSINCLUDE, C_INCDIR) == NULL)
+ cleanup();
+
+ /* C++ CXXFLAGS macro */
+ if ((htb = htlookup(MCXXFLAGS, MDEFTABLE)) != NULL)
+ getI(htb->h_key, htb->h_def, CXX_INCDIR);
+
+ /* C++ C++FLAGS macro */
+ if ((htb = htlookup(MCPXFLAGS, MDEFTABLE)) != NULL)
+ getI(htb->h_key, htb->h_def, CXX_INCDIR);
+
+ /* C++ CCFLAGS macro */
+ if ((htb = htlookup(MCCFLAGS, MDEFTABLE)) != NULL)
+ getI(htb->h_key, htb->h_def, CXX_INCDIR);
+
+ if (slappend(SYSINCLUDECC, CXX_INCDIR) == NULL ||
+ slappend(SYSINCLUDE, CXX_INCDIR) == NULL)
+ cleanup();
+
+ /* Fortran FFLAGS macro */
+ if ((htb = htlookup(MFFLAGS, MDEFTABLE)) != NULL)
+ getI(htb->h_key, htb->h_def, F_INCDIR);
+ if (slappend(SYSINCLUDE, F_INCDIR) == NULL)
+ cleanup();
+
+ /* Pascal PFLAGS macro */
+ if ((htb = htlookup(MPFLAGS, MDEFTABLE)) != NULL)
+ getI(htb->h_key, htb->h_def, P_INCDIR);
+ if (slappend(SYSINCLUDE, P_INCDIR) == NULL)
+ cleanup();
+}
+
+
+
+/*
+ * findinclude() tries to find the pathname of an include file. Returns
+ * integer INTERNAL if found in the current directory, EXTERNAL if found
+ * somewhere else, FROMRULE if derived from a transformation rule,
+ * SYSTEM if a system header file, otherwise NOTFOUND. The pathname
+ * is copied into incpath.
+ */
+#define LOCALDIR(f) (strchr(f, _PSC) == NULL)
+#define ISYSINCLUDE(f) (strncmp(f, SYSINCLUDE, SYSINCLUDELEN) == 0)
+#define INCLUDETYPE(f) (LOCALDIR(f) ? INTERNAL : (ISYSINCLUDE(f) ? SYSTEM : EXTERNAL))
+
+findinclude(incpath, incname, lastname, type)
+ char *incpath; /* pathname receiving buffer */
+ register char *incname; /* include file name */
+ char *lastname; /* file that includes incname */
+ int type; /* file type */
+{
+ register char *pp; /* include file path pointer */
+ char *optpath(); /* optimize pathname */
+ char *pathcat(); /* pathname concatenation */
+ char *pathhead(); /* remove pathname tail */
+ char *strpcpy(); /* string copy and update pointer */
+ int applyrule(); /* apply transformation rules */
+ SLBLK *slb; /* singly-linked list block */
+ SLIST *slist; /* include directory list pointer */
+
+ /*
+ * look for an absolute include file name
+ */
+ if (*incname == '/')
+ {
+ strcpy(incpath, incname);
+ return(FILEXIST(incpath) ? INCLUDETYPE(incpath) : NOTFOUND);
+ }
+
+ /*
+ * search the current include directory for an #include file
+ * whose name is enclosed in " ", or see if it can be generated
+ * by a transformation rule in the current working directory.
+ */
+ if (*incname != '<')
+ {
+ if (LOCALDIR(lastname))
+ {
+ if (LOCALDIR(incname))
+ {
+ if (applyrule(incname, incpath) == YES)
+ return(FROMRULE);
+ }
+ strcpy(incpath, incname);
+ if (FILEXIST(incpath))
+ return(INCLUDETYPE(incpath));
+ }
+ else {
+ strcpy(incpath, lastname);
+ pathcat(incpath, pathhead(incpath), incname);
+ optpath(incpath);
+ if (FILEXIST(incpath))
+ return(INCLUDETYPE(incpath));
+ }
+ }
+
+ /*
+ * search directory list
+ */
+ switch (type)
+ {
+ case INCLUDE_C:
+ slist = C_INCDIR;
+ break;
+ case INCLUDE_CXX:
+ slist = CXX_INCDIR;
+ break;
+ case INCLUDE_FORTRAN:
+ slist = F_INCDIR;
+ break;
+ case INCLUDE_PASCAL:
+ slist = P_INCDIR;
+ break;
+ }
+ for (slb = slist->head; slb != NULL; slb = slb->next)
+ {
+ pp = strpcpy(incpath, slb->key);
+ if (*incname == '<')
+ {
+ pp = strpcpy(pp, incname+1);
+ pp[-1] = '\0';
+ }
+ else {
+ strcpy(pp, incname);
+ }
+ optpath(incpath);
+ if (FILEXIST(incpath))
+ return(INCLUDETYPE(incpath));
+ }
+
+ return(NOTFOUND);
+}
+
+
+
+/*
+ * getI() appends include directories found via the -I compiler option to
+ * a singly linked list.
+ */
+void
+getI(mnam, mdef, slist)
+ char *mnam; /* compiler options macro name */
+ char *mdef; /* compiler options macro definition */
+ SLIST *slist; /* singly-linked list */
+{
+ char *getoption(); /* get next token */
+ char incpath[PATHSIZE]; /* include directory pathname buffer */
+ char *slappend(); /* append to singly-linked list */
+ int cleanup(); /* remove temporary makefile and exit */
+
+ while ((mdef = getoption(incpath, mdef, "-I")) != NULL)
+ {
+ if (*incpath == '\0')
+ {
+ warns("missing include directory in %s macro definition", mnam);
+ break;
+ }
+ else {
+ strcat(incpath, PATHSEP);
+ if (slappend(incpath, slist) == NULL)
+ cleanup();
+ }
+ }
+}
+
+
+
+/*
+ * getinclude() fetchs an include file name from a line of source code.
+ * /usr/include '<' and '>' delimiters remain with the filename to
+ * distinguish it from an include file in a local directory. Returns
+ * NO if syntax error, otherwise YES.
+ */
+getinclude(incname, curname, lineno, ifp)
+ char *curname; /* current file name */
+ char *incname; /* include file name receiving buffer */
+ int lineno; /* current line number */
+ register FILE *ifp; /* input stream */
+{
+ register char *ip; /* include file name buffer pointer */
+ register int c; /* current character */
+
+ SKIPWHITESPACE(c, ifp);
+ for (ip = incname; (c = getc(ifp)) != EOF; ip++)
+ {
+ *ip = c;
+ if (c == '\n' || c == '\t' || c == ' ' ||
+ c == ';' || c == ',' || c == '$' )
+ {
+ ungetc(c, ifp);
+ break;
+ }
+ }
+ *ip = '\0';
+ if ((*incname == '<' && ip[-1] != '>') ||
+ (*incname == '\"' && ip[-1] != '\"') ||
+ (*incname == '\'' && ip[-1] != '\'') ||
+ (*incname == '(' && ip[-1] != ')'))
+ {
+ fprintf(stderr,
+ "%s: \"%s\", line %d: bad include syntax for %s\n",
+ PGN, curname, lineno, incname);
+ return(NO);
+ }
+ if (*incname == '\"' || *incname == '\'' || *incname == '(')
+ {
+ ip[-1] = '\0';
+ ip = incname + 1;
+ while (*incname++ = *ip++)
+ continue;
+ }
+ return(YES);
+}
+
+
+
+/*
+ * inclink() stores a pointer to a hash table block (which contains
+ * include file information) somewhere. Returns a pointer to the somewhere,
+ * or calls cleanup() if out of memory.
+ */
+INCBLK *
+inclink(htb)
+ HASHBLK *htb; /* hash table block pointer to save */
+{
+ char *malloc(); /* memory allocator */
+ INCBLK *iblk; /* pointer to new include chain block */
+ int cleanup(); /* remove temporary makefile and exit */
+
+ if ((iblk = (INCBLK *) malloc(sizeof(INCBLK))) == NULL)
+ {
+ nocore();
+ cleanup();
+ }
+ iblk->i_loop = NO;
+ iblk->i_hblk = htb;
+ iblk->i_next = NULL;
+ return(iblk);
+}
+
+
+
+/*
+ * instalinclude() adds an include file name to the appropriate include
+ * file hash table. Returns a pointer to the hash table block, or calls
+ * cleanup() if out of memory.
+ */
+HASHBLK *
+instalinclude(incname, incpath, type)
+ char *incname; /* name of include file */
+ char *incpath; /* path to include file */
+ int type; /* type of source file */
+{
+ HASH *htinit(); /* initialize hash table */
+ HASHBLK *htb; /* hash table block */
+ HASHBLK *htinstall(); /* install hash table entry */
+ int cleanup(); /* remove temporary makefile and exit */
+ int ilen; /* include path length */
+
+ ilen = strlen(incpath);
+ switch (type)
+ {
+ case INCLUDE_C:
+ if (C_INCLUDETABLE == NULL)
+ {
+ C_INCLUDETABLE = htinit(INCLUDETABLESIZE);
+ }
+ htb = htinstall(incname, incpath, ilen, C_INCLUDETABLE);
+ break;
+ case INCLUDE_CXX:
+ if (CXX_INCLUDETABLE == NULL)
+ {
+ CXX_INCLUDETABLE = htinit(INCLUDETABLESIZE);
+ }
+ htb = htinstall(incname, incpath, ilen, CXX_INCLUDETABLE);
+ break;
+ case INCLUDE_FORTRAN:
+ if (F_INCLUDETABLE == NULL)
+ {
+ F_INCLUDETABLE = htinit(INCLUDETABLESIZE);
+ }
+ htb = htinstall(incname, incpath, ilen, F_INCLUDETABLE);
+ break;
+ case INCLUDE_PASCAL:
+ if (P_INCLUDETABLE == NULL)
+ {
+ P_INCLUDETABLE = htinit(INCLUDETABLESIZE);
+ }
+ htb = htinstall(incname, incpath, ilen, P_INCLUDETABLE);
+ break;
+ default:
+ htb = NULL;
+ break;
+ }
+ if (htb == NULL)
+ cleanup();
+ return(htb);
+}
+
+
+
+/*
+ * lookupinclude() returns a pointer to an include hash table block
+ * corresponding to incname and type. Returns null if not found.
+ */
+HASHBLK *
+lookupinclude(incname, type)
+ char *incname; /* name of include file */
+ int type; /* type of source file */
+{
+ HASH *includetable; /* include file hash table */
+ HASHBLK *htlookup(); /* find hash table entry */
+
+ switch (type)
+ {
+ case INCLUDE_C:
+ includetable = C_INCLUDETABLE;
+ break;
+ case INCLUDE_CXX:
+ includetable = CXX_INCLUDETABLE;
+ break;
+ case INCLUDE_FORTRAN:
+ includetable = F_INCLUDETABLE;
+ break;
+ case INCLUDE_PASCAL:
+ includetable = P_INCLUDETABLE;
+ break;
+ default:
+ includetable = NULL;
+ break;
+ }
+ return((includetable == NULL) ? NULL : htlookup(incname, includetable));
+}
+
+
+
+/*
+ * mkdepend() creates include file dependencies for object files and installs
+ * them to dependency list dlp. Returns a pointer to the dependency list.
+ */
+DLIST *
+mkdepend()
+{
+ extern SLIST *SRCLIST; /* source file name list */
+ char *suffix; /* suffix pointer */
+ DLBLK *dlappend(); /* append dependency list */
+ DLIST *dlinit(); /* initialize dependency list */
+ DLIST *dlist; /* dependency list */
+ INCBLK *ibp; /* pointer to chain of include files */
+ INCBLK *readC(); /* read C include-style files */
+ INCBLK *readF(); /* read Fortran include-style files */
+ INCBLK *readP(); /* read Pascal include-style files */
+ int cleanup(); /* remove temporary makefile and exit */
+ int lookuptypeofinclude(); /* look up the brand of include */
+ int slsort(); /* sort singly-linked list */
+ int type; /* source file type */
+ SLBLK *lbp; /* list block pointer */
+ SLIST *slinit(); /* initialize singly-linked list */
+ void addincdir(); /* add to list of include directories */
+ void rmprinttag(); /* remove "already printed" tags */
+
+ /* initialize include file look-up lists */
+ C_INCDIR = slinit();
+ CXX_INCDIR = slinit();
+ F_INCDIR = slinit();
+ P_INCDIR = slinit();
+
+ /* add additional include directories */
+ addincdir();
+
+ /* initialize external and system header file name lists */
+ EXTLIST = slinit();
+ SYSLIST = slinit();
+
+ /* initialize dependency list */
+ dlist = dlinit();
+
+ for (lbp = SRCLIST->head; lbp != NULL; lbp = lbp->next)
+ {
+ suffix = strrchr(lbp->key, '.');
+ type = lookuptypeofinclude(++suffix);
+ switch (type)
+ {
+ case INCLUDE_C:
+ case INCLUDE_CXX:
+ ibp = readC(lbp->key, 0, lbp->key, type);
+ break;
+ case INCLUDE_FORTRAN:
+ ibp = readF(lbp->key, 0, lbp->key, type);
+ break;
+ case INCLUDE_PASCAL:
+ ibp = readP(lbp->key, 0, lbp->key, type);
+ break;
+ case INCLUDE_NONE:
+ ibp = NULL;
+ break;
+ }
+ if (ibp != NULL)
+ {
+ if (dlappend(type, lbp, ibp, dlist) == NULL)
+ cleanup();
+ }
+ }
+ if (slsort(strcmp, EXTLIST) == NO || slsort(strcmp, SYSLIST) == NO)
+ cleanup();
+ return(dlist);
+}
+
+
+
+/*
+ * notfound() prints a "can't find" filename error message.
+ */
+void
+notfound(curname, lineno, incname)
+ char *curname; /* current file name */
+ char *incname; /* name of include file */
+ int lineno; /* current line number */
+{
+ if (PGN != NULL && *PGN != '\0')
+ {
+ fprintf(stderr, "%s: ", PGN);
+ }
+ if (*incname == '<')
+ {
+ fprintf(stderr, "\"%s\", line %d: can't find %s\n",
+ curname, lineno, incname);
+ }
+ else {
+ fprintf(stderr, "\"%s\", line %d: can't find \"%s\"\n",
+ curname, lineno, incname);
+ }
+}
+
+
+
+/*
+ * readC() searches C files for included files. Returns a pointer to
+ * the chain of include files installed or found in the include file
+ * hash table, or null if no include files found.
+ */
+INCBLK *
+readC(lastfile, lastline, curname, type)
+ char *lastfile; /* parent file name */
+ int lastline; /* current line in parent file */
+ char *curname; /* current file name */
+ int type; /* file type */
+{
+ register char *p; /* include string pointer */
+ register FILE *ifp; /* input file stream */
+ register int c; /* current character */
+ char incname[PATHSIZE]; /* name of include file */
+ char incpath[PATHSIZE]; /* path to include file */
+ char *slappend(); /* append pathname to list */
+ FILE *fopen(); /* open file */
+ HASHBLK *ftb; /* fromrule hash table entry block */
+ HASHBLK *htb; /* hash table entry block */
+ HASHBLK *instalinclude(); /* install include name in hash table */
+ HASHBLK *lookupinclude(); /* look up include in hash table */
+ INCBLK *i_head = NULL; /* head of include chain */
+ INCBLK *i_tail = NULL; /* tail of include chain */
+ INCBLK *inclink(); /* link include file hash blocks */
+ int cleanup(); /* remove temporary makefile and exit */
+ int findinclude(); /* locate include file */
+ int getinclude(); /* get include name from input line */
+ int inctype; /* origin of include file */
+ int lineno = 1; /* current line number */
+ void notfound(); /* print "can't find" filename msg */
+
+ if ((ifp = fopen(curname, "r")) == NULL)
+ {
+ if (lastline > 0)
+ fprintf(stderr, "%s: \"%s\", line %d: ", PGN,
+ lastfile, lastline);
+ else
+ fprintf(stderr, "%s: ", PGN);
+ perror(curname);
+ return(NULL);
+ }
+ while ((c = getc(ifp)) != EOF)
+ {
+ if (ISWHITESPACE(c))
+ continue;
+ if (c != '#')
+ goto nextline;
+ SKIPWHITESPACE(c, ifp);
+ for (p = "include"; (c = getc(ifp)) == *p && *p != '\0' ; p++)
+ continue;
+ if (*p != '\0')
+ goto nextline;
+ ungetc(c, ifp);
+ if (getinclude(incname, curname, lineno, ifp) == NO)
+ goto nextline;
+ if ((htb = lookupinclude(incname, type)) == NULL)
+ {
+ inctype = findinclude(incpath, incname, curname, type);
+ if (inctype == INTERNAL)
+ {
+ htb = instalinclude(incname, incpath, type);
+ }
+ else if (inctype == SYSTEM && SYSHDRS == YES)
+ {
+ htb = instalinclude(incname, incpath, type);
+ if (slappend(incpath, SYSLIST) == NULL)
+ cleanup();
+ }
+ else if (inctype == SYSTEM && SYSHDRS == NO)
+ {
+ goto nextline;
+ }
+ else if (inctype == EXTERNAL)
+ {
+ htb = instalinclude(incname, incpath, type);
+ if (slappend(incpath, EXTLIST) == NULL)
+ cleanup();
+ }
+ else if (inctype == FROMRULE)
+ {
+ htb = instalinclude(incname, incname, type);
+ ftb = instalinclude(incpath, incpath, type);
+ }
+ else {
+ notfound(curname, lineno, incname);
+ goto nextline;
+ }
+
+ /* look for nested include files */
+ htb->h_sub = readC(curname, lineno, incpath, type);
+
+ if (inctype == FROMRULE)
+ ftb->h_sub = htb->h_sub;
+ }
+ if (i_tail == NULL)
+ {
+ i_head = i_tail = inclink(htb);
+ }
+ else {
+ i_tail = i_tail->i_next = inclink(htb);
+ }
+nextline: while (c != '\n' && c != EOF)
+ c = getc(ifp);
+ lineno++;
+ }
+ fclose(ifp);
+ return(i_head);
+}
+
+
+
+/*
+ * readF() searches Fortran files for included files. Returns a pointer
+ * to the chain of include files installed or found in the include file
+ * hash table, or null if no include files found.
+ */
+INCBLK *
+readF(lastfile, lastline, curname, type)
+ char *lastfile; /* parent file name */
+ int lastline; /* current line in parent file */
+ char *curname; /* current file name */
+ int type; /* file type */
+{
+ register char *p; /* include string pointer */
+ register FILE *ifp; /* input file stream */
+ register int c; /* current character */
+ char incname[PATHSIZE]; /* name of include file */
+ char incpath[PATHSIZE]; /* path to include file */
+ char *slappend(); /* append pathname to list */
+ FILE *fopen(); /* open file */
+ HASHBLK *ftb; /* fromrule hash table entry block */
+ HASHBLK *htb; /* hash table entry block */
+ HASHBLK *instalinclude(); /* install include name in hash table */
+ HASHBLK *lookupinclude(); /* look up include in hash table */
+ INCBLK *i_head = NULL; /* head of include chain */
+ INCBLK *i_tail = NULL; /* tail of include chain */
+ INCBLK *inclink(); /* link include file hash blocks */
+ int cleanup(); /* remove temporary makefile and exit */
+ int findinclude(); /* locate include file */
+ int getinclude(); /* get include name from input line */
+ int inctype; /* origin of include file */
+ int lineno = 1; /* current line number */
+ void notfound(); /* print "can't find" filename msg */
+
+ if ((ifp = fopen(curname, "r")) == NULL)
+ {
+ if (lastline > 0)
+ fprintf(stderr, "%s: \"%s\", line %d: ", PGN,
+ lastfile, lastline);
+ else
+ fprintf(stderr, "%s: ", PGN);
+ perror(curname);
+ return(NULL);
+ }
+ while ((c = getc(ifp)) != EOF)
+ {
+ if (c == 'c' || c == 'C' || c == '*' || c == '\n')
+ goto nextline;
+ while ((c = getc(ifp)) == ' ' || c == '\t' || c == '#' || c == '$')
+ continue;
+ for (p = "include"; *p == TOLOWER(c) && *p != '\0'; p++)
+ c = getc(ifp);
+ if (*p != '\0')
+ goto nextline;
+ ungetc(c, ifp);
+ if (getinclude(incname, curname, lineno, ifp) == NO)
+ goto nextline;
+ if ((htb = lookupinclude(incname, type)) == NULL)
+ {
+ inctype = findinclude(incpath, incname, curname, type);
+ if (inctype == INTERNAL)
+ {
+ htb = instalinclude(incname, incpath, type);
+ }
+ else if (inctype == SYSTEM && SYSHDRS == YES)
+ {
+ htb = instalinclude(incname, incpath, type);
+ if (slappend(incpath, SYSLIST) == NULL)
+ cleanup();
+ }
+ else if (inctype == SYSTEM && SYSHDRS == NO)
+ {
+ goto nextline;
+ }
+ else if (inctype == EXTERNAL)
+ {
+ htb = instalinclude(incname, incpath, type);
+ if (slappend(incpath, EXTLIST) == NULL)
+ cleanup();
+ }
+ else if (inctype == FROMRULE)
+ {
+ htb = instalinclude(incname, incname, type);
+ ftb = instalinclude(incpath, incpath, type);
+ }
+ else {
+ notfound(curname, lineno, incname);
+ goto nextline;
+ }
+
+ /* look for nested include files */
+ htb->h_sub = readF(curname, lineno, incpath, type);
+
+ if (inctype == FROMRULE)
+ ftb->h_sub = htb->h_sub;
+ }
+ if (i_tail == NULL)
+ {
+ i_head = i_tail = inclink(htb);
+ }
+ else {
+ i_tail = i_tail->i_next = inclink(htb);
+ }
+nextline: while (c != '\n' && c != EOF)
+ c = getc(ifp);
+ lineno++;
+ }
+ fclose(ifp);
+ return(i_head);
+}
+
+
+
+/*
+ * readP() searches Pascal files for included files. Returns a pointer
+ * to the chain of include files installed or found in the include file
+ * hash table, or null if no include files found.
+ */
+INCBLK *
+readP(lastfile, lastline, curname, type)
+ char *lastfile; /* parent file name */
+ int lastline; /* current line in parent file */
+ char *curname; /* current file name */
+ int type; /* file type */
+{
+ register char *p; /* include string pointer */
+ register FILE *ifp; /* input file stream */
+ register int c; /* current character */
+ char incname[PATHSIZE]; /* name of include file */
+ char incpath[PATHSIZE]; /* path to include file */
+ char *slappend(); /* append pathname to list */
+ FILE *fopen(); /* open file */
+ HASHBLK *ftb; /* fromrule hash table entry block */
+ HASHBLK *htb; /* hash table entry block */
+ HASHBLK *instalinclude(); /* install include name in hash table */
+ HASHBLK *lookupinclude(); /* look up include in hash table */
+ INCBLK *i_head = NULL; /* head of include chain */
+ INCBLK *i_tail = NULL; /* tail of include chain */
+ INCBLK *inclink(); /* link include file hash blocks */
+ int cleanup(); /* remove temporary makefile and exit */
+ int findinclude(); /* locate include file */
+ int getinclude(); /* get include name from input line */
+ int inctype; /* origin of include file */
+ int lineno = 1; /* current line number */
+ void notfound(); /* print "can't find" filename msg */
+
+ if ((ifp = fopen(curname, "r")) == NULL)
+ {
+ if (lastline > 0)
+ fprintf(stderr, "%s: \"%s\", line %d: ", PGN,
+ lastfile, lastline);
+ else
+ fprintf(stderr, "%s: ", PGN);
+ perror(curname);
+ return(NULL);
+ }
+ while ((c = getc(ifp)) != EOF)
+ {
+ if (ISWHITESPACE(c))
+ continue;
+ if (c != '#' && c != '$')
+ goto nextline;
+ while ((c = getc(ifp)) == ' ' || c == '\t')
+ continue;
+ for (p = "include"; *p == TOLOWER(c) && *p != '\0'; p++)
+ c = getc(ifp);
+ if (*p != '\0')
+ goto nextline;
+ ungetc(c, ifp);
+ if (getinclude(incname, curname, lineno, ifp) == NO)
+ goto nextline;
+ if ((htb = lookupinclude(incname, type)) == NULL)
+ {
+ inctype = findinclude(incpath, incname, curname, type);
+ if (inctype == INTERNAL)
+ {
+ htb = instalinclude(incname, incpath, type);
+ }
+ else if (inctype == SYSTEM && SYSHDRS == YES)
+ {
+ htb = instalinclude(incname, incpath, type);
+ if (slappend(incpath, SYSLIST) == NULL)
+ cleanup();
+ }
+ else if (inctype == SYSTEM && SYSHDRS == NO)
+ {
+ goto nextline;
+ }
+ else if (inctype == EXTERNAL)
+ {
+ htb = instalinclude(incname, incpath, type);
+ if (slappend(incpath, EXTLIST) == NULL)
+ cleanup();
+ }
+ else if (inctype == FROMRULE)
+ {
+ htb = instalinclude(incname, incname, type);
+ ftb = instalinclude(incpath, incpath, type);
+ }
+ else {
+ notfound(curname, lineno, incname);
+ goto nextline;
+ }
+
+ /* look for nested include files */
+ htb->h_sub = readP(curname, lineno, incpath, type);
+
+ if (inctype == FROMRULE)
+ ftb->h_sub = htb->h_sub;
+ }
+ if (i_tail == NULL)
+ {
+ i_head = i_tail = inclink(htb);
+ }
+ else {
+ i_tail = i_tail->i_next = inclink(htb);
+ }
+nextline: while (c != '\n' && c != EOF)
+ c = getc(ifp);
+ lineno++;
+ }
+ fclose(ifp);
+ return(i_head);
+}
+
+initsysinclude()
+{
+ HASHBLK *htb; /* hash table entry block */
+ HASHBLK *htlookup(); /* find hash table entry */
+
+#ifdef _HasCompileSysType
+ if ((htb = htlookup(MCOMPILESYSTYPE, MDEFTABLE)) != NULL)
+ {
+ sprintf(SYSINCLUDE, "/%s", htb->h_def);
+ sprintf(SYSINCLUDECC, "/%s", htb->h_def);
+ }
+#endif
+
+ strcat(SYSINCLUDE, USRINCLUDE);
+ strcat(SYSINCLUDECC, USRINCLUDECC);
+ SYSINCLUDELEN = strlen(SYSINCLUDE)-1; /* length - last '/' */
+}
projects / unix-history / commitdiff