adlint 2.6.0 → 2.6.2

data/lib/adlint/c/interp.rb

@@ -44,9 +44,9 @@ module AdLint #:nodoc:
 module C #:nodoc:
 
   class Program
-    def initialize(interpreter, translation_unit)
-      @interpreter = interpreter
-      @translation_unit = translation_unit
+    def initialize(interp, trans_unit)
+      @interpreter = interp
+      @translation_unit = trans_unit
     end
 
     def execute
@@ -56,8 +56,8 @@ module C #:nodoc:
     end
 
     class ExecutionDriver < SyntaxTreeVisitor
-      def initialize(interpreter)
-        @interpreter = interpreter
+      def initialize(interp)
+        @interpreter = interp
       end
 
       def visit_declaration(node) @interpreter.execute(node) end
@@ -112,308 +112,276 @@ module C #:nodoc:
     private_class_method :def_plugin_and_notifier
 
     # NOTE: Notified when the interpreter evaluates a variable-declaration.
-    def_plugin_and_notifier :variable_declared,
-                            :variable_declaration, :variable
+    def_plugin_and_notifier :variable_declared, :var_dcl, :var
 
     # NOTE: Notified when the interpreter evaluates a variable-definition.
-    def_plugin_and_notifier :variable_defined, :variable_definition, :variable
+    def_plugin_and_notifier :variable_defined, :var_def, :var
 
     # NOTE: Notified when the interpreter evaluates an initializer of
     #       variable-definition.
-    def_plugin_and_notifier :variable_initialized,
-                            :variable_definition, :variable, :init_variable
+    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,
-                            :function_declaration, :function
+    def_plugin_and_notifier :function_declared, :func_dcl, :func
 
     # NOTE: Notified when the interpreter evaluates a function-definition.
-    def_plugin_and_notifier :function_defined, :function_definition, :function
+    def_plugin_and_notifier :function_defined, :func_def, :func
 
     # NOTE: Notified when the interpreter evaluates a struct-type-declaration.
-    def_plugin_and_notifier :struct_declared, :struct_type_declaration
+    def_plugin_and_notifier :struct_declared, :struct_type_dcl
 
     # NOTE: Notified when the interpreter evaluates a union-type-declaration.
-    def_plugin_and_notifier :union_declared, :union_type_declaration
+    def_plugin_and_notifier :union_declared, :union_type_dcl
 
     # NOTE: Notified when the interpreter evaluates a enum-type-declaration.
-    def_plugin_and_notifier :enum_declared, :enum_type_declaration
+    def_plugin_and_notifier :enum_declared, :enum_type_dcl
 
     # NOTE: Notified when the interpreter evaluates a typedef-declaration.
-    def_plugin_and_notifier :typedef_declared, :typedef_declaration
+    def_plugin_and_notifier :typedef_declared, :typedef_dcl
 
     # NOTE: Notified when the interpreter starts execution of a
     #       function-definition.
-    def_plugin_and_notifier :function_started, :function_definition, :function
+    def_plugin_and_notifier :function_started, :func_def, :func
 
     # NOTE: Notified when the interpreter ends execution of a
     #       function-definition.
-    def_plugin_and_notifier :function_ended, :function_definition, :function
+    def_plugin_and_notifier :function_ended, :func_def, :func
 
     # NOTE: Notified when the interpreter evaluates a parameter-definition at
     #       beginning of execution of a function-definition.
-    def_plugin_and_notifier :parameter_defined,
-                            :parameter_definition, :variable
+    def_plugin_and_notifier :parameter_defined, :param_def, :var
 
     # NOTE: Notified when the interpreter evaluates an expression which results
     #       a named variable.
-    def_plugin_and_notifier :variable_referred, :expression, :variable
+    def_plugin_and_notifier :variable_referred, :expr, :var
 
     # NOTE: Notified when the interpreter evaluates an expression which results
     #       a constant temporary variable.
-    def_plugin_and_notifier :constant_referred, :constant_specifier, :variable
+    def_plugin_and_notifier :constant_referred, :const_spec, :var
 
     # NOTE: Notified when the interpreter refers to a value of a variable while
     #       evaluating an expression.
-    def_plugin_and_notifier :variable_value_referred, :expression, :variable
+    def_plugin_and_notifier :variable_value_referred, :expr, :var
 
     # NOTE: Notified when the interpreter overwrites a value of a variable
     #       while evaluating an expression.
-    def_plugin_and_notifier :variable_value_updated, :expression, :variable
+    def_plugin_and_notifier :variable_value_updated, :expr, :var
 
     # NOTE: Notified when the interpreter refers to a function object while
     #       evaluating an expression.
-    def_plugin_and_notifier :function_referred, :expression, :function
+    def_plugin_and_notifier :function_referred, :expr, :func
 
     # NOTE: Notified when the interpreter evaluates a sizeof-expression.
     def_plugin_and_notifier :sizeof_expr_evaled,
-                            :expression, :operand_variable, :result_variable
+                            :expr, :operand_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates a sizeof-type-expression.
-    def_plugin_and_notifier :sizeof_type_expr_evaled,
-                            :expression, :type, :result_variable
+    def_plugin_and_notifier :sizeof_type_expr_evaled, :expr, :type, :result_var
 
     # NOTE: Notified when the interpreter evaluates a cast-expression.
     def_plugin_and_notifier :explicit_conv_performed,
-                            :expression, :original_variable, :result_variable
+                            :expr, :orig_var, :result_var
 
     # NOTE: Notified when the interpreter performs an implicit type conversion
     #       while evaluating an expression.
     def_plugin_and_notifier :implicit_conv_performed,
-                            :initializer_or_expression, :original_variable,
-                            :result_variable
+                            :init_or_expr, :orig_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates an
     #       array-subscript-expression.
     def_plugin_and_notifier :array_subscript_expr_evaled,
-                            :array_subscript_expression,
-                            :array_or_pointer_variable, :subscript_variable,
-                            :array_variable, :result_variable
+                            :expr, :ary_or_ptr, :subs, :ary_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates a function-call-expression.
     def_plugin_and_notifier :function_call_expr_evaled,
-                            :function_call_expression, :function,
-                            :arg_variables, :result_variable
+                            :expr, :func, :arg_vars, :result_var
 
     # NOTE: Notified when the interpreter evaluates an
     #       unary-arithmetic-expression.
     def_plugin_and_notifier :unary_arithmetic_expr_evaled,
-                            :unary_arithmetic_expression, :operand_variable,
-                            :result_variable
+                            :expr, :operand_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates a
     #       multiplicative-expression.
     def_plugin_and_notifier :multiplicative_expr_evaled,
-                            :multiplicative_expression, :lhs_variable,
-                            :rhs_variable, :result_variable
+                            :expr, :lhs_var, :rhs_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates an additive-expression.
     def_plugin_and_notifier :additive_expr_evaled,
-                            :additive_expression, :lhs_variable, :rhs_variable,
-                            :result_variable
+                            :expr, :lhs_var, :rhs_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates a shift-expression.
     def_plugin_and_notifier :shift_expr_evaled,
-                            :shift_expression, :lhs_variable, :rhs_variable,
-                            :result_variable
+                            :expr, :lhs_var, :rhs_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates a relational-expression.
     def_plugin_and_notifier :relational_expr_evaled,
-                            :relational_expression, :lhs_variable,
-                            :rhs_variable, :result_variable
+                            :expr, :lhs_var, :rhs_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates an equality-expression.
     def_plugin_and_notifier :equality_expr_evaled,
-                            :equality_expression, :lhs_variable, :rhs_variable,
-                            :result_variable
+                            :expr, :lhs_var, :rhs_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates a bitwise and-expression.
     def_plugin_and_notifier :and_expr_evaled,
-                            :and_expression, :lhs_variable, :rhs_variable,
-                            :result_variable
+                            :expr, :lhs_var, :rhs_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates an exclusive-or-expression.
     def_plugin_and_notifier :exclusive_or_expr_evaled,
-                            :exclusive_or_expression, :lhs_variable,
-                            :rhs_variable, :result_variable
+                            :expr, :lhs_var, :rhs_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates a bitwise
     #       inclusive-or-expression.
     def_plugin_and_notifier :inclusive_or_expr_evaled,
-                            :inclusive_or_expression, :lhs_variable,
-                            :rhs_variable, :result_variable
+                            :expr, :lhs_var, :rhs_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates a logical-and-expression.
     def_plugin_and_notifier :logical_and_expr_evaled,
-                            :logical_and_expression, :lhs_variable,
-                            :rhs_variable, :result_variable
+                            :expr, :lhs_var, :rhs_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates a logical-or-expression.
     def_plugin_and_notifier :logical_or_expr_evaled,
-                            :logical_or_expression, :lhs_variable,
-                            :rhs_variable, :result_variable
+                            :expr, :lhs_var, :rhs_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates a conditional-expression.
     def_plugin_and_notifier :conditional_expr_evaled,
-                            :conditional_expression, :controlling_variable,
-                            :result_variable
+                            :expr, :ctrlexpr_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates an address-expression.
-    def_plugin_and_notifier :address_expr_evaled,
-                            :address_expression, :object, :pointer_variable
+    def_plugin_and_notifier :address_expr_evaled, :expr, :obj, :ptr_var
 
     # NOTE: Notified when the interpreter evaluates an indirection-expression.
     def_plugin_and_notifier :indirection_expr_evaled,
-                            :indirection_expression, :pointer_variable,
-                            :dereferenced_variable
+                            :expr, :ptr_var, :derefed_var
 
     # NOTE: Notified when the interpreter evaluates a
     #       member-access-by-value-expression or a
     #       member-access-by-pointer-expression.
     def_plugin_and_notifier :member_access_expr_evaled,
-                            :member_access_expression, :outer_variable,
-                            :member_variable
+                            :expr, :outer_var, :inner_var
 
     # NOTE: Notified when the interpreter evaluates a
     #       prefix-increment-expression.
     def_plugin_and_notifier :prefix_increment_expr_evaled,
-                            :prefix_increment_expression, :operand_variable,
-                            :original_value
+                            :expr, :operand_var, :orig_val
 
     # NOTE: Notified when the interpreter evaluates a
     #       postfix-increment-expression.
     def_plugin_and_notifier :postfix_increment_expr_evaled,
-                            :postfix_increment_expression, :operand_variable,
-                            :result_variable
+                            :expr, :operand_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates a
     #       prefix-decrement-expression.
     def_plugin_and_notifier :prefix_decrement_expr_evaled,
-                            :prefix_decrement_expression, :operand_variable,
-                            :original_value
+                            :expr, :operand_var, :orig_val
 
     # NOTE: Notified when the interpreter evaluates a
     #       postfix-decrement-expression.
     def_plugin_and_notifier :postfix_decrement_expr_evaled,
-                            :postfix_decrement_expression, :operand_variable,
-                            :result_variable
+                            :expr, :operand_var, :result_var
 
     # NOTE: Notified when the interpreter evaluates a
     #       simple-assignment-expression or a compound-assignment-expression.
-    def_plugin_and_notifier :assignment_expr_evaled,
-                            :assignment_expression, :lhs_variable,
-                            :rhs_variable
+    def_plugin_and_notifier :assignment_expr_evaled, :expr, :lhs_var, :rhs_var
 
     # NOTE: Notified when the interpreter starts execution of a
     #       expression-statement.
-    def_plugin_and_notifier :expression_stmt_started, :expression_statement
+    def_plugin_and_notifier :expression_stmt_started, :stmt
 
     # NOTE: Notified when the interpreter ends execution of a
     #       expression-statement.
-    def_plugin_and_notifier :expression_stmt_ended, :expression_statement
+    def_plugin_and_notifier :expression_stmt_ended, :stmt
 
     # NOTE: Notified when the interpreter starts execution of a
     #       switch-statement.
-    def_plugin_and_notifier :switch_stmt_started, :switch_statement
+    def_plugin_and_notifier :switch_stmt_started, :stmt
 
     # NOTE: Notified when the interpreter ends execution of a switch-statement.
-    def_plugin_and_notifier :switch_stmt_ended, :switch_statement
+    def_plugin_and_notifier :switch_stmt_ended, :stmt
 
     # NOTE: Notified when the interpreter starts execution of a
     #       while-statement.
-    def_plugin_and_notifier :while_stmt_started, :while_statement
+    def_plugin_and_notifier :while_stmt_started, :stmt
 
     # NOTE: Notified when the interpreter ends execution of a while-statement.
-    def_plugin_and_notifier :while_stmt_ended, :while_statement
+    def_plugin_and_notifier :while_stmt_ended, :stmt
 
     # NOTE: Notified when the interpreter starts execution of a do-statement.
-    def_plugin_and_notifier :do_stmt_started, :do_statement
+    def_plugin_and_notifier :do_stmt_started, :stmt
 
     # NOTE: Notified when the interpreter ends execution of a do-statement.
-    def_plugin_and_notifier :do_stmt_ended, :do_statement
+    def_plugin_and_notifier :do_stmt_ended, :stmt
 
     # NOTE: Notified when the interpreter starts execution of a for-statement.
-    def_plugin_and_notifier :for_stmt_started, :for_statement
+    def_plugin_and_notifier :for_stmt_started, :stmt
 
     # NOTE: Notified when the interpreter ends execution of a for-statement.
-    def_plugin_and_notifier :for_stmt_ended, :for_statement
+    def_plugin_and_notifier :for_stmt_ended, :stmt
 
     # NOTE: Notified when the interpreter starts execution of a
     #       c99-for-statement.
-    def_plugin_and_notifier :c99_for_stmt_started, :c99_for_statement
+    def_plugin_and_notifier :c99_for_stmt_started, :stmt
 
     # NOTE: Notified when the interpreter ends execution of a
     #       c99-for-statement.
-    def_plugin_and_notifier :c99_for_stmt_ended, :c99_for_statement
+    def_plugin_and_notifier :c99_for_stmt_ended, :stmt
 
     # NOTE: Notified when the interpreter evaluates a goto-statement.
-    def_plugin_and_notifier :goto_stmt_evaled, :goto_statement, :label_name
+    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,
-                            :return_statement, :result_variable
+    def_plugin_and_notifier :return_stmt_evaled, :stmt, :result_var
 
     # NOTE: Notified when the interpreter evaluates an implicit return.
     def_plugin_and_notifier :implicit_return_evaled
 
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the if-statement.
-    def_plugin_and_notifier :if_ctrlexpr_evaled, :if_statement, :ctrlexpr_value
+    def_plugin_and_notifier :if_ctrlexpr_evaled, :if_stmt, :ctrlexpr_val
 
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the if-else-statement.
     def_plugin_and_notifier :if_else_ctrlexpr_evaled,
-                            :if_else_statement, :ctrlexpr_value
+                            :if_else_stmt, :ctrlexpr_val
 
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the switch-statement.
     def_plugin_and_notifier :switch_ctrlexpr_evaled,
-                            :switch_statement, :ctrlexpr_result
+                            :switch_stmt, :ctrlexpr_var
 
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the case-labeled-statement.
     def_plugin_and_notifier :case_ctrlexpr_evaled,
-                            :case_labeled_statement, :ctrlexpr_result
+                            :case_labeled_stmt, :ctrlexpr_var
 
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the while-statement.
     def_plugin_and_notifier :while_ctrlexpr_evaled,
-                            :while_statement, :ctrlexpr_value
+                            :while_statement, :ctrlexpr_val
 
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the do-statement.
-    def_plugin_and_notifier :do_ctrlexpr_evaled, :do_statement, :ctrlexpr_value
+    def_plugin_and_notifier :do_ctrlexpr_evaled, :do_stmt, :ctrlexpr_val
 
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the for-statement.
-    def_plugin_and_notifier :for_ctrlexpr_evaled,
-                            :for_statement, :ctrlexpr_value
+    def_plugin_and_notifier :for_ctrlexpr_evaled, :for_stmt, :ctrlexpr_val
 
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the c99-for-statement.
     def_plugin_and_notifier :c99_for_ctrlexpr_evaled,
-                            :c99_for_statement, :ctrlexpr_value
+                            :c99_for_stmt, :ctrlexpr_val
 
     # NOTE: Notified when the interpreter defines a generic-label.
-    def_plugin_and_notifier :label_defined, :generic_labeled_statement
+    def_plugin_and_notifier :label_defined, :generic_labeled_stmt
 
     # NOTE: Notified when the interpreter starts execution of a
     #       compound-statement.
-    def_plugin_and_notifier :block_started, :compound_statement
+    def_plugin_and_notifier :block_started, :compound_stmt
 
     # NOTE: Notified when the interpreter ends execution of a
     #       compound-statement.
-    def_plugin_and_notifier :block_ended, :compound_statement
+    def_plugin_and_notifier :block_ended, :compound_stmt
 
     # NOTE: Notified when the interpreter forks execution paths of a
     #       function-definition.
@@ -425,16 +393,16 @@ module C #:nodoc:
 
     # NOTE: Notified when the interpreter starts execution of a
     #       translation-unit.
-    def_plugin_and_notifier :translation_unit_started, :translation_unit
+    def_plugin_and_notifier :translation_unit_started, :trans_unit
 
     # NOTE: Notified when the interpreter ends execution of a translation-unit.
-    def_plugin_and_notifier :translation_unit_ended, :translation_unit
+    def_plugin_and_notifier :translation_unit_ended, :trans_unit
 
     # NOTE: Notified when the control reaches to a sequence-point.
-    def_plugin_and_notifier :sequence_point_reached, :sequence_point
+    def_plugin_and_notifier :sequence_point_reached, :seqp
 
-    def execute(node, *options)
-      @options_stack.push(current_options + options)
+    def execute(node, *opts)
+      @options_stack.push(current_options + opts)
       if quiet_without_side_effect?
         result = nil
         branched_eval(nil, FINAL) do
@@ -450,28 +418,27 @@ module C #:nodoc:
       @options_stack.pop
     end
 
-    def object_to_variable(object)
+    def object_to_variable(obj)
       case
-      when object.function?
-        temporary_variable(pointer_type(object.type), pointer_value_of(object))
-      when object.type.array?
-        temporary_variable(pointer_type(object.type.base_type),
-                           pointer_value_of(object))
+      when obj.function?
+        create_tempvar(pointer_type(obj.type), pointer_value_of(obj))
+      when obj.type.array?
+        create_tempvar(pointer_type(obj.type.base_type), pointer_value_of(obj))
       else
-        object
+        obj
       end
     end
 
-    def value_of(object)
-      if object.type.array? || object.type.function?
-        pointer_value_of(object)
+    def value_of(obj)
+      if obj.type.array? || obj.type.function?
+        pointer_value_of(obj)
       else
-        object.value.to_single_value
+        obj.value.to_single_value
       end
     end
 
-    def pointer_value_of(object)
-      ScalarValue.of(object.binding.memory.address)
+    def pointer_value_of(obj)
+      ScalarValue.of(obj.binding.memory.address)
     end
 
     def quiet?
@@ -509,12 +476,12 @@ module C #:nodoc:
       @active_function_stack.last
     end
 
-    def _enter_function(function_definition)
+    def _enter_function(func_def)
       # NOTE: This method is called only from FunctionInterpreter.
-      @active_function_stack.push(function_definition)
+      @active_function_stack.push(func_def)
     end
 
-    def _leave_function(function_definition)
+    def _leave_function(*)
       # NOTE: This method is called only from FunctionInterpreter.
       @active_function_stack.pop
     end
@@ -566,15 +533,12 @@ module C #:nodoc:
       checkpoint(node.location)
 
       resolve_unresolved_type(node)
-
-      node.type.declarations.each do |decl|
-        decl.mark_as_referred_by(node.identifier)
+      node.type.declarations.each do |dcl|
+        dcl.mark_as_referred_by(node.identifier)
       end
 
-      function = declare_function(node)
-
-      notify_function_declared(node, function)
-
+      func = declare_function(node)
+      notify_function_declared(node, func)
       evaluate_sequence_point(node.init_declarator.declarator)
     end
 
@@ -582,14 +546,12 @@ module C #:nodoc:
       checkpoint(node.location)
 
       resolve_unresolved_type(node)
-
-      node.type.declarations.each do |decl|
-        decl.mark_as_referred_by(node.identifier)
+      node.type.declarations.each do |dcl|
+        dcl.mark_as_referred_by(node.identifier)
       end
 
-      variable = declare_variable(node)
-      notify_variable_declared(node, variable)
-
+      var = declare_variable(node)
+      notify_variable_declared(node, var)
       evaluate_sequence_point(node.declarator)
     end
 
@@ -597,18 +559,16 @@ module C #:nodoc:
       checkpoint(node.location)
 
       resolve_unresolved_type(node)
-
-      node.type.declarations.each do |decl|
-        decl.mark_as_referred_by(node.identifier)
+      node.type.declarations.each do |dcl|
+        dcl.mark_as_referred_by(node.identifier)
       end
 
       if node.initializer
-        init_var, converted = evaluate_initializer(node)
-        variable = define_variable(node, converted.value.to_defined_value)
-
+        init_var, init_conved = evaluate_initializer(node)
+        var = define_variable(node, init_conved.value.to_defined_value)
         notify_variable_value_referred(node, init_var)
-        notify_variable_defined(node, variable)
-        notify_variable_initialized(node, variable, init_var)
+        notify_variable_defined(node, var)
+        notify_variable_initialized(node, var, init_var)
       else
         notify_variable_defined(node, define_variable(node))
       end
@@ -620,7 +580,6 @@ module C #:nodoc:
       checkpoint(node.location)
 
       resolve_unresolved_type(node)
-
       notify_struct_declared(node)
     end
 
@@ -628,25 +587,24 @@ module C #:nodoc:
       checkpoint(node.location)
 
       resolve_unresolved_type(node)
-
       notify_union_declared(node)
     end
 
     def visit_enum_type_declaration(node)
       checkpoint(node)
 
-      if enumerators = node.enum_specifier.enumerators
-        sequence = 0
-        enumerators.each do |enumerator|
-          if expression = enumerator.expression
-            object = interpret(expression)
-            if object.variable? && object.value.scalar?
-              enumerator.value = object.value.unique_sample
+      if enums = node.enum_specifier.enumerators
+        seq = 0
+        enums.each do |enum|
+          if expr = enum.expression
+            obj = interpret(expr)
+            if obj.variable? && obj.value.scalar?
+              enum.value = obj.value.unique_sample
             end
           end
-          enumerator.value ||= sequence
-          define_enumerator(enumerator)
-          sequence = enumerator.value + 1
+          enum.value ||= seq
+          define_enumerator(enum)
+          seq = enum.value + 1
         end
       end
 
@@ -657,13 +615,11 @@ module C #:nodoc:
       checkpoint(node.location)
 
       resolve_unresolved_type(node)
-
-      node.type.real_type.declarations.each do |decl|
-        decl.mark_as_referred_by(node.identifier)
+      node.type.real_type.declarations.each do |dcl|
+        dcl.mark_as_referred_by(node.identifier)
       end
 
       notify_typedef_declared(node)
-
       evaluate_sequence_point(node.init_declarator.declarator)
 
       Analyzer.current.info("user type `#{node.identifier.value}' " +
@@ -671,38 +627,38 @@ module C #:nodoc:
     end
 
     private
-    def evaluate_initializer(definition)
+    def evaluate_initializer(var_def)
       init_interp = InitializerInterpreter.new(interpreter)
-      variable, converted = init_interp.execute(definition)
+      var, conved = init_interp.execute(var_def)
 
       # NOTE: An implicit conversion and size deduction of an incomplete array
       #       have been done by InitializerInterpreter.
 
       # NOTE: For the case of array variable definition with a
       #       string-literal-specifier as the initializer.
-      if definition.type.array? && variable.type.pointer?
-        unless array = pointee_of(variable) and array.type.array?
-          array = temporary_variable(definition.type)
+      if var_def.type.array? && var.type.pointer?
+        unless ary = pointee_of(var) and ary.type.array?
+          ary = create_tempvar(var_def.type)
         end
-        deduct_array_length_from_array_variable(definition, array)
-        variable = converted = array
+        deduct_array_length_from_array_variable(var_def, ary)
+        var = conved = ary
       end
 
-      return variable, converted
+      return var, conved
     end
 
-    def deduct_array_length_from_array_variable(definition, array)
-      unless definition.type.length
-        if definition.type.user?
-          definition.type = definition.type.dup
+    def deduct_array_length_from_array_variable(var_def, ary)
+      unless var_def.type.length
+        if var_def.type.user?
+          var_def.type = var_def.type.dup
         end
-        definition.type.length = array.type.length
+        var_def.type.length = ary.type.length
       end
     end
 
-    def evaluate_sequence_point(full_declarator)
-      if sequence_point = full_declarator.subsequent_sequence_point
-        notify_sequence_point_reached(sequence_point)
+    def evaluate_sequence_point(full_dcl)
+      if seqp = full_dcl.subsequent_sequence_point
+        notify_sequence_point_reached(seqp)
       end
     end
   end
@@ -713,70 +669,63 @@ module C #:nodoc:
     include Conversion
     include MonitorUtil
 
-    def initialize(interpreter)
-      @interpreter = interpreter
+    def initialize(interp)
+      @interpreter = interp
     end
 
-    def execute(definition)
-      checkpoint(definition.initializer.location)
+    def execute(var_def)
+      checkpoint(var_def.initializer.location)
 
       case
-      when expression = definition.initializer.expression
+      when expr = var_def.initializer.expression
         # NOTE: An implicit conversion is already notified in
         #       #evaluate_expression.
-        return evaluate_expression(expression, definition.type)
-      when initializers = definition.initializer.initializers
-        variable = evaluate_initializers(initializers, definition.type)
+        return evaluate_expression(expr, var_def.type)
+      when inits = var_def.initializer.initializers
+        var = evaluate_initializers(inits, var_def.type)
 
         # NOTE: Size deduction of an incomplete array type have been done by
         #       #evaluate_initializers.
-        if definition.type.array? && variable.type.array?
-          definition.type = variable.type unless definition.type.length
+        if var_def.type.array? && var.type.array?
+          var_def.type = var.type unless var_def.type.length
         end
 
-        if variable.type.same_as?(definition.type)
-          converted = variable
+        if var.type.same_as?(var_def.type)
+          conved = var
         else
-          converted =
-            do_conversion(variable, definition.type) ||
-            temporary_variable(definition.type)
-          notify_implicit_conv_performed(initializer, variable, converted)
+          conved = do_conversion(var, var_def.type) ||
+                   create_tempvar(var_def.type)
+          notify_implicit_conv_performed(inits, var, conved)
         end
       else
-        variable = converted = temporary_variable(definition.type)
+        var = conved = create_tempvar(var_def.type)
       end
 
-      return variable, converted
+      return var, conved
     end
 
     private
-    def evaluate_expression(expression, type)
-      checkpoint(expression.location)
-
-      object = interpret(expression)
+    def evaluate_expression(expr, type)
+      checkpoint(expr.location)
 
-      variable = object_to_variable(object)
-      unless variable == object
-        notify_implicit_conv_performed(expression, object, variable)
-      end
+      obj = interpret(expr)
+      var = object_to_variable(obj)
+      notify_implicit_conv_performed(expr, obj, var) unless var == obj
 
-      if variable.type.same_as?(type)
-        converted = variable
+      if var.type.same_as?(type)
+        conved = var
       else
-        converted = do_conversion(variable, type) || temporary_variable(type)
-        notify_implicit_conv_performed(expression, variable, converted)
+        conved = do_conversion(var, type) || create_tempvar(type)
+        notify_implicit_conv_performed(expr, var, conved)
       end
 
-      return variable, converted
+      return var, conved
     end
 
-    def evaluate_initializers(initializers, type)
-      if type.union?
-      end
-
+    def evaluate_initializers(inits, type)
       case
       when type.union?
-        # NOTE: The ISO C99 standard saids;
+        # NOTE: The ISO C99 standard says;
         #
         # 6.7.8 Initialization
         #
@@ -793,14 +742,14 @@ module C #:nodoc:
         #       (recursively) according to these rules;
         #    -- if it is a union, the first named member is initialized
         #       (recursively) according to these rules.
-        if first_member = type.members.first
-          first_object = evaluate_initializers(initializers, first_member.type)
-          return temporary_variable(type, value_of(first_object))
+        if fst_memb = type.members.first
+          fst_obj = evaluate_initializers(inits, fst_memb.type)
+          return create_tempvar(type, value_of(fst_obj))
         else
-          return temporary_variable(type)
+          return create_tempvar(type)
         end
       when type.array?
-        # NOTE: The ISO C99 standard saids;
+        # NOTE: The ISO C99 standard says;
         #
         # 6.7.2.1 Structure and union specifiers
         #
@@ -819,22 +768,22 @@ module C #:nodoc:
         #       deducted in initialization.  It is treated as a pointer.
         #
         # NOTE: ISO C90 does not support flexible array members.
-        type = deduct_array_length_from_initializers(type, initializers)
-        member_types = [type.unqualify.base_type] * type.impl_length
+        type = deduct_array_length_from_initializers(type, inits)
+        memb_types = [type.unqualify.base_type] * type.impl_length
       when type.struct?
-        member_types = type.members.map { |member| member.type }
+        memb_types = type.members.map { |memb| memb.type }
       else
-        member_types = [type]
+        memb_types = [type]
       end
 
-      values = member_types.zip(initializers).map { |memb_type, initializer|
-        if initializer
-          checkpoint(initializer.location)
+      vals = memb_types.zip(inits).map { |memb_type, init|
+        if init
+          checkpoint(init.location)
           case
-          when expression = initializer.expression
-            value_of(evaluate_expression(expression, memb_type).last)
-          when initializers = initializer.initializers
-            value_of(evaluate_initializers(initializers, memb_type))
+          when expr = init.expression
+            value_of(evaluate_expression(expr, memb_type).last)
+          when inits = init.initializers
+            value_of(evaluate_initializers(inits, memb_type))
           else
             memb_type.undefined_value
           end
@@ -845,22 +794,22 @@ module C #:nodoc:
 
       case
       when type.array?
-        temporary_variable(type, ArrayValue.new(values))
+        create_tempvar(type, ArrayValue.new(vals))
       when type.composite?
-        temporary_variable(type, CompositeValue.new(values))
+        create_tempvar(type, CompositeValue.new(vals))
       else
-        temporary_variable(type, values.first)
+        create_tempvar(type, vals.first)
       end
     end
 
-    def deduct_array_length_from_initializers(orig_array_type, initializers)
-      unless orig_array_type.length
-        if orig_array_type.user?
-          orig_array_type = orig_array_type.dup
+    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
         end
-        orig_array_type.length = initializers.size
+        orig_ary_type.length = inits.size
       end
-      orig_array_type
+      orig_ary_type
     end
 
     def interpreter
@@ -880,19 +829,18 @@ module C #:nodoc:
       checkpoint(node.location)
 
       resolve_unresolved_type(node)
-
-      node.type.declarations.each do |decl|
+      node.type.declarations.each do |dcl|
         if identifier = node.identifier
-          decl.mark_as_referred_by(identifier)
+          dcl.mark_as_referred_by(identifier)
         else
-          decl.mark_as_referred_by(node.head_token)
+          dcl.mark_as_referred_by(node.head_token)
         end
       end
 
       if node.identifier
-        variable = define_variable(node.to_variable_definition,
-                                   node.type.parameter_value)
-        notify_parameter_defined(node, variable)
+        var = define_variable(node.to_variable_definition,
+                              node.type.parameter_value)
+        notify_parameter_defined(node, var)
       end
     end
   end
@@ -916,16 +864,16 @@ module C #:nodoc:
 
       reset_environment
       resolve_unresolved_type(node)
-      function = lookup_or_define_function(node)
-      notify_function_defined(node, function)
+      func = lookup_or_define_function(node)
+      notify_function_defined(node, func)
 
       begin
         interpreter._enter_function(node)
         scoped_eval do
-          notify_function_started(node, function)
+          notify_function_started(node, func)
           notify_block_started(node.function_body)
 
-          node.parameter_definitions.each { |pdef| interpret(pdef) }
+          node.parameter_definitions.each { |param_def| interpret(param_def) }
 
           BreakEvent.catch do
             node.function_body.block_items.each { |item| interpret(item) }
@@ -933,27 +881,27 @@ module C #:nodoc:
           end
 
           notify_block_ended(node.function_body)
-          notify_function_ended(node, function)
+          notify_function_ended(node, func)
         end
       ensure
         interpreter._leave_function(node)
       end
     end
 
-    def lookup_or_define_function(function_definition)
-      function_definition.type.declarations.each do |decl|
-        decl.mark_as_referred_by(function_definition.identifier)
+    def lookup_or_define_function(func_def)
+      func_def.type.declarations.each do |dcl|
+        dcl.mark_as_referred_by(func_def.identifier)
       end
 
-      if function = function_named(function_definition.identifier.value)
-        function.declarations_and_definitions.each do |decl_or_def|
-          decl_or_def.mark_as_referred_by(function_definition.identifier)
+      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)
         end
-        function.declarations_and_definitions.push(function_definition)
+        func.declarations_and_definitions.push(func_def)
       else
-        function = define_explicit_function(function_definition)
+        func = define_explicit_function(func_def)
       end
-      function
+      func
     end
   end
 
@@ -985,8 +933,8 @@ module C #:nodoc:
 
       node.executed = true
       ctrlexpr = node.expression
-      ctrlexpr_result = object_to_variable(interpret(ctrlexpr, QUIET))
-      notify_case_ctrlexpr_evaled(node, ctrlexpr_result)
+      ctrlexpr_var = object_to_variable(interpret(ctrlexpr, QUIET))
+      notify_case_ctrlexpr_evaled(node, ctrlexpr_var)
 
       interpret(node.statement)
     end
@@ -1005,7 +953,7 @@ module C #:nodoc:
       scoped_eval do
         begin
           notify_block_started(node)
-          node.block_items.each { |block_item| interpret(block_item) }
+          node.block_items.each { |item| interpret(item) }
         ensure
           notify_block_ended(node)
         end
@@ -1030,20 +978,20 @@ module C #:nodoc:
 
       orig_ctrlexpr = node.expression
       if orig_ctrlexpr == effective_ctrlexpr
-        ctrlexpr_value = ScalarValue.of_arbitrary
+        ctrlexpr_val = ScalarValue.of_arbitrary
         ctrlexpr = nil
       else
-        ctrlexpr_value = value_of(interpret(orig_ctrlexpr))
+        ctrlexpr_val = value_of(interpret(orig_ctrlexpr))
         ctrlexpr = orig_ctrlexpr.to_normalized_logical
       end
-      notify_if_ctrlexpr_evaled(node, ctrlexpr_value)
+      notify_if_ctrlexpr_evaled(node, ctrlexpr_val)
 
       case
-      when ctrlexpr_value.must_be_true?
+      when ctrlexpr_val.must_be_true?
         branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND, COMPLETE) do
           interpret(node.statement)
         end
-      when ctrlexpr_value.may_be_true?
+      when ctrlexpr_val.may_be_true?
         branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND) do
           interpret(node.statement)
         end
@@ -1060,21 +1008,21 @@ module C #:nodoc:
 
       orig_ctrlexpr = node.expression
       if orig_ctrlexpr == effective_ctrlexpr
-        ctrlexpr_value = ScalarValue.of_arbitrary
+        ctrlexpr_val = ScalarValue.of_arbitrary
         ctrlexpr = nil
       else
-        ctrlexpr_value = value_of(interpret(orig_ctrlexpr))
+        ctrlexpr_val = value_of(interpret(orig_ctrlexpr))
         ctrlexpr = orig_ctrlexpr.to_normalized_logical
       end
-      notify_if_else_ctrlexpr_evaled(node, ctrlexpr_value)
+      notify_if_else_ctrlexpr_evaled(node, ctrlexpr_val)
 
       case
-      when ctrlexpr_value.must_be_true?
+      when ctrlexpr_val.must_be_true?
         branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND, COMPLETE) do
           interpret(node.then_statement)
         end
         return
-      when ctrlexpr_value.may_be_true?
+      when ctrlexpr_val.may_be_true?
         branched_eval(ctrlexpr, NARROWING, IMPLICIT_COND) do
           interpret(node.then_statement)
         end
@@ -1098,13 +1046,13 @@ module C #:nodoc:
 
       widen_varying_variable_value_domain(node)
 
-      ctrlexpr_value = value_of(interpret(node.expression))
-      notify_while_ctrlexpr_evaled(node, ctrlexpr_value)
+      ctrlexpr_val = value_of(interpret(node.expression))
+      notify_while_ctrlexpr_evaled(node, ctrlexpr_val)
 
       orig_ctrlexpr, ctrlexpr = node.deduct_controlling_expression
 
       case
-      when ctrlexpr_value.must_be_true?
+      when ctrlexpr_val.must_be_true?
         begin
           enter_iteration_statement(orig_ctrlexpr)
           branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND, COMPLETE) do
@@ -1113,7 +1061,7 @@ module C #:nodoc:
         ensure
           leave_iteration_statement(orig_ctrlexpr)
         end
-      when ctrlexpr_value.may_be_true?
+      when ctrlexpr_val.may_be_true?
         begin
           enter_iteration_statement(orig_ctrlexpr)
           branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND) do
@@ -1146,8 +1094,8 @@ module C #:nodoc:
         leave_iteration_statement(orig_ctrlexpr)
       end
 
-      ctrlexpr_value = value_of(interpret(node.expression))
-      notify_do_ctrlexpr_evaled(node, ctrlexpr_value)
+      ctrlexpr_val = value_of(interpret(node.expression))
+      notify_do_ctrlexpr_evaled(node, ctrlexpr_val)
     ensure
       notify_do_stmt_ended(node)
     end
@@ -1165,16 +1113,16 @@ module C #:nodoc:
 
       node.condition_statement.executed = true
       if explicit_ctrlexpr = node.condition_statement.expression
-        ctrlexpr_value = value_of(interpret(explicit_ctrlexpr))
-        notify_for_ctrlexpr_evaled(node, ctrlexpr_value)
+        ctrlexpr_val = value_of(interpret(explicit_ctrlexpr))
+        notify_for_ctrlexpr_evaled(node, ctrlexpr_val)
       else
-        ctrlexpr_value = ScalarValue.of_true
+        ctrlexpr_val = ScalarValue.of_true
       end
 
       case
-      when ctrlexpr_value.must_be_true?
+      when ctrlexpr_val.must_be_true?
         interpret_for_body_statement(node, orig_ctrlexpr, ctrlexpr, true)
-      when ctrlexpr_value.may_be_true?
+      when ctrlexpr_val.may_be_true?
         interpret_for_body_statement(node, orig_ctrlexpr, ctrlexpr, false)
       end
     ensure
@@ -1195,16 +1143,16 @@ module C #:nodoc:
 
         node.condition_statement.executed = true
         if explicit_ctrlexpr = node.condition_statement.expression
-          ctrlexpr_value = value_of(interpret(explicit_ctrlexpr))
-          notify_c99_for_ctrlexpr_evaled(node, ctrlexpr_value)
+          ctrlexpr_val = value_of(interpret(explicit_ctrlexpr))
+          notify_c99_for_ctrlexpr_evaled(node, ctrlexpr_val)
         else
-          ctrlexpr_value = ScalarValue.of_true
+          ctrlexpr_val = ScalarValue.of_true
         end
 
         case
-        when ctrlexpr_value.must_be_true?
+        when ctrlexpr_val.must_be_true?
           interpret_for_body_statement(node, orig_ctrlexpr, ctrlexpr, true)
-        when ctrlexpr_value.may_be_true?
+        when ctrlexpr_val.may_be_true?
           interpret_for_body_statement(node, orig_ctrlexpr, ctrlexpr, false)
         end
       end
@@ -1244,29 +1192,29 @@ module C #:nodoc:
         BreakEvent.of_return.throw
       end
 
-      object = interpret(node.expression)
-      variable = object_to_variable(object)
-      unless variable == object
-        notify_implicit_conv_performed(node.expression, object, variable)
+      obj = interpret(node.expression)
+      var = object_to_variable(obj)
+      unless var == obj
+        notify_implicit_conv_performed(node.expression, obj, var)
       end
 
-      notify_variable_value_referred(node.expression, variable)
+      notify_variable_value_referred(node.expression, var)
 
-      if active_function = interpreter._active_function and
-          return_type = active_function.type.return_type
-        if variable.type.same_as?(return_type)
-          converted = variable
+      if active_func = interpreter._active_function and
+          return_type = active_func.type.return_type
+        if var.type.same_as?(return_type)
+          conved = var
         else
-          converted =
-            do_conversion(variable, return_type) ||
-            temporary_variable(return_type)
-          notify_implicit_conv_performed(node.expression, variable, converted)
+          conved = do_conversion(var, return_type) ||
+                   create_tempvar(return_type)
+          notify_implicit_conv_performed(node.expression, var, conved)
         end
       else
-        converted = variable
+        conved = var
       end
 
-      notify_return_stmt_evaled(node, variable)
+      notify_sequence_point_reached(SequencePoint.new(node))
+      notify_return_stmt_evaled(node, var)
       BreakEvent.of_return.throw
     end
 
@@ -1275,12 +1223,12 @@ module C #:nodoc:
       enter_iteration_statement(orig_ctrlexpr)
 
       if complete
-        branch_options = [NARROWING, FINAL, IMPLICIT_COND, COMPLETE]
+        branch_opts = [NARROWING, FINAL, IMPLICIT_COND, COMPLETE]
       else
-        branch_options = [NARROWING, FINAL, IMPLICIT_COND]
+        branch_opts = [NARROWING, FINAL, IMPLICIT_COND]
       end
 
-      branched_eval(ctrlexpr, *branch_options) do
+      branched_eval(ctrlexpr, *branch_opts) do
         interpret(node.body_statement)
         interpret(node.expression) if node.expression
 
@@ -1302,58 +1250,57 @@ module C #:nodoc:
       leave_iteration_statement(orig_ctrlexpr)
     end
 
-    def uninitialize_block_local_variables(generic_labeled_statement)
-      related_goto_statements = generic_labeled_statement.referrers
-      return if related_goto_statements.empty?
+    def uninitialize_block_local_variables(generic_labeled_stmt)
+      related_goto_stmts = generic_labeled_stmt.referrers
+      return if related_goto_stmts.empty?
 
-      local_variables.each do |variable|
-        variable_definition = variable.declarations_and_definitions.first
+      local_variables.each do |var|
+        var_def = var.declarations_and_definitions.first
 
-        anterior_gotos = related_goto_statements.select { |goto|
-          goto.location.line_no < variable_definition.location.line_no
+        anterior_goto_stmts = related_goto_stmts.select { |goto_stmt|
+          goto_stmt.location.line_no < var_def.location.line_no
         }
 
-        unless anterior_gotos.empty?
-          variable.value.enter_versioning_group
-          variable.value.begin_versioning
-          variable.uninitialize!
-          variable.value.end_versioning
-          variable.value.leave_versioning_group(true)
+        unless anterior_goto_stmts.empty?
+          var.value.enter_versioning_group
+          var.value.begin_versioning
+          var.uninitialize!
+          var.value.end_versioning
+          var.value.leave_versioning_group(true)
         end
       end
     end
 
-    def widen_varying_variable_value_domain(iteration_statement)
+    def widen_varying_variable_value_domain(iteration_stmt)
       varying_vars = {}
-      iteration_statement.varying_variable_names.each do |name|
-        if variable = variable_named(name)
-          varying_vars[variable] = variable.value.dup
-          variable.widen_value_domain!(Operator::EQ,
-                                       variable.type.arbitrary_value)
+      iteration_stmt.varying_variable_names.each do |name|
+        if var = variable_named(name)
+          varying_vars[var] = var.value.dup
+          var.widen_value_domain!(Operator::EQ, var.type.arbitrary_value)
         end
       end
 
-      varying_vars.each do |variable, orig_value|
-        case deduct_variable_varying_path(variable, iteration_statement)
+      varying_vars.each do |var, orig_val|
+        case deduct_variable_varying_path(var, iteration_stmt)
         when :increase
-          variable.narrow_value_domain!(Operator::GE, orig_value)
+          var.narrow_value_domain!(Operator::GE, orig_val)
         when :decrease
-          variable.narrow_value_domain!(Operator::LE, orig_value)
+          var.narrow_value_domain!(Operator::LE, orig_val)
         end
       end
     end
 
-    def deduct_variable_varying_path(variable, iteration_statement)
-      histogram = iteration_statement.varying_expressions.map { |expr|
+    def deduct_variable_varying_path(var, iteration_stmt)
+      histogram = iteration_stmt.varying_expressions.map { |expr|
         case expr
         when SimpleAssignmentExpression
-          deduct_ctrl_var_path_by_simple_assignment_expr(variable, expr)
+          deduct_ctrl_var_path_by_simple_assignment_expr(var, expr)
         when CompoundAssignmentExpression
-          deduct_ctrl_var_path_by_compound_assignment_expr(variable, expr)
+          deduct_ctrl_var_path_by_compound_assignment_expr(var, expr)
         when PrefixIncrementExpression, PostfixIncrementExpression
-          expr.operand.identifier.value == variable.name ? :increase : nil
+          expr.operand.identifier.value == var.name ? :increase : nil
         when PrefixDecrementExpression, PostfixDecrementExpression
-          expr.operand.identifier.value == variable.name ? :decrease : nil
+          expr.operand.identifier.value == var.name ? :decrease : nil
         else
           nil
         end
@@ -1366,22 +1313,19 @@ module C #:nodoc:
       end
     end
 
-    def deduct_ctrl_var_path_by_simple_assignment_expr(variable, expr)
-      return nil unless expr.lhs_operand.identifier.value == variable.name
+    def deduct_ctrl_var_path_by_simple_assignment_expr(var, expr)
+      return nil unless expr.lhs_operand.identifier.value == var.name
 
       additive_exprs = collect_additive_expressions(expr.rhs_operand)
       histogram = additive_exprs.map { |additive_expr|
         if additive_expr.lhs_operand.kind_of?(ObjectSpecifier)
           lhs_name = additive_expr.lhs_operand.identifier.value
         end
-
         if additive_expr.rhs_operand.kind_of?(ObjectSpecifier)
           rhs_name = additive_expr.rhs_operand.identifier.value
         end
 
-        unless lhs_name == variable.name || rhs_name == variable.name
-          next nil
-        end
+        next nil unless lhs_name == var.name || rhs_name == var.name
 
         case additive_expr.operator.type
         when "+"
@@ -1400,8 +1344,8 @@ module C #:nodoc:
       end
     end
 
-    def deduct_ctrl_var_path_by_compound_assignment_expr(variable, expr)
-      return nil unless expr.lhs_operand.identifier.value == variable.name
+    def deduct_ctrl_var_path_by_compound_assignment_expr(var, expr)
+      return nil unless expr.lhs_operand.identifier.value == var.name
 
       case expr.operator.type
       when "+="
@@ -1441,32 +1385,34 @@ module C #:nodoc:
       notify_switch_stmt_started(node)
 
       ctrlexpr = node.expression
-      ctrlexpr_result = object_to_variable(interpret(ctrlexpr))
-      notify_switch_ctrlexpr_evaled(node, ctrlexpr_result)
-
-      execute_switch_body(ctrlexpr_result, node.statement)
+      ctrlexpr_var = object_to_variable(interpret(ctrlexpr))
+      notify_switch_ctrlexpr_evaled(node, ctrlexpr_var)
 
+      execute_switch_body(ctrlexpr_var, node.statement)
       notify_switch_stmt_ended(node)
     end
 
     private
-    def execute_switch_body(variable, node)
+    def execute_switch_body(var, node)
       checkpoint(node.location)
 
       node.executed = true
       scoped_eval do
         begin
           notify_block_started(node)
-          execute_switch_branches(variable, node.block_items)
+          execute_switch_branches(var, node.block_items)
         ensure
           notify_block_ended(node)
         end
       end
     end
 
-    def execute_switch_branches(variable, block_items)
-      base_options = [SMOTHER_BREAK, IMPLICIT_COND, NARROWING]
-      base_options.push(COMPLETE) if complete?(block_items)
+    def execute_switch_branches(var, block_items)
+      if complete?(block_items)
+        base_opts = [SMOTHER_BREAK, IMPLICIT_COND, NARROWING, COMPLETE]
+      else
+        base_opts = [SMOTHER_BREAK, IMPLICIT_COND, NARROWING]
+      end
 
       index = 0
       while block_item = block_items[index]
@@ -1478,9 +1424,12 @@ module C #:nodoc:
 
         case block_item
         when CaseLabeledStatement, DefaultLabeledStatement
-          options = base_options.dup
-          options.push(FINAL) if final_branch?(block_items, index)
-          index = execute_branch(block_item, block_items, index + 1, options)
+          if final_branch?(block_items, index)
+            opts = base_opts + [FINAL]
+          else
+            opts = base_opts.dup
+          end
+          index = execute_branch(block_item, block_items, index + 1, opts)
           break unless index
         else
           interpret(block_item)
@@ -1489,22 +1438,22 @@ module C #:nodoc:
       end
     end
 
-    def execute_branch(labeled_statement, block_items, index, branch_options)
-      ctrlexpr = labeled_statement.normalized_expression
-      ctrlexpr_value = value_of(interpret(ctrlexpr, QUIET))
+    def execute_branch(labeled_stmt, block_items, index, branch_opts)
+      ctrlexpr = labeled_stmt.normalized_expression
+      ctrlexpr_val = value_of(interpret(ctrlexpr, QUIET))
 
       case
-      when ctrlexpr_value.must_be_true?
-        branch_options.push(FINAL, COMPLETE)
-      when ctrlexpr_value.must_be_false?
+      when ctrlexpr_val.must_be_true?
+        branch_opts.push(FINAL, COMPLETE)
+      when ctrlexpr_val.must_be_false?
         # NOTE: To end the current branch group of switch-statement if this
         #       case-clause is the final one.
-        branched_eval(ctrlexpr, *branch_options) {}
+        branched_eval(ctrlexpr, *branch_opts) {}
         return seek_next_branch(block_items, index)
       end
 
-      branched_eval(ctrlexpr, *branch_options) do |branch|
-        interpret(labeled_statement)
+      branched_eval(ctrlexpr, *branch_opts) do |branch|
+        interpret(labeled_stmt)
         while block_item = block_items[index]
           while block_item.kind_of?(GenericLabeledStatement)
             block_item.executed = true
@@ -1515,9 +1464,9 @@ module C #:nodoc:
           case block_item
           when CaseLabeledStatement, DefaultLabeledStatement
             # NOTE: Fall through!
-            prepare_fall_through(branch, branch_options, block_item)
-            branch_options.push(FINAL) if final_branch?(block_items, index)
-            branch.add_options(*branch_options)
+            prepare_fall_through(branch, branch_opts, block_item)
+            branch_opts.push(FINAL) if final_branch?(block_items, index)
+            branch.add_options(*branch_opts)
           end
           interpret(block_item)
           index += 1
@@ -1526,21 +1475,20 @@ module C #:nodoc:
         BreakEvent.of_break.throw
       end
 
-      branch_options.include?(FINAL) ?
-        nil : seek_next_branch(block_items, index)
+      branch_opts.include?(FINAL) ? nil : seek_next_branch(block_items, index)
     end
 
-    def prepare_fall_through(branch, branch_options, labeled_statement)
+    def prepare_fall_through(branch, branch_opts, labeled_stmt)
       value_domain_manip = nil
 
       branch.restart_versioning do
-        ctrlexpr = labeled_statement.normalized_expression
-        ctrlexpr_value = value_of(interpret(ctrlexpr, QUIET))
+        ctrlexpr = labeled_stmt.normalized_expression
+        ctrlexpr_val = value_of(interpret(ctrlexpr, QUIET))
 
         case
-        when ctrlexpr_value.must_be_true?
-          branch_options.push(FINAL, COMPLETE)
-        when ctrlexpr_value.must_be_false?
+        when ctrlexpr_val.must_be_true?
+          branch_opts.push(FINAL, COMPLETE)
+        when ctrlexpr_val.must_be_false?
           return
         end
 
@@ -1617,8 +1565,8 @@ module C #:nodoc:
         def #{method_name}(node)
           super
         ensure
-          if sequence_point = node.subsequent_sequence_point
-            notify_sequence_point_reached(sequence_point)
+          if seqp = node.subsequent_sequence_point
+            notify_sequence_point_reached(seqp)
           end
         end
       EOS
@@ -1668,18 +1616,18 @@ module C #:nodoc:
       checkpoint(node.location)
 
       ctrlexpr = node.condition
-      ctrlexpr_variable = interpret(ctrlexpr, QUIET)
-      ctrlexpr_value = value_of(ctrlexpr_variable)
+      ctrlexpr_var = interpret(ctrlexpr, QUIET)
+      ctrlexpr_val = value_of(ctrlexpr_var)
 
       then_var = nil
-      if ctrlexpr_value.may_be_true?
+      if ctrlexpr_val.may_be_true?
         branched_eval(ctrlexpr, NARROWING) do
           then_var = object_to_variable(interpret(node.then_expression))
         end
       end
 
       else_var = nil
-      if ctrlexpr_value.may_be_false?
+      if ctrlexpr_val.may_be_false?
         branched_eval(nil, NARROWING, FINAL, COMPLETE) do
           else_var = object_to_variable(interpret(node.else_expression))
         end
@@ -1690,7 +1638,7 @@ module C #:nodoc:
       case
       when then_var && else_var
         result_val = then_var.value.single_value_unified_with(else_var.value)
-        result = temporary_variable(then_var.type, result_val)
+        result_var = create_tempvar(then_var.type, result_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
@@ -1698,20 +1646,20 @@ module C #:nodoc:
         notify_variable_value_referred(node, then_var)
         notify_variable_value_referred(node, else_var)
       when then_var
-        result = then_var
+        result_var = then_var
       when else_var
-        result = else_var
+        result_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 = temporary_variable
+        result_var = create_tempvar
       end
 
-      notify_conditional_expr_evaled(node, ctrlexpr_variable, result)
-      result
+      notify_conditional_expr_evaled(node, ctrlexpr_var, result_var)
+      result_var
     ensure
-      if sequence_point = node.subsequent_sequence_point
-        notify_sequence_point_reached(sequence_point)
+      if seqp = node.subsequent_sequence_point
+        notify_sequence_point_reached(seqp)
       end
     end
   end