zeroc-ice 3.6b1

data/ext/ice/mcpp/eval.c

@@ -0,0 +1,1673 @@
+/*-
+ * Copyright (c) 1998, 2002-2008 Kiyoshi Matsui <kmatsui@t3.rim.or.jp>
+ * All rights reserved.
+ *
+ * Some parts of this code are derived from the public domain software
+ * DECUS cpp (1984,1985) written by Martin Minow.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ *                              E V A L . C
+ *                  E x p r e s s i o n   E v a l u a t i o n
+ *
+ * The routines to evaluate #if expression are placed here.
+ * Some routines are used also to evaluate the value of numerical tokens.
+ */
+
+#if PREPROCESSED
+#include    "mcpp.H"
+#else
+#include    "system.H"
+#include    "internal.H"
+#endif
+
+typedef struct optab {
+    char    op;                     /* Operator                     */
+    char    prec;                   /* Its precedence               */
+    char    skip;                   /* Short-circuit: non-0 to skip */
+} OPTAB;
+
+static int      eval_lex( void);
+                /* Get type and value of token  */
+static int      chk_ops( void);
+                /* Check identifier-like ops    */
+static VAL_SIGN *   eval_char( char * const token);
+                /* Evaluate character constant  */
+static expr_t   eval_one( char ** seq_pp, int wide, int mbits, int * ucn8);
+                /* Evaluate a character         */
+static VAL_SIGN *   eval_eval( VAL_SIGN * valp, int op);
+                /* Entry to #if arithmetic      */
+static expr_t   eval_signed( VAL_SIGN ** valpp, expr_t v1, expr_t v2, int op);
+                /* Do signed arithmetic of expr.*/
+static expr_t   eval_unsigned( VAL_SIGN ** valpp, uexpr_t v1u, uexpr_t v2u
+        , int op);
+                /* Do unsigned arithmetic       */
+static void     overflow( const char * op_name, VAL_SIGN ** valpp
+        , int ll_overflow);
+                /* Diagnose overflow of expr.   */
+static int      do_sizeof( void);
+                /* Evaluate sizeof (type)       */
+static int      look_type( int typecode);
+                /* Look for type of the name    */
+static void     dump_val( const char * msg, const VAL_SIGN * valp);
+                /* Print value of an operand    */
+static void     dump_stack( const OPTAB * opstack, const OPTAB * opp
+        , const VAL_SIGN * value, const VAL_SIGN * valp);
+                /* Print stacked operators      */
+
+/* For debug and error messages.    */
+static const char * const   opname[ OP_END + 1] = {
+    "end of expression",    "val",  "(",
+    "unary +",      "unary -",      "~",    "!",
+    "*",    "/",    "%",
+    "+",    "-",    "<<",   ">>",
+    "<",    "<=",   ">",    ">=",   "==",   "!=",
+    "&",    "^",    "|",    "&&",   "||",
+    "?",    ":",
+    ")",    "(none)"
+};
+
+/*
+ * opdope[] has the operator (and operand) precedence:
+ *     Bits
+ *        7     Unused (so the value is always positive)
+ *      6-2     Precedence (0000 .. 0174)
+ *      1-0     Binary op. flags:
+ *          10  The next binop flag (binop should/not follow).
+ *          01  The binop flag (should be set/cleared when this op is seen).
+ * Note:   next binop
+ * value    1   0   Value doesn't follow value.
+ *                  Binop, ), END should follow value, value or unop doesn't.
+ *  (       0   0   ( doesn't follow value.  Value follows.
+ * unary    0   0   Unop doesn't follow value.  Value follows.
+ * binary   0   1   Binary op follows value.  Value follows.
+ *  )       1   1   ) follows value.  Binop, ), END follows.
+ * END      0   1   END follows value, doesn't follow ops.
+ */
+
+static const char   opdope[ OP_END + 1] = {
+    0001,                               /* End of expression        */
+    0002, 0170,                         /* VAL (constant), LPA      */
+/* Unary op's   */
+    0160, 0160, 0160, 0160,             /* PLU, NEG, COM, NOT       */
+/* Binary op's  */
+    0151, 0151, 0151,                   /* MUL, DIV, MOD,           */
+    0141, 0141, 0131, 0131,             /* ADD, SUB, SL, SR         */
+    0121, 0121, 0121, 0121, 0111, 0111, /* LT, LE, GT, GE, EQ, NE   */
+    0101, 0071, 0061, 0051, 0041,       /* AND, XOR, OR, ANA, ORO   */
+    0031, 0031,                         /* QUE, COL                 */
+/* Parens       */
+    0013, 0023                          /* RPA, END                 */
+};
+/*
+ * OP_QUE, OP_RPA and unary operators have alternate precedences:
+ */
+#define OP_RPA_PREC     0013
+#define OP_QUE_PREC     0024    /* From right to left grouping      */
+#define OP_UNOP_PREC    0154            /*      ditto               */
+
+/*
+ * S_ANDOR and S_QUEST signal "short-circuit" boolean evaluation, so that
+ *      #if FOO != 0 && 10 / FOO ...
+ * doesn't generate an error message.  They are stored in optab.skip.
+ */
+#define S_ANDOR         2
+#define S_QUEST         1
+
+static VAL_SIGN     ev;     /* Current value and signedness     */
+static int          skip = 0;   /* 3-way signal of skipping expr*/
+static const char * const   non_eval
+        = " (in non-evaluated sub-expression)";             /* _W8_ */
+
+#if HAVE_LONG_LONG && COMPILER == INDEPENDENT
+    static int  w_level = 1;    /* warn_level at overflow of long   */
+#else
+    static int  w_level = 2;
+#endif
+
+/*
+ * In KR and OLD_PREP modes.
+ * Define bits for the basic types and their adjectives.
+ */
+#define T_CHAR          1
+#define T_INT           2
+#define T_FLOAT         4
+#define T_DOUBLE        8
+#define T_LONGDOUBLE    16
+#define T_SHORT         32
+#define T_LONG          64
+#define T_LONGLONG      128
+#define T_SIGNED        256
+#define T_UNSIGNED      512
+#define T_PTR           1024        /* Pointer to data objects      */
+#define T_FPTR          2048        /* Pointer to functions         */
+
+/*
+ * The SIZES structure is used to store the values for #if sizeof.
+ */
+typedef struct sizes {
+        int             bits;       /* If this bit is set,          */
+        int             size;       /* this is the datum size value */
+        int             psize;      /* this is the pointer size     */
+} SIZES;
+
+/*
+ * S_CHAR, etc.  define the sizeof the basic TARGET machine word types.
+ *      By default, sizes are set to the values for the HOST computer.  If
+ *      this is inappropriate, see those tables for details on what to change.
+ *      Also, if you have a machine where sizeof (signed int) differs from
+ *      sizeof (unsigned int), you will have to edit those tables and code in
+ *      eval.c.
+ * Note: sizeof in #if expression is disallowed by Standard.
+ */
+
+#define S_CHAR      (sizeof (char))
+#define S_SINT      (sizeof (short int))
+#define S_INT       (sizeof (int))
+#define S_LINT      (sizeof (long int))
+#define S_FLOAT     (sizeof (float))
+#define S_DOUBLE    (sizeof (double))
+#define S_PCHAR     (sizeof (char *))
+#define S_PSINT     (sizeof (short int *))
+#define S_PINT      (sizeof (int *))
+#define S_PLINT     (sizeof (long int *))
+#define S_PFLOAT    (sizeof (float *))
+#define S_PDOUBLE   (sizeof (double *))
+#define S_PFPTR     (sizeof (int (*)()))
+#if HAVE_LONG_LONG
+#if (HOST_COMPILER == BORLANDC) \
+        || (HOST_COMPILER == MSC && defined(_MSC_VER) && (_MSC_VER < 1300))
+#define S_LLINT     (sizeof (__int64))
+#define S_PLLINT    (sizeof (__int64 *))
+#else
+#define S_LLINT     (sizeof (long long int))
+#define S_PLLINT    (sizeof (long long int *))
+#endif
+#endif
+#define S_LDOUBLE   (sizeof (long double))
+#define S_PLDOUBLE  (sizeof (long double *))
+
+typedef struct types {
+    int         type;               /* This is the bits for types   */
+    char *      token_name;         /* this is the token word       */
+    int         excluded;           /* but these aren't legal here. */
+} TYPES;
+
+#define ANYSIGN     (T_SIGNED | T_UNSIGNED)
+#define ANYFLOAT    (T_FLOAT | T_DOUBLE | T_LONGDOUBLE)
+#if HAVE_LONG_LONG
+#define ANYINT      (T_CHAR | T_SHORT | T_INT | T_LONG | T_LONGLONG)
+#else
+#define ANYINT      (T_CHAR | T_SHORT | T_INT | T_LONG)
+#endif
+
+static const TYPES  basic_types[] = {
+    { T_CHAR,       "char",         ANYFLOAT | ANYINT },
+    { T_SHORT,      "short",        ANYFLOAT | ANYINT },
+    { T_INT,        "int",          ANYFLOAT | T_CHAR | T_INT },
+    { T_LONG,       "long",         ANYFLOAT | ANYINT },
+#if HAVE_LONG_LONG
+#if HOST_COMPILER == BORLANDC
+    { T_LONGLONG,   "__int64",      ANYFLOAT | ANYINT },
+#else
+    { T_LONGLONG,   "long long",    ANYFLOAT | ANYINT },
+#endif
+#endif
+    { T_FLOAT,      "float",        ANYFLOAT | ANYINT | ANYSIGN },
+    { T_DOUBLE,     "double",       ANYFLOAT | ANYINT | ANYSIGN },
+    { T_LONGDOUBLE, "long double",  ANYFLOAT | ANYINT | ANYSIGN },
+    { T_SIGNED,     "signed",       ANYFLOAT | ANYINT | ANYSIGN },
+    { T_UNSIGNED,   "unsigned",     ANYFLOAT | ANYINT | ANYSIGN },
+    { 0,            NULL,           0 }     /* Signal end           */
+};
+
+/*
+ * In this table, T_FPTR (pointer to function) should be placed last.
+ */
+static const SIZES  size_table[] = {
+    { T_CHAR,   S_CHAR,     S_PCHAR     },          /* char         */
+    { T_SHORT,  S_SINT,     S_PSINT     },          /* short int    */
+    { T_INT,    S_INT,      S_PINT      },          /* int          */
+    { T_LONG,   S_LINT,     S_PLINT     },          /* long         */
+#if HAVE_LONG_LONG
+    { T_LONGLONG, S_LLINT,  S_PLLINT    },          /* long long    */
+#endif
+    { T_FLOAT,  S_FLOAT,    S_PFLOAT    },          /* float        */
+    { T_DOUBLE, S_DOUBLE,   S_PDOUBLE   },          /* double       */
+    { T_LONGDOUBLE, S_LDOUBLE, S_PLDOUBLE },        /* long double  */
+    { T_FPTR,   0,          S_PFPTR     },          /* int (*())    */
+    { 0,        0,          0           }           /* End of table */
+};
+
+#define is_binary(op)   (FIRST_BINOP <= op && op <= LAST_BINOP)
+#define is_unary(op)    (FIRST_UNOP  <= op && op <= LAST_UNOP)
+
+
+#if MCPP_LIB
+void    init_eval( void)
+{
+    skip = 0;
+}
+#endif
+
+expr_t  eval_if( void)
+/*
+ * Evaluate a #if expression.  Straight-forward operator precedence.
+ * This is called from directive() on encountering an #if directive.
+ * It calls the following routines:
+ * eval_lex()   Lexical analyser -- returns the type and value of
+ *              the next input token.
+ * eval_eval()  Evaluates the current operator, given the values on the
+ *              value stack.  Returns a pointer to the (new) value stack.
+ */
+{
+    VAL_SIGN        value[ NEXP * 2 + 1];   /* Value stack          */
+    OPTAB           opstack[ NEXP * 3 + 1]; /* Operator stack       */
+    int             parens = 0;     /* Nesting levels of (, )       */
+    int             prec;           /* Operator precedence          */
+    int             binop = 0;      /* Set if binary op. needed     */
+    int             op1;            /* Operator from stack          */
+    int             skip_cur;       /* For short-circuit testing    */
+    VAL_SIGN *      valp = value;   /* -> Value and signedness      */
+    OPTAB *         opp = opstack;  /* -> Operator stack            */
+    int             op;             /* Current operator             */
+
+    opp->op = OP_END;               /* Mark bottom of stack         */
+    opp->prec = opdope[ OP_END];    /* And its precedence           */
+    skip = skip_cur = opp->skip = 0;        /* Not skipping now     */
+
+    while (1) {
+        if (mcpp_debug & EXPRESSION)
+            mcpp_fprintf( DBG
+                    , "In eval loop skip = %d, binop = %d, line is: %s\n"
+                    , opp->skip, binop, infile->bptr);
+        skip = opp->skip;
+        op = eval_lex();
+        skip = 0;                   /* Reset to be ready to return  */
+        switch (op) {
+        case OP_SUB :
+            if (binop == 0)
+                op = OP_NEG;                /* Unary minus          */
+            break;
+        case OP_ADD :
+            if (binop == 0)
+                op = OP_PLU;                /* Unary plus           */
+            break;
+        case OP_FAIL:
+            return  0L;                     /* Token error          */
+        }
+        if (mcpp_debug & EXPRESSION)
+            mcpp_fprintf( DBG
+                    , "op = %s, opdope = %04o, binop = %d, skip = %d\n"
+                    , opname[ op], opdope[ op], binop, opp->skip);
+        if (op == VAL) {                    /* Value?               */
+            if (binop != 0) {               /* Binop is needed      */
+                cerror( "Misplaced constant \"%s\""         /* _E_  */
+                        , work_buf, 0L, NULL);
+                return  0L;
+            } else if (& value[ NEXP * 2] <= valp) {
+                cerror( "More than %.0s%ld constants stacked at %s" /* _E_  */
+                        , NULL, (long) (NEXP * 2 - 1), work_buf);
+                return  0L;
+            } else {
+                if (mcpp_debug & EXPRESSION) {
+                    dump_val( "pushing ", &ev);
+                    mcpp_fprintf( DBG, " onto value stack[%d]\n"
+                            , (int)(valp - value));
+                }
+                valp->val = ev.val;
+                (valp++)->sign = ev.sign;
+                binop = 1;  /* Binary operator or so should follow  */
+            }
+            continue;
+        }                                   /* Else operators       */
+        prec = opdope[ op];
+        if (binop != (prec & 1)) {
+            if (op == OP_EOE)
+                cerror( "Unterminated expression"           /* _E_  */
+                        , NULL, 0L, NULL);
+            else
+                cerror( "Operator \"%s\" in incorrect context"      /* _E_  */
+                        , opname[ op], 0L, NULL);
+            return  0L;
+        }
+        binop = (prec & 2) >> 1;            /* Binop should follow? */
+
+        while (1) {
+            if (mcpp_debug & EXPRESSION)
+                mcpp_fprintf( DBG
+                        , "op %s, prec %d, stacked op %s, prec %d, skip %d\n"
+                , opname[ op], prec, opname[ opp->op], opp->prec, opp->skip);
+
+            /* Stack coming sub-expression of higher precedence.    */
+            if (opp->prec < prec) {
+                if (op == OP_LPA) {
+                    prec = OP_RPA_PREC;
+                    if (standard && (warn_level & 4)
+                            && ++parens == std_limits.exp_nest + 1)
+                        cwarn(
+                    "More than %.0s%ld nesting of parens"   /* _W4_ */
+                            , NULL, (long) std_limits.exp_nest, NULL);
+                } else if (op == OP_QUE) {
+                    prec = OP_QUE_PREC;
+                } else if (is_unary( op)) {
+                    prec = OP_UNOP_PREC;
+                }
+                op1 = opp->skip;            /* Save skip for test   */
+                /*
+                 * Push operator onto operator stack.
+                 */
+                opp++;
+                if (& opstack[ NEXP * 3] <= opp) {
+                    cerror(
+            "More than %.0s%ld operators and parens stacked at %s"  /* _E_  */
+                            , NULL, (long) (NEXP * 3 - 1), opname[ op]);
+                    return  0L;
+                }
+                opp->op = op;
+                opp->prec = prec;
+                if (&value[0] < valp)
+                    skip_cur = (valp[-1].val != 0L);
+                                            /* Short-circuit tester */
+                /*
+                 * Do the short-circuit stuff here.  Short-circuiting
+                 * stops automagically when operators are evaluated.
+                 */
+                if ((op == OP_ANA && ! skip_cur)
+                        || (op == OP_ORO && skip_cur)) {
+                    opp->skip = S_ANDOR;    /* And/or skip starts   */
+                    if (skip_cur)           /* Evaluate non-zero    */
+                        valp[-1].val = 1L;  /*   value to 1         */
+                } else if (op == OP_QUE) {  /* Start of ?: operator */
+                    opp->skip = (op1 & S_ANDOR) | (!skip_cur ? S_QUEST : 0);
+                } else if (op == OP_COL) {  /* : inverts S_QUEST    */
+                    opp->skip = (op1 & S_ANDOR)
+                              | (((op1 & S_QUEST) != 0) ? 0 : S_QUEST);
+                } else {                    /* Other operators leave*/
+                    opp->skip = op1;        /*  skipping unchanged. */
+                }
+                if (mcpp_debug & EXPRESSION) {
+                    mcpp_fprintf( DBG, "stacking %s, ", opname[ op]);
+                    if (&value[0] < valp)
+                        dump_val( "valp[-1].val == ", valp - 1);
+                    mcpp_fprintf( DBG, " at %s\n", infile->bptr);
+                    dump_stack( opstack, opp, value, valp);
+                }
+                break;
+            }
+
+            /*
+             * Coming sub-expression is of lower precedence.
+             * Evaluate stacked sub-expression.
+             * Pop operator from operator stack and evaluate it.
+             * End of stack and '(', ')' are specials.
+             */
+            skip_cur = opp->skip;           /* Remember skip value  */
+            switch ((op1 = opp->op)) {      /* Look at stacked op   */
+            case OP_END:                    /* Stack end marker     */
+                if (op == OP_RPA) {         /* No corresponding (   */
+                    cerror( "Excessive \")\"", NULL, 0L, NULL);     /* _E_  */
+                    return  0L;
+                }
+                if (op == OP_EOE)
+                    return  valp[-1].val;   /* Finished ok.         */
+                break;
+            case OP_LPA:                    /* ( on stack           */
+                if (op != OP_RPA) {         /* Matches ) on input?  */
+                    cerror( "Missing \")\"", NULL, 0L, NULL);       /* _E_  */
+                    return  0L;
+                }
+                opp--;                      /* Unstack it           */
+                parens--;                   /* Count down nest level*/
+                break;
+            case OP_QUE:                    /* Evaluate true expr.  */
+                break;
+            case OP_COL:                    /* : on stack           */
+                opp--;                      /* Unstack :            */
+                if (opp->op != OP_QUE) {    /* Matches ? on stack?  */
+                    cerror(
+                    "Misplaced \":\", previous operator is \"%s\""  /* _E_  */
+                            , opname[opp->op], 0L, NULL);
+                    return  0L;
+                }
+                /* Evaluate op1.            Fall through            */
+            default:                        /* Others:              */
+                opp--;                      /* Unstack the operator */
+                if (mcpp_debug & EXPRESSION) {
+                    mcpp_fprintf( DBG, "Stack before evaluation of %s\n"
+                            , opname[ op1]);
+                    dump_stack( opstack, opp, value, valp);
+                }
+                if (op1 == OP_COL)
+                    skip = 0;
+                else
+                    skip = skip_cur;
+                valp = eval_eval( valp, op1);
+                if (valp->sign == VAL_ERROR)
+                    return  0L;     /* Out of range or divide by 0  */
+                valp++;
+                skip = 0;
+                if (mcpp_debug & EXPRESSION) {
+                    mcpp_fprintf( DBG, "Stack after evaluation\n");
+                    dump_stack( opstack, opp, value, valp);
+                }
+            }                               /* op1 switch end       */
+
+            if (op1 == OP_END || op1 == OP_LPA || op1 == OP_QUE)
+                break;                      /* Read another op.     */
+        }                                   /* Stack unwind loop    */
+
+    }
+
+    return  0L;                             /* Never reach here     */
+}
+
+static int  eval_lex( void)
+/*
+ * Return next operator or constant to evaluate.  Called from eval_if().  It 
+ * calls a special-purpose routines for character constants and numeric values:
+ *      eval_char()     called to evaluate 'x'
+ *      eval_num()      called to evaluate numbers
+ * C++98 treats 11 identifier-like tokens as operators.
+ * POST_STD forbids character constants in #if expression.
+ */
+{
+    int     c1;
+    VAL_SIGN *  valp;
+    int     warn = ! skip || (warn_level & 8);
+    int     token_type;
+    int     c;
+
+    ev.sign = SIGNED;                       /* Default signedness   */
+    ev.val = 0L;            /* Default value (on error or 0 value)  */
+    in_if = ! skip; /* Inform to expand_macro() that the macro is   */
+                    /*      in #if line and not skipped expression. */
+    c = skip_ws();
+    if (c == '\n') {
+        unget_ch();
+        return  OP_EOE;                     /* End of expression    */
+    }
+    token_type = get_unexpandable( c, warn);
+    if (standard && macro_line == MACRO_ERROR)
+        return  OP_FAIL;                /* Unterminated macro call  */
+    if (token_type == NO_TOKEN)
+        return  OP_EOE;     /* Only macro(s) expanding to 0-token   */
+
+    switch (token_type) {
+    case NAM:
+        if (standard && str_eq( identifier, "defined")) {   /* defined name */
+            c1 = c = skip_ws();
+            if (c == '(')                   /* Allow defined (name) */
+                c = skip_ws();
+            if (scan_token( c, (workp = work_buf, &workp), work_end) == NAM) {
+                DEFBUF *    defp = look_id( identifier);
+                if (warn) {
+                    ev.val = (defp != NULL);
+                    if ((mcpp_debug & MACRO_CALL) && ! skip && defp)
+                        /* Annotate if the macro is in non-skipped expr.    */
+                        mcpp_fprintf( OUT, "/*%s*/", defp->name);
+                }
+                if (c1 != '(' || skip_ws() == ')')  /* Balanced ?   */
+                    return  VAL;            /* Parsed ok            */
+            }
+            cerror( "Bad defined syntax: %s"                /* _E_  */
+                    , infile->fp ? "" : infile->buffer, 0L, NULL);
+            break;
+        } else if (cplus_val) {
+            if (str_eq( identifier, "true")) {
+                ev.val = 1L;
+                return  VAL;
+            } else if (str_eq( identifier, "false")) {
+                ev.val = 0L;
+                return  VAL;
+            } else if (mcpp_mode != POST_STD
+                    && (openum = id_operator( identifier)) != 0) {
+                /* Identifier-like operator in C++98    */
+                strcpy( work_buf, identifier);
+                return  chk_ops();
+            }
+        } else if (! standard && str_eq( identifier, "sizeof")) {
+            /* sizeof hackery       */
+            return  do_sizeof();            /* Gets own routine     */
+        }
+        /*
+         * The ANSI C Standard says that an undefined symbol
+         * in an #if has the value zero.  We are a bit pickier,
+         * warning except where the programmer was careful to write
+         *          #if defined(foo) ? foo : 0
+         */
+        if ((! skip && (warn_level & 4)) || (skip && (warn_level & 8)))
+            cwarn( "Undefined symbol \"%s\"%.0ld%s" /* _W4_ _W8_    */
+                    , identifier, 0L, skip ? non_eval : ", evaluated to 0");
+        return  VAL;
+    case CHR:                               /* Character constant   */
+    case WCHR:                              /* Wide char constant   */
+        if (mcpp_mode == POST_STD) {
+            cerror( "Can't use a character constant %s"     /* _E_  */
+                    , work_buf, 0L, NULL);
+            break;
+        }
+        valp = eval_char( work_buf);        /* 'valp' points 'ev'   */
+        if (valp->sign == VAL_ERROR)
+            break;
+        if (mcpp_debug & EXPRESSION) {
+            dump_val( "eval_char returns ", &ev);
+            mcpp_fputc( '\n', DBG);
+        }
+        return  VAL;                        /* Return a value       */
+    case STR:                               /* String literal       */
+    case WSTR:                              /* Wide string literal  */
+        cerror(
+    "Can't use a string literal %s", work_buf, 0L, NULL);   /* _E_  */
+        break;
+    case NUM:                               /* Numbers are harder   */
+        valp = eval_num( work_buf);         /* 'valp' points 'ev'   */
+        if (valp->sign == VAL_ERROR)
+            break;
+        if (mcpp_debug & EXPRESSION) {
+            dump_val( "eval_num returns ", &ev);
+            mcpp_fputc( '\n', DBG);
+        }
+        return  VAL;
+    case OPE:                           /* Operator or punctuator   */
+        return  chk_ops();
+
+    default:                                /* Total nonsense       */
+        cerror( "Can't use the character %.0s0x%02lx"       /* _E_  */
+                , NULL, (long) c, NULL);
+        break;
+    }
+
+    return  OP_FAIL;                        /* Any errors           */
+}
+
+static int  chk_ops( void)
+/*
+ * Check the operator.
+ * If it can't be used in #if expression return OP_FAIL
+ * else return openum.
+ */
+{
+    switch (openum) {
+    case OP_STR:    case OP_CAT:    case OP_ELL:
+    case OP_1:      case OP_2:      case OP_3:
+        cerror( "Can't use the operator \"%s\""             /* _E_  */
+                , work_buf, 0L, NULL);
+        return  OP_FAIL;
+    default:
+        return  openum;
+    }
+}
+
+static int  do_sizeof( void)
+/*
+ * Process the sizeof (basic type) operation in an #if string.
+ * Sets ev.val to the size and returns
+ *      VAL             success
+ *      OP_FAIL         bad parse or something.
+ * This routine is never called in STD and POST_STD mode.
+ */
+{
+    const char * const  no_type = "sizeof: No type specified";      /* _E_  */
+    int     warn = ! skip || (warn_level & 8);
+    int     type_end = FALSE;
+    int     typecode = 0;
+    int     token_type = NO_TOKEN;
+    const SIZES *   sizp = NULL;
+
+    if (get_unexpandable( skip_ws(), warn) != OPE || openum != OP_LPA)
+        goto  no_good;                      /* Not '('              */
+
+    /*
+     * Scan off the tokens.
+     */
+
+    while (! type_end) {
+        token_type = get_unexpandable( skip_ws(), warn);
+                                /* Get next token expanding macros  */
+        switch (token_type) {
+        case OPE:
+            if (openum == OP_LPA) {         /* thing (*)() func ptr */
+                if (get_unexpandable( skip_ws(), warn) == OPE
+                        && openum == OP_MUL
+                        && get_unexpandable( skip_ws(), warn) == OPE
+                        && openum == OP_RPA) {      /* (*)          */
+                    if (get_unexpandable( skip_ws(), warn) != OPE
+                            || openum != OP_LPA
+                            || get_unexpandable( skip_ws(), warn) != OPE
+                            || openum != OP_RPA)    /* Not ()       */
+                        goto  no_good;
+                    typecode |= T_FPTR;     /* Function pointer     */
+                } else {                    /* Junk is an error     */
+                    goto  no_good;
+                }
+            } else {                        /* '*' or ')'           */
+                type_end = TRUE;
+            }
+            break;
+        case NAM:                           /* Look for type comb.  */
+            if ((typecode = look_type( typecode)) == 0)
+                return  OP_FAIL;            /* Illegal type or comb.*/
+            break;
+        default:    goto  no_good;          /* Illegal token        */
+        }
+    }                                       /* End of while         */
+
+    /*
+     * We are at the end of the type scan.  Chew off '*' if necessary.
+     */
+    if (token_type == OPE) {
+        if (openum == OP_MUL) {             /* '*'                  */
+            typecode |= T_PTR;
+            if (get_unexpandable( skip_ws(), warn) != OPE)
+                goto  no_good;
+        }
+        if (openum == OP_RPA) {             /* ')'                  */
+            /*
+             * Last syntax check
+             * We assume that all function pointers are the same size:
+             *          sizeof (int (*)()) == sizeof (float (*)())
+             * We assume that signed and unsigned don't change the size:
+             *          sizeof (signed int) == sizeof (unsigned int)
+             */
+            if ((typecode & T_FPTR) != 0) { /* Function pointer     */
+                typecode = T_FPTR | T_PTR;
+            } else {                        /* Var or var * datum   */
+                typecode &= ~(T_SIGNED | T_UNSIGNED);
+#if HAVE_LONG_LONG
+                if ((typecode & (T_SHORT | T_LONG | T_LONGLONG)) != 0)
+#else
+                if ((typecode & (T_SHORT | T_LONG)) != 0)
+#endif
+                    typecode &= ~T_INT;
+            }
+            if ((typecode & ~T_PTR) == 0) {
+                cerror( no_type, NULL, 0L, NULL);
+                return  OP_FAIL;
+            } else {
+                /*
+                 * Exactly one bit (and possibly T_PTR) may be set.
+                 */
+                for (sizp = size_table; sizp->bits != 0; sizp++) {
+                    if ((typecode & ~T_PTR) == sizp->bits) {
+                        ev.val = ((typecode & T_PTR) != 0)
+                                ? sizp->psize : sizp->size;
+                        break;
+                    }
+                }
+            }
+        } else {
+            goto  no_good;
+        }
+    } else {
+        goto  no_good;
+    }
+
+    if (mcpp_debug & EXPRESSION) {
+        if (sizp)
+            mcpp_fprintf( DBG,
+            "sizp->bits:0x%x sizp->size:0x%x sizp->psize:0x%x ev.val:0x%lx\n"
+                    , sizp->bits, sizp->size, sizp->psize
+                    , (unsigned long) ev.val);
+    }
+    return  VAL;
+
+no_good:
+    unget_ch();
+    cerror( "sizeof: Syntax error", NULL, 0L, NULL);        /* _E_  */
+    return  OP_FAIL;
+}
+
+static int  look_type(
+    int     typecode
+)
+{
+    const char * const  unknown_type
+            = "sizeof: Unknown type \"%s\"%.0ld%s";     /* _E_ _W8_ */
+    const char * const  illeg_comb
+    = "sizeof: Illegal type combination with \"%s\"%.0ld%s";    /* _E_ _W8_ */
+    int     token_type;
+    const TYPES *   tp;
+
+    if (str_eq( identifier, "long")) {
+        if ((token_type
+                = get_unexpandable( skip_ws(), !skip || (warn_level & 8)))
+                == NO_TOKEN)
+            return  typecode;
+        if (token_type == NAM) {
+#if HAVE_LONG_LONG
+            if (str_eq( identifier, "long")) {
+                strcpy( work_buf, "long long");
+                goto  basic;
+            }
+#endif
+            if (str_eq( identifier, "double")) {
+                strcpy( work_buf, "long double");
+                goto  basic;
+            }
+        }
+        unget_string( work_buf, NULL);      /* Not long long        */
+        strcpy( work_buf, "long");          /*   nor long double    */
+    }
+
+    /*
+     * Look for this unexpandable token in basic_types.
+     */
+basic:
+    for (tp = basic_types; tp->token_name != NULL; tp++) {
+        if (str_eq( work_buf, tp->token_name))
+            break;
+    }
+
+    if (tp->token_name == NULL) {
+        if (! skip) {
+            cerror( unknown_type, work_buf, 0L, NULL);
+            return  0;
+        } else if (warn_level & 8) {
+            cwarn( unknown_type, work_buf, 0L, non_eval);
+        }
+    }
+    if ((typecode & tp->excluded) != 0) {
+        if (! skip) {
+            cerror( illeg_comb, work_buf, 0L, NULL);
+            return  0;
+        } else if (warn_level & 8) {
+            cwarn( illeg_comb, work_buf, 0L, non_eval);
+        }
+    }
+
+    if (mcpp_debug & EXPRESSION) {
+        if (tp->token_name)
+            mcpp_fprintf( DBG,
+            "sizeof -- typecode:0x%x tp->token_name:\"%s\" tp->type:0x%x\n"
+                    , typecode, tp->token_name, tp->type);
+    }
+    return  typecode |= tp->type;           /* Or in the type bit   */
+}
+
+VAL_SIGN *  eval_num(
+    const char *  nump                      /* Preprocessing number */
+)
+/*
+ * Evaluate number for #if lexical analysis.  Note: eval_num recognizes
+ * the unsigned suffix, but only returns a signed expr_t value, and stores
+ * the signedness to ev.sign, which is set UNSIGNED (== unsigned) if the
+ * value is not in the range of positive (signed) expr_t.
+ */
+{
+    const char * const  not_integer = "Not an integer \"%s\"";      /* _E_  */
+    const char * const  out_of_range
+            = "Constant \"%s\"%.0ld%s is out of range"; /* _E_ _W1_ _W8_    */
+    expr_t          value;
+    uexpr_t         v, v1;  /* unsigned long long or unsigned long  */
+    int             uflag = FALSE;
+    int             lflag = FALSE;
+    int             erange = FALSE;
+    int             base;
+    int             c, c1;
+    const char *    cp = nump;
+#if HAVE_LONG_LONG
+    const char * const  out_of_range_long =
+        "Constant \"%s\"%.0ld%s is out of range "   /* _E_ _W1_ _W2_ _W8_   */
+            "of (unsigned) long";
+    const char * const  ll_suffix =
+"LL suffix is used in other than C99 mode \"%s\"%.0ld%s"; /* _W1_ _W2_ _W8_ */
+#if COMPILER == MSC || COMPILER == BORLANDC
+    const char * const  i64_suffix =
+"I64 suffix is used in other than C99 mode \"%s\"%.0ld%s";  /* _W2_ _W8_    */
+#endif
+    int             llflag = FALSE;
+    int             erange_long = FALSE;
+#endif
+
+    ev.sign = SIGNED;                       /* Default signedness   */
+    ev.val = 0L;                            /* Default value        */
+    if ((char_type[ c = *cp++ & UCHARMAX] & DIG) == 0)   /* Dot     */
+        goto  num_err;
+    if (c != '0') {                         /* Decimal              */
+        base = 10;
+    } else if ((c = *cp++ & UCHARMAX) == 'x' || c == 'X') {
+        base = 16;                          /* Hexadecimal          */
+        c = *cp++ & UCHARMAX;
+    } else if (c == EOS) {                  /* 0                    */
+        return  & ev;
+    } else {                                /* Octal or illegal     */
+        base = 8;
+    }
+
+    v = v1 = 0L;
+    for (;;) {
+        c1 = c;
+        if (isupper( c1))
+            c1 = tolower( c1);
+        if (c1 >= 'a')
+            c1 -= ('a' - 10);
+        else
+            c1 -= '0';
+        if (c1 < 0 || base <= c1)
+            break;
+        v1 *= base;
+        v1 += c1;
+        if (v1 / base < v) {                /* Overflow             */
+            if (! skip)
+                goto  range_err;
+            else
+                erange = TRUE;
+        }
+#if HAVE_LONG_LONG
+        if (! stdc3 && v1 > ULONGMAX)
+            /* Overflow of long or unsigned long    */
+            erange_long = TRUE;
+#endif
+        v = v1;
+        c = *cp++ & UCHARMAX;
+    }
+
+    value = v;
+    while (c == 'u' || c == 'U' || c == 'l' || c == 'L') {
+        if (c == 'u' || c == 'U') {
+            if (uflag)
+                goto  num_err;
+            uflag = TRUE;
+        } else if (c == 'l' || c == 'L') {
+#if HAVE_LONG_LONG
+            if (llflag) {
+                goto  num_err;
+            } else if (lflag) {
+                llflag = TRUE;
+                if (! stdc3 && ((! skip && (warn_level & w_level))
+                        || (skip && (warn_level & 8))))
+                    cwarn( ll_suffix, nump, 0L, skip ? non_eval : NULL);
+            } else {
+                lflag = TRUE;
+            }
+#else
+            if (lflag)
+                goto  num_err;
+            else
+                lflag = TRUE;
+#endif
+        }
+        c = *cp++;
+    }
+#if HAVE_LONG_LONG && (COMPILER == MSC || COMPILER == BORLANDC)
+    if (tolower( c) == 'i') {
+        c1 = atoi( cp);
+        if (c1 == 64) {
+            if (! stdc3 && ((! skip && (warn_level & w_level))
+                    || (skip && (warn_level & 8))))
+                cwarn( i64_suffix, nump, 0L, skip ? non_eval : NULL);
+            cp += 2;
+        } else if (c1 == 32 || c1 == 16) {
+            cp += 2;
+        } else if (c1 == 8) {
+            cp++;
+        }
+        c = *cp++;
+    }
+#endif
+
+    if (c != EOS)
+        goto  num_err;
+
+    if (standard) {
+        if (uflag)      /* If 'U' suffixed, uexpr_t is treated as unsigned  */
+            ev.sign = UNSIGNED;
+        else
+            ev.sign = (value >= 0L);
+#if HAVE_LONG_LONG
+    } else {
+        if (value > LONGMAX)
+            erange_long = TRUE;
+#endif
+    }
+
+    ev.val = value;
+    if (erange && (warn_level & 8))
+        cwarn( out_of_range, nump, 0L, non_eval);
+#if HAVE_LONG_LONG
+    else if (erange_long && ((skip && (warn_level & 8))
+            || (! stdc3 && ! skip && (warn_level & w_level))))
+        cwarn( out_of_range_long, nump, 0L, skip ? non_eval : NULL);
+#endif
+    return  & ev;
+
+range_err:
+    cerror( out_of_range, nump, 0L, NULL);
+    ev.sign = VAL_ERROR;
+    return  & ev;
+num_err:
+    cerror( not_integer, nump, 0L, NULL);
+    ev.sign = VAL_ERROR;
+    return  & ev;
+}
+
+static VAL_SIGN *   eval_char(
+    char * const    token
+)
+/*
+ * Evaluate a character constant.
+ * This routine is never called in POST_STD mode.
+ */
+{
+    const char * const  w_out_of_range
+        = "Wide character constant %s%.0ld%s is out of range";  /* _E_ _W8_ */
+    const char * const  c_out_of_range
+    = "Integer character constant %s%.0ld%s is out of range";   /* _E_ _W8_ */
+    uexpr_t     value;
+    uexpr_t     tmp;
+    expr_t      cl;
+    int         erange = FALSE;
+    int         wide = (*token == 'L');
+    int         ucn8;
+    int         i;
+    int         bits, mbits, u8bits, bits_save;
+    char *      cp = token + 1;         /* Character content        */
+#if HAVE_LONG_LONG
+    const char * const  w_out_of_range_long =
+        "Wide character constant %s%.0ld%s is "     /* _E_ _W1_ _W2_ _W8_   */
+            "out of range of unsigned long";
+    const char * const  c_out_of_range_long =
+        "Integer character constant %s%.0ld%s is "  /* _E_ _W1_ _W2_ _W8_   */
+            "out of range of unsigned long";
+    int         erange_long = FALSE;
+#endif
+
+    bits = CHARBIT;
+    u8bits = CHARBIT * 4;
+    if (mbchar & UTF8)
+        mbits = CHARBIT * 4;
+    else
+        mbits = CHARBIT * 2;
+    if (mcpp_mode == STD && wide) {          /* Wide character constant  */
+        cp++;                           /* Skip 'L'                 */
+        bits = mbits;
+    }
+    if (char_type[ *cp & UCHARMAX] & mbchk) {
+        cl = mb_eval( &cp);
+        bits = mbits;
+    } else if ((cl = eval_one( &cp, wide, mbits, (ucn8 = FALSE, &ucn8)))
+                == -1L) {
+        ev.sign = VAL_ERROR;
+        return  & ev;
+    }
+    bits_save = bits;
+    value = cl;
+
+    for (i = 0; *cp != '\'' && *cp != EOS; i++) {
+        if (char_type[ *cp & UCHARMAX] & mbchk) {
+            cl = mb_eval( &cp);
+            if (cl == 0)
+                /* Shift-out sequence of multi-byte or wide character   */
+                continue;
+            bits = mbits;
+        } else {
+            cl = eval_one( &cp, wide, mbits, (ucn8 = FALSE, &ucn8));
+            if (cl == -1L) {
+                ev.sign = VAL_ERROR;
+                return  & ev;
+            }
+#if OK_UCN
+            if (ucn8 == TRUE)
+                bits = u8bits;
+            else
+                bits = bits_save;
+#endif
+        }
+        tmp = value;
+        value = (value << bits) | cl;   /* Multi-char or multi-byte char    */
+        if ((value >> bits) < tmp) {    /* Overflow                 */
+            if (! skip)
+                goto  range_err;
+            else
+                erange = TRUE;
+        }
+#if HAVE_LONG_LONG
+        if ((mcpp_mode == STD && (! stdc3 && value > ULONGMAX))
+                || (! standard && value > LONGMAX))
+            erange_long = TRUE;
+#endif
+    }
+
+    ev.sign = ((expr_t) value >= 0L);
+    ev.val = value;
+
+    if (erange && skip && (warn_level & 8)) {
+        if (wide)
+            cwarn( w_out_of_range, token, 0L, non_eval);
+        else
+            cwarn( c_out_of_range, token, 0L, non_eval);
+#if HAVE_LONG_LONG
+    } else if (erange_long && ((skip && (warn_level & 8))
+            || (! stdc3 && ! skip && (warn_level & w_level)))) {
+        if (wide)
+            cwarn( w_out_of_range_long, token, 0L, skip ? non_eval : NULL);
+        else
+            cwarn( c_out_of_range_long, token, 0L, skip ? non_eval : NULL);
+#endif
+    }
+
+    if (i == 0)         /* Constant of single (character or wide-character) */
+        return  & ev;
+
+    if ((! skip && (warn_level & 4)) || (skip && (warn_level & 8))) {
+        if (mcpp_mode == STD && wide)
+            cwarn(
+"Multi-character wide character constant %s%.0ld%s isn't portable"  /* _W4_ _W8_    */
+                    , token, 0L, skip ? non_eval : NULL);
+        else
+            cwarn(
+"Multi-character or multi-byte character constant %s%.0ld%s isn't portable" /* _W4_ _W8_    */
+                    , token, 0L, skip ? non_eval : NULL);
+    }
+    return  & ev;
+
+range_err:
+    if (wide)
+        cerror( w_out_of_range, token, 0L, NULL);
+    else
+        cerror( c_out_of_range, token, 0L, NULL);
+    ev.sign = VAL_ERROR;
+    return  & ev;
+}
+
+static expr_t   eval_one(
+    char **     seq_pp,         /* Address of pointer to sequence   */
+                    /* eval_one() advances the pointer to sequence  */
+    int     wide,                       /* Flag of wide-character   */
+    int     mbits,              /* Number of bits of a wide-char    */
+    int *   ucn8                            /* Flag of UCN-32 bits  */
+)
+/*
+ * Called from eval_char() above to get a single character, single multi-
+ * byte character or wide character (with or without \ escapes).
+ * Returns the value of the character or -1L on error.
+ */
+{
+#if OK_UCN
+    const char * const  ucn_malval
+        = "UCN cannot specify the value %.0s\"%08lx\""; /* _E_ _W8_ */
+#endif
+    const char * const  out_of_range
+        = "%s%ld bits can't represent escape sequence '%s'";    /* _E_ _W8_ */
+    uexpr_t         value;
+    int             erange = FALSE;
+    char *          seq = *seq_pp;  /* Initial seq_pp for diagnostic*/
+    const char *    cp;
+    const char *    digits;
+    unsigned        uc;
+    unsigned        uc1;
+    int             count;
+    int             bits;
+    size_t          wchar_max;
+
+    uc = *(*seq_pp)++ & UCHARMAX;
+
+    if (uc != '\\')                 /* Other than escape sequence   */
+        return  (expr_t) uc;
+
+    /* escape sequence  */
+    uc1 = uc = *(*seq_pp)++ & UCHARMAX;
+    switch (uc) {
+    case 'a':
+        return  '\a';
+    case 'b':
+        return  '\b';
+    case 'f':
+        return  '\f';
+    case 'n':
+        return  '\n';
+    case 'r':
+        return  '\r';
+    case 't':
+        return  '\t';
+    case 'v':
+        return  '\v';
+#if OK_UCN
+    case 'u':   case 'U':
+        if (! stdc2)
+            goto  undefined;
+        /* Else Universal character name    */
+        /* Fall through */
+#endif
+    case 'x':                               /* '\xFF'               */
+        if (! standard)
+            goto  undefined;
+        digits = "0123456789abcdef";
+        bits = 4;
+        uc = *(*seq_pp)++ & UCHARMAX;
+        break;
+    case '0': case '1': case '2': case '3':
+    case '4': case '5': case '6': case '7':
+        digits = "01234567";
+        bits = 3;
+        break;
+    case '\'':  case '"':   case '?':   case '\\':
+        return  (expr_t) uc;
+    default:
+        goto  undefined;
+    }
+
+    wchar_max = (UCHARMAX << CHARBIT) | UCHARMAX;
+    if (mbits == CHARBIT * 4) {
+        if (mcpp_mode == STD)
+            wchar_max = (wchar_max << CHARBIT * 2) | wchar_max;
+        else
+            wchar_max = LONGMAX;
+    }
+
+    value = 0L;
+    for (count = 0; ; ++count) {
+        if (isupper( uc))
+            uc = tolower( uc);
+        if ((cp = strchr( digits, uc)) == NULL)
+            break;
+        if (count >= 3 && bits == 3)
+            break;      /* Octal escape sequence at most 3 digits   */
+#if OK_UCN
+        if ((count >= 4 && uc1 == 'u') || (count >= 8 && uc1 == 'U'))
+            break;
+#endif
+        value = (value << bits) | (cp - digits);
+#if OK_UCN
+        if (wchar_max < value && uc1 != 'u' && uc1 != 'U')
+#else
+        if (wchar_max < value)
+#endif
+        {
+            if (! skip)
+                goto  range_err;
+            else
+                erange = TRUE;
+        }
+        uc = *(*seq_pp)++ & UCHARMAX;
+    }
+    (*seq_pp)--;
+
+    if (erange) {
+        value &= wchar_max;
+        goto  range_err;
+    }
+
+    if (count == 0 && bits == 4)            /* '\xnonsense'         */
+        goto  undefined;
+#if OK_UCN
+    if (uc1 == 'u' || uc1 == 'U') {
+        if ((count < 4 && uc1 == 'u') || (count < 8 && uc1 == 'U'))
+            goto  undefined;
+        if ((value >= 0L && value <= 0x9FL
+                    && value != 0x24L && value != 0x40L && value != 0x60L)
+                || (!stdc3 && value >= 0xD800L && value <= 0xDFFFL)) {
+            if (!skip)
+                cerror( ucn_malval, NULL, (long) value, NULL);
+            else if (warn_level & 8)
+                cwarn( ucn_malval, NULL, (long) value, NULL);
+        }
+        if (count >= 8 && uc1 == 'U')
+            *ucn8 = TRUE;
+        return  (expr_t) value;
+    }
+#endif  /* OK_UCN   */
+    if (! wide && (UCHARMAX < value)) {
+        value &= UCHARMAX;
+        goto  range_err;
+    }
+    return  (expr_t) value;
+
+undefined:
+    uc1 = **seq_pp;
+    **seq_pp = EOS;                         /* For diagnostic       */
+    if ((! skip && (warn_level & 1)) || (skip && (warn_level & 8)))
+        cwarn(
+    "Undefined escape sequence%s %.0ld'%s'"         /* _W1_ _W8_    */
+                , skip ? non_eval : NULL, 0L, seq);
+    **seq_pp = uc1;
+    *seq_pp = seq + 1;
+    return  (expr_t) '\\';              /* Returns the escape char  */
+
+range_err:
+    uc1 = **seq_pp;
+    **seq_pp = EOS;                         /* For diagnostic       */
+    if (wide) {
+        if (! skip)
+            cerror( out_of_range, NULL, (long) mbits, seq);
+        else if (warn_level & 8)
+            cwarn( out_of_range, non_eval, (long) mbits, seq);
+    } else {
+        if (! skip)
+            cerror( out_of_range, NULL, (long) CHARBIT, seq);
+        else if (warn_level & 8)
+            cwarn( out_of_range, non_eval, (long) CHARBIT, seq);
+    }
+
+    **seq_pp = uc1;
+    if (! skip)
+        return  -1L;
+    else
+        return  (expr_t) value;
+}
+
+static VAL_SIGN *   eval_eval(
+    VAL_SIGN *  valp,
+    int         op
+)
+/*
+ * One or two values are popped from the value stack and do arithmetic.
+ * The result is pushed onto the value stack.
+ * eval_eval() returns the new pointer to the top of the value stack.
+ */
+{
+    const char * const  zero_div = "%sDivision by zero%.0ld%s"; /* _E_ _W8_ */
+#if HAVE_LONG_LONG
+    const char * const  neg_format =
+"Negative value \"%" LL_FORM "d\" is converted to positive \"%" /* _W1_ _W8_*/
+                    LL_FORM "u\"%%s";
+#else
+    const char * const  neg_format =
+"Negative value \"%ld\" is converted to positive \"%lu\"%%s";   /* _W1_ _W8_*/
+#endif
+    expr_t  v1, v2;
+    int     sign1, sign2;
+
+    if (is_binary( op)) {
+        v2 = (--valp)->val;
+        sign2 = valp->sign;
+    } else {
+        v2 = 0L;                            /* Dummy    */
+        sign2 = SIGNED;                     /* Dummy    */
+    }
+    v1 = (--valp)->val;
+    sign1 = valp->sign;
+    if (mcpp_debug & EXPRESSION) {
+        mcpp_fprintf( DBG, "%s op %s", (is_binary( op)) ? "binary" : "unary"
+                , opname[ op]);
+        dump_val( ", v1 = ", valp);
+        if (is_binary( op))
+            dump_val( ", v2 = ", valp + 1);
+        mcpp_fputc( '\n', DBG);
+    }
+
+    if (standard
+            && (sign1 == UNSIGNED || sign2 == UNSIGNED) && is_binary( op)
+            && op != OP_ANA && op != OP_ORO && op != OP_SR && op != OP_SL) {
+        if (((sign1 == SIGNED && v1 < 0L) || (sign2 == SIGNED && v2 < 0L)
+                ) && ((! skip && (warn_level & 1))
+                    || (skip && (warn_level & 8)))) {
+            char    negate[(((sizeof (expr_t) * 8) / 3) + 1) * 2 + 50];
+            expr_t  v3;
+
+            v3 = (sign1 == SIGNED ? v1 : v2);
+            sprintf( negate, neg_format, v3, v3);
+            cwarn( negate, skip ? non_eval : NULL, 0L, NULL);
+        }
+        valp->sign = sign1 = sign2 = UNSIGNED;
+    }
+    if ((op == OP_SL || op == OP_SR)
+            && ((! skip && (warn_level & 1)) || (skip && (warn_level & 8)))) {
+        if (v2 < 0L || v2 >= sizeof (expr_t) * CHARBIT)
+            cwarn( "Illegal shift count %.0s\"%ld\"%s"      /* _W1_ _W8_    */
+                , NULL, (long) v2, skip ? non_eval : NULL);
+#if HAVE_LONG_LONG
+        else if (! stdc3 && v2 >= sizeof (long) * CHARBIT
+                && ((! skip && (warn_level & w_level))
+                    || (skip && (warn_level & 8))))
+            cwarn(
+"Shift count %.0s\"%ld\" is larger than bit count of long%s"    /* _W1_ _W8_*/
+                , NULL, (long) v2, skip ? non_eval : NULL);
+#endif
+    }
+    if ((op == OP_DIV || op == OP_MOD) && v2 == 0L) {
+        if (! skip) {
+            cerror( zero_div, NULL, 0L, NULL);
+            valp->sign = VAL_ERROR;
+            return  valp;
+        } else {
+            if (warn_level & 8)
+                cwarn( zero_div, NULL, 0L, non_eval);
+            valp->sign = sign1;
+            valp->val = (expr_t) EXPR_MAX;
+            return  valp;
+        }
+    }
+
+    if (! standard || sign1 == SIGNED)
+        v1 = eval_signed( & valp, v1, v2, op);
+    else
+        v1 = eval_unsigned( & valp, (uexpr_t) v1, (uexpr_t) v2, op);
+
+    if (valp->sign == VAL_ERROR)                /* Out of range */
+        return  valp;
+
+    switch (op) {
+    case OP_NOT:    case OP_EQ:     case OP_NE:
+    case OP_LT:     case OP_LE:     case OP_GT:     case OP_GE:
+    case OP_ANA:    case OP_ORO:
+        valp->sign = SIGNED;
+        break;
+    default:
+        valp->sign = sign1;
+        break;
+    }
+    valp->val = v1;
+    return  valp;
+}
+
+static expr_t   eval_signed(
+    VAL_SIGN ** valpp,
+    expr_t      v1,
+    expr_t      v2,
+    int         op
+)
+/*
+ * Apply the argument operator to the signed data.
+ * OP_COL is a special case.
+ */
+{
+    const char * const   illeg_op
+        = "Bug: Illegal operator \"%s\" in eval_signed()";      /* _F_  */
+    const char * const  not_portable
+        = "\"%s\" of negative number isn't portable%.0ld%s";    /* _W1_ _W8_*/
+    const char *    op_name = opname[ op];
+    VAL_SIGN *      valp = *valpp;
+    expr_t  val;
+    int     chk;                /* Flag of overflow in long long    */
+
+    switch (op) {
+    case OP_EOE:
+    case OP_PLU:                        break;
+    case OP_NEG:
+        chk = v1 && v1 == -v1;
+        if (chk
+#if HAVE_LONG_LONG
+                || (! stdc3 && v1 && (long) v1 == (long) -v1)
+#endif 
+            )
+            overflow( op_name, valpp, chk);
+        v1 = -v1;
+        break;
+    case OP_COM:    v1 = ~v1;           break;
+    case OP_NOT:    v1 = !v1;           break;
+    case OP_MUL:
+        val = v1 * v2;
+        chk = v1 && v2 && (val / v1 != v2 || val / v2 != v1);
+        if (chk
+#if HAVE_LONG_LONG
+                || (! stdc3 && v1 && v2
+                    && ((long)val / (long)v1 != (long)v2
+                        || (long)val / (long)v2 != (long)v1))
+#endif
+            )
+            overflow( op_name, valpp, chk);
+        v1 = val;
+        break;
+    case OP_DIV:
+    case OP_MOD:
+        /* Division by 0 has been already diagnosed by eval_eval(). */
+        chk = -v1 == v1 && v2 == -1;
+        if (chk             /* LONG_MIN / -1 on two's complement    */
+#if HAVE_LONG_LONG
+                || (! stdc3
+                    && (long)-v1 == (long)v1 && (long)v2 == (long)-1)
+#endif
+            )
+            overflow( op_name, valpp, chk);
+        else if (! stdc3 && (v1 < 0L || v2 < 0L)
+                && ((! skip && (warn_level & 1))
+                    || (skip && (warn_level & 8))))
+            cwarn( not_portable, op_name, 0L, skip ? non_eval : NULL);
+        if (op == OP_DIV)
+            v1 /= v2;
+        else
+            v1 %= v2;
+        break;
+    case OP_ADD:
+        val = v1 + v2;
+        chk = (v2 > 0L && v1 > val) || (v2 < 0L && v1 < val);
+        if (chk
+#if HAVE_LONG_LONG
+                || (! stdc3
+                    && (((long)v2 > 0L && (long)v1 > (long)val)
+                        || ((long)v2 < 0L && (long)v1 < (long)val)))
+#endif
+            )
+            overflow( op_name, valpp, chk);
+        v1 = val;
+        break;
+    case OP_SUB:
+        val = v1 - v2;
+        chk = (v2 > 0L && val > v1) || (v2 < 0L && val < v1);
+        if (chk
+#if HAVE_LONG_LONG
+                || (! stdc3
+                    && (((long)v2 > 0L && (long)val > (long)v1)
+                        || ((long)v2 < 0L && (long)val < (long)v1)))
+#endif
+            )
+            overflow( op_name, valpp, chk);
+        v1 = val;
+        break;
+    case OP_SL:     v1 <<= v2;          break;
+    case OP_SR:
+        if (v1 < 0L
+                && ((!skip && (warn_level & 1))
+                    || (skip && (warn_level & 8))))
+            cwarn( not_portable, op_name, 0L, skip ? non_eval : NULL);
+        v1 >>= v2;
+        break;
+    case OP_LT:     v1 = (v1 < v2);     break;
+    case OP_LE:     v1 = (v1 <= v2);    break;
+    case OP_GT:     v1 = (v1 > v2);     break;
+    case OP_GE:     v1 = (v1 >= v2);    break;
+    case OP_EQ:     v1 = (v1 == v2);    break;
+    case OP_NE:     v1 = (v1 != v2);    break;
+    case OP_AND:    v1 &= v2;           break;
+    case OP_XOR:    v1 ^= v2;           break;
+    case OP_OR:     v1 |= v2;           break;
+    case OP_ANA:    v1 = (v1 && v2);    break;
+    case OP_ORO:    v1 = (v1 || v2);    break;
+    case OP_COL:
+        /*
+         * If v1 has the "true" value, v2 has the "false" value.
+         * The top of the value stack has the test.
+         */
+        v1 = (--*valpp)->val ? v1 : v2;
+        break;
+    default:
+        cfatal( illeg_op, op_name, 0L, NULL);
+    }
+
+    *valpp = valp;
+    return  v1;
+}
+
+static expr_t   eval_unsigned(
+    VAL_SIGN ** valpp,
+    uexpr_t     v1u,
+    uexpr_t     v2u,
+    int         op
+)
+/*
+ * Apply the argument operator to the unsigned data.
+ * Called from eval_eval() only in Standard mode.
+ */
+{
+    const char * const   illeg_op
+        = "Bug: Illegal operator \"%s\" in eval_unsigned()";    /* _F_  */
+    const char *    op_name = opname[ op];
+    VAL_SIGN *      valp = *valpp;
+    uexpr_t     v1 = 0;
+    int     chk;        /* Flag of overflow in unsigned long long   */
+    int     minus;      /* Big integer converted from signed long   */
+
+    minus = ! stdc3 && (v1u > ULONGMAX || v2u > ULONGMAX);
+
+    switch (op) {
+    case OP_EOE:
+    case OP_PLU:    v1 = v1u;           break;
+    case OP_NEG:
+        v1 = -v1u;
+        if (v1u)
+            overflow( op_name, valpp, TRUE);
+        break;
+    case OP_COM:    v1 = ~v1u;          break;
+    case OP_NOT:    v1 = !v1u;          break;
+    case OP_MUL:
+        v1 = v1u * v2u;
+        chk = v1u && v2u && (v1 / v2u != v1u || v1 / v1u != v2u);
+        if (chk
+#if HAVE_LONG_LONG
+                || (! stdc3 && ! minus && v1 > ULONGMAX)
+#endif
+            )
+            overflow( op_name, valpp, chk);
+        break;
+    case OP_DIV:
+        /* Division by 0 has been already diagnosed by eval_eval().  */
+        v1 = v1u / v2u;
+        break;
+    case OP_MOD:
+        v1 = v1u % v2u;
+        break;
+    case OP_ADD:
+        v1 = v1u + v2u;
+        chk = v1 < v1u;
+        if (chk
+#if HAVE_LONG_LONG
+                || (! stdc3 && ! minus && v1 > ULONGMAX)
+#endif
+            )
+            overflow( op_name, valpp, chk);
+        break;
+    case OP_SUB:
+        v1 = v1u - v2u;
+        chk = v1 > v1u;
+        if (chk
+#if HAVE_LONG_LONG
+                || (! stdc3 && ! minus && v1 > ULONGMAX)
+#endif
+            )
+            overflow( op_name, valpp, chk);
+        break;
+    case OP_SL:     v1 = v1u << v2u;    break;
+    case OP_SR:     v1 = v1u >> v2u;    break;
+    case OP_LT:     v1 = (v1u < v2u);   break;
+    case OP_LE:     v1 = (v1u <= v2u);  break;
+    case OP_GT:     v1 = (v1u > v2u);   break;
+    case OP_GE:     v1 = (v1u >= v2u);  break;
+    case OP_EQ:     v1 = (v1u == v2u);  break;
+    case OP_NE:     v1 = (v1u != v2u);  break;
+    case OP_AND:    v1 = v1u & v2u;     break;
+    case OP_XOR:    v1 = v1u ^ v2u;     break;
+    case OP_OR:     v1 = v1u | v2u;     break;
+    case OP_ANA:    v1 = (v1u && v2u);  break;
+    case OP_ORO:    v1 = (v1u || v2u);  break;
+    case OP_COL:    valp--;
+        if (valp->val)
+            v1 = v1u;
+        else
+            v1 = v2u;
+        break;
+    default:
+        cfatal( illeg_op, op_name, 0L, NULL);
+    }
+
+    *valpp = valp;
+    return  v1;
+}
+
+static void overflow(
+    const char *    op_name,
+    VAL_SIGN ** valpp,
+    int         ll_overflow     /* Flag of overflow in long long    */
+)
+{
+    const char * const  out_of_range
+        = "Result of \"%s\" is out of range%.0ld%s";    /* _E_ _W1_ _W8_    */
+
+#if HAVE_LONG_LONG
+    if (standard && ! ll_overflow) {
+        /* Overflow of long not in C99 mode */
+        if ((! skip && (warn_level & w_level)) || (skip && (warn_level & 8)))
+            cwarn( out_of_range, op_name, 0L, " of (unsigned) long");
+    } else
+#endif
+    if (skip) {
+        if (warn_level & 8)
+            cwarn( out_of_range, op_name, 0L, non_eval);
+        /* Else don't warn  */
+    } else if (standard && (*valpp)->sign == UNSIGNED) {/* Never overflow   */
+        if (warn_level & 1)
+            cwarn( out_of_range, op_name, 0L, NULL);
+    } else {
+        cerror( out_of_range, op_name, 0L, NULL);
+        (*valpp)->sign = VAL_ERROR;
+    }
+}
+
+static void dump_val(
+    const char *        msg,
+    const VAL_SIGN *    valp
+)
+/*
+ * Dump a value by internal representation.
+ */
+{
+#if HAVE_LONG_LONG
+    const char * const  format
+                = "%s(%ssigned long long) 0x%016" LL_FORM "x";
+#else
+    const char * const  format = "%s(%ssigned long) 0x%08lx";
+#endif
+    int     sign = valp->sign;
+
+    mcpp_fprintf( DBG, format, msg, sign ? "" : "un", valp->val);
+}
+
+static void dump_stack(
+    const OPTAB *       opstack,        /* Operator stack               */
+    const OPTAB *       opp,            /* Pointer into operator stack  */
+    const VAL_SIGN *    value,          /* Value stack                  */
+    const VAL_SIGN *    valp            /* -> value vector              */
+)
+/*
+ * Dump stacked operators and values.
+ */
+{
+    if (opstack < opp)
+        mcpp_fprintf( DBG, "Index op prec skip name -- op stack at %s"
+                , infile->bptr);
+
+    while (opstack < opp) {
+        mcpp_fprintf( DBG, " [%2d] %2d %04o    %d %s\n", (int)(opp - opstack)
+                , opp->op, opp->prec, opp->skip, opname[ opp->op]);
+        opp--;
+    }
+
+    while (value <= --valp) {
+        mcpp_fprintf( DBG, "value[%d].val = ", (int)(valp - value));
+        dump_val( "", valp);
+        mcpp_fputc( '\n', DBG);
+    }
+}
+