| /************************************************************** |
| * |
| * 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; |
| } |
