OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libcpp/] [expr.c] - Blame information for rev 772

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 730 jeremybenn
/* Parse C expressions for cpplib.
2
   Copyright (C) 1987, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
3
   2002, 2004, 2008, 2009, 2010, 2011 Free Software Foundation.
4
   Contributed by Per Bothner, 1994.
5
 
6
This program is free software; you can redistribute it and/or modify it
7
under the terms of the GNU General Public License as published by the
8
Free Software Foundation; either version 3, or (at your option) any
9
later version.
10
 
11
This program is distributed in the hope that it will be useful,
12
but WITHOUT ANY WARRANTY; without even the implied warranty of
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
GNU General Public License for more details.
15
 
16
You should have received a copy of the GNU General Public License
17
along with this program; see the file COPYING3.  If not see
18
<http://www.gnu.org/licenses/>.  */
19
 
20
#include "config.h"
21
#include "system.h"
22
#include "cpplib.h"
23
#include "internal.h"
24
 
25
#define PART_PRECISION (sizeof (cpp_num_part) * CHAR_BIT)
26
#define HALF_MASK (~(cpp_num_part) 0 >> (PART_PRECISION / 2))
27
#define LOW_PART(num_part) (num_part & HALF_MASK)
28
#define HIGH_PART(num_part) (num_part >> (PART_PRECISION / 2))
29
 
30
struct op
31
{
32
  const cpp_token *token;       /* The token forming op (for diagnostics).  */
33
  cpp_num value;                /* The value logically "right" of op.  */
34
  source_location loc;          /* The location of this value.         */
35
  enum cpp_ttype op;
36
};
37
 
38
/* Some simple utility routines on double integers.  */
39
#define num_zerop(num) ((num.low | num.high) == 0)
40
#define num_eq(num1, num2) (num1.low == num2.low && num1.high == num2.high)
41
static bool num_positive (cpp_num, size_t);
42
static bool num_greater_eq (cpp_num, cpp_num, size_t);
43
static cpp_num num_trim (cpp_num, size_t);
44
static cpp_num num_part_mul (cpp_num_part, cpp_num_part);
45
 
46
static cpp_num num_unary_op (cpp_reader *, cpp_num, enum cpp_ttype);
47
static cpp_num num_binary_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
48
static cpp_num num_negate (cpp_num, size_t);
49
static cpp_num num_bitwise_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
50
static cpp_num num_inequality_op (cpp_reader *, cpp_num, cpp_num,
51
                                  enum cpp_ttype);
52
static cpp_num num_equality_op (cpp_reader *, cpp_num, cpp_num,
53
                                enum cpp_ttype);
54
static cpp_num num_mul (cpp_reader *, cpp_num, cpp_num);
55
static cpp_num num_div_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype,
56
                           source_location);
57
static cpp_num num_lshift (cpp_num, size_t, size_t);
58
static cpp_num num_rshift (cpp_num, size_t, size_t);
59
 
60
static cpp_num append_digit (cpp_num, int, int, size_t);
61
static cpp_num parse_defined (cpp_reader *);
62
static cpp_num eval_token (cpp_reader *, const cpp_token *);
63
static struct op *reduce (cpp_reader *, struct op *, enum cpp_ttype);
64
static unsigned int interpret_float_suffix (const uchar *, size_t);
65
static unsigned int interpret_int_suffix (const uchar *, size_t);
66
static void check_promotion (cpp_reader *, const struct op *);
67
 
68
/* Token type abuse to create unary plus and minus operators.  */
69
#define CPP_UPLUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 1))
70
#define CPP_UMINUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 2))
71
 
72
/* With -O2, gcc appears to produce nice code, moving the error
73
   message load and subsequent jump completely out of the main path.  */
74
#define SYNTAX_ERROR(msgid) \
75
  do { cpp_error (pfile, CPP_DL_ERROR, msgid); goto syntax_error; } while(0)
76
#define SYNTAX_ERROR2(msgid, arg) \
77
  do { cpp_error (pfile, CPP_DL_ERROR, msgid, arg); goto syntax_error; } \
78
  while(0)
79
 
80
/* Subroutine of cpp_classify_number.  S points to a float suffix of
81
   length LEN, possibly zero.  Returns 0 for an invalid suffix, or a
82
   flag vector describing the suffix.  */
83
static unsigned int
84
interpret_float_suffix (const uchar *s, size_t len)
85
{
86
  size_t flags;
87
  size_t f, d, l, w, q, i;
88
 
89
  flags = 0;
90
  f = d = l = w = q = i = 0;
91
 
92
  /* Process decimal float suffixes, which are two letters starting
93
     with d or D.  Order and case are significant.  */
94
  if (len == 2 && (*s == 'd' || *s == 'D'))
95
    {
96
      bool uppercase = (*s == 'D');
97
      switch (s[1])
98
      {
99
      case 'f': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_SMALL): 0); break;
100
      case 'F': return (uppercase ? (CPP_N_DFLOAT | CPP_N_SMALL) : 0); break;
101
      case 'd': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_MEDIUM): 0); break;
102
      case 'D': return (uppercase ? (CPP_N_DFLOAT | CPP_N_MEDIUM) : 0); break;
103
      case 'l': return (!uppercase ? (CPP_N_DFLOAT | CPP_N_LARGE) : 0); break;
104
      case 'L': return (uppercase ? (CPP_N_DFLOAT | CPP_N_LARGE) : 0); break;
105
      default:
106
        /* Additional two-character suffixes beginning with D are not
107
           for decimal float constants.  */
108
        break;
109
      }
110
    }
111
 
112
  /* Recognize a fixed-point suffix.  */
113
  switch (s[len-1])
114
    {
115
    case 'k': case 'K': flags = CPP_N_ACCUM; break;
116
    case 'r': case 'R': flags = CPP_N_FRACT; break;
117
    default: break;
118
    }
119
 
120
  /* Continue processing a fixed-point suffix.  The suffix is case
121
     insensitive except for ll or LL.  Order is significant.  */
122
  if (flags)
123
    {
124
      if (len == 1)
125
        return flags;
126
      len--;
127
 
128
      if (*s == 'u' || *s == 'U')
129
        {
130
          flags |= CPP_N_UNSIGNED;
131
          if (len == 1)
132
            return flags;
133
          len--;
134
          s++;
135
        }
136
 
137
      switch (*s)
138
      {
139
      case 'h': case 'H':
140
        if (len == 1)
141
          return flags |= CPP_N_SMALL;
142
        break;
143
      case 'l':
144
        if (len == 1)
145
          return flags |= CPP_N_MEDIUM;
146
        if (len == 2 && s[1] == 'l')
147
          return flags |= CPP_N_LARGE;
148
        break;
149
      case 'L':
150
        if (len == 1)
151
          return flags |= CPP_N_MEDIUM;
152
        if (len == 2 && s[1] == 'L')
153
          return flags |= CPP_N_LARGE;
154
        break;
155
      default:
156
        break;
157
      }
158
      /* Anything left at this point is invalid.  */
159
      return 0;
160
    }
161
 
162
  /* In any remaining valid suffix, the case and order don't matter.  */
163
  while (len--)
164
    switch (s[len])
165
      {
166
      case 'f': case 'F': f++; break;
167
      case 'd': case 'D': d++; break;
168
      case 'l': case 'L': l++; break;
169
      case 'w': case 'W': w++; break;
170
      case 'q': case 'Q': q++; break;
171
      case 'i': case 'I':
172
      case 'j': case 'J': i++; break;
173
      default:
174
        return 0;
175
      }
176
 
177
  if (f + d + l + w + q > 1 || i > 1)
178
    return 0;
179
 
180
  return ((i ? CPP_N_IMAGINARY : 0)
181
          | (f ? CPP_N_SMALL :
182
             d ? CPP_N_MEDIUM :
183
             l ? CPP_N_LARGE :
184
             w ? CPP_N_MD_W :
185
             q ? CPP_N_MD_Q : CPP_N_DEFAULT));
186
}
187
 
188
/* Return the classification flags for a float suffix.  */
189
unsigned int
190
cpp_interpret_float_suffix (const char *s, size_t len)
191
{
192
  return interpret_float_suffix ((const unsigned char *)s, len);
193
}
194
 
195
/* Subroutine of cpp_classify_number.  S points to an integer suffix
196
   of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
197
   flag vector describing the suffix.  */
198
static unsigned int
199
interpret_int_suffix (const uchar *s, size_t len)
200
{
201
  size_t u, l, i;
202
 
203
  u = l = i = 0;
204
 
205
  while (len--)
206
    switch (s[len])
207
      {
208
      case 'u': case 'U':       u++; break;
209
      case 'i': case 'I':
210
      case 'j': case 'J':       i++; break;
211
      case 'l': case 'L':       l++;
212
        /* If there are two Ls, they must be adjacent and the same case.  */
213
        if (l == 2 && s[len] != s[len + 1])
214
          return 0;
215
        break;
216
      default:
217
        return 0;
218
      }
219
 
220
  if (l > 2 || u > 1 || i > 1)
221
    return 0;
222
 
223
  return ((i ? CPP_N_IMAGINARY : 0)
224
          | (u ? CPP_N_UNSIGNED : 0)
225
          | ((l == 0) ? CPP_N_SMALL
226
             : (l == 1) ? CPP_N_MEDIUM : CPP_N_LARGE));
227
}
228
 
229
/* Return the classification flags for an int suffix.  */
230
unsigned int
231
cpp_interpret_int_suffix (const char *s, size_t len)
232
{
233
  return interpret_int_suffix ((const unsigned char *)s, len);
234
}
235
 
236
/* Return the string type corresponding to the the input user-defined string
237
   literal type.  If the input type is not a user-defined string literal
238
   type return the input type.  */
239
enum cpp_ttype
240
cpp_userdef_string_remove_type (enum cpp_ttype type)
241
{
242
  if (type == CPP_STRING_USERDEF)
243
    return CPP_STRING;
244
  else if (type == CPP_WSTRING_USERDEF)
245
    return CPP_WSTRING;
246
  else if (type == CPP_STRING16_USERDEF)
247
    return CPP_STRING16;
248
  else if (type == CPP_STRING32_USERDEF)
249
    return CPP_STRING32;
250
  else if (type == CPP_UTF8STRING_USERDEF)
251
    return CPP_UTF8STRING;
252
  else
253
    return type;
254
}
255
 
256
/* Return the user-defined string literal type corresponding to the input
257
   string type.  If the input type is not a string type return the input
258
   type.  */
259
enum cpp_ttype
260
cpp_userdef_string_add_type (enum cpp_ttype type)
261
{
262
  if (type == CPP_STRING)
263
    return CPP_STRING_USERDEF;
264
  else if (type == CPP_WSTRING)
265
    return CPP_WSTRING_USERDEF;
266
  else if (type == CPP_STRING16)
267
    return CPP_STRING16_USERDEF;
268
  else if (type == CPP_STRING32)
269
    return CPP_STRING32_USERDEF;
270
  else if (type == CPP_UTF8STRING)
271
    return CPP_UTF8STRING_USERDEF;
272
  else
273
    return type;
274
}
275
 
276
/* Return the char type corresponding to the the input user-defined char
277
   literal type.  If the input type is not a user-defined char literal
278
   type return the input type.  */
279
enum cpp_ttype
280
cpp_userdef_char_remove_type (enum cpp_ttype type)
281
{
282
  if (type == CPP_CHAR_USERDEF)
283
    return CPP_CHAR;
284
  else if (type == CPP_WCHAR_USERDEF)
285
    return CPP_WCHAR;
286
  else if (type == CPP_CHAR16_USERDEF)
287
    return CPP_CHAR16;
288
  else if (type == CPP_CHAR32_USERDEF)
289
    return CPP_CHAR32;
290
  else
291
    return type;
292
}
293
 
294
/* Return the user-defined char literal type corresponding to the input
295
   char type.  If the input type is not a char type return the input
296
   type.  */
297
enum cpp_ttype
298
cpp_userdef_char_add_type (enum cpp_ttype type)
299
{
300
  if (type == CPP_CHAR)
301
    return CPP_CHAR_USERDEF;
302
  else if (type == CPP_WCHAR)
303
    return CPP_WCHAR_USERDEF;
304
  else if (type == CPP_CHAR16)
305
    return CPP_CHAR16_USERDEF;
306
  else if (type == CPP_CHAR32)
307
    return CPP_CHAR32_USERDEF;
308
  else
309
    return type;
310
}
311
 
312
/* Return true if the token type is a user-defined string literal.  */
313
bool
314
cpp_userdef_string_p (enum cpp_ttype type)
315
{
316
  if (type == CPP_STRING_USERDEF
317
   || type == CPP_WSTRING_USERDEF
318
   || type == CPP_STRING16_USERDEF
319
   || type == CPP_STRING32_USERDEF
320
   || type == CPP_UTF8STRING_USERDEF)
321
    return true;
322
  else
323
    return false;
324
}
325
 
326
/* Return true if the token type is a user-defined char literal.  */
327
bool
328
cpp_userdef_char_p (enum cpp_ttype type)
329
{
330
  if (type == CPP_CHAR_USERDEF
331
   || type == CPP_WCHAR_USERDEF
332
   || type == CPP_CHAR16_USERDEF
333
   || type == CPP_CHAR32_USERDEF)
334
    return true;
335
  else
336
    return false;
337
}
338
 
339
/* Extract the suffix from a user-defined literal string or char.  */
340
const char *
341
cpp_get_userdef_suffix (const cpp_token *tok)
342
{
343
  unsigned int len = tok->val.str.len;
344
  const char *text = (const char *)tok->val.str.text;
345
  char delim;
346
  unsigned int i;
347
  for (i = 0; i < len; ++i)
348
    if (text[i] == '\'' || text[i] == '"')
349
      break;
350
  if (i == len)
351
    return text + len;
352
  delim = text[i];
353
  for (i = len; i > 0; --i)
354
    if (text[i - 1] == delim)
355
      break;
356
  return text + i;
357
}
358
 
359
/* Categorize numeric constants according to their field (integer,
360
   floating point, or invalid), radix (decimal, octal, hexadecimal),
361
   and type suffixes.  In C++0X if UD_SUFFIX is non null it will be
362
   assigned any unrecognized suffix for a user-defined literal.  */
363
unsigned int
364
cpp_classify_number (cpp_reader *pfile, const cpp_token *token,
365
                     const char **ud_suffix)
366
{
367
  const uchar *str = token->val.str.text;
368
  const uchar *limit;
369
  unsigned int max_digit, result, radix;
370
  enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;
371
  bool seen_digit;
372
 
373
  if (ud_suffix)
374
    *ud_suffix = NULL;
375
 
376
  /* If the lexer has done its job, length one can only be a single
377
     digit.  Fast-path this very common case.  */
378
  if (token->val.str.len == 1)
379
    return CPP_N_INTEGER | CPP_N_SMALL | CPP_N_DECIMAL;
380
 
381
  limit = str + token->val.str.len;
382
  float_flag = NOT_FLOAT;
383
  max_digit = 0;
384
  radix = 10;
385
  seen_digit = false;
386
 
387
  /* First, interpret the radix.  */
388
  if (*str == '0')
389
    {
390
      radix = 8;
391
      str++;
392
 
393
      /* Require at least one hex digit to classify it as hex.  */
394
      if ((*str == 'x' || *str == 'X')
395
          && (str[1] == '.' || ISXDIGIT (str[1])))
396
        {
397
          radix = 16;
398
          str++;
399
        }
400
      else if ((*str == 'b' || *str == 'B') && (str[1] == '0' || str[1] == '1'))
401
        {
402
          radix = 2;
403
          str++;
404
        }
405
    }
406
 
407
  /* Now scan for a well-formed integer or float.  */
408
  for (;;)
409
    {
410
      unsigned int c = *str++;
411
 
412
      if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
413
        {
414
          seen_digit = true;
415
          c = hex_value (c);
416
          if (c > max_digit)
417
            max_digit = c;
418
        }
419
      else if (c == '.')
420
        {
421
          if (float_flag == NOT_FLOAT)
422
            float_flag = AFTER_POINT;
423
          else
424
            SYNTAX_ERROR ("too many decimal points in number");
425
        }
426
      else if ((radix <= 10 && (c == 'e' || c == 'E'))
427
               || (radix == 16 && (c == 'p' || c == 'P')))
428
        {
429
          float_flag = AFTER_EXPON;
430
          break;
431
        }
432
      else
433
        {
434
          /* Start of suffix.  */
435
          str--;
436
          break;
437
        }
438
    }
439
 
440
  /* The suffix may be for decimal fixed-point constants without exponent.  */
441
  if (radix != 16 && float_flag == NOT_FLOAT)
442
    {
443
      result = interpret_float_suffix (str, limit - str);
444
      if ((result & CPP_N_FRACT) || (result & CPP_N_ACCUM))
445
        {
446
          result |= CPP_N_FLOATING;
447
          /* We need to restore the radix to 10, if the radix is 8.  */
448
          if (radix == 8)
449
            radix = 10;
450
 
451
          if (CPP_PEDANTIC (pfile))
452
            cpp_error (pfile, CPP_DL_PEDWARN,
453
                       "fixed-point constants are a GCC extension");
454
          goto syntax_ok;
455
        }
456
      else
457
        result = 0;
458
    }
459
 
460
  if (float_flag != NOT_FLOAT && radix == 8)
461
    radix = 10;
462
 
463
  if (max_digit >= radix)
464
    {
465
      if (radix == 2)
466
        SYNTAX_ERROR2 ("invalid digit \"%c\" in binary constant", '0' + max_digit);
467
      else
468
        SYNTAX_ERROR2 ("invalid digit \"%c\" in octal constant", '0' + max_digit);
469
    }
470
 
471
  if (float_flag != NOT_FLOAT)
472
    {
473
      if (radix == 2)
474
        {
475
          cpp_error (pfile, CPP_DL_ERROR,
476
                     "invalid prefix \"0b\" for floating constant");
477
          return CPP_N_INVALID;
478
        }
479
 
480
      if (radix == 16 && !seen_digit)
481
        SYNTAX_ERROR ("no digits in hexadecimal floating constant");
482
 
483
      if (radix == 16 && CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, c99))
484
        cpp_error (pfile, CPP_DL_PEDWARN,
485
                   "use of C99 hexadecimal floating constant");
486
 
487
      if (float_flag == AFTER_EXPON)
488
        {
489
          if (*str == '+' || *str == '-')
490
            str++;
491
 
492
          /* Exponent is decimal, even if string is a hex float.  */
493
          if (!ISDIGIT (*str))
494
            SYNTAX_ERROR ("exponent has no digits");
495
 
496
          do
497
            str++;
498
          while (ISDIGIT (*str));
499
        }
500
      else if (radix == 16)
501
        SYNTAX_ERROR ("hexadecimal floating constants require an exponent");
502
 
503
      result = interpret_float_suffix (str, limit - str);
504
      if (result == 0)
505
        {
506
          if (CPP_OPTION (pfile, user_literals))
507
            {
508
              if (ud_suffix)
509
                *ud_suffix = (const char *) str;
510
              result = CPP_N_LARGE | CPP_N_USERDEF;
511
            }
512
          else
513
            {
514
              cpp_error (pfile, CPP_DL_ERROR,
515
                         "invalid suffix \"%.*s\" on floating constant",
516
                         (int) (limit - str), str);
517
              return CPP_N_INVALID;
518
            }
519
        }
520
 
521
      /* Traditional C didn't accept any floating suffixes.  */
522
      if (limit != str
523
          && CPP_WTRADITIONAL (pfile)
524
          && ! cpp_sys_macro_p (pfile))
525
        cpp_warning (pfile, CPP_W_TRADITIONAL,
526
                     "traditional C rejects the \"%.*s\" suffix",
527
                     (int) (limit - str), str);
528
 
529
      /* A suffix for double is a GCC extension via decimal float support.
530
         If the suffix also specifies an imaginary value we'll catch that
531
         later.  */
532
      if ((result == CPP_N_MEDIUM) && CPP_PEDANTIC (pfile))
533
        cpp_error (pfile, CPP_DL_PEDWARN,
534
                   "suffix for double constant is a GCC extension");
535
 
536
      /* Radix must be 10 for decimal floats.  */
537
      if ((result & CPP_N_DFLOAT) && radix != 10)
538
        {
539
          cpp_error (pfile, CPP_DL_ERROR,
540
                     "invalid suffix \"%.*s\" with hexadecimal floating constant",
541
                     (int) (limit - str), str);
542
          return CPP_N_INVALID;
543
        }
544
 
545
      if ((result & (CPP_N_FRACT | CPP_N_ACCUM)) && CPP_PEDANTIC (pfile))
546
        cpp_error (pfile, CPP_DL_PEDWARN,
547
                   "fixed-point constants are a GCC extension");
548
 
549
      if ((result & CPP_N_DFLOAT) && CPP_PEDANTIC (pfile))
550
        cpp_error (pfile, CPP_DL_PEDWARN,
551
                   "decimal float constants are a GCC extension");
552
 
553
      result |= CPP_N_FLOATING;
554
    }
555
  else
556
    {
557
      result = interpret_int_suffix (str, limit - str);
558
      if (result == 0)
559
        {
560
          if (CPP_OPTION (pfile, user_literals))
561
            {
562
              if (ud_suffix)
563
                *ud_suffix = (const char *) str;
564
              result = CPP_N_UNSIGNED | CPP_N_LARGE | CPP_N_USERDEF;
565
            }
566
          else
567
            {
568
              cpp_error (pfile, CPP_DL_ERROR,
569
                         "invalid suffix \"%.*s\" on integer constant",
570
                         (int) (limit - str), str);
571
              return CPP_N_INVALID;
572
            }
573
        }
574
 
575
      /* Traditional C only accepted the 'L' suffix.
576
         Suppress warning about 'LL' with -Wno-long-long.  */
577
      if (CPP_WTRADITIONAL (pfile) && ! cpp_sys_macro_p (pfile))
578
        {
579
          int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY));
580
          int large = (result & CPP_N_WIDTH) == CPP_N_LARGE
581
                       && CPP_OPTION (pfile, cpp_warn_long_long);
582
 
583
          if (u_or_i || large)
584
            cpp_warning (pfile, large ? CPP_W_LONG_LONG : CPP_W_TRADITIONAL,
585
                         "traditional C rejects the \"%.*s\" suffix",
586
                         (int) (limit - str), str);
587
        }
588
 
589
      if ((result & CPP_N_WIDTH) == CPP_N_LARGE
590
          && CPP_OPTION (pfile, cpp_warn_long_long))
591
        {
592
          const char *message = CPP_OPTION (pfile, cplusplus)
593
                                ? N_("use of C++0x long long integer constant")
594
                                : N_("use of C99 long long integer constant");
595
 
596
          if (CPP_OPTION (pfile, c99))
597
            cpp_warning (pfile, CPP_W_LONG_LONG, message);
598
          else
599
            cpp_pedwarning (pfile, CPP_W_LONG_LONG, message);
600
        }
601
 
602
      result |= CPP_N_INTEGER;
603
    }
604
 
605
 syntax_ok:
606
  if ((result & CPP_N_IMAGINARY) && CPP_PEDANTIC (pfile))
607
    cpp_error (pfile, CPP_DL_PEDWARN,
608
               "imaginary constants are a GCC extension");
609
  if (radix == 2 && CPP_PEDANTIC (pfile))
610
    cpp_error (pfile, CPP_DL_PEDWARN,
611
               "binary constants are a GCC extension");
612
 
613
  if (radix == 10)
614
    result |= CPP_N_DECIMAL;
615
  else if (radix == 16)
616
    result |= CPP_N_HEX;
617
  else if (radix == 2)
618
    result |= CPP_N_BINARY;
619
  else
620
    result |= CPP_N_OCTAL;
621
 
622
  return result;
623
 
624
 syntax_error:
625
  return CPP_N_INVALID;
626
}
627
 
628
/* cpp_interpret_integer converts an integer constant into a cpp_num,
629
   of precision options->precision.
630
 
631
   We do not provide any interface for decimal->float conversion,
632
   because the preprocessor doesn't need it and we don't want to
633
   drag in GCC's floating point emulator.  */
634
cpp_num
635
cpp_interpret_integer (cpp_reader *pfile, const cpp_token *token,
636
                       unsigned int type)
637
{
638
  const uchar *p, *end;
639
  cpp_num result;
640
 
641
  result.low = 0;
642
  result.high = 0;
643
  result.unsignedp = !!(type & CPP_N_UNSIGNED);
644
  result.overflow = false;
645
 
646
  p = token->val.str.text;
647
  end = p + token->val.str.len;
648
 
649
  /* Common case of a single digit.  */
650
  if (token->val.str.len == 1)
651
    result.low = p[0] - '0';
652
  else
653
    {
654
      cpp_num_part max;
655
      size_t precision = CPP_OPTION (pfile, precision);
656
      unsigned int base = 10, c = 0;
657
      bool overflow = false;
658
 
659
      if ((type & CPP_N_RADIX) == CPP_N_OCTAL)
660
        {
661
          base = 8;
662
          p++;
663
        }
664
      else if ((type & CPP_N_RADIX) == CPP_N_HEX)
665
        {
666
          base = 16;
667
          p += 2;
668
        }
669
      else if ((type & CPP_N_RADIX) == CPP_N_BINARY)
670
        {
671
          base = 2;
672
          p += 2;
673
        }
674
 
675
      /* We can add a digit to numbers strictly less than this without
676
         needing the precision and slowness of double integers.  */
677
      max = ~(cpp_num_part) 0;
678
      if (precision < PART_PRECISION)
679
        max >>= PART_PRECISION - precision;
680
      max = (max - base + 1) / base + 1;
681
 
682
      for (; p < end; p++)
683
        {
684
          c = *p;
685
 
686
          if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
687
            c = hex_value (c);
688
          else
689
            break;
690
 
691
          /* Strict inequality for when max is set to zero.  */
692
          if (result.low < max)
693
            result.low = result.low * base + c;
694
          else
695
            {
696
              result = append_digit (result, c, base, precision);
697
              overflow |= result.overflow;
698
              max = 0;
699
            }
700
        }
701
 
702
      if (overflow && !(type & CPP_N_USERDEF))
703
        cpp_error (pfile, CPP_DL_PEDWARN,
704
                   "integer constant is too large for its type");
705
      /* If too big to be signed, consider it unsigned.  Only warn for
706
         decimal numbers.  Traditional numbers were always signed (but
707
         we still honor an explicit U suffix); but we only have
708
         traditional semantics in directives.  */
709
      else if (!result.unsignedp
710
               && !(CPP_OPTION (pfile, traditional)
711
                    && pfile->state.in_directive)
712
               && !num_positive (result, precision))
713
        {
714
          /* This is for constants within the range of uintmax_t but
715
             not that of intmax_t.  For such decimal constants, a
716
             diagnostic is required for C99 as the selected type must
717
             be signed and not having a type is a constraint violation
718
             (DR#298, TC3), so this must be a pedwarn.  For C90,
719
             unsigned long is specified to be used for a constant that
720
             does not fit in signed long; if uintmax_t has the same
721
             range as unsigned long this means only a warning is
722
             appropriate here.  C90 permits the preprocessor to use a
723
             wider range than unsigned long in the compiler, so if
724
             uintmax_t is wider than unsigned long no diagnostic is
725
             required for such constants in preprocessor #if
726
             expressions and the compiler will pedwarn for such
727
             constants outside the range of unsigned long that reach
728
             the compiler so a diagnostic is not required there
729
             either; thus, pedwarn for C99 but use a plain warning for
730
             C90.  */
731
          if (base == 10)
732
            cpp_error (pfile, (CPP_OPTION (pfile, c99)
733
                               ? CPP_DL_PEDWARN
734
                               : CPP_DL_WARNING),
735
                       "integer constant is so large that it is unsigned");
736
          result.unsignedp = true;
737
        }
738
    }
739
 
740
  return result;
741
}
742
 
743
/* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE.  */
744
static cpp_num
745
append_digit (cpp_num num, int digit, int base, size_t precision)
746
{
747
  cpp_num result;
748
  unsigned int shift;
749
  bool overflow;
750
  cpp_num_part add_high, add_low;
751
 
752
  /* Multiply by 2, 8 or 16.  Catching this overflow here means we don't
753
     need to worry about add_high overflowing.  */
754
  switch (base)
755
    {
756
    case 2:
757
      shift = 1;
758
      break;
759
 
760
    case 16:
761
      shift = 4;
762
      break;
763
 
764
    default:
765
      shift = 3;
766
    }
767
  overflow = !!(num.high >> (PART_PRECISION - shift));
768
  result.high = num.high << shift;
769
  result.low = num.low << shift;
770
  result.high |= num.low >> (PART_PRECISION - shift);
771
  result.unsignedp = num.unsignedp;
772
 
773
  if (base == 10)
774
    {
775
      add_low = num.low << 1;
776
      add_high = (num.high << 1) + (num.low >> (PART_PRECISION - 1));
777
    }
778
  else
779
    add_high = add_low = 0;
780
 
781
  if (add_low + digit < add_low)
782
    add_high++;
783
  add_low += digit;
784
 
785
  if (result.low + add_low < result.low)
786
    add_high++;
787
  if (result.high + add_high < result.high)
788
    overflow = true;
789
 
790
  result.low += add_low;
791
  result.high += add_high;
792
  result.overflow = overflow;
793
 
794
  /* The above code catches overflow of a cpp_num type.  This catches
795
     overflow of the (possibly shorter) target precision.  */
796
  num.low = result.low;
797
  num.high = result.high;
798
  result = num_trim (result, precision);
799
  if (!num_eq (result, num))
800
    result.overflow = true;
801
 
802
  return result;
803
}
804
 
805
/* Handle meeting "defined" in a preprocessor expression.  */
806
static cpp_num
807
parse_defined (cpp_reader *pfile)
808
{
809
  cpp_num result;
810
  int paren = 0;
811
  cpp_hashnode *node = 0;
812
  const cpp_token *token;
813
  cpp_context *initial_context = pfile->context;
814
 
815
  /* Don't expand macros.  */
816
  pfile->state.prevent_expansion++;
817
 
818
  token = cpp_get_token (pfile);
819
  if (token->type == CPP_OPEN_PAREN)
820
    {
821
      paren = 1;
822
      token = cpp_get_token (pfile);
823
    }
824
 
825
  if (token->type == CPP_NAME)
826
    {
827
      node = token->val.node.node;
828
      if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)
829
        {
830
          cpp_error (pfile, CPP_DL_ERROR, "missing ')' after \"defined\"");
831
          node = 0;
832
        }
833
    }
834
  else
835
    {
836
      cpp_error (pfile, CPP_DL_ERROR,
837
                 "operator \"defined\" requires an identifier");
838
      if (token->flags & NAMED_OP)
839
        {
840
          cpp_token op;
841
 
842
          op.flags = 0;
843
          op.type = token->type;
844
          cpp_error (pfile, CPP_DL_ERROR,
845
                     "(\"%s\" is an alternative token for \"%s\" in C++)",
846
                     cpp_token_as_text (pfile, token),
847
                     cpp_token_as_text (pfile, &op));
848
        }
849
    }
850
 
851
  if (node)
852
    {
853
      if (pfile->context != initial_context && CPP_PEDANTIC (pfile))
854
        cpp_error (pfile, CPP_DL_WARNING,
855
                   "this use of \"defined\" may not be portable");
856
 
857
      _cpp_mark_macro_used (node);
858
      if (!(node->flags & NODE_USED))
859
        {
860
          node->flags |= NODE_USED;
861
          if (node->type == NT_MACRO)
862
            {
863
              if ((node->flags & NODE_BUILTIN)
864
                  && pfile->cb.user_builtin_macro)
865
                pfile->cb.user_builtin_macro (pfile, node);
866
              if (pfile->cb.used_define)
867
                pfile->cb.used_define (pfile, pfile->directive_line, node);
868
            }
869
          else
870
            {
871
              if (pfile->cb.used_undef)
872
                pfile->cb.used_undef (pfile, pfile->directive_line, node);
873
            }
874
        }
875
 
876
      /* A possible controlling macro of the form #if !defined ().
877
         _cpp_parse_expr checks there was no other junk on the line.  */
878
      pfile->mi_ind_cmacro = node;
879
    }
880
 
881
  pfile->state.prevent_expansion--;
882
 
883
  /* Do not treat conditional macros as being defined.  This is due to the
884
     powerpc and spu ports using conditional macros for 'vector', 'bool', and
885
     'pixel' to act as conditional keywords.  This messes up tests like #ifndef
886
     bool.  */
887
  result.unsignedp = false;
888
  result.high = 0;
889
  result.overflow = false;
890
  result.low = (node && node->type == NT_MACRO
891
                && (node->flags & NODE_CONDITIONAL) == 0);
892
  return result;
893
}
894
 
895
/* Convert a token into a CPP_NUMBER (an interpreted preprocessing
896
   number or character constant, or the result of the "defined" or "#"
897
   operators).  */
898
static cpp_num
899
eval_token (cpp_reader *pfile, const cpp_token *token)
900
{
901
  cpp_num result;
902
  unsigned int temp;
903
  int unsignedp = 0;
904
 
905
  result.unsignedp = false;
906
  result.overflow = false;
907
 
908
  switch (token->type)
909
    {
910
    case CPP_NUMBER:
911
      temp = cpp_classify_number (pfile, token, NULL);
912
      if (temp & CPP_N_USERDEF)
913
        cpp_error (pfile, CPP_DL_ERROR,
914
                   "user-defined literal in preprocessor expression");
915
      switch (temp & CPP_N_CATEGORY)
916
        {
917
        case CPP_N_FLOATING:
918
          cpp_error (pfile, CPP_DL_ERROR,
919
                     "floating constant in preprocessor expression");
920
          break;
921
        case CPP_N_INTEGER:
922
          if (!(temp & CPP_N_IMAGINARY))
923
            return cpp_interpret_integer (pfile, token, temp);
924
          cpp_error (pfile, CPP_DL_ERROR,
925
                     "imaginary number in preprocessor expression");
926
          break;
927
 
928
        case CPP_N_INVALID:
929
          /* Error already issued.  */
930
          break;
931
        }
932
      result.high = result.low = 0;
933
      break;
934
 
935
    case CPP_WCHAR:
936
    case CPP_CHAR:
937
    case CPP_CHAR16:
938
    case CPP_CHAR32:
939
      {
940
        cppchar_t cc = cpp_interpret_charconst (pfile, token,
941
                                                &temp, &unsignedp);
942
 
943
        result.high = 0;
944
        result.low = cc;
945
        /* Sign-extend the result if necessary.  */
946
        if (!unsignedp && (cppchar_signed_t) cc < 0)
947
          {
948
            if (PART_PRECISION > BITS_PER_CPPCHAR_T)
949
              result.low |= ~(~(cpp_num_part) 0
950
                              >> (PART_PRECISION - BITS_PER_CPPCHAR_T));
951
            result.high = ~(cpp_num_part) 0;
952
            result = num_trim (result, CPP_OPTION (pfile, precision));
953
          }
954
      }
955
      break;
956
 
957
    case CPP_NAME:
958
      if (token->val.node.node == pfile->spec_nodes.n_defined)
959
        return parse_defined (pfile);
960
      else if (CPP_OPTION (pfile, cplusplus)
961
               && (token->val.node.node == pfile->spec_nodes.n_true
962
                   || token->val.node.node == pfile->spec_nodes.n_false))
963
        {
964
          result.high = 0;
965
          result.low = (token->val.node.node == pfile->spec_nodes.n_true);
966
        }
967
      else
968
        {
969
          result.high = 0;
970
          result.low = 0;
971
          if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
972
            cpp_warning (pfile, CPP_W_UNDEF, "\"%s\" is not defined",
973
                         NODE_NAME (token->val.node.node));
974
        }
975
      break;
976
 
977
    case CPP_HASH:
978
      if (!pfile->state.skipping)
979
        {
980
          /* A pedantic warning takes precedence over a deprecated
981
             warning here.  */
982
          if (CPP_PEDANTIC (pfile))
983
            cpp_error (pfile, CPP_DL_PEDWARN,
984
                       "assertions are a GCC extension");
985
          else if (CPP_OPTION (pfile, cpp_warn_deprecated))
986
            cpp_warning (pfile, CPP_W_DEPRECATED,
987
                         "assertions are a deprecated extension");
988
        }
989
      _cpp_test_assertion (pfile, &temp);
990
      result.high = 0;
991
      result.low = temp;
992
      break;
993
 
994
    default:
995
      abort ();
996
    }
997
 
998
  result.unsignedp = !!unsignedp;
999
  return result;
1000
}
1001
 
1002
/* Operator precedence and flags table.
1003
 
1004
After an operator is returned from the lexer, if it has priority less
1005
than the operator on the top of the stack, we reduce the stack by one
1006
operator and repeat the test.  Since equal priorities do not reduce,
1007
this is naturally right-associative.
1008
 
1009
We handle left-associative operators by decrementing the priority of
1010
just-lexed operators by one, but retaining the priority of operators
1011
already on the stack.
1012
 
1013
The remaining cases are '(' and ')'.  We handle '(' by skipping the
1014
reduction phase completely.  ')' is given lower priority than
1015
everything else, including '(', effectively forcing a reduction of the
1016
parenthesized expression.  If there is a matching '(', the routine
1017
reduce() exits immediately.  If the normal exit route sees a ')', then
1018
there cannot have been a matching '(' and an error message is output.
1019
 
1020
The parser assumes all shifted operators require a left operand unless
1021
the flag NO_L_OPERAND is set.  These semantics are automatic; any
1022
extra semantics need to be handled with operator-specific code.  */
1023
 
1024
/* Flags.  If CHECK_PROMOTION, we warn if the effective sign of an
1025
   operand changes because of integer promotions.  */
1026
#define NO_L_OPERAND    (1 << 0)
1027
#define LEFT_ASSOC      (1 << 1)
1028
#define CHECK_PROMOTION (1 << 2)
1029
 
1030
/* Operator to priority map.  Must be in the same order as the first
1031
   N entries of enum cpp_ttype.  */
1032
static const struct cpp_operator
1033
{
1034
  uchar prio;
1035
  uchar flags;
1036
} optab[] =
1037
{
1038
  /* EQ */              {0, 0},   /* Shouldn't happen.  */
1039
  /* NOT */             {16, NO_L_OPERAND},
1040
  /* GREATER */         {12, LEFT_ASSOC | CHECK_PROMOTION},
1041
  /* LESS */            {12, LEFT_ASSOC | CHECK_PROMOTION},
1042
  /* PLUS */            {14, LEFT_ASSOC | CHECK_PROMOTION},
1043
  /* MINUS */           {14, LEFT_ASSOC | CHECK_PROMOTION},
1044
  /* MULT */            {15, LEFT_ASSOC | CHECK_PROMOTION},
1045
  /* DIV */             {15, LEFT_ASSOC | CHECK_PROMOTION},
1046
  /* MOD */             {15, LEFT_ASSOC | CHECK_PROMOTION},
1047
  /* AND */             {9, LEFT_ASSOC | CHECK_PROMOTION},
1048
  /* OR */              {7, LEFT_ASSOC | CHECK_PROMOTION},
1049
  /* XOR */             {8, LEFT_ASSOC | CHECK_PROMOTION},
1050
  /* RSHIFT */          {13, LEFT_ASSOC},
1051
  /* LSHIFT */          {13, LEFT_ASSOC},
1052
 
1053
  /* COMPL */           {16, NO_L_OPERAND},
1054
  /* AND_AND */         {6, LEFT_ASSOC},
1055
  /* OR_OR */           {5, LEFT_ASSOC},
1056
  /* Note that QUERY, COLON, and COMMA must have the same precedence.
1057
     However, there are some special cases for these in reduce().  */
1058
  /* QUERY */           {4, 0},
1059
  /* COLON */           {4, LEFT_ASSOC | CHECK_PROMOTION},
1060
  /* COMMA */           {4, LEFT_ASSOC},
1061
  /* OPEN_PAREN */      {1, NO_L_OPERAND},
1062
  /* CLOSE_PAREN */     {0, 0},
1063
  /* EOF */             {0, 0},
1064
  /* EQ_EQ */           {11, LEFT_ASSOC},
1065
  /* NOT_EQ */          {11, LEFT_ASSOC},
1066
  /* GREATER_EQ */      {12, LEFT_ASSOC | CHECK_PROMOTION},
1067
  /* LESS_EQ */         {12, LEFT_ASSOC | CHECK_PROMOTION},
1068
  /* UPLUS */           {16, NO_L_OPERAND},
1069
  /* UMINUS */          {16, NO_L_OPERAND}
1070
};
1071
 
1072
/* Parse and evaluate a C expression, reading from PFILE.
1073
   Returns the truth value of the expression.
1074
 
1075
   The implementation is an operator precedence parser, i.e. a
1076
   bottom-up parser, using a stack for not-yet-reduced tokens.
1077
 
1078
   The stack base is op_stack, and the current stack pointer is 'top'.
1079
   There is a stack element for each operator (only), and the most
1080
   recently pushed operator is 'top->op'.  An operand (value) is
1081
   stored in the 'value' field of the stack element of the operator
1082
   that precedes it.  */
1083
bool
1084
_cpp_parse_expr (cpp_reader *pfile, bool is_if)
1085
{
1086
  struct op *top = pfile->op_stack;
1087
  unsigned int lex_count;
1088
  bool saw_leading_not, want_value = true;
1089
 
1090
  pfile->state.skip_eval = 0;
1091
 
1092
  /* Set up detection of #if ! defined().  */
1093
  pfile->mi_ind_cmacro = 0;
1094
  saw_leading_not = false;
1095
  lex_count = 0;
1096
 
1097
  /* Lowest priority operator prevents further reductions.  */
1098
  top->op = CPP_EOF;
1099
 
1100
  for (;;)
1101
    {
1102
      struct op op;
1103
 
1104
      lex_count++;
1105
      op.token = cpp_get_token (pfile);
1106
      op.op = op.token->type;
1107
      op.loc = op.token->src_loc;
1108
 
1109
      switch (op.op)
1110
        {
1111
          /* These tokens convert into values.  */
1112
        case CPP_NUMBER:
1113
        case CPP_CHAR:
1114
        case CPP_WCHAR:
1115
        case CPP_CHAR16:
1116
        case CPP_CHAR32:
1117
        case CPP_NAME:
1118
        case CPP_HASH:
1119
          if (!want_value)
1120
            SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
1121
                           cpp_token_as_text (pfile, op.token));
1122
          want_value = false;
1123
          top->value = eval_token (pfile, op.token);
1124
          continue;
1125
 
1126
        case CPP_NOT:
1127
          saw_leading_not = lex_count == 1;
1128
          break;
1129
        case CPP_PLUS:
1130
          if (want_value)
1131
            op.op = CPP_UPLUS;
1132
          break;
1133
        case CPP_MINUS:
1134
          if (want_value)
1135
            op.op = CPP_UMINUS;
1136
          break;
1137
 
1138
        default:
1139
          if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
1140
            SYNTAX_ERROR2 ("token \"%s\" is not valid in preprocessor expressions",
1141
                           cpp_token_as_text (pfile, op.token));
1142
          break;
1143
        }
1144
 
1145
      /* Check we have a value or operator as appropriate.  */
1146
      if (optab[op.op].flags & NO_L_OPERAND)
1147
        {
1148
          if (!want_value)
1149
            SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
1150
                           cpp_token_as_text (pfile, op.token));
1151
        }
1152
      else if (want_value)
1153
        {
1154
          /* We want a number (or expression) and haven't got one.
1155
             Try to emit a specific diagnostic.  */
1156
          if (op.op == CPP_CLOSE_PAREN && top->op == CPP_OPEN_PAREN)
1157
            SYNTAX_ERROR ("missing expression between '(' and ')'");
1158
 
1159
          if (op.op == CPP_EOF && top->op == CPP_EOF)
1160
            SYNTAX_ERROR2 ("%s with no expression", is_if ? "#if" : "#elif");
1161
 
1162
          if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
1163
            SYNTAX_ERROR2 ("operator '%s' has no right operand",
1164
                           cpp_token_as_text (pfile, top->token));
1165
          else if (op.op == CPP_CLOSE_PAREN || op.op == CPP_EOF)
1166
            /* Complain about missing paren during reduction.  */;
1167
          else
1168
            SYNTAX_ERROR2 ("operator '%s' has no left operand",
1169
                           cpp_token_as_text (pfile, op.token));
1170
        }
1171
 
1172
      top = reduce (pfile, top, op.op);
1173
      if (!top)
1174
        goto syntax_error;
1175
 
1176
      if (op.op == CPP_EOF)
1177
        break;
1178
 
1179
      switch (op.op)
1180
        {
1181
        case CPP_CLOSE_PAREN:
1182
          continue;
1183
        case CPP_OR_OR:
1184
          if (!num_zerop (top->value))
1185
            pfile->state.skip_eval++;
1186
          break;
1187
        case CPP_AND_AND:
1188
        case CPP_QUERY:
1189
          if (num_zerop (top->value))
1190
            pfile->state.skip_eval++;
1191
          break;
1192
        case CPP_COLON:
1193
          if (top->op != CPP_QUERY)
1194
            SYNTAX_ERROR (" ':' without preceding '?'");
1195
          if (!num_zerop (top[-1].value)) /* Was '?' condition true?  */
1196
            pfile->state.skip_eval++;
1197
          else
1198
            pfile->state.skip_eval--;
1199
        default:
1200
          break;
1201
        }
1202
 
1203
      want_value = true;
1204
 
1205
      /* Check for and handle stack overflow.  */
1206
      if (++top == pfile->op_limit)
1207
        top = _cpp_expand_op_stack (pfile);
1208
 
1209
      top->op = op.op;
1210
      top->token = op.token;
1211
      top->loc = op.token->src_loc;
1212
    }
1213
 
1214
  /* The controlling macro expression is only valid if we called lex 3
1215
     times: <!> <defined expression> and <EOF>.  push_conditional ()
1216
     checks that we are at top-of-file.  */
1217
  if (pfile->mi_ind_cmacro && !(saw_leading_not && lex_count == 3))
1218
    pfile->mi_ind_cmacro = 0;
1219
 
1220
  if (top != pfile->op_stack)
1221
    {
1222
      cpp_error (pfile, CPP_DL_ICE, "unbalanced stack in %s",
1223
                 is_if ? "#if" : "#elif");
1224
    syntax_error:
1225
      return false;  /* Return false on syntax error.  */
1226
    }
1227
 
1228
  return !num_zerop (top->value);
1229
}
1230
 
1231
/* Reduce the operator / value stack if possible, in preparation for
1232
   pushing operator OP.  Returns NULL on error, otherwise the top of
1233
   the stack.  */
1234
static struct op *
1235
reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
1236
{
1237
  unsigned int prio;
1238
 
1239
  if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
1240
    {
1241
    bad_op:
1242
      cpp_error (pfile, CPP_DL_ICE, "impossible operator '%u'", top->op);
1243
      return 0;
1244
    }
1245
 
1246
  if (op == CPP_OPEN_PAREN)
1247
    return top;
1248
 
1249
  /* Decrement the priority of left-associative operators to force a
1250
     reduction with operators of otherwise equal priority.  */
1251
  prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC) != 0);
1252
  while (prio < optab[top->op].prio)
1253
    {
1254
      if (CPP_OPTION (pfile, warn_num_sign_change)
1255
          && optab[top->op].flags & CHECK_PROMOTION)
1256
        check_promotion (pfile, top);
1257
 
1258
      switch (top->op)
1259
        {
1260
        case CPP_UPLUS:
1261
        case CPP_UMINUS:
1262
        case CPP_NOT:
1263
        case CPP_COMPL:
1264
          top[-1].value = num_unary_op (pfile, top->value, top->op);
1265
          top[-1].loc = top->loc;
1266
          break;
1267
 
1268
        case CPP_PLUS:
1269
        case CPP_MINUS:
1270
        case CPP_RSHIFT:
1271
        case CPP_LSHIFT:
1272
        case CPP_COMMA:
1273
          top[-1].value = num_binary_op (pfile, top[-1].value,
1274
                                         top->value, top->op);
1275
          top[-1].loc = top->loc;
1276
          break;
1277
 
1278
        case CPP_GREATER:
1279
        case CPP_LESS:
1280
        case CPP_GREATER_EQ:
1281
        case CPP_LESS_EQ:
1282
          top[-1].value
1283
            = num_inequality_op (pfile, top[-1].value, top->value, top->op);
1284
          top[-1].loc = top->loc;
1285
          break;
1286
 
1287
        case CPP_EQ_EQ:
1288
        case CPP_NOT_EQ:
1289
          top[-1].value
1290
            = num_equality_op (pfile, top[-1].value, top->value, top->op);
1291
          top[-1].loc = top->loc;
1292
          break;
1293
 
1294
        case CPP_AND:
1295
        case CPP_OR:
1296
        case CPP_XOR:
1297
          top[-1].value
1298
            = num_bitwise_op (pfile, top[-1].value, top->value, top->op);
1299
          top[-1].loc = top->loc;
1300
          break;
1301
 
1302
        case CPP_MULT:
1303
          top[-1].value = num_mul (pfile, top[-1].value, top->value);
1304
          top[-1].loc = top->loc;
1305
          break;
1306
 
1307
        case CPP_DIV:
1308
        case CPP_MOD:
1309
          top[-1].value = num_div_op (pfile, top[-1].value,
1310
                                      top->value, top->op, top->loc);
1311
          top[-1].loc = top->loc;
1312
          break;
1313
 
1314
        case CPP_OR_OR:
1315
          top--;
1316
          if (!num_zerop (top->value))
1317
            pfile->state.skip_eval--;
1318
          top->value.low = (!num_zerop (top->value)
1319
                            || !num_zerop (top[1].value));
1320
          top->value.high = 0;
1321
          top->value.unsignedp = false;
1322
          top->value.overflow = false;
1323
          top->loc = top[1].loc;
1324
          continue;
1325
 
1326
        case CPP_AND_AND:
1327
          top--;
1328
          if (num_zerop (top->value))
1329
            pfile->state.skip_eval--;
1330
          top->value.low = (!num_zerop (top->value)
1331
                            && !num_zerop (top[1].value));
1332
          top->value.high = 0;
1333
          top->value.unsignedp = false;
1334
          top->value.overflow = false;
1335
          top->loc = top[1].loc;
1336
          continue;
1337
 
1338
        case CPP_OPEN_PAREN:
1339
          if (op != CPP_CLOSE_PAREN)
1340
            {
1341
              cpp_error_with_line (pfile, CPP_DL_ERROR,
1342
                                   top->token->src_loc,
1343
                                   0, "missing ')' in expression");
1344
              return 0;
1345
            }
1346
          top--;
1347
          top->value = top[1].value;
1348
          top->loc = top[1].loc;
1349
          return top;
1350
 
1351
        case CPP_COLON:
1352
          top -= 2;
1353
          if (!num_zerop (top->value))
1354
            {
1355
              pfile->state.skip_eval--;
1356
              top->value = top[1].value;
1357
              top->loc = top[1].loc;
1358
            }
1359
          else
1360
            {
1361
              top->value = top[2].value;
1362
              top->loc = top[2].loc;
1363
            }
1364
          top->value.unsignedp = (top[1].value.unsignedp
1365
                                  || top[2].value.unsignedp);
1366
          continue;
1367
 
1368
        case CPP_QUERY:
1369
          /* COMMA and COLON should not reduce a QUERY operator.  */
1370
          if (op == CPP_COMMA || op == CPP_COLON)
1371
            return top;
1372
          cpp_error (pfile, CPP_DL_ERROR, "'?' without following ':'");
1373
          return 0;
1374
 
1375
        default:
1376
          goto bad_op;
1377
        }
1378
 
1379
      top--;
1380
      if (top->value.overflow && !pfile->state.skip_eval)
1381
        cpp_error (pfile, CPP_DL_PEDWARN,
1382
                   "integer overflow in preprocessor expression");
1383
    }
1384
 
1385
  if (op == CPP_CLOSE_PAREN)
1386
    {
1387
      cpp_error (pfile, CPP_DL_ERROR, "missing '(' in expression");
1388
      return 0;
1389
    }
1390
 
1391
  return top;
1392
}
1393
 
1394
/* Returns the position of the old top of stack after expansion.  */
1395
struct op *
1396
_cpp_expand_op_stack (cpp_reader *pfile)
1397
{
1398
  size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
1399
  size_t new_size = old_size * 2 + 20;
1400
 
1401
  pfile->op_stack = XRESIZEVEC (struct op, pfile->op_stack, new_size);
1402
  pfile->op_limit = pfile->op_stack + new_size;
1403
 
1404
  return pfile->op_stack + old_size;
1405
}
1406
 
1407
/* Emits a warning if the effective sign of either operand of OP
1408
   changes because of integer promotions.  */
1409
static void
1410
check_promotion (cpp_reader *pfile, const struct op *op)
1411
{
1412
  if (op->value.unsignedp == op[-1].value.unsignedp)
1413
    return;
1414
 
1415
  if (op->value.unsignedp)
1416
    {
1417
      if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
1418
        cpp_error_with_line (pfile, CPP_DL_WARNING, op[-1].loc, 0,
1419
                             "the left operand of \"%s\" changes sign when promoted",
1420
                             cpp_token_as_text (pfile, op->token));
1421
    }
1422
  else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
1423
    cpp_error_with_line (pfile, CPP_DL_WARNING, op->loc, 0,
1424
               "the right operand of \"%s\" changes sign when promoted",
1425
               cpp_token_as_text (pfile, op->token));
1426
}
1427
 
1428
/* Clears the unused high order bits of the number pointed to by PNUM.  */
1429
static cpp_num
1430
num_trim (cpp_num num, size_t precision)
1431
{
1432
  if (precision > PART_PRECISION)
1433
    {
1434
      precision -= PART_PRECISION;
1435
      if (precision < PART_PRECISION)
1436
        num.high &= ((cpp_num_part) 1 << precision) - 1;
1437
    }
1438
  else
1439
    {
1440
      if (precision < PART_PRECISION)
1441
        num.low &= ((cpp_num_part) 1 << precision) - 1;
1442
      num.high = 0;
1443
    }
1444
 
1445
  return num;
1446
}
1447
 
1448
/* True iff A (presumed signed) >= 0.  */
1449
static bool
1450
num_positive (cpp_num num, size_t precision)
1451
{
1452
  if (precision > PART_PRECISION)
1453
    {
1454
      precision -= PART_PRECISION;
1455
      return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
1456
    }
1457
 
1458
  return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
1459
}
1460
 
1461
/* Sign extend a number, with PRECISION significant bits and all
1462
   others assumed clear, to fill out a cpp_num structure.  */
1463
cpp_num
1464
cpp_num_sign_extend (cpp_num num, size_t precision)
1465
{
1466
  if (!num.unsignedp)
1467
    {
1468
      if (precision > PART_PRECISION)
1469
        {
1470
          precision -= PART_PRECISION;
1471
          if (precision < PART_PRECISION
1472
              && (num.high & (cpp_num_part) 1 << (precision - 1)))
1473
            num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1474
        }
1475
      else if (num.low & (cpp_num_part) 1 << (precision - 1))
1476
        {
1477
          if (precision < PART_PRECISION)
1478
            num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1479
          num.high = ~(cpp_num_part) 0;
1480
        }
1481
    }
1482
 
1483
  return num;
1484
}
1485
 
1486
/* Returns the negative of NUM.  */
1487
static cpp_num
1488
num_negate (cpp_num num, size_t precision)
1489
{
1490
  cpp_num copy;
1491
 
1492
  copy = num;
1493
  num.high = ~num.high;
1494
  num.low = ~num.low;
1495
  if (++num.low == 0)
1496
    num.high++;
1497
  num = num_trim (num, precision);
1498
  num.overflow = (!num.unsignedp && num_eq (num, copy) && !num_zerop (num));
1499
 
1500
  return num;
1501
}
1502
 
1503
/* Returns true if A >= B.  */
1504
static bool
1505
num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
1506
{
1507
  bool unsignedp;
1508
 
1509
  unsignedp = pa.unsignedp || pb.unsignedp;
1510
 
1511
  if (!unsignedp)
1512
    {
1513
      /* Both numbers have signed type.  If they are of different
1514
       sign, the answer is the sign of A.  */
1515
      unsignedp = num_positive (pa, precision);
1516
 
1517
      if (unsignedp != num_positive (pb, precision))
1518
        return unsignedp;
1519
 
1520
      /* Otherwise we can do an unsigned comparison.  */
1521
    }
1522
 
1523
  return (pa.high > pb.high) || (pa.high == pb.high && pa.low >= pb.low);
1524
}
1525
 
1526
/* Returns LHS OP RHS, where OP is a bit-wise operation.  */
1527
static cpp_num
1528
num_bitwise_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1529
                cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1530
{
1531
  lhs.overflow = false;
1532
  lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;
1533
 
1534
  /* As excess precision is zeroed, there is no need to num_trim () as
1535
     these operations cannot introduce a set bit there.  */
1536
  if (op == CPP_AND)
1537
    {
1538
      lhs.low &= rhs.low;
1539
      lhs.high &= rhs.high;
1540
    }
1541
  else if (op == CPP_OR)
1542
    {
1543
      lhs.low |= rhs.low;
1544
      lhs.high |= rhs.high;
1545
    }
1546
  else
1547
    {
1548
      lhs.low ^= rhs.low;
1549
      lhs.high ^= rhs.high;
1550
    }
1551
 
1552
  return lhs;
1553
}
1554
 
1555
/* Returns LHS OP RHS, where OP is an inequality.  */
1556
static cpp_num
1557
num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
1558
                   enum cpp_ttype op)
1559
{
1560
  bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision));
1561
 
1562
  if (op == CPP_GREATER_EQ)
1563
    lhs.low = gte;
1564
  else if (op == CPP_LESS)
1565
    lhs.low = !gte;
1566
  else if (op == CPP_GREATER)
1567
    lhs.low = gte && !num_eq (lhs, rhs);
1568
  else /* CPP_LESS_EQ.  */
1569
    lhs.low = !gte || num_eq (lhs, rhs);
1570
 
1571
  lhs.high = 0;
1572
  lhs.overflow = false;
1573
  lhs.unsignedp = false;
1574
  return lhs;
1575
}
1576
 
1577
/* Returns LHS OP RHS, where OP is == or !=.  */
1578
static cpp_num
1579
num_equality_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1580
                 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1581
{
1582
  /* Work around a 3.0.4 bug; see PR 6950.  */
1583
  bool eq = num_eq (lhs, rhs);
1584
  if (op == CPP_NOT_EQ)
1585
    eq = !eq;
1586
  lhs.low = eq;
1587
  lhs.high = 0;
1588
  lhs.overflow = false;
1589
  lhs.unsignedp = false;
1590
  return lhs;
1591
}
1592
 
1593
/* Shift NUM, of width PRECISION, right by N bits.  */
1594
static cpp_num
1595
num_rshift (cpp_num num, size_t precision, size_t n)
1596
{
1597
  cpp_num_part sign_mask;
1598
  bool x = num_positive (num, precision);
1599
 
1600
  if (num.unsignedp || x)
1601
    sign_mask = 0;
1602
  else
1603
    sign_mask = ~(cpp_num_part) 0;
1604
 
1605
  if (n >= precision)
1606
    num.high = num.low = sign_mask;
1607
  else
1608
    {
1609
      /* Sign-extend.  */
1610
      if (precision < PART_PRECISION)
1611
        num.high = sign_mask, num.low |= sign_mask << precision;
1612
      else if (precision < 2 * PART_PRECISION)
1613
        num.high |= sign_mask << (precision - PART_PRECISION);
1614
 
1615
      if (n >= PART_PRECISION)
1616
        {
1617
          n -= PART_PRECISION;
1618
          num.low = num.high;
1619
          num.high = sign_mask;
1620
        }
1621
 
1622
      if (n)
1623
        {
1624
          num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
1625
          num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
1626
        }
1627
    }
1628
 
1629
  num = num_trim (num, precision);
1630
  num.overflow = false;
1631
  return num;
1632
}
1633
 
1634
/* Shift NUM, of width PRECISION, left by N bits.  */
1635
static cpp_num
1636
num_lshift (cpp_num num, size_t precision, size_t n)
1637
{
1638
  if (n >= precision)
1639
    {
1640
      num.overflow = !num.unsignedp && !num_zerop (num);
1641
      num.high = num.low = 0;
1642
    }
1643
  else
1644
    {
1645
      cpp_num orig, maybe_orig;
1646
      size_t m = n;
1647
 
1648
      orig = num;
1649
      if (m >= PART_PRECISION)
1650
        {
1651
          m -= PART_PRECISION;
1652
          num.high = num.low;
1653
          num.low = 0;
1654
        }
1655
      if (m)
1656
        {
1657
          num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
1658
          num.low <<= m;
1659
        }
1660
      num = num_trim (num, precision);
1661
 
1662
      if (num.unsignedp)
1663
        num.overflow = false;
1664
      else
1665
        {
1666
          maybe_orig = num_rshift (num, precision, n);
1667
          num.overflow = !num_eq (orig, maybe_orig);
1668
        }
1669
    }
1670
 
1671
  return num;
1672
}
1673
 
1674
/* The four unary operators: +, -, ! and ~.  */
1675
static cpp_num
1676
num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
1677
{
1678
  switch (op)
1679
    {
1680
    case CPP_UPLUS:
1681
      if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
1682
        cpp_warning (pfile, CPP_W_TRADITIONAL,
1683
                     "traditional C rejects the unary plus operator");
1684
      num.overflow = false;
1685
      break;
1686
 
1687
    case CPP_UMINUS:
1688
      num = num_negate (num, CPP_OPTION (pfile, precision));
1689
      break;
1690
 
1691
    case CPP_COMPL:
1692
      num.high = ~num.high;
1693
      num.low = ~num.low;
1694
      num = num_trim (num, CPP_OPTION (pfile, precision));
1695
      num.overflow = false;
1696
      break;
1697
 
1698
    default: /* case CPP_NOT: */
1699
      num.low = num_zerop (num);
1700
      num.high = 0;
1701
      num.overflow = false;
1702
      num.unsignedp = false;
1703
      break;
1704
    }
1705
 
1706
  return num;
1707
}
1708
 
1709
/* The various binary operators.  */
1710
static cpp_num
1711
num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1712
{
1713
  cpp_num result;
1714
  size_t precision = CPP_OPTION (pfile, precision);
1715
  size_t n;
1716
 
1717
  switch (op)
1718
    {
1719
      /* Shifts.  */
1720
    case CPP_LSHIFT:
1721
    case CPP_RSHIFT:
1722
      if (!rhs.unsignedp && !num_positive (rhs, precision))
1723
        {
1724
          /* A negative shift is a positive shift the other way.  */
1725
          if (op == CPP_LSHIFT)
1726
            op = CPP_RSHIFT;
1727
          else
1728
            op = CPP_LSHIFT;
1729
          rhs = num_negate (rhs, precision);
1730
        }
1731
      if (rhs.high)
1732
        n = ~0;                  /* Maximal.  */
1733
      else
1734
        n = rhs.low;
1735
      if (op == CPP_LSHIFT)
1736
        lhs = num_lshift (lhs, precision, n);
1737
      else
1738
        lhs = num_rshift (lhs, precision, n);
1739
      break;
1740
 
1741
      /* Arithmetic.  */
1742
    case CPP_MINUS:
1743
      rhs = num_negate (rhs, precision);
1744
    case CPP_PLUS:
1745
      result.low = lhs.low + rhs.low;
1746
      result.high = lhs.high + rhs.high;
1747
      if (result.low < lhs.low)
1748
        result.high++;
1749
      result.unsignedp = lhs.unsignedp || rhs.unsignedp;
1750
      result.overflow = false;
1751
 
1752
      result = num_trim (result, precision);
1753
      if (!result.unsignedp)
1754
        {
1755
          bool lhsp = num_positive (lhs, precision);
1756
          result.overflow = (lhsp == num_positive (rhs, precision)
1757
                             && lhsp != num_positive (result, precision));
1758
        }
1759
      return result;
1760
 
1761
      /* Comma.  */
1762
    default: /* case CPP_COMMA: */
1763
      if (CPP_PEDANTIC (pfile) && (!CPP_OPTION (pfile, c99)
1764
                                   || !pfile->state.skip_eval))
1765
        cpp_error (pfile, CPP_DL_PEDWARN,
1766
                   "comma operator in operand of #if");
1767
      lhs = rhs;
1768
      break;
1769
    }
1770
 
1771
  return lhs;
1772
}
1773
 
1774
/* Multiplies two unsigned cpp_num_parts to give a cpp_num.  This
1775
   cannot overflow.  */
1776
static cpp_num
1777
num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
1778
{
1779
  cpp_num result;
1780
  cpp_num_part middle[2], temp;
1781
 
1782
  result.low = LOW_PART (lhs) * LOW_PART (rhs);
1783
  result.high = HIGH_PART (lhs) * HIGH_PART (rhs);
1784
 
1785
  middle[0] = LOW_PART (lhs) * HIGH_PART (rhs);
1786
  middle[1] = HIGH_PART (lhs) * LOW_PART (rhs);
1787
 
1788
  temp = result.low;
1789
  result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
1790
  if (result.low < temp)
1791
    result.high++;
1792
 
1793
  temp = result.low;
1794
  result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
1795
  if (result.low < temp)
1796
    result.high++;
1797
 
1798
  result.high += HIGH_PART (middle[0]);
1799
  result.high += HIGH_PART (middle[1]);
1800
  result.unsignedp = true;
1801
  result.overflow = false;
1802
 
1803
  return result;
1804
}
1805
 
1806
/* Multiply two preprocessing numbers.  */
1807
static cpp_num
1808
num_mul (cpp_reader *pfile, cpp_num lhs, cpp_num rhs)
1809
{
1810
  cpp_num result, temp;
1811
  bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1812
  bool overflow, negate = false;
1813
  size_t precision = CPP_OPTION (pfile, precision);
1814
 
1815
  /* Prepare for unsigned multiplication.  */
1816
  if (!unsignedp)
1817
    {
1818
      if (!num_positive (lhs, precision))
1819
        negate = !negate, lhs = num_negate (lhs, precision);
1820
      if (!num_positive (rhs, precision))
1821
        negate = !negate, rhs = num_negate (rhs, precision);
1822
    }
1823
 
1824
  overflow = lhs.high && rhs.high;
1825
  result = num_part_mul (lhs.low, rhs.low);
1826
 
1827
  temp = num_part_mul (lhs.high, rhs.low);
1828
  result.high += temp.low;
1829
  if (temp.high)
1830
    overflow = true;
1831
 
1832
  temp = num_part_mul (lhs.low, rhs.high);
1833
  result.high += temp.low;
1834
  if (temp.high)
1835
    overflow = true;
1836
 
1837
  temp.low = result.low, temp.high = result.high;
1838
  result = num_trim (result, precision);
1839
  if (!num_eq (result, temp))
1840
    overflow = true;
1841
 
1842
  if (negate)
1843
    result = num_negate (result, precision);
1844
 
1845
  if (unsignedp)
1846
    result.overflow = false;
1847
  else
1848
    result.overflow = overflow || (num_positive (result, precision) ^ !negate
1849
                                   && !num_zerop (result));
1850
  result.unsignedp = unsignedp;
1851
 
1852
  return result;
1853
}
1854
 
1855
/* Divide two preprocessing numbers, LHS and RHS, returning the answer
1856
   or the remainder depending upon OP. LOCATION is the source location
1857
   of this operator (for diagnostics).  */
1858
 
1859
static cpp_num
1860
num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op,
1861
            source_location location)
1862
{
1863
  cpp_num result, sub;
1864
  cpp_num_part mask;
1865
  bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1866
  bool negate = false, lhs_neg = false;
1867
  size_t i, precision = CPP_OPTION (pfile, precision);
1868
 
1869
  /* Prepare for unsigned division.  */
1870
  if (!unsignedp)
1871
    {
1872
      if (!num_positive (lhs, precision))
1873
        negate = !negate, lhs_neg = true, lhs = num_negate (lhs, precision);
1874
      if (!num_positive (rhs, precision))
1875
        negate = !negate, rhs = num_negate (rhs, precision);
1876
    }
1877
 
1878
  /* Find the high bit.  */
1879
  if (rhs.high)
1880
    {
1881
      i = precision - 1;
1882
      mask = (cpp_num_part) 1 << (i - PART_PRECISION);
1883
      for (; ; i--, mask >>= 1)
1884
        if (rhs.high & mask)
1885
          break;
1886
    }
1887
  else if (rhs.low)
1888
    {
1889
      if (precision > PART_PRECISION)
1890
        i = precision - PART_PRECISION - 1;
1891
      else
1892
        i = precision - 1;
1893
      mask = (cpp_num_part) 1 << i;
1894
      for (; ; i--, mask >>= 1)
1895
        if (rhs.low & mask)
1896
          break;
1897
    }
1898
  else
1899
    {
1900
      if (!pfile->state.skip_eval)
1901
        cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
1902
                             "division by zero in #if");
1903
      return lhs;
1904
    }
1905
 
1906
  /* First nonzero bit of RHS is bit I.  Do naive division by
1907
     shifting the RHS fully left, and subtracting from LHS if LHS is
1908
     at least as big, and then repeating but with one less shift.
1909
     This is not very efficient, but is easy to understand.  */
1910
 
1911
  rhs.unsignedp = true;
1912
  lhs.unsignedp = true;
1913
  i = precision - i - 1;
1914
  sub = num_lshift (rhs, precision, i);
1915
 
1916
  result.high = result.low = 0;
1917
  for (;;)
1918
    {
1919
      if (num_greater_eq (lhs, sub, precision))
1920
        {
1921
          lhs = num_binary_op (pfile, lhs, sub, CPP_MINUS);
1922
          if (i >= PART_PRECISION)
1923
            result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
1924
          else
1925
            result.low |= (cpp_num_part) 1 << i;
1926
        }
1927
      if (i-- == 0)
1928
        break;
1929
      sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
1930
      sub.high >>= 1;
1931
    }
1932
 
1933
  /* We divide so that the remainder has the sign of the LHS.  */
1934
  if (op == CPP_DIV)
1935
    {
1936
      result.unsignedp = unsignedp;
1937
      result.overflow = false;
1938
      if (!unsignedp)
1939
        {
1940
          if (negate)
1941
            result = num_negate (result, precision);
1942
          result.overflow = (num_positive (result, precision) ^ !negate
1943
                             && !num_zerop (result));
1944
        }
1945
 
1946
      return result;
1947
    }
1948
 
1949
  /* CPP_MOD.  */
1950
  lhs.unsignedp = unsignedp;
1951
  lhs.overflow = false;
1952
  if (lhs_neg)
1953
    lhs = num_negate (lhs, precision);
1954
 
1955
  return lhs;
1956
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.