/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/expr.c

Bug Summary

File:	build/libcpp/expr.c
Warning:	line 2161, column 38 The result of the left shift is undefined due to shifting by '18446744073709551551', which is greater or equal to the width of type 'cpp_num_part'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name expr.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -fdeprecated-macro -fdebug-compilation-dir /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/libcpp -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-01-16-135054-17580-1/report-DiEWFd.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/expr.c
1/* Parse C expressions for cpplib.
 Copyright (C) 1987-2021 Free Software Foundation, Inc.
 Contributed by Per Bothner, 1994.

5This program is free software; you can redistribute it and/or modify it
6under the terms of the GNU General Public License as published by the
7Free Software Foundation; either version 3, or (at your option) any
8later version.

10This program is distributed in the hope that it will be useful,
11but WITHOUT ANY WARRANTY; without even the implied warranty of
12MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13GNU General Public License for more details.

15You should have received a copy of the GNU General Public License
16along with this program; see the file COPYING3.  If not see
17<http://www.gnu.org/licenses/>.  */

19#include "config.h"
20#include "system.h"
21#include "cpplib.h"
22#include "internal.h"

24#define PART_PRECISION(sizeof (cpp_num_part) * 8) (sizeof (cpp_num_part) * CHAR_BIT8)
25#define HALF_MASK(~(cpp_num_part) 0 >> ((sizeof (cpp_num_part) * 8) / 2)
) (~(cpp_num_part) 0 >> (PART_PRECISION(sizeof (cpp_num_part) * 8) / 2))
26#define LOW_PART(num_part)(num_part & (~(cpp_num_part) 0 >> ((sizeof (cpp_num_part
) * 8) / 2))) (num_part & HALF_MASK(~(cpp_num_part) 0 >> ((sizeof (cpp_num_part) * 8) / 2)
))
27#define HIGH_PART(num_part)(num_part >> ((sizeof (cpp_num_part) * 8) / 2)) (num_part >> (PART_PRECISION(sizeof (cpp_num_part) * 8) / 2))

29struct op
30{
const cpp_token *token;	/* The token forming op (for diagnostics).  */
cpp_num value;		/* The value logically "right" of op.  */
location_t loc;          /* The location of this value.         */
enum cpp_ttype op;
35};

37/* Some simple utility routines on double integers.  */
38#define num_zerop(num)((num.low | num.high) == 0) ((num.low | num.high) == 0)
39#define num_eq(num1, num2)(num1.low == num2.low && num1.high == num2.high) (num1.low == num2.low && num1.high == num2.high)
40static bool num_positive (cpp_num, size_t);
41static bool num_greater_eq (cpp_num, cpp_num, size_t);
42static cpp_num num_trim (cpp_num, size_t);
43static cpp_num num_part_mul (cpp_num_part, cpp_num_part);

45static cpp_num num_unary_op (cpp_reader *, cpp_num, enum cpp_ttype);
46static cpp_num num_binary_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
47static cpp_num num_negate (cpp_num, size_t);
48static cpp_num num_bitwise_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype);
49static cpp_num num_inequality_op (cpp_reader *, cpp_num, cpp_num,
		  enum cpp_ttype);
51static cpp_num num_equality_op (cpp_reader *, cpp_num, cpp_num,
		enum cpp_ttype);
53static cpp_num num_mul (cpp_reader *, cpp_num, cpp_num);
54static cpp_num num_div_op (cpp_reader *, cpp_num, cpp_num, enum cpp_ttype,
	   location_t);
56static cpp_num num_lshift (cpp_num, size_t, size_t);
57static cpp_num num_rshift (cpp_num, size_t, size_t);

59static cpp_num append_digit (cpp_num, int, int, size_t);
60static cpp_num parse_defined (cpp_reader *);
61static cpp_num eval_token (cpp_reader *, const cpp_token *, location_t);
62static struct op *reduce (cpp_reader *, struct op *, enum cpp_ttype);
63static unsigned int interpret_float_suffix (cpp_reader *, const uchar *, size_t);
64static unsigned int interpret_int_suffix (cpp_reader *, const uchar *, size_t);
65static void check_promotion (cpp_reader *, const struct op *);

67/* Token type abuse to create unary plus and minus operators.  */
68#define CPP_UPLUS((enum cpp_ttype) (CPP_LAST_CPP_OP + 1)) ((enum cpp_ttype) (CPP_LAST_CPP_OP + 1))
69#define CPP_UMINUS((enum cpp_ttype) (CPP_LAST_CPP_OP + 2)) ((enum cpp_ttype) (CPP_LAST_CPP_OP + 2))

71/* With -O2, gcc appears to produce nice code, moving the error
 message load and subsequent jump completely out of the main path.  */
73#define SYNTAX_ERROR(msgid)do { cpp_error (pfile, CPP_DL_ERROR, msgid); goto syntax_error
; } while(0) \
do { cpp_error (pfile, CPP_DL_ERROR, msgid); goto syntax_error; } while(0)
75#define SYNTAX_ERROR2(msgid, arg)do { cpp_error (pfile, CPP_DL_ERROR, msgid, arg); goto syntax_error
; } while(0) \
do { cpp_error (pfile, CPP_DL_ERROR, msgid, arg); goto syntax_error; } \
while(0)
78#define SYNTAX_ERROR_AT(loc, msgid)do { cpp_error_with_line (pfile, CPP_DL_ERROR, (loc), 0, msgid
); goto syntax_error; } while(0) \
do { cpp_error_with_line (pfile, CPP_DL_ERROR, (loc), 0, msgid); goto syntax_error; } \
while(0)
81#define SYNTAX_ERROR2_AT(loc, msgid, arg)do { cpp_error_with_line (pfile, CPP_DL_ERROR, (loc), 0, msgid
, arg); goto syntax_error; } while(0)					\
do { cpp_error_with_line (pfile, CPP_DL_ERROR, (loc), 0, msgid, arg); goto syntax_error; } \
while(0)

85/* 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 (of CPP_N_* bits) describing the suffix.  */
88static unsigned int
89interpret_float_suffix (cpp_reader *pfile, const uchar *s, size_t len)
90{
size_t orig_len = len;
const uchar *orig_s = s;
size_t flags;
size_t f, d, l, w, q, i, fn, fnx, fn_bits;

flags = 0;
f = d = l = w = q = i = fn = fnx = fn_bits = 0;

/* The following decimal float suffixes, from TR 24732:2009, TS
   18661-2:2015 and C2X, are supported:

   df, DF - _Decimal32.
   dd, DD - _Decimal64.
   dl, DL - _Decimal128.

   The dN and DN suffixes for _DecimalN, and dNx and DNx for
   _DecimalNx, defined in TS 18661-3:2015, are not supported.

   Fixed-point suffixes, from TR 18037:2008, are supported.  They
   consist of three parts, in order:

   (i) An optional u or U, for unsigned types.

   (ii) An optional h or H, for short types, or l or L, for long
   types, or ll or LL, for long long types.  Use of ll or LL is a
   GNU extension.

   (iii) r or R, for _Fract types, or k or K, for _Accum types.

   Otherwise the suffix is for a binary or standard floating-point
   type.  Such a suffix, or the absence of a suffix, may be preceded
   or followed by i, I, j or J, to indicate an imaginary number with
   the corresponding complex type.  The following suffixes for
   binary or standard floating-point types are supported:

   f, F - float (ISO C and C++).
   l, L - long double (ISO C and C++).
   d, D - double, even with the FLOAT_CONST_DECIMAL64 pragma in
   operation (from TR 24732:2009; the pragma and the suffix
   are not included in TS 18661-2:2015).
   w, W - machine-specific type such as __float80 (GNU extension).
   q, Q - machine-specific type such as __float128 (GNU extension).
   fN, FN - _FloatN (TS 18661-3:2015).
   fNx, FNx - _FloatNx (TS 18661-3:2015).  */

/* Process decimal float suffixes, which are two letters starting
   with d or D.  Order and case are significant.  */
if (len == 2 && (*s == 'd' || *s == 'D'))
  {
    bool uppercase = (*s == 'D');
    switch (s[1])
    {
    case 'f': return (!uppercase ? (CPP_N_DFLOAT0x4000 | CPP_N_SMALL0x0010): 0); break;
    case 'F': return (uppercase ? (CPP_N_DFLOAT0x4000 | CPP_N_SMALL0x0010) : 0); break;
    case 'd': return (!uppercase ? (CPP_N_DFLOAT0x4000 | CPP_N_MEDIUM0x0020): 0); break;
    case 'D': return (uppercase ? (CPP_N_DFLOAT0x4000 | CPP_N_MEDIUM0x0020) : 0); break;
    case 'l': return (!uppercase ? (CPP_N_DFLOAT0x4000 | CPP_N_LARGE0x0040) : 0); break;
    case 'L': return (uppercase ? (CPP_N_DFLOAT0x4000 | CPP_N_LARGE0x0040) : 0); break;
    default:
/* Additional two-character suffixes beginning with D are not
  for decimal float constants.  */
break;
    }
  }

if (CPP_OPTION (pfile, ext_numeric_literals)((pfile)->opts.ext_numeric_literals))
  {
    /* Recognize a fixed-point suffix.  */
    if (len != 0)
switch (s[len-1])
 {
 case 'k': case 'K': flags = CPP_N_ACCUM0x200000; break;
 case 'r': case 'R': flags = CPP_N_FRACT0x100000; break;
 default: break;
 }

    /* Continue processing a fixed-point suffix.  The suffix is case
insensitive except for ll or LL.  Order is significant.  */
    if (flags)
{
 if (len == 1)
   return flags;
 len--;

 if (*s == 'u' || *s == 'U')
   {
     flags |= CPP_N_UNSIGNED0x1000;
     if (len == 1)
return flags;
     len--;
     s++;
          }

 switch (*s)
 {
 case 'h': case 'H':
   if (len == 1)
     return flags |= CPP_N_SMALL0x0010;
   break;
 case 'l':
   if (len == 1)
     return flags |= CPP_N_MEDIUM0x0020;
   if (len == 2 && s[1] == 'l')
     return flags |= CPP_N_LARGE0x0040;
   break;
 case 'L':
   if (len == 1)
     return flags |= CPP_N_MEDIUM0x0020;
   if (len == 2 && s[1] == 'L')
     return flags |= CPP_N_LARGE0x0040;
   break;
 default:
   break;
 }
 /* Anything left at this point is invalid.  */
 return 0;
}
  }

/* In any remaining valid suffix, the case and order don't matter.  */
while (len--)
  {
    switch (s[0])
{
case 'f': case 'F':
 f++;
 if (len > 0
     && !CPP_OPTION (pfile, cplusplus)((pfile)->opts.cplusplus)
     && s[1] >= '1'
     && s[1] <= '9'
     && fn_bits == 0)
   {
     f--;
     while (len > 0
     && s[1] >= '0'
     && s[1] <= '9'
     && fn_bits < CPP_FLOATN_MAX0xF0)
{
  fn_bits = fn_bits * 10 + (s[1] - '0');
  len--;
  s++;
}
     if (len > 0 && s[1] == 'x')
{
  fnx++;
  len--;
  s++;
}
     else
fn++;
   }
 break;
case 'd': case 'D': d++; break;
case 'l': case 'L': l++; break;
case 'w': case 'W': w++; break;
case 'q': case 'Q': q++; break;
case 'i': case 'I':
case 'j': case 'J': i++; break;
default:
 return 0;
}
    s++;
  }

/* Reject any case of multiple suffixes specifying types, multiple
   suffixes specifying an imaginary constant, _FloatN or _FloatNx
   suffixes for invalid values of N, and _FloatN suffixes for values
   of N larger than can be represented in the return value.  The
   caller is responsible for rejecting _FloatN suffixes where
   _FloatN is not supported on the chosen target.  */
if (f + d + l + w + q + fn + fnx > 1 || i > 1)
  return 0;
if (fn_bits > CPP_FLOATN_MAX0xF0)
  return 0;
if (fnx && fn_bits != 32 && fn_bits != 64 && fn_bits != 128)
  return 0;
if (fn && fn_bits != 16 && fn_bits % 32 != 0)
  return 0;
if (fn && fn_bits == 96)
  return 0;

if (i)
  {
    if (!CPP_OPTION (pfile, ext_numeric_literals)((pfile)->opts.ext_numeric_literals))
return 0;

    /* In C++14 and up these suffixes are in the standard library, so treat
them as user-defined literals.  */
    if (CPP_OPTION (pfile, cplusplus)((pfile)->opts.cplusplus)
 && CPP_OPTION (pfile, lang)((pfile)->opts.lang) > CLK_CXX11
 && orig_s[0] == 'i'
 && (orig_len == 1
     || (orig_len == 2
  && (orig_s[1] == 'f' || orig_s[1] == 'l'))))
return 0;
  }

if ((w || q) && !CPP_OPTION (pfile, ext_numeric_literals)((pfile)->opts.ext_numeric_literals))
  return 0;

return ((i ? CPP_N_IMAGINARY0x2000 : 0)
 | (f ? CPP_N_SMALL0x0010 :
    d ? CPP_N_MEDIUM0x0020 :
    l ? CPP_N_LARGE0x0040 :
    w ? CPP_N_MD_W0x10000 :
    q ? CPP_N_MD_Q0x20000 :
    fn ? CPP_N_FLOATN0x400000 | (fn_bits << CPP_FLOATN_SHIFT24) :
    fnx ? CPP_N_FLOATNX0x800000 | (fn_bits << CPP_FLOATN_SHIFT24) :
    CPP_N_DEFAULT0x8000));
300}

302/* Return the classification flags for a float suffix.  */
303unsigned int
304cpp_interpret_float_suffix (cpp_reader *pfile, const char *s, size_t len)
305{
return interpret_float_suffix (pfile, (const unsigned char *)s, len);
307}

309/* 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.  */
312static unsigned int
313interpret_int_suffix (cpp_reader *pfile, const uchar *s, size_t len)
314{
size_t orig_len = 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;

if (i)
  {
    if (!CPP_OPTION (pfile, ext_numeric_literals)((pfile)->opts.ext_numeric_literals))
return 0;

    /* In C++14 and up these suffixes are in the standard library, so treat
them as user-defined literals.  */
    if (CPP_OPTION (pfile, cplusplus)((pfile)->opts.cplusplus)
 && CPP_OPTION (pfile, lang)((pfile)->opts.lang) > CLK_CXX11
 && s[0] == 'i'
 && (orig_len == 1 || (orig_len == 2 && s[1] == 'l')))
return 0;
  }

return ((i ? CPP_N_IMAGINARY0x2000 : 0)
 | (u ? CPP_N_UNSIGNED0x1000 : 0)
 | ((l == 0) ? CPP_N_SMALL0x0010
    : (l == 1) ? CPP_N_MEDIUM0x0020 : CPP_N_LARGE0x0040));
356}

358/* Return the classification flags for an int suffix.  */
359unsigned int
360cpp_interpret_int_suffix (cpp_reader *pfile, const char *s, size_t len)
361{
return interpret_int_suffix (pfile, (const unsigned char *)s, len);
363}

365/* Return the string type corresponding to the the input user-defined string
 literal type.  If the input type is not a user-defined string literal
 type return the input type.  */
368enum cpp_ttype
369cpp_userdef_string_remove_type (enum cpp_ttype type)
370{
if (type == CPP_STRING_USERDEF)
  return CPP_STRING;
else if (type == CPP_WSTRING_USERDEF)
  return CPP_WSTRING;
else if (type == CPP_STRING16_USERDEF)
  return CPP_STRING16;
else if (type == CPP_STRING32_USERDEF)
  return CPP_STRING32;
else if (type == CPP_UTF8STRING_USERDEF)
  return CPP_UTF8STRING;
else
  return type;
383}

385/* Return the user-defined string literal type corresponding to the input
 string type.  If the input type is not a string type return the input
 type.  */
388enum cpp_ttype
389cpp_userdef_string_add_type (enum cpp_ttype type)
390{
if (type == CPP_STRING)
  return CPP_STRING_USERDEF;
else if (type == CPP_WSTRING)
  return CPP_WSTRING_USERDEF;
else if (type == CPP_STRING16)
  return CPP_STRING16_USERDEF;
else if (type == CPP_STRING32)
  return CPP_STRING32_USERDEF;
else if (type == CPP_UTF8STRING)
  return CPP_UTF8STRING_USERDEF;
else
  return type;
403}

405/* Return the char type corresponding to the the input user-defined char
 literal type.  If the input type is not a user-defined char literal
 type return the input type.  */
408enum cpp_ttype
409cpp_userdef_char_remove_type (enum cpp_ttype type)
410{
if (type == CPP_CHAR_USERDEF)
  return CPP_CHAR;
else if (type == CPP_WCHAR_USERDEF)
  return CPP_WCHAR;
else if (type == CPP_CHAR16_USERDEF)
  return CPP_CHAR16;
else if (type == CPP_CHAR32_USERDEF)
  return CPP_CHAR32;
else if (type == CPP_UTF8CHAR_USERDEF)
  return CPP_UTF8CHAR;
else
  return type;
423}

425/* Return the user-defined char literal type corresponding to the input
 char type.  If the input type is not a char type return the input
 type.  */
428enum cpp_ttype
429cpp_userdef_char_add_type (enum cpp_ttype type)
430{
if (type == CPP_CHAR)
  return CPP_CHAR_USERDEF;
else if (type == CPP_WCHAR)
  return CPP_WCHAR_USERDEF;
else if (type == CPP_CHAR16)
  return CPP_CHAR16_USERDEF;
else if (type == CPP_CHAR32)
  return CPP_CHAR32_USERDEF;
else if (type == CPP_UTF8CHAR)
  return CPP_UTF8CHAR_USERDEF;
else
  return type;
443}

445/* Return true if the token type is a user-defined string literal.  */
446bool
447cpp_userdef_string_p (enum cpp_ttype type)
448{
if (type == CPP_STRING_USERDEF
 || type == CPP_WSTRING_USERDEF
 || type == CPP_STRING16_USERDEF
 || type == CPP_STRING32_USERDEF
 || type == CPP_UTF8STRING_USERDEF)
  return true;
else
  return false;
457}

459/* Return true if the token type is a user-defined char literal.  */
460bool
461cpp_userdef_char_p (enum cpp_ttype type)
462{
if (type == CPP_CHAR_USERDEF
 || type == CPP_WCHAR_USERDEF
 || type == CPP_CHAR16_USERDEF
 || type == CPP_CHAR32_USERDEF
 || type == CPP_UTF8CHAR_USERDEF)
  return true;
else
  return false;
471}

473/* Extract the suffix from a user-defined literal string or char.  */
474const char *
475cpp_get_userdef_suffix (const cpp_token *tok)
476{
unsigned int len = tok->val.str.len;
const char *text = (const char *)tok->val.str.text;
char delim;
unsigned int i;
for (i = 0; i < len; ++i)
  if (text[i] == '\'' || text[i] == '"')
    break;
if (i == len)
  return text + len;
delim = text[i];
for (i = len; i > 0; --i)
  if (text[i - 1] == delim)
    break;
return text + i;
491}

493/* Categorize numeric constants according to their field (integer,
 floating point, or invalid), radix (decimal, octal, hexadecimal),
 and type suffixes.

 TOKEN is the token that represents the numeric constant to
 classify.

 In C++0X if UD_SUFFIX is non null it will be assigned
 any unrecognized suffix for a user-defined literal.

 VIRTUAL_LOCATION is the virtual location for TOKEN.  */
504unsigned int
505cpp_classify_number (cpp_reader *pfile, const cpp_token *token,
     const char **ud_suffix, location_t virtual_location)
507{
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;
bool seen_digit;
bool seen_digit_sep;

if (ud_suffix)
  *ud_suffix = NULL__null;

/* 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_INTEGER0x0001 | CPP_N_SMALL0x0010 | CPP_N_DECIMAL0x0100;

limit = str + token->val.str.len;
float_flag = NOT_FLOAT;
max_digit = 0;
radix = 10;
seen_digit = false;
seen_digit_sep = false;

/* 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')
{
 if (str[1] == '.' || ISXDIGIT (str[1])(_sch_istable[(str[1]) & 0xff] & (unsigned short)(_sch_isxdigit
)))
   {
     radix = 16;
     str++;
   }
 else if (DIGIT_SEP (str[1])((str[1]) == '\'' && ((pfile)->opts.digit_separators
)))
   SYNTAX_ERROR_AT (virtual_location,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "digit separator after base indicator"); goto syntax_error
; } while(0)
	     "digit separator after base indicator")do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "digit separator after base indicator"); goto syntax_error
; } while(0);
}
    else if (*str == 'b' || *str == 'B')
{
 if (str[1] == '0' || str[1] == '1')
   {
     radix = 2;
     str++;
   }
 else if (DIGIT_SEP (str[1])((str[1]) == '\'' && ((pfile)->opts.digit_separators
)))
   SYNTAX_ERROR_AT (virtual_location,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "digit separator after base indicator"); goto syntax_error
; } while(0)
	     "digit separator after base indicator")do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "digit separator after base indicator"); goto syntax_error
; } while(0);
}
  }

/* Now scan for a well-formed integer or float.  */
for (;;)
  {
    unsigned int c = *str++;

    if (ISDIGIT (c)(_sch_istable[(c) & 0xff] & (unsigned short)(_sch_isdigit
)) || (ISXDIGIT (c)(_sch_istable[(c) & 0xff] & (unsigned short)(_sch_isxdigit
)) && radix == 16))
{
 seen_digit_sep = false;
 seen_digit = true;
 c = hex_value (c)((unsigned int) _hex_value[(unsigned char) (c)]);
 if (c > max_digit)
   max_digit = c;
}
    else if (DIGIT_SEP (c)((c) == '\'' && ((pfile)->opts.digit_separators)))
{
 if (seen_digit_sep)
   SYNTAX_ERROR_AT (virtual_location, "adjacent digit separators")do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "adjacent digit separators"); goto syntax_error; } while
(0);
 seen_digit_sep = true;
}
    else if (c == '.')
{
 if (seen_digit_sep || DIGIT_SEP (*str)((*str) == '\'' && ((pfile)->opts.digit_separators
)))
   SYNTAX_ERROR_AT (virtual_location,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "digit separator adjacent to decimal point"); goto syntax_error
; } while(0)
	     "digit separator adjacent to decimal point")do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "digit separator adjacent to decimal point"); goto syntax_error
; } while(0);
 seen_digit_sep = false;
 if (float_flag == NOT_FLOAT)
   float_flag = AFTER_POINT;
 else
   SYNTAX_ERROR_AT (virtual_location,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "too many decimal points in number"); goto syntax_error
; } while(0)
	     "too many decimal points in number")do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "too many decimal points in number"); goto syntax_error
; } while(0);
}
    else if ((radix <= 10 && (c == 'e' || c == 'E'))
      || (radix == 16 && (c == 'p' || c == 'P')))
{
 if (seen_digit_sep || DIGIT_SEP (*str)((*str) == '\'' && ((pfile)->opts.digit_separators
)))
   SYNTAX_ERROR_AT (virtual_location,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "digit separator adjacent to exponent"); goto syntax_error
; } while(0)
	     "digit separator adjacent to exponent")do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "digit separator adjacent to exponent"); goto syntax_error
; } while(0);
 float_flag = AFTER_EXPON;
 break;
}
    else
{
 /* Start of suffix.  */
 str--;
 break;
}
  }

if (seen_digit_sep && float_flag != AFTER_EXPON)
  SYNTAX_ERROR_AT (virtual_location,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "digit separator outside digit sequence"); goto syntax_error
; } while(0)
     "digit separator outside digit sequence")do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "digit separator outside digit sequence"); goto syntax_error
; } while(0);

/* The suffix may be for decimal fixed-point constants without exponent.  */
if (radix != 16 && float_flag == NOT_FLOAT)
  {
    result = interpret_float_suffix (pfile, str, limit - str);
    if ((result & CPP_N_FRACT0x100000) || (result & CPP_N_ACCUM0x200000))
{
 result |= CPP_N_FLOATING0x0002;
 /* We need to restore the radix to 10, if the radix is 8.  */
 if (radix == 8)
   radix = 10;

 if (CPP_PEDANTIC (pfile)((pfile)->opts.cpp_pedantic))
   cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
		 "fixed-point constants are a GCC extension");
 goto syntax_ok;
}
    else
result = 0;
  }

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

if (max_digit >= radix)
  {
    if (radix == 2)
SYNTAX_ERROR2_AT (virtual_location,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "invalid digit \"%c\" in binary constant", '0' + max_digit
); goto syntax_error; } while(0)
	  "invalid digit \"%c\" in binary constant", '0' + max_digit)do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "invalid digit \"%c\" in binary constant", '0' + max_digit
); goto syntax_error; } while(0);
    else
SYNTAX_ERROR2_AT (virtual_location,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "invalid digit \"%c\" in octal constant", '0' + max_digit
); goto syntax_error; } while(0)
	  "invalid digit \"%c\" in octal constant", '0' + max_digit)do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "invalid digit \"%c\" in octal constant", '0' + max_digit
); goto syntax_error; } while(0);
  }

if (float_flag != NOT_FLOAT)
  {
    if (radix == 2)
{
 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
	       "invalid prefix \"0b\" for floating constant");
 return CPP_N_INVALID0x0000;
}

    if (radix == 16 && !seen_digit)
SYNTAX_ERROR_AT (virtual_location,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "no digits in hexadecimal floating constant"); goto syntax_error
; } while(0)
	 "no digits in hexadecimal floating constant")do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "no digits in hexadecimal floating constant"); goto syntax_error
; } while(0);

    if (radix == 16 && CPP_PEDANTIC (pfile)((pfile)->opts.cpp_pedantic)
 && !CPP_OPTION (pfile, extended_numbers)((pfile)->opts.extended_numbers))
{
 if (CPP_OPTION (pfile, cplusplus)((pfile)->opts.cplusplus))
   cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
		 "use of C++17 hexadecimal floating constant");
 else
   cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
		 "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)(_sch_istable[(*str) & 0xff] & (unsigned short)(_sch_isdigit
)))
   {
     if (DIGIT_SEP (*str)((*str) == '\'' && ((pfile)->opts.digit_separators
)))
SYNTAX_ERROR_AT (virtual_location,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "digit separator adjacent to exponent"); goto syntax_error
; } while(0)
		 "digit separator adjacent to exponent")do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "digit separator adjacent to exponent"); goto syntax_error
; } while(0);
     else
SYNTAX_ERROR_AT (virtual_location, "exponent has no digits")do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "exponent has no digits"); goto syntax_error; } while(0
);
   }
 do
   {
     seen_digit_sep = DIGIT_SEP (*str)((*str) == '\'' && ((pfile)->opts.digit_separators
));
     str++;
   }
 while (ISDIGIT (*str)(_sch_istable[(*str) & 0xff] & (unsigned short)(_sch_isdigit
)) || DIGIT_SEP (*str)((*str) == '\'' && ((pfile)->opts.digit_separators
)));
}
    else if (radix == 16)
SYNTAX_ERROR_AT (virtual_location,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "hexadecimal floating constants require an exponent"); goto
 syntax_error; } while(0)
	 "hexadecimal floating constants require an exponent")do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "hexadecimal floating constants require an exponent"); goto
 syntax_error; } while(0);

    if (seen_digit_sep)
SYNTAX_ERROR_AT (virtual_location,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "digit separator outside digit sequence"); goto syntax_error
; } while(0)
	 "digit separator outside digit sequence")do { cpp_error_with_line (pfile, CPP_DL_ERROR, (virtual_location
), 0, "digit separator outside digit sequence"); goto syntax_error
; } while(0);

    result = interpret_float_suffix (pfile, str, limit - str);
    if (result == 0)
{
 if (CPP_OPTION (pfile, user_literals)((pfile)->opts.user_literals))
   {
     if (ud_suffix)
*ud_suffix = (const char *) str;
     result = CPP_N_LARGE0x0040 | CPP_N_USERDEF0x1000000;
   }
 else
   {
     cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
		   "invalid suffix \"%.*s\" on floating constant",
		   (int) (limit - str), str);
     return CPP_N_INVALID0x0000;
   }
}

    /* Traditional C didn't accept any floating suffixes.  */
    if (limit != str
 && CPP_WTRADITIONAL (pfile)((pfile)->opts.cpp_warn_traditional)
 && ! cpp_sys_macro_p (pfile))
cpp_warning_with_line (pfile, CPP_W_TRADITIONAL, virtual_location, 0,
	       "traditional C rejects the \"%.*s\" suffix",
	       (int) (limit - str), str);

    /* A suffix for double is a GCC extension via decimal float support.
If the suffix also specifies an imaginary value we'll catch that
later.  */
    if ((result == CPP_N_MEDIUM0x0020) && CPP_PEDANTIC (pfile)((pfile)->opts.cpp_pedantic))
cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
	     "suffix for double constant is a GCC extension");

    /* Radix must be 10 for decimal floats.  */
    if ((result & CPP_N_DFLOAT0x4000) && radix != 10)
      {
        cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
	       "invalid suffix \"%.*s\" with hexadecimal floating constant",
	       (int) (limit - str), str);
        return CPP_N_INVALID0x0000;
      }

    if ((result & (CPP_N_FRACT0x100000 | CPP_N_ACCUM0x200000)) && CPP_PEDANTIC (pfile)((pfile)->opts.cpp_pedantic))
cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
	     "fixed-point constants are a GCC extension");

    if (result & CPP_N_DFLOAT0x4000)
{
 if (CPP_PEDANTIC (pfile)((pfile)->opts.cpp_pedantic) && !CPP_OPTION (pfile, dfp_constants)((pfile)->opts.dfp_constants))
   cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
		 "decimal float constants are a C2X feature");
 else if (CPP_OPTION (pfile, cpp_warn_c11_c2x_compat)((pfile)->opts.cpp_warn_c11_c2x_compat) > 0)
   cpp_warning_with_line (pfile, CPP_W_C11_C2X_COMPAT,
		   virtual_location, 0,
		   "decimal float constants are a C2X feature");
}

    result |= CPP_N_FLOATING0x0002;
  }
else
  {
    result = interpret_int_suffix (pfile, str, limit - str);
    if (result == 0)
{
 if (CPP_OPTION (pfile, user_literals)((pfile)->opts.user_literals))
   {
     if (ud_suffix)
*ud_suffix = (const char *) str;
     result = CPP_N_UNSIGNED0x1000 | CPP_N_LARGE0x0040 | CPP_N_USERDEF0x1000000;
   }
 else
   {
     cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
		   "invalid suffix \"%.*s\" on integer constant",
		   (int) (limit - str), str);
     return CPP_N_INVALID0x0000;
   }
}

    /* Traditional C only accepted the 'L' suffix.
       Suppress warning about 'LL' with -Wno-long-long.  */
    if (CPP_WTRADITIONAL (pfile)((pfile)->opts.cpp_warn_traditional) && ! cpp_sys_macro_p (pfile))
{
 int u_or_i = (result & (CPP_N_UNSIGNED0x1000|CPP_N_IMAGINARY0x2000));
 int large = (result & CPP_N_WIDTH0x00F0) == CPP_N_LARGE0x0040
       && CPP_OPTION (pfile, cpp_warn_long_long)((pfile)->opts.cpp_warn_long_long);

 if (u_or_i || large)
   cpp_warning_with_line (pfile, large ? CPP_W_LONG_LONG : CPP_W_TRADITIONAL,
		   virtual_location, 0,
		   "traditional C rejects the \"%.*s\" suffix",
		   (int) (limit - str), str);
}

    if ((result & CPP_N_WIDTH0x00F0) == CPP_N_LARGE0x0040
 && CPP_OPTION (pfile, cpp_warn_long_long)((pfile)->opts.cpp_warn_long_long))
      {
        const char *message = CPP_OPTION (pfile, cplusplus)((pfile)->opts.cplusplus) 
		? N_("use of C++11 long long integer constant")"use of C++11 long long integer constant"
                : N_("use of C99 long long integer constant")"use of C99 long long integer constant";

 if (CPP_OPTION (pfile, c99)((pfile)->opts.c99))
          cpp_warning_with_line (pfile, CPP_W_LONG_LONG, virtual_location,
		   0, message);
        else
          cpp_pedwarning_with_line (pfile, CPP_W_LONG_LONG,
		      virtual_location, 0, message);
      }

    result |= CPP_N_INTEGER0x0001;
  }

syntax_ok:
if ((result & CPP_N_IMAGINARY0x2000) && CPP_PEDANTIC (pfile)((pfile)->opts.cpp_pedantic))
  cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
	 "imaginary constants are a GCC extension");
if (radix == 2)
  {
    if (!CPP_OPTION (pfile, binary_constants)((pfile)->opts.binary_constants)
 && CPP_PEDANTIC (pfile)((pfile)->opts.cpp_pedantic))
cpp_error_with_line (pfile, CPP_DL_PEDWARN, virtual_location, 0,
	     CPP_OPTION (pfile, cplusplus)((pfile)->opts.cplusplus)
	     ? N_("binary constants are a C++14 feature ""binary constants are a C++14 feature " "or GCC extension"
		  "or GCC extension")"binary constants are a C++14 feature " "or GCC extension"
	     : N_("binary constants are a C2X feature ""binary constants are a C2X feature " "or GCC extension"
		  "or GCC extension")"binary constants are a C2X feature " "or GCC extension");
    else if (CPP_OPTION (pfile, cpp_warn_c11_c2x_compat)((pfile)->opts.cpp_warn_c11_c2x_compat) > 0)
cpp_warning_with_line (pfile, CPP_W_C11_C2X_COMPAT,
	       virtual_location, 0,
	       "binary constants are a C2X feature");
  }

if (radix == 10)
  result |= CPP_N_DECIMAL0x0100;
else if (radix == 16)
  result |= CPP_N_HEX0x0200;
else if (radix == 2)
  result |= CPP_N_BINARY0x0800;
else
  result |= CPP_N_OCTAL0x0400;

return result;

syntax_error:
return CPP_N_INVALID0x0000;
844}

846/* 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.  */
852cpp_num
853cpp_interpret_integer (cpp_reader *pfile, const cpp_token *token,
       unsigned int type)
855{
const uchar *p, *end;
cpp_num result;

result.low = 0;
result.high = 0;
result.unsignedp = !!(type & CPP_N_UNSIGNED0x1000);
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)((pfile)->opts.precision);
    unsigned int base = 10, c = 0;
    bool overflow = false;

    if ((type & CPP_N_RADIX0x0F00) == CPP_N_OCTAL0x0400)
{
 base = 8;
 p++;
}
    else if ((type & CPP_N_RADIX0x0F00) == CPP_N_HEX0x0200)
{
 base = 16;
 p += 2;
}
    else if ((type & CPP_N_RADIX0x0F00) == CPP_N_BINARY0x0800)
{
 base = 2;
 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(sizeof (cpp_num_part) * 8))
max >>= PART_PRECISION(sizeof (cpp_num_part) * 8) - precision;
    max = (max - base + 1) / base + 1;

    for (; p < end; p++)
{
 c = *p;

 if (ISDIGIT (c)(_sch_istable[(c) & 0xff] & (unsigned short)(_sch_isdigit
)) || (base == 16 && ISXDIGIT (c)(_sch_istable[(c) & 0xff] & (unsigned short)(_sch_isxdigit
))))
   c = hex_value (c)((unsigned int) _hex_value[(unsigned char) (c)]);
 else if (DIGIT_SEP (c)((c) == '\'' && ((pfile)->opts.digit_separators)))
   continue;
 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 && !(type & CPP_N_USERDEF0x1000000))
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)->opts.traditional)
    && pfile->state.in_directive)
      && !num_positive (result, precision))
{
 /* This is for constants within the range of uintmax_t but
    not that of intmax_t.  For such decimal constants, a
    diagnostic is required for C99 as the selected type must
    be signed and not having a type is a constraint violation
    (DR#298, TC3), so this must be a pedwarn.  For C90,
    unsigned long is specified to be used for a constant that
    does not fit in signed long; if uintmax_t has the same
    range as unsigned long this means only a warning is
    appropriate here.  C90 permits the preprocessor to use a
    wider range than unsigned long in the compiler, so if
    uintmax_t is wider than unsigned long no diagnostic is
    required for such constants in preprocessor #if
    expressions and the compiler will pedwarn for such
    constants outside the range of unsigned long that reach
    the compiler so a diagnostic is not required there
    either; thus, pedwarn for C99 but use a plain warning for
    C90.  */
 if (base == 10)
   cpp_error (pfile, (CPP_OPTION (pfile, c99)((pfile)->opts.c99)
	       ? CPP_DL_PEDWARN
	       : CPP_DL_WARNING),
       "integer constant is so large that it is unsigned");
 result.unsignedp = true;
}
  }

return result;
961}

963/* Append DIGIT to NUM, a number of PRECISION bits being read in base BASE.  */
964static cpp_num
965append_digit (cpp_num num, int digit, int base, size_t precision)
966{
cpp_num result;
unsigned int shift;
bool overflow;
cpp_num_part add_high, add_low;

/* Multiply by 2, 8 or 16.  Catching this overflow here means we don't
   need to worry about add_high overflowing.  */
switch (base)
  {
  case 2:
    shift = 1;
    break;

  case 16:
    shift = 4;
    break;

  default:
    shift = 3;
  }
overflow = !!(num.high >> (PART_PRECISION(sizeof (cpp_num_part) * 8) - shift));
result.high = num.high << shift;
result.low = num.low << shift;
result.high |= num.low >> (PART_PRECISION(sizeof (cpp_num_part) * 8) - shift);
result.unsignedp = num.unsignedp;

if (base == 10)
  {
    add_low = num.low << 1;
    add_high = (num.high << 1) + (num.low >> (PART_PRECISION(sizeof (cpp_num_part) * 8) - 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.low == num.low && result.high == num.high))
  result.overflow = true;

return result;
1023}

1025/* Handle meeting "defined" in a preprocessor expression.  */
1026static cpp_num
1027parse_defined (cpp_reader *pfile)
1028{
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.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(1 << 4))
{
 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));
}
  }

bool is_defined = false;
if (node)
  {
    if ((pfile->context != initial_context
  || initial_context != &pfile->base_context)
 && CPP_OPTION (pfile, warn_expansion_to_defined)((pfile)->opts.warn_expansion_to_defined))
      cpp_pedwarning (pfile, CPP_W_EXPANSION_TO_DEFINED,
        "this use of \"defined\" may not be portable");
    is_defined = _cpp_defined_macro_p (node);
    if (!_cpp_maybe_notify_macro_use (pfile, node, token->src_loc))
/* It wasn't a macro after all.  */
is_defined = false;
    _cpp_mark_macro_used (node)(cpp_user_macro_p (node) ? (node)->value.macro->used = 1
 : 0);

    /* 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--;

/* Do not treat conditional macros as being defined.  This is due to the
   powerpc port using conditional macros for 'vector', 'bool', and 'pixel'
   to act as conditional keywords.  This messes up tests like #ifndef
   bool.  */
result.unsignedp = false;
result.high = 0;
result.overflow = false;
result.low = is_defined;
return result;
1101}

1103/* Convert a token into a CPP_NUMBER (an interpreted preprocessing
 number or character constant, or the result of the "defined" or "#"
 operators).  */
1106static cpp_num
1107eval_token (cpp_reader *pfile, const cpp_token *token,
   location_t virtual_location)
1109{
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, NULL__null, virtual_location);
    if (temp & CPP_N_USERDEF0x1000000)
cpp_error (pfile, CPP_DL_ERROR,
   "user-defined literal in preprocessor expression");
    switch (temp & CPP_N_CATEGORY0x000F)
{
case CPP_N_FLOATING0x0002:
 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
	       "floating constant in preprocessor expression");
 break;
case CPP_N_INTEGER0x0001:
 if (!(temp & CPP_N_IMAGINARY0x2000))
   return cpp_interpret_integer (pfile, token, temp);
 cpp_error_with_line (pfile, CPP_DL_ERROR, virtual_location, 0,
	       "imaginary number in preprocessor expression");
 break;

case CPP_N_INVALID0x0000:
 /* Error already issued.  */
 break;
}
    result.high = result.low = 0;
    break;

  case CPP_WCHAR:
  case CPP_CHAR:
  case CPP_CHAR16:
  case CPP_CHAR32:
  case CPP_UTF8CHAR:
    {
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(sizeof (cpp_num_part) * 8) > BITS_PER_CPPCHAR_T(8 * sizeof (cppchar_t)))
     result.low |= ~(~(cpp_num_part) 0
	      >> (PART_PRECISION(sizeof (cpp_num_part) * 8) - BITS_PER_CPPCHAR_T(8 * sizeof (cppchar_t))));
   result.high = ~(cpp_num_part) 0;
   result = num_trim (result, CPP_OPTION (pfile, precision)((pfile)->opts.precision));
 }
    }
    break;

  case CPP_NAME:
    if (token->val.node.node == pfile->spec_nodes.n_defined)
return parse_defined (pfile);
    else if (CPP_OPTION (pfile, cplusplus)((pfile)->opts.cplusplus)
      && (token->val.node.node == pfile->spec_nodes.n_true
   || token->val.node.node == pfile->spec_nodes.n_false))
{
 result.high = 0;
 result.low = (token->val.node.node == pfile->spec_nodes.n_true);
}
    else
{
 result.high = 0;
 result.low = 0;
 if (CPP_OPTION (pfile, warn_undef)((pfile)->opts.warn_undef) && !pfile->state.skip_eval)
   cpp_warning_with_line (pfile, CPP_W_UNDEF, virtual_location, 0,
		   "\"%s\" is not defined, evaluates to 0",
		   NODE_NAME (token->val.node.node)(((&(token->val.node.node)->ident))->str));
}
    break;

  case CPP_HASH:
    if (!pfile->state.skipping)
{
 /* A pedantic warning takes precedence over a deprecated
    warning here.  */
 if (CPP_PEDANTIC (pfile)((pfile)->opts.cpp_pedantic))
   cpp_error_with_line (pfile, CPP_DL_PEDWARN,
		 virtual_location, 0,
		 "assertions are a GCC extension");
 else if (CPP_OPTION (pfile, cpp_warn_deprecated)((pfile)->opts.cpp_warn_deprecated))
   cpp_warning_with_line (pfile, CPP_W_DEPRECATED, virtual_location, 0,
		   "assertions are a deprecated extension");
}
    _cpp_test_assertion (pfile, &temp);
    result.high = 0;
    result.low = temp;
    break;

  default:
    abort ()fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libcpp/expr.c"
, 1207, __FUNCTION__);
  }

result.unsignedp = !!unsignedp;
return result;
1212}
1213
1214/* Operator precedence and flags table.

1216After an operator is returned from the lexer, if it has priority less
1217than the operator on the top of the stack, we reduce the stack by one
1218operator and repeat the test.  Since equal priorities do not reduce,
1219this is naturally right-associative.

1221We handle left-associative operators by decrementing the priority of
1222just-lexed operators by one, but retaining the priority of operators
1223already on the stack.

1225The remaining cases are '(' and ')'.  We handle '(' by skipping the
1226reduction phase completely.  ')' is given lower priority than
1227everything else, including '(', effectively forcing a reduction of the
1228parenthesized expression.  If there is a matching '(', the routine
1229reduce() exits immediately.  If the normal exit route sees a ')', then
1230there cannot have been a matching '(' and an error message is output.

1232The parser assumes all shifted operators require a left operand unless
1233the flag NO_L_OPERAND is set.  These semantics are automatic; any
1234extra semantics need to be handled with operator-specific code.  */

1236/* Flags.  If CHECK_PROMOTION, we warn if the effective sign of an
 operand changes because of integer promotions.  */
1238#define NO_L_OPERAND(1 << 0)	(1 << 0)
1239#define LEFT_ASSOC(1 << 1)	(1 << 1)
1240#define CHECK_PROMOTION(1 << 2)	(1 << 2)

1242/* Operator to priority map.  Must be in the same order as the first
 N entries of enum cpp_ttype.  */
1244static const struct cpp_operator
1245{
uchar prio;
uchar flags;
1248} optab[] =
1249{
/* EQ */		{0, 0},	/* Shouldn't happen.  */
/* NOT */		{16, NO_L_OPERAND(1 << 0)},
/* GREATER */		{12, LEFT_ASSOC(1 << 1) | CHECK_PROMOTION(1 << 2)},
/* LESS */		{12, LEFT_ASSOC(1 << 1) | CHECK_PROMOTION(1 << 2)},
/* PLUS */		{14, LEFT_ASSOC(1 << 1) | CHECK_PROMOTION(1 << 2)},
/* MINUS */		{14, LEFT_ASSOC(1 << 1) | CHECK_PROMOTION(1 << 2)},
/* MULT */		{15, LEFT_ASSOC(1 << 1) | CHECK_PROMOTION(1 << 2)},
/* DIV */		{15, LEFT_ASSOC(1 << 1) | CHECK_PROMOTION(1 << 2)},
/* MOD */		{15, LEFT_ASSOC(1 << 1) | CHECK_PROMOTION(1 << 2)},
/* AND */		{9, LEFT_ASSOC(1 << 1) | CHECK_PROMOTION(1 << 2)},
/* OR */		{7, LEFT_ASSOC(1 << 1) | CHECK_PROMOTION(1 << 2)},
/* XOR */		{8, LEFT_ASSOC(1 << 1) | CHECK_PROMOTION(1 << 2)},
/* RSHIFT */		{13, LEFT_ASSOC(1 << 1)},
/* LSHIFT */		{13, LEFT_ASSOC(1 << 1)},

/* COMPL */		{16, NO_L_OPERAND(1 << 0)},
/* AND_AND */		{6, LEFT_ASSOC(1 << 1)},
/* OR_OR */		{5, LEFT_ASSOC(1 << 1)},
/* Note that QUERY, COLON, and COMMA must have the same precedence.
   However, there are some special cases for these in reduce().  */
/* QUERY */		{4, 0},
/* COLON */		{4, LEFT_ASSOC(1 << 1) | CHECK_PROMOTION(1 << 2)},
/* COMMA */		{4, LEFT_ASSOC(1 << 1)},
/* OPEN_PAREN */	{1, NO_L_OPERAND(1 << 0)},
/* CLOSE_PAREN */	{0, 0},
/* EOF */		{0, 0},
/* EQ_EQ */		{11, LEFT_ASSOC(1 << 1)},
/* NOT_EQ */		{11, LEFT_ASSOC(1 << 1)},
/* GREATER_EQ */	{12, LEFT_ASSOC(1 << 1) | CHECK_PROMOTION(1 << 2)},
/* LESS_EQ */		{12, LEFT_ASSOC(1 << 1) | CHECK_PROMOTION(1 << 2)},
/* UPLUS */		{16, NO_L_OPERAND(1 << 0)},
/* UMINUS */		{16, NO_L_OPERAND(1 << 0)}
1282};

1284/* Parse and evaluate a C expression, reading from PFILE.
 Returns the truth value of the expression.

 The implementation is an operator precedence parser, i.e. a
 bottom-up parser, using a stack for not-yet-reduced tokens.

 The stack base is op_stack, and the current stack pointer is 'top'.
 There is a stack element for each operator (only), and the most
 recently pushed operator is 'top->op'.  An operand (value) is
 stored in the 'value' field of the stack element of the operator
 that precedes it.  */
1295bool
1296_cpp_parse_expr (cpp_reader *pfile, bool is_if)
1297{
struct op *top = pfile->op_stack;
unsigned int lex_count;
bool saw_leading_not, want_value = true;
location_t virtual_location = 0;

pfile->state.skip_eval = 0;

/* Set up detection of #if ! defined().  */
pfile->mi_ind_cmacro = 0;
saw_leading_not = false;
lex_count = 0;

/* Lowest priority operator prevents further reductions.  */
top->op = CPP_EOF;

for (;;)
1
Loop condition is true.  Entering loop body→
17
←
Loop condition is true.  Entering loop body→
  {
    struct op op;

    lex_count++;
    op.token = cpp_get_token_with_location (pfile, &virtual_location);
    op.op = op.token->type;
    op.loc = virtual_location;

    switch (op.op)
2
←
Control jumps to the 'default' case at line 1353→
18
←
Control jumps to 'case CPP_NOT:'  at line 1341→
{
 /* These tokens convert into values.  */
case CPP_NUMBER:
case CPP_CHAR:
case CPP_WCHAR:
case CPP_CHAR16:
case CPP_CHAR32:
case CPP_UTF8CHAR:
case CPP_NAME:
case CPP_HASH:
 if (!want_value)
   SYNTAX_ERROR2_AT (op.loc,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "missing binary operator before token \"%s\""
, cpp_token_as_text (pfile, op.token)); goto syntax_error; } while
(0)
	      "missing binary operator before token \"%s\"",do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "missing binary operator before token \"%s\""
, cpp_token_as_text (pfile, op.token)); goto syntax_error; } while
(0)
	      cpp_token_as_text (pfile, op.token))do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "missing binary operator before token \"%s\""
, cpp_token_as_text (pfile, op.token)); goto syntax_error; } while
(0);
 want_value = false;
 top->value = eval_token (pfile, op.token, op.loc);
 continue;

case CPP_NOT:
 saw_leading_not = lex_count == 1;
 break;
19
←
 Execution continues on line 1362→
case CPP_PLUS:
 if (want_value)
   op.op = CPP_UPLUS((enum cpp_ttype) (CPP_LAST_CPP_OP + 1));
 break;
case CPP_MINUS:
 if (want_value)
   op.op = CPP_UMINUS((enum cpp_ttype) (CPP_LAST_CPP_OP + 2));
 break;

default:
 if ((int) op.op <= (int) CPP_EQ || (int) op.op >= (int) CPP_PLUS_EQ)
3
←
Assuming field 'op' is > CPP_EQ→
4
←
Assuming field 'op' is < CPP_PLUS_EQ→
5
←
Taking false branch→
   SYNTAX_ERROR2_AT (op.loc,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "token \"%s\" is not valid in preprocessor expressions"
, cpp_token_as_text (pfile, op.token)); goto syntax_error; } while
(0)
	      "token \"%s\" is not valid in preprocessor expressions",do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "token \"%s\" is not valid in preprocessor expressions"
, cpp_token_as_text (pfile, op.token)); goto syntax_error; } while
(0)
	      cpp_token_as_text (pfile, op.token))do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "token \"%s\" is not valid in preprocessor expressions"
, cpp_token_as_text (pfile, op.token)); goto syntax_error; } while
(0);
 break;
6
←
 Execution continues on line 1362→
}

    /* Check we have a value or operator as appropriate.  */
    if (optab[op.op].flags & NO_L_OPERAND(1 << 0))
7
←
Assuming the condition is true→
8
←
Taking true branch→
20
←
Assuming the condition is true→
21
←
Taking true branch→
{
 if (!want_value8.1
'want_value' is true
1
'want_value' is true
)
9
←
Taking false branch→
22
←
Taking false branch→
   SYNTAX_ERROR2_AT (op.loc,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "missing binary operator before token \"%s\""
, cpp_token_as_text (pfile, op.token)); goto syntax_error; } while
(0)
	      "missing binary operator before token \"%s\"",do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "missing binary operator before token \"%s\""
, cpp_token_as_text (pfile, op.token)); goto syntax_error; } while
(0)
	      cpp_token_as_text (pfile, op.token))do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "missing binary operator before token \"%s\""
, cpp_token_as_text (pfile, op.token)); goto syntax_error; } while
(0);
}
    else if (want_value)
{
 /* We want a number (or expression) and haven't got one.
    Try to emit a specific diagnostic.  */
 if (op.op == CPP_CLOSE_PAREN && top->op == CPP_OPEN_PAREN)
   SYNTAX_ERROR_AT (op.loc,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "missing expression between '(' and ')'"
); goto syntax_error; } while(0)
	     "missing expression between '(' and ')'")do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "missing expression between '(' and ')'"
); goto syntax_error; } while(0);

 if (op.op == CPP_EOF && top->op == CPP_EOF)
    SYNTAX_ERROR2_AT (op.loc,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "%s with no expression"
, is_if ? "#if" : "#elif"); goto syntax_error; } while(0)
	      "%s with no expression", is_if ? "#if" : "#elif")do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "%s with no expression"
, is_if ? "#if" : "#elif"); goto syntax_error; } while(0);

  if (top->op != CPP_EOF && top->op != CPP_OPEN_PAREN)
    SYNTAX_ERROR2_AT (op.loc,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "operator '%s' has no right operand"
, cpp_token_as_text (pfile, top->token)); goto syntax_error
; } while(0)
	      "operator '%s' has no right operand",do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "operator '%s' has no right operand"
, cpp_token_as_text (pfile, top->token)); goto syntax_error
; } while(0)
	      cpp_token_as_text (pfile, top->token))do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "operator '%s' has no right operand"
, cpp_token_as_text (pfile, top->token)); goto syntax_error
; } while(0);
 else if (op.op == CPP_CLOSE_PAREN || op.op == CPP_EOF)
   /* Complain about missing paren during reduction.  */;
 else
   SYNTAX_ERROR2_AT (op.loc,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "operator '%s' has no left operand"
, cpp_token_as_text (pfile, op.token)); goto syntax_error; } while
(0)
	      "operator '%s' has no left operand",do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "operator '%s' has no left operand"
, cpp_token_as_text (pfile, op.token)); goto syntax_error; } while
(0)
	      cpp_token_as_text (pfile, op.token))do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, "operator '%s' has no left operand"
, cpp_token_as_text (pfile, op.token)); goto syntax_error; } while
(0);
}

    top = reduce (pfile, top, op.op);
23
←
Calling 'reduce'→
    if (!top9.1
'top' is non-null
)
10
←
Taking false branch→
goto syntax_error;

    if (op.op == CPP_EOF)
11
←
Assuming field 'op' is not equal to CPP_EOF→
12
←
Taking false branch→
break;

    switch (op.op)
13
←
Control jumps to the 'default' case at line 1421→
{
case CPP_CLOSE_PAREN:
 continue;
case CPP_OR_OR:
 if (!num_zerop (top->value)((top->value.low | top->value.high) == 0))
   pfile->state.skip_eval++;
 break;
case CPP_AND_AND:
case CPP_QUERY:
 if (num_zerop (top->value)((top->value.low | top->value.high) == 0))
   pfile->state.skip_eval++;
 break;
case CPP_COLON:
 if (top->op != CPP_QUERY)
   SYNTAX_ERROR_AT (op.loc,do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, " ':' without preceding '?'"
); goto syntax_error; } while(0)
	     " ':' without preceding '?'")do { cpp_error_with_line (pfile, CPP_DL_ERROR, (op.loc), 0, " ':' without preceding '?'"
); goto syntax_error; } while(0);
 if (!num_zerop (top[-1].value)((top[-1].value.low | top[-1].value.high) == 0)) /* Was '?' condition true?  */
   pfile->state.skip_eval++;
 else
   pfile->state.skip_eval--;
default:
 break;
14
←
 Execution continues on line 1425→
}

    want_value = true;

    /* Check for and handle stack overflow.  */
    if (++top == pfile->op_limit)
15
←
Assuming the condition is false→
16
←
Taking false branch→
top = _cpp_expand_op_stack (pfile);

    top->op = op.op;
    top->token = op.token;
    top->loc = op.loc;
  }

/* The controlling macro expression is only valid if we called lex 3
   times: <!> <defined expression> and <EOF>.  push_conditional ()
   checks that we are at top-of-file.  */
if (pfile->mi_ind_cmacro && !(saw_leading_not && lex_count == 3))
  pfile->mi_ind_cmacro = 0;

if (top != pfile->op_stack)
  {
    cpp_error_with_line (pfile, CPP_DL_ICE, top->loc, 0,
	   "unbalanced stack in %s",
	   is_if ? "#if" : "#elif");
  syntax_error:
    return false;  /* Return false on syntax error.  */
  }

return !num_zerop (top->value)((top->value.low | top->value.high) == 0);
1452}

1454/* Reduce the operator / value stack if possible, in preparation for
 pushing operator OP.  Returns NULL on error, otherwise the top of
 the stack.  */
1457static struct op *
1458reduce (cpp_reader *pfile, struct op *top, enum cpp_ttype op)
1459{
unsigned int prio;

if (top->op23.1
Field 'op' is > CPP_EQ
 <= CPP_EQ || top->op > CPP_LAST_CPP_OP + 2)
24
←
Taking false branch→
  {
  bad_op:
    cpp_error (pfile, CPP_DL_ICE, "impossible operator '%u'", top->op);
    return 0;
  }

if (op24.1
'op' is not equal to CPP_OPEN_PAREN
 == CPP_OPEN_PAREN)
25
←
Taking false branch→
  return top;

/* Decrement the priority of left-associative operators to force a
   reduction with operators of otherwise equal priority.  */
prio = optab[op].prio - ((optab[op].flags & LEFT_ASSOC(1 << 1)) != 0);
26
←
Assuming the condition is false→
while (prio < optab[top->op].prio)
27
←
Assuming 'prio' is < field 'prio'→
28
←
Loop condition is true.  Entering loop body→
  {
    if (CPP_OPTION (pfile, warn_num_sign_change)((pfile)->opts.warn_num_sign_change)
29
←
Assuming field 'warn_num_sign_change' is 0→
 && optab[top->op].flags & CHECK_PROMOTION(1 << 2))
check_promotion (pfile, top);

    switch (top->op)
30
←
Control jumps to 'case CPP_DIV:'  at line 1530→
{
case CPP_UPLUS((enum cpp_ttype) (CPP_LAST_CPP_OP + 1)):
case CPP_UMINUS((enum cpp_ttype) (CPP_LAST_CPP_OP + 2)):
case CPP_NOT:
case CPP_COMPL:
 top[-1].value = num_unary_op (pfile, top->value, top->op);
 top[-1].loc = top->loc;
 break;

case CPP_PLUS:
case CPP_MINUS:
case CPP_RSHIFT:
case CPP_LSHIFT:
case CPP_COMMA:
 top[-1].value = num_binary_op (pfile, top[-1].value,
			 top->value, top->op);
 top[-1].loc = top->loc;
 break;

case CPP_GREATER:
case CPP_LESS:
case CPP_GREATER_EQ:
case CPP_LESS_EQ:
 top[-1].value
   = num_inequality_op (pfile, top[-1].value, top->value, top->op);
 top[-1].loc = top->loc;
 break;

case CPP_EQ_EQ:
case CPP_NOT_EQ:
 top[-1].value
   = num_equality_op (pfile, top[-1].value, top->value, top->op);
 top[-1].loc = top->loc;
 break;

case CPP_AND:
case CPP_OR:
case CPP_XOR:
 top[-1].value
   = num_bitwise_op (pfile, top[-1].value, top->value, top->op);
 top[-1].loc = top->loc;
 break;

case CPP_MULT:
 top[-1].value = num_mul (pfile, top[-1].value, top->value);
 top[-1].loc = top->loc;
 break;

case CPP_DIV:
case CPP_MOD:
 top[-1].value = num_div_op (pfile, top[-1].value,
31
←
Calling 'num_div_op'→
		      top->value, top->op, top->loc);
 top[-1].loc = top->loc;
 break;

case CPP_OR_OR:
 top--;
 if (!num_zerop (top->value)((top->value.low | top->value.high) == 0))
   pfile->state.skip_eval--;
 top->value.low = (!num_zerop (top->value)((top->value.low | top->value.high) == 0)
	    || !num_zerop (top[1].value)((top[1].value.low | top[1].value.high) == 0));
 top->value.high = 0;
 top->value.unsignedp = false;
 top->value.overflow = false;
 top->loc = top[1].loc;
 continue;

case CPP_AND_AND:
 top--;
 if (num_zerop (top->value)((top->value.low | top->value.high) == 0))
   pfile->state.skip_eval--;
 top->value.low = (!num_zerop (top->value)((top->value.low | top->value.high) == 0)
	    && !num_zerop (top[1].value)((top[1].value.low | top[1].value.high) == 0));
 top->value.high = 0;
 top->value.unsignedp = false;
 top->value.overflow = false;
 top->loc = top[1].loc;
 continue;

case CPP_OPEN_PAREN:
 if (op != CPP_CLOSE_PAREN)
   {
     cpp_error_with_line (pfile, CPP_DL_ERROR, 
		   top->token->src_loc,
		   0, "missing ')' in expression");
     return 0;
   }
 top--;
 top->value = top[1].value;
 top->loc = top[1].loc;
 return top;

case CPP_COLON:
 top -= 2;
 if (!num_zerop (top->value)((top->value.low | top->value.high) == 0))
   {
     pfile->state.skip_eval--;
     top->value = top[1].value;
     top->loc = top[1].loc;
   }
 else
   {
     top->value = top[2].value;
     top->loc = top[2].loc;
   }
 top->value.unsignedp = (top[1].value.unsignedp
		  || top[2].value.unsignedp);
 continue;

case CPP_QUERY:
 /* COMMA and COLON should not reduce a QUERY operator.  */
 if (op == CPP_COMMA || op == CPP_COLON)
   return top;
 cpp_error (pfile, CPP_DL_ERROR, "'?' without following ':'");
 return 0;

default:
 goto bad_op;
}

    top--;
    if (top->value.overflow && !pfile->state.skip_eval)
cpp_error (pfile, CPP_DL_PEDWARN,
   "integer overflow in preprocessor expression");
  }

if (op == CPP_CLOSE_PAREN)
  {
    cpp_error (pfile, CPP_DL_ERROR, "missing '(' in expression");
    return 0;
  }

return top;
1615}

1617/* Returns the position of the old top of stack after expansion.  */
1618struct op *
1619_cpp_expand_op_stack (cpp_reader *pfile)
1620{
size_t old_size = (size_t) (pfile->op_limit - pfile->op_stack);
size_t new_size = old_size * 2 + 20;

pfile->op_stack = XRESIZEVEC (struct op, pfile->op_stack, new_size)((struct op *) xrealloc ((void *) (pfile->op_stack), sizeof
 (struct op) * (new_size)));
pfile->op_limit = pfile->op_stack + new_size;

return pfile->op_stack + old_size;
1628}

1630/* Emits a warning if the effective sign of either operand of OP
 changes because of integer promotions.  */
1632static void
1633check_promotion (cpp_reader *pfile, const struct op *op)
1634{
if (op->value.unsignedp == op[-1].value.unsignedp)
  return;

if (op->value.unsignedp)
  {
    if (!num_positive (op[-1].value, CPP_OPTION (pfile, precision)((pfile)->opts.precision)))
cpp_error_with_line (pfile, CPP_DL_WARNING, op[-1].loc, 0,
	     "the left operand of \"%s\" changes sign when promoted",
	     cpp_token_as_text (pfile, op->token));
  }
else if (!num_positive (op->value, CPP_OPTION (pfile, precision)((pfile)->opts.precision)))
  cpp_error_with_line (pfile, CPP_DL_WARNING, op->loc, 0,
      "the right operand of \"%s\" changes sign when promoted",
      cpp_token_as_text (pfile, op->token));
1649}

1651/* Clears the unused high order bits of the number pointed to by PNUM.  */
1652static cpp_num
1653num_trim (cpp_num num, size_t precision)
1654{
if (precision > PART_PRECISION(sizeof (cpp_num_part) * 8))
  {
    precision -= PART_PRECISION(sizeof (cpp_num_part) * 8);
    if (precision < PART_PRECISION(sizeof (cpp_num_part) * 8))
num.high &= ((cpp_num_part) 1 << precision) - 1;
  }
else
  {
    if (precision < PART_PRECISION(sizeof (cpp_num_part) * 8))
num.low &= ((cpp_num_part) 1 << precision) - 1;
    num.high = 0;
  }

return num;
1669}

1671/* True iff A (presumed signed) >= 0.  */
1672static bool
1673num_positive (cpp_num num, size_t precision)
1674{
if (precision > PART_PRECISION(sizeof (cpp_num_part) * 8))
  {
    precision -= PART_PRECISION(sizeof (cpp_num_part) * 8);
    return (num.high & (cpp_num_part) 1 << (precision - 1)) == 0;
  }

return (num.low & (cpp_num_part) 1 << (precision - 1)) == 0;
1682}

1684/* Sign extend a number, with PRECISION significant bits and all
 others assumed clear, to fill out a cpp_num structure.  */
1686cpp_num
1687cpp_num_sign_extend (cpp_num num, size_t precision)
1688{
if (!num.unsignedp)
  {
    if (precision > PART_PRECISION(sizeof (cpp_num_part) * 8))
{
 precision -= PART_PRECISION(sizeof (cpp_num_part) * 8);
 if (precision < PART_PRECISION(sizeof (cpp_num_part) * 8)
     && (num.high & (cpp_num_part) 1 << (precision - 1)))
   num.high |= ~(~(cpp_num_part) 0 >> (PART_PRECISION(sizeof (cpp_num_part) * 8) - precision));
}
    else if (num.low & (cpp_num_part) 1 << (precision - 1))
{
 if (precision < PART_PRECISION(sizeof (cpp_num_part) * 8))
   num.low |= ~(~(cpp_num_part) 0 >> (PART_PRECISION(sizeof (cpp_num_part) * 8) - precision));
 num.high = ~(cpp_num_part) 0;
}
  }

return num;
1707}

1709/* Returns the negative of NUM.  */
1710static cpp_num
1711num_negate (cpp_num num, size_t precision)
1712{
cpp_num copy;

copy = num;
num.high = ~num.high;
num.low = ~num.low;
if (++num.low == 0)
  num.high++;
num = num_trim (num, precision);
num.overflow = (!num.unsignedp && num_eq (num, copy)(num.low == copy.low && num.high == copy.high) && !num_zerop (num)((num.low | num.high) == 0));

return num;
1724}

1726/* Returns true if A >= B.  */
1727static bool
1728num_greater_eq (cpp_num pa, cpp_num pb, size_t precision)
1729{
bool unsignedp;

unsignedp = pa.unsignedp52.1
Field 'unsignedp' is true
 || pb.unsignedp;

if (!unsignedp52.2
'unsignedp' is true
)
53
←
Taking false branch→
  {
    /* Both numbers have signed type.  If they are of different
     sign, the answer is the sign of A.  */
    unsignedp = num_positive (pa, precision);

    if (unsignedp != num_positive (pb, precision))
return unsignedp;

    /* Otherwise we can do an unsigned comparison.  */
  }

return (pa.high53.1
'pa.high' is <= 'pb.high'
 > pb.high) || (pa.high53.2
'pa.high' is equal to 'pb.high'
 == pb.high && pa.low53.3
'pa.low' is >= 'pb.low'
 >= pb.low);
54
←
Returning the value 1, which participates in a condition later→
1747}

1749/* Returns LHS OP RHS, where OP is a bit-wise operation.  */
1750static cpp_num
1751num_bitwise_op (cpp_reader *pfile ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1753{
lhs.overflow = false;
lhs.unsignedp = lhs.unsignedp || rhs.unsignedp;

/* As excess precision is zeroed, there is no need to num_trim () as
   these operations cannot introduce a set bit there.  */
if (op == CPP_AND)
  {
    lhs.low &= rhs.low;
    lhs.high &= rhs.high;
  }
else if (op == CPP_OR)
  {
    lhs.low |= rhs.low;
    lhs.high |= rhs.high;
  }
else
  {
    lhs.low ^= rhs.low;
    lhs.high ^= rhs.high;
  }

return lhs;
1776}

1778/* Returns LHS OP RHS, where OP is an inequality.  */
1779static cpp_num
1780num_inequality_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs,
   enum cpp_ttype op)
1782{
bool gte = num_greater_eq (lhs, rhs, CPP_OPTION (pfile, precision)((pfile)->opts.precision));

if (op == CPP_GREATER_EQ)
  lhs.low = gte;
else if (op == CPP_LESS)
  lhs.low = !gte;
else if (op == CPP_GREATER)
  lhs.low = gte && !num_eq (lhs, rhs)(lhs.low == rhs.low && lhs.high == rhs.high);
else /* CPP_LESS_EQ.  */
  lhs.low = !gte || num_eq (lhs, rhs)(lhs.low == rhs.low && lhs.high == rhs.high);

lhs.high = 0;
lhs.overflow = false;
lhs.unsignedp = false;
return lhs;
1798}

1800/* Returns LHS OP RHS, where OP is == or !=.  */
1801static cpp_num
1802num_equality_op (cpp_reader *pfile ATTRIBUTE_UNUSED__attribute__ ((__unused__)),
 cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1804{
/* Work around a 3.0.4 bug; see PR 6950.  */
bool eq = num_eq (lhs, rhs)(lhs.low == rhs.low && lhs.high == rhs.high);
if (op == CPP_NOT_EQ)
  eq = !eq;
lhs.low = eq;
lhs.high = 0;
lhs.overflow = false;
lhs.unsignedp = false;
return lhs;
1814}

1816/* Shift NUM, of width PRECISION, right by N bits.  */
1817static cpp_num
1818num_rshift (cpp_num num, size_t precision, size_t n)
1819{
cpp_num_part sign_mask;
bool x = num_positive (num, precision);

if (num.unsignedp || x)
  sign_mask = 0;
else
  sign_mask = ~(cpp_num_part) 0;

if (n >= precision)
  num.high = num.low = sign_mask;
else
  {
    /* Sign-extend.  */
    if (precision < PART_PRECISION(sizeof (cpp_num_part) * 8))
num.high = sign_mask, num.low |= sign_mask << precision;
    else if (precision < 2 * PART_PRECISION(sizeof (cpp_num_part) * 8))
num.high |= sign_mask << (precision - PART_PRECISION(sizeof (cpp_num_part) * 8));

    if (n >= PART_PRECISION(sizeof (cpp_num_part) * 8))
{
 n -= PART_PRECISION(sizeof (cpp_num_part) * 8);
 num.low = num.high;
 num.high = sign_mask;
}

    if (n)
{
 num.low = (num.low >> n) | (num.high << (PART_PRECISION(sizeof (cpp_num_part) * 8) - n));
 num.high = (num.high >> n) | (sign_mask << (PART_PRECISION(sizeof (cpp_num_part) * 8) - n));
}
  }

num = num_trim (num, precision);
num.overflow = false;
return num;
1855}

1857/* Shift NUM, of width PRECISION, left by N bits.  */
1858static cpp_num
1859num_lshift (cpp_num num, size_t precision, size_t n)
1860{
if (n >= precision)
  {
    num.overflow = !num.unsignedp && !num_zerop (num)((num.low | num.high) == 0);
    num.high = num.low = 0;
  }
else
  {
    cpp_num orig, maybe_orig;
    size_t m = n;

    orig = num;
    if (m >= PART_PRECISION(sizeof (cpp_num_part) * 8))
{
 m -= PART_PRECISION(sizeof (cpp_num_part) * 8);
 num.high = num.low;
 num.low = 0;
}
    if (m)
{
 num.high = (num.high << m) | (num.low >> (PART_PRECISION(sizeof (cpp_num_part) * 8) - m));
 num.low <<= m;
}
    num = num_trim (num, precision);

    if (num.unsignedp)
num.overflow = false;
    else
{
 maybe_orig = num_rshift (num, precision, n);
 num.overflow = !num_eq (orig, maybe_orig)(orig.low == maybe_orig.low && orig.high == maybe_orig
.high);
}
  }

return num;
1895}

1897/* The four unary operators: +, -, ! and ~.  */
1898static cpp_num
1899num_unary_op (cpp_reader *pfile, cpp_num num, enum cpp_ttype op)
1900{
switch (op)
  {
  case CPP_UPLUS((enum cpp_ttype) (CPP_LAST_CPP_OP + 1)):
    if (CPP_WTRADITIONAL (pfile)((pfile)->opts.cpp_warn_traditional) && !pfile->state.skip_eval)
cpp_warning (pfile, CPP_W_TRADITIONAL,
     "traditional C rejects the unary plus operator");
    num.overflow = false;
    break;

  case CPP_UMINUS((enum cpp_ttype) (CPP_LAST_CPP_OP + 2)):
    num = num_negate (num, CPP_OPTION (pfile, precision)((pfile)->opts.precision));
    break;

  case CPP_COMPL:
    num.high = ~num.high;
    num.low = ~num.low;
    num = num_trim (num, CPP_OPTION (pfile, precision)((pfile)->opts.precision));
    num.overflow = false;
    break;

  default: /* case CPP_NOT: */
    num.low = num_zerop (num)((num.low | num.high) == 0);
    num.high = 0;
    num.overflow = false;
    num.unsignedp = false;
    break;
  }

return num;
1930}

1932/* The various binary operators.  */
1933static cpp_num
1934num_binary_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op)
1935{
cpp_num result;
size_t precision = CPP_OPTION (pfile, precision)((pfile)->opts.precision);
size_t n;

switch (op)
  {
    /* Shifts.  */
  case CPP_LSHIFT:
  case CPP_RSHIFT:
    if (!rhs.unsignedp && !num_positive (rhs, precision))
{
 /* A negative shift is a positive shift the other way.  */
 if (op == CPP_LSHIFT)
   op = CPP_RSHIFT;
 else
   op = CPP_LSHIFT;
 rhs = num_negate (rhs, precision);
}
    if (rhs.high)
n = ~0;			/* Maximal.  */
    else
n = rhs.low;
    if (op == CPP_LSHIFT)
lhs = num_lshift (lhs, precision, n);
    else
lhs = num_rshift (lhs, precision, n);
    break;

    /* Arithmetic.  */
  case CPP_MINUS:
    result.low = lhs.low - rhs.low;
    result.high = lhs.high - rhs.high;
    if (result.low > lhs.low)
result.high--;
    result.unsignedp = lhs.unsignedp || rhs.unsignedp;
    result.overflow = false;

    result = num_trim (result, precision);
    if (!result.unsignedp)
{
 bool lhsp = num_positive (lhs, precision);
 result.overflow = (lhsp != num_positive (rhs, precision)
	     && lhsp != num_positive (result, precision));
}
    return result;

  case CPP_PLUS:
    result.low = lhs.low + rhs.low;
    result.high = lhs.high + rhs.high;
    if (result.low < lhs.low)
result.high++;
    result.unsignedp = lhs.unsignedp || rhs.unsignedp;
    result.overflow = false;

    result = num_trim (result, precision);
    if (!result.unsignedp)
{
 bool lhsp = num_positive (lhs, precision);
 result.overflow = (lhsp == num_positive (rhs, precision)
	     && lhsp != num_positive (result, precision));
}
    return result;

    /* Comma.  */
  default: /* case CPP_COMMA: */
    if (CPP_PEDANTIC (pfile)((pfile)->opts.cpp_pedantic) && (!CPP_OPTION (pfile, c99)((pfile)->opts.c99)
		   || !pfile->state.skip_eval))
cpp_pedwarning (pfile, CPP_W_PEDANTIC,
	"comma operator in operand of #if");
    lhs = rhs;
    break;
  }

return lhs;
2010}

2012/* Multiplies two unsigned cpp_num_parts to give a cpp_num.  This
 cannot overflow.  */
2014static cpp_num
2015num_part_mul (cpp_num_part lhs, cpp_num_part rhs)
2016{
cpp_num result;
cpp_num_part middle[2], temp;

result.low = LOW_PART (lhs)(lhs & (~(cpp_num_part) 0 >> ((sizeof (cpp_num_part
) * 8) / 2))) * LOW_PART (rhs)(rhs & (~(cpp_num_part) 0 >> ((sizeof (cpp_num_part
) * 8) / 2)));
result.high = HIGH_PART (lhs)(lhs >> ((sizeof (cpp_num_part) * 8) / 2)) * HIGH_PART (rhs)(rhs >> ((sizeof (cpp_num_part) * 8) / 2));

middle[0] = LOW_PART (lhs)(lhs & (~(cpp_num_part) 0 >> ((sizeof (cpp_num_part
) * 8) / 2))) * HIGH_PART (rhs)(rhs >> ((sizeof (cpp_num_part) * 8) / 2));
middle[1] = HIGH_PART (lhs)(lhs >> ((sizeof (cpp_num_part) * 8) / 2)) * LOW_PART (rhs)(rhs & (~(cpp_num_part) 0 >> ((sizeof (cpp_num_part
) * 8) / 2)));

temp = result.low;
result.low += LOW_PART (middle[0])(middle[0] & (~(cpp_num_part) 0 >> ((sizeof (cpp_num_part
) * 8) / 2))) << (PART_PRECISION(sizeof (cpp_num_part) * 8) / 2);
if (result.low < temp)
  result.high++;

temp = result.low;
result.low += LOW_PART (middle[1])(middle[1] & (~(cpp_num_part) 0 >> ((sizeof (cpp_num_part
) * 8) / 2))) << (PART_PRECISION(sizeof (cpp_num_part) * 8) / 2);
if (result.low < temp)
  result.high++;

result.high += HIGH_PART (middle[0])(middle[0] >> ((sizeof (cpp_num_part) * 8) / 2));
result.high += HIGH_PART (middle[1])(middle[1] >> ((sizeof (cpp_num_part) * 8) / 2));
result.unsignedp = true;
result.overflow = false;

return result;
2042}

2044/* Multiply two preprocessing numbers.  */
2045static cpp_num
2046num_mul (cpp_reader *pfile, cpp_num lhs, cpp_num rhs)
2047{
cpp_num result, temp;
bool unsignedp = lhs.unsignedp || rhs.unsignedp;
bool overflow, negate = false;
size_t precision = CPP_OPTION (pfile, precision)((pfile)->opts.precision);

/* Prepare for unsigned multiplication.  */
if (!unsignedp)
  {
    if (!num_positive (lhs, precision))
negate = !negate, lhs = num_negate (lhs, precision);
    if (!num_positive (rhs, precision))
negate = !negate, rhs = num_negate (rhs, precision);
  }

overflow = lhs.high && rhs.high;
result = num_part_mul (lhs.low, rhs.low);

temp = num_part_mul (lhs.high, rhs.low);
result.high += temp.low;
if (temp.high)
  overflow = true;

temp = num_part_mul (lhs.low, rhs.high);
result.high += temp.low;
if (temp.high)
  overflow = true;

temp.low = result.low, temp.high = result.high;
result = num_trim (result, precision);
if (!num_eq (result, temp)(result.low == temp.low && result.high == temp.high))
  overflow = true;

if (negate)
  result = num_negate (result, precision);

if (unsignedp)
  result.overflow = false;
else
  result.overflow = overflow || (num_positive (result, precision) ^ !negate
		   && !num_zerop (result)((result.low | result.high) == 0));
result.unsignedp = unsignedp;

return result;
2091}

2093/* Divide two preprocessing numbers, LHS and RHS, returning the answer
 or the remainder depending upon OP. LOCATION is the source location
 of this operator (for diagnostics).  */

2097static cpp_num
2098num_div_op (cpp_reader *pfile, cpp_num lhs, cpp_num rhs, enum cpp_ttype op,
   location_t location)
2100{
cpp_num result, sub;
cpp_num_part mask;
bool unsignedp = lhs.unsignedp || rhs.unsignedp;
32
←
Assuming field 'unsignedp' is false→
bool negate = false, lhs_neg = false;
size_t i, precision = CPP_OPTION (pfile, precision)((pfile)->opts.precision);

/* Prepare for unsigned division.  */
if (!unsignedp)
33
←
Assuming 'unsignedp' is true→
34
←
Taking false branch→
  {
    if (!num_positive (lhs, precision))
negate = !negate, lhs_neg = true, lhs = num_negate (lhs, precision);
    if (!num_positive (rhs, precision))
negate = !negate, rhs = num_negate (rhs, precision);
  }

/* Find the high bit.  */
if (rhs.high)
35
←
Assuming field 'high' is 0→
36
←
Taking false branch→
  {
    i = precision - 1;
    mask = (cpp_num_part) 1 << (i - PART_PRECISION(sizeof (cpp_num_part) * 8));
    for (; ; i--, mask >>= 1)
if (rhs.high & mask)
 break;
  }
else if (rhs.low)
37
←
Assuming field 'low' is not equal to 0→
38
←
Taking true branch→
  {
    if (precision > PART_PRECISION(sizeof (cpp_num_part) * 8))
39
←
Assuming the condition is false→
40
←
Taking false branch→
i = precision - PART_PRECISION(sizeof (cpp_num_part) * 8) - 1;
    else
i = precision - 1;
    mask = (cpp_num_part) 1 << i;
    for (; ; i--, mask >>= 1)
41
←
Loop condition is true.  Entering loop body→
if (rhs.low & mask)
42
←
Assuming the condition is true→
43
←
Taking true branch→
 break;
44
←
 Execution continues on line 2149→
  }
else
  {
    if (!pfile->state.skip_eval)
cpp_error_with_line (pfile, CPP_DL_ERROR, location, 0,
	     "division by zero in #if");
    return lhs;
  }

/* First nonzero bit of RHS is bit I.  Do naive division by
   shifting the RHS fully left, and subtracting from LHS if LHS is
   at least as big, and then repeating but with one less shift.
   This is not very efficient, but is easy to understand.  */

rhs.unsignedp = true;
lhs.unsignedp = true;
i = precision - i - 1;
sub = num_lshift (rhs, precision, i);

result.high = result.low = 0;
for (;;)
45
←
Loop condition is true.  Entering loop body→
51
←
Loop condition is true.  Entering loop body→
  {
    if (num_greater_eq (lhs, sub, precision))
46
←
Taking true branch→
52
←
Calling 'num_greater_eq'→
55
←
Returning from 'num_greater_eq'→
56
←
Taking true branch→
{
 lhs = num_binary_op (pfile, lhs, sub, CPP_MINUS);
 if (i >= PART_PRECISION(sizeof (cpp_num_part) * 8))
47
←
Assuming the condition is false→
48
←
Taking false branch→
57
←
Taking true branch→
   result.high |= (cpp_num_part) 1 << (i - PART_PRECISION(sizeof (cpp_num_part) * 8));
58
←
The result of the left shift is undefined due to shifting by '18446744073709551551', which is greater or equal to the width of type 'cpp_num_part'
 else
   result.low |= (cpp_num_part) 1 << i;
}
    if (i-- == 0)
49
←
Assuming the condition is false→
50
←
Taking false branch→
break;
    sub.low = (sub.low >> 1) | (sub.high << (PART_PRECISION(sizeof (cpp_num_part) * 8) - 1));
    sub.high >>= 1;
  }

/* We divide so that the remainder has the sign of the LHS.  */
if (op == CPP_DIV)
  {
    result.unsignedp = unsignedp;
    result.overflow = false;
    if (!unsignedp)
{
 if (negate)
   result = num_negate (result, precision);
 result.overflow = (num_positive (result, precision) ^ !negate
	     && !num_zerop (result)((result.low | result.high) == 0));
}

    return result;
  }

/* CPP_MOD.  */
lhs.unsignedp = unsignedp;
lhs.overflow = false;
if (lhs_neg)
  lhs = num_negate (lhs, precision);

return lhs;
2194}
