adlint 2.6.0 → 2.6.2

data/lib/adlint/c/ctrlexpr.rb

@@ -47,8 +47,8 @@ module C #:nodoc:
   #  +-> ValueDomainManipulator
   #      | <-- ValueDomainNarrower
   #      | <-- ValueDomainWidener
-  #      | <-- WithoutExpressionValueDomainNarrower
-  #      | <-- WithoutExpressionValueDomainWidener
+  #      | <-- NilValueDomainNarrower
+  #      | <-- NilValueDomainWidener
   #      |
   #      +-> ValueDomainNarrowing
   #            <-- ValueComparison
@@ -59,15 +59,15 @@ module C #:nodoc:
   class ControllingExpression
     include SyntaxNodeCollector
 
-    def initialize(interpreter, branch, expression = nil)
-      @interpreter = interpreter
-      @branch = branch
-      @expression = expression
+    def initialize(interpreter, branch, target_expr = nil)
+      @interpreter  = interpreter
+      @branch       = branch
+      @target_expr  = target_expr
       @manipulators = []
     end
 
-    def ensure_true_by_narrowing(other_expr = nil)
-      target_expr = other_expr ? other_expr : @expression
+    def ensure_true_by_narrowing(alt_expr = nil)
+      target_expr = alt_expr ? alt_expr : @target_expr
 
       if target_expr
         new_manip = ValueDomainNarrower.new(@interpreter, target_expr)
@@ -82,16 +82,15 @@ module C #:nodoc:
           end
         end
       else
-        new_manip =
-          WithoutExpressionValueDomainNarrower.new(@interpreter, @branch.group)
+        new_manip = NilValueDomainNarrower.new(@interpreter, @branch.group)
       end
 
       @manipulators.push(new_manip)
       new_manip
     end
 
-    def ensure_true_by_widening(other_expr = nil)
-      target_expr = other_expr ? other_expr : @expression
+    def ensure_true_by_widening(alt_expr = nil)
+      target_expr = alt_expr ? alt_expr : @target_expr
 
       if target_expr
         new_manip = ValueDomainWidener.new(@interpreter, target_expr)
@@ -106,8 +105,7 @@ module C #:nodoc:
           end
         end
       else
-        new_manip =
-          WithoutExpressionValueDomainWidener.new(@interpreter, @branch.group)
+        new_manip = NilValueDomainWidener.new(@interpreter, @branch.group)
       end
 
       @manipulators.push(new_manip)
@@ -133,7 +131,7 @@ module C #:nodoc:
     def complexly_compounded?
       # NOTE: This method determines whether the controlling expression is too
       #       complex to thin value domains of controlling variables.
-      @expression && !collect_logical_and_expressions(@expression).empty?
+      @target_expr && !collect_logical_and_expressions(@target_expr).empty?
     end
   end
 
@@ -141,23 +139,23 @@ module C #:nodoc:
     include InterpreterMediator
     include NotifierMediator
     include Conversion
-    include ExpressionUtil
+    include ExpressionEvaluator::Impl
     include MonitorUtil
 
-    def initialize(interpreter, expression)
-      @interpreter = interpreter
-      @expression = expression
+    def initialize(interpreter, target_expr)
+      @interpreter        = interpreter
+      @target_expr        = target_expr
       @affected_variables = []
-      @narrowing = nil
-      @value_memory = nil
+      @narrowing          = nil
+      @value_memory       = nil
     end
 
     attr_reader :interpreter
     attr_reader :affected_variables
 
     def prepare!
-      if @expression
-        @narrowing = @expression.accept(self)
+      if @target_expr
+        @narrowing = @target_expr.accept(self)
         @narrowing.execute!
       end
     end
@@ -170,7 +168,7 @@ module C #:nodoc:
       commit_changes(@narrowing)
 
       if @narrowing
-        @affected_variables = @narrowing.narrowed_values.each_key.to_a
+        @affected_variables = @narrowing.narrowed_values.keys
         @narrowing = nil
       end
     end
@@ -183,16 +181,14 @@ module C #:nodoc:
 
     def save!
       @value_memory = {}
-      @affected_variables.each do |variable|
-        @value_memory[variable] = variable.value.to_single_value.dup
+      @affected_variables.each do |var|
+        @value_memory[var] = var.value.to_single_value.dup
       end
     end
 
     def restore!
       if @value_memory
-        @value_memory.each do |variable, saved_value|
-          variable.assign!(saved_value)
-        end
+        @value_memory.each { |var, saved_val| var.assign!(saved_val) }
         @value_memory = nil
       end
     end
@@ -215,69 +211,52 @@ module C #:nodoc:
     def visit_array_subscript_expression(node)
       checkpoint(node.location)
 
-      base_narrowing = node.expression.accept(self)
-      subscript_narrowing = node.array_subscript.accept(self)
+      obj_manip = node.expression.accept(self)
+      subs_manip = node.array_subscript.accept(self)
 
-      DelayedObjectDerivation.new(self, node,
-                                  base_narrowing, subscript_narrowing) do
+      DelayedObjectDerivation.new(self, node, obj_manip, subs_manip) do
         checkpoint(node.location)
-
-        base_narrowing.execute!
-        subscript_narrowing.execute!
-
-        execute_array_subscript_expression(node, base_narrowing.result,
-                                           subscript_narrowing.result)
+        obj_manip.execute!
+        subs_manip.execute!
+        eval_array_subscript_expr(node, obj_manip.result, subs_manip.result)
       end
     end
 
     def visit_function_call_expression(node)
       checkpoint(node.location)
 
-      object_narrowing = node.expression.accept(self)
-      arg_narrowings = node.argument_expressions.map { |expr|
-        expr.accept(self)
-      }
+      obj_manip  = node.expression.accept(self)
+      arg_manips = node.argument_expressions.map { |expr| expr.accept(self) }
 
-      DelayedObjectDerivation.new(self, node,
-                                  object_narrowing, *arg_narrowings) do
+      DelayedObjectDerivation.new(self, node, obj_manip, *arg_manips) do
         checkpoint(node.location)
-
-        object_narrowing.execute!
-        args = arg_narrowings.map { |narrowing|
-          narrowing.execute!; [narrowing.result, narrowing.node]
-        }
-
-        execute_function_call_expression(node, object_narrowing.result, args)
+        obj_manip.execute!
+        args = arg_manips.map { |m| m.execute!; [m.result, m.node] }
+        eval_function_call_expr(node, obj_manip.result, args)
       end
     end
 
     def visit_member_access_by_value_expression(node)
       checkpoint(node.location)
 
-      object_narrowing = node.expression.accept(self)
+      obj_manip = node.expression.accept(self)
 
-      DelayedObjectDerivation.new(self, node, object_narrowing) do
+      DelayedObjectDerivation.new(self, node, obj_manip) do
         checkpoint(node.location)
-
-        object_narrowing.execute!
-
-        execute_member_access_by_value_expression(
-          node, object_narrowing.result)
+        obj_manip.execute!
+        eval_member_access_by_value_expr(node, obj_manip.result)
       end
     end
 
     def visit_member_access_by_pointer_expression(node)
       checkpoint(node.location)
 
-      object_narrowing = node.expression.accept(self)
+      obj_manip = node.expression.accept(self)
 
-      DelayedObjectDerivation.new(self, node, object_narrowing) do
+      DelayedObjectDerivation.new(self, node, obj_manip) do
         checkpoint(node.location)
-
-        object_narrowing.execute!
-
-        execute_member_access_by_pointer_expression(
-          node, object_narrowing.result)
+        obj_manip.execute!
+        eval_member_access_by_pointer_expr(node, obj_manip.result)
       end
     end
 
@@ -287,26 +266,24 @@ module C #:nodoc:
     def visit_postfix_increment_expression(node)
       checkpoint(node.location)
 
-      object_narrowing = node.operand.accept(self)
+      obj_manip = node.operand.accept(self)
 
-      DelayedObjectDerivation.new(self, node, object_narrowing) do
+      DelayedObjectDerivation.new(self, node, obj_manip) do
         checkpoint(node.location)
-
-        object_narrowing.execute!
-        execute_postfix_increment_expression(node, object_narrowing.result)
+        obj_manip.execute!
+        eval_postfix_increment_expr(node, obj_manip.result)
       end
     end
 
     def visit_postfix_decrement_expression(node)
       checkpoint(node.location)
 
-      object_narrowing = node.operand.accept(self)
+      obj_manip = node.operand.accept(self)
 
-      DelayedObjectDerivation.new(self, node, object_narrowing) do
+      DelayedObjectDerivation.new(self, node, obj_manip) do
         checkpoint(node.location)
-
-        object_narrowing.execute!
-        execute_postfix_decrement_expression(node, object_narrowing.result)
+        obj_manip.execute!
+        eval_postfix_decrement_expr(node, obj_manip.result)
       end
     end
 
@@ -315,26 +292,24 @@ module C #:nodoc:
     def visit_prefix_increment_expression(node)
       checkpoint(node.location)
 
-      object_narrowing = node.operand.accept(self)
+      obj_manip = node.operand.accept(self)
 
-      DelayedObjectDerivation.new(self, node, object_narrowing) do
+      DelayedObjectDerivation.new(self, node, obj_manip) do
         checkpoint(node.location)
-
-        object_narrowing.execute!
-        execute_prefix_increment_expression(node, object_narrowing.result)
+        obj_manip.execute!
+        eval_prefix_increment_expr(node, obj_manip.result)
       end
     end
 
     def visit_prefix_decrement_expression(node)
       checkpoint(node.location)
 
-      object_narrowing = node.operand.accept(self)
+      obj_manip = node.operand.accept(self)
 
-      DelayedObjectDerivation.new(self, node, object_narrowing) do
+      DelayedObjectDerivation.new(self, node, obj_manip) do
         checkpoint(node.location)
-
-        object_narrowing.execute!
-        execute_prefix_decrement_expression(node, object_narrowing.result)
+        obj_manip.execute!
+        eval_prefix_decrement_expr(node, obj_manip.result)
       end
     end
 
@@ -343,28 +318,24 @@ module C #:nodoc:
     def visit_indirection_expression(node)
       checkpoint(node.location)
 
-      object_narrowing = node.operand.accept(self)
+      obj_manip = node.operand.accept(self)
 
-      DelayedObjectDerivation.new(self, node, object_narrowing) do
+      DelayedObjectDerivation.new(self, node, obj_manip) do
         checkpoint(node.location)
-
-        object_narrowing.execute!
-
-        execute_indirection_expression(node, object_narrowing.result)
+        obj_manip.execute!
+        eval_indirection_expr(node, obj_manip.result)
       end
     end
 
     def visit_unary_arithmetic_expression(node)
       checkpoint(node.location)
 
-      object_narrowing = node.operand.accept(self)
+      obj_manip = node.operand.accept(self)
 
-      DelayedObjectDerivation.new(self, node, object_narrowing) do
+      DelayedObjectDerivation.new(self, node, obj_manip) do
         checkpoint(node.location)
-
-        object_narrowing.execute!
-
-        execute_unary_arithmetic_expression(node, object_narrowing.result)
+        obj_manip.execute!
+        eval_unary_arithmetic_expr(node, obj_manip.result)
       end
     end
 
@@ -376,153 +347,121 @@ module C #:nodoc:
     def visit_cast_expression(node)
       checkpoint(node.location)
 
-      object_narrowing = node.operand.accept(self)
+      obj_manip = node.operand.accept(self)
 
-      DelayedObjectDerivation.new(self, node, object_narrowing) do
+      DelayedObjectDerivation.new(self, node, obj_manip) do
         checkpoint(node.location)
-
-        object_narrowing.execute!
-
-        execute_cast_expression(node, object_narrowing.result)
+        obj_manip.execute!
+        eval_cast_expr(node, obj_manip.result)
       end
     end
 
     def visit_multiplicative_expression(node)
       checkpoint(node.location)
 
-      lhs_narrowing = node.lhs_operand.accept(self)
-      rhs_narrowing = node.rhs_operand.accept(self)
+      lhs_manip = node.lhs_operand.accept(self)
+      rhs_manip = node.rhs_operand.accept(self)
 
-      DelayedObjectDerivation.new(self, node, lhs_narrowing, rhs_narrowing) do
+      DelayedObjectDerivation.new(self, node, lhs_manip, rhs_manip) do
         checkpoint(node.location)
-
-        lhs_narrowing.execute!
-        rhs_narrowing.execute!
-
-        execute_multiplicative_expression(
-          node, lhs_narrowing.result, rhs_narrowing.result)
+        lhs_manip.execute!
+        rhs_manip.execute!
+        eval_multiplicative_expr(node, lhs_manip.result, rhs_manip.result)
       end
     end
 
     def visit_additive_expression(node)
       checkpoint(node.location)
 
-      lhs_narrowing = node.lhs_operand.accept(self)
-      rhs_narrowing = node.rhs_operand.accept(self)
+      lhs_manip = node.lhs_operand.accept(self)
+      rhs_manip = node.rhs_operand.accept(self)
 
-      DelayedObjectDerivation.new(self, node, lhs_narrowing, rhs_narrowing) do
+      DelayedObjectDerivation.new(self, node, lhs_manip, rhs_manip) do
         checkpoint(node.location)
-
-        lhs_narrowing.execute!
-        rhs_narrowing.execute!
-
-        execute_additive_expression(
-          node, lhs_narrowing.result, rhs_narrowing.result)
+        lhs_manip.execute!
+        rhs_manip.execute!
+        eval_additive_expr(node, lhs_manip.result, rhs_manip.result)
       end
     end
 
     def visit_shift_expression(node)
       checkpoint(node.location)
 
-      lhs_narrowing = node.lhs_operand.accept(self)
-      rhs_narrowing = node.rhs_operand.accept(self)
+      lhs_manip = node.lhs_operand.accept(self)
+      rhs_manip = node.rhs_operand.accept(self)
 
-      DelayedObjectDerivation.new(self, node, lhs_narrowing, rhs_narrowing) do
+      DelayedObjectDerivation.new(self, node, lhs_manip, rhs_manip) do
         checkpoint(node.location)
-
-        lhs_narrowing.execute!
-        rhs_narrowing.execute!
-
-        execute_shift_expression(
-          node, lhs_narrowing.result, rhs_narrowing.result)
+        lhs_manip.execute!
+        rhs_manip.execute!
+        eval_shift_expr(node, lhs_manip.result, rhs_manip.result)
       end
     end
 
     def visit_relational_expression(node)
       checkpoint(node.location)
-
-      lhs_narrowing = node.lhs_operand.accept(self)
-      rhs_narrowing = node.rhs_operand.accept(self)
-
-      ValueComparison.new(self, node, lhs_narrowing, rhs_narrowing)
+      ValueComparison.new(self, node, node.lhs_operand.accept(self),
+                          node.rhs_operand.accept(self))
     end
 
     def visit_equality_expression(node)
       checkpoint(node.location)
-
-      lhs_narrowing = node.lhs_operand.accept(self)
-      rhs_narrowing = node.rhs_operand.accept(self)
-
-      ValueComparison.new(self, node, lhs_narrowing, rhs_narrowing)
+      ValueComparison.new(self, node, node.lhs_operand.accept(self),
+                          node.rhs_operand.accept(self))
     end
 
     def visit_and_expression(node)
       checkpoint(node.location)
 
-      lhs_narrowing = node.lhs_operand.accept(self)
-      rhs_narrowing = node.rhs_operand.accept(self)
+      lhs_manip = node.lhs_operand.accept(self)
+      rhs_manip = node.rhs_operand.accept(self)
 
-      DelayedObjectDerivation.new(self, node, lhs_narrowing, rhs_narrowing) do
+      DelayedObjectDerivation.new(self, node, lhs_manip, rhs_manip) do
         checkpoint(node.location)
-
-        lhs_narrowing.execute!
-        rhs_narrowing.execute!
-
-        execute_and_expression(node,
-                               lhs_narrowing.result, rhs_narrowing.result)
+        lhs_manip.execute!
+        rhs_manip.execute!
+        eval_and_expr(node, lhs_manip.result, rhs_manip.result)
       end
     end
 
     def visit_exclusive_or_expression(node)
       checkpoint(node.location)
 
-      lhs_narrowing = node.lhs_operand.accept(self)
-      rhs_narrowing = node.rhs_operand.accept(self)
+      lhs_manip = node.lhs_operand.accept(self)
+      rhs_manip = node.rhs_operand.accept(self)
 
-      DelayedObjectDerivation.new(self, node, lhs_narrowing, rhs_narrowing) do
+      DelayedObjectDerivation.new(self, node, lhs_manip, rhs_manip) do
         checkpoint(node.location)
-
-        lhs_narrowing.execute!
-        rhs_narrowing.execute!
-
-        execute_exclusive_or_expression(
-          node, lhs_narrowing.result, rhs_narrowing.result)
+        lhs_manip.execute!
+        rhs_manip.execute!
+        eval_exclusive_or_expr(node, lhs_manip.result, rhs_manip.result)
       end
     end
 
     def visit_inclusive_or_expression(node)
       checkpoint(node.location)
 
-      lhs_narrowing = node.lhs_operand.accept(self)
-      rhs_narrowing = node.rhs_operand.accept(self)
+      lhs_manip = node.lhs_operand.accept(self)
+      rhs_manip = node.rhs_operand.accept(self)
 
-      DelayedObjectDerivation.new(self, node, lhs_narrowing, rhs_narrowing) do
+      DelayedObjectDerivation.new(self, node, lhs_manip, rhs_manip) do
         checkpoint(node.location)
-
-        lhs_narrowing.execute!
-        rhs_narrowing.execute!
-
-        execute_inclusive_or_expression(
-          node, lhs_narrowing.result, rhs_narrowing.result)
+        lhs_manip.execute!
+        rhs_manip.execute!
+        eval_inclusive_or_expr(node, lhs_manip.result, rhs_manip.result)
       end
     end
 
     def visit_logical_and_expression(node)
       checkpoint(node.location)
-
-      lhs_narrowing = node.lhs_operand.accept(self)
-      rhs_narrowing = node.rhs_operand.accept(self)
-
-      LogicalAnd.new(self, node, lhs_narrowing, rhs_narrowing)
+      LogicalAnd.new(self, node, node.lhs_operand.accept(self),
+                     node.rhs_operand.accept(self))
     end
 
     def visit_logical_or_expression(node)
       checkpoint(node.location)
-
-      lhs_narrowing = node.lhs_operand.accept(self)
-      rhs_narrowing = node.rhs_operand.accept(self)
-
-      LogicalOr.new(self, node, lhs_narrowing, rhs_narrowing)
+      LogicalOr.new(self, node, node.lhs_operand.accept(self),
+                    node.rhs_operand.accept(self))
     end
 
     def_strict_object_derivation :visit_conditional_expression
@@ -530,77 +469,67 @@ module C #:nodoc:
     def visit_simple_assignment_expression(node)
       checkpoint(node.location)
 
-      lhs_narrowing = node.lhs_operand.accept(self)
-      rhs_narrowing = node.rhs_operand.accept(self)
+      lhs_manip = node.lhs_operand.accept(self)
+      rhs_manip = node.rhs_operand.accept(self)
 
-      DelayedObjectDerivation.new(self, node, lhs_narrowing, rhs_narrowing) do
+      DelayedObjectDerivation.new(self, node, lhs_manip, rhs_manip) do
         checkpoint(node.location)
-
-        lhs_narrowing.execute!
-        rhs_narrowing.execute!
-
-        execute_simple_assignment_expression(
-          node, lhs_narrowing.result, rhs_narrowing.result)
+        lhs_manip.execute!
+        rhs_manip.execute!
+        eval_simple_assignment_expr(node, lhs_manip.result, rhs_manip.result)
       end
     end
 
     def visit_compound_assignment_expression(node)
       checkpoint(node.location)
 
-      lhs_narrowing = node.lhs_operand.accept(self)
-      rhs_narrowing = node.rhs_operand.accept(self)
+      lhs_manip = node.lhs_operand.accept(self)
+      rhs_manip = node.rhs_operand.accept(self)
 
-      DelayedObjectDerivation.new(self, node, lhs_narrowing, rhs_narrowing) do
+      DelayedObjectDerivation.new(self, node, lhs_manip, rhs_manip) do
         checkpoint(node.location)
-
-        lhs_narrowing.execute!
-        rhs_narrowing.execute!
-
-        execute_compound_assignment_expression(
-          node, lhs_narrowing.result, rhs_narrowing.result)
+        lhs_manip.execute!
+        rhs_manip.execute!
+        eval_compound_assignment_expr(node, lhs_manip.result, rhs_manip.result)
       end
     end
 
     def visit_comma_separated_expression(node)
       checkpoint(node.location)
 
-      object_narrowings = node.expressions.map { |expr| expr.accept(self) }
+      obj_manips = node.expressions.map { |expr| expr.accept(self) }
 
-      DelayedObjectDerivation.new(self, node, *object_narrowings) do
+      DelayedObjectDerivation.new(self, node, *obj_manips) do
         checkpoint(node.location)
-
-        object_narrowings.map { |narrowing|
-          narrowing.execute!
-          narrowing.result
-        }.last
+        obj_manips.map { |manip| manip.execute!; manip.result }.last
       end
     end
 
     private
-    def commit_changes(narrowing)
+    def commit_changes(manip)
       subclass_responsibility
     end
   end
 
   class ValueDomainNarrower < ValueDomainManipulator
     private
-    def commit_changes(narrowing)
-      narrowing.narrowed_values.each do |variable, narrowed_value|
-        variable.narrow_value_domain!(Operator::EQ, narrowed_value)
+    def commit_changes(manip)
+      manip.narrowed_values.each do |var, val|
+        var.narrow_value_domain!(Operator::EQ, val)
       end
     end
   end
 
   class ValueDomainWidener < ValueDomainManipulator
     private
-    def commit_changes(narrowing)
-      narrowing.narrowed_values.each do |variable, narrowed_value|
-        variable.widen_value_domain!(Operator::EQ, narrowed_value)
+    def commit_changes(manip)
+      manip.narrowed_values.each do |var, val|
+        var.widen_value_domain!(Operator::EQ, val)
       end
     end
   end
 
-  class WithoutExpressionValueDomainNarrower < ValueDomainManipulator
+  class NilValueDomainNarrower < ValueDomainManipulator
     def initialize(interpreter, branch_group)
       super(interpreter, nil)
       @branch_group = branch_group
@@ -611,16 +540,15 @@ module C #:nodoc:
     end
 
     private
-    def commit_changes(narrowing)
-      @branch_group.all_controlling_variables.each do |variable|
-        variable.narrow_value_domain!(Operator::EQ,
-                                      variable.type.arbitrary_value)
+    def commit_changes(*)
+      @branch_group.all_controlling_variables.each do |var|
+        var.narrow_value_domain!(Operator::EQ, var.type.arbitrary_value)
       end
       true
     end
   end
 
-  class WithoutExpressionValueDomainWidener < ValueDomainManipulator
+  class NilValueDomainWidener < ValueDomainManipulator
     def initialize(interpreter, branch_group)
       super(interpreter, nil)
       @branch_group = branch_group
@@ -631,10 +559,9 @@ module C #:nodoc:
     end
 
     private
-    def commit_changes(narrowing)
-      @branch_group.all_controlling_variables.each do |variable|
-        variable.widen_value_domain!(Operator::EQ,
-                                     variable.type.arbitrary_value)
+    def commit_changes(*)
+      @branch_group.all_controlling_variables.each do |var|
+        var.widen_value_domain!(Operator::EQ, var.type.arbitrary_value)
       end
       true
     end
@@ -645,39 +572,39 @@ module C #:nodoc:
     include NotifierMediator
     include Conversion
 
-    def initialize(value_domain_manipulator, node, *children)
-      @manipulator = value_domain_manipulator
-      @node = node
-      @children = children
+    def initialize(manip, node, *children)
+      @manipulator     = manip
+      @node            = node
+      @children        = children
       @original_values = {}
       @narrowed_values = {}
-      @result = nil
+      @result          = nil
     end
 
     attr_reader :node
     attr_reader :narrowed_values
     attr_reader :result
 
-    def load_original_values!(narrowing)
-      @original_values = narrowing.narrowed_values
-      @children.each { |child| child.load_original_values!(narrowing) }
+    def load_original_values!(manip)
+      @original_values = manip.narrowed_values
+      @children.each { |child| child.load_original_values!(manip) }
     end
 
     def execute!
       @result = do_narrowing
-      @children.each do |narrowing|
-        @narrowed_values = narrowing.narrowed_values.merge(@narrowed_values)
+      @children.each do |manip|
+        @narrowed_values = manip.narrowed_values.merge(@narrowed_values)
       end
     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
 
-    def ensure_result_equal_to(value)
+    def ensure_result_equal_to(val)
       if @result.variable? && @result.designated_by_lvalue?
-        if @result.value.scalar? && value.scalar?
-          ensure_relation(@result, Operator::EQ, value)
+        if @result.value.scalar? && val.scalar?
+          ensure_relation(@result, Operator::EQ, val)
         end
       end
     end
@@ -690,61 +617,57 @@ module C #:nodoc:
       subclass_responsibility
     end
 
-    def do_logical_arithmetic_conversion(node, lhs_variable, rhs_variable)
-      lhs_result, rhs_result =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
+    def do_logical_arithmetic_conversion(node, lhs_var, rhs_var)
+      lhs_conved, rhs_conved = do_usual_arithmetic_conversion(lhs_var, rhs_var)
 
-      unless lhs_variable == lhs_result
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_result)
+      unless lhs_conved == lhs_var
+        notify_implicit_conv_performed(node.lhs_operand, lhs_var, lhs_conved)
       end
 
-      unless rhs_variable == rhs_result
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_result)
+      unless rhs_conved == rhs_var
+        notify_implicit_conv_performed(node.rhs_operand, rhs_var, rhs_conved)
       end
 
-      return lhs_result, rhs_result
+      return lhs_conved, rhs_conved
     end
 
-    def ensure_relation(variable, operator, value)
+    def ensure_relation(var, op, val)
       # NOTE: To avoid over-narrowing.
-      if value.definite? or
-          variable.value.contain?(value) && !value.contain?(variable.value)
-        target_value = save_original_value(variable).dup
-        target_value.narrow_domain!(operator, value)
-        update_narrowed_value(variable, target_value)
+      if val.definite? or var.value.contain?(val) && !val.contain?(var.value)
+        target_val = save_original_value(var).dup
+        target_val.narrow_domain!(op, val)
+        update_narrowed_value(var, target_val)
       end
     end
 
-    def save_original_value(variable)
-      @original_values[variable.to_named_variable] ||= variable.value.dup
+    def save_original_value(var)
+      @original_values[var.to_named_variable] ||= var.value.dup
     end
 
-    def original_value_of(variable)
-      @original_values[variable.to_named_variable]
+    def original_value_of(var)
+      @original_values[var.to_named_variable]
     end
 
-    def update_narrowed_value(variable, new_value)
-      @narrowed_values[variable.to_named_variable] = new_value
+    def update_narrowed_value(var, new_val)
+      @narrowed_values[var.to_named_variable] = new_val
     end
 
-    def narrowing_merge!(lhs_narrowing, rhs_narrowing)
-      lhs_values = lhs_narrowing.narrowed_values
-      rhs_values = rhs_narrowing.narrowed_values
+    def narrowing_merge!(lhs_manip, rhs_manip)
+      lhs_vals = lhs_manip.narrowed_values
+      rhs_vals = rhs_manip.narrowed_values
 
-      @narrowed_values = lhs_values.merge(rhs_values) { |key, lhs_val, rhs_val|
+      @narrowed_values = lhs_vals.merge(rhs_vals) { |key, lhs_val, rhs_val|
         result = lhs_val.dup
         result.narrow_domain!(Operator::EQ, rhs_val)
         result
       }
     end
 
-    def widening_merge!(lhs_narrowing, rhs_narrowing)
-      lhs_values = lhs_narrowing.narrowed_values
-      rhs_values = rhs_narrowing.narrowed_values
+    def widening_merge!(lhs_manip, rhs_manip)
+      lhs_vals = lhs_manip.narrowed_values
+      rhs_vals = rhs_manip.narrowed_values
 
-      @narrowed_values = lhs_values.merge(rhs_values) { |key, lhs_val, rhs_val|
+      @narrowed_values = lhs_vals.merge(rhs_vals) { |key, lhs_val, rhs_val|
         result = lhs_val.dup
         result.widen_domain!(Operator::EQ, rhs_val)
         result
@@ -760,45 +683,48 @@ module C #:nodoc:
   end
 
   class ValueComparison < ValueDomainNarrowing
-    def initialize(value_domain_manip, node, lhs_narrowing, rhs_narrowing)
+    def initialize(manip, node, lhs_manip, rhs_manip)
       super
-      @operator = ComparisonOperator.new(node.operator)
-      @lhs_narrowing = lhs_narrowing
-      @rhs_narrowing = rhs_narrowing
+      @operator  = ComparisonOperator.new(node.operator)
+      @lhs_manip = lhs_manip
+      @rhs_manip = rhs_manip
     end
 
     private
     def do_narrowing
-      @lhs_narrowing.execute!
-      lhs_var = object_to_variable(@lhs_narrowing.result)
+      @lhs_manip.execute!
+      lhs_var = object_to_variable(@lhs_manip.result)
 
-      @rhs_narrowing.execute!
-      rhs_var = object_to_variable(@rhs_narrowing.result)
+      @rhs_manip.execute!
+      rhs_var = object_to_variable(@rhs_manip.result)
 
       unless lhs_var.type.scalar? && rhs_var.type.scalar?
-        return temporary_variable(int_type)
+        return create_tempvar(int_type)
       end
 
       unless lhs_var.value.scalar? && rhs_var.value.scalar?
-        return temporary_variable(int_type)
+        return create_tempvar(int_type)
       end
 
-      lhs_conv, rhs_conv =
+      lhs_conved, rhs_conved =
         do_logical_arithmetic_conversion(@node, lhs_var, rhs_var)
 
+      lhs_val = lhs_conved.value
+      rhs_val = rhs_conved.value
+
       case @operator
       when Operator::EQ
-        result = temporary_variable(int_type, lhs_conv.value == rhs_conv.value)
+        result = create_tempvar(int_type, lhs_val == rhs_val)
       when Operator::NE
-        result = temporary_variable(int_type, lhs_conv.value != rhs_conv.value)
+        result = create_tempvar(int_type, lhs_val != rhs_val)
       when Operator::LT
-        result = temporary_variable(int_type, lhs_conv.value < rhs_conv.value)
+        result = create_tempvar(int_type, lhs_val <  rhs_val)
       when Operator::GT
-        result = temporary_variable(int_type, lhs_conv.value > rhs_conv.value)
+        result = create_tempvar(int_type, lhs_val >  rhs_val)
       when Operator::LE
-        result = temporary_variable(int_type, lhs_conv.value <= rhs_conv.value)
+        result = create_tempvar(int_type, lhs_val <= rhs_val)
       when Operator::GE
-        result = temporary_variable(int_type, lhs_conv.value >= rhs_conv.value)
+        result = create_tempvar(int_type, lhs_val >= rhs_val)
       else
         __NOTREACHED__
       end
@@ -808,18 +734,18 @@ module C #:nodoc:
 
       case @operator
       when Operator::EQ, Operator::NE
-        notify_equality_expr_evaled(@node, lhs_conv, rhs_conv, result)
+        notify_equality_expr_evaled(@node, lhs_conved, rhs_conved, result)
       when Operator::LT, Operator::GT, Operator::LE, Operator::GE
-        notify_relational_expr_evaled(@node, lhs_conv, rhs_conv, result)
+        notify_relational_expr_evaled(@node, lhs_conved, rhs_conved, result)
       else
         __NOTREACHED__
       end
 
       case
-      when lhs_conv.designated_by_lvalue?
-        ensure_relation(lhs_conv, @operator, rhs_conv.value)
-      when rhs_conv.designated_by_lvalue?
-        ensure_relation(rhs_conv, @operator.for_commutation, lhs_conv.value)
+      when lhs_conved.designated_by_lvalue?
+        ensure_relation(lhs_conved, @operator, rhs_val)
+      when rhs_conved.designated_by_lvalue?
+        ensure_relation(rhs_conved, @operator.for_commutation, lhs_val)
       else
         # NOTE: Domain of the rvalue should not be narrowed.
       end
@@ -829,19 +755,19 @@ module C #:nodoc:
   end
 
   class LogicalAnd < ValueDomainNarrowing
-    def initialize(value_domain_manip, node, lhs_narrowing, rhs_narrowing)
+    def initialize(manip, node, lhs_manip, rhs_manip)
       super
-      @lhs_narrowing = lhs_narrowing
-      @rhs_narrowing = rhs_narrowing
+      @lhs_manip = lhs_manip
+      @rhs_manip = rhs_manip
     end
 
     private
     def do_narrowing
-      @lhs_narrowing.execute!
-      @lhs_narrowing.ensure_result_equal_to(ScalarValue.of_true)
-      lhs_variable = object_to_variable(@lhs_narrowing.result)
+      @lhs_manip.execute!
+      @lhs_manip.ensure_result_equal_to(ScalarValue.of_true)
+      lhs_var = object_to_variable(@lhs_manip.result)
 
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.5.13 Logical AND operator
       #
@@ -854,50 +780,51 @@ module C #:nodoc:
       notify_sequence_point_reached(SequencePoint.new(@node.lhs_operand))
 
       # TODO: Must look about the short-circuit evaluation.
-      @rhs_narrowing.load_original_values!(@lhs_narrowing)
-      @rhs_narrowing.execute!
-      @rhs_narrowing.ensure_result_equal_to(ScalarValue.of_true)
-      rhs_variable = object_to_variable(@rhs_narrowing.result)
+      @rhs_manip.load_original_values!(@lhs_manip)
+      @rhs_manip.execute!
+      @rhs_manip.ensure_result_equal_to(ScalarValue.of_true)
+      rhs_var = object_to_variable(@rhs_manip.result)
 
       notify_sequence_point_reached(SequencePoint.new(@node.rhs_operand))
 
-      narrowing_merge!(@lhs_narrowing, @rhs_narrowing)
-      notify_variable_value_referred(@node, lhs_variable)
-      notify_variable_value_referred(@node, rhs_variable)
+      narrowing_merge!(@lhs_manip, @rhs_manip)
+      notify_variable_value_referred(@node, lhs_var)
+      notify_variable_value_referred(@node, rhs_var)
 
-      unless lhs_variable.type.scalar? && rhs_variable.type.scalar?
-        return temporary_variable(int_type)
+      unless lhs_var.type.scalar? && rhs_var.type.scalar?
+        return create_tempvar(int_type)
       end
 
-      unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
-        return temporary_variable(int_type)
+      unless lhs_var.value.scalar? && rhs_var.value.scalar?
+        return create_tempvar(int_type)
       end
 
-      lhs_converted, rhs_converted =
-        do_logical_arithmetic_conversion(@node, lhs_variable, rhs_variable)
+      lhs_conved, rhs_conved =
+        do_logical_arithmetic_conversion(@node, lhs_var, rhs_var)
+
+      lhs_val = lhs_conved.value
+      rhs_val = rhs_conved.value
 
-      result = temporary_variable(
-        int_type, lhs_converted.value.logical_and(rhs_converted.value))
-      notify_logical_and_expr_evaled(@node,
-                                     lhs_converted, rhs_converted, result)
+      result = create_tempvar(int_type, lhs_val.logical_and(rhs_val))
+      notify_logical_and_expr_evaled(@node, lhs_conved, rhs_conved, result)
       result
     end
   end
 
   class LogicalOr < ValueDomainNarrowing
-    def initialize(value_domain_manip, node, lhs_narrowing, rhs_narrowing)
+    def initialize(manip, node, lhs_manip, rhs_manip)
       super
-      @lhs_narrowing = lhs_narrowing
-      @rhs_narrowing = rhs_narrowing
+      @lhs_manip = lhs_manip
+      @rhs_manip = rhs_manip
     end
 
     private
     def do_narrowing
-      @lhs_narrowing.execute!
-      @lhs_narrowing.ensure_result_equal_to(ScalarValue.of_true)
-      lhs_variable = object_to_variable(@lhs_narrowing.result)
+      @lhs_manip.execute!
+      @lhs_manip.ensure_result_equal_to(ScalarValue.of_true)
+      lhs_var = object_to_variable(@lhs_manip.result)
 
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
       #
       # 6.5.14 Logical OR operator
       #
@@ -912,46 +839,47 @@ module C #:nodoc:
       # TODO: Must look about the short-circuit evaluation.
       # FIXME: Base value of the RHS narrowing should be updated to ensure that
       #        the LHS condition is false.
-      @rhs_narrowing.execute!
-      @rhs_narrowing.ensure_result_equal_to(ScalarValue.of_true)
-      rhs_variable = object_to_variable(@rhs_narrowing.result)
+      @rhs_manip.execute!
+      @rhs_manip.ensure_result_equal_to(ScalarValue.of_true)
+      rhs_var = object_to_variable(@rhs_manip.result)
 
       notify_sequence_point_reached(SequencePoint.new(@node.rhs_operand))
 
-      widening_merge!(@lhs_narrowing, @rhs_narrowing)
-      notify_variable_value_referred(@node, lhs_variable)
-      notify_variable_value_referred(@node, rhs_variable)
+      widening_merge!(@lhs_manip, @rhs_manip)
+      notify_variable_value_referred(@node, lhs_var)
+      notify_variable_value_referred(@node, rhs_var)
 
-      unless lhs_variable.type.scalar? && rhs_variable.type.scalar?
-        return temporary_variable(int_type)
+      unless lhs_var.type.scalar? && rhs_var.type.scalar?
+        return create_tempvar(int_type)
       end
 
-      unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
-        return temporary_variable(int_type)
+      unless lhs_var.value.scalar? && rhs_var.value.scalar?
+        return create_tempvar(int_type)
       end
 
-      lhs_converted, rhs_converted =
-        do_logical_arithmetic_conversion(@node, lhs_variable, rhs_variable)
+      lhs_conved, rhs_conved =
+        do_logical_arithmetic_conversion(@node, lhs_var, rhs_var)
+
+      lhs_val = lhs_conved.value
+      rhs_val = rhs_conved.value
 
-      result = temporary_variable(
-        int_type, lhs_converted.value.logical_or(rhs_converted.value))
-      notify_logical_or_expr_evaled(@node,
-                                    lhs_converted, rhs_converted, result)
+      result = create_tempvar(int_type, lhs_val.logical_or(rhs_val))
+      notify_logical_or_expr_evaled(@node, lhs_conved, rhs_conved, result)
       result
     end
   end
 
   class StrictObjectDerivation < ValueDomainNarrowing
-    def initialize(value_domain_manipulator, node)
-      super(value_domain_manipulator, node)
+    def initialize(manip, node)
+      super(manip, node)
       @object = interpret(node)
     end
 
     private
     def do_narrowing
       if @object.variable? && @object.named?
-        if original_value = original_value_of(@object)
-          @object = PhantomVariable.new(@object, original_value)
+        if orig_val = original_value_of(@object)
+          @object = PhantomVariable.new(@object, orig_val)
         end
       end
       @object
@@ -959,8 +887,8 @@ module C #:nodoc:
   end
 
   class DelayedObjectDerivation < ValueDomainNarrowing
-    def initialize(value_domain_manipulator, node, *children, &block)
-      super(value_domain_manipulator, node, *children)
+    def initialize(manip, node, *children, &block)
+      super(manip, node, *children)
       @block = block
     end
 
@@ -971,36 +899,29 @@ module C #:nodoc:
   end
 
   class PhantomVariable < AliasVariable
-    def initialize(named_variable, phantom_value = nil)
-      super(named_variable)
-
-      @base_variable = named_variable
-      @phantom_value =
-        phantom_value ? phantom_value : named_variable.memory.read.dup
+    def initialize(named_var, phantom_val = nil)
+      super(named_var)
+      @base_var    = named_var
+      @phantom_val = phantom_val ? phantom_val : named_var.memory.read.dup
     end
 
     def value
-      @phantom_value
+      @phantom_val
     end
 
-    def assign!(value)
-      @phantom_value = value
+    def assign!(val)
+      @phantom_val = val
     end
 
     def to_named_variable
-      @base_variable.to_named_variable
+      @base_var.to_named_variable
     end
 
     def pretty_print(pp)
-      Summary.new(object_id, name, type, @phantom_value).pretty_print(pp)
+      Summary.new(object_id, name, type, @phantom_val).pretty_print(pp)
     end
 
     Summary = Struct.new(:object_id, :name, :type, :value)
-
-    private
-    def modifiable_value
-      @phantom_value
-    end
   end
 
 end