1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 #include <stdio.h>
25 #include <ctype.h>
26 #include "cppdef.h"
27 #include "cpp.h"
28
29 /*
30 * Evaluate an #if expression.
31 */
32
33 static char *opname[] = { /* For debug and error messages */
34 "end of expression", "val", "id",
35 "+", "-", "*", "/", "%",
36 "<<", ">>", "&", "|", "^",
37 "==", "!=", "<", "<=", ">=", ">",
38 "&&", "||", "?", ":", ",",
39 "unary +", "unary -", "~", "!", "(", ")", "(none)",
40 };
41
42 /*
43 * opdope[] has the operator precedence:
44 * Bits
45 * 7 Unused (so the value is always positive)
46 * 6-2 Precedence (000x .. 017x)
47 * 1-0 Binary op. flags:
48 * 01 The binop flag should be set/cleared when this op is seen.
49 * 10 The new value of the binop flag.
50 * Note: Expected, New binop
51 * constant 0 1 Binop, end, or ) should follow constants
52 * End of line 1 0 End may not be preceded by an operator
53 * binary 1 0 Binary op follows a value, value follows.
54 * unary 0 0 Unary op doesn't follow a value, value follows
55 * ( 0 0 Doesn't follow value, value or unop follows
56 * ) 1 1 Follows value. Op follows.
57 */
58
59 static char opdope[OP_MAX] = {
60 0001, /* End of expression */
61 0002, /* Digit */
62 0000, /* Letter (identifier) */
63 0141, 0141, 0151, 0151, 0151, /* ADD, SUB, MUL, DIV, MOD */
64 0131, 0131, 0101, 0071, 0071, /* ASL, ASR, AND, OR, XOR */
65 0111, 0111, 0121, 0121, 0121, 0121, /* EQ, NE, LT, LE, GE, GT */
66 0061, 0051, 0041, 0041, 0031, /* ANA, ORO, QUE, COL, CMA */
67 /*
68 * Unary op's follow
69 */
70 0160, 0160, 0160, 0160, /* NEG, PLU, COM, NOT */
71 0170, 0013, 0023, /* LPA, RPA, END */
72 };
73 /*
74 * OP_QUE and OP_RPA have alternate precedences:
75 */
76 #define OP_RPA_PREC 0013
77 #define OP_QUE_PREC 0034
78
79 /*
80 * S_ANDOR and S_QUEST signal "short-circuit" boolean evaluation, so that
81 * #if FOO != 0 && 10 / FOO ...
82 * doesn't generate an error message. They are stored in optab.skip.
83 */
84 #define S_ANDOR 2
85 #define S_QUEST 1
86
87 typedef struct optab {
88 char op; /* Operator */
89 char prec; /* Its precedence */
90 char skip; /* Short-circuit: TRUE to skip */
91 } OPTAB;
92 static int evalue; /* Current value from evallex() */
93
94 #ifdef nomacargs
95 FILE_LOCAL int
isbinary(op)96 isbinary(op)
97 register int op;
98 {
99 return (op >= FIRST_BINOP && op <= LAST_BINOP);
100 }
101
102 FILE_LOCAL int
isunary(op)103 isunary(op)
104 register int op;
105 {
106 return (op >= FIRST_UNOP && op <= LAST_UNOP);
107 }
108 #else
109 #define isbinary(op) (op >= FIRST_BINOP && op <= LAST_BINOP)
110 #define isunary(op) (op >= FIRST_UNOP && op <= LAST_UNOP)
111 #endif
112
113 /*
114 * The following definitions are used to specify basic variable sizes.
115 */
116
117 #ifndef S_CHAR
118 #define S_CHAR (sizeof (char))
119 #endif
120 #ifndef S_SINT
121 #define S_SINT (sizeof (short int))
122 #endif
123 #ifndef S_INT
124 #define S_INT (sizeof (int))
125 #endif
126 #ifndef S_LINT
127 #define S_LINT (sizeof (long int))
128 #endif
129 #ifndef S_FLOAT
130 #define S_FLOAT (sizeof (float))
131 #endif
132 #ifndef S_DOUBLE
133 #define S_DOUBLE (sizeof (double))
134 #endif
135 #ifndef S_PCHAR
136 #define S_PCHAR (sizeof (char *))
137 #endif
138 #ifndef S_PSINT
139 #define S_PSINT (sizeof (short int *))
140 #endif
141 #ifndef S_PINT
142 #define S_PINT (sizeof (int *))
143 #endif
144 #ifndef S_PLINT
145 #define S_PLINT (sizeof (long int *))
146 #endif
147 #ifndef S_PFLOAT
148 #define S_PFLOAT (sizeof (float *))
149 #endif
150 #ifndef S_PDOUBLE
151 #define S_PDOUBLE (sizeof (double *))
152 #endif
153 #ifndef S_PFPTR
154 #define S_PFPTR (sizeof (int (*)()))
155 #endif
156
157 typedef struct types {
158 short type; /* This is the bit if */
159 char *name; /* this is the token word */
160 } TYPES;
161
162 static TYPES basic_types[] = {
163 { T_CHAR, "char", },
164 { T_INT, "int", },
165 { T_FLOAT, "float", },
166 { T_DOUBLE, "double", },
167 { T_SHORT, "short", },
168 { T_LONG, "long", },
169 { T_SIGNED, "signed", },
170 { T_UNSIGNED, "unsigned", },
171 { 0, NULL, }, /* Signal end */
172 };
173
174 /*
175 * Test_table[] is used to test for illegal combinations.
176 */
177 static short test_table[] = {
178 T_FLOAT | T_DOUBLE | T_LONG | T_SHORT,
179 T_FLOAT | T_DOUBLE | T_CHAR | T_INT,
180 T_FLOAT | T_DOUBLE | T_SIGNED | T_UNSIGNED,
181 T_LONG | T_SHORT | T_CHAR,
182 0 /* end marker */
183 };
184
185 /*
186 * The order of this table is important -- it is also referenced by
187 * the command line processor to allow run-time overriding of the
188 * built-in size values. The order must not be changed:
189 * char, short, int, long, float, double (func pointer)
190 */
191 SIZES size_table[] = {
192 { T_CHAR, S_CHAR, S_PCHAR }, /* char */
193 { T_SHORT, S_SINT, S_PSINT }, /* short int */
194 { T_INT, S_INT, S_PINT }, /* int */
195 { T_LONG, S_LINT, S_PLINT }, /* long */
196 { T_FLOAT, S_FLOAT, S_PFLOAT }, /* float */
197 { T_DOUBLE, S_DOUBLE, S_PDOUBLE }, /* double */
198 { T_FPTR, 0, S_PFPTR }, /* int (*()) */
199 { 0, 0, 0 }, /* End of table */
200 };
201
202
InitCpp5()203 void InitCpp5()
204 {
205
206 }
207
208
209
210 int
eval()211 eval()
212 /*
213 * Evaluate an expression. Straight-forward operator precedence.
214 * This is called from control() on encountering an #if statement.
215 * It calls the following routines:
216 * evallex Lexical analyser -- returns the type and value of
217 * the next input token.
218 * evaleval Evaluate the current operator, given the values on
219 * the value stack. Returns a pointer to the (new)
220 * value stack.
221 * For compatibility with older cpp's, this return returns 1 (TRUE)
222 * if a syntax error is detected.
223 */
224 {
225 register int op; /* Current operator */
226 register int *valp; /* -> value vector */
227 register OPTAB *opp; /* Operator stack */
228 int prec; /* Op precedence */
229 int binop; /* Set if binary op. needed */
230 int op1; /* Operand from stack */
231 int skip; /* For short-circuit testing */
232 int value[NEXP]; /* Value stack */
233 OPTAB opstack[NEXP]; /* Operand stack */
234 #ifndef ZTC /* BP */
235 extern int *evaleval(); /* Does actual evaluation */
236 #endif
237 valp = value;
238 opp = opstack;
239 opp->op = OP_END; /* Mark bottom of stack */
240 opp->prec = opdope[OP_END]; /* And its precedence */
241 opp->skip = 0; /* Not skipping now */
242 binop = 0;
243 again:
244 #ifdef DEBUG_EVAL
245 fprintf( pCppOut, "In #if at again: skip = %d, binop = %d, line is: %s",
246 opp->skip, binop, infile->bptr);
247 #endif
248 if ((op = evallex(opp->skip)) == OP_SUB && binop == 0)
249 op = OP_NEG; /* Unary minus */
250 else if (op == OP_ADD && binop == 0)
251 op = OP_PLU; /* Unary plus */
252 else if (op == OP_FAIL)
253 return (1); /* Error in evallex */
254 #ifdef DEBUG_EVAL
255 fprintf( pCppOut, "op = %s, opdope = %03o, binop = %d, skip = %d\n",
256 opname[op], opdope[op], binop, opp->skip);
257 #endif
258 if (op == DIG) { /* Value? */
259 if (binop != 0) {
260 cerror("misplaced constant in #if", NULLST);
261 return (1);
262 }
263 else if (valp >= &value[NEXP-1]) {
264 cerror("#if value stack overflow", NULLST);
265 return (1);
266 }
267 else {
268 #ifdef DEBUG_EVAL
269 fprintf( pCppOut, "pushing %d onto value stack[%d]\n",
270 evalue, valp - value);
271 #endif
272 *valp++ = evalue;
273 binop = 1;
274 }
275 goto again;
276 }
277 else if (op > OP_END) {
278 cerror("Illegal #if line", NULLST);
279 return (1);
280 }
281 prec = opdope[op];
282 if (binop != (prec & 1)) {
283 cerror("Operator %s in incorrect context", opname[op]);
284 return (1);
285 }
286 binop = (prec & 2) >> 1;
287 for (;;) {
288 #ifdef DEBUG_EVAL
289 fprintf( pCppOut, "op %s, prec %d., stacked op %s, prec %d, skip %d\n",
290 opname[op], prec, opname[opp->op], opp->prec, opp->skip);
291 #endif
292 if (prec > opp->prec) {
293 if (op == OP_LPA)
294 prec = OP_RPA_PREC;
295 else if (op == OP_QUE)
296 prec = OP_QUE_PREC;
297 op1 = opp->skip; /* Save skip for test */
298 /*
299 * Push operator onto op. stack.
300 */
301 opp++;
302 if (opp >= &opstack[NEXP]) {
303 cerror("expression stack overflow at op \"%s\"",
304 opname[op]);
305 return (1);
306 }
307 opp->op = (char)op;
308 opp->prec = (char)prec;
309 skip = (valp[-1] != 0); /* Short-circuit tester */
310 /*
311 * Do the short-circuit stuff here. Short-circuiting
312 * stops automagically when operators are evaluated.
313 */
314 if ((op == OP_ANA && !skip)
315 || (op == OP_ORO && skip))
316 opp->skip = S_ANDOR; /* And/or skip starts */
317 else if (op == OP_QUE) /* Start of ?: operator */
318 opp->skip = (char)((op1 & S_ANDOR) | ((!skip) ? S_QUEST : 0));
319 else if (op == OP_COL) { /* : inverts S_QUEST */
320 opp->skip = (char)((op1 & S_ANDOR)
321 | (((op1 & S_QUEST) != 0) ? 0 : S_QUEST));
322 }
323 else { /* Other ops leave */
324 opp->skip = (char)op1; /* skipping unchanged. */
325 }
326 #ifdef DEBUG_EVAL
327 fprintf( pCppOut, "stacking %s, valp[-1] == %d at %s",
328 opname[op], valp[-1], infile->bptr);
329 dumpstack(opstack, opp, value, valp);
330 #endif
331 goto again;
332 }
333 /*
334 * Pop operator from op. stack and evaluate it.
335 * End of stack and '(' are specials.
336 */
337 skip = opp->skip; /* Remember skip value */
338 switch ((op1 = opp->op)) { /* Look at stacked op */
339 case OP_END: /* Stack end marker */
340 if (op == OP_EOE)
341 return (valp[-1]); /* Finished ok. */
342 goto again; /* Read another op. */
343
344 case OP_LPA: /* ( on stack */
345 if (op != OP_RPA) { /* Matches ) on input */
346 cerror("unbalanced paren's, op is \"%s\"", opname[op]);
347 return (1);
348 }
349 opp--; /* Unstack it */
350 /* goto again; -- Fall through */
351
352 case OP_QUE:
353 goto again; /* Evaluate true expr. */
354
355 case OP_COL: /* : on stack. */
356 opp--; /* Unstack : */
357 if (opp->op != OP_QUE) { /* Matches ? on stack? */
358 cerror("Misplaced '?' or ':', previous operator is %s",
359 opname[(int)opp->op]);
360 return (1);
361 }
362 /*
363 * Evaluate op1.
364 */
365 default: /* Others: */
366 opp--; /* Unstack the operator */
367 #ifdef DEBUG_EVAL
368 fprintf( pCppOut, "Stack before evaluation of %s\n", opname[op1]);
369 dumpstack(opstack, opp, value, valp);
370 #endif
371 valp = evaleval(valp, op1, skip);
372 #ifdef DEBUG_EVAL
373 fprintf( pCppOut, "Stack after evaluation\n");
374 dumpstack(opstack, opp, value, valp);
375 #endif
376 } /* op1 switch end */
377 } /* Stack unwind loop */
378 }
379
380 FILE_LOCAL int
evallex(int skip)381 evallex(int skip)
382 /*
383 * Return next eval operator or value. Called from eval(). It
384 * calls a special-purpose routines for 'char' strings and
385 * numeric values:
386 * evalchar called to evaluate 'x'
387 * evalnum called to evaluate numbers.
388 */
389 {
390 register int c, c1, t;
391
392 again: do { /* Collect the token */
393 c = skipws();
394 if ((c = macroid(c)) == EOF_CHAR || c == '\n') {
395 unget();
396 return (OP_EOE); /* End of expression */
397 }
398 } while ((t = type[c]) == LET && catenate());
399 if (t == INV) { /* Total nonsense */
400 if (!skip) {
401 if (isascii(c) && isprint(c))
402 cierror("illegal character '%c' in #if", c);
403 else
404 cierror("illegal character (%d decimal) in #if", c);
405 }
406 return (OP_FAIL);
407 }
408 else if (t == QUO) { /* ' or " */
409 if (c == '\'') { /* Character constant */
410 evalue = evalchar(skip); /* Somewhat messy */
411 #ifdef DEBUG_EVAL
412 fprintf( pCppOut, "evalchar returns %d.\n", evalue);
413 #endif
414 return (DIG); /* Return a value */
415 }
416 cerror("Can't use a string in an #if", NULLST);
417 return (OP_FAIL);
418 }
419 else if (t == LET) { /* ID must be a macro */
420 if (streq(token, "defined")) { /* Or defined name */
421 c1 = c = skipws();
422 if (c == '(') /* Allow defined(name) */
423 c = skipws();
424 if (type[c] == LET) {
425 evalue = (lookid(c) != NULL);
426 if (c1 != '(' /* Need to balance */
427 || skipws() == ')') /* Did we balance? */
428 return (DIG); /* Parsed ok */
429 }
430 cerror("Bad #if ... defined() syntax", NULLST);
431 return (OP_FAIL);
432 }
433 else if (streq(token, "sizeof")) /* New sizeof hackery */
434 return (dosizeof()); /* Gets own routine */
435 /*
436 * The Draft ANSI C Standard says that an undefined symbol
437 * in an #if has the value zero. We are a bit pickier,
438 * warning except where the programmer was careful to write
439 * #if defined(foo) ? foo : 0
440 */
441 #ifdef STRICT_UNDEF
442 if (!skip)
443 cwarn("undefined symbol \"%s\" in #if, 0 used", token);
444 #endif
445 evalue = 0;
446 return (DIG);
447 }
448 else if (t == DIG) { /* Numbers are harder */
449 evalue = evalnum(c);
450 #ifdef DEBUG_EVAL
451 fprintf( pCppOut, "evalnum returns %d.\n", evalue);
452 #endif
453 }
454 else if (strchr("!=<>&|\\", c) != NULL) {
455 /*
456 * Process a possible multi-byte lexeme.
457 */
458 c1 = cget(); /* Peek at next char */
459 switch (c) {
460 case '!':
461 if (c1 == '=')
462 return (OP_NE);
463 break;
464
465 case '=':
466 if (c1 != '=') { /* Can't say a=b in #if */
467 unget();
468 cerror("= not allowed in #if", NULLST);
469 return (OP_FAIL);
470 }
471 return (OP_EQ);
472
473 case '>':
474 case '<':
475 if (c1 == c)
476 return ((c == '<') ? OP_ASL : OP_ASR);
477 else if (c1 == '=')
478 return ((c == '<') ? OP_LE : OP_GE);
479 break;
480
481 case '|':
482 case '&':
483 if (c1 == c)
484 return ((c == '|') ? OP_ORO : OP_ANA);
485 break;
486
487 case '\\':
488 if (c1 == '\n') /* Multi-line if */
489 goto again;
490 cerror("Unexpected \\ in #if", NULLST);
491 return (OP_FAIL);
492 }
493 unget();
494 }
495 return (t);
496 }
497
498 FILE_LOCAL int
dosizeof()499 dosizeof()
500 /*
501 * Process the sizeof (basic type) operation in an #if string.
502 * Sets evalue to the size and returns
503 * DIG success
504 * OP_FAIL bad parse or something.
505 */
506 {
507 register int c;
508 register TYPES *tp;
509 register SIZES *sizp;
510 register short *testp;
511 short typecode;
512
513 if ((c = skipws()) != '(')
514 goto nogood;
515 /*
516 * Scan off the tokens.
517 */
518 typecode = 0;
519 while (0 != (c = skipws())) {
520 if ((c = macroid(c)) == EOF_CHAR || c == '\n')
521 goto nogood; /* End of line is a bug */
522 else if (c == '(') { /* thing (*)() func ptr */
523 if (skipws() == '*'
524 && skipws() == ')') { /* We found (*) */
525 if (skipws() != '(') /* Let () be optional */
526 unget();
527 else if (skipws() != ')')
528 goto nogood;
529 typecode |= T_FPTR; /* Function pointer */
530 }
531 else { /* Junk is a bug */
532 goto nogood;
533 }
534 }
535 else if (type[c] != LET) /* Exit if not a type */
536 break;
537 else if (!catenate()) { /* Maybe combine tokens */
538 /*
539 * Look for this unexpandable token in basic_types.
540 * The code accepts "int long" as well as "long int"
541 * which is a minor bug as bugs go (and one shared with
542 * a lot of C compilers).
543 */
544 for (tp = basic_types; tp->name != NULLST; tp++) {
545 if (streq(token, tp->name))
546 break;
547 }
548 if (tp->name == NULLST) {
549 cerror("#if sizeof, unknown type \"%s\"", token);
550 return (OP_FAIL);
551 }
552 typecode |= tp->type; /* Or in the type bit */
553 }
554 }
555 /*
556 * We are at the end of the type scan. Chew off '*' if necessary.
557 */
558 if (c == '*') {
559 typecode |= T_PTR;
560 c = skipws();
561 }
562 if (c == ')') { /* Last syntax check */
563 for (testp = test_table; *testp != 0; testp++) {
564 if (!bittest(typecode & *testp)) {
565 cerror("#if ... sizeof: illegal type combination", NULLST);
566 return (OP_FAIL);
567 }
568 }
569 /*
570 * We assume that all function pointers are the same size:
571 * sizeof (int (*)()) == sizeof (float (*)())
572 * We assume that signed and unsigned don't change the size:
573 * sizeof (signed int) == (sizeof unsigned int)
574 */
575 if ((typecode & T_FPTR) != 0) /* Function pointer */
576 typecode = T_FPTR | T_PTR;
577 else { /* Var or var * datum */
578 typecode &= ~(T_SIGNED | T_UNSIGNED);
579 if ((typecode & (T_SHORT | T_LONG)) != 0)
580 typecode &= ~T_INT;
581 }
582 if ((typecode & ~T_PTR) == 0) {
583 cerror("#if sizeof() error, no type specified", NULLST);
584 return (OP_FAIL);
585 }
586 /*
587 * Exactly one bit (and possibly T_PTR) may be set.
588 */
589 for (sizp = size_table; sizp->bits != 0; sizp++) {
590 if ((typecode & ~T_PTR) == sizp->bits) {
591 evalue = ((typecode & T_PTR) != 0)
592 ? sizp->psize : sizp->size;
593 return (DIG);
594 }
595 } /* We shouldn't fail */
596 cierror("#if ... sizeof: bug, unknown type code 0x%x", typecode);
597 return (OP_FAIL);
598 }
599
600 nogood: unget();
601 cerror("#if ... sizeof() syntax error", NULLST);
602 return (OP_FAIL);
603 }
604
605 FILE_LOCAL int
bittest(int value)606 bittest(int value)
607 /*
608 * TRUE if value is zero or exactly one bit is set in value.
609 */
610 {
611 #if (4096 & ~(-4096)) == 0
612 return ((value & ~(-value)) == 0);
613 #else
614 /*
615 * Do it the hard way (for non 2's complement machines)
616 */
617 return (value == 0 || value ^ (value - 1) == (value * 2 - 1));
618 #endif
619 }
620
621 FILE_LOCAL int
evalnum(int c)622 evalnum(int c)
623 /*
624 * Expand number for #if lexical analysis. Note: evalnum recognizes
625 * the unsigned suffix, but only returns a signed int value.
626 */
627 {
628 register int value;
629 register int base;
630 register int c1;
631
632 if (c != '0')
633 base = 10;
634 else if ((c = cget()) == 'x' || c == 'X') {
635 base = 16;
636 c = cget();
637 }
638 else base = 8;
639 value = 0;
640 for (;;) {
641 c1 = c;
642 if (isascii(c) && isupper(c1))
643 c1 = tolower(c1);
644 #ifdef EBCDIC
645 if (c1 <= 'f')
646 #else
647 if (c1 >= 'a')
648 #endif
649 c1 -= ('a' - 10);
650 else c1 -= '0';
651 if (c1 < 0 || c1 >= base)
652 break;
653 value *= base;
654 value += c1;
655 c = cget();
656 }
657 if (c == 'u' || c == 'U') /* Unsigned nonsense */
658 c = cget();
659 unget();
660 return (value);
661 }
662
663 FILE_LOCAL int
evalchar(int skip)664 evalchar(int skip)
665 /*
666 * Get a character constant
667 */
668 {
669 register int c;
670 register int value;
671 register int count;
672
673 instring = TRUE;
674 if ((c = cget()) == '\\') {
675 switch ((c = cget())) {
676 case 'a': /* New in Standard */
677 #if ('a' == '\a' || '\a' == ALERT)
678 value = ALERT; /* Use predefined value */
679 #else
680 value = '\a'; /* Use compiler's value */
681 #endif
682 break;
683
684 case 'b':
685 value = '\b';
686 break;
687
688 case 'f':
689 value = '\f';
690 break;
691
692 case 'n':
693 value = '\n';
694 break;
695
696 case 'r':
697 value = '\r';
698 break;
699
700 case 't':
701 value = '\t';
702 break;
703
704 case 'v': /* New in Standard */
705 #if ('v' == '\v' || '\v' == VT)
706 value = VT; /* Use predefined value */
707 #else
708 value = '\v'; /* Use compiler's value */
709 #endif
710 break;
711
712 case 'x': /* '\xFF' */
713 count = 3;
714 value = 0;
715 while ((((c = get()) >= '0' && c <= '9')
716 || (c >= 'a' && c <= 'f')
717 || (c >= 'A' && c <= 'F'))
718 && (--count >= 0)) {
719 value *= 16;
720 #ifdef EBCDIC
721 value += (c <= '9') ? (c - '0') : ((c & 0xF) + 9);
722 #else
723 value += (c >= '0') ? (c - '0') : ((c & 0xF) + 9);
724 #endif
725 }
726 unget();
727 break;
728
729 default:
730 if (c >= '0' && c <= '7') {
731 count = 3;
732 value = 0;
733 while (c >= '0' && c <= '7' && --count >= 0) {
734 value *= 8;
735 value += (c - '0');
736 c = get();
737 }
738 unget();
739 }
740 else value = c;
741 break;
742 }
743 }
744 else if (c == '\'')
745 value = 0;
746 else value = c;
747 /*
748 * We warn on multi-byte constants and try to hack
749 * (big|little)endian machines.
750 */
751 #if BIG_ENDIAN
752 count = 0;
753 #endif
754 while ((c = get()) != '\'' && c != EOF_CHAR && c != '\n') {
755 if (!skip)
756 ciwarn("multi-byte constant '%c' isn't portable", c);
757 #if BIG_ENDIAN
758 count += BITS_CHAR;
759 value += (c << count);
760 #else
761 value <<= BITS_CHAR;
762 value += c;
763 #endif
764 }
765 instring = FALSE;
766 return (value);
767 }
768
769 FILE_LOCAL int *
evaleval(int * valp,int op,int skip)770 evaleval(int* valp, int op, int skip)
771 /*
772 * Apply the argument operator to the data on the value stack.
773 * One or two values are popped from the value stack and the result
774 * is pushed onto the value stack.
775 *
776 * OP_COL is a special case.
777 *
778 * evaleval() returns the new pointer to the top of the value stack.
779 */
780 {
781 register int v1, v2 = 0;
782
783 if (isbinary(op))
784 v2 = *--valp;
785 v1 = *--valp;
786 #ifdef DEBUG_EVAL
787 fprintf( pCppOut, "%s op %s", (isbinary(op)) ? "binary" : "unary",
788 opname[op]);
789 if (isbinary(op))
790 fprintf( pCppOut, ", v2 = %d.", v2);
791 fprintf( pCppOut, ", v1 = %d.\n", v1);
792 #endif
793 switch (op) {
794 case OP_EOE:
795 break;
796
797 case OP_ADD:
798 v1 += v2;
799 break;
800
801 case OP_SUB:
802 v1 -= v2;
803 break;
804
805 case OP_MUL:
806 v1 *= v2;
807 break;
808
809 case OP_DIV:
810 case OP_MOD:
811 if (v2 == 0) {
812 if (!skip) {
813 cwarn("%s by zero in #if, zero result assumed",
814 (op == OP_DIV) ? "divide" : "mod");
815 }
816 v1 = 0;
817 }
818 else if (op == OP_DIV)
819 v1 /= v2;
820 else
821 v1 %= v2;
822 break;
823
824 case OP_ASL:
825 v1 <<= v2;
826 break;
827
828 case OP_ASR:
829 v1 >>= v2;
830 break;
831
832 case OP_AND:
833 v1 &= v2;
834 break;
835
836 case OP_OR:
837 v1 |= v2;
838 break;
839
840 case OP_XOR:
841 v1 ^= v2;
842 break;
843
844 case OP_EQ:
845 v1 = (v1 == v2);
846 break;
847
848 case OP_NE:
849 v1 = (v1 != v2);
850 break;
851
852 case OP_LT:
853 v1 = (v1 < v2);
854 break;
855
856 case OP_LE:
857 v1 = (v1 <= v2);
858 break;
859
860 case OP_GE:
861 v1 = (v1 >= v2);
862 break;
863
864 case OP_GT:
865 v1 = (v1 > v2);
866 break;
867
868 case OP_ANA:
869 v1 = (v1 && v2);
870 break;
871
872 case OP_ORO:
873 v1 = (v1 || v2);
874 break;
875
876 case OP_COL:
877 /*
878 * v1 has the "true" value, v2 the "false" value.
879 * The top of the value stack has the test.
880 */
881 v1 = (*--valp) ? v1 : v2;
882 break;
883
884 case OP_NEG:
885 v1 = (-v1);
886 break;
887
888 case OP_PLU:
889 break;
890
891 case OP_COM:
892 v1 = ~v1;
893 break;
894
895 case OP_NOT:
896 v1 = !v1;
897 break;
898
899 default:
900 cierror("#if bug, operand = %d.", op);
901 v1 = 0;
902 }
903 *valp++ = v1;
904 return (valp);
905 }
906
907 #ifdef DEBUG_EVAL
dumpstack(opstack,opp,value,valp)908 dumpstack(opstack, opp, value, valp)
909 OPTAB opstack[NEXP]; /* Operand stack */
910 register OPTAB *opp; /* Operator stack */
911 int value[NEXP]; /* Value stack */
912 register int *valp; /* -> value vector */
913 {
914 fprintf( pCppOut, "index op prec skip name -- op stack at %s", infile->bptr);
915 while (opp > opstack) {
916 fprintf( pCppOut, " [%2d] %2d %03o %d %s\n", opp - opstack,
917 opp->op, opp->prec, opp->skip, opname[opp->op]);
918 opp--;
919 }
920 while (--valp >= value) {
921 fprintf( pCppOut, "value[%d] = %d\n", (valp - value), *valp);
922 }
923 }
924 #endif
925
926