adlint 2.6.14 → 3.0.0

data/lib/adlint/{c → cc1}/interp.rb

@@ -1,7 +1,7 @@
 # Kernel of the abstract interpreter of C language.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -30,23 +30,24 @@
 #++
 
 require "adlint/monitor"
-require "adlint/c/environ"
-require "adlint/c/resolver"
-require "adlint/c/mediator"
-require "adlint/c/syntax"
-require "adlint/c/expr"
-require "adlint/c/conv"
-require "adlint/c/option"
-require "adlint/c/operator"
-require "adlint/c/util"
+require "adlint/util"
+require "adlint/cc1/environ"
+require "adlint/cc1/resolver"
+require "adlint/cc1/mediator"
+require "adlint/cc1/syntax"
+require "adlint/cc1/expr"
+require "adlint/cc1/conv"
+require "adlint/cc1/option"
+require "adlint/cc1/operator"
+require "adlint/cc1/util"
 
 module AdLint #:nodoc:
-module C #:nodoc:
+module Cc1 #:nodoc:
 
   class Program
-    def initialize(interp, trans_unit)
+    def initialize(interp, tunit)
       @interpreter = interp
-      @translation_unit = trans_unit
+      @translation_unit = tunit
     end
 
     def execute
@@ -73,10 +74,10 @@ module C #:nodoc:
     include InterpreterOptions
     include BranchOptions
 
-    def initialize(type_table)
-      type_table = type_table
-      @environment = Environment.new(type_table)
-      @type_resolver = DynamicTypeResolver.new(type_table, self)
+    def initialize(type_tbl)
+      @type_table    = type_tbl
+      @environment   = Environment.new(type_tbl)
+      @type_resolver = DynamicTypeResolver.new(type_tbl, self)
 
       @sub_interpreters = [
         DeclarationInterpreter.new(self),
@@ -97,6 +98,12 @@ module C #:nodoc:
     attr_reader :environment
     attr_reader :type_resolver
 
+    extend Forwardable
+
+    def_delegator :@type_table, :traits
+    def_delegator :@type_table, :monitor
+    def_delegator :@type_table, :logger
+
     extend Pluggable
 
     def self.def_plugin_and_notifier(event_name, *arg_names)
@@ -122,10 +129,10 @@ module C #:nodoc:
     def_plugin_and_notifier :variable_initialized, :var_def, :var, :init_var
 
     # NOTE: Notified when the interpreter evaluates a function-declaration.
-    def_plugin_and_notifier :function_declared, :func_dcl, :func
+    def_plugin_and_notifier :explicit_function_declared, :fun_dcl, :fun
 
     # NOTE: Notified when the interpreter evaluates a function-definition.
-    def_plugin_and_notifier :function_defined, :func_def, :func
+    def_plugin_and_notifier :explicit_function_defined, :fun_def, :fun
 
     # NOTE: Notified when the interpreter evaluates a struct-type-declaration.
     def_plugin_and_notifier :struct_declared, :struct_type_dcl
@@ -141,11 +148,11 @@ module C #:nodoc:
 
     # NOTE: Notified when the interpreter starts execution of a
     #       function-definition.
-    def_plugin_and_notifier :function_started, :func_def, :func
+    def_plugin_and_notifier :function_started, :fun_def, :fun
 
     # NOTE: Notified when the interpreter ends execution of a
     #       function-definition.
-    def_plugin_and_notifier :function_ended, :func_def, :func
+    def_plugin_and_notifier :function_ended, :fun_def, :fun
 
     # NOTE: Notified when the interpreter evaluates a parameter-definition at
     #       beginning of execution of a function-definition.
@@ -169,83 +176,85 @@ module C #:nodoc:
 
     # NOTE: Notified when the interpreter refers to a function object while
     #       evaluating an expression.
-    def_plugin_and_notifier :function_referred, :expr, :func
+    def_plugin_and_notifier :function_referred, :expr, :fun
+
+    # NOTE: Notified when the interpreter creates function-declaration of an
+    #       implicit function.
+    def_plugin_and_notifier :implicit_function_declared, :obj_spec, :fun
 
     # NOTE: Notified when the interpreter evaluates a sizeof-expression.
-    def_plugin_and_notifier :sizeof_expr_evaled,
-                            :expr, :operand_var, :result_var
+    def_plugin_and_notifier :sizeof_expr_evaled, :expr, :ope_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates a sizeof-type-expression.
-    def_plugin_and_notifier :sizeof_type_expr_evaled, :expr, :type, :result_var
+    def_plugin_and_notifier :sizeof_type_expr_evaled, :expr, :type, :res_var
 
     # NOTE: Notified when the interpreter evaluates a cast-expression.
-    def_plugin_and_notifier :explicit_conv_performed,
-                            :expr, :orig_var, :result_var
+    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.
     def_plugin_and_notifier :implicit_conv_performed,
-                            :init_or_expr, :orig_var, :result_var
+                            :init_or_expr, :org_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates an
     #       array-subscript-expression.
     def_plugin_and_notifier :array_subscript_expr_evaled,
-                            :expr, :ary_or_ptr, :subs, :ary_var, :result_var
+                            :expr, :ary_or_ptr, :subs, :ary_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates a function-call-expression.
     def_plugin_and_notifier :function_call_expr_evaled,
-                            :expr, :func, :arg_vars, :result_var
+                            :expr, :fun, :arg_vars, :res_var
 
     # NOTE: Notified when the interpreter evaluates an
     #       unary-arithmetic-expression.
     def_plugin_and_notifier :unary_arithmetic_expr_evaled,
-                            :expr, :operand_var, :result_var
+                            :expr, :ope_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates a
     #       multiplicative-expression.
     def_plugin_and_notifier :multiplicative_expr_evaled,
-                            :expr, :lhs_var, :rhs_var, :result_var
+                            :expr, :lhs_var, :rhs_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates an additive-expression.
     def_plugin_and_notifier :additive_expr_evaled,
-                            :expr, :lhs_var, :rhs_var, :result_var
+                            :expr, :lhs_var, :rhs_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates a shift-expression.
     def_plugin_and_notifier :shift_expr_evaled,
-                            :expr, :lhs_var, :rhs_var, :result_var
+                            :expr, :lhs_var, :rhs_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates a relational-expression.
     def_plugin_and_notifier :relational_expr_evaled,
-                            :expr, :lhs_var, :rhs_var, :result_var
+                            :expr, :lhs_var, :rhs_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates an equality-expression.
     def_plugin_and_notifier :equality_expr_evaled,
-                            :expr, :lhs_var, :rhs_var, :result_var
+                            :expr, :lhs_var, :rhs_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates a bitwise and-expression.
     def_plugin_and_notifier :and_expr_evaled,
-                            :expr, :lhs_var, :rhs_var, :result_var
+                            :expr, :lhs_var, :rhs_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates an exclusive-or-expression.
     def_plugin_and_notifier :exclusive_or_expr_evaled,
-                            :expr, :lhs_var, :rhs_var, :result_var
+                            :expr, :lhs_var, :rhs_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates a bitwise
     #       inclusive-or-expression.
     def_plugin_and_notifier :inclusive_or_expr_evaled,
-                            :expr, :lhs_var, :rhs_var, :result_var
+                            :expr, :lhs_var, :rhs_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates a logical-and-expression.
     def_plugin_and_notifier :logical_and_expr_evaled,
-                            :expr, :lhs_var, :rhs_var, :result_var
+                            :expr, :lhs_var, :rhs_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates a logical-or-expression.
     def_plugin_and_notifier :logical_or_expr_evaled,
-                            :expr, :lhs_var, :rhs_var, :result_var
+                            :expr, :lhs_var, :rhs_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates a conditional-expression.
     def_plugin_and_notifier :conditional_expr_evaled,
-                            :expr, :ctrlexpr_var, :result_var
+                            :expr, :ctrlexpr_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates an address-expression.
     def_plugin_and_notifier :address_expr_evaled, :expr, :obj, :ptr_var
@@ -263,22 +272,22 @@ module C #:nodoc:
     # NOTE: Notified when the interpreter evaluates a
     #       prefix-increment-expression.
     def_plugin_and_notifier :prefix_increment_expr_evaled,
-                            :expr, :operand_var, :orig_val
+                            :expr, :ope_var, :org_val
 
     # NOTE: Notified when the interpreter evaluates a
     #       postfix-increment-expression.
     def_plugin_and_notifier :postfix_increment_expr_evaled,
-                            :expr, :operand_var, :result_var
+                            :expr, :ope_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates a
     #       prefix-decrement-expression.
     def_plugin_and_notifier :prefix_decrement_expr_evaled,
-                            :expr, :operand_var, :orig_val
+                            :expr, :ope_var, :org_val
 
     # NOTE: Notified when the interpreter evaluates a
     #       postfix-decrement-expression.
     def_plugin_and_notifier :postfix_decrement_expr_evaled,
-                            :expr, :operand_var, :result_var
+                            :expr, :ope_var, :res_var
 
     # NOTE: Notified when the interpreter evaluates a
     #       simple-assignment-expression or a compound-assignment-expression.
@@ -330,10 +339,10 @@ module C #:nodoc:
     def_plugin_and_notifier :goto_stmt_evaled, :stmt, :label_name
 
     # NOTE: Notified when the interpreter evaluates a return-statement.
-    def_plugin_and_notifier :return_stmt_evaled, :stmt, :result_var
+    def_plugin_and_notifier :return_stmt_evaled, :stmt, :retn_var
 
     # NOTE: Notified when the interpreter evaluates an implicit return.
-    def_plugin_and_notifier :implicit_return_evaled
+    def_plugin_and_notifier :implicit_return_evaled, :loc
 
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the if-statement.
@@ -393,16 +402,16 @@ module C #:nodoc:
 
     # NOTE: Notified when the interpreter starts execution of a
     #       translation-unit.
-    def_plugin_and_notifier :translation_unit_started, :trans_unit
+    def_plugin_and_notifier :translation_unit_started, :tunit
 
     # NOTE: Notified when the interpreter ends execution of a translation-unit.
-    def_plugin_and_notifier :translation_unit_ended, :trans_unit
+    def_plugin_and_notifier :translation_unit_ended, :tunit
 
     # NOTE: Notified when the control reaches to a sequence-point.
     def_plugin_and_notifier :sequence_point_reached, :seqp
 
     def execute(node, *opts)
-      @options_stack.push(current_options + opts)
+      @options_stack.push(cur_opts + opts)
       if quiet_without_side_effect?
         result = nil
         branched_eval(nil, FINAL) do
@@ -421,9 +430,9 @@ module C #:nodoc:
     def object_to_variable(obj)
       case
       when obj.function?
-        create_tempvar(pointer_type(obj.type), pointer_value_of(obj))
+        create_tmpvar(pointer_type(obj.type), pointer_value_of(obj))
       when obj.type.array?
-        create_tempvar(pointer_type(obj.type.base_type), pointer_value_of(obj))
+        create_tmpvar(pointer_type(obj.type.base_type), pointer_value_of(obj))
       else
         obj
       end
@@ -438,33 +447,32 @@ module C #:nodoc:
     end
 
     def pointer_value_of(obj)
-      ScalarValue.of(obj.binding.memory.address)
+      scalar_value_of(obj.binding.memory.address)
     end
 
     def quiet?
-      current_options.include?(QUIET) ||
-        current_options.include?(QUIET_WITHOUT_SIDE_EFFECT)
+      cur_opts.include?(QUIET) || cur_opts.include?(QUIET_WITHOUT_SIDE_EFFECT)
     end
 
     def _quiet=(quiet)
       # NOTE: This method is called only from ControllingExpression.
       if quiet
-        current_options.add(QUIET)
+        cur_opts.add(QUIET)
       else
-        current_options.delete(QUIET)
+        cur_opts.delete(QUIET)
       end
     end
 
     def quiet_without_side_effect?
-      current_options.include?(QUIET_WITHOUT_SIDE_EFFECT)
+      cur_opts.include?(QUIET_WITHOUT_SIDE_EFFECT)
     end
 
     def _quiet_without_side_effect=(quiet_without_side_effect)
       # NOTE: This method is called only from ExpressionEvaluator.
       if quiet_without_side_effect
-        current_options.add(QUIET_WITHOUT_SIDE_EFFECT)
+        cur_opts.add(QUIET_WITHOUT_SIDE_EFFECT)
       else
-        current_options.delete(QUIET_WITHOUT_SIDE_EFFECT)
+        cur_opts.delete(QUIET_WITHOUT_SIDE_EFFECT)
       end
     end
 
@@ -476,9 +484,9 @@ module C #:nodoc:
       @active_function_stack.last
     end
 
-    def _enter_function(func_def)
+    def _enter_function(fun_def)
       # NOTE: This method is called only from FunctionInterpreter.
-      @active_function_stack.push(func_def)
+      @active_function_stack.push(fun_def)
     end
 
     def _leave_function(*)
@@ -493,7 +501,7 @@ module C #:nodoc:
       end
     end
 
-    def current_options
+    def cur_opts
       @options_stack.last || Set.new
     end
 
@@ -505,11 +513,12 @@ module C #:nodoc:
   end
 
   class SubInterpreter < SyntaxTreeVisitor
+    include InterpreterOptions
     include InterpreterMediator
     include NotifierMediator
     include Conversion
     include MonitorUtil
-    include InterpreterOptions
+    include LogUtil
 
     def initialize(owner, target_node_class)
       @owner = owner
@@ -520,8 +529,19 @@ module C #:nodoc:
 
     private
     def interpreter
+      # NOTE: This is private attr_reader for InterpreterMediator.
+      #       This attribute is read via a normal method to suppress
+      #       `private attribute?' warning.
       @owner
     end
+
+    extend Forwardable
+
+    def_delegator :interpreter, :monitor
+    private :monitor
+
+    def_delegator :interpreter, :logger
+    private :logger
   end
 
   class DeclarationInterpreter < SubInterpreter
@@ -537,8 +557,8 @@ module C #:nodoc:
         dcl.mark_as_referred_by(node.identifier)
       end
 
-      func = declare_function(node)
-      notify_function_declared(node, func)
+      fun = declare_explicit_function(node)
+      notify_explicit_function_declared(node, fun)
       evaluate_sequence_point(node.init_declarator.declarator)
     end
 
@@ -622,8 +642,8 @@ module C #:nodoc:
       notify_typedef_declared(node)
       evaluate_sequence_point(node.init_declarator.declarator)
 
-      Analyzer.current.info("user type `#{node.identifier.value}' " +
-                            "defined at #{node.location.to_s}.")
+      LOG_I("user-type `#{node.identifier.value}' " +
+            "defined at #{node.location.to_s}.")
     end
 
     private
@@ -638,7 +658,7 @@ module C #:nodoc:
       #       string-literal-specifier as the initializer.
       if var_def.type.array? && var.type.pointer?
         unless ary = pointee_of(var) and ary.type.array?
-          ary = create_tempvar(var_def.type)
+          ary = create_tmpvar(var_def.type)
         end
         deduct_array_length_from_array_variable(var_def, ary)
         var = conved = ary
@@ -656,8 +676,8 @@ module C #:nodoc:
       end
     end
 
-    def evaluate_sequence_point(full_dcl)
-      if seqp = full_dcl.subsequent_sequence_point
+    def evaluate_sequence_point(full_dcr)
+      if seqp = full_dcr.subsequent_sequence_point
         notify_sequence_point_reached(seqp)
       end
     end
@@ -694,11 +714,11 @@ module C #:nodoc:
           conved = var
         else
           conved = do_conversion(var, var_def.type) ||
-                   create_tempvar(var_def.type)
+                   create_tmpvar(var_def.type)
           notify_implicit_conv_performed(inits, var, conved)
         end
       else
-        var = conved = create_tempvar(var_def.type)
+        var = conved = create_tmpvar(var_def.type)
       end
 
       return var, conved
@@ -715,7 +735,7 @@ module C #:nodoc:
       if var.type.same_as?(type)
         conved = var
       else
-        conved = do_conversion(var, type) || create_tempvar(type)
+        conved = do_conversion(var, type) || create_tmpvar(type)
         notify_implicit_conv_performed(expr, var, conved)
       end
 
@@ -744,9 +764,9 @@ module C #:nodoc:
         #       (recursively) according to these rules.
         if fst_memb = type.members.first
           fst_obj = evaluate_initializers(inits, fst_memb.type)
-          return create_tempvar(type, value_of(fst_obj))
+          return create_tmpvar(type, value_of(fst_obj))
         else
-          return create_tempvar(type)
+          return create_tmpvar(type)
         end
       when type.array?
         # NOTE: The ISO C99 standard says;
@@ -794,22 +814,22 @@ module C #:nodoc:
 
       case
       when type.array?
-        create_tempvar(type, ArrayValue.new(vals))
+        create_tmpvar(type, ArrayValue.new(vals))
       when type.composite?
-        create_tempvar(type, CompositeValue.new(vals))
+        create_tmpvar(type, CompositeValue.new(vals))
       else
-        create_tempvar(type, vals.first)
+        create_tmpvar(type, vals.first)
       end
     end
 
-    def deduct_array_length_from_initializers(orig_ary_type, inits)
-      unless orig_ary_type.length
-        if orig_ary_type.user?
-          orig_ary_type = orig_ary_type.dup
+    def deduct_array_length_from_initializers(org_ary_type, inits)
+      unless org_ary_type.length
+        if org_ary_type.user?
+          org_ary_type = org_ary_type.dup
         end
-        orig_ary_type.length = inits.size
+        org_ary_type.length = inits.size
       end
-      orig_ary_type
+      org_ary_type
     end
 
     def interpreter
@@ -818,6 +838,11 @@ module C #:nodoc:
       #       `private attribute?' warning.
       @interpreter
     end
+
+    extend Forwardable
+
+    def_delegator :interpreter, :monitor
+    private :monitor
   end
 
   class ParameterDefinitionInterpreter < SubInterpreter
@@ -829,15 +854,17 @@ module C #:nodoc:
       checkpoint(node.location)
 
       resolve_unresolved_type(node)
+      id = node.identifier
+
       node.type.declarations.each do |dcl|
-        if identifier = node.identifier
-          dcl.mark_as_referred_by(identifier)
+        if id
+          dcl.mark_as_referred_by(id)
         else
           dcl.mark_as_referred_by(node.head_token)
         end
       end
 
-      if node.identifier
+      if id
         var = define_variable(node.to_variable_definition,
                               node.type.parameter_value)
         notify_parameter_defined(node, var)
@@ -859,49 +886,50 @@ module C #:nodoc:
     end
 
     private
-    def interpret_function(node)
-      checkpoint(node.location)
+    def interpret_function(fun_def)
+      checkpoint(fun_def.location)
 
       reset_environment
-      resolve_unresolved_type(node)
-      func = lookup_or_define_function(node)
-      notify_function_defined(node, func)
-
-      begin
-        interpreter._enter_function(node)
-        scoped_eval do
-          notify_function_started(node, func)
-          notify_block_started(node.function_body)
+      resolve_unresolved_type(fun_def)
+      fun = lookup_or_define_function(fun_def)
+      notify_explicit_function_defined(fun_def, fun)
 
-          node.parameter_definitions.each { |param_def| interpret(param_def) }
+      interpret_function_body(fun_def, fun) if fun_def.analysis_target?(traits)
+    end
 
-          BreakEvent.catch do
-            node.function_body.block_items.each { |item| interpret(item) }
-            notify_implicit_return_evaled
-          end
+    def interpret_function_body(fun_def, fun)
+      interpreter._enter_function(fun_def)
+      scoped_eval do
+        notify_function_started(fun_def, fun)
+        notify_block_started(fun_def.function_body)
 
-          notify_block_ended(node.function_body)
-          notify_function_ended(node, func)
+        fun_def.parameter_definitions.each { |param_def| interpret(param_def) }
+        BreakEvent.catch do
+          fun_def.function_body.block_items.each { |item| interpret(item) }
+          notify_implicit_return_evaled(fun_def.function_body.tail_location)
         end
-      ensure
-        interpreter._leave_function(node)
+
+        notify_block_ended(fun_def.function_body)
+        notify_function_ended(fun_def, fun)
       end
+    ensure
+      interpreter._leave_function(fun_def)
     end
 
-    def lookup_or_define_function(func_def)
-      func_def.type.declarations.each do |dcl|
-        dcl.mark_as_referred_by(func_def.identifier)
+    def lookup_or_define_function(fun_def)
+      fun_def.type.declarations.each do |dcl|
+        dcl.mark_as_referred_by(fun_def.identifier)
       end
 
-      if func = function_named(func_def.identifier.value)
-        func.declarations_and_definitions.each do |dcl_or_def|
-          dcl_or_def.mark_as_referred_by(func_def.identifier)
+      if fun = function_named(fun_def.identifier.value) and fun.explicit?
+        fun.declarations_and_definitions.each do |dcl_or_def|
+          dcl_or_def.mark_as_referred_by(fun_def.identifier)
         end
-        func.declarations_and_definitions.push(func_def)
+        fun.declarations_and_definitions.push(fun_def)
+        fun
       else
-        func = define_explicit_function(func_def)
+        define_explicit_function(fun_def)
       end
-      func
     end
   end
 
@@ -976,16 +1004,16 @@ module C #:nodoc:
 
       node.executed = true
 
-      orig_ctrlexpr = node.expression
-      if orig_ctrlexpr == effective_ctrlexpr
-        ctrlexpr_val = ScalarValue.of_arbitrary
+      org_ctrlexpr = node.expression
+      if org_ctrlexpr == effective_ctrlexpr
+        ctrlexpr_val = scalar_value_of_arbitrary
         ctrlexpr = nil
       else
-        ctrlexpr_var = object_to_variable(interpret(orig_ctrlexpr))
+        ctrlexpr_var = object_to_variable(interpret(org_ctrlexpr))
         ctrlexpr_val = value_of(ctrlexpr_var)
-        notify_variable_value_referred(orig_ctrlexpr, ctrlexpr_var)
-        notify_sequence_point_reached(SequencePoint.new(orig_ctrlexpr))
-        ctrlexpr = orig_ctrlexpr.to_normalized_logical
+        notify_variable_value_referred(org_ctrlexpr, ctrlexpr_var)
+        notify_sequence_point_reached(SequencePoint.new(org_ctrlexpr))
+        ctrlexpr = org_ctrlexpr.to_normalized_logical
       end
       notify_if_ctrlexpr_evaled(node, ctrlexpr_val)
 
@@ -1009,16 +1037,16 @@ module C #:nodoc:
 
       node.executed = true
 
-      orig_ctrlexpr = node.expression
-      if orig_ctrlexpr == effective_ctrlexpr
-        ctrlexpr_val = ScalarValue.of_arbitrary
+      org_ctrlexpr = node.expression
+      if org_ctrlexpr == effective_ctrlexpr
+        ctrlexpr_val = scalar_value_of_arbitrary
         ctrlexpr = nil
       else
-        ctrlexpr_var = object_to_variable(interpret(orig_ctrlexpr))
+        ctrlexpr_var = object_to_variable(interpret(org_ctrlexpr))
         ctrlexpr_val = value_of(ctrlexpr_var)
-        notify_variable_value_referred(orig_ctrlexpr, ctrlexpr_var)
-        notify_sequence_point_reached(SequencePoint.new(orig_ctrlexpr))
-        ctrlexpr = orig_ctrlexpr.to_normalized_logical
+        notify_variable_value_referred(org_ctrlexpr, ctrlexpr_var)
+        notify_sequence_point_reached(SequencePoint.new(org_ctrlexpr))
+        ctrlexpr = org_ctrlexpr.to_normalized_logical
       end
       notify_if_else_ctrlexpr_evaled(node, ctrlexpr_val)
 
@@ -1038,7 +1066,7 @@ module C #:nodoc:
       when IfStatement, IfElseStatement
         interpret(node.else_statement)
       else
-        branched_eval(nil, NARROWING, FINAL, COMPLETE) do
+        branched_eval(nil, NARROWING, COMPLEMENTAL, FINAL, COMPLETE) do
           interpret(node.else_statement)
         end
       end
@@ -1058,26 +1086,26 @@ module C #:nodoc:
       notify_sequence_point_reached(SequencePoint.new(node.expression))
       notify_while_ctrlexpr_evaled(node, ctrlexpr_val)
 
-      orig_ctrlexpr, ctrlexpr = node.deduct_controlling_expression
+      org_ctrlexpr, ctrlexpr = node.deduct_controlling_expression
 
       case
       when ctrlexpr_val.must_be_true?
         begin
-          enter_iteration_statement(orig_ctrlexpr)
+          enter_iteration_statement(org_ctrlexpr)
           branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND, COMPLETE) do
             interpret(node.statement)
           end
         ensure
-          leave_iteration_statement(orig_ctrlexpr)
+          leave_iteration_statement(org_ctrlexpr)
         end
       when ctrlexpr_val.may_be_true?
         begin
-          enter_iteration_statement(orig_ctrlexpr)
+          enter_iteration_statement(org_ctrlexpr)
           branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND) do
             interpret(node.statement)
           end
         ensure
-          leave_iteration_statement(orig_ctrlexpr)
+          leave_iteration_statement(org_ctrlexpr)
         end
       end
     ensure
@@ -1092,15 +1120,15 @@ module C #:nodoc:
 
       widen_varying_variable_value_domain(node)
 
-      orig_ctrlexpr, ctrlexpr = node.deduct_controlling_expression
+      org_ctrlexpr, ctrlexpr = node.deduct_controlling_expression
 
       begin
-        enter_iteration_statement(orig_ctrlexpr)
+        enter_iteration_statement(org_ctrlexpr)
         branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND, COMPLETE) do
           interpret(node.statement)
         end
       ensure
-        leave_iteration_statement(orig_ctrlexpr)
+        leave_iteration_statement(org_ctrlexpr)
       end
 
       ctrlexpr_var = object_to_variable(interpret(node.expression))
@@ -1121,7 +1149,7 @@ module C #:nodoc:
       node.initial_statement.accept(self)
 
       widen_varying_variable_value_domain(node)
-      orig_ctrlexpr, ctrlexpr = node.deduct_controlling_expression
+      org_ctrlexpr, ctrlexpr = node.deduct_controlling_expression
 
       node.condition_statement.executed = true
       if explicit_ctrlexpr = node.condition_statement.expression
@@ -1131,14 +1159,14 @@ module C #:nodoc:
         notify_sequence_point_reached(SequencePoint.new(explicit_ctrlexpr))
         notify_for_ctrlexpr_evaled(node, ctrlexpr_val)
       else
-        ctrlexpr_val = ScalarValue.of_true
+        ctrlexpr_val = scalar_value_of_true
       end
 
       case
       when ctrlexpr_val.must_be_true?
-        interpret_for_body_statement(node, orig_ctrlexpr, ctrlexpr, true)
+        interpret_for_body_statement(node, org_ctrlexpr, ctrlexpr, true)
       when ctrlexpr_val.may_be_true?
-        interpret_for_body_statement(node, orig_ctrlexpr, ctrlexpr, false)
+        interpret_for_body_statement(node, org_ctrlexpr, ctrlexpr, false)
       end
     ensure
       notify_for_stmt_ended(node)
@@ -1154,7 +1182,7 @@ module C #:nodoc:
         notify_c99_for_stmt_started(node)
 
         widen_varying_variable_value_domain(node)
-        orig_ctrlexpr, ctrlexpr = node.deduct_controlling_expression
+        org_ctrlexpr, ctrlexpr = node.deduct_controlling_expression
 
         node.condition_statement.executed = true
         if explicit_ctrlexpr = node.condition_statement.expression
@@ -1164,14 +1192,14 @@ module C #:nodoc:
           notify_sequence_point_reached(SequencePoint.new(explicit_ctrlexpr))
           notify_c99_for_ctrlexpr_evaled(node, ctrlexpr_val)
         else
-          ctrlexpr_val = ScalarValue.of_true
+          ctrlexpr_val = scalar_value_of_true
         end
 
         case
         when ctrlexpr_val.must_be_true?
-          interpret_for_body_statement(node, orig_ctrlexpr, ctrlexpr, true)
+          interpret_for_body_statement(node, org_ctrlexpr, ctrlexpr, true)
         when ctrlexpr_val.may_be_true?
-          interpret_for_body_statement(node, orig_ctrlexpr, ctrlexpr, false)
+          interpret_for_body_statement(node, org_ctrlexpr, ctrlexpr, false)
         end
       end
     ensure
@@ -1218,13 +1246,12 @@ module C #:nodoc:
 
       notify_variable_value_referred(node.expression, var)
 
-      if active_func = interpreter._active_function and
-          return_type = active_func.type.return_type
-        if var.type.same_as?(return_type)
+      if active_fun = interpreter._active_function and
+          retn_type = active_fun.type.return_type
+        if var.type.same_as?(retn_type)
           conved = var
         else
-          conved = do_conversion(var, return_type) ||
-                   create_tempvar(return_type)
+          conved = do_conversion(var, retn_type) || create_tmpvar(retn_type)
           notify_implicit_conv_performed(node.expression, var, conved)
         end
       else
@@ -1237,8 +1264,8 @@ module C #:nodoc:
     end
 
     private
-    def interpret_for_body_statement(node, orig_ctrlexpr, ctrlexpr, complete)
-      enter_iteration_statement(orig_ctrlexpr)
+    def interpret_for_body_statement(node, org_ctrlexpr, ctrlexpr, complete)
+      enter_iteration_statement(org_ctrlexpr)
 
       if complete
         branch_opts = [NARROWING, FINAL, IMPLICIT_COND, COMPLETE]
@@ -1267,7 +1294,7 @@ module C #:nodoc:
         end
       end
     ensure
-      leave_iteration_statement(orig_ctrlexpr)
+      leave_iteration_statement(org_ctrlexpr)
     end
 
     def uninitialize_block_local_variables(generic_labeled_stmt)
@@ -1300,12 +1327,12 @@ module C #:nodoc:
         end
       end
 
-      varying_vars.each do |var, orig_val|
+      varying_vars.each do |var, org_val|
         case deduct_variable_varying_path(var, iteration_stmt)
         when :increase
-          var.narrow_value_domain!(Operator::GE, orig_val)
+          var.narrow_value_domain!(Operator::GE, org_val)
         when :decrease
-          var.narrow_value_domain!(Operator::LE, orig_val)
+          var.narrow_value_domain!(Operator::LE, org_val)
         end
       end
     end
@@ -1407,6 +1434,7 @@ module C #:nodoc:
       ctrlexpr = node.expression
       ctrlexpr_var = object_to_variable(interpret(ctrlexpr))
       notify_switch_ctrlexpr_evaled(node, ctrlexpr_var)
+      notify_variable_value_referred(ctrlexpr, ctrlexpr_var)
 
       execute_switch_body(ctrlexpr_var, node.statement)
       notify_switch_stmt_ended(node)
@@ -1434,34 +1462,38 @@ module C #:nodoc:
         base_opts = [SMOTHER_BREAK, IMPLICIT_COND, NARROWING]
       end
 
-      index = 0
-      while block_item = block_items[index]
-        while block_item.kind_of?(GenericLabeledStatement)
+      idx = 0
+      while block_item = block_items[idx]
+        case block_item
+        when GenericLabeledStatement
           block_item.executed = true
           notify_label_defined(block_item)
           block_item = block_item.statement
-        end
-
-        case block_item
+          redo
         when CaseLabeledStatement, DefaultLabeledStatement
-          if final_branch?(block_items, index)
+          if final_branch?(block_items, idx)
             opts = base_opts + [FINAL]
           else
             opts = base_opts.dup
           end
-          index = execute_branch(block_item, block_items, index + 1, opts)
-          break unless index
+          idx = execute_branch(block_item, block_items, idx, opts)
+          break unless idx
         else
           interpret(block_item)
-          index += 1
+          idx += 1
         end
       end
     end
 
-    def execute_branch(labeled_stmt, block_items, index, branch_opts)
+    def execute_branch(labeled_stmt, block_items, idx, branch_opts)
       ctrlexpr = labeled_stmt.normalized_expression
       ctrlexpr_val = value_of(interpret(ctrlexpr, QUIET))
 
+      case labeled_stmt
+      when DefaultLabeledStatement
+        branch_opts.push(COMPLEMENTAL)
+      end
+
       case
       when ctrlexpr_val.must_be_true?
         branch_opts.push(FINAL, COMPLETE)
@@ -1469,33 +1501,54 @@ module C #:nodoc:
         # NOTE: To end the current branch group of switch-statement if this
         #       case-clause is the final one.
         branched_eval(ctrlexpr, *branch_opts) {}
-        return seek_next_branch(block_items, index)
+        return seek_next_branch(block_items, idx)
       end
 
       branched_eval(ctrlexpr, *branch_opts) do |branch|
+        case stmt = labeled_stmt.statement
+        when CaseLabeledStatement, DefaultLabeledStatement
+          # NOTE: Consecutive label appears!
+          enter_next_clause(stmt, block_items, idx, branch, branch_opts)
+        end
         interpret(labeled_stmt)
-        while block_item = block_items[index]
-          while block_item.kind_of?(GenericLabeledStatement)
-            block_item.executed = true
-            notify_label_defined(block_item)
-            block_item = block_item.statement
-          end
-
-          case block_item
+        idx += 1
+
+        while item = block_items[idx]
+          case item
+          when GenericLabeledStatement
+            item.executed = true
+            notify_label_defined(item)
+            item = item.statement
+            redo
           when CaseLabeledStatement, DefaultLabeledStatement
             # NOTE: Fall through!
-            prepare_fall_through(branch, branch_opts, block_item)
-            branch_opts.push(FINAL) if final_branch?(block_items, index)
-            branch.add_options(*branch_opts)
+            enter_next_clause(item, block_items, idx, branch, branch_opts)
           end
-          interpret(block_item)
-          index += 1
+          interpret(item)
+          idx += 1
         end
         # NOTE: To simulate implicit breaking of the last case-clause.
         BreakEvent.of_break.throw
       end
 
-      branch_opts.include?(FINAL) ? nil : seek_next_branch(block_items, index)
+      branch_opts.include?(FINAL) ? nil : seek_next_branch(block_items, idx)
+    end
+
+    def enter_next_clause(labeled_stmt, block_items, idx, branch, branch_opts)
+      prepare_fall_through(branch, branch_opts, labeled_stmt)
+
+      case labeled_stmt
+      when DefaultLabeledStatement
+        branch_opts.push(COMPLEMENTAL)
+      end
+
+      branch_opts.push(FINAL) if final_branch?(block_items, idx)
+      branch.add_options(*branch_opts)
+
+      case stmt = labeled_stmt.statement
+      when CaseLabeledStatement, DefaultLabeledStatement
+        enter_next_clause(stmt, block_items, idx, branch, branch_opts)
+      end
     end
 
     def prepare_fall_through(branch, branch_opts, labeled_stmt)
@@ -1519,55 +1572,51 @@ module C #:nodoc:
       value_domain_manip.commit!
     end
 
-    def final_branch?(block_items, index)
-      index += 1
-      while block_item = block_items[index]
-        while block_item.kind_of?(GenericLabeledStatement)
-          block_item = block_item.statement
-        end
-
+    def final_branch?(block_items, idx)
+      idx += 1
+      while block_item = block_items[idx]
         case block_item
+        when GenericLabeledStatement
+          block_item = block_item.statement
+          redo
         when CaseLabeledStatement, DefaultLabeledStatement
           return false
         else
-          index += 1
+          idx += 1
         end
       end
       true
     end
 
     def complete?(block_items)
-      index = 0
-      while block_item = block_items[index]
-        while block_item.kind_of?(GenericLabeledStatement)
-          block_item = block_item.statement
-        end
-
+      block_items.any? do |block_item|
         case block_item
+        when GenericLabeledStatement, CaseLabeledStatement
+          block_item = block_item.statement
+          redo
         when DefaultLabeledStatement
-          return true
+          true
         else
-          index += 1
+          false
         end
       end
-      false
     end
 
-    def seek_next_branch(block_items, index)
-      while block_item = block_items[index]
-        while block_item.kind_of?(GenericLabeledStatement)
+    def seek_next_branch(block_items, idx)
+      idx += 1
+      while block_item = block_items[idx]
+        case block_item
+        when GenericLabeledStatement
           notify_label_defined(block_item)
           block_item = block_item.statement
-        end
-
-        case block_item
+          redo
         when CaseLabeledStatement, DefaultLabeledStatement
-          break
+          return idx
         else
-          index += 1
+          idx += 1
         end
       end
-      index
+      nil
     end
   end
 
@@ -1660,8 +1709,8 @@ module C #:nodoc:
 
       case
       when then_var && else_var
-        result_val = then_var.value.single_value_unified_with(else_var.value)
-        result_var = create_tempvar(then_var.type, result_val)
+        res_val = then_var.value.single_value_unified_with(else_var.value)
+        res_var = create_tmpvar(then_var.type, res_val)
         # FIXME: Not to over-warn about discarding a function return value.
         #        Because the unified result is a new temporary variable, it is
         #        impossible to relate a reference of the unified result and a
@@ -1669,17 +1718,17 @@ module C #:nodoc:
         notify_variable_value_referred(node, then_var)
         notify_variable_value_referred(node, else_var)
       when then_var
-        result_var = then_var
+        res_var = then_var
       when else_var
-        result_var = else_var
+        res_var = else_var
       else
         # FIXME: Nevertheless, the then-expression is not reachable, the branch
         #        execution check may fail in evaluation of the else branch.
-        result_var = create_tempvar
+        res_var = create_tmpvar
       end
 
-      notify_conditional_expr_evaled(node, ctrlexpr_var, result_var)
-      result_var
+      notify_conditional_expr_evaled(node, ctrlexpr_var, res_var)
+      res_var
     ensure
       if seqp = node.subsequent_sequence_point
         notify_sequence_point_reached(seqp)