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