Subversion Repositories openrisc_2011-10-31

/* Parse C expressions for cpplib.

   Copyright (C) 1987, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2001,

   2002, 2004 Free Software Foundation.

   Contributed by Per Bothner, 1994.

This program is free software; you can redistribute it and/or modify it

under the terms of the GNU General Public License as published by the

Free Software Foundation; either version 2, or (at your option) any

later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, 51 Franklin Street, Fifth Floor,

Boston, MA 02110-1301, USA.  */

#include "config.h"

#include "system.h"

#include "cpplib.h"

#include "internal.h"

#define PART_PRECISION (sizeof (cpp_num_part) * CHAR_BIT)

#define HALF_MASK (~(cpp_num_part) 0 >> (PART_PRECISION / 2))

#define LOW_PART(num_part) (num_part & HALF_MASK)

#define HIGH_PART(num_part) (num_part >> (PART_PRECISION / 2))

struct op

{

  const cpp_token *token;       /* The token forming op (for diagnostics).  */

  cpp_num value;                /* The value logically "right" of op.  */

  enum cpp_ttype op;

};

/* Some simple utility routines on double integers.  */

#define num_zerop(num) ((num.low | num.high) == 0)

#define num_eq(num1, num2) (num1.low == num2.low && num1.high == num2.high)

static bool num_positive (cpp_num, size_t);

static bool num_greater_eq (cpp_num, cpp_num, size_t);

static cpp_num num_trim (cpp_num, size_t);

static cpp_num num_part_mul (cpp_num_part, cpp_num_part);

static cpp_num num_unary_op (cpp_reader *, cpp_num, enum cpp_ttype);

static cpp_num num_binary_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);

static cpp_num num_negate (cpp_num, size_t);

static cpp_num num_bitwise_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);

static cpp_num num_inequality_op (cpp_reader *, cpp_num, cpp_num,

                                  enum cpp_ttype);

static cpp_num num_equality_op (cpp_reader *, cpp_num, cpp_num,

                                enum cpp_ttype);

static cpp_num num_mul (cpp_reader *, cpp_num, cpp_num);

static cpp_num num_div_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);

static cpp_num num_lshift (cpp_num, size_t, size_t);

static cpp_num num_rshift (cpp_num, size_t, size_t);

static cpp_num append_digit (cpp_num, int, int, size_t);

static cpp_num parse_defined (cpp_reader *);

static cpp_num eval_token (cpp_reader *, const cpp_token *);

static struct op *reduce (cpp_reader *, struct op *, enum cpp_ttype);

static unsigned int interpret_float_suffix (const uchar *, size_t);

static unsigned int interpret_int_suffix (const uchar *, size_t);

static void check_promotion (cpp_reader *, const struct op *);

/* Token type abuse to create unary plus and minus operators.  */

#define CPP_UPLUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 1))

#define CPP_UMINUS ((enum cpp_ttype) (CPP_LAST_CPP_OP + 2))

/* With -O2, gcc appears to produce nice code, moving the error

   message load and subsequent jump completely out of the main path.  */

#define SYNTAX_ERROR(msgid) \

  do { cpp_error (pfile, CPP_DL_ERROR, msgid); goto syntax_error; } while(0)

#define SYNTAX_ERROR2(msgid, arg) \

  do { cpp_error (pfile, CPP_DL_ERROR, msgid, arg); goto syntax_error; } \

  while(0)

/* Subroutine of cpp_classify_number.  S points to a float suffix of

   length LEN, possibly zero.  Returns 0 for an invalid suffix, or a

   flag vector describing the suffix.  */

static unsigned int

interpret_float_suffix (const uchar *s, size_t len)

{

  size_t f = 0, l = 0, i = 0, d = 0;

  while (len--)

    switch (s[len])

      {

      case 'f': case 'F': f++; break;

      case 'l': case 'L': l++; break;

      case 'i': case 'I':

      case 'j': case 'J': i++; break;

      case 'd': case 'D':

        /* Disallow fd, ld suffixes.  */

        if (d && (f || l))

          return 0;

        d++;

        break;

      default:

        return 0;

      }

  if (f + l > 1 || i > 1)

    return 0;

  /* Allow dd, df, dl suffixes for decimal float constants.  */

  if (d && ((d + f + l != 2) || i))

    return 0;

  return ((i ? CPP_N_IMAGINARY : 0)

          | (f ? CPP_N_SMALL :

             l ? CPP_N_LARGE : CPP_N_MEDIUM)

          | (d ? CPP_N_DFLOAT : 0));

}

/* Subroutine of cpp_classify_number.  S points to an integer suffix

   of length LEN, possibly zero. Returns 0 for an invalid suffix, or a

   flag vector describing the suffix.  */

static unsigned int

interpret_int_suffix (const uchar *s, size_t len)

{

  size_t u, l, i;

  u = l = i = 0;

  while (len--)

    switch (s[len])

      {

      case 'u': case 'U':       u++; break;

      case 'i': case 'I':

      case 'j': case 'J':       i++; break;

      case 'l': case 'L':       l++;

        /* If there are two Ls, they must be adjacent and the same case.  */

        if (l == 2 && s[len] != s[len + 1])

          return 0;

        break;

      default:

        return 0;

      }

  if (l > 2 || u > 1 || i > 1)

    return 0;

  return ((i ? CPP_N_IMAGINARY : 0)

          | (u ? CPP_N_UNSIGNED : 0)

          | ((l == 0) ? CPP_N_SMALL

             : (l == 1) ? CPP_N_MEDIUM : CPP_N_LARGE));

}

/* Categorize numeric constants according to their field (integer,

   floating point, or invalid), radix (decimal, octal, hexadecimal),

   and type suffixes.  */

unsigned int

cpp_classify_number (cpp_reader *pfile, const cpp_token *token)

{

  const uchar *str = token->val.str.text;

  const uchar *limit;

  unsigned int max_digit, result, radix;

  enum {NOT_FLOAT = 0, AFTER_POINT, AFTER_EXPON} float_flag;

  /* If the lexer has done its job, length one can only be a single

     digit.  Fast-path this very common case.  */

  if (token->val.str.len == 1)

    return CPP_N_INTEGER | CPP_N_SMALL | CPP_N_DECIMAL;

  limit = str + token->val.str.len;

  float_flag = NOT_FLOAT;

  max_digit = 0;

  radix = 10;

  /* First, interpret the radix.  */

  if (*str == '0')

    {

      radix = 8;

      str++;

      /* Require at least one hex digit to classify it as hex.  */

      if ((*str == 'x' || *str == 'X')

          && (str[1] == '.' || ISXDIGIT (str[1])))

        {

          radix = 16;

          str++;

        }

    }

  /* Now scan for a well-formed integer or float.  */

  for (;;)

    {

      unsigned int c = *str++;

      if (ISDIGIT (c) || (ISXDIGIT (c) && radix == 16))

        {

          c = hex_value (c);

          if (c > max_digit)

            max_digit = c;

        }

      else if (c == '.')

        {

          if (float_flag == NOT_FLOAT)

            float_flag = AFTER_POINT;

          else

            SYNTAX_ERROR ("too many decimal points in number");

        }

      else if ((radix <= 10 && (c == 'e' || c == 'E'))

               || (radix == 16 && (c == 'p' || c == 'P')))

        {

          float_flag = AFTER_EXPON;

          break;

        }

      else

        {

          /* Start of suffix.  */

          str--;

          break;

        }

    }

  if (float_flag != NOT_FLOAT && radix == 8)

    radix = 10;

  if (max_digit >= radix)

    SYNTAX_ERROR2 ("invalid digit \"%c\" in octal constant", '0' + max_digit);

  if (float_flag != NOT_FLOAT)

    {

      if (radix == 16 && CPP_PEDANTIC (pfile) && !CPP_OPTION (pfile, c99))

        cpp_error (pfile, CPP_DL_PEDWARN,

                   "use of C99 hexadecimal floating constant");

      if (float_flag == AFTER_EXPON)

        {

          if (*str == '+' || *str == '-')

            str++;

          /* Exponent is decimal, even if string is a hex float.  */

          if (!ISDIGIT (*str))

            SYNTAX_ERROR ("exponent has no digits");

          do

            str++;

          while (ISDIGIT (*str));

        }

      else if (radix == 16)

        SYNTAX_ERROR ("hexadecimal floating constants require an exponent");

      result = interpret_float_suffix (str, limit - str);

      if (result == 0)

        {

          cpp_error (pfile, CPP_DL_ERROR,

                     "invalid suffix \"%.*s\" on floating constant",

                     (int) (limit - str), str);

          return CPP_N_INVALID;

        }

      /* Traditional C didn't accept any floating suffixes.  */

      if (limit != str

          && CPP_WTRADITIONAL (pfile)

          && ! cpp_sys_macro_p (pfile))

        cpp_error (pfile, CPP_DL_WARNING,

                   "traditional C rejects the \"%.*s\" suffix",

                   (int) (limit - str), str);

      /* Radix must be 10 for decimal floats.  */

      if ((result & CPP_N_DFLOAT) && radix != 10)

        {

          cpp_error (pfile, CPP_DL_ERROR,

                     "invalid suffix \"%.*s\" with hexadecimal floating constant",

                     (int) (limit - str), str);

          return CPP_N_INVALID;

        }

      result |= CPP_N_FLOATING;

    }

  else

    {

      result = interpret_int_suffix (str, limit - str);

      if (result == 0)

        {

          cpp_error (pfile, CPP_DL_ERROR,

                     "invalid suffix \"%.*s\" on integer constant",

                     (int) (limit - str), str);

          return CPP_N_INVALID;

        }

      /* Traditional C only accepted the 'L' suffix.

         Suppress warning about 'LL' with -Wno-long-long.  */

      if (CPP_WTRADITIONAL (pfile) && ! cpp_sys_macro_p (pfile))

        {

          int u_or_i = (result & (CPP_N_UNSIGNED|CPP_N_IMAGINARY));

          int large = (result & CPP_N_WIDTH) == CPP_N_LARGE;

          if (u_or_i || (large && CPP_OPTION (pfile, warn_long_long)))

            cpp_error (pfile, CPP_DL_WARNING,

                       "traditional C rejects the \"%.*s\" suffix",

                       (int) (limit - str), str);

        }

      if ((result & CPP_N_WIDTH) == CPP_N_LARGE

          && ! CPP_OPTION (pfile, c99)

          && CPP_OPTION (pfile, warn_long_long))

        cpp_error (pfile, CPP_DL_PEDWARN,

                   "use of C99 long long integer constant");

      result |= CPP_N_INTEGER;

    }

  if ((result & CPP_N_IMAGINARY) && CPP_PEDANTIC (pfile))

    cpp_error (pfile, CPP_DL_PEDWARN,

               "imaginary constants are a GCC extension");

  if (radix == 10)

    result |= CPP_N_DECIMAL;

  else if (radix == 16)

    result |= CPP_N_HEX;

  else

    result |= CPP_N_OCTAL;

  return result;

 syntax_error:

  return CPP_N_INVALID;

}

/* cpp_interpret_integer converts an integer constant into a cpp_num,

   of precision options->precision.

   We do not provide any interface for decimal->float conversion,

   because the preprocessor doesn't need it and we don't want to

   drag in GCC's floating point emulator.  */

cpp_num

cpp_interpret_integer (cpp_reader *pfile, const cpp_token *token,

                       unsigned int type)

{

  const uchar *p, *end;

  cpp_num result;

  result.low = 0;

  result.high = 0;

  result.unsignedp = !!(type & CPP_N_UNSIGNED);

  result.overflow = false;

  p = token->val.str.text;

  end = p + token->val.str.len;

  /* Common case of a single digit.  */

  if (token->val.str.len == 1)

    result.low = p[0] - '0';

  else

    {

      cpp_num_part max;

      size_t precision = CPP_OPTION (pfile, precision);

      unsigned int base = 10, c = 0;

      bool overflow = false;

      if ((type & CPP_N_RADIX) == CPP_N_OCTAL)

        {

          base = 8;

          p++;

        }

      else if ((type & CPP_N_RADIX) == CPP_N_HEX)

        {

          base = 16;

          p += 2;

        }

      /* We can add a digit to numbers strictly less than this without

         needing the precision and slowness of double integers.  */

      max = ~(cpp_num_part) 0;

      if (precision < PART_PRECISION)

        max >>= PART_PRECISION - precision;

      max = (max - base + 1) / base + 1;

      for (; p < end; p++)

        {

          c = *p;

          if (ISDIGIT (c) || (base == 16 && ISXDIGIT (c)))

            c = hex_value (c);

          else

            break;

          /* Strict inequality for when max is set to zero.  */

          if (result.low < max)

            result.low = result.low * base + c;

          else

            {

              result = append_digit (result, c, base, precision);

              overflow |= result.overflow;

              max = 0;

            }

        }

      if (overflow)

        cpp_error (pfile, CPP_DL_PEDWARN,

                   "integer constant is too large for its type");

      /* If too big to be signed, consider it unsigned.  Only warn for

         decimal numbers.  Traditional numbers were always signed (but

         we still honor an explicit U suffix); but we only have

         traditional semantics in directives.  */

      else if (!result.unsignedp

               && !(CPP_OPTION (pfile, traditional)

                    && pfile->state.in_directive)

               && !num_positive (result, precision))

        {

          if (base == 10)

            cpp_error (pfile, CPP_DL_WARNING,

                       "integer constant is so large that it is unsigned");

          result.unsignedp = true;

        }

    }

  return result;

}

/* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE.  */

static cpp_num

append_digit (cpp_num num, int digit, int base, size_t precision)

{

  cpp_num result;

  unsigned int shift = 3 + (base == 16);

  bool overflow;

  cpp_num_part add_high, add_low;

  /* Multiply by 8 or 16.  Catching this overflow here means we don't

     need to worry about add_high overflowing.  */

  overflow = !!(num.high >> (PART_PRECISION - shift));

  result.high = num.high << shift;

  result.low = num.low << shift;

  result.high |= num.low >> (PART_PRECISION - shift);

  result.unsignedp = num.unsignedp;

  if (base == 10)

    {

      add_low = num.low << 1;

      add_high = (num.high << 1) + (num.low >> (PART_PRECISION - 1));

    }

  else

    add_high = add_low = 0;

  if (add_low + digit < add_low)

    add_high++;

  add_low += digit;

  if (result.low + add_low < result.low)

    add_high++;

  if (result.high + add_high < result.high)

    overflow = true;

  result.low += add_low;

  result.high += add_high;

  result.overflow = overflow;

  /* The above code catches overflow of a cpp_num type.  This catches

     overflow of the (possibly shorter) target precision.  */

  num.low = result.low;

  num.high = result.high;

  result = num_trim (result, precision);

  if (!num_eq (result, num))

    result.overflow = true;

  return result;

}

/* Handle meeting "defined" in a preprocessor expression.  */

static cpp_num

parse_defined (cpp_reader *pfile)

{

  cpp_num result;

  int paren = 0;

  cpp_hashnode *node = 0;

  const cpp_token *token;

  cpp_context *initial_context = pfile->context;

  /* Don't expand macros.  */

  pfile->state.prevent_expansion++;

  token = cpp_get_token (pfile);

  if (token->type == CPP_OPEN_PAREN)

    {

      paren = 1;

      token = cpp_get_token (pfile);

    }

  if (token->type == CPP_NAME)

    {

      node = token->val.node;

      if (paren && cpp_get_token (pfile)->type != CPP_CLOSE_PAREN)

        {

          cpp_error (pfile, CPP_DL_ERROR, "missing ')' after \"defined\"");

          node = 0;

        }

    }

  else

    {

      cpp_error (pfile, CPP_DL_ERROR,

                 "operator \"defined\" requires an identifier");

      if (token->flags & NAMED_OP)

        {

          cpp_token op;

          op.flags = 0;

          op.type = token->type;

          cpp_error (pfile, CPP_DL_ERROR,

                     "(\"%s\" is an alternative token for \"%s\" in C++)",

                     cpp_token_as_text (pfile, token),

                     cpp_token_as_text (pfile, &op));

        }

    }

  if (node)

    {

      if (pfile->context != initial_context && CPP_PEDANTIC (pfile))

        cpp_error (pfile, CPP_DL_WARNING,

                   "this use of \"defined\" may not be portable");

      _cpp_mark_macro_used (node);

      /* A possible controlling macro of the form #if !defined ().

         _cpp_parse_expr checks there was no other junk on the line.  */

      pfile->mi_ind_cmacro = node;

    }

  pfile->state.prevent_expansion--;

  result.unsignedp = false;

  result.high = 0;

  result.overflow = false;

  result.low = node && node->type == NT_MACRO;

  return result;

}

/* Convert a token into a CPP_NUMBER (an interpreted preprocessing

   number or character constant, or the result of the "defined" or "#"

   operators).  */

static cpp_num

eval_token (cpp_reader *pfile, const cpp_token *token)

{

  cpp_num result;

  unsigned int temp;

  int unsignedp = 0;

  result.unsignedp = false;

  result.overflow = false;

  switch (token->type)

    {

    case CPP_NUMBER:

      temp = cpp_classify_number (pfile, token);

      switch (temp & CPP_N_CATEGORY)

        {

        case CPP_N_FLOATING:

          cpp_error (pfile, CPP_DL_ERROR,

                     "floating constant in preprocessor expression");

          break;

        case CPP_N_INTEGER:

          if (!(temp & CPP_N_IMAGINARY))

            return cpp_interpret_integer (pfile, token, temp);

          cpp_error (pfile, CPP_DL_ERROR,

                     "imaginary number in preprocessor expression");

          break;

        case CPP_N_INVALID:

          /* Error already issued.  */

          break;

        }

      result.high = result.low = 0;

      break;

    case CPP_WCHAR:

    case CPP_CHAR:

      {

        cppchar_t cc = cpp_interpret_charconst (pfile, token,

                                                &temp, &unsignedp);

        result.high = 0;

        result.low = cc;

        /* Sign-extend the result if necessary.  */

        if (!unsignedp && (cppchar_signed_t) cc < 0)

          {

            if (PART_PRECISION > BITS_PER_CPPCHAR_T)

              result.low |= ~(~(cpp_num_part) 0

                              >> (PART_PRECISION - BITS_PER_CPPCHAR_T));

            result.high = ~(cpp_num_part) 0;

            result = num_trim (result, CPP_OPTION (pfile, precision));

          }

      }

      break;

    case CPP_NAME:

      if (token->val.node == pfile->spec_nodes.n_defined)

        return parse_defined (pfile);

      else if (CPP_OPTION (pfile, cplusplus)

               && (token->val.node == pfile->spec_nodes.n_true

                   || token->val.node == pfile->spec_nodes.n_false))

        {

          result.high = 0;

          result.low = (token->val.node == pfile->spec_nodes.n_true);

        }

      else

        {

          result.high = 0;

          result.low = 0;

          if (CPP_OPTION (pfile, warn_undef) && !pfile->state.skip_eval)

            cpp_error (pfile, CPP_DL_WARNING, "\"%s\" is not defined",

                       NODE_NAME (token->val.node));

        }

      break;

    default: /* CPP_HASH */

      _cpp_test_assertion (pfile, &temp);

      result.high = 0;

      result.low = temp;

    }

  result.unsignedp = !!unsignedp;

  return result;

}

/* Operator precedence and flags table.

After an operator is returned from the lexer, if it has priority less

than the operator on the top of the stack, we reduce the stack by one

operator and repeat the test.  Since equal priorities do not reduce,

this is naturally right-associative.

We handle left-associative operators by decrementing the priority of

just-lexed operators by one, but retaining the priority of operators

already on the stack.

The remaining cases are '(' and ')'.  We handle '(' by skipping the

reduction phase completely.  ')' is given lower priority than

everything else, including '(', effectively forcing a reduction of the

parenthesized expression.  If there is a matching '(', the routine

reduce() exits immediately.  If the normal exit route sees a ')', then

there cannot have been a matching '(' and an error message is output.

The parser assumes all shifted operators require a left operand unless

the flag NO_L_OPERAND is set.  These semantics are automatic; any

extra semantics need to be handled with operator-specific code.  */

/* Flags.  If CHECK_PROMOTION, we warn if the effective sign of an

   operand changes because of integer promotions.  */

#define NO_L_OPERAND    (1 << 0)

#define LEFT_ASSOC      (1 << 1)

#define CHECK_PROMOTION (1 << 2)

/* Operator to priority map.  Must be in the same order as the first

   N entries of enum cpp_ttype.  */

static const struct cpp_operator

{

  uchar prio;

  uchar flags;

} optab[] =

{

  /* EQ */              {0, 0},   /* Shouldn't happen.  */

  /* NOT */             {16, NO_L_OPERAND},

  /* GREATER */         {12, LEFT_ASSOC | CHECK_PROMOTION},

  /* LESS */            {12, LEFT_ASSOC | CHECK_PROMOTION},

  /* PLUS */            {14, LEFT_ASSOC | CHECK_PROMOTION},

  /* MINUS */           {14, LEFT_ASSOC | CHECK_PROMOTION},

  /* MULT */            {15, LEFT_ASSOC | CHECK_PROMOTION},

  /* DIV */             {15, LEFT_ASSOC | CHECK_PROMOTION},