# This is a shell archive. Save it in a file, remove anything before

# this line, and then unpack it by entering "sh file". Note, it may

# create directories; files and directories will be owned by you and

# have default permissions.

#

# This archive contains:

#

# cpp5.c

# cpp6.c

#

echo x - cpp5.c

sed 's/^X//' >cpp5.c << 'END-of-cpp5.c'

X/*

X * C P P 5 . C

X * E x p r e s s i o n E v a l u a t i o n

X *

X * Edit History

X * 31-Aug-84 MM USENET net.sources release

X * 04-Oct-84 MM __LINE__ and __FILE__ must call ungetstring()

X * so they work correctly with token concatenation.

X * Added string formal recognition.

X * 25-Oct-84 MM "Short-circuit" evaluate #if's so that we

X * don't print unnecessary error messages for

X * #if !defined(FOO) && FOO != 0 && 10 / FOO ...

X * 31-Oct-84 ado/MM Added token concatenation

X * 6-Nov-84 MM Split from #define stuff, added sizeof stuff

X * 19-Nov-84 ado #if error returns TRUE for (sigh) compatibility

X */

X

X#include <stdio.h>

X#include <ctype.h>

X#include "cppdef.h"

X#include "cpp.h"

X

X/*

X * Evaluate an #if expression.

X */

X

Xstatic char *opname[] = { /* For debug and error messages */

X"end of expression", "val", "id",

X "+", "-", "*", "/", "%",

X "<<", ">>", "&", "|", "^",

X "==", "!=", "<", "<=", ">=", ">",

X "&&", "||", "?", ":", ",",

X "unary +", "unary -", "~", "!", "(", ")", "(none)",

X};

X

X/*

X * opdope[] has the operator precedence:

X * Bits

X * 7 Unused (so the value is always positive)

X * 6-2 Precedence (000x .. 017x)

X * 1-0 Binary op. flags:

X * 01 The binop flag should be set/cleared when this op is seen.

X * 10 The new value of the binop flag.

X * Note: Expected, New binop

X * constant 0 1 Binop, end, or ) should follow constants

X * End of line 1 0 End may not be preceeded by an operator

X * binary 1 0 Binary op follows a value, value follows.

X * unary 0 0 Unary op doesn't follow a value, value follows

X * ( 0 0 Doesn't follow value, value or unop follows

X * ) 1 1 Follows value. Op follows.

X */

X

Xstatic char opdope[OP_MAX] = {

X 0001, /* End of expression */

X 0002, /* Digit */

X 0000, /* Letter (identifier) */

X 0141, 0141, 0151, 0151, 0151, /* ADD, SUB, MUL, DIV, MOD */

X 0131, 0131, 0101, 0071, 0071, /* ASL, ASR, AND, OR, XOR */

X 0111, 0111, 0121, 0121, 0121, 0121, /* EQ, NE, LT, LE, GE, GT */

X 0061, 0051, 0041, 0041, 0031, /* ANA, ORO, QUE, COL, CMA */

X/*

X * Unary op's follow

X */

X 0160, 0160, 0160, 0160, /* NEG, PLU, COM, NOT */

X 0170, 0013, 0023, /* LPA, RPA, END */

X};

X/*

X * OP_QUE and OP_RPA have alternate precedences:

X */

X#define OP_RPA_PREC 0013

X#define OP_QUE_PREC 0034

X

X/*

X * S_ANDOR and S_QUEST signal "short-circuit" boolean evaluation, so that

X * #if FOO != 0 && 10 / FOO ...

X * doesn't generate an error message. They are stored in optab.skip.

X */

X#define S_ANDOR 2

X#define S_QUEST 1

X

Xtypedef struct optab {

X char op; /* Operator */

X char prec; /* Its precedence */

X char skip; /* Short-circuit: TRUE to skip */

X} OPTAB;

Xstatic int evalue; /* Current value from evallex() */

X

X#ifdef nomacargs

XFILE_LOCAL int

Xisbinary(op)

Xregister int op;

X{

X return (op >= FIRST_BINOP && op <= LAST_BINOP);

X}

X

XFILE_LOCAL int

Xisunary(op)

Xregister int op;

X{

X return (op >= FIRST_UNOP && op <= LAST_UNOP);

X}

X#else

X#define isbinary(op) (op >= FIRST_BINOP && op <= LAST_BINOP)

X#define isunary(op) (op >= FIRST_UNOP && op <= LAST_UNOP)

X#endif

X

X/*

X * The following definitions are used to specify basic variable sizes.

X */

X

X#ifndef S_CHAR

X#define S_CHAR (sizeof (char))

X#endif

X#ifndef S_SINT

X#define S_SINT (sizeof (short int))

X#endif

X#ifndef S_INT

X#define S_INT (sizeof (int))

X#endif

X#ifndef S_LINT

X#define S_LINT (sizeof (long int))

X#endif

X#ifndef S_FLOAT

X#define S_FLOAT (sizeof (float))

X#endif

X#ifndef S_DOUBLE

X#define S_DOUBLE (sizeof (double))

X#endif

X#ifndef S_PCHAR

X#define S_PCHAR (sizeof (char *))

X#endif

X#ifndef S_PSINT

X#define S_PSINT (sizeof (short int *))

X#endif

X#ifndef S_PINT

X#define S_PINT (sizeof (int *))

X#endif

X#ifndef S_PLINT

X#define S_PLINT (sizeof (long int *))

X#endif

X#ifndef S_PFLOAT

X#define S_PFLOAT (sizeof (float *))

X#endif

X#ifndef S_PDOUBLE

X#define S_PDOUBLE (sizeof (double *))

X#endif

X#ifndef S_PFPTR

X#define S_PFPTR (sizeof (int (*)()))

X#endif

X

Xtypedef struct types {

X short type; /* This is the bit if */

X char *name; /* this is the token word */

X} TYPES;

X

Xstatic TYPES basic_types[] = {

X { T_CHAR, "char", },

X { T_INT, "int", },

X { T_FLOAT, "float", },

X { T_DOUBLE, "double", },

X { T_SHORT, "short", },

X { T_LONG, "long", },

X { T_SIGNED, "signed", },

X { T_UNSIGNED, "unsigned", },

X { 0, NULL, }, /* Signal end */

X};

X

X/*

X * Test_table[] is used to test for illegal combinations.

X */

Xstatic short test_table[] = {

X T_FLOAT | T_DOUBLE | T_LONG | T_SHORT,

X T_FLOAT | T_DOUBLE | T_CHAR | T_INT,

X T_FLOAT | T_DOUBLE | T_SIGNED | T_UNSIGNED,

X T_LONG | T_SHORT | T_CHAR,

X 0 /* end marker */

X};

X

X/*

X * The order of this table is important -- it is also referenced by

X * the command line processor to allow run-time overriding of the

X * built-in size values. The order must not be changed:

X * char, short, int, long, float, double (func pointer)

X */

XSIZES size_table[] = {

X { T_CHAR, S_CHAR, S_PCHAR }, /* char */

X { T_SHORT, S_SINT, S_PSINT }, /* short int */

X { T_INT, S_INT, S_PINT }, /* int */

X { T_LONG, S_LINT, S_PLINT }, /* long */

X { T_FLOAT, S_FLOAT, S_PFLOAT }, /* float */

X { T_DOUBLE, S_DOUBLE, S_PDOUBLE }, /* double */

X { T_FPTR, 0, S_PFPTR }, /* int (*()) */

X { 0, 0, 0 }, /* End of table */

X};

X

Xint

Xeval()

X/*

X * Evaluate an expression. Straight-forward operator precedence.

X * This is called from control() on encountering an #if statement.

X * It calls the following routines:

X * evallex Lexical analyser -- returns the type and value of

X * the next input token.

X * evaleval Evaluate the current operator, given the values on

X * the value stack. Returns a pointer to the (new)

X * value stack.

X * For compatiblity with older cpp's, this return returns 1 (TRUE)

X * if a syntax error is detected.

X */

X{

X register int op; /* Current operator */

X register int *valp; /* -> value vector */

X register OPTAB *opp; /* Operator stack */

X int prec; /* Op precedence */

X int binop; /* Set if binary op. needed */

X int op1; /* Operand from stack */

X int skip; /* For short-circuit testing */

X int value[NEXP]; /* Value stack */

X OPTAB opstack[NEXP]; /* Operand stack */

X extern int *evaleval(); /* Does actual evaluation */

X

X valp = value;

X opp = opstack;

X opp->op = OP_END; /* Mark bottom of stack */

X opp->prec = opdope[OP_END]; /* And its precedence */

X opp->skip = 0; /* Not skipping now */

X binop = 0;

Xagain: ;

X#ifdef DEBUG_EVAL

X printf("In #if at again: skip = %d, binop = %d, line is: %s",

X opp->skip, binop, infile->bptr);

X#endif

X if ((op = evallex(opp->skip)) == OP_SUB && binop == 0)

X op = OP_NEG; /* Unary minus */

X else if (op == OP_ADD && binop == 0)

X op = OP_PLU; /* Unary plus */

X else if (op == OP_FAIL)

X return (1); /* Error in evallex */

X#ifdef DEBUG_EVAL

X printf("op = %s, opdope = %03o, binop = %d, skip = %d\n",

X opname[op], opdope[op], binop, opp->skip);

X#endif

X if (op == DIG) { /* Value? */

X if (binop != 0) {

X cerror("misplaced constant in #if", NULLST);

X return (1);

X }

X else if (valp >= &value[NEXP-1]) {

X cerror("#if value stack overflow", NULLST);

X return (1);

X }

X else {

X#ifdef DEBUG_EVAL

X printf("pushing %d onto value stack[%d]\n",

X evalue, valp - value);

X#endif

X *valp++ = evalue;

X binop = 1;

X }

X goto again;

X }

X else if (op > OP_END) {

X cerror("Illegal #if line", NULLST);

X return (1);

X }

X prec = opdope[op];

X if (binop != (prec & 1)) {

X cerror("Operator %s in incorrect context", opname[op]);

X return (1);

X }

X binop = (prec & 2) >> 1;

X for (;;) {

X#ifdef DEBUG_EVAL

X printf("op %s, prec %d., stacked op %s, prec %d, skip %d\n",

X opname[op], prec, opname[opp->op], opp->prec, opp->skip);

X#endif

X if (prec > opp->prec) {

X if (op == OP_LPA)

X prec = OP_RPA_PREC;

X else if (op == OP_QUE)

X prec = OP_QUE_PREC;

X op1 = opp->skip; /* Save skip for test */

X /*

X * Push operator onto op. stack.

X */

X opp++;

X if (opp >= &opstack[NEXP]) {

X cerror("expression stack overflow at op \"%s\"",

X opname[op]);

X return (1);

X }

X opp->op = op;

X opp->prec = prec;

X skip = (valp[-1] != 0); /* Short-circuit tester */

X /*

X * Do the short-circuit stuff here. Short-circuiting

X * stops automagically when operators are evaluated.

X */

X if ((op == OP_ANA && !skip)

X || (op == OP_ORO && skip))

X opp->skip = S_ANDOR; /* And/or skip starts */

X else if (op == OP_QUE) /* Start of ?: operator */

X opp->skip = (op1 & S_ANDOR) | ((!skip) ? S_QUEST : 0);

X else if (op == OP_COL) { /* : inverts S_QUEST */

X opp->skip = (op1 & S_ANDOR)

X | (((op1 & S_QUEST) != 0) ? 0 : S_QUEST);

X }

X else { /* Other ops leave */

X opp->skip = op1; /* skipping unchanged. */

X }

X#ifdef DEBUG_EVAL

X printf("stacking %s, valp[-1] == %d at %s",

X opname[op], valp[-1], infile->bptr);

X dumpstack(opstack, opp, value, valp);

X#endif

X goto again;

X }

X /*

X * Pop operator from op. stack and evaluate it.

X * End of stack and '(' are specials.

X */

X skip = opp->skip; /* Remember skip value */

X switch ((op1 = opp->op)) { /* Look at stacked op */

X case OP_END: /* Stack end marker */

X if (op == OP_EOE)

X return (valp[-1]); /* Finished ok. */

X goto again; /* Read another op. */

X

X case OP_LPA: /* ( on stack */

X if (op != OP_RPA) { /* Matches ) on input */

X cerror("unbalanced paren's, op is \"%s\"", opname[op]);

X return (1);

X }

X opp--; /* Unstack it */

X /* goto again; -- Fall through */

X

X case OP_QUE:

X goto again; /* Evaluate true expr. */

X

X case OP_COL: /* : on stack. */

X opp--; /* Unstack : */

X if (opp->op != OP_QUE) { /* Matches ? on stack? */

X cerror("Misplaced '?' or ':', previous operator is %s",

X opname[opp->op]);

X return (1);

X }

X /*

X * Evaluate op1.

X */

X default: /* Others: */

X opp--; /* Unstack the operator */

X#ifdef DEBUG_EVAL

X printf("Stack before evaluation of %s\n", opname[op1]);

X dumpstack(opstack, opp, value, valp);

X#endif

X valp = evaleval(valp, op1, skip);

X#ifdef DEBUG_EVAL

X printf("Stack after evaluation\n");

X dumpstack(opstack, opp, value, valp);

X#endif

X } /* op1 switch end */

X } /* Stack unwind loop */

X}

X

XFILE_LOCAL int

Xevallex(skip)

Xint skip; /* TRUE if short-circuit evaluation */

X/*

X * Return next eval operator or value. Called from eval(). It

X * calls a special-purpose routines for 'char' strings and

X * numeric values:

X * evalchar called to evaluate 'x'

X * evalnum called to evaluate numbers.

X */

X{

X register int c, c1, t;

X

Xagain: do { /* Collect the token */

X c = skipws();

X if ((c = macroid(c)) == EOF_CHAR || c == '\n') {

X unget();

X return (OP_EOE); /* End of expression */

X }

X } while ((t = type[c]) == LET && catenate());

X if (t == INV) { /* Total nonsense */

X if (!skip) {

X if (isascii(c) && isprint(c))

X cierror("illegal character '%c' in #if", c);

X else

X cierror("illegal character (%d decimal) in #if", c);

X }

X return (OP_FAIL);

X }

X else if (t == QUO) { /* ' or " */

X if (c == '\'') { /* Character constant */

X evalue = evalchar(skip); /* Somewhat messy */

X#ifdef DEBUG_EVAL

X printf("evalchar returns %d.\n", evalue);

X#endif

X return (DIG); /* Return a value */

X }

X cerror("Can't use a string in an #if", NULLST);

X return (OP_FAIL);

X }

X else if (t == LET) { /* ID must be a macro */

X if (streq(token, "defined")) { /* Or defined name */

X c1 = c = skipws();

X if (c == '(') /* Allow defined(name) */

X c = skipws();

X if (type[c] == LET) {

X evalue = (lookid(c) != NULL);

X if (c1 != '(' /* Need to balance */

X || skipws() == ')') /* Did we balance? */

X return (DIG); /* Parsed ok */

X }

X cerror("Bad #if ... defined() syntax", NULLST);

X return (OP_FAIL);

X }

X else if (streq(token, "sizeof")) /* New sizeof hackery */

X return (dosizeof()); /* Gets own routine */

X /*

X * The Draft ANSI C Standard says that an undefined symbol

X * in an #if has the value zero. We are a bit pickier,

X * warning except where the programmer was careful to write

X * #if defined(foo) ? foo : 0

X */

X#ifdef VERBOSE

X if (!skip)

X cwarn("undefined symbol \"%s\" in #if, 0 used", token);

X#endif

X evalue = 0;

X return (DIG);

X }

X else if (t == DIG) { /* Numbers are harder */

X evalue = evalnum(c);

X#ifdef DEBUG_EVAL

X printf("evalnum returns %d.\n", evalue);

X#endif

X }

X else if (strchr("!=<>&|\\", c) != NULL) {

X /*

X * Process a possible multi-byte lexeme.

X */

X c1 = cget(); /* Peek at next char */

X switch (c) {

X case '!':

X if (c1 == '=')

X return (OP_NE);

X break;

X

X case '=':

X if (c1 != '=') { /* Can't say a=b in #if */

X unget();

X cerror("= not allowed in #if", NULLST);

X return (OP_FAIL);

X }

X return (OP_EQ);

X

X case '>':

X case '<':

X if (c1 == c)

X return ((c == '<') ? OP_ASL : OP_ASR);

X else if (c1 == '=')

X return ((c == '<') ? OP_LE : OP_GE);

X break;

X

X case '|':

X case '&':

X if (c1 == c)

X return ((c == '|') ? OP_ORO : OP_ANA);

X break;

X

X case '\\':

X if (c1 == '\n') /* Multi-line if */

X goto again;

X cerror("Unexpected \\ in #if", NULLST);

X return (OP_FAIL);

X }

X unget();

X }

X return (t);

X}

X

XFILE_LOCAL int

Xdosizeof()

X/*

X * Process the sizeof (basic type) operation in an #if string.

X * Sets evalue to the size and returns

X * DIG success

X * OP_FAIL bad parse or something.

X */

X{

X register int c;

X register TYPES *tp;

X register SIZES *sizp;

X register short *testp;

X short typecode;

X

X if ((c = skipws()) != '(')

X goto nogood;

X /*

X * Scan off the tokens.

X */

X typecode = 0;

X while ((c = skipws())) {

X if ((c = macroid(c)) == EOF_CHAR || c == '\n')

X goto nogood; /* End of line is a bug */

X else if (c == '(') { /* thing (*)() func ptr */

X if (skipws() == '*'

X && skipws() == ')') { /* We found (*) */

X if (skipws() != '(') /* Let () be optional */

X unget();

X else if (skipws() != ')')

X goto nogood;

X typecode |= T_FPTR; /* Function pointer */

X }

X else { /* Junk is a bug */

X goto nogood;

X }

X }

X else if (type[c] != LET) /* Exit if not a type */

X break;

X else if (!catenate()) { /* Maybe combine tokens */

X /*

X * Look for this unexpandable token in basic_types.

X * The code accepts "int long" as well as "long int"

X * which is a minor bug as bugs go (and one shared with

X * a lot of C compilers).

X */

X for (tp = basic_types; tp->name != NULLST; tp++) {

X if (streq(token, tp->name))

X break;

X }

X if (tp->name == NULLST) {

X cerror("#if sizeof, unknown type \"%s\"", token);

X return (OP_FAIL);

X }

X typecode |= tp->type; /* Or in the type bit */

X }

X }

X /*

X * We are at the end of the type scan. Chew off '*' if necessary.

X */

X if (c == '*') {

X typecode |= T_PTR;

X c = skipws();

X }

X if (c == ')') { /* Last syntax check */

X for (testp = test_table; *testp != 0; testp++) {

X if (!bittest(typecode & *testp)) {

X cerror("#if ... sizeof: illegal type combination", NULLST);

X return (OP_FAIL);

X }

X }

X /*

X * We assume that all function pointers are the same size:

X * sizeof (int (*)()) == sizeof (float (*)())

X * We assume that signed and unsigned don't change the size:

X * sizeof (signed int) == (sizeof unsigned int)

X */

X if ((typecode & T_FPTR) != 0) /* Function pointer */

X typecode = T_FPTR | T_PTR;

X else { /* Var or var * datum */

X typecode &= ~(T_SIGNED | T_UNSIGNED);

X if ((typecode & (T_SHORT | T_LONG)) != 0)

X typecode &= ~T_INT;

X }

X if ((typecode & ~T_PTR) == 0) {

X cerror("#if sizeof() error, no type specified", NULLST);

X return (OP_FAIL);

X }

X /*

X * Exactly one bit (and possibly T_PTR) may be set.

X */

X for (sizp = size_table; sizp->bits != 0; sizp++) {

X if ((typecode & ~T_PTR) == sizp->bits) {

X evalue = ((typecode & T_PTR) != 0)

X ? sizp->psize : sizp->size;

X return (DIG);

X }

X } /* We shouldn't fail */

X cierror("#if ... sizeof: bug, unknown type code 0x%x", typecode);

X return (OP_FAIL);

X }

X

Xnogood: unget();

X cerror("#if ... sizeof() syntax error", NULLST);

X return (OP_FAIL);

X}

X

XFILE_LOCAL int

Xbittest(value)

X/*

X * TRUE if value is zero or exactly one bit is set in value.

X */

X{

X#if (4096 & ~(-4096)) == 0

X return ((value & ~(-value)) == 0);

X#else

X /*

X * Do it the hard way (for non 2's complement machines)

X */

X return (value == 0 || value ^ (value - 1) == (value * 2 - 1));

X#endif

X}

X

XFILE_LOCAL int

Xevalnum(c)

Xregister int c;

X/*

X * Expand number for #if lexical analysis. Note: evalnum recognizes

X * the unsigned suffix, but only returns a signed int value.

X */

X{

X register int value;

X register int base;

X register int c1;

X

X if (c != '0')

X base = 10;

X else if ((c = cget()) == 'x' || c == 'X') {

X base = 16;

X c = cget();

X }

X else base = 8;

X value = 0;

X for (;;) {

X c1 = c;

X if (isascii(c) && isupper(c1))

X c1 = tolower(c1);

X if (c1 >= 'a')

X c1 -= ('a' - 10);

X else c1 -= '0';

X if (c1 < 0 || c1 >= base)

X break;

X value *= base;

X value += c1;

X c = cget();

X }

X if (c == 'u' || c == 'U') /* Unsigned nonsense */

X c = cget();

X unget();

X return (value);

X}

X

XFILE_LOCAL int

Xevalchar(skip)

Xint skip; /* TRUE if short-circuit evaluation */

X/*

X * Get a character constant

X */

X{

X register int c;

X register int value;

X register int count;

X

X instring = TRUE;

X if ((c = cget()) == '\\') {

X switch ((c = cget())) {

X case 'a': /* New in Standard */

X#if ('a' == '\a' || '\a' == ALERT)

X value = ALERT; /* Use predefined value */

X#else

X value = '\a'; /* Use compiler's value */

X#endif

X break;

X

X case 'b':

X value = '\b';

X break;

X

X case 'f':

X value = '\f';

X break;

X

X case 'n':

X value = '\n';

X break;

X

X case 'r':

X value = '\r';

X break;

X

X case 't':

X value = '\t';

X break;

X

X case 'v': /* New in Standard */

X#if ('v' == '\v' || '\v' == VT)

X value = VT; /* Use predefined value */

X#else

X value = '\v'; /* Use compiler's value */

X#endif

X break;

X

X case 'x': /* '\xFF' */

X count = 3;

X value = 0;

X while ((((c = get()) >= '0' && c <= '9')

X || (c >= 'a' && c <= 'f')

X || (c >= 'A' && c <= 'F'))

X && (--count >= 0)) {

X value *= 16;

X value += (c <= '9') ? (c - '0') : ((c & 0xF) + 9);

X }

X unget();

X break;

X

X default:

X if (c >= '0' && c <= '7') {

X count = 3;

X value = 0;

X while (c >= '0' && c <= '7' && --count >= 0) {

X value *= 8;

X value += (c - '0');

X c = get();

X }

X unget();

X }

X else value = c;

X break;

X }

X }

X else if (c == '\'')

X value = 0;

X else value = c;

X /*

X * We warn on multi-byte constants and try to hack

X * (big|little)endian machines.

X */

X#if BIG_ENDIAN

X count = 0;

X#endif

X while ((c = get()) != '\'' && c != EOF_CHAR && c != '\n') {

X if (!skip)

X ciwarn("multi-byte constant '%c' isn't portable", c);

X#if BIG_ENDIAN

X count += BITS_CHAR;

X value += (c << count);

X#else

X value <<= BITS_CHAR;

X value += c;

X#endif

X }

X instring = FALSE;

X return (value);

X}

X

XFILE_LOCAL int *

Xevaleval(valp, op, skip)

Xregister int *valp;

Xint op;

Xint skip; /* TRUE if short-circuit evaluation */

X/*

X * Apply the argument operator to the data on the value stack.

X * One or two values are popped from the value stack and the result

X * is pushed onto the value stack.

X *

X * OP_COL is a special case.

X *

X * evaleval() returns the new pointer to the top of the value stack.

X */

X{

X register int v1, v2;

X

X if (isbinary(op))

X v2 = *--valp;

X v1 = *--valp;

X#ifdef DEBUG_EVAL

X printf("%s op %s", (isbinary(op)) ? "binary" : "unary",

X opname[op]);

X if (isbinary(op))

X printf(", v2 = %d.", v2);

X printf(", v1 = %d.\n", v1);

X#endif

X switch (op) {

X case OP_EOE:

X break;

X

X case OP_ADD:

X v1 += v2;

X break;

X

X case OP_SUB:

X v1 -= v2;

X break;

X

X case OP_MUL:

X v1 *= v2;

X break;

X

X case OP_DIV:

X case OP_MOD:

X if (v2 == 0) {

X if (!skip) {

X cwarn("%s by zero in #if, zero result assumed",

X (op == OP_DIV) ? "divide" : "mod");

X }

X v1 = 0;

X }

X else if (op == OP_DIV)

X v1 /= v2;

X else

X v1 %= v2;

X break;

X

X case OP_ASL:

X v1 <<= v2;

X break;

X

X case OP_ASR:

X v1 >>= v2;

X break;

X

X case OP_AND:

X v1 &= v2;

X break;

X

X case OP_OR:

X v1 |= v2;

X break;

X

X case OP_XOR:

X v1 ^= v2;

X break;

X

X case OP_EQ:

X v1 = (v1 == v2);

X break;

X

X case OP_NE:

X v1 = (v1 != v2);

X break;

X

X case OP_LT:

X v1 = (v1 < v2);

X break;

X

X case OP_LE:

X v1 = (v1 <= v2);

X break;

X

X case OP_GE:

X v1 = (v1 >= v2);

X break;

X

X case OP_GT:

X v1 = (v1 > v2);

X break;

X

X case OP_ANA:

X v1 = (v1 && v2);

X break;

X

X case OP_ORO:

X v1 = (v1 || v2);

X break;

X

X case OP_COL:

X /*

X * v1 has the "true" value, v2 the "false" value.

X * The top of the value stack has the test.

X */

X v1 = (*--valp) ? v1 : v2;

X break;

X

X case OP_NEG:

X v1 = (-v1);

X break;

X

X case OP_PLU:

X break;

X

X case OP_COM:

X v1 = ~v1;

X break;

X

X case OP_NOT:

X v1 = !v1;

X break;

X

X default:

X cierror("#if bug, operand = %d.", op);

X v1 = 0;

X }

X *valp++ = v1;

X return (valp);

X}

X

X#ifdef DEBUG_EVAL

Xdumpstack(opstack, opp, value, valp)

XOPTAB opstack[NEXP]; /* Operand stack */

Xregister OPTAB *opp; /* Operator stack */

Xint value[NEXP]; /* Value stack */

Xregister int *valp; /* -> value vector */

X{

X printf("index op prec skip name -- op stack at %s", infile->bptr);

X while (opp > opstack) {

X printf(" [%2d] %2d %03o %d %s\n", opp - opstack,

X opp->op, opp->prec, opp->skip, opname[opp->op]);

X opp--;

X }

X while (--valp >= value) {

X printf("value[%d] = %d\n", (valp - value), *valp);

X }

X}

X#endif

X

END-of-cpp5.c

echo x - cpp6.c

sed 's/^X//' >cpp6.c << 'END-of-cpp6.c'

X/*

X * C P P 6 . C

X * S u p p o r t R o u t i n e s

X *

X * Edit History

X * 25-May-84 MM Added 8-bit support to type table.

X * 30-May-84 ARF sharp() should output filename in quotes

X * 02-Aug-84 MM Newline and #line hacking. sharp() now in cpp1.c

X * 31-Aug-84 MM USENET net.sources release

X * 11-Sep-84 ado/MM Keepcomments, also line number pathological

X * 12-Sep-84 ado/MM bug if comment changes to space and we unget later.

X * 03-Oct-84 gkr/MM Fixed scannumber bug for '.e' (as in struct.element).

X * 04-Oct-84 MM Added ungetstring() for token concatenation

X * 08-Oct-84 MM Yet another attack on number scanning

X * 31-Oct-84 ado Parameterized $ in identifiers

X * 2-Nov-84 MM Token concatenation is messier than I thought

X * 6-Dec-84 MM \<nl> is everywhere invisible.

X */

X

X#include <stdio.h>

X#include <ctype.h>

X#include "cppdef.h"

X#include "cpp.h"

X

X/*

X * skipnl() skips over input text to the end of the line.

X * skipws() skips over "whitespace" (spaces or tabs), but

X * not skip over the end of the line. It skips over

X * TOK_SEP, however (though that shouldn't happen).

X * scanid() reads the next token (C identifier) into token[].

X * The caller has already read the first character of

X * the identifier. Unlike macroid(), the token is

X * never expanded.

X * macroid() reads the next token (C identifier) into token[].

X * If it is a #defined macro, it is expanded, and

X * macroid() returns TRUE, otherwise, FALSE.

X * catenate() Does the dirty work of token concatenation, TRUE if it did.

X * scanstring() Reads a string from the input stream, calling

X * a user-supplied function for each character.

X * This function may be output() to write the

X * string to the output file, or save() to save

X * the string in the work buffer.

X * scannumber() Reads a C numeric constant from the input stream,

X * calling the user-supplied function for each

X * character. (output() or save() as noted above.)

X * save() Save one character in the work[] buffer.

X * savestring() Saves a string in malloc() memory.

X * getfile() Initialize a new FILEINFO structure, called when

X * #include opens a new file, or a macro is to be

X * expanded.

X * getmem() Get a specified number of bytes from malloc memory.

X * output() Write one character to stdout (calling putchar) --

X * implemented as a function so its address may be

X * passed to scanstring() and scannumber().

X * lookid() Scans the next token (identifier) from the input

X * stream. Looks for it in the #defined symbol table.

X * Returns a pointer to the definition, if found, or NULL

X * if not present. The identifier is stored in token[].

X * defnedel() Define enter/delete subroutine. Updates the

X * symbol table.

X * get() Read the next byte from the current input stream,

X * handling end of (macro/file) input and embedded

X * comments appropriately. Note that the global

X * instring is -- essentially -- a parameter to get().

X * cget() Like get(), but skip over TOK_SEP.

X * unget() Push last gotten character back on the input stream.

X * cerror(), cwarn(), cfatal(), cierror(), ciwarn()

X * These routines format an print messages to the user.

X * cerror & cwarn take a format and a single string argument.

X * cierror & ciwarn take a format and a single int (char) argument.

X * cfatal takes a format and a single string argument.

X */

X

X/*

X * This table must be rewritten for a non-Ascii machine.

X *

X * Note that several "non-visible" characters have special meaning: