![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to buildlist.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / mkmf / src|
Return to buildlist.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / mkmf / src |
1.1 root 1: /* $Header: buildlist.c,v 1.3 86/01/12 00:49:30 lepreau Exp $ */
2:
3: /*
4: * Author: Peter J. Nicklin
5: */
6: #include <sys/types.h>
7: #include <sys/dir.h>
8: #include <stdio.h>
9: #include <ctype.h>
10: #include "Mkmf.h"
11: #include "hash.h"
12: #include "null.h"
13: #include "path.h"
14: #include "slist.h"
15: #include "suffix.h"
16: #include "system.h"
17: #include "yesno.h"
18:
19: /*
20: * buftolist() copies the items from a buffer to a singly-linked list.
21: * Returns integer YES if successful, otherwise NO.
22: */
23: buftolist(buf, list)
24: char *buf; /* item buffer */
25: SLIST *list; /* receiving list */
26: {
27: char *gettoken(); /* get next token */
28: char *slappend(); /* append file name to list */
29: char token[MAXNAMLEN]; /* item buffer */
30:
31: while ((buf = gettoken(token, buf)) != NULL)
32: {
33: if (slappend(token, list) == NULL)
34: return(NO);
35: }
36: return(YES);
37: }
38:
39:
40:
41: /*
42: * buildliblist() reads library pathnames from the LIBLIST macro
43: * definition, and adds them to the library pathname list. Libraries
44: * may be specified as `-lx'. Returns integer YES if successful,
45: * otherwise NO.
46: */
47: buildliblist()
48: {
49: extern SLIST *LIBLIST; /* library pathname list */
50: extern HASH *MDEFTABLE; /* macro definition table */
51: HASHBLK *htb; /* hash table block */
52: HASHBLK *htlookup(); /* find hash table entry */
53: int libbuftolist(); /* load library pathnames into list */
54: SLIST *slinit(); /* initialize singly-linked list */
55: void htrm(); /* remove hash table entry */
56:
57: LIBLIST = NULL;
58: if ((htb = htlookup(MLIBLIST, MDEFTABLE)) != NULL)
59: {
60: LIBLIST = slinit();
61: if (libbuftolist(htb->h_def, LIBLIST) == NO)
62: return(NO);
63: }
64: htrm(MLIBLIST, MDEFTABLE);
65: return(YES);
66: }
67:
68:
69:
70: /*
71: * buildsrclist() takes source and header file names from command line
72: * macro definitions or the current directory and appends them to source
73: * or header file name lists as appropriate. Returns integer YES if
74: * if successful, otherwise NO.
75: */
76: buildsrclist()
77: {
78: extern HASH *MDEFTABLE; /* macro definition table */
79: extern SLIST *HEADLIST; /* header file name list */
80: extern SLIST *SRCLIST; /* source file name list */
81: char *slappend(); /* append file name to list */
82: HASHBLK *headhtb; /* HEADERS macro hash table block */
83: HASHBLK *htlookup(); /* find hash table entry */
84: HASHBLK *srchtb; /* SOURCE macro hash table block */
85: int buftolist(); /* copy items from buffer to list */
86: int needheaders = 1; /* need header file names */
87: int needsource = 1; /* need source file names */
88: int read_dir(); /* read dir for source and headers */
89: int slsort(); /* sort singly-linked list */
90: int strcmp(); /* string comparison */
91: SLIST *slinit(); /* initialize singly-linked list */
92:
93: HEADLIST = slinit();
94: SRCLIST = slinit();
95:
96: /* build lists from command line macro definitions */
97: if ((headhtb = htlookup(MHEADERS, MDEFTABLE)) != NULL)
98: {
99: if (buftolist(headhtb->h_def, HEADLIST) == NO)
100: return(NO);
101: needheaders--;
102: }
103: if ((srchtb = htlookup(MSOURCE, MDEFTABLE)) != NULL)
104: {
105: if (buftolist(srchtb->h_def, SRCLIST) == NO)
106: return(NO);
107: needsource--;
108: }
109:
110: /* read the current directory to get source and header file names */
111: if (needheaders || needsource)
112: if (read_dir(needheaders, needsource) == NO)
113: return(NO);
114:
115: if (slsort(strcmp, SRCLIST) == NO)
116: return(NO);
117: if (slsort(strcmp, HEADLIST) == NO)
118: return(NO);
119: return(YES);
120: }
121:
122:
123:
124: /*
125: * expandlibpath() converts a library file specified by `-lx' into a full
126: * pathname. /lib and /usr/lib are searched for the library in the form
127: * libx.a. An integer YES is returned if the library was found, otherwise NO.
128: * A library file which doesn't begin with `-' is left unchanged.
129: */
130: expandlibpath(libpath)
131: char *libpath; /* library pathname buffer */
132: {
133: char *lib; /* /lib library pathname template */
134: char *strcpy(); /* string copy */
135: char *usrlib; /* /usr/lib library pathname template */
136: int i; /* library pathname index */
137:
138: lib = "/lib/libxxxxxxxxxxxxxxxxxxxxxxxxx";
139: usrlib = "/usr/lib/libxxxxxxxxxxxxxxxxxxxxxxxxx";
140:
141: if (libpath[0] == '-' && libpath[1] == 'l')
142: {
143: for (i = 0; libpath[i+2] != '\0' && i < 22; i++)
144: {
145: lib[i+8] = libpath[i+2];
146: usrlib[i+12] = libpath[i+2];
147: }
148: lib[i+8] = usrlib[i+12] = '.';
149: lib[i+9] = usrlib[i+13] = 'a';
150: lib[i+10] = usrlib[i+14] = '\0';
151: if (FILEXIST(lib))
152: {
153: strcpy(libpath, lib);
154: return(YES);
155: }
156: else if (FILEXIST(usrlib))
157: {
158: strcpy(libpath, usrlib);
159: return(YES);
160: }
161: else
162: return(NO);
163: }
164: return(YES);
165: }
166:
167:
168:
169: /*
170: * libbuftolist() appends each library pathname specified in libbuf to
171: * the liblist library pathname list.
172: */
173: libbuftolist(libbuf, liblist)
174: char *libbuf; /* library pathname buffer */
175: SLIST *liblist; /* library pathname list */
176: {
177: char *gettoken(); /* get next token */
178: char libpath[PATHSIZE]; /* library file pathname */
179: char *slappend(); /* append file name to list */
180: int expandlibpath(); /* -lx -> full library pathname */
181:
182: while ((libbuf = gettoken(libpath, libbuf)) != NULL)
183: {
184: if (expandlibpath(libpath) == NO)
185: {
186: warns("can't find library %s", libpath);
187: return(NO);
188: }
189: if (slappend(libpath, liblist) == NULL)
190: return(NO);
191: }
192: return(YES);
193: }
194:
195:
196:
197: /*
198: * read_dir() reads filenames from the current directory and adds them
199: * to the source or header file name lists as appropriate. Returns
200: * integer YES if successful, otherwise NO.
201: */
202: read_dir(needheaders, needsource)
203: int needheaders; /* need header file names */
204: int needsource; /* need source file names */
205: {
206: extern int AFLAG; /* accept src files w/ leading dots? */
207: extern SLIST *HEADLIST; /* header file name list */
208: extern SLIST *SRCLIST; /* source file name list */
209: char *rindex(); /* find last occurrence of character */
210: char *slappend(); /* append file name to list */
211: char *suffix; /* pointer to file name suffix */
212: char *p; /* beginning of file name component */
213: DIR *dirp; /* directory stream */
214: DIR *opendir(); /* open directory stream */
215: int lookupsfx(); /* get suffix type */
216: int sfxtyp; /* type of suffix */
217: struct direct *dp; /* directory entry pointer */
218: struct direct *readdir(); /* read a directory entry */
219:
220: if ((dirp = opendir(CURDIR)) == NULL)
221: {
222: warn("can't open current directory");
223: return(NO);
224: }
225: for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp))
226: if ((suffix = rindex(dp->d_name, '.')) != NULL)
227: {
228: if ((p = rindex(dp->d_name, '/')) != NULL)
229: p++;
230: else
231: p = dp->d_name;
232: if (*p == '.' && (AFLAG == 0))
233: continue;
234: suffix++;
235: sfxtyp = lookupsfx(suffix);
236: if (sfxtyp == SFXSRC)
237: {
238: if (needsource)
239: if (slappend(dp->d_name, SRCLIST) == NULL)
240: return(NO);
241: }
242: else if (sfxtyp == SFXHEAD)
243: {
244: if (needheaders)
245: if (slappend(dp->d_name, HEADLIST) == NULL)
246: return(NO);
247: }
248: }
249: closedir(dirp);
250: return(YES);
251: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.