| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| #include "cpp.h" | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #define NSTAK 32 | |
| #define SGN 0 | |
| #define UNS 1 | |
| #define UND 2 | |
| #define UNSMARK 0x1000 | |
| struct value | |
| { | |
| long val; | |
| int type; | |
| }; | |
| /* conversion types */ | |
| #define RELAT 1 | |
| #define ARITH 2 | |
| #define LOGIC 3 | |
| #define SPCL 4 | |
| #define SHIFT 5 | |
| #define UNARY 6 | |
| /* operator priority, arity, and conversion type, indexed by tokentype */ | |
| struct pri | |
| { | |
| char pri; | |
| char arity; | |
| char ctype; | |
| } priority[] = | |
| { | |
| { | |
| 0, 0, 0 | |
| }, /* END */ | |
| { | |
| 0, 0, 0 | |
| }, /* UNCLASS */ | |
| { | |
| 0, 0, 0 | |
| }, /* NAME */ | |
| { | |
| 0, 0, 0 | |
| }, /* NUMBER */ | |
| { | |
| 0, 0, 0 | |
| }, /* STRING */ | |
| { | |
| 0, 0, 0 | |
| }, /* CCON */ | |
| { | |
| 0, 0, 0 | |
| }, /* NL */ | |
| { | |
| 0, 0, 0 | |
| }, /* WS */ | |
| { | |
| 0, 0, 0 | |
| }, /* DSHARP */ | |
| { | |
| 11, 2, RELAT | |
| }, /* EQ */ | |
| { | |
| 11, 2, RELAT | |
| }, /* NEQ */ | |
| { | |
| 12, 2, RELAT | |
| }, /* LEQ */ | |
| { | |
| 12, 2, RELAT | |
| }, /* GEQ */ | |
| { | |
| 13, 2, SHIFT | |
| }, /* LSH */ | |
| { | |
| 13, 2, SHIFT | |
| }, /* RSH */ | |
| { | |
| 7, 2, LOGIC | |
| }, /* LAND */ | |
| { | |
| 6, 2, LOGIC | |
| }, /* LOR */ | |
| { | |
| 0, 0, 0 | |
| }, /* PPLUS */ | |
| { | |
| 0, 0, 0 | |
| }, /* MMINUS */ | |
| { | |
| 0, 0, 0 | |
| }, /* ARROW */ | |
| { | |
| 0, 0, 0 | |
| }, /* SBRA */ | |
| { | |
| 0, 0, 0 | |
| }, /* SKET */ | |
| { | |
| 3, 0, 0 | |
| }, /* LP */ | |
| { | |
| 3, 0, 0 | |
| }, /* RP */ | |
| { | |
| 0, 0, 0 | |
| }, /* DOT */ | |
| { | |
| 10, 2, ARITH | |
| }, /* AND */ | |
| { | |
| 15, 2, ARITH | |
| }, /* STAR */ | |
| { | |
| 14, 2, ARITH | |
| }, /* PLUS */ | |
| { | |
| 14, 2, ARITH | |
| }, /* MINUS */ | |
| { | |
| 16, 1, UNARY | |
| }, /* TILDE */ | |
| { | |
| 16, 1, UNARY | |
| }, /* NOT */ | |
| { | |
| 15, 2, ARITH | |
| }, /* SLASH */ | |
| { | |
| 15, 2, ARITH | |
| }, /* PCT */ | |
| { | |
| 12, 2, RELAT | |
| }, /* LT */ | |
| { | |
| 12, 2, RELAT | |
| }, /* GT */ | |
| { | |
| 9, 2, ARITH | |
| }, /* CIRC */ | |
| { | |
| 8, 2, ARITH | |
| }, /* OR */ | |
| { | |
| 5, 2, SPCL | |
| }, /* QUEST */ | |
| { | |
| 5, 2, SPCL | |
| }, /* COLON */ | |
| { | |
| 0, 0, 0 | |
| }, /* ASGN */ | |
| { | |
| 4, 2, 0 | |
| }, /* COMMA */ | |
| { | |
| 0, 0, 0 | |
| }, /* SHARP */ | |
| { | |
| 0, 0, 0 | |
| }, /* SEMIC */ | |
| { | |
| 0, 0, 0 | |
| }, /* CBRA */ | |
| { | |
| 0, 0, 0 | |
| }, /* CKET */ | |
| { | |
| 0, 0, 0 | |
| }, /* ASPLUS */ | |
| { | |
| 0, 0, 0 | |
| }, /* ASMINUS */ | |
| { | |
| 0, 0, 0 | |
| }, /* ASSTAR */ | |
| { | |
| 0, 0, 0 | |
| }, /* ASSLASH */ | |
| { | |
| 0, 0, 0 | |
| }, /* ASPCT */ | |
| { | |
| 0, 0, 0 | |
| }, /* ASCIRC */ | |
| { | |
| 0, 0, 0 | |
| }, /* ASLSH */ | |
| { | |
| 0, 0, 0 | |
| }, /* ASRSH */ | |
| { | |
| 0, 0, 0 | |
| }, /* ASOR */ | |
| { | |
| 0, 0, 0 | |
| }, /* ASAND */ | |
| { | |
| 0, 0, 0 | |
| }, /* ELLIPS */ | |
| { | |
| 0, 0, 0 | |
| }, /* DSHARP1 */ | |
| { | |
| 0, 0, 0 | |
| }, /* NAME1 */ | |
| { | |
| 0, 0, 0 | |
| }, /* NAME2 */ | |
| { | |
| 16, 1, UNARY | |
| }, /* DEFINED */ | |
| { | |
| 16, 0, UNARY | |
| }, /* UMINUS */ | |
| { | |
| 16, 1, UNARY | |
| }, /* ARCHITECTURE */ | |
| }; | |
| int evalop(struct pri); | |
| struct value tokval(Token *); | |
| struct value vals[NSTAK], *vp; | |
| enum toktype ops[NSTAK], *op; | |
| /* | |
| * Evaluate an #if #elif #ifdef #ifndef line. trp->tp points to the keyword. | |
| */ | |
| long | |
| eval(Tokenrow * trp, int kw) | |
| { | |
| Token *tp; | |
| Nlist *np; | |
| int ntok, rnd; | |
| trp->tp++; | |
| if (kw == KIFDEF || kw == KIFNDEF) | |
| { | |
| if (trp->lp - trp->bp != 4 || trp->tp->type != NAME) | |
| { | |
| error(ERROR, "Syntax error in #ifdef/#ifndef"); | |
| return 0; | |
| } | |
| np = lookup(trp->tp, 0); | |
| return (kw == KIFDEF) == (np && np->flag & (ISDEFINED | ISMAC)); | |
| } | |
| ntok = trp->tp - trp->bp; | |
| kwdefined->val = KDEFINED; /* activate special meaning of | |
| * defined */ | |
| expandrow(trp, "<if>"); | |
| kwdefined->val = NAME; | |
| vp = vals; | |
| op = ops; | |
| *op++ = END; | |
| for (rnd = 0, tp = trp->bp + ntok; tp < trp->lp; tp++) | |
| { | |
| switch (tp->type) | |
| { | |
| case WS: | |
| case NL: | |
| continue; | |
| /* nilary */ | |
| case NAME: | |
| case NAME1: | |
| case NAME2: | |
| case NUMBER: | |
| case CCON: | |
| case STRING: | |
| if (rnd) | |
| goto syntax; | |
| *vp++ = tokval(tp); | |
| rnd = 1; | |
| continue; | |
| /* unary */ | |
| case DEFINED: | |
| case TILDE: | |
| case NOT: | |
| if (rnd) | |
| goto syntax; | |
| *op++ = tp->type; | |
| continue; | |
| /* unary-binary */ | |
| case PLUS: | |
| case MINUS: | |
| case STAR: | |
| case AND: | |
| if (rnd == 0) | |
| { | |
| if (tp->type == MINUS) | |
| *op++ = UMINUS; | |
| if (tp->type == STAR || tp->type == AND) | |
| { | |
| error(ERROR, "Illegal operator * or & in #if/#elsif"); | |
| return 0; | |
| } | |
| continue; | |
| } | |
| /* flow through */ | |
| /* plain binary */ | |
| case EQ: | |
| case NEQ: | |
| case LEQ: | |
| case GEQ: | |
| case LSH: | |
| case RSH: | |
| case LAND: | |
| case LOR: | |
| case SLASH: | |
| case PCT: | |
| case LT: | |
| case GT: | |
| case CIRC: | |
| case OR: | |
| case QUEST: | |
| case COLON: | |
| case COMMA: | |
| if (rnd == 0) | |
| goto syntax; | |
| if (evalop(priority[tp->type]) != 0) | |
| return 0; | |
| *op++ = tp->type; | |
| rnd = 0; | |
| continue; | |
| case LP: | |
| if (rnd) | |
| goto syntax; | |
| *op++ = LP; | |
| continue; | |
| case RP: | |
| if (!rnd) | |
| goto syntax; | |
| if (evalop(priority[RP]) != 0) | |
| return 0; | |
| if (op <= ops || op[-1] != LP) | |
| { | |
| goto syntax; | |
| } | |
| op--; | |
| continue; | |
| case SHARP: | |
| if ((tp + 1) < trp->lp) | |
| { | |
| np = lookup(tp + 1, 0); | |
| if (np && (np->val == KMACHINE)) | |
| { | |
| tp++; | |
| if (rnd) | |
| goto syntax; | |
| *op++ = ARCHITECTURE; | |
| continue; | |
| } | |
| } | |
| /* fall through */ | |
| default: | |
| error(ERROR, "Bad operator (%t) in #if/#elsif", tp); | |
| return 0; | |
| } | |
| } | |
| if (rnd == 0) | |
| goto syntax; | |
| if (evalop(priority[END]) != 0) | |
| return 0; | |
| if (op != &ops[1] || vp != &vals[1]) | |
| { | |
| error(ERROR, "Botch in #if/#elsif"); | |
| return 0; | |
| } | |
| if (vals[0].type == UND) | |
| error(ERROR, "Undefined expression value"); | |
| return vals[0].val; | |
| syntax: | |
| error(ERROR, "Syntax error in #if/#elsif"); | |
| return 0; | |
| } | |
| int | |
| evalop(struct pri pri) | |
| { | |
| struct value v1; | |
| struct value v2 = { 0, UND }; | |
| long rv1, rv2; | |
| int rtype, oper; | |
| rv2 = 0; | |
| rtype = 0; | |
| while (pri.pri < priority[op[-1]].pri) | |
| { | |
| oper = *--op; | |
| if (priority[oper].arity == 2) | |
| { | |
| v2 = *--vp; | |
| rv2 = v2.val; | |
| } | |
| v1 = *--vp; | |
| rv1 = v1.val; | |
| /*lint -e574 -e644 */ | |
| switch (priority[oper].ctype) | |
| { | |
| case 0: | |
| default: | |
| error(WARNING, "Syntax error in #if/#endif"); | |
| return 1; | |
| case ARITH: | |
| case RELAT: | |
| if (v1.type == UNS || v2.type == UNS) | |
| rtype = UNS; | |
| else | |
| rtype = SGN; | |
| if (v1.type == UND || v2.type == UND) | |
| rtype = UND; | |
| if (priority[oper].ctype == RELAT && rtype == UNS) | |
| { | |
| oper |= UNSMARK; | |
| rtype = SGN; | |
| } | |
| break; | |
| case SHIFT: | |
| if (v1.type == UND || v2.type == UND) | |
| rtype = UND; | |
| else | |
| rtype = v1.type; | |
| if (rtype == UNS) | |
| oper |= UNSMARK; | |
| break; | |
| case UNARY: | |
| rtype = v1.type; | |
| break; | |
| case LOGIC: | |
| case SPCL: | |
| break; | |
| } | |
| switch (oper) | |
| { | |
| case EQ: | |
| case EQ | UNSMARK: | |
| rv1 = rv1 == rv2; | |
| break; | |
| case NEQ: | |
| case NEQ | UNSMARK: | |
| rv1 = rv1 != rv2; | |
| break; | |
| case LEQ: | |
| rv1 = rv1 <= rv2; | |
| break; | |
| case GEQ: | |
| rv1 = rv1 >= rv2; | |
| break; | |
| case LT: | |
| rv1 = rv1 < rv2; | |
| break; | |
| case GT: | |
| rv1 = rv1 > rv2; | |
| break; | |
| case LEQ | UNSMARK: | |
| rv1 = (unsigned long)rv1 <= (unsigned long)rv2; | |
| break; | |
| case GEQ | UNSMARK: | |
| rv1 = (unsigned long)rv1 >= (unsigned long)rv2; | |
| break; | |
| case LT | UNSMARK: | |
| rv1 = (unsigned long)rv1 < (unsigned long)rv2; | |
| break; | |
| case GT | UNSMARK: | |
| rv1 = (unsigned long)rv1 > (unsigned long)rv2; | |
| break; | |
| case LSH: | |
| rv1 <<= rv2; | |
| break; | |
| case LSH | UNSMARK: | |
| rv1 = (unsigned long) rv1 << rv2; | |
| break; | |
| case RSH: | |
| rv1 >>= rv2; | |
| break; | |
| case RSH | UNSMARK: | |
| rv1 = (unsigned long) rv1 >> rv2; | |
| break; | |
| case LAND: | |
| rtype = UND; | |
| if (v1.type == UND) | |
| break; | |
| if (rv1 != 0) | |
| { | |
| if (v2.type == UND) | |
| break; | |
| rv1 = rv2 != 0; | |
| } | |
| else | |
| rv1 = 0; | |
| rtype = SGN; | |
| break; | |
| case LOR: | |
| rtype = UND; | |
| if (v1.type == UND) | |
| break; | |
| if (rv1 == 0) | |
| { | |
| if (v2.type == UND) | |
| break; | |
| rv1 = rv2 != 0; | |
| } | |
| else | |
| rv1 = 1; | |
| rtype = SGN; | |
| break; | |
| case AND: | |
| rv1 &= rv2; | |
| break; | |
| case STAR: | |
| rv1 *= rv2; | |
| break; | |
| case PLUS: | |
| rv1 += rv2; | |
| break; | |
| case MINUS: | |
| rv1 -= rv2; | |
| break; | |
| case UMINUS: | |
| if (v1.type == UND) | |
| rtype = UND; | |
| rv1 = -rv1; | |
| break; | |
| case OR: | |
| rv1 |= rv2; | |
| break; | |
| case CIRC: | |
| rv1 ^= rv2; | |
| break; | |
| case TILDE: | |
| rv1 = ~rv1; | |
| break; | |
| case NOT: | |
| rv1 = !rv1; | |
| if (rtype != UND) | |
| rtype = SGN; | |
| break; | |
| case SLASH: | |
| if (rv2 == 0) | |
| { | |
| rtype = UND; | |
| break; | |
| } | |
| if (rtype == UNS) | |
| rv1 /= (unsigned long) rv2; | |
| else | |
| rv1 /= rv2; | |
| break; | |
| case PCT: | |
| if (rv2 == 0) | |
| { | |
| rtype = UND; | |
| break; | |
| } | |
| if (rtype == UNS) | |
| rv1 %= (unsigned long) rv2; | |
| else | |
| rv1 %= rv2; | |
| break; | |
| case COLON: | |
| if (op[-1] != QUEST) | |
| error(ERROR, "Bad ?: in #if/endif"); | |
| else | |
| { | |
| op--; | |
| if ((--vp)->val == 0) | |
| v1 = v2; | |
| rtype = v1.type; | |
| rv1 = v1.val; | |
| } | |
| break; | |
| case DEFINED: | |
| case ARCHITECTURE: | |
| break; | |
| default: | |
| error(ERROR, "Eval botch (unknown operator)"); | |
| return 1; | |
| } | |
| /*lint +e574 +e644 */ | |
| v1.val = rv1; | |
| v1.type = rtype; | |
| *vp++ = v1; | |
| } | |
| return 0; | |
| } | |
| struct value | |
| tokval(Token * tp) | |
| { | |
| struct value v; | |
| Nlist *np; | |
| int i, base; | |
| unsigned long n; | |
| uchar *p, c; | |
| v.type = SGN; | |
| v.val = 0; | |
| switch (tp->type) | |
| { | |
| case NAME: | |
| v.val = 0; | |
| break; | |
| case NAME1: | |
| if ((np = lookup(tp, 0)) != NULL && np->flag & (ISDEFINED | ISMAC)) | |
| v.val = 1; | |
| break; | |
| case NAME2: | |
| if ((np = lookup(tp, 0)) != NULL && np->flag & (ISARCHITECTURE)) | |
| v.val = 1; | |
| break; | |
| case NUMBER: | |
| n = 0; | |
| base = 10; | |
| p = tp->t; | |
| c = p[tp->len]; | |
| p[tp->len] = '\0'; | |
| if (*p == '0') | |
| { | |
| base = 8; | |
| if (p[1] == 'x' || p[1] == 'X') | |
| { | |
| base = 16; | |
| p++; | |
| } | |
| p++; | |
| } | |
| for (;; p++) | |
| { | |
| if ((i = digit(*p)) < 0) | |
| break; | |
| if (i >= base) | |
| error(WARNING, | |
| "Bad digit in number %t", tp); | |
| n *= base; | |
| n += i; | |
| } | |
| if (n >= 0x80000000 && base != 10) | |
| v.type = UNS; | |
| for (; *p; p++) | |
| { | |
| if (*p == 'u' || *p == 'U') | |
| v.type = UNS; | |
| else | |
| if (*p == 'l' || *p == 'L') | |
| ; | |
| else | |
| { | |
| error(ERROR, | |
| "Bad number %t in #if/#elsif", tp); | |
| break; | |
| } | |
| } | |
| v.val = n; | |
| tp->t[tp->len] = c; | |
| break; | |
| case CCON: | |
| n = 0; | |
| p = tp->t; | |
| if (*p == 'L') | |
| { | |
| p += 1; | |
| error(WARNING, "Wide char constant value undefined"); | |
| } | |
| p += 1; | |
| if (*p == '\\') | |
| { | |
| p += 1; | |
| if ((i = digit(*p)) >= 0 && i <= 7) | |
| { | |
| n = i; | |
| p += 1; | |
| if ((i = digit(*p)) >= 0 && i <= 7) | |
| { | |
| p += 1; | |
| n <<= 3; | |
| n += i; | |
| if ((i = digit(*p)) >= 0 && i <= 7) | |
| { | |
| p += 1; | |
| n <<= 3; | |
| n += i; | |
| } | |
| } | |
| } | |
| else | |
| if (*p == 'x') | |
| { | |
| p += 1; | |
| while ((i = digit(*p)) >= 0 && i <= 15) | |
| { | |
| p += 1; | |
| n <<= 4; | |
| n += i; | |
| } | |
| } | |
| else | |
| { | |
| static char cvcon[] = "b\bf\fn\nr\rt\tv\v''\"\"??\\\\"; | |
| static size_t cvlen = sizeof(cvcon) - 1; | |
| size_t j; | |
| for (j = 0; j < cvlen; j += 2) | |
| { | |
| if (*p == cvcon[j]) | |
| { | |
| n = cvcon[j + 1]; | |
| break; | |
| } | |
| } | |
| p += 1; | |
| if (j >= cvlen) | |
| error(WARNING, | |
| "Undefined escape in character constant"); | |
| } | |
| } | |
| else | |
| if (*p == '\'') | |
| error(ERROR, "Empty character constant"); | |
| else | |
| n = *p++; | |
| if (*p != '\'') | |
| error(WARNING, "Multibyte character constant undefined"); | |
| else | |
| if (n > 127) | |
| error(WARNING, "Character constant taken as not signed"); | |
| v.val = n; | |
| break; | |
| case STRING: | |
| error(ERROR, "String in #if/#elsif"); | |
| break; | |
| } | |
| return v; | |
| } | |
| int | |
| digit(int i) | |
| { | |
| if ('0' <= i && i <= '9') | |
| i -= '0'; | |
| else | |
| if ('a' <= i && i <= 'f') | |
| i -= 'a' - 10; | |
| else | |
| if ('A' <= i && i <= 'F') | |
| i -= 'A' - 10; | |
| else | |
| i = -1; | |
| return i; | |
| } |