← Back to branch summary

~ubuntu-branches/ubuntu/edgy/mcpp/edgy

« back to all changes in this revision

Viewing changes to src/eval.c

  • Committer: Bazaar Package Importer
  • Author(s): NIIBE Yutaka
  • Date: 2005-04-16 15:58:16 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20050416155816-q9a9ipx724qvf3le
Tags: 2.5-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/eval.c
1
1
/*-
2
 
 * Copyright (c) 1998, 2002-2004 Kiyoshi Matsui <kmatsui@t3.rim.or.jp>
 
2
 * Copyright (c) 1998, 2002-2005 Kiyoshi Matsui <kmatsui@t3.rim.or.jp>
3
3
 * All rights reserved.
4
4
 *
5
5
 * Some parts of this code are derived from the public domain software
92
92
 */
93
93
 
94
94
/*
 
95
 * MCPP Version 2.5
 
96
 * 2005/03      kmatsui
 
97
 *      Absorbed POST_STANDARD into STANDARD and OLD_PREPROCESSOR into
 
98
 *          PRE_STANDARD.
 
99
 *      Changed to use only (signed) long in PRE_STANDARD.
 
100
 */
 
101
 
 
102
/*
95
103
 * The routines to evaluate #if expression are placed here.
96
104
 * Some routines are used also to evaluate the value of numerical tokens.
97
105
 */
98
106
 
99
107
#if PREPROCESSED
100
 
#include    "cpp.H"
 
108
#include    "mcpp.H"
101
109
#else
102
110
#include    "system.H"
103
111
#include    "internal.H"
113
121
 
114
122
static int      eval_lex( void);
115
123
static int      chk_ops( void);
116
 
#if MODE != POST_STANDARD
117
124
static VAL_SIGN *   eval_char( char * const token);
118
125
static expr_t   eval_one( char ** seq_pp, int wide, int mbits, int * ucn8);
119
 
#endif
120
126
static VAL_SIGN *   eval_eval( VAL_SIGN * valp, int op);
121
127
static expr_t   eval_signed( VAL_SIGN ** valpp, expr_t v1, expr_t v2, int op);
122
 
#if HAVE_UNSIGNED_LONG
 
128
#if HAVE_UNSIGNED_LONG && MODE == STANDARD
123
129
static expr_t   eval_unsigned( VAL_SIGN ** valpp, uexpr_t v1u, uexpr_t v2u
124
130
        , int op);
125
131
#endif
138
144
 
139
145
static int      eval_lex();         /* Get type and value of token  */
140
146
static int      chk_ops();          /* Check identifier-like ops    */
141
 
#if MODE != POST_STANDARD
142
147
static VAL_SIGN *   eval_char();    /* Evaluate character constant  */
143
148
static expr_t   eval_one();         /* Evaluate a character         */
144
 
#endif
145
149
static VAL_SIGN *   eval_eval();    /* Entry to #if arithmetic      */
146
150
static expr_t   eval_signed();      /* Do signed arithmetic of expr.*/
147
 
#if HAVE_UNSIGNED_LONG
 
151
#if HAVE_UNSIGNED_LONG && MODE == STANDARD
148
152
static expr_t   eval_unsigned();    /* Do unsigned arithmetic       */
149
153
#endif
150
154
static void     overflow();         /* Diagnose overflow of expr.   */
157
161
static void     dump_stack();       /* Print stacked operators      */
158
162
#endif
159
163
 
160
 
#endif  /* ! PROTO  */
 
164
#endif
161
165
 
162
166
/* For debug and error messages.    */
163
167
static const char * const   opname[ OP_END + 1] = {
249
253
#define S_PDOUBLE   (sizeof (double *))
250
254
#define S_PFPTR     (sizeof (int (*)()))
251
255
#if HAVE_LONG_LONG
 
256
#if COMPILER == BORLANDC
 
257
#define S_LLINT     (sizeof (__int64))
 
258
#define S_PLLINT    (sizeof (__int64 *))
 
259
#else
252
260
#define S_LLINT     (sizeof (long long int))
253
261
#define S_PLLINT    (sizeof (long long int *))
254
262
#endif
 
263
#endif
255
264
#if HAVE_LONG_DOUBLE
256
265
#define S_LDOUBLE   (sizeof (long double))
257
266
#define S_PLDOUBLE  (sizeof (long double *))
281
290
    { T_INT,        "int",          ANYFLOAT | T_CHAR | T_INT },
282
291
    { T_LONG,       "long",         ANYFLOAT | ANYINT },
283
292
#if HAVE_LONG_LONG
 
293
#if COMPILER == BORLANDC
 
294
    { T_LONGLONG,   "__int64",      ANYFLOAT | ANYINT },
 
295
#else
284
296
    { T_LONGLONG,   "long long",    ANYFLOAT | ANYINT },
285
297
#endif
 
298
#endif
286
299
    { T_FLOAT,      "float",        ANYFLOAT | ANYINT | ANYSIGN },
287
300
    { T_DOUBLE,     "double",       ANYFLOAT | ANYINT | ANYSIGN },
288
301
#if HAVE_LONG_DOUBLE
337
350
{
338
351
    VAL_SIGN        value[ NEXP * 2 + 1];   /* Value stack          */
339
352
    OPTAB           opstack[ NEXP * 3 + 1]; /* Operator stack       */
340
 
#if MODE >= STANDARD
 
353
#if MODE == STANDARD
341
354
    int             parens = 0;     /* Nesting levels of (, )       */
342
355
#endif
343
356
    int             prec;           /* Operator precedence          */
427
440
            if (opp->prec < prec) {
428
441
                if (op == OP_LPA) {
429
442
                    prec = OP_RPA_PREC;
430
 
#if MODE >= STANDARD
 
443
#if MODE == STANDARD
431
444
                    if ((warn_level & 4) && ++parens == exp_nest_min + 1)
432
445
                        cwarn(
433
446
                    "More than %.0s%ld nesting of parens"   /* _W4_ */
505
518
                    return  0L;
506
519
                }
507
520
                opp--;                      /* Unstack it           */
508
 
#if MODE >= STANDARD
 
521
#if MODE == STANDARD
509
522
                parens--;                   /* Count down nest level*/
510
523
#endif
511
524
                break;
567
580
 *      eval_char()     called to evaluate 'x'
568
581
 *      eval_num()      called to evaluate numbers
569
582
 * C++98 treats 11 identifier-like tokens as operators.
570
 
 * POST_STANDARD forbids character constants in #if expression.
 
583
 * POST_STD forbids character constants in #if expression.
571
584
 */
572
585
{
573
 
#if MODE >= STANDARD
 
586
#if MODE == STANDARD
574
587
    int     c1;
575
588
#endif
576
589
    VAL_SIGN *  valp;
586
599
        return  OP_EOE;                     /* End of expression    */
587
600
    }
588
601
    token_type = get_unexpandable( c, warn);
589
 
#if MODE >= STANDARD
 
602
#if MODE == STANDARD
590
603
    if (macro_line == MACRO_ERROR)      /* Unterminated macro call  */
591
604
        return  OP_FAIL;
592
605
#endif
595
608
 
596
609
    switch (token_type) {
597
610
    case NAM:
598
 
#if MODE >= STANDARD
 
611
#if MODE == STANDARD
599
612
        if (str_eq( identifier, "defined")) {   /* defined name     */
600
613
            c1 = c = skip_ws();
601
614
            if (c == '(')                   /* Allow defined (name) */
617
630
            } else if (str_eq( identifier, "false")) {
618
631
                ev.val = 0L;
619
632
                return  VAL;
620
 
#if MODE == STANDARD
621
 
            } else if ((openum = id_operator( identifier)) != 0) {
 
633
            } else if (mode != POST_STD
 
634
                    && (openum = id_operator( identifier)) != 0) {
622
635
                /* Identifier-like operator in C++98    */
623
636
                strcpy( work, identifier);
624
637
                return  chk_ops();
625
 
#endif
626
638
            }
627
639
        }
628
 
#endif  /* MODE >= STANDARD     */
 
640
#endif
629
641
#if OK_SIZE
630
 
        if (str_eq( identifier, "sizeof"))  /* sizeof hackery       */
 
642
        if (mode != POST_STD && str_eq( identifier, "sizeof"))
 
643
            /* sizeof hackery       */
631
644
            return  do_sizeof();            /* Gets own routine     */
632
645
#endif
633
646
        /*
641
654
                    , identifier, 0L, skip ? non_eval : ", evaluated to 0");
642
655
        return  VAL;
643
656
    case CHR:                               /* Character constant   */
644
 
#if MODE >= STANDARD
 
657
#if MODE == STANDARD
645
658
    case WCHR:                              /* Wide char constant   */
 
659
        if (mode == POST_STD) {
 
660
            cerror( "Can't use a character constant %s"     /* _E_  */
 
661
                    , work, 0L, NULLST);
 
662
            break;
 
663
        }
646
664
#endif
647
 
#if MODE == POST_STANDARD
648
 
        cerror( "Can't use a character constant %s"         /* _E_  */
649
 
                , work, 0L, NULLST);
650
 
        break;
651
 
#else   /* MODE != POST_STANDARD    */
652
665
        valp = eval_char( work);            /* 'valp' points 'ev'   */
653
666
        if (valp->sign == VAL_ERROR)
654
667
            break;
659
672
        }
660
673
#endif
661
674
        return  VAL;                        /* Return a value       */
662
 
#endif  /* MODE != POST_STANDARD    */
663
675
    case STR:                               /* String literal       */
664
 
#if MODE >= STANDARD
 
676
#if MODE == STANDARD
665
677
    case WSTR:                              /* Wide string literal  */
666
678
#endif
667
679
        cerror( "Can't use a string literal %s", work, 0L, NULLST); /* _E_  */
702
714
 */
703
715
{
704
716
    switch (openum) {
705
 
#if MODE >= STANDARD
 
717
#if MODE == STANDARD
706
718
    case OP_STR:    case OP_CAT:    case OP_ELL:
707
719
#endif
708
720
    case OP_1:      case OP_2:      case OP_3:
727
739
 * Sets ev.val to the size and returns
728
740
 *      VAL             success
729
741
 *      OP_FAIL         bad parse or something.
 
742
 * This routine is never called in POST_STD mode.
730
743
 */
731
744
{
732
745
    const char * const  no_type = "sizeof: No type specified";      /* _E_  */
832
845
                    , sizp->bits, sizp->size, sizp->psize, ev.val);
833
846
    }
834
847
#endif
835
 
#if MODE >= STANDARD
 
848
#if MODE == STANDARD
836
849
    if (warn_level & 8)
837
850
        cwarn( "sizeof is disallowed in Standard"           /* _W8_ */
838
851
                , NULLST, 0L, NULLST);
942
955
    const char * const  out_of_range
943
956
            = "Constant \"%s\"%.0ld%s is out of range"; /* _E_ _W8_ */
944
957
    expr_t          value;
945
 
#if HAVE_UNSIGNED_LONG
 
958
#if HAVE_UNSIGNED_LONG && MODE == STANDARD
946
959
    uexpr_t         v, v1;  /* unsigned long or unsigned long long  */
947
960
#else
948
961
    expr_t          v, v1;                  /* signed long          */
949
962
#endif
950
 
#if MODE >= STANDARD
 
963
#if MODE == STANDARD
951
964
    int             uflag = FALSE;
952
965
#endif
953
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
966
#if HAVE_LONG_LONG && MODE == STANDARD
954
967
    int             llflag = FALSE;
955
968
#endif
956
969
    int             lflag = FALSE;
988
1001
            break;
989
1002
        v1 *= base;
990
1003
        v1 += c1;
991
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
1004
#if HAVE_LONG_LONG && MODE == STANDARD
992
1005
        if (!stdc3) {
993
1006
            if (v1 > ULONGMAX) {
994
1007
                if (! skip)
1020
1033
#endif
1021
1034
        }
1022
1035
        if (c == 'l' || c == 'L') {
1023
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
1036
#if HAVE_LONG_LONG && MODE == STANDARD
1024
1037
            if (llflag) {
1025
1038
                goto  num_err;
1026
1039
            } else if (lflag) {
1048
1061
    if (c != EOS)
1049
1062
        goto  num_err;
1050
1063
 
1051
 
#if HAVE_UNSIGNED_LONG
1052
 
#if MODE >= STANDARD
 
1064
#if HAVE_UNSIGNED_LONG && MODE == STANDARD
1053
1065
    if (uflag)  /* If 'U' suffixed, uexpr_t is treated as unsigned  */
1054
1066
        ev.sign = UNSIGNED;
1055
1067
    else
1062
1074
    }
1063
1075
#else   /* ! HAVE_LONG_LONG */
1064
1076
        ev.sign = (value >= 0L);
1065
 
#endif  /* ! HAVE_LONG_LONG */
1066
 
#else   /* MODE == PRE_STANDARD */
 
1077
#endif
 
1078
#else   /* ! HAVE_UNSIGNED_LONG || MODE == PRE_STANDARD */
1067
1079
    ev.sign = (value >= 0L);
1068
 
#endif  /* MODE == PRE_STANDARD */
1069
 
#endif  /* HAVE_UNSIGNED_LONG   */
 
1080
#endif
1070
1081
 
1071
1082
    ev.val = value;
1072
1083
    if (erange && (warn_level & 8))
1083
1094
    return  & ev;
1084
1095
}
1085
1096
 
1086
 
#if MODE != POST_STANDARD
1087
 
 
1088
1097
static VAL_SIGN *
1089
1098
#if PROTO
1090
1099
eval_char( char * const token)
1094
1103
#endif
1095
1104
/*
1096
1105
 * Evaluate a character constant.
 
1106
 * This routine is never called in POST_STD mode.
1097
1107
 */
1098
1108
{
1099
1109
#if MODE == STANDARD
1102
1112
#endif
1103
1113
    const char * const  c_out_of_range
1104
1114
    = "Integer character constant %s%.0ld%s is out of range";   /* _E_ _W8_ */
1105
 
#if HAVE_UNSIGNED_LONG
 
1115
#if HAVE_UNSIGNED_LONG && MODE == STANDARD
1106
1116
    register uexpr_t    value;
1107
1117
    uexpr_t         tmp;
1108
1118
#else
1119
1129
 
1120
1130
    bits = CHARBIT;
1121
1131
    u8bits = CHARBIT * 4;
1122
 
#if MODE == STANDARD
1123
1132
    if (mbchar & UTF8)
1124
1133
        mbits = CHARBIT * 4;
1125
1134
    else
1126
1135
        mbits = CHARBIT * 2;
 
1136
#if MODE == STANDARD
1127
1137
    if (wide) {                         /* Wide character constant  */
1128
1138
        cp++;                           /* Skip 'L'                 */
1129
1139
        bits = mbits;
1176
1186
        }
1177
1187
    }
1178
1188
 
1179
 
#if HAVE_UNSIGNED_LONG
1180
 
#if HAVE_LONG_LONG && MODE == STANDARD
 
1189
#if HAVE_UNSIGNED_LONG && MODE == STANDARD
 
1190
#if HAVE_LONG_LONG
1181
1191
    if (!stdc3)
1182
1192
        ev.sign = (value <= LONGMAX);
1183
1193
    else
1185
1195
#else
1186
1196
    ev.sign = ((expr_t) value >= 0L);
1187
1197
#endif
 
1198
#else   /* ! HAVE_UNSIGNED_LONG || MODE == PRE_STANDARD */
 
1199
    ev.sign = ((expr_t) value >= 0L);
1188
1200
#endif
1189
1201
    ev.val = value;
1190
1202
 
1257
1269
#endif
1258
1270
    const char * const  out_of_range
1259
1271
        = "%s%ld bits can't represent escape sequence '%s'";    /* _E_ _W8_ */
1260
 
#if HAVE_UNSIGNED_LONG
 
1272
#if HAVE_UNSIGNED_LONG && MODE == STANDARD
1261
1273
    uexpr_t         value;
1262
1274
#else
1263
1275
    expr_t          value;
1394
1406
        value &= UCHARMAX;
1395
1407
        goto  range_err;
1396
1408
    }
1397
 
#endif  /* MODE == PRE_STANDARD */
 
1409
#endif
1398
1410
    return  (expr_t) value;
1399
1411
 
1400
1412
undefined:
1428
1440
        cerror( out_of_range, NULLST, (long) CHARBIT, seq);
1429
1441
    else if (warn_level & 8)
1430
1442
        cwarn( out_of_range, non_eval, (long) CHARBIT, seq);
1431
 
#endif  /* MODE == PRE_STANDARD */
 
1443
#endif
1432
1444
 
1433
1445
    **seq_pp = uc1;
1434
1446
    if (! skip)
1437
1449
        return  (expr_t) value;
1438
1450
}
1439
1451
 
1440
 
#endif  /* MODE != POST_STANDARD    */
1441
 
 
1442
1452
static VAL_SIGN *
1443
1453
#if PROTO
1444
1454
eval_eval( VAL_SIGN * valp, int op)
1456
1466
    const char * const  zero_div = "%sDivision by zero%.0ld%s"; /* _E_ _W8_ */
1457
1467
    const char * const  neg_long =
1458
1468
"Negative value \"%ld\" is converted to positive \"%lu\"%%s";   /* _W1_ _W8_*/
1459
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
1469
#if HAVE_LONG_LONG && MODE == STANDARD
1460
1470
    const char * const  neg_llong =
1461
1471
"Negative value \"%" LL_FORM "d\" is converted to positive \"%" /* _W1_ _W8_*/
1462
1472
                    LL_FORM "u\"%%s";
1484
1494
    }
1485
1495
#endif
1486
1496
 
1487
 
#if HAVE_UNSIGNED_LONG                  /* Usual arithmetic conversion  */
 
1497
#if HAVE_UNSIGNED_LONG && MODE == STANDARD  /* Usual arithmetic conversion  */
1488
1498
    if ((sign1 == UNSIGNED || sign2 == UNSIGNED) && is_binary( op)
1489
1499
            && op != OP_ANA && op != OP_ORO && op != OP_SR && op != OP_SL) {
1490
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
1500
#if HAVE_LONG_LONG
1491
1501
        if (((sign1 == SIGNED && v1 < 0L) || (sign2 == SIGNED && v2 < 0L)
1492
1502
                    || (!stdc3 && ((sign1 == SIGNED && v1 > LONGMAX)
1493
1503
                                 || (sign2 == SIGNED && v2 > LONGMAX)))
1515
1525
            }
1516
1526
            cwarn( negate, skip ? non_eval : NULLST, 0L, NULLST);
1517
1527
        }
1518
 
#else   /* ! HAVE_LONG_LONG || MODE < STANDARD  */
 
1528
#else   /* ! HAVE_LONG_LONG && HAVE_UNSIGNED_LONG && MODE == STANDARD   */
1519
1529
        if (((sign1 == SIGNED && v1 < 0L) || (sign2 == SIGNED && v2 < 0L))
1520
1530
                && ((! skip && (warn_level & 1))
1521
1531
                || (skip && (warn_level & 8)))) {
1525
1535
            sprintf( negate, neg_long, (long) v3, (unsigned long) v3);
1526
1536
            cwarn( negate, skip ? non_eval : NULLST, 0L, NULLST);
1527
1537
        }
1528
 
#endif  /* ! HAVE_LONG_LONG || MODE < STANDARD  */
 
1538
#endif
1529
1539
        valp->sign = sign1 = sign2 = UNSIGNED;
1530
1540
    }
1531
 
#endif  /* HAVE_UNSIGNED_LONG   */
 
1541
#endif
1532
1542
    if ((op == OP_SL || op == OP_SR)
1533
1543
            && (v2 < 0L || v2 >= sizeof (expr_t) * CHARBIT
1534
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
1544
#if HAVE_LONG_LONG && MODE == STANDARD
1535
1545
                || (!stdc3 && v2 >= sizeof (long) * CHARBIT)
1536
1546
#endif
1537
1547
            ) && ((!skip && (warn_level & 1)) || (skip && (warn_level & 8))))
1551
1561
        }
1552
1562
    }
1553
1563
 
1554
 
#if HAVE_UNSIGNED_LONG
 
1564
#if HAVE_UNSIGNED_LONG && MODE == STANDARD
1555
1565
    if (sign1 == SIGNED)
1556
1566
        v1 = eval_signed( & valp, v1, v2, op);
1557
1567
    else
1606
1616
    case OP_PLU:                        break;
1607
1617
    case OP_NEG:
1608
1618
        if ((v1 && v1 == -v1)
1609
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
1619
#if HAVE_LONG_LONG && MODE == STANDARD
1610
1620
                || (!stdc3 && (long) v1 == (long) -v1)
1611
1621
#endif
1612
1622
            )
1619
1629
        val = v1 * v2;
1620
1630
        if (v1 && v2) {
1621
1631
            if ((val / v1 != v2 || val / v2 != v1)
1622
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
1632
#if HAVE_LONG_LONG && MODE == STANDARD
1623
1633
                    || (!stdc3 && ((long)val / (long)v1 != (long)v2
1624
1634
                                 || (long)val / (long)v2 != (long)v1))
1625
1635
#endif
1632
1642
    case OP_MOD:
1633
1643
        /* Division by 0 has been already diagnosed by eval_eval().  */
1634
1644
        if ((-v1 == v1 && v2 == -1)     /* LONG_MIN / -1 on two's complement*/
1635
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
1645
#if HAVE_LONG_LONG && MODE == STANDARD
1636
1646
                || (!stdc3 && (long)-v1 == (long)v1 && (long)v2 == (long)-1)
1637
1647
#endif
1638
1648
            )
1648
1658
    case OP_ADD:
1649
1659
        val = v1 + v2;
1650
1660
        if ((v2 > 0L && v1 > val) || (v2 < 0L && v1 < val)
1651
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
1661
#if HAVE_LONG_LONG && MODE == STANDARD
1652
1662
                || (!stdc3 && (((long)v2 > 0L && (long)v1 > (long)val)
1653
1663
                             || ((long)v2 < 0L && (long)v1 < (long)val)))
1654
1664
#endif
1659
1669
    case OP_SUB:
1660
1670
        val = v1 - v2;
1661
1671
        if (((v2 > 0L && val > v1) || (v2 < 0L && val < v1))
1662
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
1672
#if HAVE_LONG_LONG && MODE == STANDARD
1663
1673
                || (!stdc3 && (((long)v2 > 0L && (long)val > (long)v1)
1664
1674
                             || ((long)v2 < 0L && (long)val < (long)v1)))
1665
1675
#endif
1709
1719
    return  v1;
1710
1720
}
1711
1721
 
1712
 
#if HAVE_UNSIGNED_LONG
 
1722
#if HAVE_UNSIGNED_LONG && MODE == STANDARD
1713
1723
 
1714
1724
static expr_t
1715
1725
#if PROTO
1746
1756
        v1 = v1u * v2u;
1747
1757
        if (v1u && v2u && ((v1 / v2u != v1u
1748
1758
                || v1 / v1u != v2u)
1749
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
1759
#if HAVE_LONG_LONG
1750
1760
                || (!stdc3 && v1 > ULONGMAX)
1751
1761
#endif
1752
1762
            ))
1762
1772
    case OP_ADD:
1763
1773
        v1 = v1u + v2u;
1764
1774
        if ((v1 < v1u)
1765
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
1775
#if HAVE_LONG_LONG
1766
1776
                || (!stdc3 && v1 > ULONGMAX)
1767
1777
#endif
1768
1778
            )
1771
1781
    case OP_SUB:
1772
1782
        v1 = v1u - v2u;
1773
1783
        if ((v1 > v1u)
1774
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
1784
#if HAVE_LONG_LONG
1775
1785
                || (!stdc3 && v1 > ULONGMAX)
1776
1786
#endif
1777
1787
            )
1824
1834
        if (warn_level & 8)
1825
1835
            cwarn( out_of_range, op_name, 0L, non_eval);
1826
1836
        /* Else don't warn  */
1827
 
#if HAVE_UNSIGNED_LONG
 
1837
#if HAVE_UNSIGNED_LONG && MODE == STANDARD
1828
1838
    } else if ((*valpp)->sign == UNSIGNED) {     /* Never overflow  */
1829
1839
        if (warn_level & 1)
1830
1840
            cwarn( out_of_range, op_name, 0L, NULLST);
1849
1859
 * Dump a value by internal representation.
1850
1860
 */
1851
1861
{
1852
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
1862
#if HAVE_LONG_LONG && MODE == STANDARD
1853
1863
    const char * const  format_ll
1854
1864
                = "%s(%ssigned long long) 0x%016" LL_FORM "x";
1855
1865
#endif
1856
1866
    const char * const  format = "%s(%ssigned long) 0x%08lx";
1857
1867
    int     sign = valp->sign;
1858
1868
 
1859
 
#if HAVE_LONG_LONG && MODE >= STANDARD
 
1869
#if HAVE_LONG_LONG && MODE == STANDARD
1860
1870
    if (stdc3) {
1861
1871
        fprintf( fp_debug, format_ll, msg, sign ? "" : "un", valp->val);
1862
1872
    } else {