![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to misc.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 misc.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / mkmf / src |
1.1 root 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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.