adlint 1.10.0 → 1.12.0

data/lib/adlint/c/type.rb

@@ -36,6 +36,7 @@ require "adlint/c/scope"
 require "adlint/c/object"
 require "adlint/c/conv"
 require "adlint/c/option"
+require "adlint/c/operator"
 
 module AdLint #:nodoc:
 module C #:nodoc:
@@ -123,9 +124,10 @@ module C #:nodoc:
   #                  <--- EnumType ------------------- Scopeable <<module>>
   #                  <--- PointerType                      |
   #           <--- FloatingType                            |
-  #                  <--- FloatType                        |
-  #                  <--- DoubleType                       |
-  #                  <--- LongDoubleType                   |
+  #                  <--- StandardFloatingType             |
+  #                         <--- FloatType                 |
+  #                         <--- DoubleType                |
+  #                         <--- LongDoubleType            |
   #    <--- ArrayType                                      |
   #    <--- CompositeDataType -----------------------------+
   #           <--- StructType                              |
@@ -277,6 +279,10 @@ module C #:nodoc:
       subclass_responsibility
     end
 
+    def standard?
+      subclass_responsibility
+    end
+
     def undeclared?
       subclass_responsibility
     end
@@ -740,6 +746,10 @@ module C #:nodoc:
       false
     end
 
+    def standard?
+      false
+    end
+
     def undeclared?
       true
     end
@@ -1264,6 +1274,10 @@ module C #:nodoc:
       false
     end
 
+    def standard?
+      false
+    end
+
     def undeclared?
       false
     end
@@ -1804,6 +1818,10 @@ module C #:nodoc:
       @base_type.void?
     end
 
+    def standard?
+      @base_type.standard?
+    end
+
     def undeclared?
       @base_type.undeclared?
     end
@@ -2117,6 +2135,10 @@ module C #:nodoc:
       true
     end
 
+    def standard?
+      true
+    end
+
     def undeclared?
       false
     end
@@ -2645,6 +2667,10 @@ module C #:nodoc:
       false
     end
 
+    def standard?
+      false
+    end
+
     def undeclared?
       false
     end
@@ -3186,6 +3212,10 @@ module C #:nodoc:
       false
     end
 
+    def standard?
+      subclass_responsibility
+    end
+
     def undeclared?
       false
     end
@@ -3284,7 +3314,7 @@ module C #:nodoc:
 
     def coerce_scalar_value(value)
       value.dup.tap do |val|
-        val.narrow_domain!(:==, ScalarValue.of(min_value..max_value))
+        val.narrow_domain!(Operator::EQ, ScalarValue.of(min_value..max_value))
       end
     end
 
@@ -3548,6 +3578,10 @@ module C #:nodoc:
       subclass_responsibility
     end
 
+    def standard?
+      subclass_responsibility
+    end
+
     def bitfield?
       subclass_responsibility
     end
@@ -3666,6 +3700,10 @@ module C #:nodoc:
       false
     end
 
+    def standard?
+      true
+    end
+
     def bitfield?
       false
     end
@@ -4896,43 +4934,24 @@ module C #:nodoc:
     end
   end
 
-  class FloatingType < ScalarDataType
-    def initialize(type_table, name, bit_size, bit_alignment)
-      super(type_table, name, bit_size, bit_alignment)
-    end
-
-    def id
-      subclass_responsibility
-    end
+  class BitfieldType < IntegerType
+    def initialize(type_table, base_type, field_width)
+      super(type_table,
+            "#{base_type.real_type.name}:#{field_width}",
+            field_width, base_type.bit_alignment,
+            base_type.signed?, base_type.explicitly_signed?)
 
-    def image
-      name
+      @base_type = base_type
     end
 
-    def brief_image
-      name
-    end
+    attr_reader :base_type
 
-    def location
-      nil
+    def id
+      @id ||= BitfieldTypeId.new(@base_type, bit_size)
     end
 
     def incomplete?
-      false
-    end
-
-    def compatible?(to_type)
-      type.floating? &&
-        to_type.min_value <= self.min_value &&
-        self.max_value <= to_type.max_value
-    end
-
-    def integer?
-      false
-    end
-
-    def floating?
-      true
+      @base_type.incomplete?
     end
 
     def pointer?
@@ -4943,44 +4962,63 @@ module C #:nodoc:
       false
     end
 
-    def bitfield?
+    def standard?
       false
     end
 
-    def signed?
-      true
-    end
-
-    def explicitly_signed?
+    def bitfield?
       true
     end
 
-    def enumerators
-      []
+    def undeclared?
+      @base_type.undeclared?
     end
 
-    def min_value
-      (-2**fraction_bit_size * 10**(exponent_bit_size - 1)).to_f
+    def unresolved?
+      @base_type.unresolved?
     end
 
-    def max_value
-      (2**fraction_bit_size * 10**(exponent_bit_size - 1)).to_f
+    def enumerators
+      []
     end
 
     def integer_conversion_rank
-      0 # NOTREACHED
+      -1
     end
 
     def integer_promoted_type
-      self # NOTREACHED
-    end
-
-    def argument_promoted_type
-      subclass_responsibility
+      # TODO: Should support the C99 _Bool type.
+      # NOTE: The ISO C99 standard saids;
+      #
+      # 6.3.1 Arithmetic operands
+      # 6.3.1.1 Boolean, characters, and integers
+      #
+      # 2 The following may be used in an expression wherever an int or
+      #   unsigned int may be used:
+      #
+      #     -- An object or expression with an integer type whose integer
+      #        conversion rank is less than or equal to the rank of int and
+      #        unsigned int.
+      #     -- A bit-field of type _Bool, int, signed int, or unsigned int.
+      #
+      #   If an int can represent all values of the original type, the value is
+      #   converted to an int; otherwise, it is converted to an unsigned int.
+      #   These are called the integer promotions.  All other types are
+      #   unchanged by the integer promotions.
+      if self.undeclared? || self.unresolved?
+        self
+      else
+        if @base_type.same_as?(int_type) ||
+            @base_type.same_as?(unsigned_int_type)
+          self.compatible?(int_type) ? int_type : unsigned_int_type
+        else
+          self
+        end
+      end
     end
 
     def arithmetic_type_with(type)
-      subclass_responsibility
+      type._arithmetic_type_with_bitfield(self)
     end
 
     def corresponding_signed_type
@@ -4990,348 +5028,127 @@ module C #:nodoc:
     def corresponding_unsigned_type
       self # NOTREACHED
     end
+  end
 
-    private
-    def fraction_bit_size
-      subclass_responsibility
+  class BitfieldTypeId < TypeId
+    def initialize(base_type, field_width)
+      super(create_value(base_type, field_width))
     end
 
-    def exponent_bit_size
-      subclass_responsibility
+    private
+    def create_value(base_type, field_width)
+      "#{base_type.real_type.name.split(" ").sort.join(" ")}:#{field_width}"
     end
   end
 
-  class FloatType < FloatingType
+  module Scopeable
+    attr_accessor :scope
+  end
+
+  class EnumType < IntegerType
+    include Scopeable
     include StandardTypeAccessor
 
-    def initialize(type_table)
-      super(type_table, "float", float_size, float_alignment)
+    def initialize(type_table, enum_type_declaration)
+      super(type_table, enum_type_declaration.identifier.value,
+            int_size, int_alignment, true, true, [enum_type_declaration])
+
+      @image = enum_type_declaration.enum_specifier.to_s
+      @location = enum_type_declaration.location
     end
 
+    attr_accessor :image
+    attr_accessor :location
+
     def id
-      @id ||= FloatTypeId.new
+      @id ||= EnumTypeId.new(name)
     end
 
-    def argument_promoted_type
-      # NOTE: The ISO C99 standard saids;
-      #
-      # 6.5.2.2 Function calls
-      #
-      # 6 If the expression that denotes the called function has a type that
-      #   does not include a prototype, the integer promotions are performed on
-      #   each argument, and arguments that have type float are promoted to
-      #   double.  These are called the default argument promotions.  If the
-      #   number of arguments does not equal the number of parameters, the
-      #   behavior is undefined.  If the function is defined with a type that
-      #   includes a prototype, and either the prototype ends with an ellipsis
-      #   (, ...) or the types of the arguments after promotion are not
-      #   compatible with the types of the parameters, the behavior is
-      #   undefined.  If the function is defined with a type that does not
-      #   include a prototype, and the types of the arguments after promotion
-      #   are not compatible with those of the parameters after promotion, the
-      #   behavior is undefined, except for the following cases:
-      #
-      #     -- one promoted type is a signed integer type, the other promoted
-      #        type is the corresponding unsigned integer type, and the value
-      #        is representable in both types;
-      #     -- both types are pointers to qualified or unqualified versions of
-      #        a character type or void.
-      double_type
+    def incomplete?
+      declarations.all? { |decl| decl.enumerators.nil? }
     end
 
-    def arithmetic_type_with(type)
-      type._arithmetic_type_with_float(self)
+    def pointer?
+      false
     end
 
-    private
-    def fraction_bit_size
-      # TODO: Bit size of the fraction part of `float' should be configurable.
-      23
+    def enum?
+      true
     end
 
-    def exponent_bit_size
-      # TODO: Bit size of the exponent part of `float' should be configurable.
-      8
+    def standard?
+      false
     end
-  end
 
-  class FloatTypeId < StandardTypeId
-    def initialize
-      super("float")
+    def bitfield?
+      false
     end
-  end
 
-  class DoubleType < FloatingType
-    include StandardTypeAccessor
+    def brief_image
+      "enum #{name}"
+    end
 
-    def initialize(type_table)
-      super(type_table, "double", double_size, double_alignment)
+    def enumerators
+      declarations.map { |decl| decl.enumerators }.compact.flatten.uniq
     end
 
-    def id
-      @id ||= DoubleTypeId.new
+    def integer_conversion_rank
+      # NOTE: The ISO C99 standard saids;
+      #
+      # 6.3.1 Arithmetic operands
+      # 6.3.1.1 Boolean, characters, and integers
+      #
+      # 1 Every integer type has an integer conversion rank defined as follows:
+      #
+      #     -- No two signed integer types shall have the same rank, even if
+      #        they have the same representation.
+      #     -- The rank of a signed integer type shall be greater than the rank
+      #        of any signed integer type with less precision.
+      #     -- The rank of long long int shall be greater than the rank of long
+      #        int, which shall be greater than the rank of int, which shall be
+      #        greater than the rank of short int, which shall be greater than
+      #        the rank of signed char.
+      #     -- The rank of any unsigned integer type shall equal the rank of
+      #        the corresponding signed integer type, if any.
+      #     -- The rank of any standard integer type shall be greater than the
+      #        rank of any extended integer type with the same width.
+      #     -- The rank of char shall equal the rank of signed char and
+      #        unsigned char.
+      #     -- The rank of _Bool shall be less than the rank of all other
+      #        standard integer types.
+      #     -- The rank of any enumerated type shall equal the rank of the
+      #        compatible integer type.
+      #     -- The rank of any extended signed integer type relative to another
+      #        extended signed integer type with the same precision is
+      #        implementation-defined, but still subject to the other rules for
+      #        determining the integer conversion rank.
+      #     -- For all integer types T1, T2, and T3, if T1 has greater rank
+      #        than T2 and T2 has greater rank than T3, then T1 has greater
+      #        rank than T3.
+      #
+      # NOTE: The integer conversion rank of any enumerated type is equal to
+      #       the rank of int.
+      int_type.integer_conversion_rank
     end
 
-    def argument_promoted_type
+    def integer_promoted_type
+      # NOTE: Any enumerated type should be treated as `int'.
+      #       But AdLint internally treats enumerated type as itself, and omits
+      #       integer-promotion of any enumerated type in order not to
+      #       over-warn about enum-enum expressions like below;
+      #
+      #         static void foo(enum Color c)
+      #         {
+      #             if (c == RED) { /* No usual-arithmetic-conversion of
+      #                                enumerated types and no W9003 warning */
+      #                 ...
+      #             }
+      #         }
       self
     end
 
     def arithmetic_type_with(type)
-      type._arithmetic_type_with_double(self)
-    end
-
-    private
-    def fraction_bit_size
-      # TODO: Bit size of the fraction part of `double' should be configurable.
-      52
-    end
-
-    def exponent_bit_size
-      # TODO: Bit size of the exponent part of `double' should be configurable.
-      11
-    end
-  end
-
-  class DoubleTypeId < StandardTypeId
-    def initialize
-      super("double")
-    end
-  end
-
-  class LongDoubleType < FloatingType
-    include StandardTypeAccessor
-
-    def initialize(type_table)
-      super(type_table, "long double", long_double_size, long_double_alignment)
-    end
-
-    def id
-      @id ||= LongDoubleTypeId.new
-    end
-
-    def argument_promoted_type
-      self
-    end
-
-    def arithmetic_type_with(type)
-      type._arithmetic_type_with_long_double(self)
-    end
-
-    private
-    def fraction_bit_size
-      # TODO: Bit size of the fraction part of `long double' should be
-      #       configurable.
-      52
-    end
-
-    def exponent_bit_size
-      # TODO: Bit size of the exponent part of `long double' should be
-      #       configurable.
-      11
-    end
-  end
-
-  class LongDoubleTypeId < StandardTypeId
-    def initialize
-      super("long double")
-    end
-  end
-
-  class BitfieldType < IntegerType
-    def initialize(type_table, base_type, field_width)
-      super(type_table,
-            "#{base_type.real_type.name}:#{field_width}",
-            field_width, base_type.bit_alignment,
-            base_type.signed?, base_type.explicitly_signed?)
-
-      @base_type = base_type
-    end
-
-    attr_reader :base_type
-
-    def id
-      @id ||= BitfieldTypeId.new(@base_type, bit_size)
-    end
-
-    def incomplete?
-      @base_type.incomplete?
-    end
-
-    def pointer?
-      false
-    end
-
-    def enum?
-      false
-    end
-
-    def bitfield?
-      true
-    end
-
-    def undeclared?
-      @base_type.undeclared?
-    end
-
-    def unresolved?
-      @base_type.unresolved?
-    end
-
-    def enumerators
-      []
-    end
-
-    def integer_conversion_rank
-      -1
-    end
-
-    def integer_promoted_type
-      # TODO: Should support the C99 _Bool type.
-      # NOTE: The ISO C99 standard saids;
-      #
-      # 6.3.1 Arithmetic operands
-      # 6.3.1.1 Boolean, characters, and integers
-      #
-      # 2 The following may be used in an expression wherever an int or
-      #   unsigned int may be used:
-      #
-      #     -- An object or expression with an integer type whose integer
-      #        conversion rank is less than or equal to the rank of int and
-      #        unsigned int.
-      #     -- A bit-field of type _Bool, int, signed int, or unsigned int.
-      #
-      #   If an int can represent all values of the original type, the value is
-      #   converted to an int; otherwise, it is converted to an unsigned int.
-      #   These are called the integer promotions.  All other types are
-      #   unchanged by the integer promotions.
-      if self.undeclared? || self.unresolved?
-        self
-      else
-        if @base_type.same_as?(int_type) ||
-            @base_type.same_as?(unsigned_int_type)
-          self.compatible?(int_type) ? int_type : unsigned_int_type
-        else
-          self
-        end
-      end
-    end
-
-    def arithmetic_type_with(type)
-      type._arithmetic_type_with_bitfield(self)
-    end
-
-    def corresponding_signed_type
-      self # NOTREACHED
-    end
-
-    def corresponding_unsigned_type
-      self # NOTREACHED
-    end
-  end
-
-  class BitfieldTypeId < TypeId
-    def initialize(base_type, field_width)
-      super(create_value(base_type, field_width))
-    end
-
-    private
-    def create_value(base_type, field_width)
-      "#{base_type.real_type.name.split(" ").sort.join(" ")}:#{field_width}"
-    end
-  end
-
-  module Scopeable
-    attr_accessor :scope
-  end
-
-  class EnumType < IntegerType
-    include Scopeable
-    include StandardTypeAccessor
-
-    def initialize(type_table, enum_type_declaration)
-      super(type_table, enum_type_declaration.identifier.value,
-            int_size, int_alignment, true, true, [enum_type_declaration])
-
-      @image = enum_type_declaration.enum_specifier.to_s
-      @location = enum_type_declaration.location
-    end
-
-    attr_accessor :image
-    attr_accessor :location
-
-    def id
-      @id ||= EnumTypeId.new(name)
-    end
-
-    def incomplete?
-      declarations.all? { |decl| decl.enumerators.nil? }
-    end
-
-    def pointer?
-      false
-    end
-
-    def enum?
-      true
-    end
-
-    def bitfield?
-      false
-    end
-
-    def brief_image
-      "enum #{name}"
-    end
-
-    def enumerators
-      declarations.map { |decl| decl.enumerators }.compact.flatten.uniq
-    end
-
-    def integer_conversion_rank
-      # NOTE: The ISO C99 standard saids;
-      #
-      # 6.3.1 Arithmetic operands
-      # 6.3.1.1 Boolean, characters, and integers
-      #
-      # 1 Every integer type has an integer conversion rank defined as follows:
-      #
-      #     -- No two signed integer types shall have the same rank, even if
-      #        they have the same representation.
-      #     -- The rank of a signed integer type shall be greater than the rank
-      #        of any signed integer type with less precision.
-      #     -- The rank of long long int shall be greater than the rank of long
-      #        int, which shall be greater than the rank of int, which shall be
-      #        greater than the rank of short int, which shall be greater than
-      #        the rank of signed char.
-      #     -- The rank of any unsigned integer type shall equal the rank of
-      #        the corresponding signed integer type, if any.
-      #     -- The rank of any standard integer type shall be greater than the
-      #        rank of any extended integer type with the same width.
-      #     -- The rank of char shall equal the rank of signed char and
-      #        unsigned char.
-      #     -- The rank of _Bool shall be less than the rank of all other
-      #        standard integer types.
-      #     -- The rank of any enumerated type shall equal the rank of the
-      #        compatible integer type.
-      #     -- The rank of any extended signed integer type relative to another
-      #        extended signed integer type with the same precision is
-      #        implementation-defined, but still subject to the other rules for
-      #        determining the integer conversion rank.
-      #     -- For all integer types T1, T2, and T3, if T1 has greater rank
-      #        than T2 and T2 has greater rank than T3, then T1 has greater
-      #        rank than T3.
-      #
-      # NOTE: The integer conversion rank of any enumerated type is equal to
-      #       the rank of int.
-      int_type.integer_conversion_rank
-    end
-
-    def integer_promoted_type
-      int_type
-    end
-
-    def arithmetic_type_with(type)
-      type._arithmetic_type_with_enum(self)
+      type._arithmetic_type_with_enum(self)
     end
 
     def corresponding_signed_type
@@ -5409,6 +5226,10 @@ module C #:nodoc:
       false
     end
 
+    def standard?
+      false
+    end
+
     def undeclared?
       @base_type.undeclared?
     end
@@ -5518,6 +5339,253 @@ module C #:nodoc:
     end
   end
 
+  class FloatingType < ScalarDataType
+    def initialize(type_table, name, bit_size, bit_alignment)
+      super(type_table, name, bit_size, bit_alignment)
+    end
+
+    def id
+      subclass_responsibility
+    end
+
+    def image
+      name
+    end
+
+    def brief_image
+      name
+    end
+
+    def location
+      nil
+    end
+
+    def incomplete?
+      false
+    end
+
+    def compatible?(to_type)
+      type.floating? &&
+        to_type.min_value <= self.min_value &&
+        self.max_value <= to_type.max_value
+    end
+
+    def integer?
+      false
+    end
+
+    def floating?
+      true
+    end
+
+    def pointer?
+      false
+    end
+
+    def enum?
+      false
+    end
+
+    def bitfield?
+      false
+    end
+
+    def signed?
+      true
+    end
+
+    def explicitly_signed?
+      true
+    end
+
+    def enumerators
+      []
+    end
+
+    def min_value
+      (-2**fraction_bit_size * 10**(exponent_bit_size - 1)).to_f
+    end
+
+    def max_value
+      (2**fraction_bit_size * 10**(exponent_bit_size - 1)).to_f
+    end
+
+    def integer_conversion_rank
+      0 # NOTREACHED
+    end
+
+    def integer_promoted_type
+      self # NOTREACHED
+    end
+
+    def argument_promoted_type
+      subclass_responsibility
+    end
+
+    def arithmetic_type_with(type)
+      subclass_responsibility
+    end
+
+    def corresponding_signed_type
+      self # NOTREACHED
+    end
+
+    def corresponding_unsigned_type
+      self # NOTREACHED
+    end
+
+    private
+    def fraction_bit_size
+      subclass_responsibility
+    end
+
+    def exponent_bit_size
+      subclass_responsibility
+    end
+  end
+
+  class StandardFloatingType < FloatingType
+    def standard?
+      true
+    end
+  end
+
+  class FloatType < StandardFloatingType
+    include StandardTypeAccessor
+
+    def initialize(type_table)
+      super(type_table, "float", float_size, float_alignment)
+    end
+
+    def id
+      @id ||= FloatTypeId.new
+    end
+
+    def argument_promoted_type
+      # NOTE: The ISO C99 standard saids;
+      #
+      # 6.5.2.2 Function calls
+      #
+      # 6 If the expression that denotes the called function has a type that
+      #   does not include a prototype, the integer promotions are performed on
+      #   each argument, and arguments that have type float are promoted to
+      #   double.  These are called the default argument promotions.  If the
+      #   number of arguments does not equal the number of parameters, the
+      #   behavior is undefined.  If the function is defined with a type that
+      #   includes a prototype, and either the prototype ends with an ellipsis
+      #   (, ...) or the types of the arguments after promotion are not
+      #   compatible with the types of the parameters, the behavior is
+      #   undefined.  If the function is defined with a type that does not
+      #   include a prototype, and the types of the arguments after promotion
+      #   are not compatible with those of the parameters after promotion, the
+      #   behavior is undefined, except for the following cases:
+      #
+      #     -- one promoted type is a signed integer type, the other promoted
+      #        type is the corresponding unsigned integer type, and the value
+      #        is representable in both types;
+      #     -- both types are pointers to qualified or unqualified versions of
+      #        a character type or void.
+      double_type
+    end
+
+    def arithmetic_type_with(type)
+      type._arithmetic_type_with_float(self)
+    end
+
+    private
+    def fraction_bit_size
+      # TODO: Bit size of the fraction part of `float' should be configurable.
+      23
+    end
+
+    def exponent_bit_size
+      # TODO: Bit size of the exponent part of `float' should be configurable.
+      8
+    end
+  end
+
+  class FloatTypeId < StandardTypeId
+    def initialize
+      super("float")
+    end
+  end
+
+  class DoubleType < StandardFloatingType
+    include StandardTypeAccessor
+
+    def initialize(type_table)
+      super(type_table, "double", double_size, double_alignment)
+    end
+
+    def id
+      @id ||= DoubleTypeId.new
+    end
+
+    def argument_promoted_type
+      self
+    end
+
+    def arithmetic_type_with(type)
+      type._arithmetic_type_with_double(self)
+    end
+
+    private
+    def fraction_bit_size
+      # TODO: Bit size of the fraction part of `double' should be configurable.
+      52
+    end
+
+    def exponent_bit_size
+      # TODO: Bit size of the exponent part of `double' should be configurable.
+      11
+    end
+  end
+
+  class DoubleTypeId < StandardTypeId
+    def initialize
+      super("double")
+    end
+  end
+
+  class LongDoubleType < StandardFloatingType
+    include StandardTypeAccessor
+
+    def initialize(type_table)
+      super(type_table, "long double", long_double_size, long_double_alignment)
+    end
+
+    def id
+      @id ||= LongDoubleTypeId.new
+    end
+
+    def argument_promoted_type
+      self
+    end
+
+    def arithmetic_type_with(type)
+      type._arithmetic_type_with_long_double(self)
+    end
+
+    private
+    def fraction_bit_size
+      # TODO: Bit size of the fraction part of `long double' should be
+      #       configurable.
+      52
+    end
+
+    def exponent_bit_size
+      # TODO: Bit size of the exponent part of `long double' should be
+      #       configurable.
+      11
+    end
+  end
+
+  class LongDoubleTypeId < StandardTypeId
+    def initialize
+      super("long double")
+    end
+  end
+
   class ArrayType < Type
     # NOTE: To avoid huge array allocation in interpreting phase.
     MAX_LENGTH = 256
@@ -5677,6 +5745,10 @@ module C #:nodoc:
       false
     end
 
+    def standard?
+      false
+    end
+
     def undeclared?
       @base_type.undeclared?
     end
@@ -6237,6 +6309,10 @@ module C #:nodoc:
       false
     end
 
+    def standard?
+      false
+    end
+
     def undeclared?
       @members.any? { |member| member.type.undeclared? }
     end
@@ -6807,6 +6883,11 @@ module C #:nodoc:
     end
 
     def_delegator :@base_type, :void?
+
+    def standard?
+      false
+    end
+
     def_delegator :@base_type, :undeclared?
     def_delegator :@base_type, :unresolved?
     def_delegator :@base_type, :const?
@@ -6954,6 +7035,7 @@ module C #:nodoc:
     def_delegator :@type, :enum?
     def_delegator :@type, :user?
     def_delegator :@type, :void?
+    def_delegator :@type, :standard?
     def_delegator :@type, :undeclared?
     def_delegator :@type, :unresolved?
     def_delegator :@type, :const?
@@ -7052,6 +7134,10 @@ module C #:nodoc:
       false
     end
 
+    def standard?
+      false
+    end
+
     def bitfield?
       false
     end