zeroc-ice 3.6b1 → 3.6.0

data/ext/ice/mcpp/eval.c

@@ -35,12 +35,8 @@
  * 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                     */
@@ -66,10 +62,6 @@ static expr_t   eval_unsigned( VAL_SIGN ** valpp, uexpr_t v1u, uexpr_t v2u
 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
@@ -140,7 +132,7 @@ 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
+#if HAVE_LONG_LONG
     static int  w_level = 1;    /* warn_level at overflow of long   */
 #else
     static int  w_level = 2;
@@ -222,54 +214,14 @@ typedef struct types {
 #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)
 /*
@@ -358,13 +310,13 @@ expr_t  eval_if( void)
             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);
+                , opname[ op], prec, opname[ (int)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)
+                    if ((warn_level & 4)
                             && ++parens == std_limits.exp_nest + 1)
                         cwarn(
                     "More than %.0s%ld nesting of parens"   /* _W4_ */
@@ -448,7 +400,7 @@ expr_t  eval_if( void)
                 if (opp->op != OP_QUE) {    /* Matches ? on stack?  */
                     cerror(
                     "Misplaced \":\", previous operator is \"%s\""  /* _E_  */
-                            , opname[opp->op], 0L, NULL);
+                            , opname[(int)opp->op], 0L, NULL);
                     return  0L;
                 }
                 /* Evaluate op1.            Fall through            */
@@ -509,14 +461,14 @@ static int  eval_lex( void)
         return  OP_EOE;                     /* End of expression    */
     }
     token_type = get_unexpandable( c, warn);
-    if (standard && macro_line == MACRO_ERROR)
+    if (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 */
+        if (str_eq( identifier, "defined")) {   /* defined name */
             c1 = c = skip_ws();
             if (c == '(')                   /* Allow defined (name) */
                 c = skip_ws();
@@ -534,22 +486,6 @@ static int  eval_lex( void)
             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
@@ -563,11 +499,6 @@ static int  eval_lex( void)
         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;
@@ -620,192 +551,6 @@ static int  chk_ops( void)
     }
 }
 
-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 */
 )
@@ -833,10 +578,6 @@ VAL_SIGN *  eval_num(
             "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
@@ -876,7 +617,7 @@ VAL_SIGN *  eval_num(
                 erange = TRUE;
         }
 #if HAVE_LONG_LONG
-        if (! stdc3 && v1 > ULONGMAX)
+        if (v1 > ULONGMAX)
             /* Overflow of long or unsigned long    */
             erange_long = TRUE;
 #endif
@@ -896,7 +637,7 @@ VAL_SIGN *  eval_num(
                 goto  num_err;
             } else if (lflag) {
                 llflag = TRUE;
-                if (! stdc3 && ((! skip && (warn_level & w_level))
+                if (((! skip && (warn_level & w_level))
                         || (skip && (warn_level & 8))))
                     cwarn( ll_suffix, nump, 0L, skip ? non_eval : NULL);
             } else {
@@ -911,44 +652,25 @@ VAL_SIGN *  eval_num(
         }
         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 (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;
+    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))))
+            || (! skip && (warn_level & w_level))))
         cwarn( out_of_range_long, nump, 0L, skip ? non_eval : NULL);
 #endif
     return  & ev;
@@ -982,7 +704,7 @@ static VAL_SIGN *   eval_char(
     int         wide = (*token == 'L');
     int         ucn8;
     int         i;
-    int         bits, mbits, u8bits, bits_save;
+    int         bits, mbits;
     char *      cp = token + 1;         /* Character content        */
 #if HAVE_LONG_LONG
     const char * const  w_out_of_range_long =
@@ -995,12 +717,8 @@ static VAL_SIGN *   eval_char(
 #endif
 
     bits = CHARBIT;
-    u8bits = CHARBIT * 4;
-    if (mbchar & UTF8)
-        mbits = CHARBIT * 4;
-    else
-        mbits = CHARBIT * 2;
-    if (mcpp_mode == STD && wide) {          /* Wide character constant  */
+    mbits = CHARBIT * 4;
+    if (wide) {          /* Wide character constant  */
         cp++;                           /* Skip 'L'                 */
         bits = mbits;
     }
@@ -1012,7 +730,6 @@ static VAL_SIGN *   eval_char(
         ev.sign = VAL_ERROR;
         return  & ev;
     }
-    bits_save = bits;
     value = cl;
 
     for (i = 0; *cp != '\'' && *cp != EOS; i++) {
@@ -1028,12 +745,6 @@ static VAL_SIGN *   eval_char(
                 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    */
@@ -1043,11 +754,6 @@ static VAL_SIGN *   eval_char(
             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);
@@ -1060,7 +766,7 @@ static VAL_SIGN *   eval_char(
             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)))) {
+            || (! skip && (warn_level & w_level)))) {
         if (wide)
             cwarn( w_out_of_range_long, token, 0L, skip ? non_eval : NULL);
         else
@@ -1072,7 +778,7 @@ static VAL_SIGN *   eval_char(
         return  & ev;
 
     if ((! skip && (warn_level & 4)) || (skip && (warn_level & 8))) {
-        if (mcpp_mode == STD && wide)
+        if (wide)
             cwarn(
 "Multi-character wide character constant %s%.0ld%s isn't portable"  /* _W4_ _W8_    */
                     , token, 0L, skip ? non_eval : NULL);
@@ -1105,10 +811,6 @@ static expr_t   eval_one(
  * 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;
@@ -1144,16 +846,7 @@ static expr_t   eval_one(
         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;
@@ -1171,10 +864,7 @@ static expr_t   eval_one(
 
     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;
+        wchar_max = (wchar_max << CHARBIT * 2) | wchar_max;
     }
 
     value = 0L;
@@ -1185,16 +875,8 @@ static expr_t   eval_one(
             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;
@@ -1212,23 +894,6 @@ static expr_t   eval_one(
 
     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;
@@ -1308,8 +973,7 @@ static VAL_SIGN *   eval_eval(
         mcpp_fputc( '\n', DBG);
     }
 
-    if (standard
-            && (sign1 == UNSIGNED || sign2 == UNSIGNED) && is_binary( op)
+    if ((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))
@@ -1329,7 +993,7 @@ static VAL_SIGN *   eval_eval(
             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
+        else if (v2 >= sizeof (long) * CHARBIT
                 && ((! skip && (warn_level & w_level))
                     || (skip && (warn_level & 8))))
             cwarn(
@@ -1351,7 +1015,7 @@ static VAL_SIGN *   eval_eval(
         }
     }
 
-    if (! standard || sign1 == SIGNED)
+    if (sign1 == SIGNED)
         v1 = eval_signed( & valp, v1, v2, op);
     else
         v1 = eval_unsigned( & valp, (uexpr_t) v1, (uexpr_t) v2, op);
@@ -1400,7 +1064,7 @@ static expr_t   eval_signed(
         chk = v1 && v1 == -v1;
         if (chk
 #if HAVE_LONG_LONG
-                || (! stdc3 && v1 && (long) v1 == (long) -v1)
+                || (v1 && (long) v1 == (long) -v1)
 #endif 
             )
             overflow( op_name, valpp, chk);
@@ -1413,7 +1077,7 @@ static expr_t   eval_signed(
         chk = v1 && v2 && (val / v1 != v2 || val / v2 != v1);
         if (chk
 #if HAVE_LONG_LONG
-                || (! stdc3 && v1 && v2
+                || (v1 && v2
                     && ((long)val / (long)v1 != (long)v2
                         || (long)val / (long)v2 != (long)v1))
 #endif
@@ -1427,12 +1091,11 @@ static expr_t   eval_signed(
         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)
+                || ((long)-v1 == (long)v1 && (long)v2 == (long)-1)
 #endif
             )
             overflow( op_name, valpp, chk);
-        else if (! stdc3 && (v1 < 0L || v2 < 0L)
+        else if ((v1 < 0L || v2 < 0L)
                 && ((! skip && (warn_level & 1))
                     || (skip && (warn_level & 8))))
             cwarn( not_portable, op_name, 0L, skip ? non_eval : NULL);
@@ -1446,8 +1109,7 @@ static expr_t   eval_signed(
         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)
                         || ((long)v2 < 0L && (long)v1 < (long)val)))
 #endif
             )
@@ -1459,8 +1121,7 @@ static expr_t   eval_signed(
         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)
                         || ((long)v2 < 0L && (long)val < (long)v1)))
 #endif
             )
@@ -1520,7 +1181,7 @@ static expr_t   eval_unsigned(
     int     chk;        /* Flag of overflow in unsigned long long   */
     int     minus;      /* Big integer converted from signed long   */
 
-    minus = ! stdc3 && (v1u > ULONGMAX || v2u > ULONGMAX);
+    minus = (v1u > ULONGMAX || v2u > ULONGMAX);
 
     switch (op) {
     case OP_EOE:
@@ -1537,7 +1198,7 @@ static expr_t   eval_unsigned(
         chk = v1u && v2u && (v1 / v2u != v1u || v1 / v1u != v2u);
         if (chk
 #if HAVE_LONG_LONG
-                || (! stdc3 && ! minus && v1 > ULONGMAX)
+                || (! minus && v1 > ULONGMAX)
 #endif
             )
             overflow( op_name, valpp, chk);
@@ -1554,7 +1215,7 @@ static expr_t   eval_unsigned(
         chk = v1 < v1u;
         if (chk
 #if HAVE_LONG_LONG
-                || (! stdc3 && ! minus && v1 > ULONGMAX)
+                || (! minus && v1 > ULONGMAX)
 #endif
             )
             overflow( op_name, valpp, chk);
@@ -1564,7 +1225,7 @@ static expr_t   eval_unsigned(
         chk = v1 > v1u;
         if (chk
 #if HAVE_LONG_LONG
-                || (! stdc3 && ! minus && v1 > ULONGMAX)
+                || (! minus && v1 > ULONGMAX)
 #endif
             )
             overflow( op_name, valpp, chk);
@@ -1606,7 +1267,7 @@ static void overflow(
         = "Result of \"%s\" is out of range%.0ld%s";    /* _E_ _W1_ _W8_    */
 
 #if HAVE_LONG_LONG
-    if (standard && ! ll_overflow) {
+    if (! 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");
@@ -1616,7 +1277,7 @@ static void overflow(
         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   */
+    } else if ((*valpp)->sign == UNSIGNED) {/* Never overflow   */
         if (warn_level & 1)
             cwarn( out_of_range, op_name, 0L, NULL);
     } else {
@@ -1660,7 +1321,7 @@ static void dump_stack(
 
     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->op, opp->prec, opp->skip, opname[ (int)opp->op]);
         opp--;
     }