adlint 3.0.4 → 3.0.8

data/lib/adlint/cc1/domain.rb

@@ -42,57 +42,112 @@ module Cc1 #:nodoc:
     def equal_to(numeric, logical_shr)
       EqualToValueDomain.new(numeric, logical_shr)
     end
-    memoize :equal_to
+    # NOTE: Value of #equal_to depends on the `logical_shr' parameter derived
+    #       from the traits object.
+    #       But the traits object is unique in an AdLint instance.
+    #       So, it is safe to treat this method as unary method for improving
+    #       the performance.
+    memoize :equal_to, key_indices: [0]
 
     def not_equal_to(numeric, logical_shr)
       equal_to(numeric, logical_shr).inversion
     end
-    memoize :not_equal_to
+    # NOTE: Value of #not_equal_to depends on the `logical_shr' parameter
+    #       derived from the traits object.
+    #       But the traits object is unique in an AdLint instance.
+    #       So, it is safe to treat this method as unary method for improving
+    #       the performance.
+    memoize :not_equal_to, key_indices: [0]
 
     def less_than(numeric, logical_shr)
       LessThanValueDomain.new(numeric, logical_shr)
     end
-    memoize :less_than
+    # NOTE: Value of #less_than depends on the `logical_shr' parameter derived
+    #       from the traits object.
+    #       But the traits object is unique in an AdLint instance.
+    #       So, it is safe to treat this method as unary method for improving
+    #       the performance.
+    memoize :less_than, key_indices: [0]
 
     def greater_than(numeric, logical_shr)
       GreaterThanValueDomain.new(numeric, logical_shr)
     end
-    memoize :greater_than
+    # NOTE: Value of #greater_than depends on the `logical_shr' parameter
+    #       derived from the traits object.
+    #       But the traits object is unique in an AdLint instance.
+    #       So, it is safe to treat this method as unary method for improving
+    #       the performance.
+    memoize :greater_than, key_indices: [0]
 
     def less_than_or_equal_to(numeric, logical_shr)
       less_than(numeric, logical_shr).union(equal_to(numeric, logical_shr))
     end
-    memoize :less_than_or_equal_to
+    # NOTE: Value of #less_than_or_equal_to depends on the `logical_shr'
+    #       parameter derived from the traits object.
+    #       But the traits object is unique in an AdLint instance.
+    #       So, it is safe to treat this method as unary method for improving
+    #       the performance.
+    memoize :less_than_or_equal_to, key_indices: [0]
 
     def greater_than_or_equal_to(numeric, logical_shr)
       greater_than(numeric, logical_shr).union(equal_to(numeric, logical_shr))
     end
-    memoize :greater_than_or_equal_to
+    # NOTE: Value of #greater_than_or_equal_to depends on the `logical_shr'
+    #       parameter derived from the traits object.
+    #       But the traits object is unique in an AdLint instance.
+    #       So, it is safe to treat this method as unary method for improving
+    #       the performance.
+    memoize :greater_than_or_equal_to, key_indices: [0]
 
     def of_true(logical_shr)
       not_equal_to(0, logical_shr)
     end
-    memoize :of_true
+    # NOTE: Value of #of_true depends on the `logical_shr' parameter derived
+    #       from the traits object.
+    #       But the traits object is unique in an AdLint instance.
+    #       So, it is safe to treat this method as nullary method for improving
+    #       the performance.
+    memoize :of_true, force_nullary: true
 
     def of_false(logical_shr)
       equal_to(0, logical_shr)
     end
-    memoize :of_false
+    # NOTE: Value of #of_false depends on the `logical_shr' parameter derived
+    #       from the traits object.
+    #       But the traits object is unique in an AdLint instance.
+    #       So, it is safe to treat this method as nullary method for improving
+    #       the performance.
+    memoize :of_false, force_nullary: true
 
     def of_unlimited(logical_shr)
       UnlimitedValueDomain.new(logical_shr)
     end
-    memoize :of_unlimited
+    # NOTE: Value of #of_unlimited depends on the `logical_shr' parameter
+    #       derived from the traits object.
+    #       But the traits object is unique in an AdLint instance.
+    #       So, it is safe to treat this method as nullary method for improving
+    #       the performance.
+    memoize :of_unlimited, force_nullary: true
 
     def of_nil(logical_shr)
       NilValueDomain.new(logical_shr)
     end
-    memoize :of_nil
+    # NOTE: Value of #of_nil depends on the `logical_shr' parameter derived
+    #       from the traits object.
+    #       But the traits object is unique in an AdLint instance.
+    #       So, it is safe to treat this method as nullary method for improving
+    #       the performance.
+    memoize :of_nil, force_nullary: true
 
     def of_nan(logical_shr)
       NaN.new(logical_shr)
     end
-    memoize :of_nan
+    # NOTE: Value of #of_nan depends on the `logical_shr' parameter derived
+    #       from the traits object.
+    #       But the traits object is unique in an AdLint instance.
+    #       So, it is safe to treat this method as nullary method for improving
+    #       the performance.
+    memoize :of_nan, force_nullary: true
 
     def of_intersection(lhs_dom, rhs_dom)
       case lhs_dom
@@ -168,7 +223,12 @@ module Cc1 #:nodoc:
     def of_ambiguous(undefined, logical_shr)
       AmbiguousValueDomain.new(undefined, logical_shr)
     end
-    memoize :of_ambiguous
+    # NOTE: Value of #of_ambiguous depends on the `logical_shr' parameter
+    #       derived from the traits object.
+    #       But the traits object is unique in an AdLint instance.
+    #       So, it is safe to treat this method as unary method for improving
+    #       the performance.
+    memoize :of_ambiguous, key_indices: [0]
 
     def _create_intersection(lhs_dom, rhs_dom)
       expected = lhs_dom.complexity + rhs_dom.complexity

data/lib/adlint/cc1/enum.rb

@@ -44,6 +44,10 @@ module Cc1 #:nodoc:
     def lookup(name_str)
       @enumerators[name_str]
     end
+
+    def designators
+      @enumerators.keys.to_set
+    end
   end
 
 end

data/lib/adlint/cc1/expr.rb

@@ -550,7 +550,9 @@ module Cc1 #:nodoc:
         }
 
         unless fun.builtin?
-          arg_vars = args.map { |arg_obj, *| object_to_variable(arg_obj) }
+          arg_vars = args.map { |arg_obj, arg_expr|
+            object_to_variable(arg_obj, arg_expr)
+          }
           notify_function_call_expr_evaled(node, fun, arg_vars, res_var)
         end
 
@@ -627,7 +629,7 @@ module Cc1 #:nodoc:
       end
 
       def eval_postfix_increment_expr(node, obj)
-        var = object_to_variable(obj)
+        var = object_to_variable(obj, node)
         if !var.type.scalar? && !var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
@@ -650,7 +652,7 @@ module Cc1 #:nodoc:
       end
 
       def eval_postfix_decrement_expr(node, obj)
-        var = object_to_variable(obj)
+        var = object_to_variable(obj, node)
         if !var.type.scalar? && !var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
@@ -673,7 +675,7 @@ module Cc1 #:nodoc:
       end
 
       def eval_prefix_increment_expr(node, obj)
-        var = object_to_variable(obj)
+        var = object_to_variable(obj, node)
         if !var.type.scalar? && !var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
@@ -696,7 +698,7 @@ module Cc1 #:nodoc:
       end
 
       def eval_prefix_decrement_expr(node, obj)
-        var = object_to_variable(obj)
+        var = object_to_variable(obj, node)
         if !var.type.scalar? && !var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
@@ -724,13 +726,13 @@ module Cc1 #:nodoc:
         #       variable cross-references.
         _notify_variable_value_referred(node, obj)
 
-        ptr = create_tmpvar(pointer_type(obj.type), pointer_value_of(obj))
+        ptr = object_to_pointer(obj, node)
         notify_address_expr_evaled(node, obj, ptr)
         ptr
       end
 
       def eval_indirection_expr(node, obj)
-        var = object_to_variable(obj)
+        var = object_to_variable(obj, node)
         if var.type.pointer?
           ptr = var
         else
@@ -768,7 +770,7 @@ module Cc1 #:nodoc:
       end
 
       def eval_unary_arithmetic_expr(node, obj)
-        var = object_to_variable(obj)
+        var = object_to_variable(obj, node)
         if !var.type.scalar? && !var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
@@ -795,7 +797,7 @@ module Cc1 #:nodoc:
       def eval_cast_expr(node, obj)
         resolve_unresolved_type(node.type_name)
 
-        var = object_to_variable(obj)
+        var = object_to_variable(obj, node)
         res_var = do_conversion(var, node.type_name.type) ||
                   create_tmpvar(node.type_name.type)
 
@@ -810,13 +812,13 @@ module Cc1 #:nodoc:
       end
 
       def eval_multiplicative_expr(node, lhs_obj, rhs_obj)
-        lhs_var = object_to_variable(lhs_obj)
+        lhs_var = object_to_variable(lhs_obj, node.lhs_operand)
         if !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
         end
 
-        rhs_var = object_to_variable(rhs_obj)
+        rhs_var = object_to_variable(rhs_obj, node.rhs_operand)
         if !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
@@ -863,13 +865,13 @@ module Cc1 #:nodoc:
       end
 
       def eval_additive_expr(node, lhs_obj, rhs_obj)
-        lhs_var = object_to_variable(lhs_obj)
+        lhs_var = object_to_variable(lhs_obj, node.lhs_operand)
         if !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
         end
 
-        rhs_var = object_to_variable(rhs_obj)
+        rhs_var = object_to_variable(rhs_obj, node.rhs_operand)
         if !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
@@ -908,13 +910,13 @@ module Cc1 #:nodoc:
       end
 
       def eval_shift_expr(node, lhs_obj, rhs_obj)
-        lhs_var = object_to_variable(lhs_obj)
+        lhs_var = object_to_variable(lhs_obj, node.lhs_operand)
         if !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
         end
 
-        rhs_var = object_to_variable(rhs_obj)
+        rhs_var = object_to_variable(rhs_obj, node.rhs_operand)
         if !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
@@ -963,13 +965,13 @@ module Cc1 #:nodoc:
       end
 
       def eval_relational_expr(node, lhs_obj, rhs_obj)
-        lhs_var = object_to_variable(lhs_obj)
+        lhs_var = object_to_variable(lhs_obj, node.lhs_operand)
         if !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar(int_t, scalar_value_of_arbitrary)
         end
 
-        rhs_var = object_to_variable(rhs_obj)
+        rhs_var = object_to_variable(rhs_obj, node.rhs_operand)
         if !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar(int_t, scalar_value_of_arbitrary)
@@ -1008,13 +1010,13 @@ module Cc1 #:nodoc:
       end
 
       def eval_equality_expr(node, lhs_obj, rhs_obj)
-        lhs_var = object_to_variable(lhs_obj)
+        lhs_var = object_to_variable(lhs_obj, node.lhs_operand)
         if !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar(int_t, scalar_value_of_arbitrary)
         end
 
-        rhs_var = object_to_variable(rhs_obj)
+        rhs_var = object_to_variable(rhs_obj, node.rhs_operand)
         if !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar(int_t, scalar_value_of_arbitrary)
@@ -1049,13 +1051,13 @@ module Cc1 #:nodoc:
       end
 
       def eval_and_expr(node, lhs_obj, rhs_obj)
-        lhs_var = object_to_variable(lhs_obj)
+        lhs_var = object_to_variable(lhs_obj, node.lhs_operand)
         if !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
         end
 
-        rhs_var = object_to_variable(rhs_obj)
+        rhs_var = object_to_variable(rhs_obj, node.rhs_operand)
         if !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
@@ -1085,13 +1087,13 @@ module Cc1 #:nodoc:
       end
 
       def eval_exclusive_or_expr(node, lhs_obj, rhs_obj)
-        lhs_var = object_to_variable(lhs_obj)
+        lhs_var = object_to_variable(lhs_obj, node.lhs_operand)
         if !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
         end
 
-        rhs_var = object_to_variable(rhs_obj)
+        rhs_var = object_to_variable(rhs_obj, node.rhs_operand)
         if !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
@@ -1121,13 +1123,13 @@ module Cc1 #:nodoc:
       end
 
       def eval_inclusive_or_expr(node, lhs_obj, rhs_obj)
-        lhs_var = object_to_variable(lhs_obj)
+        lhs_var = object_to_variable(lhs_obj, node.lhs_operand)
         if !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
         end
 
-        rhs_var = object_to_variable(rhs_obj)
+        rhs_var = object_to_variable(rhs_obj, node.rhs_operand)
         if !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return create_tmpvar
@@ -1157,8 +1159,8 @@ module Cc1 #:nodoc:
       end
 
       def eval_simple_assignment_expr(node, lhs_obj, rhs_obj)
-        lhs_var = object_to_variable(lhs_obj)
-        rhs_var = object_to_variable(rhs_obj)
+        lhs_var = object_to_variable(lhs_obj, node.lhs_operand)
+        rhs_var = object_to_variable(rhs_obj, node.rhs_operand)
 
         if rhs_var.type.same_as?(lhs_var.type)
           rhs_conved = rhs_var
@@ -1182,13 +1184,13 @@ module Cc1 #:nodoc:
       end
 
       def eval_compound_assignment_expr(node, lhs_obj, rhs_obj)
-        lhs_var = object_to_variable(lhs_obj)
+        lhs_var = object_to_variable(lhs_obj, node.lhs_operand)
         if !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return lhs_obj
         end
 
-        rhs_var = object_to_variable(rhs_obj)
+        rhs_var = object_to_variable(rhs_obj, node.rhs_operand)
         if !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
           return lhs_var

data/lib/adlint/cc1/interp.rb

@@ -191,11 +191,17 @@ module Cc1 #:nodoc:
     # NOTE: Notified when the interpreter evaluates a cast-expression.
     def_plugin_and_notifier :explicit_conv_performed, :expr, :org_var, :res_var
 
-    # NOTE: Notified when the interpreter performs an implicit type conversion
-    #       while evaluating an expression.
+    # NOTE: Notified when the interpreter performs an implicit conversion while
+    #       evaluating an expression.
     def_plugin_and_notifier :implicit_conv_performed,
                             :init_or_expr, :org_var, :res_var
 
+    # NOTE: Notified when the interpreter performs an address derivation while
+    #       address-expression evaluation and array or function address
+    #       derivation.
+    def_plugin_and_notifier :address_derivation_performed,
+                            :init_or_expr, :obj, :ptr
+
     # NOTE: Notified when the interpreter evaluates an
     #       array-subscript-expression.
     def_plugin_and_notifier :array_subscript_expr_evaled,
@@ -427,37 +433,6 @@ module Cc1 #:nodoc:
       @options_stack.pop
     end
 
-    def object_to_variable(obj)
-      case
-      when obj.function?
-        function_to_pointer(obj)
-      when obj.variable? && obj.type.array?
-        array_to_pointer(obj)
-      else
-        obj
-      end
-    end
-
-    def function_to_pointer(fun)
-      create_tmpvar(pointer_type(fun.type), pointer_value_of(fun))
-    end
-
-    def array_to_pointer(ary)
-      create_tmpvar(pointer_type(ary.type.base_type), pointer_value_of(ary))
-    end
-
-    def value_of(obj)
-      if obj.type.array? || obj.type.function?
-        pointer_value_of(obj)
-      else
-        obj.value.to_single_value
-      end
-    end
-
-    def pointer_value_of(obj)
-      scalar_value_of(obj.binding.memory.address)
-    end
-
     def quiet?
       cur_opts.include?(QUIET) || cur_opts.include?(QUIET_WITHOUT_SIDE_EFFECT)
     end
@@ -592,8 +567,20 @@ module Cc1 #:nodoc:
       end
 
       if node.initializer
-        init_var, init_conved = evaluate_initializer(node)
-        var = define_variable(node, init_conved.value.to_defined_value)
+        if node.type.incomplete?
+          # NOTE: Unable to define variable of incomplete type such as an array
+          #       without length.
+          init_var, init_conved = evaluate_initializer(node)
+          var = define_variable(node, init_conved.value.to_defined_value)
+        else
+          # NOTE: Define variable first in order to correctly evaluate
+          #       sizeof-expression that refers to the defining variable in the
+          #       initializer.
+          define_variable(node) unless variable_named(node.identifier.value)
+          init_var, init_conved = evaluate_initializer(node)
+          var = define_variable(node, init_conved.value.to_defined_value)
+        end
+
         notify_variable_value_referred(node, init_var)
         notify_variable_defined(node, var)
         notify_variable_initialized(node, var, init_var)
@@ -736,9 +723,7 @@ module Cc1 #:nodoc:
     def evaluate_expression(expr, type)
       checkpoint(expr.location)
 
-      obj = interpret(expr)
-      var = object_to_variable(obj)
-      notify_implicit_conv_performed(expr, obj, var) unless var == obj
+      var = object_to_variable(interpret(expr), expr)
 
       if var.type.same_as?(type)
         conved = var
@@ -969,7 +954,7 @@ module Cc1 #:nodoc:
 
       node.executed = true
       ctrlexpr = node.expression
-      ctrlexpr_var = object_to_variable(interpret(ctrlexpr, QUIET))
+      ctrlexpr_var = object_to_variable(interpret(ctrlexpr, QUIET), ctrlexpr)
       notify_case_ctrlexpr_evaled(node, ctrlexpr_var)
 
       interpret(node.statement)
@@ -1017,7 +1002,8 @@ module Cc1 #:nodoc:
         ctrlexpr_val = scalar_value_of_arbitrary
         ctrlexpr = nil
       else
-        ctrlexpr_var = object_to_variable(interpret(org_ctrlexpr))
+        ctrlexpr_var = object_to_variable(interpret(org_ctrlexpr),
+                                          org_ctrlexpr)
         ctrlexpr_val = value_of(ctrlexpr_var)
         notify_variable_value_referred(org_ctrlexpr, ctrlexpr_var)
         notify_sequence_point_reached(SequencePoint.new(org_ctrlexpr))
@@ -1050,7 +1036,8 @@ module Cc1 #:nodoc:
         ctrlexpr_val = scalar_value_of_arbitrary
         ctrlexpr = nil
       else
-        ctrlexpr_var = object_to_variable(interpret(org_ctrlexpr))
+        ctrlexpr_var = object_to_variable(interpret(org_ctrlexpr),
+                                          org_ctrlexpr)
         ctrlexpr_val = value_of(ctrlexpr_var)
         notify_variable_value_referred(org_ctrlexpr, ctrlexpr_var)
         notify_sequence_point_reached(SequencePoint.new(org_ctrlexpr))
@@ -1088,7 +1075,8 @@ module Cc1 #:nodoc:
 
       widen_varying_variable_value_domain(node)
 
-      ctrlexpr_var = object_to_variable(interpret(node.expression))
+      ctrlexpr_var = object_to_variable(interpret(node.expression),
+                                        node.expression)
       ctrlexpr_val = value_of(ctrlexpr_var)
       notify_variable_value_referred(node.expression, ctrlexpr_var)
       notify_sequence_point_reached(SequencePoint.new(node.expression))
@@ -1139,7 +1127,8 @@ module Cc1 #:nodoc:
         leave_iteration_statement(org_ctrlexpr)
       end
 
-      ctrlexpr_var = object_to_variable(interpret(node.expression))
+      ctrlexpr_var = object_to_variable(interpret(node.expression),
+                                        node.expression)
       ctrlexpr_val = value_of(ctrlexpr_var)
       notify_variable_value_referred(node.expression, ctrlexpr_var)
       notify_sequence_point_reached(SequencePoint.new(node.expression))
@@ -1161,7 +1150,8 @@ module Cc1 #:nodoc:
 
       node.condition_statement.executed = true
       if explicit_ctrlexpr = node.condition_statement.expression
-        ctrlexpr_var = object_to_variable(interpret(explicit_ctrlexpr))
+        ctrlexpr_var = object_to_variable(interpret(explicit_ctrlexpr),
+                                          explicit_ctrlexpr)
         ctrlexpr_val = value_of(ctrlexpr_var)
         notify_variable_value_referred(explicit_ctrlexpr, ctrlexpr_var)
         notify_sequence_point_reached(SequencePoint.new(explicit_ctrlexpr))
@@ -1194,7 +1184,8 @@ module Cc1 #:nodoc:
 
         node.condition_statement.executed = true
         if explicit_ctrlexpr = node.condition_statement.expression
-          ctrlexpr_var = object_to_variable(interpret(explicit_ctrlexpr))
+          ctrlexpr_var = object_to_variable(interpret(explicit_ctrlexpr),
+                                            explicit_ctrlexpr)
           ctrlexpr_val = value_of(ctrlexpr_var)
           notify_variable_value_referred(explicit_ctrlexpr, ctrlexpr_var)
           notify_sequence_point_reached(SequencePoint.new(explicit_ctrlexpr))
@@ -1246,12 +1237,7 @@ module Cc1 #:nodoc:
         BreakEvent.of_return.throw
       end
 
-      obj = interpret(node.expression)
-      var = object_to_variable(obj)
-      unless var == obj
-        notify_implicit_conv_performed(node.expression, obj, var)
-      end
-
+      var = object_to_variable(interpret(node.expression), node.expression)
       notify_variable_value_referred(node.expression, var)
 
       if active_fun = interpreter._active_function and
@@ -1296,7 +1282,8 @@ module Cc1 #:nodoc:
           #        causes "logical-expression must be false" warnings about a
           #        one-time-for-loop.  To avoid this, now, workarounds are in
           #        builtin code checks W0609 and W0610.
-          var = object_to_variable(interpret(explicit_ctrlexpr))
+          var = object_to_variable(interpret(explicit_ctrlexpr),
+                                   explicit_ctrlexpr)
           notify_variable_value_referred(explicit_ctrlexpr, var)
           notify_sequence_point_reached(SequencePoint.new(explicit_ctrlexpr))
         end
@@ -1440,7 +1427,7 @@ module Cc1 #:nodoc:
       notify_switch_stmt_started(node)
 
       ctrlexpr = node.expression
-      ctrlexpr_var = object_to_variable(interpret(ctrlexpr))
+      ctrlexpr_var = object_to_variable(interpret(ctrlexpr), ctrlexpr)
       notify_switch_ctrlexpr_evaled(node, ctrlexpr_var)
       notify_variable_value_referred(ctrlexpr, ctrlexpr_var)
 
@@ -1693,7 +1680,7 @@ module Cc1 #:nodoc:
       checkpoint(node.location)
 
       ctrlexpr = node.condition
-      ctrlexpr_var = object_to_variable(interpret(ctrlexpr))
+      ctrlexpr_var = object_to_variable(interpret(ctrlexpr), ctrlexpr)
       ctrlexpr_val = value_of(ctrlexpr_var)
       notify_variable_value_referred(ctrlexpr, ctrlexpr_var)
       notify_sequence_point_reached(ctrlexpr.subsequent_sequence_point)
@@ -1702,14 +1689,16 @@ module Cc1 #:nodoc:
       then_var = nil
       if ctrlexpr_val.may_be_true?
         branched_eval(ctrlexpr, NARROWING, IMPLICIT_COND) do
-          then_var = object_to_variable(interpret(node.then_expression))
+          then_var = object_to_variable(interpret(node.then_expression),
+                                        node.then_expression)
         end
       end
 
       else_var = nil
       if ctrlexpr_val.may_be_false?
         branched_eval(nil, NARROWING, FINAL, COMPLETE) do
-          else_var = object_to_variable(interpret(node.else_expression))
+          else_var = object_to_variable(interpret(node.else_expression),
+                                        node.else_expression)
         end
       else
         branched_eval(nil, NARROWING, FINAL, COMPLETE) {}

data/lib/adlint/cc1/lexer.rb

@@ -69,11 +69,11 @@ module Cc1 #:nodoc:
       @object_names.leave_scope
     end
 
-    def start_identifier_translation
+    def enable_identifier_translation
       @identifier_translation = true
     end
 
-    def stop_identifier_translation
+    def disable_identifier_translation
       @identifier_translation = false
     end
 
@@ -119,14 +119,35 @@ module Cc1 #:nodoc:
     end
 
     def translate_identifier(tok, lexer_ctxt)
+      # NOTE: To translate given IDENTIFIER into TYPEDEF_NAME if needed.
+
+      # NOTE: The ISO C99 standard says;
+      #
+      # 6.2.3 Name spaces of identifiers
+      #
+      # 1 If more than one declaration of a particular identifier is visible at
+      #   any point in a translation unit, the syntactic context disambiguates
+      #   uses that refer to different entities.  Thus, there are separate name
+      #   spaces for various categories of identifiers, as follows:
+      #   -- label names (disambiguated by the syntax of the label declaration
+      #      and use);
+      #   -- the tags of structures, unions, and enumerations (disambiguated by
+      #      following any of the keywords struct, union, or enum);
+      #   -- the members of structures or unions; each structure or union has a
+      #      separate name space for its members (disambiguated by the type of
+      #      the expression used to access the member via the . or ->
+      #      operator);
+      #   -- all other identifiers, called ordinary identifiers (declared in
+      #      ordinary declarators or as enumeration constants).
+
       if @identifier_translation
         if tok.type == :IDENTIFIER
           return tok if @object_names.include?(tok.value)
           if @typedef_names.include?(tok.value)
             unless @lst_tok and
-                   @lst_tok.type == :STRUCT || @lst_tok.type == :UNION ||
-                   @lst_tok.type == :ENUM ||
-                   @lst_tok.type == "->" || @lst_tok.type == "."
+                @lst_tok.type == :STRUCT || @lst_tok.type == :UNION ||
+                @lst_tok.type == :ENUM ||
+                @lst_tok.type == "->" || @lst_tok.type == "."
               tok = tok.class.new(:TYPEDEF_NAME, tok.value, tok.location)
             end
           end