URL https://opencores.org/ocsvn/eco32/eco32/trunk

Subversion Repositories eco32

[/] [eco32/] [trunk/] [lcc/] [cpp/] [eval.c] - Blame information for rev 262

Go to most recent revision | Details | Compare with Previous | View Log


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cpp.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 */
        { 16, 1, UNARY },       /* DEFINED */
        { 16, 0, UNARY },        /* UMINUS */
};
 
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, rand;
 
        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 (rand=0, tp = trp->bp+ntok; tp < trp->lp; tp++) {
                switch(tp->type) {
                case WS:
                case NL:
                        continue;
 
                /* nilary */
                case NAME:
                case NAME1:
                case NUMBER:
                case CCON:
                case STRING:
                        if (rand)
                                goto syntax;
                        if (vp == &vals[NSTAK]) {
                                error(ERROR, "Eval botch (stack overflow)");
                                return 0;
                        }
                        *vp++ = tokval(tp);
                        rand = 1;
                        continue;
 
                /* unary */
                case DEFINED:
                case TILDE:
                case NOT:
                        if (rand)
                                goto syntax;
                        *op++ = tp->type;
                        continue;
 
                /* unary-binary */
                case PLUS: case MINUS: case STAR: case AND:
                        if (rand==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 (rand==0)
                                goto syntax;
                        if (evalop(priority[tp->type])!=0)
                                return 0;
                        *op++ = tp->type;
                        rand = 0;
                        continue;
 
                case LP:
                        if (rand)
                                goto syntax;
                        *op++ = LP;
                        continue;
 
                case RP:
                        if (!rand)
                                goto syntax;
                        if (evalop(priority[RP])!=0)
                                return 0;
                        if (op<=ops || op[-1]!=LP) {
                                goto syntax;
                        }
                        op--;
                        continue;
 
                default:
                        error(ERROR,"Bad operator (%t) in #if/#elsif", tp);
                        return 0;
                }
        }
        if (rand==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, v2;
        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<=rv2; break;
                case GEQ|UNSMARK:
                        rv1 = (unsigned long)rv1>=rv2; break;
                case LT|UNSMARK:
                        rv1 = (unsigned long)rv1<rv2; break;
                case GT|UNSMARK:
                        rv1 = (unsigned long)rv1>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:
                        break;
                default:
                        error(ERROR, "Eval botch (unknown operator)");
                        return 1;
                }
/*lint +e574 +e644 */
                v1.val = rv1;
                v1.type = rtype;
                if (vp == &vals[NSTAK]) {
                        error(ERROR, "Eval botch (stack overflow)");
                        return 0;
                }
                *vp++ = v1;
        }
        return 0;
}
 
struct value
tokval(Token *tp)
{
        struct value v;
        Nlist *np;
        int i, base, c;
        unsigned long n;
        uchar *p;
 
        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 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''\"\"??\\\\";
                                for (i=0; i<sizeof(cvcon); i+=2) {
                                        if (*p == cvcon[i]) {
                                                n = cvcon[i+1];
                                                break;
                                        }
                                }
                                p += 1;
                                if (i>=sizeof(cvcon))
                                        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;
}

Browse

Tools

Subversion Repositories eco32

[/] [eco32/] [trunk/] [lcc/] [cpp/] [eval.c] - Blame information for rev 262

Line No.	Rev	Author	Line
1	4	hellwig	`#include <stdio.h>`
2			`#include <stdlib.h>`
3			`#include <string.h>`
4			`#include "cpp.h"`
5
6			`#define NSTAK 32`
7			`#define SGN 0`
8			`#define UNS 1`
9			`#define UND 2`
10
11			`#define UNSMARK 0x1000`
12
13			`struct value {`
14			`long val;`
15			`int type;`
16			`};`
17
18			`/* conversion types */`
19			`#define RELAT 1`
20			`#define ARITH 2`
21			`#define LOGIC 3`
22			`#define SPCL 4`
23			`#define SHIFT 5`
24			`#define UNARY 6`
25
26			`/* operator priority, arity, and conversion type, indexed by tokentype */`
27			`struct pri {`
28			`char pri;`
29			`char arity;`
30			`char ctype;`
31			`} priority[] = {`
32			`{ 0, 0, 0 }, /* END */`
33			`{ 0, 0, 0 }, /* UNCLASS */`
34			`{ 0, 0, 0 }, /* NAME */`
35			`{ 0, 0, 0 }, /* NUMBER */`
36			`{ 0, 0, 0 }, /* STRING */`
37			`{ 0, 0, 0 }, /* CCON */`
38			`{ 0, 0, 0 }, /* NL */`
39			`{ 0, 0, 0 }, /* WS */`
40			`{ 0, 0, 0 }, /* DSHARP */`
41			`{ 11, 2, RELAT }, /* EQ */`
42			`{ 11, 2, RELAT }, /* NEQ */`
43			`{ 12, 2, RELAT }, /* LEQ */`
44			`{ 12, 2, RELAT }, /* GEQ */`
45			`{ 13, 2, SHIFT }, /* LSH */`
46			`{ 13, 2, SHIFT }, /* RSH */`
47			`{ 7, 2, LOGIC }, /* LAND */`
48			`{ 6, 2, LOGIC }, /* LOR */`
49			`{ 0, 0, 0 }, /* PPLUS */`
50			`{ 0, 0, 0 }, /* MMINUS */`
51			`{ 0, 0, 0 }, /* ARROW */`
52			`{ 0, 0, 0 }, /* SBRA */`
53			`{ 0, 0, 0 }, /* SKET */`
54			`{ 3, 0, 0 }, /* LP */`
55			`{ 3, 0, 0 }, /* RP */`
56			`{ 0, 0, 0 }, /* DOT */`
57			`{ 10, 2, ARITH }, /* AND */`
58			`{ 15, 2, ARITH }, /* STAR */`
59			`{ 14, 2, ARITH }, /* PLUS */`
60			`{ 14, 2, ARITH }, /* MINUS */`
61			`{ 16, 1, UNARY }, /* TILDE */`
62			`{ 16, 1, UNARY }, /* NOT */`
63			`{ 15, 2, ARITH }, /* SLASH */`
64			`{ 15, 2, ARITH }, /* PCT */`
65			`{ 12, 2, RELAT }, /* LT */`
66			`{ 12, 2, RELAT }, /* GT */`
67			`{ 9, 2, ARITH }, /* CIRC */`
68			`{ 8, 2, ARITH }, /* OR */`
69			`{ 5, 2, SPCL }, /* QUEST */`
70			`{ 5, 2, SPCL }, /* COLON */`
71			`{ 0, 0, 0 }, /* ASGN */`
72			`{ 4, 2, 0 }, /* COMMA */`
73			`{ 0, 0, 0 }, /* SHARP */`
74			`{ 0, 0, 0 }, /* SEMIC */`
75			`{ 0, 0, 0 }, /* CBRA */`
76			`{ 0, 0, 0 }, /* CKET */`
77			`{ 0, 0, 0 }, /* ASPLUS */`
78			`{ 0, 0, 0 }, /* ASMINUS */`
79			`{ 0, 0, 0 }, /* ASSTAR */`
80			`{ 0, 0, 0 }, /* ASSLASH */`
81			`{ 0, 0, 0 }, /* ASPCT */`
82			`{ 0, 0, 0 }, /* ASCIRC */`
83			`{ 0, 0, 0 }, /* ASLSH */`
84			`{ 0, 0, 0 }, /* ASRSH */`
85			`{ 0, 0, 0 }, /* ASOR */`
86			`{ 0, 0, 0 }, /* ASAND */`
87			`{ 0, 0, 0 }, /* ELLIPS */`
88			`{ 0, 0, 0 }, /* DSHARP1 */`
89			`{ 0, 0, 0 }, /* NAME1 */`
90			`{ 16, 1, UNARY }, /* DEFINED */`
91			`{ 16, 0, UNARY }, /* UMINUS */`
92			`};`
93
94			`int evalop(struct pri);`
95			`struct value tokval(Token *);`
96			`struct value vals[NSTAK], *vp;`
97			`enum toktype ops[NSTAK], *op;`
98
99			`/*`
100			`* Evaluate an #if #elif #ifdef #ifndef line. trp->tp points to the keyword.`
101			`*/`
102			`long`
103			`eval(Tokenrow *trp, int kw)`
104			`{`
105			`Token *tp;`
106			`Nlist *np;`
107			`int ntok, rand;`
108
109			`trp->tp++;`
110			`if (kw==KIFDEF \|\| kw==KIFNDEF) {`
111			`if (trp->lp - trp->bp != 4 \|\| trp->tp->type!=NAME) {`
112			`error(ERROR, "Syntax error in #ifdef/#ifndef");`
113			`return 0;`
114			`}`
115			`np = lookup(trp->tp, 0);`
116			`return (kw==KIFDEF) == (np && np->flag&(ISDEFINED\|ISMAC));`
117			`}`
118			`ntok = trp->tp - trp->bp;`
119			`kwdefined->val = KDEFINED; /* activate special meaning of defined */`
120			`expandrow(trp, "<if>");`
121			`kwdefined->val = NAME;`
122			`vp = vals;`
123			`op = ops;`
124			`*op++ = END;`
125			`for (rand=0, tp = trp->bp+ntok; tp < trp->lp; tp++) {`
126			`switch(tp->type) {`
127			`case WS:`
128			`case NL:`
129			`continue;`
130
131			`/* nilary */`
132			`case NAME:`
133			`case NAME1:`
134			`case NUMBER:`
135			`case CCON:`
136			`case STRING:`
137			`if (rand)`
138			`goto syntax;`
139			`if (vp == &vals[NSTAK]) {`
140			`error(ERROR, "Eval botch (stack overflow)");`
141			`return 0;`
142			`}`
143			`*vp++ = tokval(tp);`
144			`rand = 1;`
145			`continue;`
146
147			`/* unary */`
148			`case DEFINED:`
149			`case TILDE:`
150			`case NOT:`
151			`if (rand)`
152			`goto syntax;`
153			`*op++ = tp->type;`
154			`continue;`
155
156			`/* unary-binary */`
157			`case PLUS: case MINUS: case STAR: case AND:`
158			`if (rand==0) {`
159			`if (tp->type==MINUS)`
160			`*op++ = UMINUS;`
161			`if (tp->type==STAR \|\| tp->type==AND) {`
162			`error(ERROR, "Illegal operator * or & in #if/#elsif");`
163			`return 0;`
164			`}`
165			`continue;`
166			`}`
167			`/* flow through */`
168
169			`/* plain binary */`
170			`case EQ: case NEQ: case LEQ: case GEQ: case LSH: case RSH:`
171			`case LAND: case LOR: case SLASH: case PCT:`
172			`case LT: case GT: case CIRC: case OR: case QUEST:`
173			`case COLON: case COMMA:`
174			`if (rand==0)`
175			`goto syntax;`
176			`if (evalop(priority[tp->type])!=0)`
177			`return 0;`
178			`*op++ = tp->type;`
179			`rand = 0;`
180			`continue;`
181
182			`case LP:`
183			`if (rand)`
184			`goto syntax;`
185			`*op++ = LP;`
186			`continue;`
187
188			`case RP:`
189			`if (!rand)`
190			`goto syntax;`
191			`if (evalop(priority[RP])!=0)`
192			`return 0;`
193			`if (op<=ops \|\| op[-1]!=LP) {`
194			`goto syntax;`
195			`}`
196			`op--;`
197			`continue;`
198
199			`default:`
200			`error(ERROR,"Bad operator (%t) in #if/#elsif", tp);`
201			`return 0;`
202			`}`
203			`}`
204			`if (rand==0)`
205			`goto syntax;`
206			`if (evalop(priority[END])!=0)`
207			`return 0;`
208			`if (op!=&ops[1] \|\| vp!=&vals[1]) {`
209			`error(ERROR, "Botch in #if/#elsif");`
210			`return 0;`
211			`}`
212			`if (vals[0].type==UND)`
213			`error(ERROR, "Undefined expression value");`
214			`return vals[0].val;`
215			`syntax:`
216			`error(ERROR, "Syntax error in #if/#elsif");`
217			`return 0;`
218			`}`
219
220			`int`
221			`evalop(struct pri pri)`
222			`{`
223			`struct value v1, v2;`
224			`long rv1, rv2;`
225			`int rtype, oper;`
226
227			`rv2=0;`
228			`rtype=0;`
229			`while (pri.pri < priority[op[-1]].pri) {`
230			`oper = *--op;`
231			`if (priority[oper].arity==2) {`
232			`v2 = *--vp;`
233			`rv2 = v2.val;`
234			`}`
235			`v1 = *--vp;`
236			`rv1 = v1.val;`
237			`/lint -e574 -e644 /`
238			`switch (priority[oper].ctype) {`
239			`case 0:`
240			`default:`
241			`error(WARNING, "Syntax error in #if/#endif");`
242			`return 1;`
243			`case ARITH:`
244			`case RELAT:`
245			`if (v1.type==UNS \|\| v2.type==UNS)`
246			`rtype = UNS;`
247			`else`
248			`rtype = SGN;`
249			`if (v1.type==UND \|\| v2.type==UND)`
250			`rtype = UND;`
251			`if (priority[oper].ctype==RELAT && rtype==UNS) {`
252			`oper \|= UNSMARK;`
253			`rtype = SGN;`
254			`}`
255			`break;`
256			`case SHIFT:`
257			`if (v1.type==UND \|\| v2.type==UND)`
258			`rtype = UND;`
259			`else`
260			`rtype = v1.type;`
261			`if (rtype==UNS)`
262			`oper \|= UNSMARK;`
263			`break;`
264			`case UNARY:`
265			`rtype = v1.type;`
266			`break;`
267			`case LOGIC:`
268			`case SPCL:`
269			`break;`
270			`}`
271			`switch (oper) {`
272			`case EQ: case EQ\|UNSMARK:`
273			`rv1 = rv1==rv2; break;`
274			`case NEQ: case NEQ\|UNSMARK:`
275			`rv1 = rv1!=rv2; break;`
276			`case LEQ:`
277			`rv1 = rv1<=rv2; break;`
278			`case GEQ:`
279			`rv1 = rv1>=rv2; break;`
280			`case LT:`
281			`rv1 = rv1<rv2; break;`
282			`case GT:`
283			`rv1 = rv1>rv2; break;`
284			`case LEQ\|UNSMARK:`
285			`rv1 = (unsigned long)rv1<=rv2; break;`
286			`case GEQ\|UNSMARK:`
287			`rv1 = (unsigned long)rv1>=rv2; break;`
288			`case LT\|UNSMARK:`
289			`rv1 = (unsigned long)rv1<rv2; break;`
290			`case GT\|UNSMARK:`
291			`rv1 = (unsigned long)rv1>rv2; break;`
292			`case LSH:`
293			`rv1 <<= rv2; break;`
294			`case LSH\|UNSMARK:`
295			`rv1 = (unsigned long)rv1<<rv2; break;`
296			`case RSH:`
297			`rv1 >>= rv2; break;`
298			`case RSH\|UNSMARK:`
299			`rv1 = (unsigned long)rv1>>rv2; break;`
300			`case LAND:`
301			`rtype = UND;`
302			`if (v1.type==UND)`
303			`break;`
304			`if (rv1!=0) {`
305			`if (v2.type==UND)`
306			`break;`
307			`rv1 = rv2!=0;`
308			`} else`
309			`rv1 = 0;`
310			`rtype = SGN;`
311			`break;`
312			`case LOR:`
313			`rtype = UND;`
314			`if (v1.type==UND)`
315			`break;`
316			`if (rv1==0) {`
317			`if (v2.type==UND)`
318			`break;`
319			`rv1 = rv2!=0;`
320			`} else`
321			`rv1 = 1;`
322			`rtype = SGN;`
323			`break;`
324			`case AND:`
325			`rv1 &= rv2; break;`
326			`case STAR:`
327			`rv1 *= rv2; break;`
328			`case PLUS:`
329			`rv1 += rv2; break;`
330			`case MINUS:`
331			`rv1 -= rv2; break;`
332			`case UMINUS:`
333			`if (v1.type==UND)`
334			`rtype = UND;`
335			`rv1 = -rv1; break;`
336			`case OR:`
337			`rv1 \|= rv2; break;`
338			`case CIRC:`
339			`rv1 ^= rv2; break;`
340			`case TILDE:`
341			`rv1 = ~rv1; break;`
342			`case NOT:`
343			`rv1 = !rv1; if (rtype!=UND) rtype = SGN; break;`
344			`case SLASH:`
345			`if (rv2==0) {`
346			`rtype = UND;`
347			`break;`
348			`}`
349			`if (rtype==UNS)`
350			`rv1 /= (unsigned long)rv2;`
351			`else`
352			`rv1 /= rv2;`
353			`break;`
354			`case PCT:`
355			`if (rv2==0) {`
356			`rtype = UND;`
357			`break;`
358			`}`
359			`if (rtype==UNS)`
360			`rv1 %= (unsigned long)rv2;`
361			`else`
362			`rv1 %= rv2;`
363			`break;`
364			`case COLON:`
365			`if (op[-1] != QUEST)`
366			`error(ERROR, "Bad ?: in #if/endif");`
367			`else {`
368			`op--;`
369			`if ((--vp)->val==0)`
370			`v1 = v2;`
371			`rtype = v1.type;`
372			`rv1 = v1.val;`
373			`}`
374			`break;`
375			`case DEFINED:`
376			`break;`
377			`default:`
378			`error(ERROR, "Eval botch (unknown operator)");`
379			`return 1;`
380			`}`
381			`/lint +e574 +e644 /`
382			`v1.val = rv1;`
383			`v1.type = rtype;`
384			`if (vp == &vals[NSTAK]) {`
385			`error(ERROR, "Eval botch (stack overflow)");`
386			`return 0;`
387			`}`
388			`*vp++ = v1;`
389			`}`
390			`return 0;`
391			`}`
392
393			`struct value`
394			`tokval(Token *tp)`
395			`{`
396			`struct value v;`
397			`Nlist *np;`
398			`int i, base, c;`
399			`unsigned long n;`
400			`uchar *p;`
401
402			`v.type = SGN;`
403			`v.val = 0;`
404			`switch (tp->type) {`
405
406			`case NAME:`
407			`v.val = 0;`
408			`break;`
409
410			`case NAME1:`
411			`if ((np = lookup(tp, 0)) != NULL && np->flag&(ISDEFINED\|ISMAC))`
412			`v.val = 1;`
413			`break;`
414
415			`case NUMBER:`
416			`n = 0;`
417			`base = 10;`
418			`p = tp->t;`
419			`c = p[tp->len];`
420			`p[tp->len] = '\0';`
421			`if (*p=='0') {`
422			`base = 8;`
423			`if (p[1]=='x' \|\| p[1]=='X') {`
424			`base = 16;`
425			`p++;`
426			`}`
427			`p++;`
428			`}`
429			`for (;; p++) {`
430			`if ((i = digit(*p)) < 0)`
431			`break;`
432			`if (i>=base)`
433			`error(WARNING,`
434			`"Bad digit in number %t", tp);`
435			`n *= base;`
436			`n += i;`
437			`}`
438			`if (n>=0x80000000 && base!=10)`
439			`v.type = UNS;`
440			`for (; *p; p++) {`
441			`if (p=='u' \|\| p=='U')`
442			`v.type = UNS;`
443			`else if (p=='l' \|\| p=='L')`
444			`;`
445			`else {`
446			`error(ERROR,`
447			`"Bad number %t in #if/#elsif", tp);`
448			`break;`
449			`}`
450			`}`
451			`v.val = n;`
452			`tp->t[tp->len] = c;`
453			`break;`
454
455			`case CCON:`
456			`n = 0;`
457			`p = tp->t;`
458			`if (*p=='L') {`
459			`p += 1;`
460			`error(WARNING, "Wide char constant value undefined");`
461			`}`
462			`p += 1;`
463			`if (*p=='\\') {`
464			`p += 1;`
465			`if ((i = digit(*p))>=0 && i<=7) {`
466			`n = i;`
467			`p += 1;`
468			`if ((i = digit(*p))>=0 && i<=7) {`
469			`p += 1;`
470			`n <<= 3;`
471			`n += i;`
472			`if ((i = digit(*p))>=0 && i<=7) {`
473			`p += 1;`
474			`n <<= 3;`
475			`n += i;`
476			`}`
477			`}`
478			`} else if (*p=='x') {`
479			`p += 1;`
480			`while ((i = digit(*p))>=0 && i<=15) {`
481			`p += 1;`
482			`n <<= 4;`
483			`n += i;`
484			`}`
485			`} else {`
486			`static char cvcon[]`
487			`= "b\bf\fn\nr\rt\tv\v''\"\"??\\\\";`
488			`for (i=0; i<sizeof(cvcon); i+=2) {`
489			`if (*p == cvcon[i]) {`
490			`n = cvcon[i+1];`
491			`break;`
492			`}`
493			`}`
494			`p += 1;`
495			`if (i>=sizeof(cvcon))`
496			`error(WARNING,`
497			`"Undefined escape in character constant");`
498			`}`
499			`} else if (*p=='\'')`
500			`error(ERROR, "Empty character constant");`
501			`else`
502			`n = *p++;`
503			`if (*p!='\'')`
504			`error(WARNING, "Multibyte character constant undefined");`
505			`else if (n>127)`
506			`error(WARNING, "Character constant taken as not signed");`
507			`v.val = n;`
508			`break;`
509
510			`case STRING:`
511			`error(ERROR, "String in #if/#elsif");`
512			`break;`
513			`}`
514			`return v;`
515			`}`
516
517			`int`
518			`digit(int i)`
519			`{`
520			`if ('0'<=i && i<='9')`
521			`i -= '0';`
522			`else if ('a'<=i && i<='f')`
523			`i -= 'a'-10;`
524			`else if ('A'<=i && i<='F')`
525			`i -= 'A'-10;`
526			`else`
527			`i = -1;`
528			`return i;`
529			`}`