source: branches/FREEBSD/src/kmk/cond.c@ 24

Last change on this file since 24 was 24, checked in by bird, 23 years ago

Import of RELENG_4_7_0_RELEASE
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 30.1 KB
Line 
1/*
2 * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
3 * Copyright (c) 1988, 1989 by Adam de Boor
4 * Copyright (c) 1989 by Berkeley Softworks
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to Berkeley by
8 * Adam de Boor.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. All advertising materials mentioning features or use of this software
19 * must display the following acknowledgement:
20 * This product includes software developed by the University of
21 * California, Berkeley and its contributors.
22 * 4. Neither the name of the University nor the names of its contributors
23 * may be used to endorse or promote products derived from this software
24 * without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * SUCH DAMAGE.
37 */
38
39#ifndef lint
40#if 0
41static char sccsid[] = "@(#)cond.c 8.2 (Berkeley) 1/2/94";
42#else
43static const char rcsid[] =
44 "$FreeBSD: src/usr.bin/make/cond.c,v 1.12 1999/09/11 13:08:01 hoek Exp $";
45#endif
46#endif /* not lint */
47
48/*-
49 * cond.c --
50 * Functions to handle conditionals in a makefile.
51 *
52 * Interface:
53 * Cond_Eval Evaluate the conditional in the passed line.
54 *
55 */
56
57#include <ctype.h>
58#include <math.h>
59#include "make.h"
60#include "hash.h"
61#include "dir.h"
62#include "buf.h"
63
64/*
65 * The parsing of conditional expressions is based on this grammar:
66 * E -> F || E
67 * E -> F
68 * F -> T && F
69 * F -> T
70 * T -> defined(variable)
71 * T -> make(target)
72 * T -> exists(file)
73 * T -> empty(varspec)
74 * T -> target(name)
75 * T -> symbol
76 * T -> $(varspec) op value
77 * T -> $(varspec) == "string"
78 * T -> $(varspec) != "string"
79 * T -> ( E )
80 * T -> ! T
81 * op -> == | != | > | < | >= | <=
82 *
83 * 'symbol' is some other symbol to which the default function (condDefProc)
84 * is applied.
85 *
86 * Tokens are scanned from the 'condExpr' string. The scanner (CondToken)
87 * will return And for '&' and '&&', Or for '|' and '||', Not for '!',
88 * LParen for '(', RParen for ')' and will evaluate the other terminal
89 * symbols, using either the default function or the function given in the
90 * terminal, and return the result as either True or False.
91 *
92 * All Non-Terminal functions (CondE, CondF and CondT) return Err on error.
93 */
94typedef enum {
95 And, Or, Not, True, False, LParen, RParen, EndOfFile, None, Err
96} Token;
97
98/*-
99 * Structures to handle elegantly the different forms of #if's. The
100 * last two fields are stored in condInvert and condDefProc, respectively.
101 */
102static void CondPushBack __P((Token));
103static int CondGetArg __P((char **, char **, char *, Boolean));
104static Boolean CondDoDefined __P((int, char *));
105static int CondStrMatch __P((ClientData, ClientData));
106static Boolean CondDoMake __P((int, char *));
107static Boolean CondDoExists __P((int, char *));
108static Boolean CondDoTarget __P((int, char *));
109static char * CondCvtArg __P((char *, double *));
110static Token CondToken __P((Boolean));
111static Token CondT __P((Boolean));
112static Token CondF __P((Boolean));
113static Token CondE __P((Boolean));
114
115static struct If {
116 char *form; /* Form of if */
117 int formlen; /* Length of form */
118 Boolean doNot; /* TRUE if default function should be negated */
119 Boolean (*defProc) __P((int, char *)); /* Default function to apply */
120} ifs[] = {
121 { "ifdef", 5, FALSE, CondDoDefined },
122 { "ifndef", 6, TRUE, CondDoDefined },
123 { "ifmake", 6, FALSE, CondDoMake },
124 { "ifnmake", 7, TRUE, CondDoMake },
125 { "if", 2, FALSE, CondDoDefined },
126 { NULL, 0, FALSE, NULL }
127};
128
129static Boolean condInvert; /* Invert the default function */
130static Boolean (*condDefProc) /* Default function to apply */
131 __P((int, char *));
132static char *condExpr; /* The expression to parse */
133static Token condPushBack=None; /* Single push-back token used in
134 * parsing */
135
136#define MAXIF 30 /* greatest depth of #if'ing */
137
138static Boolean condStack[MAXIF]; /* Stack of conditionals's values */
139static int condTop = MAXIF; /* Top-most conditional */
140static int skipIfLevel=0; /* Depth of skipped conditionals */
141static Boolean skipLine = FALSE; /* Whether the parse module is skipping
142 * lines */
143
144/*-
145 *-----------------------------------------------------------------------
146 * CondPushBack --
147 * Push back the most recent token read. We only need one level of
148 * this, so the thing is just stored in 'condPushback'.
149 *
150 * Results:
151 * None.
152 *
153 * Side Effects:
154 * condPushback is overwritten.
155 *
156 *-----------------------------------------------------------------------
157 */
158static void
159CondPushBack (t)
160 Token t; /* Token to push back into the "stream" */
161{
162 condPushBack = t;
163}
164
165
166/*-
167 *-----------------------------------------------------------------------
168 * CondGetArg --
169 * Find the argument of a built-in function.
170 *
171 * Results:
172 * The length of the argument and the address of the argument.
173 *
174 * Side Effects:
175 * The pointer is set to point to the closing parenthesis of the
176 * function call.
177 *
178 *-----------------------------------------------------------------------
179 */
180static int
181CondGetArg (linePtr, argPtr, func, parens)
182 char **linePtr;
183 char **argPtr;
184 char *func;
185 Boolean parens; /* TRUE if arg should be bounded by parens */
186{
187 register char *cp;
188 int argLen;
189 register Buffer buf;
190
191 cp = *linePtr;
192 if (parens) {
193 while (*cp != '(' && *cp != '\0') {
194 cp++;
195 }
196 if (*cp == '(') {
197 cp++;
198 }
199 }
200
201 if (*cp == '\0') {
202 /*
203 * No arguments whatsoever. Because 'make' and 'defined' aren't really
204 * "reserved words", we don't print a message. I think this is better
205 * than hitting the user with a warning message every time s/he uses
206 * the word 'make' or 'defined' at the beginning of a symbol...
207 */
208 *argPtr = cp;
209 return (0);
210 }
211
212 while (*cp == ' ' || *cp == '\t') {
213 cp++;
214 }
215
216 /*
217 * Create a buffer for the argument and start it out at 16 characters
218 * long. Why 16? Why not?
219 */
220 buf = Buf_Init(16);
221
222 while ((strchr(" \t)&|", *cp) == (char *)NULL) && (*cp != '\0')) {
223 if (*cp == '$') {
224 /*
225 * Parse the variable spec and install it as part of the argument
226 * if it's valid. We tell Var_Parse to complain on an undefined
227 * variable, so we don't do it too. Nor do we return an error,
228 * though perhaps we should...
229 */
230 char *cp2;
231 int len;
232 Boolean doFree;
233
234 cp2 = Var_Parse(cp, VAR_CMD, TRUE, &len, &doFree);
235
236 Buf_AddBytes(buf, strlen(cp2), (Byte *)cp2);
237 if (doFree) {
238 free(cp2);
239 }
240 cp += len;
241 } else {
242 Buf_AddByte(buf, (Byte)*cp);
243 cp++;
244 }
245 }
246
247 Buf_AddByte(buf, (Byte)'\0');
248 *argPtr = (char *)Buf_GetAll(buf, &argLen);
249 Buf_Destroy(buf, FALSE);
250
251 while (*cp == ' ' || *cp == '\t') {
252 cp++;
253 }
254 if (parens && *cp != ')') {
255 Parse_Error (PARSE_WARNING, "Missing closing parenthesis for %s()",
256 func);
257 return (0);
258 } else if (parens) {
259 /*
260 * Advance pointer past close parenthesis.
261 */
262 cp++;
263 }
264
265 *linePtr = cp;
266 return (argLen);
267}
268
269
270/*-
271 *-----------------------------------------------------------------------
272 * CondDoDefined --
273 * Handle the 'defined' function for conditionals.
274 *
275 * Results:
276 * TRUE if the given variable is defined.
277 *
278 * Side Effects:
279 * None.
280 *
281 *-----------------------------------------------------------------------
282 */
283static Boolean
284CondDoDefined (argLen, arg)
285 int argLen;
286 char *arg;
287{
288 char savec = arg[argLen];
289 char *p1;
290 Boolean result;
291
292 arg[argLen] = '\0';
293 if (Var_Value (arg, VAR_CMD, &p1) != (char *)NULL) {
294 result = TRUE;
295 } else {
296 result = FALSE;
297 }
298 efree(p1);
299 arg[argLen] = savec;
300 return (result);
301}
302
303
304/*-
305 *-----------------------------------------------------------------------
306 * CondStrMatch --
307 * Front-end for Str_Match so it returns 0 on match and non-zero
308 * on mismatch. Callback function for CondDoMake via Lst_Find
309 *
310 * Results:
311 * 0 if string matches pattern
312 *
313 * Side Effects:
314 * None
315 *
316 *-----------------------------------------------------------------------
317 */
318static int
319CondStrMatch(string, pattern)
320 ClientData string;
321 ClientData pattern;
322{
323 return(!Str_Match((char *) string,(char *) pattern));
324}
325
326
327/*-
328 *-----------------------------------------------------------------------
329 * CondDoMake --
330 * Handle the 'make' function for conditionals.
331 *
332 * Results:
333 * TRUE if the given target is being made.
334 *
335 * Side Effects:
336 * None.
337 *
338 *-----------------------------------------------------------------------
339 */
340static Boolean
341CondDoMake (argLen, arg)
342 int argLen;
343 char *arg;
344{
345 char savec = arg[argLen];
346 Boolean result;
347
348 arg[argLen] = '\0';
349 if (Lst_Find (create, (ClientData)arg, CondStrMatch) == NILLNODE) {
350 result = FALSE;
351 } else {
352 result = TRUE;
353 }
354 arg[argLen] = savec;
355 return (result);
356}
357
358
359/*-
360 *-----------------------------------------------------------------------
361 * CondDoExists --
362 * See if the given file exists.
363 *
364 * Results:
365 * TRUE if the file exists and FALSE if it does not.
366 *
367 * Side Effects:
368 * None.
369 *
370 *-----------------------------------------------------------------------
371 */
372static Boolean
373CondDoExists (argLen, arg)
374 int argLen;
375 char *arg;
376{
377 char savec = arg[argLen];
378 Boolean result;
379 char *path;
380
381 arg[argLen] = '\0';
382 path = Dir_FindFile(arg, dirSearchPath);
383 if (path != (char *)NULL) {
384 result = TRUE;
385 free(path);
386 } else {
387 result = FALSE;
388 }
389 arg[argLen] = savec;
390 return (result);
391}
392
393
394/*-
395 *-----------------------------------------------------------------------
396 * CondDoTarget --
397 * See if the given node exists and is an actual target.
398 *
399 * Results:
400 * TRUE if the node exists as a target and FALSE if it does not.
401 *
402 * Side Effects:
403 * None.
404 *
405 *-----------------------------------------------------------------------
406 */
407static Boolean
408CondDoTarget (argLen, arg)
409 int argLen;
410 char *arg;
411{
412 char savec = arg[argLen];
413 Boolean result;
414 GNode *gn;
415
416 arg[argLen] = '\0';
417 gn = Targ_FindNode(arg, TARG_NOCREATE);
418 if ((gn != NILGNODE) && !OP_NOP(gn->type)) {
419 result = TRUE;
420 } else {
421 result = FALSE;
422 }
423 arg[argLen] = savec;
424 return (result);
425}
426
427
428
429/*-
430 *-----------------------------------------------------------------------
431 * CondCvtArg --
432 * Convert the given number into a double. If the number begins
433 * with 0x, it is interpreted as a hexadecimal integer
434 * and converted to a double from there. All other strings just have
435 * strtod called on them.
436 *
437 * Results:
438 * Sets 'value' to double value of string.
439 * Returns address of the first character after the last valid
440 * character of the converted number.
441 *
442 * Side Effects:
443 * Can change 'value' even if string is not a valid number.
444 *
445 *
446 *-----------------------------------------------------------------------
447 */
448static char *
449CondCvtArg(str, value)
450 register char *str;
451 double *value;
452{
453 if ((*str == '0') && (str[1] == 'x')) {
454 register long i;
455
456 for (str += 2, i = 0; ; str++) {
457 int x;
458 if (isdigit((unsigned char) *str))
459 x = *str - '0';
460 else if (isxdigit((unsigned char) *str))
461 x = 10 + *str - isupper((unsigned char) *str) ? 'A' : 'a';
462 else {
463 *value = (double) i;
464 return str;
465 }
466 i = (i << 4) + x;
467 }
468 }
469 else {
470 char *eptr;
471 *value = strtod(str, &eptr);
472 return eptr;
473 }
474}
475
476
477/*-
478 *-----------------------------------------------------------------------
479 * CondToken --
480 * Return the next token from the input.
481 *
482 * Results:
483 * A Token for the next lexical token in the stream.
484 *
485 * Side Effects:
486 * condPushback will be set back to None if it is used.
487 *
488 *-----------------------------------------------------------------------
489 */
490static Token
491CondToken(doEval)
492 Boolean doEval;
493{
494 Token t;
495
496 if (condPushBack == None) {
497 while (*condExpr == ' ' || *condExpr == '\t') {
498 condExpr++;
499 }
500 switch (*condExpr) {
501 case '(':
502 t = LParen;
503 condExpr++;
504 break;
505 case ')':
506 t = RParen;
507 condExpr++;
508 break;
509 case '|':
510 if (condExpr[1] == '|') {
511 condExpr++;
512 }
513 condExpr++;
514 t = Or;
515 break;
516 case '&':
517 if (condExpr[1] == '&') {
518 condExpr++;
519 }
520 condExpr++;
521 t = And;
522 break;
523 case '!':
524 t = Not;
525 condExpr++;
526 break;
527 case '\n':
528 case '\0':
529 t = EndOfFile;
530 break;
531 case '$': {
532 char *lhs;
533 char *rhs;
534 char *op;
535 int varSpecLen;
536 Boolean doFree;
537
538 /*
539 * Parse the variable spec and skip over it, saving its
540 * value in lhs.
541 */
542 t = Err;
543 lhs = Var_Parse(condExpr, VAR_CMD, doEval,&varSpecLen,&doFree);
544 if (lhs == var_Error) {
545 /*
546 * Even if !doEval, we still report syntax errors, which
547 * is what getting var_Error back with !doEval means.
548 */
549 return(Err);
550 }
551 condExpr += varSpecLen;
552
553 if (!isspace((unsigned char) *condExpr) &&
554 strchr("!=><", *condExpr) == NULL) {
555 Buffer buf;
556 char *cp;
557
558 buf = Buf_Init(0);
559
560 for (cp = lhs; *cp; cp++)
561 Buf_AddByte(buf, (Byte)*cp);
562
563 if (doFree)
564 free(lhs);
565
566 for (;*condExpr && !isspace((unsigned char) *condExpr);
567 condExpr++)
568 Buf_AddByte(buf, (Byte)*condExpr);
569
570 Buf_AddByte(buf, (Byte)'\0');
571 lhs = (char *)Buf_GetAll(buf, &varSpecLen);
572 Buf_Destroy(buf, FALSE);
573
574 doFree = TRUE;
575 }
576
577 /*
578 * Skip whitespace to get to the operator
579 */
580 while (isspace((unsigned char) *condExpr))
581 condExpr++;
582
583 /*
584 * Make sure the operator is a valid one. If it isn't a
585 * known relational operator, pretend we got a
586 * != 0 comparison.
587 */
588 op = condExpr;
589 switch (*condExpr) {
590 case '!':
591 case '=':
592 case '<':
593 case '>':
594 if (condExpr[1] == '=') {
595 condExpr += 2;
596 } else {
597 condExpr += 1;
598 }
599 break;
600 default:
601 op = "!=";
602 rhs = "0";
603
604 goto do_compare;
605 }
606 while (isspace((unsigned char) *condExpr)) {
607 condExpr++;
608 }
609 if (*condExpr == '\0') {
610 Parse_Error(PARSE_WARNING,
611 "Missing right-hand-side of operator");
612 goto error;
613 }
614 rhs = condExpr;
615do_compare:
616 if (*rhs == '"') {
617 /*
618 * Doing a string comparison. Only allow == and != for
619 * operators.
620 */
621 char *string;
622 char *cp, *cp2;
623 int qt;
624 Buffer buf;
625
626do_string_compare:
627 if (((*op != '!') && (*op != '=')) || (op[1] != '=')) {
628 Parse_Error(PARSE_WARNING,
629 "String comparison operator should be either == or !=");
630 goto error;
631 }
632
633 buf = Buf_Init(0);
634 qt = *rhs == '"' ? 1 : 0;
635
636 for (cp = &rhs[qt];
637 ((qt && (*cp != '"')) ||
638 (!qt && strchr(" \t)", *cp) == NULL)) &&
639 (*cp != '\0'); cp++) {
640 if ((*cp == '\\') && (cp[1] != '\0')) {
641 /*
642 * Backslash escapes things -- skip over next
643 * character, if it exists.
644 */
645 cp++;
646 Buf_AddByte(buf, (Byte)*cp);
647 } else if (*cp == '$') {
648 int len;
649 Boolean freeIt;
650
651 cp2 = Var_Parse(cp, VAR_CMD, doEval,&len, &freeIt);
652 if (cp2 != var_Error) {
653 Buf_AddBytes(buf, strlen(cp2), (Byte *)cp2);
654 if (freeIt) {
655 free(cp2);
656 }
657 cp += len - 1;
658 } else {
659 Buf_AddByte(buf, (Byte)*cp);
660 }
661 } else {
662 Buf_AddByte(buf, (Byte)*cp);
663 }
664 }
665
666 Buf_AddByte(buf, (Byte)0);
667
668 string = (char *)Buf_GetAll(buf, (int *)0);
669 Buf_Destroy(buf, FALSE);
670
671 if (DEBUG(COND)) {
672 printf("lhs = \"%s\", rhs = \"%s\", op = %.2s\n",
673 lhs, string, op);
674 }
675 /*
676 * Null-terminate rhs and perform the comparison.
677 * t is set to the result.
678 */
679 if (*op == '=') {
680 t = strcmp(lhs, string) ? False : True;
681 } else {
682 t = strcmp(lhs, string) ? True : False;
683 }
684 free(string);
685 if (rhs == condExpr) {
686 if (!qt && *cp == ')')
687 condExpr = cp;
688 else
689 condExpr = cp + 1;
690 }
691 } else {
692 /*
693 * rhs is either a float or an integer. Convert both the
694 * lhs and the rhs to a double and compare the two.
695 */
696 double left, right;
697 char *string;
698
699 if (*CondCvtArg(lhs, &left) != '\0')
700 goto do_string_compare;
701 if (*rhs == '$') {
702 int len;
703 Boolean freeIt;
704
705 string = Var_Parse(rhs, VAR_CMD, doEval,&len,&freeIt);
706 if (string == var_Error) {
707 right = 0.0;
708 } else {
709 if (*CondCvtArg(string, &right) != '\0') {
710 if (freeIt)
711 free(string);
712 goto do_string_compare;
713 }
714 if (freeIt)
715 free(string);
716 if (rhs == condExpr)
717 condExpr += len;
718 }
719 } else {
720 char *c = CondCvtArg(rhs, &right);
721 if (*c != '\0' && !isspace(*c))
722 goto do_string_compare;
723 if (rhs == condExpr) {
724 /*
725 * Skip over the right-hand side
726 */
727 while(!isspace((unsigned char) *condExpr) &&
728 (*condExpr != '\0')) {
729 condExpr++;
730 }
731 }
732 }
733
734 if (DEBUG(COND)) {
735 printf("left = %f, right = %f, op = %.2s\n", left,
736 right, op);
737 }
738 switch(op[0]) {
739 case '!':
740 if (op[1] != '=') {
741 Parse_Error(PARSE_WARNING,
742 "Unknown operator");
743 goto error;
744 }
745 t = (left != right ? True : False);
746 break;
747 case '=':
748 if (op[1] != '=') {
749 Parse_Error(PARSE_WARNING,
750 "Unknown operator");
751 goto error;
752 }
753 t = (left == right ? True : False);
754 break;
755 case '<':
756 if (op[1] == '=') {
757 t = (left <= right ? True : False);
758 } else {
759 t = (left < right ? True : False);
760 }
761 break;
762 case '>':
763 if (op[1] == '=') {
764 t = (left >= right ? True : False);
765 } else {
766 t = (left > right ? True : False);
767 }
768 break;
769 }
770 }
771error:
772 if (doFree)
773 free(lhs);
774 break;
775 }
776 default: {
777 Boolean (*evalProc) __P((int, char *));
778 Boolean invert = FALSE;
779 char *arg;
780 int arglen;
781
782 if (strncmp (condExpr, "defined", 7) == 0) {
783 /*
784 * Use CondDoDefined to evaluate the argument and
785 * CondGetArg to extract the argument from the 'function
786 * call'.
787 */
788 evalProc = CondDoDefined;
789 condExpr += 7;
790 arglen = CondGetArg (&condExpr, &arg, "defined", TRUE);
791 if (arglen == 0) {
792 condExpr -= 7;
793 goto use_default;
794 }
795 } else if (strncmp (condExpr, "make", 4) == 0) {
796 /*
797 * Use CondDoMake to evaluate the argument and
798 * CondGetArg to extract the argument from the 'function
799 * call'.
800 */
801 evalProc = CondDoMake;
802 condExpr += 4;
803 arglen = CondGetArg (&condExpr, &arg, "make", TRUE);
804 if (arglen == 0) {
805 condExpr -= 4;
806 goto use_default;
807 }
808 } else if (strncmp (condExpr, "exists", 6) == 0) {
809 /*
810 * Use CondDoExists to evaluate the argument and
811 * CondGetArg to extract the argument from the
812 * 'function call'.
813 */
814 evalProc = CondDoExists;
815 condExpr += 6;
816 arglen = CondGetArg(&condExpr, &arg, "exists", TRUE);
817 if (arglen == 0) {
818 condExpr -= 6;
819 goto use_default;
820 }
821 } else if (strncmp(condExpr, "empty", 5) == 0) {
822 /*
823 * Use Var_Parse to parse the spec in parens and return
824 * True if the resulting string is empty.
825 */
826 int length;
827 Boolean doFree;
828 char *val;
829
830 condExpr += 5;
831
832 for (arglen = 0;
833 condExpr[arglen] != '(' && condExpr[arglen] != '\0';
834 arglen += 1)
835 continue;
836
837 if (condExpr[arglen] != '\0') {
838 val = Var_Parse(&condExpr[arglen - 1], VAR_CMD,
839 doEval, &length, &doFree);
840 if (val == var_Error) {
841 t = Err;
842 } else {
843 /*
844 * A variable is empty when it just contains
845 * spaces... 4/15/92, christos
846 */
847 char *p;
848 for (p = val; *p && isspace((unsigned char)*p); p++)
849 continue;
850 t = (*p == '\0') ? True : False;
851 }
852 if (doFree) {
853 free(val);
854 }
855 /*
856 * Advance condExpr to beyond the closing ). Note that
857 * we subtract one from arglen + length b/c length
858 * is calculated from condExpr[arglen - 1].
859 */
860 condExpr += arglen + length - 1;
861 } else {
862 condExpr -= 5;
863 goto use_default;
864 }
865 break;
866 } else if (strncmp (condExpr, "target", 6) == 0) {
867 /*
868 * Use CondDoTarget to evaluate the argument and
869 * CondGetArg to extract the argument from the
870 * 'function call'.
871 */
872 evalProc = CondDoTarget;
873 condExpr += 6;
874 arglen = CondGetArg(&condExpr, &arg, "target", TRUE);
875 if (arglen == 0) {
876 condExpr -= 6;
877 goto use_default;
878 }
879 } else {
880 /*
881 * The symbol is itself the argument to the default
882 * function. We advance condExpr to the end of the symbol
883 * by hand (the next whitespace, closing paren or
884 * binary operator) and set to invert the evaluation
885 * function if condInvert is TRUE.
886 */
887 use_default:
888 invert = condInvert;
889 evalProc = condDefProc;
890 arglen = CondGetArg(&condExpr, &arg, "", FALSE);
891 }
892
893 /*
894 * Evaluate the argument using the set function. If invert
895 * is TRUE, we invert the sense of the function.
896 */
897 t = (!doEval || (* evalProc) (arglen, arg) ?
898 (invert ? False : True) :
899 (invert ? True : False));
900 free(arg);
901 break;
902 }
903 }
904 } else {
905 t = condPushBack;
906 condPushBack = None;
907 }
908 return (t);
909}
910
911
912/*-
913 *-----------------------------------------------------------------------
914 * CondT --
915 * Parse a single term in the expression. This consists of a terminal
916 * symbol or Not and a terminal symbol (not including the binary
917 * operators):
918 * T -> defined(variable) | make(target) | exists(file) | symbol
919 * T -> ! T | ( E )
920 *
921 * Results:
922 * True, False or Err.
923 *
924 * Side Effects:
925 * Tokens are consumed.
926 *
927 *-----------------------------------------------------------------------
928 */
929static Token
930CondT(doEval)
931 Boolean doEval;
932{
933 Token t;
934
935 t = CondToken(doEval);
936
937 if (t == EndOfFile) {
938 /*
939 * If we reached the end of the expression, the expression
940 * is malformed...
941 */
942 t = Err;
943 } else if (t == LParen) {
944 /*
945 * T -> ( E )
946 */
947 t = CondE(doEval);
948 if (t != Err) {
949 if (CondToken(doEval) != RParen) {
950 t = Err;
951 }
952 }
953 } else if (t == Not) {
954 t = CondT(doEval);
955 if (t == True) {
956 t = False;
957 } else if (t == False) {
958 t = True;
959 }
960 }
961 return (t);
962}
963
964
965/*-
966 *-----------------------------------------------------------------------
967 * CondF --
968 * Parse a conjunctive factor (nice name, wot?)
969 * F -> T && F | T
970 *
971 * Results:
972 * True, False or Err
973 *
974 * Side Effects:
975 * Tokens are consumed.
976 *
977 *-----------------------------------------------------------------------
978 */
979static Token
980CondF(doEval)
981 Boolean doEval;
982{
983 Token l, o;
984
985 l = CondT(doEval);
986 if (l != Err) {
987 o = CondToken(doEval);
988
989 if (o == And) {
990 /*
991 * F -> T && F
992 *
993 * If T is False, the whole thing will be False, but we have to
994 * parse the r.h.s. anyway (to throw it away).
995 * If T is True, the result is the r.h.s., be it an Err or no.
996 */
997 if (l == True) {
998 l = CondF(doEval);
999 } else {
1000 (void) CondF(FALSE);
1001 }
1002 } else {
1003 /*
1004 * F -> T
1005 */
1006 CondPushBack (o);
1007 }
1008 }
1009 return (l);
1010}
1011
1012
1013/*-
1014 *-----------------------------------------------------------------------
1015 * CondE --
1016 * Main expression production.
1017 * E -> F || E | F
1018 *
1019 * Results:
1020 * True, False or Err.
1021 *
1022 * Side Effects:
1023 * Tokens are, of course, consumed.
1024 *
1025 *-----------------------------------------------------------------------
1026 */
1027static Token
1028CondE(doEval)
1029 Boolean doEval;
1030{
1031 Token l, o;
1032
1033 l = CondF(doEval);
1034 if (l != Err) {
1035 o = CondToken(doEval);
1036
1037 if (o == Or) {
1038 /*
1039 * E -> F || E
1040 *
1041 * A similar thing occurs for ||, except that here we make sure
1042 * the l.h.s. is False before we bother to evaluate the r.h.s.
1043 * Once again, if l is False, the result is the r.h.s. and once
1044 * again if l is True, we parse the r.h.s. to throw it away.
1045 */
1046 if (l == False) {
1047 l = CondE(doEval);
1048 } else {
1049 (void) CondE(FALSE);
1050 }
1051 } else {
1052 /*
1053 * E -> F
1054 */
1055 CondPushBack (o);
1056 }
1057 }
1058 return (l);
1059}
1060
1061
1062/*-
1063 *-----------------------------------------------------------------------
1064 * Cond_Eval --
1065 * Evaluate the conditional in the passed line. The line
1066 * looks like this:
1067 * #<cond-type> <expr>
1068 * where <cond-type> is any of if, ifmake, ifnmake, ifdef,
1069 * ifndef, elif, elifmake, elifnmake, elifdef, elifndef
1070 * and <expr> consists of &&, ||, !, make(target), defined(variable)
1071 * and parenthetical groupings thereof.
1072 *
1073 * Results:
1074 * COND_PARSE if should parse lines after the conditional
1075 * COND_SKIP if should skip lines after the conditional
1076 * COND_INVALID if not a valid conditional.
1077 *
1078 * Side Effects:
1079 * None.
1080 *
1081 *-----------------------------------------------------------------------
1082 */
1083int
1084Cond_Eval (line)
1085 char *line; /* Line to parse */
1086{
1087 struct If *ifp;
1088 Boolean isElse;
1089 Boolean value = FALSE;
1090 int level; /* Level at which to report errors. */
1091
1092 level = PARSE_FATAL;
1093
1094 for (line++; *line == ' ' || *line == '\t'; line++) {
1095 continue;
1096 }
1097
1098 /*
1099 * Find what type of if we're dealing with. The result is left
1100 * in ifp and isElse is set TRUE if it's an elif line.
1101 */
1102 if (line[0] == 'e' && line[1] == 'l') {
1103 line += 2;
1104 isElse = TRUE;
1105 } else if (strncmp (line, "endif", 5) == 0) {
1106 /*
1107 * End of a conditional section. If skipIfLevel is non-zero, that
1108 * conditional was skipped, so lines following it should also be
1109 * skipped. Hence, we return COND_SKIP. Otherwise, the conditional
1110 * was read so succeeding lines should be parsed (think about it...)
1111 * so we return COND_PARSE, unless this endif isn't paired with
1112 * a decent if.
1113 */
1114 if (skipIfLevel != 0) {
1115 skipIfLevel -= 1;
1116 return (COND_SKIP);
1117 } else {
1118 if (condTop == MAXIF) {
1119 Parse_Error (level, "if-less endif");
1120 return (COND_INVALID);
1121 } else {
1122 skipLine = FALSE;
1123 condTop += 1;
1124 return (COND_PARSE);
1125 }
1126 }
1127 } else {
1128 isElse = FALSE;
1129 }
1130
1131 /*
1132 * Figure out what sort of conditional it is -- what its default
1133 * function is, etc. -- by looking in the table of valid "ifs"
1134 */
1135 for (ifp = ifs; ifp->form != (char *)0; ifp++) {
1136 if (strncmp (ifp->form, line, ifp->formlen) == 0) {
1137 break;
1138 }
1139 }
1140
1141 if (ifp->form == (char *) 0) {
1142 /*
1143 * Nothing fit. If the first word on the line is actually
1144 * "else", it's a valid conditional whose value is the inverse
1145 * of the previous if we parsed.
1146 */
1147 if (isElse && (line[0] == 's') && (line[1] == 'e')) {
1148 if (condTop == MAXIF) {
1149 Parse_Error (level, "if-less else");
1150 return (COND_INVALID);
1151 } else if (skipIfLevel == 0) {
1152 value = !condStack[condTop];
1153 } else {
1154 return (COND_SKIP);
1155 }
1156 } else {
1157 /*
1158 * Not a valid conditional type. No error...
1159 */
1160 return (COND_INVALID);
1161 }
1162 } else {
1163 if (isElse) {
1164 if (condTop == MAXIF) {
1165 Parse_Error (level, "if-less elif");
1166 return (COND_INVALID);
1167 } else if (skipIfLevel != 0) {
1168 /*
1169 * If skipping this conditional, just ignore the whole thing.
1170 * If we don't, the user might be employing a variable that's
1171 * undefined, for which there's an enclosing ifdef that
1172 * we're skipping...
1173 */
1174 return(COND_SKIP);
1175 }
1176 } else if (skipLine) {
1177 /*
1178 * Don't even try to evaluate a conditional that's not an else if
1179 * we're skipping things...
1180 */
1181 skipIfLevel += 1;
1182 return(COND_SKIP);
1183 }
1184
1185 /*
1186 * Initialize file-global variables for parsing
1187 */
1188 condDefProc = ifp->defProc;
1189 condInvert = ifp->doNot;
1190
1191 line += ifp->formlen;
1192
1193 while (*line == ' ' || *line == '\t') {
1194 line++;
1195 }
1196
1197 condExpr = line;
1198 condPushBack = None;
1199
1200 switch (CondE(TRUE)) {
1201 case True:
1202 if (CondToken(TRUE) == EndOfFile) {
1203 value = TRUE;
1204 break;
1205 }
1206 goto err;
1207 /*FALLTHRU*/
1208 case False:
1209 if (CondToken(TRUE) == EndOfFile) {
1210 value = FALSE;
1211 break;
1212 }
1213 /*FALLTHRU*/
1214 case Err:
1215 err:
1216 Parse_Error (level, "Malformed conditional (%s)",
1217 line);
1218 return (COND_INVALID);
1219 default:
1220 break;
1221 }
1222 }
1223 if (!isElse) {
1224 condTop -= 1;
1225 } else if ((skipIfLevel != 0) || condStack[condTop]) {
1226 /*
1227 * If this is an else-type conditional, it should only take effect
1228 * if its corresponding if was evaluated and FALSE. If its if was
1229 * TRUE or skipped, we return COND_SKIP (and start skipping in case
1230 * we weren't already), leaving the stack unmolested so later elif's
1231 * don't screw up...
1232 */
1233 skipLine = TRUE;
1234 return (COND_SKIP);
1235 }
1236
1237 if (condTop < 0) {
1238 /*
1239 * This is the one case where we can definitely proclaim a fatal
1240 * error. If we don't, we're hosed.
1241 */
1242 Parse_Error (PARSE_FATAL, "Too many nested if's. %d max.", MAXIF);
1243 return (COND_INVALID);
1244 } else {
1245 condStack[condTop] = value;
1246 skipLine = !value;
1247 return (value ? COND_PARSE : COND_SKIP);
1248 }
1249}
1250
1251
1252/*-
1253 *-----------------------------------------------------------------------
1254 * Cond_End --
1255 * Make sure everything's clean at the end of a makefile.
1256 *
1257 * Results:
1258 * None.
1259 *
1260 * Side Effects:
1261 * Parse_Error will be called if open conditionals are around.
1262 *
1263 *-----------------------------------------------------------------------
1264 */
1265void
1266Cond_End()
1267{
1268 if (condTop != MAXIF) {
1269 Parse_Error(PARSE_FATAL, "%d open conditional%s", MAXIF-condTop,
1270 MAXIF-condTop == 1 ? "" : "s");
1271 }
1272 condTop = MAXIF;
1273}
Note: See TracBrowser for help on using the repository browser.