![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to depend.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / mkmf / src|
Return to depend.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / mkmf / src |
1.1 root 1: /* $Header: depend.c,v 1.14 86/05/15 09:01:04 lepreau Exp $ */
2:
3: /*
4: * Author: Peter J. Nicklin
5: */
6: #include <ctype.h>
7: #include <stdio.h>
8: #include "Mkmf.h"
9: #include "dlist.h"
10: #include "hash.h"
11: #include "macro.h"
12: #include "null.h"
13: #include "path.h"
14: #include "slist.h"
15: #include "system.h"
16: #include "yesno.h"
17:
18: #define USRINCLUDE "/usr/include/"
19: #define CURINCLUDE "./"
20: #define TOLOWER(c) (isupper(c) ? tolower(c) : (c))
21: #define SKIPWHITESPACE(c, f) while ((c = getc(f))==' ' || c=='\t'); ungetc(c,f);
22:
23: /*
24: * Include file state
25: */
26: #define NOTFOUND 0 /* not found anywhere */
27: #define EXTERNAL 1 /* not found in current directory */
28: #define INTERNAL 2 /* found in current directory */
29: #define FROMRULE 3 /* derived from tranformation rule */
30:
31: /*
32: * Include files are stored in hash tables by direct chaining (See
33: * p. 134 in `The C Programming Language' by Kernighan and Ritchie).
34: * Included include files are also added to a singly-linked list
35: * attached to the hash table entry for the include file.
36: */
37: static HASH *C_INCLUDETABLE = NULL; /* C include file hash table */
38: static HASH *F_INCLUDETABLE = NULL; /* Fortran include file hash table */
39: static HASH *P_INCLUDETABLE = NULL; /* Pascal include file hash table */
40: /*
41: * Additional include directories are specified via the -I compiler
42: * command line option. These directories are stored in singly-linked lists.
43: * We also assume that the last look-up directory is "/usr/include".
44: */
45: static SLIST *C_INCDIR; /* C include directories */
46: static SLIST *F_INCDIR; /* Fortran include directories */
47: static SLIST *P_INCDIR; /* Pascal include directories */
48:
49: SLIST *EXTLIST; /* external header file name list */
50:
51: extern char *PGN; /* program name */
52:
53: /*
54: * addincdir() adds directories containing include files to the
55: * appropriate singly-linked list. The pathnames to the directories
56: * are derived from makefile macro definitions.
57: */
58: void
59: addincdir()
60: {
61: extern HASH *MDEFTABLE; /* macro definition table */
62: char *slappend(); /* append to singly-linked list */
63: HASHBLK *htb; /* hash table entry block */
64: HASHBLK *htlookup(); /* find hash table entry */
65: int cleanup(); /* remove temporary makefile and exit */
66: void getI(); /* get include directory pathnames */
67:
68: /* C files */
69: if ((htb = htlookup(MCFLAGS, MDEFTABLE)) != NULL)
70: getI(htb->h_key, htb->h_def, C_INCDIR);
71: if (slappend(USRINCLUDE, C_INCDIR) == NULL)
72: cleanup();
73:
74: /* Fortran files */
75: if ((htb = htlookup(MFFLAGS, MDEFTABLE)) != NULL)
76: getI(htb->h_key, htb->h_def, F_INCDIR);
77: if (slappend(USRINCLUDE, F_INCDIR) == NULL)
78: cleanup();
79:
80: /* Pascal files */
81: if ((htb = htlookup(MPFLAGS, MDEFTABLE)) != NULL)
82: getI(htb->h_key, htb->h_def, P_INCDIR);
83: if (slappend(USRINCLUDE, P_INCDIR) == NULL)
84: cleanup();
85: }
86:
87:
88:
89: /*
90: * findinclude() tries to find the pathname of an include file. Returns
91: * integer INTERNAL if found in the current directory, EXTERNAL if found
92: * somewhere else, FROMRULE if derived from a transformation rule,
93: * otherwise NOTFOUND. The pathname is copied into incpath.
94: */
95: #define LOCALDIR(f) (index(f, _PSC) == NULL)
96: #define INCLUDETYPE(f) ((index(f, _PSC) == NULL) ? INTERNAL : EXTERNAL)
97:
98: findinclude(incpath, incname, lastname, type)
99: char *incpath; /* pathname receiving buffer */
100: register char *incname; /* include file name */
101: char *lastname; /* file that includes incname */
102: int type; /* file type */
103: {
104: register char *pp; /* include file path pointer */
105: char *index(); /* find occurrence of character */
106: char *optpath(); /* optimize pathname */
107: char *pathcat(); /* pathname concatenation */
108: char *pathhead(); /* remove pathname tail */
109: char *strcpy(); /* string copy */
110: char *strpcpy(); /* string copy and update pointer */
111: int lookuprule(); /* look up transformation rules */
112: SLBLK *slb; /* singly-linked list block */
113: SLIST *slist; /* include directory list pointer */
114:
115: /*
116: * look in /usr/include only
117: */
118: if (*incname == '<')
119: {
120: pp = strpcpy(incpath, USRINCLUDE);
121: for (incname++; *incname != '>'; incname++, pp++)
122: *pp = *incname;
123: *pp = '\0';
124: return(FILEXIST(incpath) ? EXTERNAL : NOTFOUND);
125: }
126:
127: /*
128: * look for an absolute include file name
129: */
130: if (*incname == '/')
131: {
132: strcpy(incpath, incname);
133: return(FILEXIST(incpath) ? EXTERNAL : NOTFOUND);
134: }
135:
136: /*
137: * look in current include directory to see if the file exists,
138: * or can be generated by a transformation rule in the current
139: * working directory.
140: */
141: if (LOCALDIR(lastname))
142: {
143: if (LOCALDIR(incname))
144: {
145: if (lookuprule(incname, incpath) == YES)
146: return(FROMRULE);
147: }
148: strcpy(incpath, incname);
149: if (FILEXIST(incpath))
150: return(INCLUDETYPE(incpath));
151: }
152: else {
153: strcpy(incpath, lastname);
154: pathcat(incpath, pathhead(incpath), incname);
155: optpath(incpath);
156: if (FILEXIST(incpath))
157: return(INCLUDETYPE(incpath));
158: }
159:
160: /*
161: * search directory list
162: */
163: switch (type)
164: {
165: case INCLUDE_C:
166: slist = C_INCDIR;
167: break;
168: case INCLUDE_FORTRAN:
169: slist = F_INCDIR;
170: break;
171: case INCLUDE_PASCAL:
172: slist = P_INCDIR;
173: break;
174: }
175: for (slb = slist->head; slb != NULL; slb = slb->next)
176: {
177: pp = strpcpy(incpath, slb->key);
178: strcpy(pp, incname);
179: optpath(incpath);
180: if (FILEXIST(incpath))
181: return(INCLUDETYPE(incpath));
182: }
183: return(NOTFOUND);
184: }
185:
186:
187:
188: /*
189: * getI() appends include directories found via the -I compiler option to
190: * a singly linked list.
191: */
192: void
193: getI(mnam, mdef, slist)
194: char *mnam; /* compiler options macro name */
195: char *mdef; /* compiler options macro definition */
196: SLIST *slist; /* singly-linked list */
197: {
198: char *gettoken(); /* get next token */
199: char incpath[PATHSIZE]; /* include directory pathname buffer */
200: char *slappend(); /* append to singly-linked list */
201: char *strcat(); /* string concatenation */
202: int cleanup(); /* remove temporary makefile and exit */
203:
204: while ((mdef = gettoken(incpath, mdef)) != NULL)
205: if (incpath[0] == '-' && incpath[1] == 'I')
206: if (incpath[2] == '\0') /* -I dir option */
207: {
208: if ((mdef = gettoken(incpath, mdef)) != NULL)
209: {
210: strcat(incpath, PATHSEP);
211: if (slappend(incpath, slist) == NULL)
212: cleanup();
213: }
214: else {
215: warn2("missing include directory in %s %s",
216: mnam, "macro definition");
217: break;
218: }
219: }
220: else { /* -Idir option */
221: strcat(incpath+2, PATHSEP);
222: if (slappend(incpath+2, slist) == NULL)
223: cleanup();
224: }
225: }
226:
227:
228:
229: /*
230: * getinclude() fetchs an include file name from a line of source code.
231: * /usr/include '<' and '>' delimiters remain with the filename to
232: * distinguish it from an include file in a local directory. Returns
233: * NO if syntax error, otherwise YES.
234: */
235: getinclude(incname, curname, lineno, ifp)
236: char *curname; /* current file name */
237: char *incname; /* include file name receiving buffer */
238: int lineno; /* current line number */
239: register FILE *ifp; /* input stream */
240: {
241: register char *ip; /* include file name buffer pointer */
242: register int c; /* current character */
243:
244: SKIPWHITESPACE(c, ifp);
245: for (ip = incname; (c = getc(ifp)) != EOF; ip++)
246: {
247: *ip = c;
248: if (c == '\n' || c == '\t' || c == ' ' || c == ';' || c == ',')
249: {
250: ungetc(c, ifp);
251: break;
252: }
253: }
254: *ip = '\0';
255: if ((*incname == '<' && ip[-1] != '>') ||
256: (*incname == '\"' && ip[-1] != '\"') ||
257: (*incname == '\'' && ip[-1] != '\'') ||
258: (*incname == '(' && ip[-1] != ')'))
259: {
260: fprintf(stderr,
261: "%s: \"%s\", line %d: bad include syntax for %s\n",
262: PGN, curname, lineno, incname);
263: return(NO);
264: }
265: if (*incname == '\"' || *incname == '\'' || *incname == '(')
266: {
267: ip[-1] = '\0';
268: ip = incname + 1;
269: while (*incname++ = *ip++)
270: continue;
271: }
272: return(YES);
273: }
274:
275:
276:
277: /*
278: * inclink() stores a pointer to a hash table block (which contains
279: * include file information) somewhere. Returns a pointer to the somewhere,
280: * or calls cleanup() if out of memory.
281: */
282: INCBLK *
283: inclink(htb)
284: HASHBLK *htb; /* hash table block pointer to save */
285: {
286: char *malloc(); /* memory allocator */
287: INCBLK *iblk; /* pointer to new include chain block */
288: int cleanup(); /* remove temporary makefile and exit */
289:
290: if ((iblk = (INCBLK *) malloc(sizeof(INCBLK))) == NULL)
291: {
292: warn("out of memory");
293: cleanup();
294: }
295: iblk->i_loop = NO;
296: iblk->i_hblk = htb;
297: iblk->i_next = NULL;
298: return(iblk);
299: }
300:
301:
302:
303: /*
304: * instalinclude() adds an include file name to the appropriate include
305: * file hash table. Returns a pointer to the hash table block, or calls
306: * cleanup() if out of memory.
307: */
308: HASHBLK *
309: instalinclude(incname, incpath, type)
310: char *incname; /* name of include file */
311: char *incpath; /* path to include file */
312: int type; /* type of source file */
313: {
314: HASH *htinit(); /* initialize hash table */
315: HASHBLK *htb = NULL; /* hash table block */
316: HASHBLK *htinstall(); /* install hash table entry */
317: int cleanup(); /* remove temporary makefile and exit */
318: int ilen; /* include path length */
319: int strlen(); /* string length */
320:
321: ilen = strlen(incpath);
322: switch (type)
323: {
324: case INCLUDE_C:
325: if (C_INCLUDETABLE == NULL)
326: {
327: C_INCLUDETABLE = htinit(INCLUDETABLESIZE);
328: }
329: htb = htinstall(incname, incpath, ilen, C_INCLUDETABLE);
330: break;
331: case INCLUDE_FORTRAN:
332: if (F_INCLUDETABLE == NULL)
333: {
334: F_INCLUDETABLE = htinit(INCLUDETABLESIZE);
335: }
336: htb = htinstall(incname, incpath, ilen, F_INCLUDETABLE);
337: break;
338: case INCLUDE_PASCAL:
339: if (P_INCLUDETABLE == NULL)
340: {
341: P_INCLUDETABLE = htinit(INCLUDETABLESIZE);
342: }
343: htb = htinstall(incname, incpath, ilen, P_INCLUDETABLE);
344: break;
345: }
346: if (htb == NULL)
347: cleanup();
348: return(htb);
349: }
350:
351:
352:
353: /*
354: * lookupinclude() returns a pointer to an include hash table block
355: * corresponding to incname and type. Returns null if not found.
356: */
357: HASHBLK *
358: lookupinclude(incname, type)
359: char *incname; /* name of include file */
360: int type; /* type of source file */
361: {
362: HASH *includetable = NULL; /* include file hash table */
363: HASHBLK *htlookup(); /* find hash table entry */
364:
365: switch (type)
366: {
367: case INCLUDE_C:
368: includetable = C_INCLUDETABLE;
369: break;
370: case INCLUDE_FORTRAN:
371: includetable = F_INCLUDETABLE;
372: break;
373: case INCLUDE_PASCAL:
374: includetable = P_INCLUDETABLE;
375: break;
376: }
377: return((includetable == NULL) ? NULL : htlookup(incname, includetable));
378: }
379:
380:
381:
382: /*
383: * mkdepend() creates include file dependencies for object files and installs
384: * them to dependency list dlp. Returns a pointer to the dependency list.
385: */
386: DLIST *
387: mkdepend()
388: {
389: extern SLIST *SRCLIST; /* source file name list */
390: char *rindex(); /* find last occurrence of character */
391: char *suffix; /* suffix pointer */
392: DLBLK *dlappend(); /* append dependency list */
393: DLIST *dlinit(); /* initialize dependency list */
394: DLIST *dlist; /* dependency list */
395: INCBLK *ibp; /* pointer to chain of include files */
396: INCBLK *readC(); /* read C include-style files */
397: INCBLK *readF(); /* read Fortran include-style files */
398: INCBLK *readP(); /* read Pascal include-style files */
399: int cleanup(); /* remove temporary makefile and exit */
400: int lookuptypeofinclude(); /* look up the brand of include */
401: int slsort(); /* sort singly-linked list */
402: int strcmp(); /* string comparison */
403: int type; /* source file type */
404: SLBLK *lbp; /* list block pointer */
405: SLIST *slinit(); /* initialize singly-linked list */
406: void addincdir(); /* add to list of include directories */
407: void rmprinttag(); /* remove "already printed" tags */
408:
409: /* initialize include file look-up lists */
410: C_INCDIR = slinit();
411: F_INCDIR = slinit();
412: P_INCDIR = slinit();
413:
414: /* add additional include directories */
415: addincdir();
416:
417: /* initialize external header file name list */
418: EXTLIST = slinit();
419:
420: /* initialize dependency list */
421: dlist = dlinit();
422:
423: for (lbp = SRCLIST->head; lbp != NULL; lbp = lbp->next)
424: {
425: suffix = rindex(lbp->key, '.');
426: type = lookuptypeofinclude(++suffix);
427: switch (type)
428: {
429: case INCLUDE_C:
430: ibp = readC(lbp->key, 0, lbp->key);
431: break;
432: case INCLUDE_FORTRAN:
433: ibp = readF(lbp->key, 0, lbp->key);
434: break;
435: case INCLUDE_PASCAL:
436: ibp = readP(lbp->key, 0, lbp->key);
437: break;
438: case INCLUDE_NONE:
439: ibp = NULL;
440: break;
441: }
442: if (ibp != NULL)
443: {
444: if (dlappend(type, lbp, ibp, dlist) == NULL)
445: cleanup();
446: }
447: }
448: if (slsort(strcmp, EXTLIST) == NO)
449: cleanup();
450: return(dlist);
451: }
452:
453:
454:
455: /*
456: * notfound() prints a "can't find" filename error message.
457: */
458: void
459: notfound(curname, lineno, incname)
460: char *curname; /* current file name */
461: char *incname; /* name of include file */
462: int lineno; /* current line number */
463: {
464: if (PGN != NULL && *PGN != '\0')
465: {
466: fprintf(stderr, "%s: ", PGN);
467: }
468: if (*incname == '<')
469: {
470: fprintf(stderr, "\"%s\", line %d: can't find %s\n",
471: curname, lineno, incname);
472: }
473: else {
474: fprintf(stderr, "\"%s\", line %d: can't find \"%s\"\n",
475: curname, lineno, incname);
476: }
477: }
478:
479:
480:
481: /*
482: * readC() searches C files for included files. Returns a pointer to
483: * the chain of include files installed or found in the include file
484: * hash table, or null if no include files found.
485: */
486: INCBLK *
487: readC(lastfile, lastline, curname)
488: char *lastfile; /* parent file name */
489: int lastline; /* current line in parent file */
490: char *curname; /* current file name */
491: {
492: register char *p; /* include string pointer */
493: register FILE *ifp; /* input file stream */
494: register int c; /* current character */
495: char incname[PATHSIZE]; /* name of include file */
496: char incpath[PATHSIZE]; /* path to include file */
497: char *slappend(); /* append pathname to list */
498: FILE *fopen(); /* open file */
499: HASHBLK *ftb; /* fromrule hash table entry block */
500: HASHBLK *htb = NULL; /* hash table entry block */
501: HASHBLK *instalinclude(); /* install include name in hash table */
502: HASHBLK *lookupinclude(); /* look up include in hash table */
503: INCBLK *i_head = NULL; /* head of include chain */
504: INCBLK *i_tail = NULL; /* tail of include chain */
505: INCBLK *inclink(); /* link include file hash blocks */
506: int cleanup(); /* remove temporary makefile and exit */
507: int findinclude(); /* locate include file */
508: int getinclude(); /* get include name from input line */
509: int inctype; /* origin of include file */
510: int lineno = 1; /* current line number */
511: int strlen(); /* string length */
512: int type; /* file type */
513: void notfound(); /* print "can't find" filename msg */
514:
515: type = INCLUDE_C;
516:
517: if ((ifp = fopen(curname, "r")) == NULL)
518: {
519: if (lastline > 0)
520: fprintf(stderr, "%s: \"%s\", line %d: ", PGN,
521: lastfile, lastline);
522: else
523: fprintf(stderr, "%s: ", PGN);
524: perror(curname);
525: return(NULL);
526: }
527: while ((c = getc(ifp)) != EOF)
528: {
529: if (c != '#')
530: goto nextline;
531: SKIPWHITESPACE(c, ifp);
532: for (p = "include"; (c = getc(ifp)) == *p && *p != '\0' ; p++)
533: continue;
534: if (*p != '\0')
535: goto nextline;
536: if (getinclude(incname, curname, lineno, ifp) == NO)
537: goto nextline;
538: if ((htb = lookupinclude(incname, type)) == NULL)
539: {
540: inctype = findinclude(incpath, incname, curname, type);
541: if (inctype == INTERNAL)
542: {
543: htb = instalinclude(incname, incpath, type);
544: }
545: else if (inctype == EXTERNAL)
546: {
547: htb = instalinclude(incname, incpath, type);
548: if (slappend(incpath, EXTLIST) == NULL)
549: cleanup();
550: }
551: else if (inctype == FROMRULE)
552: {
553: htb = instalinclude(incname, incname, type);
554: ftb = instalinclude(incpath, incpath, type);
555: }
556: else {
557: notfound(curname, lineno, incname);
558: goto nextline;
559: }
560:
561: /* look for nested include files */
562: htb->h_sub = readC(curname, lineno, incpath);
563:
564: if (inctype == FROMRULE)
565: ftb->h_sub = htb->h_sub;
566: }
567: if (i_tail == NULL)
568: {
569: i_head = i_tail = inclink(htb);
570: }
571: else {
572: i_tail = i_tail->i_next = inclink(htb);
573: }
574: nextline: while (c != '\n' && c != EOF)
575: c = getc(ifp);
576: lineno++;
577: }
578: fclose(ifp);
579: return(i_head);
580: }
581:
582:
583:
584: /*
585: * readF() searches Fortran files for included files. Returns a pointer
586: * to the chain of include files installed or found in the include file
587: * hash table, or null if no include files found.
588: */
589: INCBLK *
590: readF(lastfile, lastline, curname)
591: char *lastfile; /* parent file name */
592: int lastline; /* current line in parent file */
593: char *curname; /* current file name */
594: {
595: register char *p; /* include string pointer */
596: register FILE *ifp; /* input file stream */
597: register int c; /* current character */
598: char incname[PATHSIZE]; /* name of include file */
599: char incpath[PATHSIZE]; /* path to include file */
600: char *slappend(); /* append pathname to list */
601: FILE *fopen(); /* open file */
602: HASHBLK *ftb; /* fromrule hash table entry block */
603: HASHBLK *htb = NULL; /* hash table entry block */
604: HASHBLK *instalinclude(); /* install include name in hash table */
605: HASHBLK *lookupinclude(); /* look up include in hash table */
606: INCBLK *i_head = NULL; /* head of include chain */
607: INCBLK *i_tail = NULL; /* tail of include chain */
608: INCBLK *inclink(); /* link include file hash blocks */
609: int cleanup(); /* remove temporary makefile and exit */
610: int findinclude(); /* locate include file */
611: int getinclude(); /* get include name from input line */
612: int inctype; /* origin of include file */
613: int lineno = 1; /* current line number */
614: int strlen(); /* string length */
615: int type; /* file type */
616: void notfound(); /* print "can't find" filename msg */
617:
618: type = INCLUDE_FORTRAN;
619:
620: if ((ifp = fopen(curname, "r")) == NULL)
621: {
622: if (lastline > 0)
623: fprintf(stderr, "%s: \"%s\", line %d: ", PGN,
624: lastfile, lastline);
625: else
626: fprintf(stderr, "%s: ", PGN);
627: perror(curname);
628: return(NULL);
629: }
630: while ((c = getc(ifp)) != EOF)
631: {
632: if (c == 'c' || c == 'C' || c == '*' || c == '\n')
633: goto nextline;
634: while ((c = getc(ifp)) == ' ' || c == '\t')
635: continue;
636: for (p = "include"; *p == TOLOWER(c) && *p != '\0'; p++)
637: c = getc(ifp);
638: if (*p != '\0')
639: goto nextline;
640: if (getinclude(incname, curname, lineno, ifp) == NO)
641: goto nextline;
642: if ((htb = lookupinclude(incname, type)) == NULL)
643: {
644: inctype = findinclude(incpath, incname, curname, type);
645: if (inctype == INTERNAL)
646: {
647: htb = instalinclude(incname, incpath, type);
648: }
649: else if (inctype == EXTERNAL)
650: {
651: htb = instalinclude(incname, incpath, type);
652: if (slappend(incpath, EXTLIST) == NULL)
653: cleanup();
654: }
655: else if (inctype == FROMRULE)
656: {
657: htb = instalinclude(incname, incname, type);
658: ftb = instalinclude(incpath, incpath, type);
659: }
660: else {
661: notfound(curname, lineno, incname);
662: goto nextline;
663: }
664:
665: /* look for nested include files */
666: htb->h_sub = readF(curname, lineno, incpath);
667:
668: if (inctype == FROMRULE)
669: ftb->h_sub = htb->h_sub;
670: }
671: if (i_tail == NULL)
672: {
673: i_head = i_tail = inclink(htb);
674: }
675: else {
676: i_tail = i_tail->i_next = inclink(htb);
677: }
678: nextline: while (c != '\n' && c != EOF)
679: c = getc(ifp);
680: lineno++;
681: }
682: fclose(ifp);
683: return(i_head);
684: }
685:
686:
687:
688: /*
689: * readP() searches Pascal files for included files. Returns a pointer
690: * to the chain of include files installed or found in the include file
691: * hash table, or null if no include files found.
692: */
693: INCBLK *
694: readP(lastfile, lastline, curname)
695: char *lastfile; /* parent file name */
696: int lastline; /* current line in parent file */
697: char *curname; /* current file name */
698: {
699: register char *p; /* include string pointer */
700: register FILE *ifp; /* input file stream */
701: register int c; /* current character */
702: char incname[PATHSIZE]; /* name of include file */
703: char incpath[PATHSIZE]; /* path to include file */
704: char *slappend(); /* append pathname to list */
705: FILE *fopen(); /* open file */
706: HASHBLK *ftb; /* fromrule hash table entry block */
707: HASHBLK *htb = NULL; /* hash table entry block */
708: HASHBLK *instalinclude(); /* install include name in hash table */
709: HASHBLK *lookupinclude(); /* look up include in hash table */
710: INCBLK *i_head = NULL; /* head of include chain */
711: INCBLK *i_tail = NULL; /* tail of include chain */
712: INCBLK *inclink(); /* link include file hash blocks */
713: int cleanup(); /* remove temporary makefile and exit */
714: int findinclude(); /* locate include file */
715: int getinclude(); /* get include name from input line */
716: int inctype; /* origin of include file */
717: int lineno = 1; /* current line number */
718: int strlen(); /* string length */
719: int type; /* file type */
720: void notfound(); /* print "can't find" filename msg */
721:
722: type = INCLUDE_PASCAL;
723:
724: if ((ifp = fopen(curname, "r")) == NULL)
725: {
726: if (lastline > 0)
727: fprintf(stderr, "%s: \"%s\", line %d: ", PGN,
728: lastfile, lastline);
729: else
730: fprintf(stderr, "%s: ", PGN);
731: perror(curname);
732: return(NULL);
733: }
734: while ((c = getc(ifp)) != EOF)
735: {
736: if (c != '#')
737: goto nextline;
738: while ((c = getc(ifp)) == ' ' || c == '\t')
739: continue;
740: for (p = "include"; *p == TOLOWER(c) && *p != '\0'; p++)
741: c = getc(ifp);
742: if (*p != '\0')
743: goto nextline;
744: if (getinclude(incname, curname, lineno, ifp) == NO)
745: goto nextline;
746: if ((htb = lookupinclude(incname, type)) == NULL)
747: {
748: inctype = findinclude(incpath, incname, curname, type);
749: if (inctype == INTERNAL)
750: {
751: htb = instalinclude(incname, incpath, type);
752: }
753: else if (inctype == EXTERNAL)
754: {
755: htb = instalinclude(incname, incpath, type);
756: if (slappend(incpath, EXTLIST) == NULL)
757: cleanup();
758: }
759: else if (inctype == FROMRULE)
760: {
761: htb = instalinclude(incname, incname, type);
762: ftb = instalinclude(incpath, incpath, type);
763: }
764: else {
765: notfound(curname, lineno, incname);
766: goto nextline;
767: }
768:
769: /* look for nested include files */
770: htb->h_sub = readP(curname, lineno, incpath);
771:
772: if (inctype == FROMRULE)
773: ftb->h_sub = htb->h_sub;
774: }
775: if (i_tail == NULL)
776: {
777: i_head = i_tail = inclink(htb);
778: }
779: else {
780: i_tail = i_tail->i_next = inclink(htb);
781: }
782: nextline: while (c != '\n' && c != EOF)
783: c = getc(ifp);
784: lineno++;
785: }
786: fclose(ifp);
787: return(i_head);
788: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.