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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [libcpp/] [expr.c] - Blame information for rev 816

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* Parse C expressions for cpplib.
2
   Copyright (C) 1987, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
3
   2002, 2004 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 2, 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; if not, write to the Free Software
18
Foundation, 51 Franklin Street, Fifth Floor,
19
Boston, MA 02110-1301, USA.  */
20
 
21
#include "config.h"
22
#include "system.h"
23
#include "cpplib.h"
24
#include "internal.h"
25
 
26
#define PART_PRECISION (sizeof (cpp_num_part) * CHAR_BIT)
27
#define HALF_MASK (~(cpp_num_part) 0 >> (PART_PRECISION / 2))
28
#define LOW_PART(num_part) (num_part & HALF_MASK)
29
#define HIGH_PART(num_part) (num_part >> (PART_PRECISION / 2))
30
 
31
struct op
32
{
33
  const cpp_token *token;       /* The token forming op (for diagnostics).  */
34
  cpp_num value;                /* The value logically "right" of op.  */
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
static cpp_num num_lshift (cpp_num, size_t, size_t);
57
static cpp_num num_rshift (cpp_num, size_t, size_t);
58
 
59
static cpp_num append_digit (cpp_num, int, int, size_t);
60
static cpp_num parse_defined (cpp_reader *);
61
static cpp_num eval_token (cpp_reader *, const cpp_token *);
62
static struct op *reduce (cpp_reader *, struct op *, enum cpp_ttype);
63
static unsigned int interpret_float_suffix (const uchar *, size_t);
64
static unsigned int interpret_int_suffix (const uchar *, size_t);
65
static void check_promotion (cpp_reader *, const struct op *);
66
 
67
/* Token type abuse to create unary plus and minus operators.  */
68
#define CPP_UPLUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 1))
69
#define CPP_UMINUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 2))
70
 
71
/* With -O2, gcc appears to produce nice code, moving the error
72
   message load and subsequent jump completely out of the main path.  */
73
#define SYNTAX_ERROR(msgid) \
74
  do { cpp_error (pfile, CPP_DL_ERROR, msgid); goto syntax_error; } while(0)
75
#define SYNTAX_ERROR2(msgid, arg) \
76
  do { cpp_error (pfile, CPP_DL_ERROR, msgid, arg); goto syntax_error; } \
77
  while(0)
78
 
79
/* Subroutine of cpp_classify_number.  S points to a float suffix of
80
   length LEN, possibly zero.  Returns 0 for an invalid suffix, or a
81
   flag vector describing the suffix.  */
82
static unsigned int
83
interpret_float_suffix (const uchar *s, size_t len)
84
{
85
  size_t f = 0, l = 0, i = 0, d = 0;
86
 
87
  while (len--)
88
    switch (s[len])
89
      {
90
      case 'f': case 'F': f++; break;
91
      case 'l': case 'L': l++; break;
92
      case 'i': case 'I':
93
      case 'j': case 'J': i++; break;
94
      case 'd': case 'D':
95
        /* Disallow fd, ld suffixes.  */
96
        if (d && (f || l))
97
          return 0;
98
        d++;
99
        break;
100
      default:
101
        return 0;
102
      }
103
 
104
  if (f + l > 1 || i > 1)
105
    return 0;
106
 
107
  /* Allow dd, df, dl suffixes for decimal float constants.  */
108
  if (d && ((d + f + l != 2) || i))
109
    return 0;
110
 
111
  return ((i ? CPP_N_IMAGINARY : 0)
112
          | (f ? CPP_N_SMALL :
113
             l ? CPP_N_LARGE : CPP_N_MEDIUM)
114
          | (d ? CPP_N_DFLOAT : 0));
115
}
116
 
117
/* Subroutine of cpp_classify_number.  S points to an integer suffix
118
   of length LEN, possibly zero. Returns 0 for an invalid suffix, or a
119
   flag vector describing the suffix.  */
120
static unsigned int
121
interpret_int_suffix (const uchar *s, size_t len)
122
{
123
  size_t u, l, i;
124
 
125
  u = l = i = 0;
126
 
127
  while (len--)
128
    switch (s[len])
129
      {
130
      case 'u': case 'U':       u++; break;
131
      case 'i': case 'I':
132
      case 'j': case 'J':       i++; break;
133
      case 'l': case 'L':       l++;
134
        /* If there are two Ls, they must be adjacent and the same case.  */
135
        if (l == 2 && s[len] != s[len + 1])
136
          return 0;
137
        break;
138
      default:
139
        return 0;
140
      }
141
 
142
  if (l > 2 || u > 1 || i > 1)
143
    return 0;
144
 
145
  return ((i ? CPP_N_IMAGINARY : 0)
146
          | (u ? CPP_N_UNSIGNED : 0)
147
          | ((l == 0) ? CPP_N_SMALL
148
             : (l == 1) ? CPP_N_MEDIUM : CPP_N_LARGE));
149
}
150
 
151
/* Categorize numeric constants according to their field (integer,
152
   floating point, or invalid), radix (decimal, octal, hexadecimal),
153
   and type suffixes.  */
154
unsigned int
155
cpp_classify_number (cpp_reader *pfile, const cpp_token *token)
156
{
157
  const uchar *str = token->val.str.text;
158
  const uchar *limit;
159
  unsigned int max_digit, result, radix;
160
  enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;
161
 
162
  /* If the lexer has done its job, length one can only be a single
163
     digit.  Fast-path this very common case.  */
164
  if (token->val.str.len == 1)
165
    return CPP_N_INTEGER | CPP_N_SMALL | CPP_N_DECIMAL;
166
 
167
  limit = str + token->val.str.len;
168
  float_flag = NOT_FLOAT;
169
  max_digit = 0;
170
  radix = 10;
171
 
172
  /* First, interpret the radix.  */
173
  if (*str == '0')
174
    {
175
      radix = 8;
176
      str++;
177
 
178
      /* Require at least one hex digit to classify it as hex.  */
179
      if ((*str == 'x' || *str == 'X')
180
          && (str[1] == '.' || ISXDIGIT (str[1])))
181
        {
182
          radix = 16;
183
          str++;
184
        }
185
    }
186
 
187
  /* Now scan for a well-formed integer or float.  */
188
  for (;;)
189
    {
190
      unsigned int c = *str++;
191
 
192
      if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))
193
        {
194
          c = hex_value (c);
195
          if (c > max_digit)
196
            max_digit = c;
197
        }
198
      else if (c == '.')
199
        {
200
          if (float_flag == NOT_FLOAT)
201
            float_flag = AFTER_POINT;
202
          else
203
            SYNTAX_ERROR ("too many decimal points in number");
204
        }
205
      else if ((radix <= 10 && (c == 'e' || c == 'E'))
206
               || (radix == 16 && (c == 'p' || c == 'P')))
207
        {
208
          float_flag = AFTER_EXPON;
209
          break;
210
        }
211
      else
212
        {
213
          /* Start of suffix.  */
214
          str--;
215
          break;
216
        }
217
    }
218
 
219
  if (float_flag != NOT_FLOAT && radix == 8)
220
    radix = 10;
221
 
222
  if (max_digit >= radix)
223
    SYNTAX_ERROR2 ("invalid digit \"%c\" in octal constant", '0' + max_digit);
224
 
225
  if (float_flag != NOT_FLOAT)
226
    {
227
      if (radix == 16 && CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, c99))
228
        cpp_error (pfile, CPP_DL_PEDWARN,
229
                   "use of C99 hexadecimal floating constant");
230
 
231
      if (float_flag == AFTER_EXPON)
232
        {
233
          if (*str == '+' || *str == '-')
234
            str++;
235
 
236
          /* Exponent is decimal, even if string is a hex float.  */
237
          if (!ISDIGIT (*str))
238
            SYNTAX_ERROR ("exponent has no digits");
239
 
240
          do
241
            str++;
242
          while (ISDIGIT (*str));
243
        }
244
      else if (radix == 16)
245
        SYNTAX_ERROR ("hexadecimal floating constants require an exponent");
246
 
247
      result = interpret_float_suffix (str, limit - str);
248
      if (result == 0)
249
        {
250
          cpp_error (pfile, CPP_DL_ERROR,
251
                     "invalid suffix \"%.*s\" on floating constant",
252
                     (int) (limit - str), str);
253
          return CPP_N_INVALID;
254
        }
255
 
256
      /* Traditional C didn't accept any floating suffixes.  */
257
      if (limit != str
258
          && CPP_WTRADITIONAL (pfile)
259
          && ! cpp_sys_macro_p (pfile))
260
        cpp_error (pfile, CPP_DL_WARNING,
261
                   "traditional C rejects the \"%.*s\" suffix",
262
                   (int) (limit - str), str);
263
 
264
      /* Radix must be 10 for decimal floats.  */
265
      if ((result & CPP_N_DFLOAT) && radix != 10)
266
        {
267
          cpp_error (pfile, CPP_DL_ERROR,
268
                     "invalid suffix \"%.*s\" with hexadecimal floating constant",
269
                     (int) (limit - str), str);
270
          return CPP_N_INVALID;
271
        }
272
 
273
      result |= CPP_N_FLOATING;
274
    }
275
  else
276
    {
277
      result = interpret_int_suffix (str, limit - str);
278
      if (result == 0)
279
        {
280
          cpp_error (pfile, CPP_DL_ERROR,
281
                     "invalid suffix \"%.*s\" on integer constant",
282
                     (int) (limit - str), str);
283
          return CPP_N_INVALID;
284
        }
285
 
286
      /* Traditional C only accepted the 'L' suffix.
287
         Suppress warning about 'LL' with -Wno-long-long.  */
288
      if (CPP_WTRADITIONAL (pfile) && ! cpp_sys_macro_p (pfile))
289
        {
290
          int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY));
291
          int large = (result & CPP_N_WIDTH) == CPP_N_LARGE;
292
 
293
          if (u_or_i || (large && CPP_OPTION (pfile, warn_long_long)))
294
            cpp_error (pfile, CPP_DL_WARNING,
295
                       "traditional C rejects the \"%.*s\" suffix",
296
                       (int) (limit - str), str);
297
        }
298
 
299
      if ((result & CPP_N_WIDTH) == CPP_N_LARGE
300
          && ! CPP_OPTION (pfile, c99)
301
          && CPP_OPTION (pfile, warn_long_long))
302
        cpp_error (pfile, CPP_DL_PEDWARN,
303
                   "use of C99 long long integer constant");
304
 
305
      result |= CPP_N_INTEGER;
306
    }
307
 
308
  if ((result & CPP_N_IMAGINARY) && CPP_PEDANTIC (pfile))
309
    cpp_error (pfile, CPP_DL_PEDWARN,
310
               "imaginary constants are a GCC extension");
311
 
312
  if (radix == 10)
313
    result |= CPP_N_DECIMAL;
314
  else if (radix == 16)
315
    result |= CPP_N_HEX;
316
  else
317
    result |= CPP_N_OCTAL;
318
 
319
  return result;
320
 
321
 syntax_error:
322
  return CPP_N_INVALID;
323
}
324
 
325
/* cpp_interpret_integer converts an integer constant into a cpp_num,
326
   of precision options->precision.
327
 
328
   We do not provide any interface for decimal->float conversion,
329
   because the preprocessor doesn't need it and we don't want to
330
   drag in GCC's floating point emulator.  */
331
cpp_num
332
cpp_interpret_integer (cpp_reader *pfile, const cpp_token *token,
333
                       unsigned int type)
334
{
335
  const uchar *p, *end;
336
  cpp_num result;
337
 
338
  result.low = 0;
339
  result.high = 0;
340
  result.unsignedp = !!(type & CPP_N_UNSIGNED);
341
  result.overflow = false;
342
 
343
  p = token->val.str.text;
344
  end = p + token->val.str.len;
345
 
346
  /* Common case of a single digit.  */
347
  if (token->val.str.len == 1)
348
    result.low = p[0] - '0';
349
  else
350
    {
351
      cpp_num_part max;
352
      size_t precision = CPP_OPTION (pfile, precision);
353
      unsigned int base = 10, c = 0;
354
      bool overflow = false;
355
 
356
      if ((type & CPP_N_RADIX) == CPP_N_OCTAL)
357
        {
358
          base = 8;
359
          p++;
360
        }
361
      else if ((type & CPP_N_RADIX) == CPP_N_HEX)
362
        {
363
          base = 16;
364
          p += 2;
365
        }
366
 
367
      /* We can add a digit to numbers strictly less than this without
368
         needing the precision and slowness of double integers.  */
369
      max = ~(cpp_num_part) 0;
370
      if (precision < PART_PRECISION)
371
        max >>= PART_PRECISION - precision;
372
      max = (max - base + 1) / base + 1;
373
 
374
      for (; p < end; p++)
375
        {
376
          c = *p;
377
 
378
          if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))
379
            c = hex_value (c);
380
          else
381
            break;
382
 
383
          /* Strict inequality for when max is set to zero.  */
384
          if (result.low < max)
385
            result.low = result.low * base + c;
386
          else
387
            {
388
              result = append_digit (result, c, base, precision);
389
              overflow |= result.overflow;
390
              max = 0;
391
            }
392
        }
393
 
394
      if (overflow)
395
        cpp_error (pfile, CPP_DL_PEDWARN,
396
                   "integer constant is too large for its type");
397
      /* If too big to be signed, consider it unsigned.  Only warn for
398
         decimal numbers.  Traditional numbers were always signed (but
399
         we still honor an explicit U suffix); but we only have
400
         traditional semantics in directives.  */
401
      else if (!result.unsignedp
402
               && !(CPP_OPTION (pfile, traditional)
403
                    && pfile->state.in_directive)
404
               && !num_positive (result, precision))
405
        {
406
          if (base == 10)
407
            cpp_error (pfile, CPP_DL_WARNING,
408
                       "integer constant is so large that it is unsigned");
409
          result.unsignedp = true;
410
        }
411
    }
412
 
413
  return result;
414
}
415
 
416
/* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE.  */
417
static cpp_num
418
append_digit (cpp_num num, int digit, int base, size_t precision)
419
{
420
  cpp_num result;
421
  unsigned int shift = 3 + (base == 16);
422
  bool overflow;
423
  cpp_num_part add_high, add_low;
424
 
425
  /* Multiply by 8 or 16.  Catching this overflow here means we don't
426
     need to worry about add_high overflowing.  */
427
  overflow = !!(num.high >> (PART_PRECISION - shift));
428
  result.high = num.high << shift;
429
  result.low = num.low << shift;
430
  result.high |= num.low >> (PART_PRECISION - shift);
431
  result.unsignedp = num.unsignedp;
432
 
433
  if (base == 10)
434
    {
435
      add_low = num.low << 1;
436
      add_high = (num.high << 1) + (num.low >> (PART_PRECISION - 1));
437
    }
438
  else
439
    add_high = add_low = 0;
440
 
441
  if (add_low + digit < add_low)
442
    add_high++;
443
  add_low += digit;
444
 
445
  if (result.low + add_low < result.low)
446
    add_high++;
447
  if (result.high + add_high < result.high)
448
    overflow = true;
449
 
450
  result.low += add_low;
451
  result.high += add_high;
452
  result.overflow = overflow;
453
 
454
  /* The above code catches overflow of a cpp_num type.  This catches
455
     overflow of the (possibly shorter) target precision.  */
456
  num.low = result.low;
457
  num.high = result.high;
458
  result = num_trim (result, precision);
459
  if (!num_eq (result, num))
460
    result.overflow = true;
461
 
462
  return result;
463
}
464
 
465
/* Handle meeting "defined" in a preprocessor expression.  */
466
static cpp_num
467
parse_defined (cpp_reader *pfile)
468
{
469
  cpp_num result;
470
  int paren = 0;
471
  cpp_hashnode *node = 0;
472
  const cpp_token *token;
473
  cpp_context *initial_context = pfile->context;
474
 
475
  /* Don't expand macros.  */
476
  pfile->state.prevent_expansion++;
477
 
478
  token = cpp_get_token (pfile);
479
  if (token->type == CPP_OPEN_PAREN)
480
    {
481
      paren = 1;
482
      token = cpp_get_token (pfile);
483
    }
484
 
485
  if (token->type == CPP_NAME)
486
    {
487
      node = token->val.node;
488
      if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)
489
        {
490
          cpp_error (pfile, CPP_DL_ERROR, "missing ')' after \"defined\"");
491
          node = 0;
492
        }
493
    }
494
  else
495
    {
496
      cpp_error (pfile, CPP_DL_ERROR,
497
                 "operator \"defined\" requires an identifier");
498
      if (token->flags & NAMED_OP)
499
        {
500
          cpp_token op;
501
 
502
          op.flags = 0;
503
          op.type = token->type;
504
          cpp_error (pfile, CPP_DL_ERROR,
505
                     "(\"%s\" is an alternative token for \"%s\" in C++)",
506
                     cpp_token_as_text (pfile, token),
507
                     cpp_token_as_text (pfile, &op));
508
        }
509
    }
510
 
511
  if (node)
512
    {
513
      if (pfile->context != initial_context && CPP_PEDANTIC (pfile))
514
        cpp_error (pfile, CPP_DL_WARNING,
515
                   "this use of \"defined\" may not be portable");
516
 
517
      _cpp_mark_macro_used (node);
518
 
519
      /* A possible controlling macro of the form #if !defined ().
520
         _cpp_parse_expr checks there was no other junk on the line.  */
521
      pfile->mi_ind_cmacro = node;
522
    }
523
 
524
  pfile->state.prevent_expansion--;
525
 
526
  result.unsignedp = false;
527
  result.high = 0;
528
  result.overflow = false;
529
  result.low = node && node->type == NT_MACRO;
530
  return result;
531
}
532
 
533
/* Convert a token into a CPP_NUMBER (an interpreted preprocessing
534
   number or character constant, or the result of the "defined" or "#"
535
   operators).  */
536
static cpp_num
537
eval_token (cpp_reader *pfile, const cpp_token *token)
538
{
539
  cpp_num result;
540
  unsigned int temp;
541
  int unsignedp = 0;
542
 
543
  result.unsignedp = false;
544
  result.overflow = false;
545
 
546
  switch (token->type)
547
    {
548
    case CPP_NUMBER:
549
      temp = cpp_classify_number (pfile, token);
550
      switch (temp & CPP_N_CATEGORY)
551
        {
552
        case CPP_N_FLOATING:
553
          cpp_error (pfile, CPP_DL_ERROR,
554
                     "floating constant in preprocessor expression");
555
          break;
556
        case CPP_N_INTEGER:
557
          if (!(temp & CPP_N_IMAGINARY))
558
            return cpp_interpret_integer (pfile, token, temp);
559
          cpp_error (pfile, CPP_DL_ERROR,
560
                     "imaginary number in preprocessor expression");
561
          break;
562
 
563
        case CPP_N_INVALID:
564
          /* Error already issued.  */
565
          break;
566
        }
567
      result.high = result.low = 0;
568
      break;
569
 
570
    case CPP_WCHAR:
571
    case CPP_CHAR:
572
      {
573
        cppchar_t cc = cpp_interpret_charconst (pfile, token,
574
                                                &temp, &unsignedp);
575
 
576
        result.high = 0;
577
        result.low = cc;
578
        /* Sign-extend the result if necessary.  */
579
        if (!unsignedp && (cppchar_signed_t) cc < 0)
580
          {
581
            if (PART_PRECISION > BITS_PER_CPPCHAR_T)
582
              result.low |= ~(~(cpp_num_part) 0
583
                              >> (PART_PRECISION - BITS_PER_CPPCHAR_T));
584
            result.high = ~(cpp_num_part) 0;
585
            result = num_trim (result, CPP_OPTION (pfile, precision));
586
          }
587
      }
588
      break;
589
 
590
    case CPP_NAME:
591
      if (token->val.node == pfile->spec_nodes.n_defined)
592
        return parse_defined (pfile);
593
      else if (CPP_OPTION (pfile, cplusplus)
594
               && (token->val.node == pfile->spec_nodes.n_true
595
                   || token->val.node == pfile->spec_nodes.n_false))
596
        {
597
          result.high = 0;
598
          result.low = (token->val.node == pfile->spec_nodes.n_true);
599
        }
600
      else
601
        {
602
          result.high = 0;
603
          result.low = 0;
604
          if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)
605
            cpp_error (pfile, CPP_DL_WARNING, "\"%s\" is not defined",
606
                       NODE_NAME (token->val.node));
607
        }
608
      break;
609
 
610
    default: /* CPP_HASH */
611
      _cpp_test_assertion (pfile, &temp);
612
      result.high = 0;
613
      result.low = temp;
614
    }
615
 
616
  result.unsignedp = !!unsignedp;
617
  return result;
618
}
619
 
620
/* Operator precedence and flags table.
621
 
622
After an operator is returned from the lexer, if it has priority less
623
than the operator on the top of the stack, we reduce the stack by one
624
operator and repeat the test.  Since equal priorities do not reduce,
625
this is naturally right-associative.
626
 
627
We handle left-associative operators by decrementing the priority of
628
just-lexed operators by one, but retaining the priority of operators
629
already on the stack.
630
 
631
The remaining cases are '(' and ')'.  We handle '(' by skipping the
632
reduction phase completely.  ')' is given lower priority than
633
everything else, including '(', effectively forcing a reduction of the
634
parenthesized expression.  If there is a matching '(', the routine
635
reduce() exits immediately.  If the normal exit route sees a ')', then
636
there cannot have been a matching '(' and an error message is output.
637
 
638
The parser assumes all shifted operators require a left operand unless
639
the flag NO_L_OPERAND is set.  These semantics are automatic; any
640
extra semantics need to be handled with operator-specific code.  */
641
 
642
/* Flags.  If CHECK_PROMOTION, we warn if the effective sign of an
643
   operand changes because of integer promotions.  */
644
#define NO_L_OPERAND    (1 << 0)
645
#define LEFT_ASSOC      (1 << 1)
646
#define CHECK_PROMOTION (1 << 2)
647
 
648
/* Operator to priority map.  Must be in the same order as the first
649
   N entries of enum cpp_ttype.  */
650
static const struct cpp_operator
651
{
652
  uchar prio;
653
  uchar flags;
654
} optab[] =
655
{
656
  /* EQ */              {0, 0},   /* Shouldn't happen.  */
657
  /* NOT */             {16, NO_L_OPERAND},
658
  /* GREATER */         {12, LEFT_ASSOC | CHECK_PROMOTION},
659
  /* LESS */            {12, LEFT_ASSOC | CHECK_PROMOTION},
660
  /* PLUS */            {14, LEFT_ASSOC | CHECK_PROMOTION},
661
  /* MINUS */           {14, LEFT_ASSOC | CHECK_PROMOTION},
662
  /* MULT */            {15, LEFT_ASSOC | CHECK_PROMOTION},
663
  /* DIV */             {15, LEFT_ASSOC | CHECK_PROMOTION},
664
  /* MOD */             {15, LEFT_ASSOC | CHECK_PROMOTION},
665
  /* AND */             {9, LEFT_ASSOC | CHECK_PROMOTION},
666
  /* OR */              {7, LEFT_ASSOC | CHECK_PROMOTION},
667
  /* XOR */             {8, LEFT_ASSOC | CHECK_PROMOTION},
668
  /* RSHIFT */          {13, LEFT_ASSOC},
669
  /* LSHIFT */          {13, LEFT_ASSOC},
670
 
671
  /* COMPL */           {16, NO_L_OPERAND},
672
  /* AND_AND */         {6, LEFT_ASSOC},
673
  /* OR_OR */           {5, LEFT_ASSOC},
674
  /* QUERY */           {3, 0},
675
  /* COLON */           {4, LEFT_ASSOC | CHECK_PROMOTION},
676
  /* COMMA */           {2, LEFT_ASSOC},
677
  /* OPEN_PAREN */      {1, NO_L_OPERAND},
678
  /* CLOSE_PAREN */     {0, 0},
679
  /* EOF */             {0, 0},
680
  /* EQ_EQ */           {11, LEFT_ASSOC},
681
  /* NOT_EQ */          {11, LEFT_ASSOC},
682
  /* GREATER_EQ */      {12, LEFT_ASSOC | CHECK_PROMOTION},
683
  /* LESS_EQ */         {12, LEFT_ASSOC | CHECK_PROMOTION},
684
  /* UPLUS */           {16, NO_L_OPERAND},
685
  /* UMINUS */          {16, NO_L_OPERAND}
686
};
687
 
688
/* Parse and evaluate a C expression, reading from PFILE.
689
   Returns the truth value of the expression.
690
 
691
   The implementation is an operator precedence parser, i.e. a
692
   bottom-up parser, using a stack for not-yet-reduced tokens.
693
 
694
   The stack base is op_stack, and the current stack pointer is 'top'.
695
   There is a stack element for each operator (only), and the most
696
   recently pushed operator is 'top->op'.  An operand (value) is
697
   stored in the 'value' field of the stack element of the operator
698
   that precedes it.  */
699
bool
700
_cpp_parse_expr (cpp_reader *pfile)
701
{
702
  struct op *top = pfile->op_stack;
703
  unsigned int lex_count;
704
  bool saw_leading_not, want_value = true;
705
 
706
  pfile->state.skip_eval = 0;
707
 
708
  /* Set up detection of #if ! defined().  */
709
  pfile->mi_ind_cmacro = 0;
710
  saw_leading_not = false;
711
  lex_count = 0;
712
 
713
  /* Lowest priority operator prevents further reductions.  */
714
  top->op = CPP_EOF;
715
 
716
  for (;;)
717
    {
718
      struct op op;
719
 
720
      lex_count++;
721
      op.token = cpp_get_token (pfile);
722
      op.op = op.token->type;
723
 
724
      switch (op.op)
725
        {
726
          /* These tokens convert into values.  */
727
        case CPP_NUMBER:
728
        case CPP_CHAR:
729
        case CPP_WCHAR:
730
        case CPP_NAME:
731
        case CPP_HASH:
732
          if (!want_value)
733
            SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
734
                           cpp_token_as_text (pfile, op.token));
735
          want_value = false;
736
          top->value = eval_token (pfile, op.token);
737
          continue;
738
 
739
        case CPP_NOT:
740
          saw_leading_not = lex_count == 1;
741
          break;
742
        case CPP_PLUS:
743
          if (want_value)
744
            op.op = CPP_UPLUS;
745
          break;
746
        case CPP_MINUS:
747
          if (want_value)
748
            op.op = CPP_UMINUS;
749
          break;
750
 
751
        default:
752
          if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
753
            SYNTAX_ERROR2 ("token \"%s\" is not valid in preprocessor expressions",
754
                           cpp_token_as_text (pfile, op.token));
755
          break;
756
        }
757
 
758
      /* Check we have a value or operator as appropriate.  */
759
      if (optab[op.op].flags & NO_L_OPERAND)
760
        {
761
          if (!want_value)
762
            SYNTAX_ERROR2 ("missing binary operator before token \"%s\"",
763
                           cpp_token_as_text (pfile, op.token));
764
        }
765
      else if (want_value)
766
        {
767
          /* We want a number (or expression) and haven't got one.
768
             Try to emit a specific diagnostic.  */
769
          if (op.op == CPP_CLOSE_PAREN && top->op == CPP_OPEN_PAREN)
770
            SYNTAX_ERROR ("missing expression between '(' and ')'");
771
 
772
          if (op.op == CPP_EOF && top->op == CPP_EOF)
773
            SYNTAX_ERROR ("#if with no expression");
774
 
775
          if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
776
            SYNTAX_ERROR2 ("operator '%s' has no right operand",
777
                           cpp_token_as_text (pfile, top->token));
778
          else if (op.op == CPP_CLOSE_PAREN || op.op == CPP_EOF)
779
            /* Complain about missing paren during reduction.  */;
780
          else
781
            SYNTAX_ERROR2 ("operator '%s' has no left operand",
782
                           cpp_token_as_text (pfile, op.token));
783
        }
784
 
785
      top = reduce (pfile, top, op.op);
786
      if (!top)
787
        goto syntax_error;
788
 
789
      if (op.op == CPP_EOF)
790
        break;
791
 
792
      switch (op.op)
793
        {
794
        case CPP_CLOSE_PAREN:
795
          continue;
796
        case CPP_OR_OR:
797
          if (!num_zerop (top->value))
798
            pfile->state.skip_eval++;
799
          break;
800
        case CPP_AND_AND:
801
        case CPP_QUERY:
802
          if (num_zerop (top->value))
803
            pfile->state.skip_eval++;
804
          break;
805
        case CPP_COLON:
806
          if (top->op != CPP_QUERY)
807
            SYNTAX_ERROR (" ':' without preceding '?'");
808
          if (!num_zerop (top[-1].value)) /* Was '?' condition true?  */
809
            pfile->state.skip_eval++;
810
          else
811
            pfile->state.skip_eval--;
812
        default:
813
          break;
814
        }
815
 
816
      want_value = true;
817
 
818
      /* Check for and handle stack overflow.  */
819
      if (++top == pfile->op_limit)
820
        top = _cpp_expand_op_stack (pfile);
821
 
822
      top->op = op.op;
823
      top->token = op.token;
824
    }
825
 
826
  /* The controlling macro expression is only valid if we called lex 3
827
     times: <!> <defined expression> and <EOF>.  push_conditional ()
828
     checks that we are at top-of-file.  */
829
  if (pfile->mi_ind_cmacro && !(saw_leading_not && lex_count == 3))
830
    pfile->mi_ind_cmacro = 0;
831
 
832
  if (top != pfile->op_stack)
833
    {
834
      cpp_error (pfile, CPP_DL_ICE, "unbalanced stack in #if");
835
    syntax_error:
836
      return false;  /* Return false on syntax error.  */
837
    }
838
 
839
  return !num_zerop (top->value);
840
}
841
 
842
/* Reduce the operator / value stack if possible, in preparation for
843
   pushing operator OP.  Returns NULL on error, otherwise the top of
844
   the stack.  */
845
static struct op *
846
reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
847
{
848
  unsigned int prio;
849
 
850
  if (top->op <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
851
    {
852
    bad_op:
853
      cpp_error (pfile, CPP_DL_ICE, "impossible operator '%u'", top->op);
854
      return 0;
855
    }
856
 
857
  if (op == CPP_OPEN_PAREN)
858
    return top;
859
 
860
  /* Decrement the priority of left-associative operators to force a
861
     reduction with operators of otherwise equal priority.  */
862
  prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC) != 0);
863
  while (prio < optab[top->op].prio)
864
    {
865
      if (CPP_OPTION (pfile, warn_num_sign_change)
866
          && optab[top->op].flags & CHECK_PROMOTION)
867
        check_promotion (pfile, top);
868
 
869
      switch (top->op)
870
        {
871
        case CPP_UPLUS:
872
        case CPP_UMINUS:
873
        case CPP_NOT:
874
        case CPP_COMPL:
875
          top[-1].value = num_unary_op (pfile, top->value, top->op);
876
          break;
877
 
878
        case CPP_PLUS:
879
        case CPP_MINUS:
880
        case CPP_RSHIFT:
881
        case CPP_LSHIFT:
882
        case CPP_COMMA:
883
          top[-1].value = num_binary_op (pfile, top[-1].value,
884
                                         top->value, top->op);
885
          break;
886
 
887
        case CPP_GREATER:
888
        case CPP_LESS:
889
        case CPP_GREATER_EQ:
890
        case CPP_LESS_EQ:
891
          top[-1].value
892
            = num_inequality_op (pfile, top[-1].value, top->value, top->op);
893
          break;
894
 
895
        case CPP_EQ_EQ:
896
        case CPP_NOT_EQ:
897
          top[-1].value
898
            = num_equality_op (pfile, top[-1].value, top->value, top->op);
899
          break;
900
 
901
        case CPP_AND:
902
        case CPP_OR:
903
        case CPP_XOR:
904
          top[-1].value
905
            = num_bitwise_op (pfile, top[-1].value, top->value, top->op);
906
          break;
907
 
908
        case CPP_MULT:
909
          top[-1].value = num_mul (pfile, top[-1].value, top->value);
910
          break;
911
 
912
        case CPP_DIV:
913
        case CPP_MOD:
914
          top[-1].value = num_div_op (pfile, top[-1].value,
915
                                      top->value, top->op);
916
          break;
917
 
918
        case CPP_OR_OR:
919
          top--;
920
          if (!num_zerop (top->value))
921
            pfile->state.skip_eval--;
922
          top->value.low = (!num_zerop (top->value)
923
                            || !num_zerop (top[1].value));
924
          top->value.high = 0;
925
          top->value.unsignedp = false;
926
          top->value.overflow = false;
927
          continue;
928
 
929
        case CPP_AND_AND:
930
          top--;
931
          if (num_zerop (top->value))
932
            pfile->state.skip_eval--;
933
          top->value.low = (!num_zerop (top->value)
934
                            && !num_zerop (top[1].value));
935
          top->value.high = 0;
936
          top->value.unsignedp = false;
937
          top->value.overflow = false;
938
          continue;
939
 
940
        case CPP_OPEN_PAREN:
941
          if (op != CPP_CLOSE_PAREN)
942
            {
943
              cpp_error (pfile, CPP_DL_ERROR, "missing ')' in expression");
944
              return 0;
945
            }
946
          top--;
947
          top->value = top[1].value;
948
          return top;
949
 
950
        case CPP_COLON:
951
          top -= 2;
952
          if (!num_zerop (top->value))
953
            {
954
              pfile->state.skip_eval--;
955
              top->value = top[1].value;
956
            }
957
          else
958
            top->value = top[2].value;
959
          top->value.unsignedp = (top[1].value.unsignedp
960
                                  || top[2].value.unsignedp);
961
          continue;
962
 
963
        case CPP_QUERY:
964
          cpp_error (pfile, CPP_DL_ERROR, "'?' without following ':'");
965
          return 0;
966
 
967
        default:
968
          goto bad_op;
969
        }
970
 
971
      top--;
972
      if (top->value.overflow && !pfile->state.skip_eval)
973
        cpp_error (pfile, CPP_DL_PEDWARN,
974
                   "integer overflow in preprocessor expression");
975
    }
976
 
977
  if (op == CPP_CLOSE_PAREN)
978
    {
979
      cpp_error (pfile, CPP_DL_ERROR, "missing '(' in expression");
980
      return 0;
981
    }
982
 
983
  return top;
984
}
985
 
986
/* Returns the position of the old top of stack after expansion.  */
987
struct op *
988
_cpp_expand_op_stack (cpp_reader *pfile)
989
{
990
  size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
991
  size_t new_size = old_size * 2 + 20;
992
 
993
  pfile->op_stack = XRESIZEVEC (struct op, pfile->op_stack, new_size);
994
  pfile->op_limit = pfile->op_stack + new_size;
995
 
996
  return pfile->op_stack + old_size;
997
}
998
 
999
/* Emits a warning if the effective sign of either operand of OP
1000
   changes because of integer promotions.  */
1001
static void
1002
check_promotion (cpp_reader *pfile, const struct op *op)
1003
{
1004
  if (op->value.unsignedp == op[-1].value.unsignedp)
1005
    return;
1006
 
1007
  if (op->value.unsignedp)
1008
    {
1009
      if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)))
1010
        cpp_error (pfile, CPP_DL_WARNING,
1011
                   "the left operand of \"%s\" changes sign when promoted",
1012
                   cpp_token_as_text (pfile, op->token));
1013
    }
1014
  else if (!num_positive (op->value, CPP_OPTION (pfile, precision)))
1015
    cpp_error (pfile, CPP_DL_WARNING,
1016
               "the right operand of \"%s\" changes sign when promoted",
1017
               cpp_token_as_text (pfile, op->token));
1018
}
1019
 
1020
/* Clears the unused high order bits of the number pointed to by PNUM.  */
1021
static cpp_num
1022
num_trim (cpp_num num, size_t precision)
1023
{
1024
  if (precision > PART_PRECISION)
1025
    {
1026
      precision -= PART_PRECISION;
1027
      if (precision < PART_PRECISION)
1028
        num.high &= ((cpp_num_part) 1 << precision) - 1;
1029
    }
1030
  else
1031
    {
1032
      if (precision < PART_PRECISION)
1033
        num.low &= ((cpp_num_part) 1 << precision) - 1;
1034
      num.high = 0;
1035
    }
1036
 
1037
  return num;
1038
}
1039
 
1040
/* True iff A (presumed signed) >= 0.  */
1041
static bool
1042
num_positive (cpp_num num, size_t precision)
1043
{
1044
  if (precision > PART_PRECISION)
1045
    {
1046
      precision -= PART_PRECISION;
1047
      return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
1048
    }
1049
 
1050
  return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
1051
}
1052
 
1053
/* Sign extend a number, with PRECISION significant bits and all
1054
   others assumed clear, to fill out a cpp_num structure.  */
1055
cpp_num
1056
cpp_num_sign_extend (cpp_num num, size_t precision)
1057
{
1058
  if (!num.unsignedp)
1059
    {
1060
      if (precision > PART_PRECISION)
1061
        {
1062
          precision -= PART_PRECISION;
1063
          if (precision < PART_PRECISION
1064
              && (num.high & (cpp_num_part) 1 << (precision - 1)))
1065
            num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1066
        }
1067
      else if (num.low & (cpp_num_part) 1 << (precision - 1))
1068
        {
1069
          if (precision < PART_PRECISION)
1070
            num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION - precision));
1071
          num.high = ~(cpp_num_part) 0;
1072
        }
1073
    }
1074
 
1075
  return num;
1076
}
1077
 
1078
/* Returns the negative of NUM.  */
1079
static cpp_num
1080
num_negate (cpp_num num, size_t precision)
1081
{
1082
  cpp_num copy;
1083
 
1084
  copy = num;
1085
  num.high = ~num.high;
1086
  num.low = ~num.low;
1087
  if (++num.low == 0)
1088
    num.high++;
1089
  num = num_trim (num, precision);
1090
  num.overflow = (!num.unsignedp && num_eq (num, copy) && !num_zerop (num));
1091
 
1092
  return num;
1093
}
1094
 
1095
/* Returns true if A >= B.  */
1096
static bool
1097
num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
1098
{
1099
  bool unsignedp;
1100
 
1101
  unsignedp = pa.unsignedp || pb.unsignedp;
1102
 
1103
  if (!unsignedp)
1104
    {
1105
      /* Both numbers have signed type.  If they are of different
1106
       sign, the answer is the sign of A.  */
1107
      unsignedp = num_positive (pa, precision);
1108
 
1109
      if (unsignedp != num_positive (pb, precision))
1110
        return unsignedp;
1111
 
1112
      /* Otherwise we can do an unsigned comparison.  */
1113
    }
1114
 
1115
  return (pa.high > pb.high) || (pa.high == pb.high && pa.low >= pb.low);
1116
}
1117
 
1118
/* Returns LHS OP RHS, where OP is a bit-wise operation.  */
1119
static cpp_num
1120
num_bitwise_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1121
                cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1122
{
1123
  lhs.overflow = false;
1124
  lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;
1125
 
1126
  /* As excess precision is zeroed, there is no need to num_trim () as
1127
     these operations cannot introduce a set bit there.  */
1128
  if (op == CPP_AND)
1129
    {
1130
      lhs.low &= rhs.low;
1131
      lhs.high &= rhs.high;
1132
    }
1133
  else if (op == CPP_OR)
1134
    {
1135
      lhs.low |= rhs.low;
1136
      lhs.high |= rhs.high;
1137
    }
1138
  else
1139
    {
1140
      lhs.low ^= rhs.low;
1141
      lhs.high ^= rhs.high;
1142
    }
1143
 
1144
  return lhs;
1145
}
1146
 
1147
/* Returns LHS OP RHS, where OP is an inequality.  */
1148
static cpp_num
1149
num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
1150
                   enum cpp_ttype op)
1151
{
1152
  bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision));
1153
 
1154
  if (op == CPP_GREATER_EQ)
1155
    lhs.low = gte;
1156
  else if (op == CPP_LESS)
1157
    lhs.low = !gte;
1158
  else if (op == CPP_GREATER)
1159
    lhs.low = gte && !num_eq (lhs, rhs);
1160
  else /* CPP_LESS_EQ.  */
1161
    lhs.low = !gte || num_eq (lhs, rhs);
1162
 
1163
  lhs.high = 0;
1164
  lhs.overflow = false;
1165
  lhs.unsignedp = false;
1166
  return lhs;
1167
}
1168
 
1169
/* Returns LHS OP RHS, where OP is == or !=.  */
1170
static cpp_num
1171
num_equality_op (cpp_reader *pfile ATTRIBUTE_UNUSED,
1172
                 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1173
{
1174
  /* Work around a 3.0.4 bug; see PR 6950.  */
1175
  bool eq = num_eq (lhs, rhs);
1176
  if (op == CPP_NOT_EQ)
1177
    eq = !eq;
1178
  lhs.low = eq;
1179
  lhs.high = 0;
1180
  lhs.overflow = false;
1181
  lhs.unsignedp = false;
1182
  return lhs;
1183
}
1184
 
1185
/* Shift NUM, of width PRECISION, right by N bits.  */
1186
static cpp_num
1187
num_rshift (cpp_num num, size_t precision, size_t n)
1188
{
1189
  cpp_num_part sign_mask;
1190
  bool x = num_positive (num, precision);
1191
 
1192
  if (num.unsignedp || x)
1193
    sign_mask = 0;
1194
  else
1195
    sign_mask = ~(cpp_num_part) 0;
1196
 
1197
  if (n >= precision)
1198
    num.high = num.low = sign_mask;
1199
  else
1200
    {
1201
      /* Sign-extend.  */
1202
      if (precision < PART_PRECISION)
1203
        num.high = sign_mask, num.low |= sign_mask << precision;
1204
      else if (precision < 2 * PART_PRECISION)
1205
        num.high |= sign_mask << (precision - PART_PRECISION);
1206
 
1207
      if (n >= PART_PRECISION)
1208
        {
1209
          n -= PART_PRECISION;
1210
          num.low = num.high;
1211
          num.high = sign_mask;
1212
        }
1213
 
1214
      if (n)
1215
        {
1216
          num.low = (num.low >> n) | (num.high << (PART_PRECISION - n));
1217
          num.high = (num.high >> n) | (sign_mask << (PART_PRECISION - n));
1218
        }
1219
    }
1220
 
1221
  num = num_trim (num, precision);
1222
  num.overflow = false;
1223
  return num;
1224
}
1225
 
1226
/* Shift NUM, of width PRECISION, left by N bits.  */
1227
static cpp_num
1228
num_lshift (cpp_num num, size_t precision, size_t n)
1229
{
1230
  if (n >= precision)
1231
    {
1232
      num.overflow = !num.unsignedp && !num_zerop (num);
1233
      num.high = num.low = 0;
1234
    }
1235
  else
1236
    {
1237
      cpp_num orig, maybe_orig;
1238
      size_t m = n;
1239
 
1240
      orig = num;
1241
      if (m >= PART_PRECISION)
1242
        {
1243
          m -= PART_PRECISION;
1244
          num.high = num.low;
1245
          num.low = 0;
1246
        }
1247
      if (m)
1248
        {
1249
          num.high = (num.high << m) | (num.low >> (PART_PRECISION - m));
1250
          num.low <<= m;
1251
        }
1252
      num = num_trim (num, precision);
1253
 
1254
      if (num.unsignedp)
1255
        num.overflow = false;
1256
      else
1257
        {
1258
          maybe_orig = num_rshift (num, precision, n);
1259
          num.overflow = !num_eq (orig, maybe_orig);
1260
        }
1261
    }
1262
 
1263
  return num;
1264
}
1265
 
1266
/* The four unary operators: +, -, ! and ~.  */
1267
static cpp_num
1268
num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
1269
{
1270
  switch (op)
1271
    {
1272
    case CPP_UPLUS:
1273
      if (CPP_WTRADITIONAL (pfile) && !pfile->state.skip_eval)
1274
        cpp_error (pfile, CPP_DL_WARNING,
1275
                   "traditional C rejects the unary plus operator");
1276
      num.overflow = false;
1277
      break;
1278
 
1279
    case CPP_UMINUS:
1280
      num = num_negate (num, CPP_OPTION (pfile, precision));
1281
      break;
1282
 
1283
    case CPP_COMPL:
1284
      num.high = ~num.high;
1285
      num.low = ~num.low;
1286
      num = num_trim (num, CPP_OPTION (pfile, precision));
1287
      num.overflow = false;
1288
      break;
1289
 
1290
    default: /* case CPP_NOT: */
1291
      num.low = num_zerop (num);
1292
      num.high = 0;
1293
      num.overflow = false;
1294
      num.unsignedp = false;
1295
      break;
1296
    }
1297
 
1298
  return num;
1299
}
1300
 
1301
/* The various binary operators.  */
1302
static cpp_num
1303
num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1304
{
1305
  cpp_num result;
1306
  size_t precision = CPP_OPTION (pfile, precision);
1307
  size_t n;
1308
 
1309
  switch (op)
1310
    {
1311
      /* Shifts.  */
1312
    case CPP_LSHIFT:
1313
    case CPP_RSHIFT:
1314
      if (!rhs.unsignedp && !num_positive (rhs, precision))
1315
        {
1316
          /* A negative shift is a positive shift the other way.  */
1317
          if (op == CPP_LSHIFT)
1318
            op = CPP_RSHIFT;
1319
          else
1320
            op = CPP_LSHIFT;
1321
          rhs = num_negate (rhs, precision);
1322
        }
1323
      if (rhs.high)
1324
        n = ~0;                  /* Maximal.  */
1325
      else
1326
        n = rhs.low;
1327
      if (op == CPP_LSHIFT)
1328
        lhs = num_lshift (lhs, precision, n);
1329
      else
1330
        lhs = num_rshift (lhs, precision, n);
1331
      break;
1332
 
1333
      /* Arithmetic.  */
1334
    case CPP_MINUS:
1335
      rhs = num_negate (rhs, precision);
1336
    case CPP_PLUS:
1337
      result.low = lhs.low + rhs.low;
1338
      result.high = lhs.high + rhs.high;
1339
      if (result.low < lhs.low)
1340
        result.high++;
1341
      result.unsignedp = lhs.unsignedp || rhs.unsignedp;
1342
      result.overflow = false;
1343
 
1344
      result = num_trim (result, precision);
1345
      if (!result.unsignedp)
1346
        {
1347
          bool lhsp = num_positive (lhs, precision);
1348
          result.overflow = (lhsp == num_positive (rhs, precision)
1349
                             && lhsp != num_positive (result, precision));
1350
        }
1351
      return result;
1352
 
1353
      /* Comma.  */
1354
    default: /* case CPP_COMMA: */
1355
      if (CPP_PEDANTIC (pfile) && (!CPP_OPTION (pfile, c99)
1356
                                   || !pfile->state.skip_eval))
1357
        cpp_error (pfile, CPP_DL_PEDWARN,
1358
                   "comma operator in operand of #if");
1359
      lhs = rhs;
1360
      break;
1361
    }
1362
 
1363
  return lhs;
1364
}
1365
 
1366
/* Multiplies two unsigned cpp_num_parts to give a cpp_num.  This
1367
   cannot overflow.  */
1368
static cpp_num
1369
num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
1370
{
1371
  cpp_num result;
1372
  cpp_num_part middle[2], temp;
1373
 
1374
  result.low = LOW_PART (lhs) * LOW_PART (rhs);
1375
  result.high = HIGH_PART (lhs) * HIGH_PART (rhs);
1376
 
1377
  middle[0] = LOW_PART (lhs) * HIGH_PART (rhs);
1378
  middle[1] = HIGH_PART (lhs) * LOW_PART (rhs);
1379
 
1380
  temp = result.low;
1381
  result.low += LOW_PART (middle[0]) << (PART_PRECISION / 2);
1382
  if (result.low < temp)
1383
    result.high++;
1384
 
1385
  temp = result.low;
1386
  result.low += LOW_PART (middle[1]) << (PART_PRECISION / 2);
1387
  if (result.low < temp)
1388
    result.high++;
1389
 
1390
  result.high += HIGH_PART (middle[0]);
1391
  result.high += HIGH_PART (middle[1]);
1392
  result.unsignedp = true;
1393
  result.overflow = false;
1394
 
1395
  return result;
1396
}
1397
 
1398
/* Multiply two preprocessing numbers.  */
1399
static cpp_num
1400
num_mul (cpp_reader *pfile, cpp_num lhs, cpp_num rhs)
1401
{
1402
  cpp_num result, temp;
1403
  bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1404
  bool overflow, negate = false;
1405
  size_t precision = CPP_OPTION (pfile, precision);
1406
 
1407
  /* Prepare for unsigned multiplication.  */
1408
  if (!unsignedp)
1409
    {
1410
      if (!num_positive (lhs, precision))
1411
        negate = !negate, lhs = num_negate (lhs, precision);
1412
      if (!num_positive (rhs, precision))
1413
        negate = !negate, rhs = num_negate (rhs, precision);
1414
    }
1415
 
1416
  overflow = lhs.high && rhs.high;
1417
  result = num_part_mul (lhs.low, rhs.low);
1418
 
1419
  temp = num_part_mul (lhs.high, rhs.low);
1420
  result.high += temp.low;
1421
  if (temp.high)
1422
    overflow = true;
1423
 
1424
  temp = num_part_mul (lhs.low, rhs.high);
1425
  result.high += temp.low;
1426
  if (temp.high)
1427
    overflow = true;
1428
 
1429
  temp.low = result.low, temp.high = result.high;
1430
  result = num_trim (result, precision);
1431
  if (!num_eq (result, temp))
1432
    overflow = true;
1433
 
1434
  if (negate)
1435
    result = num_negate (result, precision);
1436
 
1437
  if (unsignedp)
1438
    result.overflow = false;
1439
  else
1440
    result.overflow = overflow || (num_positive (result, precision) ^ !negate
1441
                                   && !num_zerop (result));
1442
  result.unsignedp = unsignedp;
1443
 
1444
  return result;
1445
}
1446
 
1447
/* Divide two preprocessing numbers, returning the answer or the
1448
   remainder depending upon OP.  */
1449
static cpp_num
1450
num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1451
{
1452
  cpp_num result, sub;
1453
  cpp_num_part mask;
1454
  bool unsignedp = lhs.unsignedp || rhs.unsignedp;
1455
  bool negate = false, lhs_neg = false;
1456
  size_t i, precision = CPP_OPTION (pfile, precision);
1457
 
1458
  /* Prepare for unsigned division.  */
1459
  if (!unsignedp)
1460
    {
1461
      if (!num_positive (lhs, precision))
1462
        negate = !negate, lhs_neg = true, lhs = num_negate (lhs, precision);
1463
      if (!num_positive (rhs, precision))
1464
        negate = !negate, rhs = num_negate (rhs, precision);
1465
    }
1466
 
1467
  /* Find the high bit.  */
1468
  if (rhs.high)
1469
    {
1470
      i = precision - 1;
1471
      mask = (cpp_num_part) 1 << (i - PART_PRECISION);
1472
      for (; ; i--, mask >>= 1)
1473
        if (rhs.high & mask)
1474
          break;
1475
    }
1476
  else if (rhs.low)
1477
    {
1478
      if (precision > PART_PRECISION)
1479
        i = precision - PART_PRECISION - 1;
1480
      else
1481
        i = precision - 1;
1482
      mask = (cpp_num_part) 1 << i;
1483
      for (; ; i--, mask >>= 1)
1484
        if (rhs.low & mask)
1485
          break;
1486
    }
1487
  else
1488
    {
1489
      if (!pfile->state.skip_eval)
1490
        cpp_error (pfile, CPP_DL_ERROR, "division by zero in #if");
1491
      return lhs;
1492
    }
1493
 
1494
  /* First nonzero bit of RHS is bit I.  Do naive division by
1495
     shifting the RHS fully left, and subtracting from LHS if LHS is
1496
     at least as big, and then repeating but with one less shift.
1497
     This is not very efficient, but is easy to understand.  */
1498
 
1499
  rhs.unsignedp = true;
1500
  lhs.unsignedp = true;
1501
  i = precision - i - 1;
1502
  sub = num_lshift (rhs, precision, i);
1503
 
1504
  result.high = result.low = 0;
1505
  for (;;)
1506
    {
1507
      if (num_greater_eq (lhs, sub, precision))
1508
        {
1509
          lhs = num_binary_op (pfile, lhs, sub, CPP_MINUS);
1510
          if (i >= PART_PRECISION)
1511
            result.high |= (cpp_num_part) 1 << (i - PART_PRECISION);
1512
          else
1513
            result.low |= (cpp_num_part) 1 << i;
1514
        }
1515
      if (i-- == 0)
1516
        break;
1517
      sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION - 1));
1518
      sub.high >>= 1;
1519
    }
1520
 
1521
  /* We divide so that the remainder has the sign of the LHS.  */
1522
  if (op == CPP_DIV)
1523
    {
1524
      result.unsignedp = unsignedp;
1525
      result.overflow = false;
1526
      if (!unsignedp)
1527
        {
1528
          if (negate)
1529
            result = num_negate (result, precision);
1530
          result.overflow = num_positive (result, precision) ^ !negate;
1531
        }
1532
 
1533
      return result;
1534
    }
1535
 
1536
  /* CPP_MOD.  */
1537
  lhs.unsignedp = unsignedp;
1538
  lhs.overflow = false;
1539
  if (lhs_neg)
1540
    lhs = num_negate (lhs, precision);
1541
 
1542
  return lhs;
1543
}

powered by: WebSVN 2.1.0

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