parse.c revision 1.127 1 1.127 dsl /* $NetBSD: parse.c,v 1.127 2007/01/01 21:47:32 dsl Exp $ */
2 1.15 christos
3 1.1 cgd /*
4 1.27 christos * Copyright (c) 1988, 1989, 1990, 1993
5 1.27 christos * The Regents of the University of California. All rights reserved.
6 1.94 agc *
7 1.94 agc * This code is derived from software contributed to Berkeley by
8 1.94 agc * Adam de Boor.
9 1.94 agc *
10 1.94 agc * Redistribution and use in source and binary forms, with or without
11 1.94 agc * modification, are permitted provided that the following conditions
12 1.94 agc * are met:
13 1.94 agc * 1. Redistributions of source code must retain the above copyright
14 1.94 agc * notice, this list of conditions and the following disclaimer.
15 1.94 agc * 2. Redistributions in binary form must reproduce the above copyright
16 1.94 agc * notice, this list of conditions and the following disclaimer in the
17 1.94 agc * documentation and/or other materials provided with the distribution.
18 1.94 agc * 3. Neither the name of the University nor the names of its contributors
19 1.94 agc * may be used to endorse or promote products derived from this software
20 1.94 agc * without specific prior written permission.
21 1.94 agc *
22 1.94 agc * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 1.94 agc * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 1.94 agc * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 1.94 agc * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 1.94 agc * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 1.94 agc * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 1.94 agc * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 1.94 agc * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 1.94 agc * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 1.94 agc * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 1.94 agc * SUCH DAMAGE.
33 1.94 agc */
34 1.94 agc
35 1.94 agc /*
36 1.1 cgd * Copyright (c) 1989 by Berkeley Softworks
37 1.1 cgd * All rights reserved.
38 1.1 cgd *
39 1.1 cgd * This code is derived from software contributed to Berkeley by
40 1.1 cgd * Adam de Boor.
41 1.1 cgd *
42 1.1 cgd * Redistribution and use in source and binary forms, with or without
43 1.1 cgd * modification, are permitted provided that the following conditions
44 1.1 cgd * are met:
45 1.1 cgd * 1. Redistributions of source code must retain the above copyright
46 1.1 cgd * notice, this list of conditions and the following disclaimer.
47 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
48 1.1 cgd * notice, this list of conditions and the following disclaimer in the
49 1.1 cgd * documentation and/or other materials provided with the distribution.
50 1.1 cgd * 3. All advertising materials mentioning features or use of this software
51 1.1 cgd * must display the following acknowledgement:
52 1.1 cgd * This product includes software developed by the University of
53 1.1 cgd * California, Berkeley and its contributors.
54 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
55 1.1 cgd * may be used to endorse or promote products derived from this software
56 1.1 cgd * without specific prior written permission.
57 1.1 cgd *
58 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
59 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
60 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
61 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
62 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
63 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
64 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
65 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
66 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
67 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
68 1.1 cgd * SUCH DAMAGE.
69 1.1 cgd */
70 1.1 cgd
71 1.96 ross #ifndef MAKE_NATIVE
72 1.127 dsl static char rcsid[] = "$NetBSD: parse.c,v 1.127 2007/01/01 21:47:32 dsl Exp $";
73 1.36 lukem #else
74 1.34 christos #include <sys/cdefs.h>
75 1.1 cgd #ifndef lint
76 1.15 christos #if 0
77 1.27 christos static char sccsid[] = "@(#)parse.c 8.3 (Berkeley) 3/19/94";
78 1.15 christos #else
79 1.127 dsl __RCSID("$NetBSD: parse.c,v 1.127 2007/01/01 21:47:32 dsl Exp $");
80 1.15 christos #endif
81 1.1 cgd #endif /* not lint */
82 1.36 lukem #endif
83 1.1 cgd
84 1.1 cgd /*-
85 1.1 cgd * parse.c --
86 1.1 cgd * Functions to parse a makefile.
87 1.1 cgd *
88 1.1 cgd * One function, Parse_Init, must be called before any functions
89 1.1 cgd * in this module are used. After that, the function Parse_File is the
90 1.1 cgd * main entry point and controls most of the other functions in this
91 1.1 cgd * module.
92 1.1 cgd *
93 1.1 cgd * Most important structures are kept in Lsts. Directories for
94 1.123 dsl * the .include "..." function are kept in the 'parseIncPath' Lst, while
95 1.123 dsl * those for the .include <...> are kept in the 'sysIncPath' Lst. The
96 1.1 cgd * targets currently being defined are kept in the 'targets' Lst.
97 1.1 cgd *
98 1.1 cgd * The variables 'fname' and 'lineno' are used to track the name
99 1.1 cgd * of the current file and the line number in that file so that error
100 1.1 cgd * messages can be more meaningful.
101 1.1 cgd *
102 1.1 cgd * Interface:
103 1.1 cgd * Parse_Init Initialization function which must be
104 1.1 cgd * called before anything else in this module
105 1.1 cgd * is used.
106 1.1 cgd *
107 1.9 jtc * Parse_End Cleanup the module
108 1.9 jtc *
109 1.1 cgd * Parse_File Function used to parse a makefile. It must
110 1.1 cgd * be given the name of the file, which should
111 1.1 cgd * already have been opened, and a function
112 1.1 cgd * to call to read a character from the file.
113 1.1 cgd *
114 1.1 cgd * Parse_IsVar Returns TRUE if the given line is a
115 1.1 cgd * variable assignment. Used by MainParseArgs
116 1.1 cgd * to determine if an argument is a target
117 1.1 cgd * or a variable assignment. Used internally
118 1.1 cgd * for pretty much the same thing...
119 1.1 cgd *
120 1.1 cgd * Parse_Error Function called when an error occurs in
121 1.1 cgd * parsing. Used by the variable and
122 1.1 cgd * conditional modules.
123 1.1 cgd * Parse_MainName Returns a Lst of the main target to create.
124 1.1 cgd */
125 1.1 cgd
126 1.84 wiz #include <ctype.h>
127 1.84 wiz #include <errno.h>
128 1.125 dsl #include <fcntl.h>
129 1.5 cgd #include <stdarg.h>
130 1.5 cgd #include <stdio.h>
131 1.84 wiz
132 1.1 cgd #include "make.h"
133 1.5 cgd #include "hash.h"
134 1.5 cgd #include "dir.h"
135 1.5 cgd #include "job.h"
136 1.1 cgd #include "buf.h"
137 1.1 cgd #include "pathnames.h"
138 1.1 cgd
139 1.1 cgd /*
140 1.1 cgd * These values are returned by ParseEOF to tell Parse_File whether to
141 1.1 cgd * CONTINUE parsing, i.e. it had only reached the end of an include file,
142 1.1 cgd * or if it's DONE.
143 1.1 cgd */
144 1.1 cgd #define CONTINUE 1
145 1.1 cgd #define DONE 0
146 1.1 cgd static Lst targets; /* targets we're working on */
147 1.45 mycroft #ifdef CLEANUP
148 1.9 jtc static Lst targCmds; /* command lines for targets */
149 1.45 mycroft #endif
150 1.1 cgd static Boolean inLine; /* true if currently in a dependency
151 1.1 cgd * line or its commands */
152 1.1 cgd static int fatals = 0;
153 1.1 cgd
154 1.1 cgd static GNode *mainNode; /* The main target to create. This is the
155 1.1 cgd * first target on the first dependency
156 1.1 cgd * line in the first makefile */
157 1.1 cgd typedef struct IFile {
158 1.122 dsl const char *fname; /* name of file */
159 1.122 dsl int lineno; /* line number in file */
160 1.125 dsl int fd; /* the open file */
161 1.123 dsl char *P_str; /* point to base of string buffer */
162 1.123 dsl char *P_ptr; /* point to next char of string buffer */
163 1.125 dsl char *P_end; /* point to the end of string buffer */
164 1.127 dsl int P_buflen; /* current size of file buffer */
165 1.5 cgd } IFile;
166 1.1 cgd
167 1.127 dsl #define IFILE_BUFLEN 0x8000
168 1.125 dsl static IFile *curFile;
169 1.82 reinoud
170 1.82 reinoud
171 1.82 reinoud /*
172 1.82 reinoud * Definitions for handling #include specifications
173 1.82 reinoud */
174 1.82 reinoud
175 1.123 dsl static Lst includes; /* stack of IFiles generated by .includes */
176 1.1 cgd Lst parseIncPath; /* list of directories for "..." includes */
177 1.1 cgd Lst sysIncPath; /* list of directories for <...> includes */
178 1.74 tv Lst defIncPath; /* default directories for <...> includes */
179 1.1 cgd
180 1.1 cgd /*-
181 1.1 cgd * specType contains the SPECial TYPE of the current target. It is
182 1.1 cgd * Not if the target is unspecial. If it *is* special, however, the children
183 1.1 cgd * are linked as children of the parent but not vice versa. This variable is
184 1.1 cgd * set in ParseDoDependency
185 1.1 cgd */
186 1.1 cgd typedef enum {
187 1.1 cgd Begin, /* .BEGIN */
188 1.1 cgd Default, /* .DEFAULT */
189 1.1 cgd End, /* .END */
190 1.1 cgd Ignore, /* .IGNORE */
191 1.1 cgd Includes, /* .INCLUDES */
192 1.1 cgd Interrupt, /* .INTERRUPT */
193 1.1 cgd Libs, /* .LIBS */
194 1.1 cgd MFlags, /* .MFLAGS or .MAKEFLAGS */
195 1.1 cgd Main, /* .MAIN and we don't have anything user-specified to
196 1.1 cgd * make */
197 1.5 cgd NoExport, /* .NOEXPORT */
198 1.32 gwr NoPath, /* .NOPATH */
199 1.1 cgd Not, /* Not special */
200 1.75 tv NotParallel, /* .NOTPARALLEL */
201 1.1 cgd Null, /* .NULL */
202 1.75 tv ExObjdir, /* .OBJDIR */
203 1.1 cgd Order, /* .ORDER */
204 1.18 christos Parallel, /* .PARALLEL */
205 1.5 cgd ExPath, /* .PATH */
206 1.22 christos Phony, /* .PHONY */
207 1.48 sjg #ifdef POSIX
208 1.48 sjg Posix, /* .POSIX */
209 1.48 sjg #endif
210 1.1 cgd Precious, /* .PRECIOUS */
211 1.5 cgd ExShell, /* .SHELL */
212 1.1 cgd Silent, /* .SILENT */
213 1.1 cgd SingleShell, /* .SINGLESHELL */
214 1.1 cgd Suffixes, /* .SUFFIXES */
215 1.18 christos Wait, /* .WAIT */
216 1.5 cgd Attribute /* Generic attribute */
217 1.1 cgd } ParseSpecial;
218 1.1 cgd
219 1.5 cgd static ParseSpecial specType;
220 1.1 cgd
221 1.77 christos #define LPAREN '('
222 1.77 christos #define RPAREN ')'
223 1.1 cgd /*
224 1.1 cgd * Predecessor node for handling .ORDER. Initialized to NILGNODE when .ORDER
225 1.1 cgd * seen, then set to each successive source on the line.
226 1.1 cgd */
227 1.1 cgd static GNode *predecessor;
228 1.1 cgd
229 1.1 cgd /*
230 1.1 cgd * The parseKeywords table is searched using binary search when deciding
231 1.1 cgd * if a target or source is special. The 'spec' field is the ParseSpecial
232 1.1 cgd * type of the keyword ("Not" if the keyword isn't special as a target) while
233 1.1 cgd * the 'op' field is the operator to apply to the list of targets if the
234 1.1 cgd * keyword is used as a source ("0" if the keyword isn't special as a source)
235 1.1 cgd */
236 1.1 cgd static struct {
237 1.93 christos const char *name; /* Name of keyword */
238 1.1 cgd ParseSpecial spec; /* Type when used as a target */
239 1.1 cgd int op; /* Operator when used as a source */
240 1.1 cgd } parseKeywords[] = {
241 1.1 cgd { ".BEGIN", Begin, 0 },
242 1.1 cgd { ".DEFAULT", Default, 0 },
243 1.1 cgd { ".END", End, 0 },
244 1.1 cgd { ".EXEC", Attribute, OP_EXEC },
245 1.1 cgd { ".IGNORE", Ignore, OP_IGNORE },
246 1.1 cgd { ".INCLUDES", Includes, 0 },
247 1.1 cgd { ".INTERRUPT", Interrupt, 0 },
248 1.1 cgd { ".INVISIBLE", Attribute, OP_INVISIBLE },
249 1.1 cgd { ".JOIN", Attribute, OP_JOIN },
250 1.1 cgd { ".LIBS", Libs, 0 },
251 1.29 christos { ".MADE", Attribute, OP_MADE },
252 1.1 cgd { ".MAIN", Main, 0 },
253 1.1 cgd { ".MAKE", Attribute, OP_MAKE },
254 1.1 cgd { ".MAKEFLAGS", MFlags, 0 },
255 1.1 cgd { ".MFLAGS", MFlags, 0 },
256 1.32 gwr { ".NOPATH", NoPath, OP_NOPATH },
257 1.1 cgd { ".NOTMAIN", Attribute, OP_NOTMAIN },
258 1.1 cgd { ".NOTPARALLEL", NotParallel, 0 },
259 1.18 christos { ".NO_PARALLEL", NotParallel, 0 },
260 1.1 cgd { ".NULL", Null, 0 },
261 1.75 tv { ".OBJDIR", ExObjdir, 0 },
262 1.14 ws { ".OPTIONAL", Attribute, OP_OPTIONAL },
263 1.1 cgd { ".ORDER", Order, 0 },
264 1.18 christos { ".PARALLEL", Parallel, 0 },
265 1.5 cgd { ".PATH", ExPath, 0 },
266 1.22 christos { ".PHONY", Phony, OP_PHONY },
267 1.48 sjg #ifdef POSIX
268 1.48 sjg { ".POSIX", Posix, 0 },
269 1.48 sjg #endif
270 1.1 cgd { ".PRECIOUS", Precious, OP_PRECIOUS },
271 1.1 cgd { ".RECURSIVE", Attribute, OP_MAKE },
272 1.5 cgd { ".SHELL", ExShell, 0 },
273 1.1 cgd { ".SILENT", Silent, OP_SILENT },
274 1.1 cgd { ".SINGLESHELL", SingleShell, 0 },
275 1.1 cgd { ".SUFFIXES", Suffixes, 0 },
276 1.1 cgd { ".USE", Attribute, OP_USE },
277 1.71 christos { ".USEBEFORE", Attribute, OP_USEBEFORE },
278 1.18 christos { ".WAIT", Wait, 0 },
279 1.1 cgd };
280 1.1 cgd
281 1.84 wiz static int ParseIsEscaped(const char *, const char *);
282 1.122 dsl static void ParseErrorInternal(const char *, size_t, int, const char *, ...)
283 1.53 is __attribute__((__format__(__printf__, 4, 5)));
284 1.127 dsl static void ParseVErrorInternal(FILE *, const char *, size_t, int, const char *, va_list)
285 1.127 dsl __attribute__((__format__(__printf__, 5, 0)));
286 1.120 dsl static int ParseFindKeyword(const char *);
287 1.84 wiz static int ParseLinkSrc(ClientData, ClientData);
288 1.84 wiz static int ParseDoOp(ClientData, ClientData);
289 1.120 dsl static void ParseDoSrc(int, const char *);
290 1.84 wiz static int ParseFindMain(ClientData, ClientData);
291 1.84 wiz static int ParseAddDir(ClientData, ClientData);
292 1.84 wiz static int ParseClearPath(ClientData, ClientData);
293 1.84 wiz static void ParseDoDependency(char *);
294 1.84 wiz static int ParseAddCmd(ClientData, ClientData);
295 1.84 wiz static void ParseHasCommands(ClientData);
296 1.84 wiz static void ParseDoInclude(char *);
297 1.122 dsl static void ParseSetParseFile(const char *);
298 1.5 cgd #ifdef SYSVINCLUDE
299 1.84 wiz static void ParseTraditionalInclude(char *);
300 1.5 cgd #endif
301 1.123 dsl static int ParseEOF(void);
302 1.84 wiz static char *ParseReadLine(void);
303 1.84 wiz static void ParseFinishLine(void);
304 1.84 wiz static void ParseMark(GNode *);
305 1.5 cgd
306 1.56 christos extern int maxJobs;
307 1.56 christos
308 1.77 christos
309 1.77 christos /*-
310 1.77 christos *----------------------------------------------------------------------
311 1.77 christos * ParseIsEscaped --
312 1.77 christos * Check if the current character is escaped on the current line
313 1.77 christos *
314 1.77 christos * Results:
315 1.77 christos * 0 if the character is not backslash escaped, 1 otherwise
316 1.77 christos *
317 1.77 christos * Side Effects:
318 1.77 christos * None
319 1.77 christos *----------------------------------------------------------------------
320 1.77 christos */
321 1.77 christos static int
322 1.84 wiz ParseIsEscaped(const char *line, const char *c)
323 1.77 christos {
324 1.77 christos int active = 0;
325 1.77 christos for (;;) {
326 1.77 christos if (line == c)
327 1.77 christos return active;
328 1.77 christos if (*--c != '\\')
329 1.77 christos return active;
330 1.77 christos active = !active;
331 1.77 christos }
332 1.77 christos }
333 1.77 christos
334 1.1 cgd /*-
335 1.1 cgd *----------------------------------------------------------------------
336 1.1 cgd * ParseFindKeyword --
337 1.1 cgd * Look in the table of keywords for one matching the given string.
338 1.1 cgd *
339 1.84 wiz * Input:
340 1.84 wiz * str String to find
341 1.84 wiz *
342 1.1 cgd * Results:
343 1.1 cgd * The index of the keyword, or -1 if it isn't there.
344 1.1 cgd *
345 1.1 cgd * Side Effects:
346 1.1 cgd * None
347 1.1 cgd *----------------------------------------------------------------------
348 1.1 cgd */
349 1.1 cgd static int
350 1.120 dsl ParseFindKeyword(const char *str)
351 1.1 cgd {
352 1.84 wiz int start, end, cur;
353 1.84 wiz int diff;
354 1.27 christos
355 1.1 cgd start = 0;
356 1.1 cgd end = (sizeof(parseKeywords)/sizeof(parseKeywords[0])) - 1;
357 1.1 cgd
358 1.1 cgd do {
359 1.1 cgd cur = start + ((end - start) / 2);
360 1.103 christos diff = strcmp(str, parseKeywords[cur].name);
361 1.1 cgd
362 1.1 cgd if (diff == 0) {
363 1.1 cgd return (cur);
364 1.1 cgd } else if (diff < 0) {
365 1.1 cgd end = cur - 1;
366 1.1 cgd } else {
367 1.1 cgd start = cur + 1;
368 1.1 cgd }
369 1.1 cgd } while (start <= end);
370 1.1 cgd return (-1);
371 1.1 cgd }
372 1.1 cgd
373 1.1 cgd /*-
374 1.38 christos * ParseVErrorInternal --
375 1.1 cgd * Error message abort function for parsing. Prints out the context
376 1.1 cgd * of the error (line number and file) as well as the message with
377 1.1 cgd * two optional arguments.
378 1.1 cgd *
379 1.1 cgd * Results:
380 1.1 cgd * None
381 1.1 cgd *
382 1.1 cgd * Side Effects:
383 1.1 cgd * "fatals" is incremented if the level is PARSE_FATAL.
384 1.1 cgd */
385 1.1 cgd /* VARARGS */
386 1.38 christos static void
387 1.127 dsl ParseVErrorInternal(FILE *f, const char *cfname, size_t clineno, int type,
388 1.122 dsl const char *fmt, va_list ap)
389 1.38 christos {
390 1.56 christos static Boolean fatal_warning_error_printed = FALSE;
391 1.56 christos
392 1.127 dsl (void)fprintf(f, "%s: \"", progname);
393 1.63 christos
394 1.55 sjg if (*cfname != '/') {
395 1.93 christos char *cp;
396 1.93 christos const char *dir;
397 1.55 sjg
398 1.55 sjg /*
399 1.55 sjg * Nothing is more anoying than not knowing which Makefile
400 1.55 sjg * is the culprit.
401 1.55 sjg */
402 1.55 sjg dir = Var_Value(".PARSEDIR", VAR_GLOBAL, &cp);
403 1.63 christos if (dir == NULL || *dir == '\0' ||
404 1.55 sjg (*dir == '.' && dir[1] == '\0'))
405 1.55 sjg dir = Var_Value(".CURDIR", VAR_GLOBAL, &cp);
406 1.63 christos if (dir == NULL)
407 1.63 christos dir = ".";
408 1.55 sjg
409 1.127 dsl (void)fprintf(f, "%s/%s", dir, cfname);
410 1.55 sjg } else
411 1.127 dsl (void)fprintf(f, "%s", cfname);
412 1.63 christos
413 1.127 dsl (void)fprintf(f, "\" line %d: ", (int)clineno);
414 1.38 christos if (type == PARSE_WARNING)
415 1.127 dsl (void)fprintf(f, "warning: ");
416 1.127 dsl (void)vfprintf(f, fmt, ap);
417 1.127 dsl (void)fprintf(f, "\n");
418 1.127 dsl (void)fflush(f);
419 1.56 christos if (type == PARSE_FATAL || parseWarnFatal)
420 1.38 christos fatals += 1;
421 1.56 christos if (parseWarnFatal && !fatal_warning_error_printed) {
422 1.56 christos Error("parsing warnings being treated as errors");
423 1.56 christos fatal_warning_error_printed = TRUE;
424 1.56 christos }
425 1.38 christos }
426 1.38 christos
427 1.38 christos /*-
428 1.38 christos * ParseErrorInternal --
429 1.38 christos * Error function
430 1.38 christos *
431 1.38 christos * Results:
432 1.38 christos * None
433 1.38 christos *
434 1.38 christos * Side Effects:
435 1.38 christos * None
436 1.38 christos */
437 1.38 christos /* VARARGS */
438 1.38 christos static void
439 1.122 dsl ParseErrorInternal(const char *cfname, size_t clineno, int type,
440 1.122 dsl const char *fmt, ...)
441 1.38 christos {
442 1.38 christos va_list ap;
443 1.84 wiz
444 1.38 christos va_start(ap, fmt);
445 1.127 dsl ParseVErrorInternal(stderr, cfname, clineno, type, fmt, ap);
446 1.38 christos va_end(ap);
447 1.127 dsl
448 1.127 dsl if (debug_file != NULL && debug_file != stderr) {
449 1.127 dsl va_start(ap, fmt);
450 1.127 dsl ParseVErrorInternal(stderr, cfname, clineno, type, fmt, ap);
451 1.127 dsl va_end(ap);
452 1.127 dsl }
453 1.38 christos }
454 1.38 christos
455 1.38 christos /*-
456 1.38 christos * Parse_Error --
457 1.38 christos * External interface to ParseErrorInternal; uses the default filename
458 1.38 christos * Line number.
459 1.38 christos *
460 1.38 christos * Results:
461 1.38 christos * None
462 1.38 christos *
463 1.38 christos * Side Effects:
464 1.38 christos * None
465 1.38 christos */
466 1.38 christos /* VARARGS */
467 1.1 cgd void
468 1.93 christos Parse_Error(int type, const char *fmt, ...)
469 1.1 cgd {
470 1.1 cgd va_list ap;
471 1.84 wiz
472 1.5 cgd va_start(ap, fmt);
473 1.127 dsl ParseVErrorInternal(stderr, curFile->fname, curFile->lineno,
474 1.127 dsl type, fmt, ap);
475 1.1 cgd va_end(ap);
476 1.127 dsl
477 1.127 dsl if (debug_file != NULL && debug_file != stderr) {
478 1.127 dsl va_start(ap, fmt);
479 1.127 dsl ParseVErrorInternal(debug_file, curFile->fname, curFile->lineno,
480 1.127 dsl type, fmt, ap);
481 1.127 dsl va_end(ap);
482 1.127 dsl }
483 1.1 cgd }
484 1.1 cgd
485 1.1 cgd /*-
486 1.1 cgd *---------------------------------------------------------------------
487 1.1 cgd * ParseLinkSrc --
488 1.1 cgd * Link the parent node to its new child. Used in a Lst_ForEach by
489 1.1 cgd * ParseDoDependency. If the specType isn't 'Not', the parent
490 1.1 cgd * isn't linked as a parent of the child.
491 1.1 cgd *
492 1.84 wiz * Input:
493 1.84 wiz * pgnp The parent node
494 1.84 wiz * cgpn The child node
495 1.84 wiz *
496 1.1 cgd * Results:
497 1.1 cgd * Always = 0
498 1.1 cgd *
499 1.1 cgd * Side Effects:
500 1.1 cgd * New elements are added to the parents list of cgn and the
501 1.1 cgd * children list of cgn. the unmade field of pgn is updated
502 1.1 cgd * to reflect the additional child.
503 1.1 cgd *---------------------------------------------------------------------
504 1.1 cgd */
505 1.1 cgd static int
506 1.84 wiz ParseLinkSrc(ClientData pgnp, ClientData cgnp)
507 1.1 cgd {
508 1.105 christos GNode *pgn = (GNode *)pgnp;
509 1.105 christos GNode *cgn = (GNode *)cgnp;
510 1.52 mycroft
511 1.47 mycroft if ((pgn->type & OP_DOUBLEDEP) && !Lst_IsEmpty (pgn->cohorts))
512 1.103 christos pgn = (GNode *)Lst_Datum(Lst_Last(pgn->cohorts));
513 1.119 dsl (void)Lst_AtEnd(pgn->children, cgn);
514 1.52 mycroft if (specType == Not)
515 1.119 dsl (void)Lst_AtEnd(cgn->parents, pgn);
516 1.52 mycroft pgn->unmade += 1;
517 1.109 dsl if (DEBUG(PARSE)) {
518 1.116 dsl fprintf(debug_file, "# ParseLinkSrc: added child %s - %s\n", pgn->name, cgn->name);
519 1.109 dsl Targ_PrintNode(pgn, 0);
520 1.109 dsl Targ_PrintNode(cgn, 0);
521 1.109 dsl }
522 1.1 cgd return (0);
523 1.1 cgd }
524 1.1 cgd
525 1.1 cgd /*-
526 1.1 cgd *---------------------------------------------------------------------
527 1.1 cgd * ParseDoOp --
528 1.1 cgd * Apply the parsed operator to the given target node. Used in a
529 1.1 cgd * Lst_ForEach call by ParseDoDependency once all targets have
530 1.1 cgd * been found and their operator parsed. If the previous and new
531 1.1 cgd * operators are incompatible, a major error is taken.
532 1.1 cgd *
533 1.84 wiz * Input:
534 1.84 wiz * gnp The node to which the operator is to be applied
535 1.84 wiz * opp The operator to apply
536 1.84 wiz *
537 1.1 cgd * Results:
538 1.1 cgd * Always 0
539 1.1 cgd *
540 1.1 cgd * Side Effects:
541 1.1 cgd * The type field of the node is altered to reflect any new bits in
542 1.1 cgd * the op.
543 1.1 cgd *---------------------------------------------------------------------
544 1.1 cgd */
545 1.1 cgd static int
546 1.84 wiz ParseDoOp(ClientData gnp, ClientData opp)
547 1.1 cgd {
548 1.105 christos GNode *gn = (GNode *)gnp;
549 1.105 christos int op = *(int *)opp;
550 1.1 cgd /*
551 1.1 cgd * If the dependency mask of the operator and the node don't match and
552 1.1 cgd * the node has actually had an operator applied to it before, and
553 1.27 christos * the operator actually has some dependency information in it, complain.
554 1.1 cgd */
555 1.1 cgd if (((op & OP_OPMASK) != (gn->type & OP_OPMASK)) &&
556 1.1 cgd !OP_NOP(gn->type) && !OP_NOP(op))
557 1.1 cgd {
558 1.97 christos Parse_Error(PARSE_FATAL, "Inconsistent operator for %s", gn->name);
559 1.1 cgd return (1);
560 1.1 cgd }
561 1.1 cgd
562 1.1 cgd if ((op == OP_DOUBLEDEP) && ((gn->type & OP_OPMASK) == OP_DOUBLEDEP)) {
563 1.1 cgd /*
564 1.1 cgd * If the node was the object of a :: operator, we need to create a
565 1.1 cgd * new instance of it for the children and commands on this dependency
566 1.1 cgd * line. The new instance is placed on the 'cohorts' list of the
567 1.1 cgd * initial one (note the initial one is not on its own cohorts list)
568 1.1 cgd * and the new instance is linked to all parents of the initial
569 1.1 cgd * instance.
570 1.1 cgd */
571 1.84 wiz GNode *cohort;
572 1.27 christos
573 1.33 mycroft /*
574 1.46 mycroft * Propagate copied bits to the initial node. They'll be propagated
575 1.46 mycroft * back to the rest of the cohorts later.
576 1.33 mycroft */
577 1.46 mycroft gn->type |= op & ~OP_OPMASK;
578 1.33 mycroft
579 1.120 dsl cohort = Targ_FindNode(gn->name, TARG_NOHASH);
580 1.1 cgd /*
581 1.1 cgd * Make the cohort invisible as well to avoid duplicating it into
582 1.1 cgd * other variables. True, parents of this target won't tend to do
583 1.1 cgd * anything with their local variables, but better safe than
584 1.46 mycroft * sorry. (I think this is pointless now, since the relevant list
585 1.46 mycroft * traversals will no longer see this node anyway. -mycroft)
586 1.1 cgd */
587 1.46 mycroft cohort->type = op | OP_INVISIBLE;
588 1.119 dsl (void)Lst_AtEnd(gn->cohorts, cohort);
589 1.83 pk cohort->centurion = gn;
590 1.83 pk gn->unmade_cohorts += 1;
591 1.120 dsl snprintf(cohort->cohort_num, sizeof cohort->cohort_num, "#%d",
592 1.120 dsl gn->unmade_cohorts);
593 1.46 mycroft } else {
594 1.1 cgd /*
595 1.46 mycroft * We don't want to nuke any previous flags (whatever they were) so we
596 1.46 mycroft * just OR the new operator into the old
597 1.1 cgd */
598 1.46 mycroft gn->type |= op;
599 1.1 cgd }
600 1.33 mycroft
601 1.1 cgd return (0);
602 1.1 cgd }
603 1.1 cgd
604 1.27 christos /*-
605 1.18 christos *---------------------------------------------------------------------
606 1.1 cgd * ParseDoSrc --
607 1.1 cgd * Given the name of a source, figure out if it is an attribute
608 1.1 cgd * and apply it to the targets if it is. Else decide if there is
609 1.1 cgd * some attribute which should be applied *to* the source because
610 1.1 cgd * of some special target and apply it if so. Otherwise, make the
611 1.1 cgd * source be a child of the targets in the list 'targets'
612 1.1 cgd *
613 1.84 wiz * Input:
614 1.84 wiz * tOp operator (if any) from special targets
615 1.84 wiz * src name of the source to handle
616 1.84 wiz *
617 1.1 cgd * Results:
618 1.1 cgd * None
619 1.1 cgd *
620 1.1 cgd * Side Effects:
621 1.1 cgd * Operator bits may be added to the list of targets or to the source.
622 1.1 cgd * The targets may have a new source added to their lists of children.
623 1.1 cgd *---------------------------------------------------------------------
624 1.1 cgd */
625 1.1 cgd static void
626 1.120 dsl ParseDoSrc(int tOp, const char *src)
627 1.1 cgd {
628 1.18 christos GNode *gn = NULL;
629 1.120 dsl static int wait_number = 0;
630 1.120 dsl char wait_src[16];
631 1.1 cgd
632 1.40 christos if (*src == '.' && isupper ((unsigned char)src[1])) {
633 1.1 cgd int keywd = ParseFindKeyword(src);
634 1.1 cgd if (keywd != -1) {
635 1.18 christos int op = parseKeywords[keywd].op;
636 1.18 christos if (op != 0) {
637 1.119 dsl Lst_ForEach(targets, ParseDoOp, &op);
638 1.18 christos return;
639 1.18 christos }
640 1.18 christos if (parseKeywords[keywd].spec == Wait) {
641 1.120 dsl /*
642 1.120 dsl * We add a .WAIT node in the dependency list.
643 1.120 dsl * After any dynamic dependencies (and filename globbing)
644 1.120 dsl * have happened, it is given a dependency on the each
645 1.120 dsl * previous child back to and previous .WAIT node.
646 1.120 dsl * The next child won't be scheduled until the .WAIT node
647 1.120 dsl * is built.
648 1.120 dsl * We give each .WAIT node a unique name (mainly for diag).
649 1.120 dsl */
650 1.120 dsl snprintf(wait_src, sizeof wait_src, ".WAIT_%u", ++wait_number);
651 1.120 dsl gn = Targ_FindNode(wait_src, TARG_NOHASH);
652 1.120 dsl gn->type = OP_WAIT | OP_PHONY | OP_DEPENDS | OP_NOTMAIN;
653 1.120 dsl Lst_ForEach(targets, ParseLinkSrc, gn);
654 1.18 christos return;
655 1.18 christos }
656 1.1 cgd }
657 1.1 cgd }
658 1.18 christos
659 1.18 christos switch (specType) {
660 1.18 christos case Main:
661 1.1 cgd /*
662 1.1 cgd * If we have noted the existence of a .MAIN, it means we need
663 1.1 cgd * to add the sources of said target to the list of things
664 1.1 cgd * to create. The string 'src' is likely to be free, so we
665 1.1 cgd * must make a new copy of it. Note that this will only be
666 1.1 cgd * invoked if the user didn't specify a target on the command
667 1.1 cgd * line. This is to allow #ifmake's to succeed, or something...
668 1.1 cgd */
669 1.119 dsl (void)Lst_AtEnd(create, estrdup(src));
670 1.1 cgd /*
671 1.118 dsl * Add the name to the .TARGETS variable as well, so the user can
672 1.1 cgd * employ that, if desired.
673 1.1 cgd */
674 1.1 cgd Var_Append(".TARGETS", src, VAR_GLOBAL);
675 1.18 christos return;
676 1.18 christos
677 1.18 christos case Order:
678 1.1 cgd /*
679 1.1 cgd * Create proper predecessor/successor links between the previous
680 1.1 cgd * source and the current one.
681 1.1 cgd */
682 1.1 cgd gn = Targ_FindNode(src, TARG_CREATE);
683 1.1 cgd if (predecessor != NILGNODE) {
684 1.120 dsl (void)Lst_AtEnd(predecessor->order_succ, gn);
685 1.120 dsl (void)Lst_AtEnd(gn->order_pred, predecessor);
686 1.109 dsl if (DEBUG(PARSE)) {
687 1.116 dsl fprintf(debug_file, "# ParseDoSrc: added Order dependency %s - %s\n",
688 1.109 dsl predecessor->name, gn->name);
689 1.109 dsl Targ_PrintNode(predecessor, 0);
690 1.109 dsl Targ_PrintNode(gn, 0);
691 1.109 dsl }
692 1.1 cgd }
693 1.1 cgd /*
694 1.1 cgd * The current source now becomes the predecessor for the next one.
695 1.1 cgd */
696 1.1 cgd predecessor = gn;
697 1.18 christos break;
698 1.18 christos
699 1.18 christos default:
700 1.1 cgd /*
701 1.1 cgd * If the source is not an attribute, we need to find/create
702 1.1 cgd * a node for it. After that we can apply any operator to it
703 1.1 cgd * from a special target or link it to its parents, as
704 1.1 cgd * appropriate.
705 1.1 cgd *
706 1.1 cgd * In the case of a source that was the object of a :: operator,
707 1.1 cgd * the attribute is applied to all of its instances (as kept in
708 1.1 cgd * the 'cohorts' list of the node) or all the cohorts are linked
709 1.1 cgd * to all the targets.
710 1.1 cgd */
711 1.118 dsl
712 1.118 dsl /* Find/create the 'src' node and attach to all targets */
713 1.97 christos gn = Targ_FindNode(src, TARG_CREATE);
714 1.1 cgd if (tOp) {
715 1.1 cgd gn->type |= tOp;
716 1.1 cgd } else {
717 1.119 dsl Lst_ForEach(targets, ParseLinkSrc, gn);
718 1.1 cgd }
719 1.18 christos break;
720 1.18 christos }
721 1.1 cgd }
722 1.1 cgd
723 1.1 cgd /*-
724 1.1 cgd *-----------------------------------------------------------------------
725 1.1 cgd * ParseFindMain --
726 1.1 cgd * Find a real target in the list and set it to be the main one.
727 1.1 cgd * Called by ParseDoDependency when a main target hasn't been found
728 1.1 cgd * yet.
729 1.1 cgd *
730 1.84 wiz * Input:
731 1.84 wiz * gnp Node to examine
732 1.84 wiz *
733 1.1 cgd * Results:
734 1.1 cgd * 0 if main not found yet, 1 if it is.
735 1.1 cgd *
736 1.1 cgd * Side Effects:
737 1.1 cgd * mainNode is changed and Targ_SetMain is called.
738 1.1 cgd *
739 1.1 cgd *-----------------------------------------------------------------------
740 1.1 cgd */
741 1.1 cgd static int
742 1.84 wiz ParseFindMain(ClientData gnp, ClientData dummy)
743 1.1 cgd {
744 1.105 christos GNode *gn = (GNode *)gnp;
745 1.30 christos if ((gn->type & OP_NOTARGET) == 0) {
746 1.1 cgd mainNode = gn;
747 1.1 cgd Targ_SetMain(gn);
748 1.9 jtc return (dummy ? 1 : 1);
749 1.1 cgd } else {
750 1.9 jtc return (dummy ? 0 : 0);
751 1.1 cgd }
752 1.1 cgd }
753 1.1 cgd
754 1.1 cgd /*-
755 1.1 cgd *-----------------------------------------------------------------------
756 1.1 cgd * ParseAddDir --
757 1.1 cgd * Front-end for Dir_AddDir to make sure Lst_ForEach keeps going
758 1.1 cgd *
759 1.1 cgd * Results:
760 1.1 cgd * === 0
761 1.1 cgd *
762 1.1 cgd * Side Effects:
763 1.1 cgd * See Dir_AddDir.
764 1.1 cgd *
765 1.1 cgd *-----------------------------------------------------------------------
766 1.1 cgd */
767 1.1 cgd static int
768 1.84 wiz ParseAddDir(ClientData path, ClientData name)
769 1.1 cgd {
770 1.105 christos (void)Dir_AddDir((Lst) path, (char *)name);
771 1.1 cgd return(0);
772 1.1 cgd }
773 1.1 cgd
774 1.1 cgd /*-
775 1.1 cgd *-----------------------------------------------------------------------
776 1.1 cgd * ParseClearPath --
777 1.1 cgd * Front-end for Dir_ClearPath to make sure Lst_ForEach keeps going
778 1.1 cgd *
779 1.1 cgd * Results:
780 1.1 cgd * === 0
781 1.1 cgd *
782 1.1 cgd * Side Effects:
783 1.1 cgd * See Dir_ClearPath
784 1.1 cgd *
785 1.1 cgd *-----------------------------------------------------------------------
786 1.1 cgd */
787 1.1 cgd static int
788 1.84 wiz ParseClearPath(ClientData path, ClientData dummy)
789 1.1 cgd {
790 1.9 jtc Dir_ClearPath((Lst) path);
791 1.9 jtc return(dummy ? 0 : 0);
792 1.1 cgd }
793 1.1 cgd
794 1.1 cgd /*-
795 1.1 cgd *---------------------------------------------------------------------
796 1.1 cgd * ParseDoDependency --
797 1.1 cgd * Parse the dependency line in line.
798 1.1 cgd *
799 1.84 wiz * Input:
800 1.84 wiz * line the line to parse
801 1.84 wiz *
802 1.1 cgd * Results:
803 1.1 cgd * None
804 1.1 cgd *
805 1.1 cgd * Side Effects:
806 1.1 cgd * The nodes of the sources are linked as children to the nodes of the
807 1.1 cgd * targets. Some nodes may be created.
808 1.1 cgd *
809 1.1 cgd * We parse a dependency line by first extracting words from the line and
810 1.1 cgd * finding nodes in the list of all targets with that name. This is done
811 1.1 cgd * until a character is encountered which is an operator character. Currently
812 1.1 cgd * these are only ! and :. At this point the operator is parsed and the
813 1.1 cgd * pointer into the line advanced until the first source is encountered.
814 1.1 cgd * The parsed operator is applied to each node in the 'targets' list,
815 1.1 cgd * which is where the nodes found for the targets are kept, by means of
816 1.1 cgd * the ParseDoOp function.
817 1.1 cgd * The sources are read in much the same way as the targets were except
818 1.1 cgd * that now they are expanded using the wildcarding scheme of the C-Shell
819 1.1 cgd * and all instances of the resulting words in the list of all targets
820 1.1 cgd * are found. Each of the resulting nodes is then linked to each of the
821 1.1 cgd * targets as one of its children.
822 1.1 cgd * Certain targets are handled specially. These are the ones detailed
823 1.1 cgd * by the specType variable.
824 1.1 cgd * The storing of transformation rules is also taken care of here.
825 1.1 cgd * A target is recognized as a transformation rule by calling
826 1.1 cgd * Suff_IsTransform. If it is a transformation rule, its node is gotten
827 1.1 cgd * from the suffix module via Suff_AddTransform rather than the standard
828 1.1 cgd * Targ_FindNode in the target module.
829 1.1 cgd *---------------------------------------------------------------------
830 1.1 cgd */
831 1.1 cgd static void
832 1.84 wiz ParseDoDependency(char *line)
833 1.1 cgd {
834 1.9 jtc char *cp; /* our current position */
835 1.98 christos GNode *gn = NULL; /* a general purpose temporary node */
836 1.9 jtc int op; /* the operator on the line */
837 1.1 cgd char savec; /* a place to save a character */
838 1.1 cgd Lst paths; /* List of search paths to alter when parsing
839 1.1 cgd * a list of .PATH targets */
840 1.1 cgd int tOp; /* operator from special target */
841 1.18 christos Lst sources; /* list of archive source names after
842 1.18 christos * expansion */
843 1.1 cgd Lst curTargs; /* list of target names to be found and added
844 1.1 cgd * to the targets list */
845 1.77 christos char *lstart = line;
846 1.1 cgd
847 1.120 dsl if (DEBUG(PARSE))
848 1.120 dsl fprintf(debug_file, "ParseDoDependency(%s)\n", line);
849 1.1 cgd tOp = 0;
850 1.1 cgd
851 1.1 cgd specType = Not;
852 1.1 cgd paths = (Lst)NULL;
853 1.1 cgd
854 1.1 cgd curTargs = Lst_Init(FALSE);
855 1.27 christos
856 1.1 cgd do {
857 1.121 dsl for (cp = line; *cp && (ParseIsEscaped(lstart, cp) ||
858 1.121 dsl !(isspace((unsigned char)*cp) ||
859 1.121 dsl *cp == '!' || *cp == ':' || *cp == LPAREN));
860 1.121 dsl cp++) {
861 1.1 cgd if (*cp == '$') {
862 1.1 cgd /*
863 1.1 cgd * Must be a dynamic source (would have been expanded
864 1.1 cgd * otherwise), so call the Var module to parse the puppy
865 1.1 cgd * so we can safely advance beyond it...There should be
866 1.1 cgd * no errors in this, as they would have been discovered
867 1.1 cgd * in the initial Var_Subst and we wouldn't be here.
868 1.1 cgd */
869 1.1 cgd int length;
870 1.114 christos void *freeIt;
871 1.1 cgd char *result;
872 1.1 cgd
873 1.114 christos result = Var_Parse(cp, VAR_CMD, TRUE, &length, &freeIt);
874 1.114 christos if (freeIt)
875 1.114 christos free(freeIt);
876 1.1 cgd cp += length-1;
877 1.1 cgd }
878 1.1 cgd }
879 1.121 dsl
880 1.77 christos if (!ParseIsEscaped(lstart, cp) && *cp == LPAREN) {
881 1.1 cgd /*
882 1.1 cgd * Archives must be handled specially to make sure the OP_ARCHV
883 1.1 cgd * flag is set in their 'type' field, for one thing, and because
884 1.1 cgd * things like "archive(file1.o file2.o file3.o)" are permissible.
885 1.1 cgd * Arch_ParseArchive will set 'line' to be the first non-blank
886 1.1 cgd * after the archive-spec. It creates/finds nodes for the members
887 1.1 cgd * and places them on the given list, returning SUCCESS if all
888 1.1 cgd * went well and FAILURE if there was an error in the
889 1.1 cgd * specification. On error, line should remain untouched.
890 1.1 cgd */
891 1.97 christos if (Arch_ParseArchive(&line, targets, VAR_CMD) != SUCCESS) {
892 1.97 christos Parse_Error(PARSE_FATAL,
893 1.1 cgd "Error in archive specification: \"%s\"", line);
894 1.112 christos goto out;
895 1.1 cgd } else {
896 1.1 cgd continue;
897 1.1 cgd }
898 1.1 cgd }
899 1.1 cgd savec = *cp;
900 1.27 christos
901 1.1 cgd if (!*cp) {
902 1.1 cgd /*
903 1.1 cgd * Ending a dependency line without an operator is a Bozo
904 1.65 sommerfe * no-no. As a heuristic, this is also often triggered by
905 1.65 sommerfe * undetected conflicts from cvs/rcs merges.
906 1.1 cgd */
907 1.65 sommerfe if ((strncmp(line, "<<<<<<", 6) == 0) ||
908 1.65 sommerfe (strncmp(line, "======", 6) == 0) ||
909 1.65 sommerfe (strncmp(line, ">>>>>>", 6) == 0))
910 1.97 christos Parse_Error(PARSE_FATAL,
911 1.67 sommerfe "Makefile appears to contain unresolved cvs/rcs/??? merge conflicts");
912 1.65 sommerfe else
913 1.97 christos Parse_Error(PARSE_FATAL, "Need an operator");
914 1.112 christos goto out;
915 1.1 cgd }
916 1.1 cgd *cp = '\0';
917 1.118 dsl
918 1.1 cgd /*
919 1.1 cgd * Have a word in line. See if it's a special target and set
920 1.1 cgd * specType to match it.
921 1.1 cgd */
922 1.40 christos if (*line == '.' && isupper ((unsigned char)line[1])) {
923 1.1 cgd /*
924 1.1 cgd * See if the target is a special target that must have it
925 1.27 christos * or its sources handled specially.
926 1.1 cgd */
927 1.1 cgd int keywd = ParseFindKeyword(line);
928 1.1 cgd if (keywd != -1) {
929 1.5 cgd if (specType == ExPath && parseKeywords[keywd].spec != ExPath) {
930 1.1 cgd Parse_Error(PARSE_FATAL, "Mismatched special targets");
931 1.112 christos goto out;
932 1.1 cgd }
933 1.27 christos
934 1.1 cgd specType = parseKeywords[keywd].spec;
935 1.1 cgd tOp = parseKeywords[keywd].op;
936 1.1 cgd
937 1.1 cgd /*
938 1.1 cgd * Certain special targets have special semantics:
939 1.1 cgd * .PATH Have to set the dirSearchPath
940 1.1 cgd * variable too
941 1.1 cgd * .MAIN Its sources are only used if
942 1.1 cgd * nothing has been specified to
943 1.1 cgd * create.
944 1.1 cgd * .DEFAULT Need to create a node to hang
945 1.1 cgd * commands on, but we don't want
946 1.1 cgd * it in the graph, nor do we want
947 1.1 cgd * it to be the Main Target, so we
948 1.1 cgd * create it, set OP_NOTMAIN and
949 1.1 cgd * add it to the list, setting
950 1.1 cgd * DEFAULT to the new node for
951 1.1 cgd * later use. We claim the node is
952 1.1 cgd * A transformation rule to make
953 1.1 cgd * life easier later, when we'll
954 1.1 cgd * use Make_HandleUse to actually
955 1.1 cgd * apply the .DEFAULT commands.
956 1.22 christos * .PHONY The list of targets
957 1.32 gwr * .NOPATH Don't search for file in the path
958 1.1 cgd * .BEGIN
959 1.1 cgd * .END
960 1.1 cgd * .INTERRUPT Are not to be considered the
961 1.1 cgd * main target.
962 1.1 cgd * .NOTPARALLEL Make only one target at a time.
963 1.1 cgd * .SINGLESHELL Create a shell for each command.
964 1.1 cgd * .ORDER Must set initial predecessor to NIL
965 1.1 cgd */
966 1.1 cgd switch (specType) {
967 1.5 cgd case ExPath:
968 1.1 cgd if (paths == NULL) {
969 1.1 cgd paths = Lst_Init(FALSE);
970 1.1 cgd }
971 1.119 dsl (void)Lst_AtEnd(paths, dirSearchPath);
972 1.1 cgd break;
973 1.1 cgd case Main:
974 1.1 cgd if (!Lst_IsEmpty(create)) {
975 1.1 cgd specType = Not;
976 1.1 cgd }
977 1.1 cgd break;
978 1.1 cgd case Begin:
979 1.1 cgd case End:
980 1.1 cgd case Interrupt:
981 1.1 cgd gn = Targ_FindNode(line, TARG_CREATE);
982 1.99 christos gn->type |= OP_NOTMAIN|OP_SPECIAL;
983 1.119 dsl (void)Lst_AtEnd(targets, gn);
984 1.1 cgd break;
985 1.1 cgd case Default:
986 1.1 cgd gn = Targ_NewGN(".DEFAULT");
987 1.1 cgd gn->type |= (OP_NOTMAIN|OP_TRANSFORM);
988 1.119 dsl (void)Lst_AtEnd(targets, gn);
989 1.1 cgd DEFAULT = gn;
990 1.1 cgd break;
991 1.1 cgd case NotParallel:
992 1.113 dsl maxJobs = 1;
993 1.1 cgd break;
994 1.1 cgd case SingleShell:
995 1.54 sommerfe compatMake = TRUE;
996 1.1 cgd break;
997 1.1 cgd case Order:
998 1.1 cgd predecessor = NILGNODE;
999 1.1 cgd break;
1000 1.5 cgd default:
1001 1.5 cgd break;
1002 1.1 cgd }
1003 1.103 christos } else if (strncmp(line, ".PATH", 5) == 0) {
1004 1.1 cgd /*
1005 1.1 cgd * .PATH<suffix> has to be handled specially.
1006 1.1 cgd * Call on the suffix module to give us a path to
1007 1.1 cgd * modify.
1008 1.1 cgd */
1009 1.1 cgd Lst path;
1010 1.27 christos
1011 1.5 cgd specType = ExPath;
1012 1.97 christos path = Suff_GetPath(&line[5]);
1013 1.1 cgd if (path == NILLST) {
1014 1.97 christos Parse_Error(PARSE_FATAL,
1015 1.1 cgd "Suffix '%s' not defined (yet)",
1016 1.1 cgd &line[5]);
1017 1.112 christos goto out;
1018 1.1 cgd } else {
1019 1.1 cgd if (paths == (Lst)NULL) {
1020 1.1 cgd paths = Lst_Init(FALSE);
1021 1.1 cgd }
1022 1.119 dsl (void)Lst_AtEnd(paths, path);
1023 1.1 cgd }
1024 1.1 cgd }
1025 1.1 cgd }
1026 1.27 christos
1027 1.1 cgd /*
1028 1.1 cgd * Have word in line. Get or create its node and stick it at
1029 1.27 christos * the end of the targets list
1030 1.1 cgd */
1031 1.1 cgd if ((specType == Not) && (*line != '\0')) {
1032 1.1 cgd if (Dir_HasWildcards(line)) {
1033 1.1 cgd /*
1034 1.1 cgd * Targets are to be sought only in the current directory,
1035 1.1 cgd * so create an empty path for the thing. Note we need to
1036 1.1 cgd * use Dir_Destroy in the destruction of the path as the
1037 1.1 cgd * Dir module could have added a directory to the path...
1038 1.1 cgd */
1039 1.1 cgd Lst emptyPath = Lst_Init(FALSE);
1040 1.27 christos
1041 1.1 cgd Dir_Expand(line, emptyPath, curTargs);
1042 1.27 christos
1043 1.1 cgd Lst_Destroy(emptyPath, Dir_Destroy);
1044 1.1 cgd } else {
1045 1.1 cgd /*
1046 1.1 cgd * No wildcards, but we want to avoid code duplication,
1047 1.1 cgd * so create a list with the word on it.
1048 1.1 cgd */
1049 1.119 dsl (void)Lst_AtEnd(curTargs, line);
1050 1.1 cgd }
1051 1.27 christos
1052 1.1 cgd while(!Lst_IsEmpty(curTargs)) {
1053 1.1 cgd char *targName = (char *)Lst_DeQueue(curTargs);
1054 1.27 christos
1055 1.1 cgd if (!Suff_IsTransform (targName)) {
1056 1.97 christos gn = Targ_FindNode(targName, TARG_CREATE);
1057 1.1 cgd } else {
1058 1.97 christos gn = Suff_AddTransform(targName);
1059 1.1 cgd }
1060 1.27 christos
1061 1.119 dsl (void)Lst_AtEnd(targets, gn);
1062 1.1 cgd }
1063 1.5 cgd } else if (specType == ExPath && *line != '.' && *line != '\0') {
1064 1.1 cgd Parse_Error(PARSE_WARNING, "Extra target (%s) ignored", line);
1065 1.1 cgd }
1066 1.27 christos
1067 1.1 cgd *cp = savec;
1068 1.1 cgd /*
1069 1.1 cgd * If it is a special type and not .PATH, it's the only target we
1070 1.1 cgd * allow on this line...
1071 1.1 cgd */
1072 1.5 cgd if (specType != Not && specType != ExPath) {
1073 1.115 christos Boolean warning = FALSE;
1074 1.27 christos
1075 1.77 christos while (*cp && (ParseIsEscaped(lstart, cp) ||
1076 1.77 christos ((*cp != '!') && (*cp != ':')))) {
1077 1.77 christos if (ParseIsEscaped(lstart, cp) ||
1078 1.77 christos (*cp != ' ' && *cp != '\t')) {
1079 1.115 christos warning = TRUE;
1080 1.1 cgd }
1081 1.1 cgd cp++;
1082 1.1 cgd }
1083 1.115 christos if (warning) {
1084 1.1 cgd Parse_Error(PARSE_WARNING, "Extra target ignored");
1085 1.1 cgd }
1086 1.1 cgd } else {
1087 1.40 christos while (*cp && isspace ((unsigned char)*cp)) {
1088 1.1 cgd cp++;
1089 1.1 cgd }
1090 1.1 cgd }
1091 1.1 cgd line = cp;
1092 1.77 christos } while (*line && (ParseIsEscaped(lstart, line) ||
1093 1.77 christos ((*line != '!') && (*line != ':'))));
1094 1.1 cgd
1095 1.1 cgd /*
1096 1.1 cgd * Don't need the list of target names anymore...
1097 1.1 cgd */
1098 1.1 cgd Lst_Destroy(curTargs, NOFREE);
1099 1.112 christos curTargs = NULL;
1100 1.1 cgd
1101 1.1 cgd if (!Lst_IsEmpty(targets)) {
1102 1.1 cgd switch(specType) {
1103 1.1 cgd default:
1104 1.1 cgd Parse_Error(PARSE_WARNING, "Special and mundane targets don't mix. Mundane ones ignored");
1105 1.1 cgd break;
1106 1.1 cgd case Default:
1107 1.1 cgd case Begin:
1108 1.1 cgd case End:
1109 1.1 cgd case Interrupt:
1110 1.1 cgd /*
1111 1.1 cgd * These four create nodes on which to hang commands, so
1112 1.1 cgd * targets shouldn't be empty...
1113 1.1 cgd */
1114 1.1 cgd case Not:
1115 1.1 cgd /*
1116 1.1 cgd * Nothing special here -- targets can be empty if it wants.
1117 1.1 cgd */
1118 1.1 cgd break;
1119 1.1 cgd }
1120 1.1 cgd }
1121 1.1 cgd
1122 1.1 cgd /*
1123 1.1 cgd * Have now parsed all the target names. Must parse the operator next. The
1124 1.1 cgd * result is left in op .
1125 1.1 cgd */
1126 1.1 cgd if (*cp == '!') {
1127 1.1 cgd op = OP_FORCE;
1128 1.1 cgd } else if (*cp == ':') {
1129 1.1 cgd if (cp[1] == ':') {
1130 1.1 cgd op = OP_DOUBLEDEP;
1131 1.1 cgd cp++;
1132 1.1 cgd } else {
1133 1.1 cgd op = OP_DEPENDS;
1134 1.1 cgd }
1135 1.1 cgd } else {
1136 1.97 christos Parse_Error(PARSE_FATAL, "Missing dependency operator");
1137 1.112 christos goto out;
1138 1.1 cgd }
1139 1.1 cgd
1140 1.1 cgd cp++; /* Advance beyond operator */
1141 1.1 cgd
1142 1.119 dsl Lst_ForEach(targets, ParseDoOp, &op);
1143 1.1 cgd
1144 1.1 cgd /*
1145 1.27 christos * Get to the first source
1146 1.1 cgd */
1147 1.40 christos while (*cp && isspace ((unsigned char)*cp)) {
1148 1.1 cgd cp++;
1149 1.1 cgd }
1150 1.1 cgd line = cp;
1151 1.1 cgd
1152 1.1 cgd /*
1153 1.1 cgd * Several special targets take different actions if present with no
1154 1.1 cgd * sources:
1155 1.1 cgd * a .SUFFIXES line with no sources clears out all old suffixes
1156 1.1 cgd * a .PRECIOUS line makes all targets precious
1157 1.1 cgd * a .IGNORE line ignores errors for all targets
1158 1.1 cgd * a .SILENT line creates silence when making all targets
1159 1.1 cgd * a .PATH removes all directories from the search path(s).
1160 1.1 cgd */
1161 1.1 cgd if (!*line) {
1162 1.1 cgd switch (specType) {
1163 1.1 cgd case Suffixes:
1164 1.97 christos Suff_ClearSuffixes();
1165 1.1 cgd break;
1166 1.1 cgd case Precious:
1167 1.1 cgd allPrecious = TRUE;
1168 1.1 cgd break;
1169 1.1 cgd case Ignore:
1170 1.1 cgd ignoreErrors = TRUE;
1171 1.1 cgd break;
1172 1.1 cgd case Silent:
1173 1.1 cgd beSilent = TRUE;
1174 1.1 cgd break;
1175 1.5 cgd case ExPath:
1176 1.119 dsl Lst_ForEach(paths, ParseClearPath, NULL);
1177 1.85 sjg Dir_SetPATH();
1178 1.1 cgd break;
1179 1.48 sjg #ifdef POSIX
1180 1.48 sjg case Posix:
1181 1.70 sjg Var_Set("%POSIX", "1003.2", VAR_GLOBAL, 0);
1182 1.48 sjg break;
1183 1.48 sjg #endif
1184 1.5 cgd default:
1185 1.5 cgd break;
1186 1.1 cgd }
1187 1.1 cgd } else if (specType == MFlags) {
1188 1.1 cgd /*
1189 1.1 cgd * Call on functions in main.c to deal with these arguments and
1190 1.1 cgd * set the initial character to a null-character so the loop to
1191 1.1 cgd * get sources won't get anything
1192 1.1 cgd */
1193 1.97 christos Main_ParseArgLine(line);
1194 1.1 cgd *line = '\0';
1195 1.5 cgd } else if (specType == ExShell) {
1196 1.97 christos if (Job_ParseShell(line) != SUCCESS) {
1197 1.97 christos Parse_Error(PARSE_FATAL, "improper shell specification");
1198 1.112 christos goto out;
1199 1.1 cgd }
1200 1.1 cgd *line = '\0';
1201 1.1 cgd } else if ((specType == NotParallel) || (specType == SingleShell)) {
1202 1.1 cgd *line = '\0';
1203 1.1 cgd }
1204 1.27 christos
1205 1.1 cgd /*
1206 1.27 christos * NOW GO FOR THE SOURCES
1207 1.1 cgd */
1208 1.5 cgd if ((specType == Suffixes) || (specType == ExPath) ||
1209 1.1 cgd (specType == Includes) || (specType == Libs) ||
1210 1.75 tv (specType == Null) || (specType == ExObjdir))
1211 1.1 cgd {
1212 1.1 cgd while (*line) {
1213 1.1 cgd /*
1214 1.1 cgd * If the target was one that doesn't take files as its sources
1215 1.1 cgd * but takes something like suffixes, we take each
1216 1.1 cgd * space-separated word on the line as a something and deal
1217 1.1 cgd * with it accordingly.
1218 1.1 cgd *
1219 1.1 cgd * If the target was .SUFFIXES, we take each source as a
1220 1.1 cgd * suffix and add it to the list of suffixes maintained by the
1221 1.1 cgd * Suff module.
1222 1.1 cgd *
1223 1.1 cgd * If the target was a .PATH, we add the source as a directory
1224 1.1 cgd * to search on the search path.
1225 1.1 cgd *
1226 1.1 cgd * If it was .INCLUDES, the source is taken to be the suffix of
1227 1.1 cgd * files which will be #included and whose search path should
1228 1.1 cgd * be present in the .INCLUDES variable.
1229 1.1 cgd *
1230 1.1 cgd * If it was .LIBS, the source is taken to be the suffix of
1231 1.1 cgd * files which are considered libraries and whose search path
1232 1.1 cgd * should be present in the .LIBS variable.
1233 1.1 cgd *
1234 1.1 cgd * If it was .NULL, the source is the suffix to use when a file
1235 1.1 cgd * has no valid suffix.
1236 1.75 tv *
1237 1.75 tv * If it was .OBJDIR, the source is a new definition for .OBJDIR,
1238 1.75 tv * and will cause make to do a new chdir to that path.
1239 1.1 cgd */
1240 1.40 christos while (*cp && !isspace ((unsigned char)*cp)) {
1241 1.1 cgd cp++;
1242 1.1 cgd }
1243 1.1 cgd savec = *cp;
1244 1.1 cgd *cp = '\0';
1245 1.1 cgd switch (specType) {
1246 1.1 cgd case Suffixes:
1247 1.97 christos Suff_AddSuffix(line, &mainNode);
1248 1.1 cgd break;
1249 1.5 cgd case ExPath:
1250 1.119 dsl Lst_ForEach(paths, ParseAddDir, line);
1251 1.1 cgd break;
1252 1.1 cgd case Includes:
1253 1.97 christos Suff_AddInclude(line);
1254 1.1 cgd break;
1255 1.1 cgd case Libs:
1256 1.97 christos Suff_AddLib(line);
1257 1.1 cgd break;
1258 1.1 cgd case Null:
1259 1.97 christos Suff_SetNull(line);
1260 1.75 tv break;
1261 1.75 tv case ExObjdir:
1262 1.75 tv Main_SetObjdir(line);
1263 1.1 cgd break;
1264 1.5 cgd default:
1265 1.5 cgd break;
1266 1.1 cgd }
1267 1.1 cgd *cp = savec;
1268 1.1 cgd if (savec != '\0') {
1269 1.1 cgd cp++;
1270 1.1 cgd }
1271 1.40 christos while (*cp && isspace ((unsigned char)*cp)) {
1272 1.1 cgd cp++;
1273 1.1 cgd }
1274 1.1 cgd line = cp;
1275 1.1 cgd }
1276 1.1 cgd if (paths) {
1277 1.1 cgd Lst_Destroy(paths, NOFREE);
1278 1.1 cgd }
1279 1.85 sjg if (specType == ExPath)
1280 1.85 sjg Dir_SetPATH();
1281 1.1 cgd } else {
1282 1.1 cgd while (*line) {
1283 1.1 cgd /*
1284 1.1 cgd * The targets take real sources, so we must beware of archive
1285 1.1 cgd * specifications (i.e. things with left parentheses in them)
1286 1.1 cgd * and handle them accordingly.
1287 1.1 cgd */
1288 1.118 dsl for (; *cp && !isspace ((unsigned char)*cp); cp++) {
1289 1.77 christos if ((*cp == LPAREN) && (cp > line) && (cp[-1] != '$')) {
1290 1.1 cgd /*
1291 1.1 cgd * Only stop for a left parenthesis if it isn't at the
1292 1.1 cgd * start of a word (that'll be for variable changes
1293 1.1 cgd * later) and isn't preceded by a dollar sign (a dynamic
1294 1.1 cgd * source).
1295 1.1 cgd */
1296 1.1 cgd break;
1297 1.1 cgd }
1298 1.1 cgd }
1299 1.1 cgd
1300 1.77 christos if (*cp == LPAREN) {
1301 1.97 christos sources = Lst_Init(FALSE);
1302 1.97 christos if (Arch_ParseArchive(&line, sources, VAR_CMD) != SUCCESS) {
1303 1.97 christos Parse_Error(PARSE_FATAL,
1304 1.1 cgd "Error in source archive spec \"%s\"", line);
1305 1.112 christos goto out;
1306 1.1 cgd }
1307 1.1 cgd
1308 1.1 cgd while (!Lst_IsEmpty (sources)) {
1309 1.103 christos gn = (GNode *)Lst_DeQueue(sources);
1310 1.120 dsl ParseDoSrc(tOp, gn->name);
1311 1.1 cgd }
1312 1.97 christos Lst_Destroy(sources, NOFREE);
1313 1.1 cgd cp = line;
1314 1.1 cgd } else {
1315 1.1 cgd if (*cp) {
1316 1.1 cgd *cp = '\0';
1317 1.1 cgd cp += 1;
1318 1.1 cgd }
1319 1.1 cgd
1320 1.120 dsl ParseDoSrc(tOp, line);
1321 1.1 cgd }
1322 1.40 christos while (*cp && isspace ((unsigned char)*cp)) {
1323 1.1 cgd cp++;
1324 1.1 cgd }
1325 1.1 cgd line = cp;
1326 1.1 cgd }
1327 1.1 cgd }
1328 1.27 christos
1329 1.1 cgd if (mainNode == NILGNODE) {
1330 1.1 cgd /*
1331 1.1 cgd * If we have yet to decide on a main target to make, in the
1332 1.1 cgd * absence of any user input, we want the first target on
1333 1.1 cgd * the first dependency line that is actually a real target
1334 1.1 cgd * (i.e. isn't a .USE or .EXEC rule) to be made.
1335 1.1 cgd */
1336 1.119 dsl Lst_ForEach(targets, ParseFindMain, NULL);
1337 1.1 cgd }
1338 1.1 cgd
1339 1.112 christos out:
1340 1.112 christos if (curTargs)
1341 1.112 christos Lst_Destroy(curTargs, NOFREE);
1342 1.1 cgd }
1343 1.1 cgd
1344 1.1 cgd /*-
1345 1.1 cgd *---------------------------------------------------------------------
1346 1.1 cgd * Parse_IsVar --
1347 1.1 cgd * Return TRUE if the passed line is a variable assignment. A variable
1348 1.1 cgd * assignment consists of a single word followed by optional whitespace
1349 1.1 cgd * followed by either a += or an = operator.
1350 1.1 cgd * This function is used both by the Parse_File function and main when
1351 1.1 cgd * parsing the command-line arguments.
1352 1.1 cgd *
1353 1.84 wiz * Input:
1354 1.84 wiz * line the line to check
1355 1.84 wiz *
1356 1.1 cgd * Results:
1357 1.1 cgd * TRUE if it is. FALSE if it ain't
1358 1.1 cgd *
1359 1.1 cgd * Side Effects:
1360 1.1 cgd * none
1361 1.1 cgd *---------------------------------------------------------------------
1362 1.1 cgd */
1363 1.1 cgd Boolean
1364 1.84 wiz Parse_IsVar(char *line)
1365 1.1 cgd {
1366 1.84 wiz Boolean wasSpace = FALSE; /* set TRUE if found a space */
1367 1.84 wiz Boolean haveName = FALSE; /* Set TRUE if have a variable name */
1368 1.16 christos int level = 0;
1369 1.16 christos #define ISEQOPERATOR(c) \
1370 1.16 christos (((c) == '+') || ((c) == ':') || ((c) == '?') || ((c) == '!'))
1371 1.1 cgd
1372 1.1 cgd /*
1373 1.1 cgd * Skip to variable name
1374 1.1 cgd */
1375 1.27 christos for (;(*line == ' ') || (*line == '\t'); line++)
1376 1.16 christos continue;
1377 1.1 cgd
1378 1.16 christos for (; *line != '=' || level != 0; line++)
1379 1.16 christos switch (*line) {
1380 1.16 christos case '\0':
1381 1.1 cgd /*
1382 1.1 cgd * end-of-line -- can't be a variable assignment.
1383 1.1 cgd */
1384 1.16 christos return FALSE;
1385 1.16 christos
1386 1.16 christos case ' ':
1387 1.16 christos case '\t':
1388 1.1 cgd /*
1389 1.1 cgd * there can be as much white space as desired so long as there is
1390 1.27 christos * only one word before the operator
1391 1.1 cgd */
1392 1.1 cgd wasSpace = TRUE;
1393 1.16 christos break;
1394 1.16 christos
1395 1.77 christos case LPAREN:
1396 1.16 christos case '{':
1397 1.16 christos level++;
1398 1.16 christos break;
1399 1.16 christos
1400 1.16 christos case '}':
1401 1.77 christos case RPAREN:
1402 1.16 christos level--;
1403 1.16 christos break;
1404 1.27 christos
1405 1.16 christos default:
1406 1.16 christos if (wasSpace && haveName) {
1407 1.16 christos if (ISEQOPERATOR(*line)) {
1408 1.16 christos /*
1409 1.23 christos * We must have a finished word
1410 1.23 christos */
1411 1.23 christos if (level != 0)
1412 1.23 christos return FALSE;
1413 1.23 christos
1414 1.23 christos /*
1415 1.16 christos * When an = operator [+?!:] is found, the next
1416 1.23 christos * character must be an = or it ain't a valid
1417 1.16 christos * assignment.
1418 1.16 christos */
1419 1.23 christos if (line[1] == '=')
1420 1.16 christos return haveName;
1421 1.23 christos #ifdef SUNSHCMD
1422 1.16 christos /*
1423 1.23 christos * This is a shell command
1424 1.16 christos */
1425 1.23 christos if (strncmp(line, ":sh", 3) == 0)
1426 1.23 christos return haveName;
1427 1.23 christos #endif
1428 1.16 christos }
1429 1.23 christos /*
1430 1.23 christos * This is the start of another word, so not assignment.
1431 1.23 christos */
1432 1.23 christos return FALSE;
1433 1.16 christos }
1434 1.16 christos else {
1435 1.27 christos haveName = TRUE;
1436 1.16 christos wasSpace = FALSE;
1437 1.1 cgd }
1438 1.16 christos break;
1439 1.1 cgd }
1440 1.1 cgd
1441 1.16 christos return haveName;
1442 1.1 cgd }
1443 1.1 cgd
1444 1.1 cgd /*-
1445 1.1 cgd *---------------------------------------------------------------------
1446 1.1 cgd * Parse_DoVar --
1447 1.1 cgd * Take the variable assignment in the passed line and do it in the
1448 1.1 cgd * global context.
1449 1.1 cgd *
1450 1.1 cgd * Note: There is a lexical ambiguity with assignment modifier characters
1451 1.1 cgd * in variable names. This routine interprets the character before the =
1452 1.1 cgd * as a modifier. Therefore, an assignment like
1453 1.1 cgd * C++=/usr/bin/CC
1454 1.1 cgd * is interpreted as "C+ +=" instead of "C++ =".
1455 1.1 cgd *
1456 1.84 wiz * Input:
1457 1.84 wiz * line a line guaranteed to be a variable assignment.
1458 1.84 wiz * This reduces error checks
1459 1.84 wiz * ctxt Context in which to do the assignment
1460 1.84 wiz *
1461 1.1 cgd * Results:
1462 1.1 cgd * none
1463 1.1 cgd *
1464 1.1 cgd * Side Effects:
1465 1.1 cgd * the variable structure of the given variable name is altered in the
1466 1.1 cgd * global context.
1467 1.1 cgd *---------------------------------------------------------------------
1468 1.1 cgd */
1469 1.1 cgd void
1470 1.84 wiz Parse_DoVar(char *line, GNode *ctxt)
1471 1.1 cgd {
1472 1.7 cgd char *cp; /* pointer into line */
1473 1.1 cgd enum {
1474 1.1 cgd VAR_SUBST, VAR_APPEND, VAR_SHELL, VAR_NORMAL
1475 1.1 cgd } type; /* Type of assignment */
1476 1.27 christos char *opc; /* ptr to operator character to
1477 1.1 cgd * null-terminate the variable name */
1478 1.86 sjg Boolean freeCp = FALSE; /* TRUE if cp needs to be freed,
1479 1.86 sjg * i.e. if any variable expansion was
1480 1.86 sjg * performed */
1481 1.1 cgd
1482 1.1 cgd /*
1483 1.1 cgd * Skip to variable name
1484 1.1 cgd */
1485 1.1 cgd while ((*line == ' ') || (*line == '\t')) {
1486 1.1 cgd line++;
1487 1.1 cgd }
1488 1.1 cgd
1489 1.1 cgd /*
1490 1.1 cgd * Skip to operator character, nulling out whitespace as we go
1491 1.1 cgd */
1492 1.1 cgd for (cp = line + 1; *cp != '='; cp++) {
1493 1.40 christos if (isspace ((unsigned char)*cp)) {
1494 1.1 cgd *cp = '\0';
1495 1.1 cgd }
1496 1.1 cgd }
1497 1.1 cgd opc = cp-1; /* operator is the previous character */
1498 1.1 cgd *cp++ = '\0'; /* nuke the = */
1499 1.1 cgd
1500 1.1 cgd /*
1501 1.1 cgd * Check operator type
1502 1.1 cgd */
1503 1.1 cgd switch (*opc) {
1504 1.1 cgd case '+':
1505 1.1 cgd type = VAR_APPEND;
1506 1.1 cgd *opc = '\0';
1507 1.1 cgd break;
1508 1.1 cgd
1509 1.1 cgd case '?':
1510 1.1 cgd /*
1511 1.1 cgd * If the variable already has a value, we don't do anything.
1512 1.1 cgd */
1513 1.1 cgd *opc = '\0';
1514 1.1 cgd if (Var_Exists(line, ctxt)) {
1515 1.1 cgd return;
1516 1.1 cgd } else {
1517 1.1 cgd type = VAR_NORMAL;
1518 1.1 cgd }
1519 1.1 cgd break;
1520 1.1 cgd
1521 1.1 cgd case ':':
1522 1.1 cgd type = VAR_SUBST;
1523 1.1 cgd *opc = '\0';
1524 1.1 cgd break;
1525 1.1 cgd
1526 1.1 cgd case '!':
1527 1.1 cgd type = VAR_SHELL;
1528 1.1 cgd *opc = '\0';
1529 1.1 cgd break;
1530 1.1 cgd
1531 1.1 cgd default:
1532 1.23 christos #ifdef SUNSHCMD
1533 1.39 christos while (opc > line && *opc != ':')
1534 1.39 christos opc--;
1535 1.23 christos
1536 1.23 christos if (strncmp(opc, ":sh", 3) == 0) {
1537 1.23 christos type = VAR_SHELL;
1538 1.23 christos *opc = '\0';
1539 1.23 christos break;
1540 1.23 christos }
1541 1.23 christos #endif
1542 1.1 cgd type = VAR_NORMAL;
1543 1.1 cgd break;
1544 1.1 cgd }
1545 1.1 cgd
1546 1.40 christos while (isspace ((unsigned char)*cp)) {
1547 1.1 cgd cp++;
1548 1.1 cgd }
1549 1.1 cgd
1550 1.1 cgd if (type == VAR_APPEND) {
1551 1.97 christos Var_Append(line, cp, ctxt);
1552 1.1 cgd } else if (type == VAR_SUBST) {
1553 1.1 cgd /*
1554 1.1 cgd * Allow variables in the old value to be undefined, but leave their
1555 1.1 cgd * invocation alone -- this is done by forcing oldVars to be false.
1556 1.1 cgd * XXX: This can cause recursive variables, but that's not hard to do,
1557 1.1 cgd * and this allows someone to do something like
1558 1.1 cgd *
1559 1.1 cgd * CFLAGS = $(.INCLUDES)
1560 1.1 cgd * CFLAGS := -I.. $(CFLAGS)
1561 1.1 cgd *
1562 1.1 cgd * And not get an error.
1563 1.1 cgd */
1564 1.1 cgd Boolean oldOldVars = oldVars;
1565 1.1 cgd
1566 1.1 cgd oldVars = FALSE;
1567 1.42 christos
1568 1.42 christos /*
1569 1.42 christos * make sure that we set the variable the first time to nothing
1570 1.42 christos * so that it gets substituted!
1571 1.42 christos */
1572 1.42 christos if (!Var_Exists(line, ctxt))
1573 1.70 sjg Var_Set(line, "", ctxt, 0);
1574 1.42 christos
1575 1.5 cgd cp = Var_Subst(NULL, cp, ctxt, FALSE);
1576 1.1 cgd oldVars = oldOldVars;
1577 1.86 sjg freeCp = TRUE;
1578 1.1 cgd
1579 1.70 sjg Var_Set(line, cp, ctxt, 0);
1580 1.1 cgd } else if (type == VAR_SHELL) {
1581 1.93 christos char *res;
1582 1.115 christos const char *error;
1583 1.5 cgd
1584 1.23 christos if (strchr(cp, '$') != NULL) {
1585 1.1 cgd /*
1586 1.1 cgd * There's a dollar sign in the command, so perform variable
1587 1.1 cgd * expansion on the whole thing. The resulting string will need
1588 1.1 cgd * freeing when we're done, so set freeCmd to TRUE.
1589 1.1 cgd */
1590 1.23 christos cp = Var_Subst(NULL, cp, VAR_CMD, TRUE);
1591 1.86 sjg freeCp = TRUE;
1592 1.1 cgd }
1593 1.1 cgd
1594 1.115 christos res = Cmd_Exec(cp, &error);
1595 1.70 sjg Var_Set(line, res, ctxt, 0);
1596 1.23 christos free(res);
1597 1.1 cgd
1598 1.115 christos if (error)
1599 1.115 christos Parse_Error(PARSE_WARNING, error, cp);
1600 1.1 cgd } else {
1601 1.1 cgd /*
1602 1.1 cgd * Normal assignment -- just do it.
1603 1.1 cgd */
1604 1.70 sjg Var_Set(line, cp, ctxt, 0);
1605 1.1 cgd }
1606 1.69 sjg if (strcmp(line, MAKEOVERRIDES) == 0)
1607 1.74 tv Main_ExportMAKEFLAGS(FALSE); /* re-export MAKEFLAGS */
1608 1.85 sjg else if (strcmp(line, ".CURDIR") == 0) {
1609 1.85 sjg /*
1610 1.85 sjg * Somone is being (too?) clever...
1611 1.85 sjg * Let's pretend they know what they are doing and
1612 1.85 sjg * re-initialize the 'cur' Path.
1613 1.85 sjg */
1614 1.85 sjg Dir_InitCur(cp);
1615 1.85 sjg Dir_SetPATH();
1616 1.85 sjg }
1617 1.86 sjg if (freeCp)
1618 1.86 sjg free(cp);
1619 1.1 cgd }
1620 1.23 christos
1621 1.1 cgd
1622 1.1 cgd /*-
1623 1.1 cgd * ParseAddCmd --
1624 1.1 cgd * Lst_ForEach function to add a command line to all targets
1625 1.1 cgd *
1626 1.84 wiz * Input:
1627 1.84 wiz * gnp the node to which the command is to be added
1628 1.84 wiz * cmd the command to add
1629 1.84 wiz *
1630 1.1 cgd * Results:
1631 1.1 cgd * Always 0
1632 1.1 cgd *
1633 1.1 cgd * Side Effects:
1634 1.1 cgd * A new element is added to the commands list of the node.
1635 1.1 cgd */
1636 1.5 cgd static int
1637 1.84 wiz ParseAddCmd(ClientData gnp, ClientData cmd)
1638 1.9 jtc {
1639 1.105 christos GNode *gn = (GNode *)gnp;
1640 1.120 dsl
1641 1.120 dsl /* Add to last (ie current) cohort for :: targets */
1642 1.47 mycroft if ((gn->type & OP_DOUBLEDEP) && !Lst_IsEmpty (gn->cohorts))
1643 1.103 christos gn = (GNode *)Lst_Datum(Lst_Last(gn->cohorts));
1644 1.120 dsl
1645 1.120 dsl /* if target already supplied, ignore commands */
1646 1.59 christos if (!(gn->type & OP_HAS_COMMANDS)) {
1647 1.59 christos (void)Lst_AtEnd(gn->commands, cmd);
1648 1.59 christos ParseMark(gn);
1649 1.59 christos } else {
1650 1.60 christos #ifdef notyet
1651 1.60 christos /* XXX: We cannot do this until we fix the tree */
1652 1.9 jtc (void)Lst_AtEnd(gn->commands, cmd);
1653 1.97 christos Parse_Error(PARSE_WARNING,
1654 1.61 christos "overriding commands for target \"%s\"; "
1655 1.61 christos "previous commands defined at %s: %d ignored",
1656 1.59 christos gn->name, gn->fname, gn->lineno);
1657 1.60 christos #else
1658 1.97 christos Parse_Error(PARSE_WARNING,
1659 1.62 mycroft "duplicate script for target \"%s\" ignored",
1660 1.62 mycroft gn->name);
1661 1.97 christos ParseErrorInternal(gn->fname, gn->lineno, PARSE_WARNING,
1662 1.62 mycroft "using previous script for \"%s\" defined here",
1663 1.62 mycroft gn->name);
1664 1.60 christos #endif
1665 1.59 christos }
1666 1.9 jtc return(0);
1667 1.1 cgd }
1668 1.1 cgd
1669 1.1 cgd /*-
1670 1.1 cgd *-----------------------------------------------------------------------
1671 1.1 cgd * ParseHasCommands --
1672 1.1 cgd * Callback procedure for Parse_File when destroying the list of
1673 1.1 cgd * targets on the last dependency line. Marks a target as already
1674 1.1 cgd * having commands if it does, to keep from having shell commands
1675 1.1 cgd * on multiple dependency lines.
1676 1.1 cgd *
1677 1.84 wiz * Input:
1678 1.84 wiz * gnp Node to examine
1679 1.84 wiz *
1680 1.1 cgd * Results:
1681 1.9 jtc * None
1682 1.1 cgd *
1683 1.1 cgd * Side Effects:
1684 1.1 cgd * OP_HAS_COMMANDS may be set for the target.
1685 1.1 cgd *
1686 1.1 cgd *-----------------------------------------------------------------------
1687 1.1 cgd */
1688 1.9 jtc static void
1689 1.84 wiz ParseHasCommands(ClientData gnp)
1690 1.1 cgd {
1691 1.105 christos GNode *gn = (GNode *)gnp;
1692 1.1 cgd if (!Lst_IsEmpty(gn->commands)) {
1693 1.1 cgd gn->type |= OP_HAS_COMMANDS;
1694 1.1 cgd }
1695 1.1 cgd }
1696 1.1 cgd
1697 1.1 cgd /*-
1698 1.1 cgd *-----------------------------------------------------------------------
1699 1.1 cgd * Parse_AddIncludeDir --
1700 1.1 cgd * Add a directory to the path searched for included makefiles
1701 1.1 cgd * bracketed by double-quotes. Used by functions in main.c
1702 1.1 cgd *
1703 1.84 wiz * Input:
1704 1.84 wiz * dir The name of the directory to add
1705 1.84 wiz *
1706 1.1 cgd * Results:
1707 1.1 cgd * None.
1708 1.1 cgd *
1709 1.1 cgd * Side Effects:
1710 1.1 cgd * The directory is appended to the list.
1711 1.1 cgd *
1712 1.1 cgd *-----------------------------------------------------------------------
1713 1.1 cgd */
1714 1.1 cgd void
1715 1.84 wiz Parse_AddIncludeDir(char *dir)
1716 1.1 cgd {
1717 1.103 christos (void)Dir_AddDir(parseIncPath, dir);
1718 1.1 cgd }
1719 1.1 cgd
1720 1.1 cgd /*-
1721 1.1 cgd *---------------------------------------------------------------------
1722 1.1 cgd * ParseDoInclude --
1723 1.1 cgd * Push to another file.
1724 1.27 christos *
1725 1.38 christos * The input is the line minus the `.'. A file spec is a string
1726 1.1 cgd * enclosed in <> or "". The former is looked for only in sysIncPath.
1727 1.1 cgd * The latter in . and the directories specified by -I command line
1728 1.1 cgd * options
1729 1.1 cgd *
1730 1.1 cgd * Results:
1731 1.1 cgd * None
1732 1.1 cgd *
1733 1.1 cgd * Side Effects:
1734 1.1 cgd * A structure is added to the includes Lst and readProc, lineno,
1735 1.1 cgd * fname and curFILE are altered for the new file
1736 1.1 cgd *---------------------------------------------------------------------
1737 1.1 cgd */
1738 1.123 dsl
1739 1.1 cgd static void
1740 1.123 dsl Parse_include_file(char *file, Boolean isSystem, int silent)
1741 1.1 cgd {
1742 1.1 cgd char *fullname; /* full pathname of file */
1743 1.125 dsl int fd;
1744 1.1 cgd
1745 1.1 cgd /*
1746 1.1 cgd * Now we know the file's name and its search path, we attempt to
1747 1.1 cgd * find the durn thing. A return of NULL indicates the file don't
1748 1.1 cgd * exist.
1749 1.1 cgd */
1750 1.105 christos fullname = NULL;
1751 1.76 reinoud
1752 1.1 cgd if (!isSystem) {
1753 1.1 cgd /*
1754 1.1 cgd * Include files contained in double-quotes are first searched for
1755 1.1 cgd * relative to the including file's location. We don't want to
1756 1.1 cgd * cd there, of course, so we just tack on the old file's
1757 1.1 cgd * leading path components and call Dir_FindFile to see if
1758 1.1 cgd * we can locate the beast.
1759 1.1 cgd */
1760 1.19 thorpej char *prefEnd, *Fname;
1761 1.1 cgd
1762 1.19 thorpej /* Make a temporary copy of this, to be safe. */
1763 1.125 dsl Fname = estrdup(curFile->fname);
1764 1.19 thorpej
1765 1.103 christos prefEnd = strrchr(Fname, '/');
1766 1.105 christos if (prefEnd != NULL) {
1767 1.1 cgd char *newName;
1768 1.27 christos
1769 1.1 cgd *prefEnd = '\0';
1770 1.9 jtc if (file[0] == '/')
1771 1.24 christos newName = estrdup(file);
1772 1.9 jtc else
1773 1.97 christos newName = str_concat(Fname, file, STR_ADDSLASH);
1774 1.97 christos fullname = Dir_FindFile(newName, parseIncPath);
1775 1.105 christos if (fullname == NULL) {
1776 1.1 cgd fullname = Dir_FindFile(newName, dirSearchPath);
1777 1.1 cgd }
1778 1.103 christos free(newName);
1779 1.1 cgd *prefEnd = '/';
1780 1.1 cgd } else {
1781 1.105 christos fullname = NULL;
1782 1.1 cgd }
1783 1.103 christos free(Fname);
1784 1.105 christos if (fullname == NULL) {
1785 1.76 reinoud /*
1786 1.76 reinoud * Makefile wasn't found in same directory as included makefile.
1787 1.76 reinoud * Search for it first on the -I search path,
1788 1.76 reinoud * then on the .PATH search path, if not found in a -I directory.
1789 1.76 reinoud * XXX: Suffix specific?
1790 1.76 reinoud */
1791 1.97 christos fullname = Dir_FindFile(file, parseIncPath);
1792 1.105 christos if (fullname == NULL) {
1793 1.76 reinoud fullname = Dir_FindFile(file, dirSearchPath);
1794 1.76 reinoud }
1795 1.76 reinoud }
1796 1.1 cgd }
1797 1.1 cgd
1798 1.76 reinoud /* Looking for a system file or file still not found */
1799 1.105 christos if (fullname == NULL) {
1800 1.1 cgd /*
1801 1.76 reinoud * Look for it on the system path
1802 1.1 cgd */
1803 1.123 dsl fullname = Dir_FindFile(file,
1804 1.123 dsl Lst_IsEmpty(sysIncPath) ? defIncPath : sysIncPath);
1805 1.1 cgd }
1806 1.1 cgd
1807 1.105 christos if (fullname == NULL) {
1808 1.38 christos if (!silent)
1809 1.97 christos Parse_Error(PARSE_FATAL, "Could not find %s", file);
1810 1.1 cgd return;
1811 1.1 cgd }
1812 1.1 cgd
1813 1.125 dsl /* Actually open the file... */
1814 1.125 dsl fd = open(fullname, O_RDONLY);
1815 1.125 dsl if (fd == -1) {
1816 1.38 christos if (!silent)
1817 1.97 christos Parse_Error(PARSE_FATAL, "Cannot open %s", fullname);
1818 1.125 dsl return;
1819 1.123 dsl }
1820 1.125 dsl
1821 1.125 dsl /* Start reading from this file next */
1822 1.125 dsl Parse_SetInput(fullname, 0, fd, NULL);
1823 1.123 dsl }
1824 1.123 dsl
1825 1.123 dsl static void
1826 1.123 dsl ParseDoInclude(char *line)
1827 1.123 dsl {
1828 1.123 dsl char endc; /* the character which ends the file spec */
1829 1.123 dsl char *cp; /* current position in file spec */
1830 1.123 dsl int silent = (*line != 'i') ? 1 : 0;
1831 1.123 dsl char *file = &line[7 + silent];
1832 1.123 dsl
1833 1.123 dsl /* Skip to delimiter character so we know where to look */
1834 1.123 dsl while (*file == ' ' || *file == '\t')
1835 1.123 dsl file++;
1836 1.123 dsl
1837 1.123 dsl if (*file != '"' && *file != '<') {
1838 1.123 dsl Parse_Error(PARSE_FATAL,
1839 1.123 dsl ".include filename must be delimited by '\"' or '<'");
1840 1.123 dsl return;
1841 1.123 dsl }
1842 1.123 dsl
1843 1.123 dsl /*
1844 1.123 dsl * Set the search path on which to find the include file based on the
1845 1.123 dsl * characters which bracket its name. Angle-brackets imply it's
1846 1.123 dsl * a system Makefile while double-quotes imply it's a user makefile
1847 1.123 dsl */
1848 1.123 dsl if (*file == '<') {
1849 1.123 dsl endc = '>';
1850 1.123 dsl } else {
1851 1.123 dsl endc = '"';
1852 1.123 dsl }
1853 1.123 dsl
1854 1.123 dsl /* Skip to matching delimiter */
1855 1.123 dsl for (cp = ++file; *cp && *cp != endc; cp++)
1856 1.123 dsl continue;
1857 1.123 dsl
1858 1.123 dsl if (*cp != endc) {
1859 1.123 dsl Parse_Error(PARSE_FATAL,
1860 1.123 dsl "Unclosed %cinclude filename. '%c' expected",
1861 1.123 dsl '.', endc);
1862 1.123 dsl return;
1863 1.1 cgd }
1864 1.123 dsl *cp = '\0';
1865 1.123 dsl
1866 1.123 dsl /*
1867 1.123 dsl * Substitute for any variables in the file name before trying to
1868 1.123 dsl * find the thing.
1869 1.123 dsl */
1870 1.123 dsl file = Var_Subst(NULL, file, VAR_CMD, FALSE);
1871 1.123 dsl
1872 1.123 dsl Parse_include_file(file, endc == '>', silent);
1873 1.123 dsl free(file);
1874 1.1 cgd }
1875 1.1 cgd
1876 1.5 cgd
1877 1.5 cgd /*-
1878 1.5 cgd *---------------------------------------------------------------------
1879 1.44 aidan * ParseSetParseFile --
1880 1.44 aidan * Set the .PARSEDIR and .PARSEFILE variables to the dirname and
1881 1.44 aidan * basename of the given filename
1882 1.44 aidan *
1883 1.44 aidan * Results:
1884 1.44 aidan * None
1885 1.44 aidan *
1886 1.44 aidan * Side Effects:
1887 1.44 aidan * The .PARSEDIR and .PARSEFILE variables are overwritten by the
1888 1.44 aidan * dirname and basename of the given filename.
1889 1.44 aidan *---------------------------------------------------------------------
1890 1.44 aidan */
1891 1.44 aidan static void
1892 1.122 dsl ParseSetParseFile(const char *filename)
1893 1.44 aidan {
1894 1.44 aidan char *slash;
1895 1.122 dsl char *dirname;
1896 1.122 dsl int len;
1897 1.44 aidan
1898 1.78 reinoud slash = strrchr(filename, '/');
1899 1.122 dsl if (slash == NULL) {
1900 1.70 sjg Var_Set(".PARSEDIR", ".", VAR_GLOBAL, 0);
1901 1.78 reinoud Var_Set(".PARSEFILE", filename, VAR_GLOBAL, 0);
1902 1.44 aidan } else {
1903 1.122 dsl len = slash - filename;
1904 1.122 dsl dirname = emalloc(len + 1);
1905 1.122 dsl memcpy(dirname, filename, len);
1906 1.122 dsl dirname[len] = 0;
1907 1.122 dsl Var_Set(".PARSEDIR", dirname, VAR_GLOBAL, 0);
1908 1.70 sjg Var_Set(".PARSEFILE", slash+1, VAR_GLOBAL, 0);
1909 1.122 dsl free(dirname);
1910 1.44 aidan }
1911 1.44 aidan }
1912 1.44 aidan
1913 1.44 aidan
1914 1.44 aidan /*-
1915 1.44 aidan *---------------------------------------------------------------------
1916 1.125 dsl * Parse_setInput --
1917 1.125 dsl * Start Parsing from the given source
1918 1.27 christos *
1919 1.5 cgd * Results:
1920 1.5 cgd * None
1921 1.5 cgd *
1922 1.5 cgd * Side Effects:
1923 1.5 cgd * A structure is added to the includes Lst and readProc, lineno,
1924 1.125 dsl * fname and curFile are altered for the new file
1925 1.5 cgd *---------------------------------------------------------------------
1926 1.5 cgd */
1927 1.5 cgd void
1928 1.125 dsl Parse_SetInput(const char *name, int line, int fd, char *buf)
1929 1.5 cgd {
1930 1.127 dsl if (name == NULL)
1931 1.127 dsl name = curFile->fname;
1932 1.127 dsl
1933 1.127 dsl if (DEBUG(PARSE))
1934 1.127 dsl fprintf(debug_file, "Parse_SetInput: file %s, line %d, fd %d, buf %p\n",
1935 1.127 dsl name, line, fd, buf);
1936 1.127 dsl
1937 1.125 dsl if (fd == -1 && buf == NULL)
1938 1.125 dsl /* sanity */
1939 1.125 dsl return;
1940 1.125 dsl
1941 1.125 dsl /* Save exiting file info */
1942 1.125 dsl Lst_AtFront(includes, curFile);
1943 1.5 cgd
1944 1.125 dsl /* Allocate and fill in new structure */
1945 1.125 dsl curFile = emalloc(sizeof *curFile);
1946 1.125 dsl
1947 1.125 dsl /*
1948 1.125 dsl * Once the previous state has been saved, we can get down to reading
1949 1.125 dsl * the new file. We set up the name of the file to be the absolute
1950 1.125 dsl * name of the include file so error messages refer to the right
1951 1.125 dsl * place.
1952 1.125 dsl */
1953 1.125 dsl curFile->fname = name;
1954 1.125 dsl curFile->lineno = line;
1955 1.125 dsl curFile->fd = fd;
1956 1.27 christos
1957 1.125 dsl ParseSetParseFile(name);
1958 1.125 dsl
1959 1.125 dsl if (buf == NULL) {
1960 1.125 dsl /*
1961 1.125 dsl * Allocate a 32k data buffer (as stdio seems to).
1962 1.125 dsl * Set pointers so that first ParseReadc has to do a file read.
1963 1.125 dsl */
1964 1.127 dsl buf = emalloc(IFILE_BUFLEN);
1965 1.125 dsl buf[0] = 0;
1966 1.125 dsl curFile->P_str = buf;
1967 1.125 dsl curFile->P_ptr = buf;
1968 1.125 dsl curFile->P_end = buf;
1969 1.127 dsl curFile->P_buflen = IFILE_BUFLEN;
1970 1.125 dsl } else {
1971 1.125 dsl /* Start reading from the start of the buffer */
1972 1.125 dsl curFile->P_str = buf;
1973 1.125 dsl curFile->P_ptr = buf;
1974 1.125 dsl curFile->P_end = NULL;
1975 1.125 dsl }
1976 1.5 cgd
1977 1.5 cgd }
1978 1.5 cgd
1979 1.5 cgd #ifdef SYSVINCLUDE
1980 1.5 cgd /*-
1981 1.5 cgd *---------------------------------------------------------------------
1982 1.5 cgd * ParseTraditionalInclude --
1983 1.5 cgd * Push to another file.
1984 1.27 christos *
1985 1.38 christos * The input is the current line. The file name(s) are
1986 1.38 christos * following the "include".
1987 1.5 cgd *
1988 1.5 cgd * Results:
1989 1.5 cgd * None
1990 1.5 cgd *
1991 1.5 cgd * Side Effects:
1992 1.5 cgd * A structure is added to the includes Lst and readProc, lineno,
1993 1.5 cgd * fname and curFILE are altered for the new file
1994 1.5 cgd *---------------------------------------------------------------------
1995 1.5 cgd */
1996 1.5 cgd static void
1997 1.84 wiz ParseTraditionalInclude(char *line)
1998 1.5 cgd {
1999 1.5 cgd char *cp; /* current position in file spec */
2000 1.38 christos int done = 0;
2001 1.38 christos int silent = (line[0] != 'i') ? 1 : 0;
2002 1.38 christos char *file = &line[silent + 7];
2003 1.123 dsl char *all_files;
2004 1.5 cgd
2005 1.111 ginsbach if (DEBUG(PARSE)) {
2006 1.116 dsl fprintf(debug_file, "ParseTraditionalInclude: %s\n", file);
2007 1.111 ginsbach }
2008 1.111 ginsbach
2009 1.5 cgd /*
2010 1.5 cgd * Skip over whitespace
2011 1.5 cgd */
2012 1.38 christos while (isspace((unsigned char)*file))
2013 1.5 cgd file++;
2014 1.5 cgd
2015 1.111 ginsbach /*
2016 1.111 ginsbach * Substitute for any variables in the file name before trying to
2017 1.111 ginsbach * find the thing.
2018 1.111 ginsbach */
2019 1.123 dsl all_files = Var_Subst(NULL, file, VAR_CMD, FALSE);
2020 1.111 ginsbach
2021 1.5 cgd if (*file == '\0') {
2022 1.97 christos Parse_Error(PARSE_FATAL,
2023 1.5 cgd "Filename missing from \"include\"");
2024 1.5 cgd return;
2025 1.5 cgd }
2026 1.5 cgd
2027 1.123 dsl for (file = all_files; !done; file = cp + 1) {
2028 1.123 dsl /* Skip to end of line or next whitespace */
2029 1.38 christos for (cp = file; *cp && !isspace((unsigned char) *cp); cp++)
2030 1.38 christos continue;
2031 1.38 christos
2032 1.38 christos if (*cp)
2033 1.38 christos *cp = '\0';
2034 1.38 christos else
2035 1.38 christos done = 1;
2036 1.38 christos
2037 1.123 dsl Parse_include_file(file, FALSE, silent);
2038 1.5 cgd }
2039 1.123 dsl free(all_files);
2040 1.5 cgd }
2041 1.5 cgd #endif
2042 1.5 cgd
2043 1.1 cgd /*-
2044 1.1 cgd *---------------------------------------------------------------------
2045 1.1 cgd * ParseEOF --
2046 1.1 cgd * Called when EOF is reached in the current file. If we were reading
2047 1.1 cgd * an include file, the includes stack is popped and things set up
2048 1.1 cgd * to go back to reading the previous file at the previous location.
2049 1.1 cgd *
2050 1.1 cgd * Results:
2051 1.1 cgd * CONTINUE if there's more to do. DONE if not.
2052 1.1 cgd *
2053 1.1 cgd * Side Effects:
2054 1.1 cgd * The old curFILE, is closed. The includes list is shortened.
2055 1.1 cgd * lineno, curFILE, and fname are changed if CONTINUE is returned.
2056 1.1 cgd *---------------------------------------------------------------------
2057 1.1 cgd */
2058 1.1 cgd static int
2059 1.123 dsl ParseEOF(void)
2060 1.1 cgd {
2061 1.125 dsl /* Dispose of curFile info */
2062 1.125 dsl /* Leak curFile->fname because all the gnodes have pointers to it */
2063 1.125 dsl if (curFile->fd != -1)
2064 1.125 dsl close(curFile->fd);
2065 1.125 dsl free(curFile->P_str);
2066 1.125 dsl free(curFile);
2067 1.125 dsl
2068 1.125 dsl curFile = Lst_DeQueue(includes);
2069 1.1 cgd
2070 1.125 dsl if (curFile == NULL) {
2071 1.125 dsl /* We've run out of input */
2072 1.44 aidan Var_Delete(".PARSEDIR", VAR_GLOBAL);
2073 1.44 aidan Var_Delete(".PARSEFILE", VAR_GLOBAL);
2074 1.125 dsl return DONE;
2075 1.1 cgd }
2076 1.1 cgd
2077 1.127 dsl if (DEBUG(PARSE))
2078 1.127 dsl fprintf(debug_file, "ParseEOF: returning to file %s, line %d, fd %d\n",
2079 1.127 dsl curFile->fname, curFile->lineno, curFile->fd);
2080 1.127 dsl
2081 1.125 dsl /* Restore the PARSEDIR/PARSEFILE variables */
2082 1.125 dsl ParseSetParseFile(curFile->fname);
2083 1.1 cgd return (CONTINUE);
2084 1.1 cgd }
2085 1.1 cgd
2086 1.127 dsl #define PARSE_RAW 1
2087 1.127 dsl #define PARSE_SKIP 2
2088 1.127 dsl
2089 1.127 dsl static char *
2090 1.127 dsl ParseGetLine(int flags, int *length)
2091 1.5 cgd {
2092 1.125 dsl IFile *cf = curFile;
2093 1.127 dsl char *ptr;
2094 1.125 dsl char ch;
2095 1.127 dsl char *line;
2096 1.127 dsl char *line_end;
2097 1.127 dsl char *escaped;
2098 1.127 dsl char *comment;
2099 1.127 dsl char *tp;
2100 1.127 dsl int len, dist;
2101 1.125 dsl
2102 1.127 dsl /* Loop through blank lines and comment lines */
2103 1.125 dsl for (;;) {
2104 1.127 dsl cf->lineno++;
2105 1.127 dsl line = cf->P_ptr;
2106 1.127 dsl ptr = line;
2107 1.127 dsl line_end = line;
2108 1.127 dsl escaped = NULL;
2109 1.127 dsl comment = NULL;
2110 1.127 dsl for (;;) {
2111 1.127 dsl ch = *ptr;
2112 1.127 dsl if (ch == 0 || (ch == '\\' && ptr[1] == 0)) {
2113 1.127 dsl if (cf->P_end == NULL)
2114 1.127 dsl /* End of string (aka for loop) data */
2115 1.127 dsl break;
2116 1.127 dsl /* End of data read from file, read more data */
2117 1.127 dsl if (ptr != cf->P_end && (ch != '\\' || ptr + 1 != cf->P_end)) {
2118 1.127 dsl Parse_Error(PARSE_FATAL, "Zero byte read from file");
2119 1.127 dsl return NULL;
2120 1.127 dsl }
2121 1.127 dsl /* Move existing data to (near) start of file buffer */
2122 1.127 dsl len = cf->P_end - cf->P_ptr;
2123 1.127 dsl tp = cf->P_str + 32;
2124 1.127 dsl memmove(tp, cf->P_ptr, len);
2125 1.127 dsl dist = cf->P_ptr - tp;
2126 1.127 dsl /* Update all pointers to reflect moved data */
2127 1.127 dsl ptr -= dist;
2128 1.127 dsl line -= dist;
2129 1.127 dsl line_end -= dist;
2130 1.127 dsl if (escaped)
2131 1.127 dsl escaped -= dist;
2132 1.127 dsl if (comment)
2133 1.127 dsl comment -= dist;
2134 1.127 dsl cf->P_ptr = tp;
2135 1.127 dsl tp += len;
2136 1.127 dsl cf->P_end = tp;
2137 1.127 dsl /* Try to read more data from file into buffer space */
2138 1.127 dsl len = cf->P_str + cf->P_buflen - tp - 32;
2139 1.127 dsl if (len <= 0) {
2140 1.127 dsl /* We need a bigger buffer to hold this line */
2141 1.127 dsl tp = erealloc(cf->P_str, cf->P_buflen + IFILE_BUFLEN);
2142 1.127 dsl cf->P_end = cf->P_end - cf->P_str + tp;
2143 1.127 dsl ptr = ptr - cf->P_str + tp;
2144 1.127 dsl line = line - cf->P_str + tp;
2145 1.127 dsl line_end = line_end - cf->P_str + tp;
2146 1.127 dsl if (escaped)
2147 1.127 dsl escaped = escaped - cf->P_str + tp;
2148 1.127 dsl if (comment)
2149 1.127 dsl comment = comment - cf->P_str + tp;
2150 1.127 dsl cf->P_str = tp;
2151 1.127 dsl tp = cf->P_end;
2152 1.127 dsl len += IFILE_BUFLEN;
2153 1.127 dsl }
2154 1.127 dsl len = read(cf->fd, tp, len);
2155 1.127 dsl if (len <= 0) {
2156 1.127 dsl if (len < 0) {
2157 1.127 dsl Parse_Error(PARSE_FATAL, "Makefile read error: %s",
2158 1.127 dsl strerror(errno));
2159 1.127 dsl return NULL;
2160 1.127 dsl }
2161 1.127 dsl /* End of file */
2162 1.127 dsl break;
2163 1.127 dsl }
2164 1.127 dsl /* 0 terminate the data, and update end pointer */
2165 1.127 dsl tp += len;
2166 1.127 dsl cf->P_end = tp;
2167 1.127 dsl *tp = 0;
2168 1.127 dsl /* Process newly read characters */
2169 1.127 dsl continue;
2170 1.127 dsl }
2171 1.127 dsl
2172 1.127 dsl if (ch == '\\') {
2173 1.127 dsl /* Don't treat next character as special, remember first one */
2174 1.127 dsl if (escaped == NULL)
2175 1.127 dsl escaped = ptr;
2176 1.127 dsl if (ptr[1] == '\n')
2177 1.127 dsl cf->lineno++;
2178 1.127 dsl ptr += 2;
2179 1.127 dsl line_end = ptr;
2180 1.127 dsl continue;
2181 1.127 dsl }
2182 1.127 dsl if (ch == '#' && comment == NULL) {
2183 1.127 dsl /* Remember first '#' for comment stripping */
2184 1.127 dsl comment = line_end;
2185 1.127 dsl }
2186 1.127 dsl ptr++;
2187 1.125 dsl if (ch == '\n')
2188 1.127 dsl break;
2189 1.127 dsl if (!isspace((unsigned char)ch))
2190 1.127 dsl /* We are not interested in trailing whitespace */
2191 1.127 dsl line_end = ptr;
2192 1.127 dsl }
2193 1.125 dsl
2194 1.127 dsl /* Save next 'to be processed' location */
2195 1.127 dsl cf->P_ptr = ptr;
2196 1.127 dsl
2197 1.127 dsl /* Check we have a non-comment, non-blank line */
2198 1.127 dsl if (line_end == line || comment == line) {
2199 1.127 dsl if (ch == 0)
2200 1.127 dsl /* At end of file */
2201 1.127 dsl return NULL;
2202 1.127 dsl /* Parse another line */
2203 1.125 dsl continue;
2204 1.127 dsl }
2205 1.125 dsl
2206 1.127 dsl /* We now have a line of data */
2207 1.127 dsl *line_end = 0;
2208 1.27 christos
2209 1.127 dsl if (flags & PARSE_RAW) {
2210 1.127 dsl /* Leave '\' (etc) in line buffer (eg 'for' lines) */
2211 1.127 dsl *length = line_end - line;
2212 1.127 dsl return line;
2213 1.127 dsl }
2214 1.5 cgd
2215 1.127 dsl if (flags & PARSE_SKIP) {
2216 1.127 dsl /* Completely ignore non-directives */
2217 1.127 dsl if (line[0] != '.')
2218 1.127 dsl continue;
2219 1.127 dsl /* We could do more of the .else/.elif/.endif checks here */
2220 1.127 dsl }
2221 1.127 dsl break;
2222 1.127 dsl }
2223 1.5 cgd
2224 1.127 dsl /* Brutally ignore anything after a non-escaped '#' in non-commands */
2225 1.127 dsl if (comment != NULL && line[0] != '\t') {
2226 1.127 dsl line_end = comment;
2227 1.127 dsl *line_end = 0;
2228 1.127 dsl }
2229 1.5 cgd
2230 1.127 dsl /* If we didn't see a '\\' then the in-situ data is fine */
2231 1.127 dsl if (escaped == NULL) {
2232 1.127 dsl *length = line_end - line;
2233 1.127 dsl return line;
2234 1.127 dsl }
2235 1.5 cgd
2236 1.127 dsl /* Remove escapes from '\n' and '#' */
2237 1.127 dsl tp = ptr = escaped;
2238 1.127 dsl escaped = line;
2239 1.127 dsl for (; ; *tp++ = ch) {
2240 1.127 dsl ch = *ptr++;
2241 1.127 dsl if (ch != '\\') {
2242 1.127 dsl if (ch == 0)
2243 1.127 dsl break;
2244 1.127 dsl continue;
2245 1.127 dsl }
2246 1.5 cgd
2247 1.127 dsl ch = *ptr++;
2248 1.127 dsl if (ch == 0) {
2249 1.127 dsl /* Delete '\\' at end of buffer */
2250 1.127 dsl tp--;
2251 1.127 dsl break;
2252 1.127 dsl }
2253 1.27 christos
2254 1.127 dsl if (ch == '#')
2255 1.127 dsl /* Delete '\\' from before '#' */
2256 1.127 dsl continue;
2257 1.27 christos
2258 1.127 dsl if (ch != '\n') {
2259 1.127 dsl /* Leave '\\' in buffer for later */
2260 1.127 dsl *tp++ = '\\';
2261 1.127 dsl /* Make sure we don't delete an escaped ' ' from the line end */
2262 1.127 dsl escaped = tp + 1;
2263 1.127 dsl continue;
2264 1.127 dsl }
2265 1.27 christos
2266 1.127 dsl /* Escaped '\n' replace all whitespace with a single ' ' */
2267 1.127 dsl while (tp > escaped && isspace((unsigned char)tp[-1]))
2268 1.127 dsl /* Back up - stopping at "\ " */
2269 1.127 dsl tp--;
2270 1.127 dsl while (ptr[0] == ' ' || ptr[0] == '\t')
2271 1.127 dsl ptr++;
2272 1.127 dsl ch = ' ';
2273 1.127 dsl }
2274 1.27 christos
2275 1.127 dsl /* Delete any trailing spaces - eg from empty continuations */
2276 1.127 dsl while (tp > escaped && isspace((unsigned char)tp[-1]))
2277 1.127 dsl tp--;
2278 1.27 christos
2279 1.127 dsl *tp = 0;
2280 1.127 dsl *length = tp - line;
2281 1.5 cgd return line;
2282 1.5 cgd }
2283 1.1 cgd
2284 1.1 cgd /*-
2285 1.1 cgd *---------------------------------------------------------------------
2286 1.1 cgd * ParseReadLine --
2287 1.1 cgd * Read an entire line from the input file. Called only by Parse_File.
2288 1.1 cgd * To facilitate escaped newlines and what have you, a character is
2289 1.1 cgd * buffered in 'lastc', which is '\0' when no characters have been
2290 1.1 cgd * read. When we break out of the loop, c holds the terminating
2291 1.1 cgd * character and lastc holds a character that should be added to
2292 1.1 cgd * the line (unless we don't read anything but a terminator).
2293 1.1 cgd *
2294 1.1 cgd * Results:
2295 1.1 cgd * A line w/o its newline
2296 1.1 cgd *
2297 1.1 cgd * Side Effects:
2298 1.1 cgd * Only those associated with reading a character
2299 1.1 cgd *---------------------------------------------------------------------
2300 1.1 cgd */
2301 1.1 cgd static char *
2302 1.84 wiz ParseReadLine(void)
2303 1.1 cgd {
2304 1.9 jtc char *line; /* Result */
2305 1.1 cgd int lineLength; /* Length of result */
2306 1.95 enami int lineno; /* Saved line # */
2307 1.1 cgd
2308 1.5 cgd for (;;) {
2309 1.127 dsl line = ParseGetLine(0, &lineLength);
2310 1.127 dsl if (line == NULL)
2311 1.127 dsl return NULL;
2312 1.1 cgd
2313 1.127 dsl if (line[0] != '.')
2314 1.127 dsl return line;
2315 1.121 dsl
2316 1.121 dsl /*
2317 1.127 dsl * The line might be a conditional. Ask the conditional module
2318 1.127 dsl * about it and act accordingly
2319 1.121 dsl */
2320 1.127 dsl switch (Cond_Eval(line)) {
2321 1.127 dsl case COND_SKIP:
2322 1.127 dsl /* Skip to next conditional that evaluates to COND_PARSE. */
2323 1.127 dsl do {
2324 1.127 dsl line = ParseGetLine(PARSE_SKIP, &lineLength);
2325 1.127 dsl } while (line && Cond_Eval(line) != COND_PARSE);
2326 1.127 dsl if (line == NULL)
2327 1.121 dsl break;
2328 1.127 dsl continue;
2329 1.127 dsl case COND_PARSE:
2330 1.127 dsl continue;
2331 1.127 dsl case COND_INVALID: /* Not a conditional line */
2332 1.127 dsl if (!For_Eval(line))
2333 1.1 cgd break;
2334 1.127 dsl lineno = curFile->lineno;
2335 1.127 dsl /* Skip after the matching end */
2336 1.121 dsl do {
2337 1.127 dsl line = ParseGetLine(PARSE_RAW, &lineLength);
2338 1.121 dsl if (line == NULL) {
2339 1.121 dsl Parse_Error(PARSE_FATAL,
2340 1.121 dsl "Unexpected end of file in for loop.\n");
2341 1.5 cgd break;
2342 1.121 dsl }
2343 1.127 dsl } while (For_Eval(line));
2344 1.127 dsl /* Stash each iteration as a new 'input file' */
2345 1.127 dsl For_Run(lineno);
2346 1.127 dsl /* Read next line from for-loop buffer */
2347 1.127 dsl continue;
2348 1.1 cgd }
2349 1.127 dsl return (line);
2350 1.1 cgd }
2351 1.1 cgd }
2352 1.1 cgd
2353 1.1 cgd /*-
2354 1.1 cgd *-----------------------------------------------------------------------
2355 1.1 cgd * ParseFinishLine --
2356 1.1 cgd * Handle the end of a dependency group.
2357 1.1 cgd *
2358 1.1 cgd * Results:
2359 1.1 cgd * Nothing.
2360 1.1 cgd *
2361 1.1 cgd * Side Effects:
2362 1.1 cgd * inLine set FALSE. 'targets' list destroyed.
2363 1.1 cgd *
2364 1.1 cgd *-----------------------------------------------------------------------
2365 1.1 cgd */
2366 1.1 cgd static void
2367 1.84 wiz ParseFinishLine(void)
2368 1.1 cgd {
2369 1.1 cgd if (inLine) {
2370 1.119 dsl Lst_ForEach(targets, Suff_EndTransform, NULL);
2371 1.97 christos Lst_Destroy(targets, ParseHasCommands);
2372 1.9 jtc targets = NULL;
2373 1.1 cgd inLine = FALSE;
2374 1.1 cgd }
2375 1.1 cgd }
2376 1.27 christos
2377 1.1 cgd
2378 1.1 cgd /*-
2379 1.1 cgd *---------------------------------------------------------------------
2380 1.1 cgd * Parse_File --
2381 1.1 cgd * Parse a file into its component parts, incorporating it into the
2382 1.1 cgd * current dependency graph. This is the main function and controls
2383 1.1 cgd * almost every other function in this module
2384 1.1 cgd *
2385 1.84 wiz * Input:
2386 1.84 wiz * name the name of the file being read
2387 1.125 dsl * fd Open file to makefile to parse
2388 1.84 wiz *
2389 1.1 cgd * Results:
2390 1.1 cgd * None
2391 1.1 cgd *
2392 1.1 cgd * Side Effects:
2393 1.125 dsl * closes fd.
2394 1.1 cgd * Loads. Nodes are added to the list of all targets, nodes and links
2395 1.1 cgd * are added to the dependency graph. etc. etc. etc.
2396 1.1 cgd *---------------------------------------------------------------------
2397 1.1 cgd */
2398 1.1 cgd void
2399 1.125 dsl Parse_File(const char *name, int fd)
2400 1.1 cgd {
2401 1.117 dsl char *cp; /* pointer into the line */
2402 1.117 dsl char *line; /* the line we're working on */
2403 1.1 cgd
2404 1.1 cgd inLine = FALSE;
2405 1.1 cgd fatals = 0;
2406 1.44 aidan
2407 1.125 dsl Parse_SetInput(name, 0, fd, NULL);
2408 1.1 cgd
2409 1.1 cgd do {
2410 1.127 dsl for (; (line = ParseReadLine()) != NULL; ) {
2411 1.120 dsl if (DEBUG(PARSE))
2412 1.127 dsl fprintf(debug_file, "ParseReadLine (%d): '%s'\n",
2413 1.127 dsl curFile->lineno, line);
2414 1.1 cgd if (*line == '.') {
2415 1.1 cgd /*
2416 1.1 cgd * Lines that begin with the special character are either
2417 1.1 cgd * include or undef directives.
2418 1.1 cgd */
2419 1.127 dsl for (cp = line + 1; isspace((unsigned char)*cp); cp++) {
2420 1.1 cgd continue;
2421 1.1 cgd }
2422 1.38 christos if (strncmp(cp, "include", 7) == 0 ||
2423 1.127 dsl ((cp[0] == 's' || cp[0] == '-') &&
2424 1.127 dsl strncmp(&cp[1], "include", 7) == 0)) {
2425 1.97 christos ParseDoInclude(cp);
2426 1.117 dsl continue;
2427 1.117 dsl }
2428 1.117 dsl if (strncmp(cp, "undef", 5) == 0) {
2429 1.1 cgd char *cp2;
2430 1.127 dsl for (cp += 5; isspace((unsigned char) *cp); cp++)
2431 1.1 cgd continue;
2432 1.9 jtc for (cp2 = cp; !isspace((unsigned char) *cp2) &&
2433 1.127 dsl (*cp2 != '\0'); cp2++)
2434 1.1 cgd continue;
2435 1.1 cgd *cp2 = '\0';
2436 1.1 cgd Var_Delete(cp, VAR_GLOBAL);
2437 1.117 dsl continue;
2438 1.1 cgd }
2439 1.1 cgd }
2440 1.27 christos
2441 1.6 jtc if (*line == '\t') {
2442 1.1 cgd /*
2443 1.6 jtc * If a line starts with a tab, it can only hope to be
2444 1.6 jtc * a creation command.
2445 1.1 cgd */
2446 1.127 dsl shellCommand:
2447 1.40 christos for (cp = line + 1; isspace ((unsigned char)*cp); cp++) {
2448 1.1 cgd continue;
2449 1.1 cgd }
2450 1.1 cgd if (*cp) {
2451 1.117 dsl if (!inLine)
2452 1.97 christos Parse_Error(PARSE_FATAL,
2453 1.25 christos "Unassociated shell command \"%s\"",
2454 1.1 cgd cp);
2455 1.117 dsl /*
2456 1.117 dsl * So long as it's not a blank line and we're actually
2457 1.117 dsl * in a dependency spec, add the command to the list of
2458 1.117 dsl * commands of all targets in the dependency spec
2459 1.117 dsl */
2460 1.127 dsl cp = estrdup(cp);
2461 1.117 dsl Lst_ForEach(targets, ParseAddCmd, cp);
2462 1.117 dsl #ifdef CLEANUP
2463 1.127 dsl Lst_AtEnd(targCmds, cp);
2464 1.117 dsl #endif
2465 1.1 cgd }
2466 1.117 dsl continue;
2467 1.117 dsl }
2468 1.117 dsl
2469 1.5 cgd #ifdef SYSVINCLUDE
2470 1.117 dsl if (((strncmp(line, "include", 7) == 0 &&
2471 1.117 dsl isspace((unsigned char) line[7])) ||
2472 1.117 dsl ((line[0] == 's' || line[0] == '-') &&
2473 1.117 dsl strncmp(&line[1], "include", 7) == 0 &&
2474 1.117 dsl isspace((unsigned char) line[8]))) &&
2475 1.117 dsl strchr(line, ':') == NULL) {
2476 1.5 cgd /*
2477 1.5 cgd * It's an S3/S5-style "include".
2478 1.5 cgd */
2479 1.97 christos ParseTraditionalInclude(line);
2480 1.117 dsl continue;
2481 1.117 dsl }
2482 1.5 cgd #endif
2483 1.117 dsl if (Parse_IsVar(line)) {
2484 1.1 cgd ParseFinishLine();
2485 1.97 christos Parse_DoVar(line, VAR_GLOBAL);
2486 1.117 dsl continue;
2487 1.117 dsl }
2488 1.117 dsl
2489 1.127 dsl #ifndef POSIX
2490 1.117 dsl /*
2491 1.117 dsl * To make life easier on novices, if the line is indented we
2492 1.117 dsl * first make sure the line has a dependency operator in it.
2493 1.117 dsl * If it doesn't have an operator and we're in a dependency
2494 1.117 dsl * line's script, we assume it's actually a shell command
2495 1.117 dsl * and add it to the current list of targets.
2496 1.117 dsl */
2497 1.117 dsl cp = line;
2498 1.117 dsl if (isspace((unsigned char) line[0])) {
2499 1.127 dsl while ((*cp != '\0') && isspace((unsigned char) *cp))
2500 1.117 dsl cp++;
2501 1.117 dsl while (*cp && (ParseIsEscaped(line, cp) ||
2502 1.77 christos (*cp != ':') && (*cp != '!'))) {
2503 1.117 dsl cp++;
2504 1.117 dsl }
2505 1.127 dsl if (*cp == '\0') {
2506 1.127 dsl if (inLine) {
2507 1.127 dsl Parse_Error(PARSE_WARNING,
2508 1.127 dsl "Shell command needs a leading tab");
2509 1.127 dsl goto shellCommand;
2510 1.127 dsl }
2511 1.127 dsl }
2512 1.127 dsl }
2513 1.11 mycroft #endif
2514 1.127 dsl ParseFinishLine();
2515 1.27 christos
2516 1.127 dsl /*
2517 1.127 dsl * For some reason - probably to make the parser impossible -
2518 1.127 dsl * a ';' can be used to separate commands from dependencies.
2519 1.127 dsl * No attempt is made to avoid ';' inside substitution patterns.
2520 1.127 dsl */
2521 1.127 dsl for (cp = line; *cp != 0; cp++) {
2522 1.127 dsl if (*cp == '\\' && cp[1] != 0) {
2523 1.127 dsl cp++;
2524 1.127 dsl continue;
2525 1.117 dsl }
2526 1.127 dsl if (*cp == ';')
2527 1.127 dsl break;
2528 1.117 dsl }
2529 1.127 dsl if (*cp != 0)
2530 1.127 dsl /* Terminate the dependency list at the ';' */
2531 1.127 dsl *cp = 0;
2532 1.127 dsl else
2533 1.127 dsl cp = NULL;
2534 1.1 cgd
2535 1.127 dsl /*
2536 1.127 dsl * We now know it's a dependency line so it needs to have all
2537 1.127 dsl * variables expanded before being parsed. Tell the variable
2538 1.127 dsl * module to complain if some variable is undefined...
2539 1.127 dsl */
2540 1.127 dsl line = Var_Subst(NULL, line, VAR_CMD, TRUE);
2541 1.27 christos
2542 1.117 dsl /*
2543 1.117 dsl * Need a non-circular list for the target nodes
2544 1.117 dsl */
2545 1.117 dsl if (targets)
2546 1.117 dsl Lst_Destroy(targets, NOFREE);
2547 1.9 jtc
2548 1.117 dsl targets = Lst_Init(FALSE);
2549 1.117 dsl inLine = TRUE;
2550 1.27 christos
2551 1.117 dsl ParseDoDependency(line);
2552 1.127 dsl free(line);
2553 1.127 dsl
2554 1.127 dsl /* If there were commands after a ';', add them now */
2555 1.127 dsl if (cp != NULL) {
2556 1.127 dsl line = cp + 1;
2557 1.127 dsl goto shellCommand;
2558 1.127 dsl }
2559 1.1 cgd }
2560 1.1 cgd /*
2561 1.27 christos * Reached EOF, but it may be just EOF of an include file...
2562 1.1 cgd */
2563 1.123 dsl } while (ParseEOF() == CONTINUE);
2564 1.1 cgd
2565 1.1 cgd /*
2566 1.1 cgd * Make sure conditionals are clean
2567 1.1 cgd */
2568 1.1 cgd Cond_End();
2569 1.1 cgd
2570 1.1 cgd if (fatals) {
2571 1.63 christos (void)fprintf(stderr,
2572 1.63 christos "%s: Fatal errors encountered -- cannot continue\n",
2573 1.63 christos progname);
2574 1.64 sjg PrintOnError(NULL);
2575 1.103 christos exit(1);
2576 1.1 cgd }
2577 1.1 cgd }
2578 1.1 cgd
2579 1.1 cgd /*-
2580 1.1 cgd *---------------------------------------------------------------------
2581 1.1 cgd * Parse_Init --
2582 1.1 cgd * initialize the parsing module
2583 1.1 cgd *
2584 1.1 cgd * Results:
2585 1.1 cgd * none
2586 1.1 cgd *
2587 1.1 cgd * Side Effects:
2588 1.1 cgd * the parseIncPath list is initialized...
2589 1.1 cgd *---------------------------------------------------------------------
2590 1.1 cgd */
2591 1.5 cgd void
2592 1.84 wiz Parse_Init(void)
2593 1.1 cgd {
2594 1.1 cgd mainNode = NILGNODE;
2595 1.97 christos parseIncPath = Lst_Init(FALSE);
2596 1.97 christos sysIncPath = Lst_Init(FALSE);
2597 1.97 christos defIncPath = Lst_Init(FALSE);
2598 1.97 christos includes = Lst_Init(FALSE);
2599 1.45 mycroft #ifdef CLEANUP
2600 1.97 christos targCmds = Lst_Init(FALSE);
2601 1.45 mycroft #endif
2602 1.1 cgd }
2603 1.9 jtc
2604 1.9 jtc void
2605 1.84 wiz Parse_End(void)
2606 1.9 jtc {
2607 1.45 mycroft #ifdef CLEANUP
2608 1.106 christos Lst_Destroy(targCmds, (FreeProc *)free);
2609 1.9 jtc if (targets)
2610 1.9 jtc Lst_Destroy(targets, NOFREE);
2611 1.74 tv Lst_Destroy(defIncPath, Dir_Destroy);
2612 1.9 jtc Lst_Destroy(sysIncPath, Dir_Destroy);
2613 1.9 jtc Lst_Destroy(parseIncPath, Dir_Destroy);
2614 1.9 jtc Lst_Destroy(includes, NOFREE); /* Should be empty now */
2615 1.45 mycroft #endif
2616 1.9 jtc }
2617 1.27 christos
2618 1.1 cgd
2619 1.1 cgd /*-
2620 1.1 cgd *-----------------------------------------------------------------------
2621 1.1 cgd * Parse_MainName --
2622 1.1 cgd * Return a Lst of the main target to create for main()'s sake. If
2623 1.1 cgd * no such target exists, we Punt with an obnoxious error message.
2624 1.1 cgd *
2625 1.1 cgd * Results:
2626 1.1 cgd * A Lst of the single node to create.
2627 1.1 cgd *
2628 1.1 cgd * Side Effects:
2629 1.1 cgd * None.
2630 1.1 cgd *
2631 1.1 cgd *-----------------------------------------------------------------------
2632 1.1 cgd */
2633 1.1 cgd Lst
2634 1.84 wiz Parse_MainName(void)
2635 1.1 cgd {
2636 1.37 fair Lst mainList; /* result list */
2637 1.1 cgd
2638 1.97 christos mainList = Lst_Init(FALSE);
2639 1.1 cgd
2640 1.1 cgd if (mainNode == NILGNODE) {
2641 1.97 christos Punt("no target to make.");
2642 1.1 cgd /*NOTREACHED*/
2643 1.1 cgd } else if (mainNode->type & OP_DOUBLEDEP) {
2644 1.119 dsl (void)Lst_AtEnd(mainList, mainNode);
2645 1.37 fair Lst_Concat(mainList, mainNode->cohorts, LST_CONCNEW);
2646 1.1 cgd }
2647 1.5 cgd else
2648 1.119 dsl (void)Lst_AtEnd(mainList, mainNode);
2649 1.81 pk Var_Append(".TARGETS", mainNode->name, VAR_GLOBAL);
2650 1.37 fair return (mainList);
2651 1.59 christos }
2652 1.59 christos
2653 1.59 christos /*-
2654 1.59 christos *-----------------------------------------------------------------------
2655 1.59 christos * ParseMark --
2656 1.59 christos * Add the filename and lineno to the GNode so that we remember
2657 1.59 christos * where it was first defined.
2658 1.59 christos *
2659 1.59 christos * Side Effects:
2660 1.59 christos * None.
2661 1.59 christos *
2662 1.59 christos *-----------------------------------------------------------------------
2663 1.59 christos */
2664 1.59 christos static void
2665 1.84 wiz ParseMark(GNode *gn)
2666 1.59 christos {
2667 1.125 dsl gn->fname = curFile->fname;
2668 1.125 dsl gn->lineno = curFile->lineno;
2669 1.1 cgd }
2670