adlint 2.6.14 → 3.0.0

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

@@ -1,7 +1,7 @@
 # C conversion semantics.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -30,63 +30,64 @@
 #++
 
 module AdLint #:nodoc:
-module C #:nodoc:
+module Cc1 #:nodoc:
 
-  # Host class of this module must include InterpreterMediator.
   module Conversion
-    def do_conversion(original, to_type)
-      if original.type.coercible?(to_type)
+    # NOTE: Host class of this module must include InterpreterMediator.
+
+    def do_conversion(org_var, to_type)
+      if org_var.type.coercible?(to_type)
         # NOTE: Value will be coerced into the destination type in
-        #       VariableTableMediator#create_tempvar.
-        create_tempvar(to_type, wrap_around_value(original, to_type))
+        #       VariableTableMediator#create_tmpvar.
+        create_tmpvar(to_type, wrap_around_value(org_var, to_type))
       else
         nil
       end
     end
 
-    def do_integer_promotion(original)
-      return original unless original.type.integer?
+    def do_integer_promotion(org_var)
+      return org_var unless org_var.type.integer?
 
-      promoted_type = original.type.integer_promoted_type
-      if original.type.same_as?(promoted_type)
-        original
+      promoted_type = org_var.type.integer_promoted_type
+      if org_var.type.same_as?(promoted_type)
+        org_var
       else
-        do_conversion(original, promoted_type) || original
+        do_conversion(org_var, promoted_type) || org_var
       end
     end
 
-    def do_usual_arithmetic_conversion(lhs_original, rhs_original)
-      if lhs_original.type.pointer? && rhs_original.type.pointer?
-        return lhs_original, rhs_original
+    def do_usual_arithmetic_conversion(lhs_org, rhs_org)
+      if lhs_org.type.pointer? && rhs_org.type.pointer?
+        return lhs_org, rhs_org
       end
 
-      arith_type = lhs_original.type.arithmetic_type_with(rhs_original.type)
+      arith_type = lhs_org.type.arithmetic_type_with(rhs_org.type)
 
-      if lhs_original.type.same_as?(arith_type)
-        lhs_converted = lhs_original
+      if lhs_org.type.same_as?(arith_type)
+        lhs_conved = lhs_org
       else
-        lhs_converted = do_conversion(lhs_original, arith_type) || lhs_original
+        lhs_conved = do_conversion(lhs_org, arith_type) || lhs_org
       end
 
-      if rhs_original.type.same_as?(arith_type)
-        rhs_converted = rhs_original
+      if rhs_org.type.same_as?(arith_type)
+        rhs_conved = rhs_org
       else
-        rhs_converted = do_conversion(rhs_original, arith_type) || rhs_original
+        rhs_conved = do_conversion(rhs_org, arith_type) || rhs_org
       end
 
-      return lhs_converted, rhs_converted
+      return lhs_conved, rhs_conved
     end
 
-    def do_default_argument_promotion(original)
-      promoted_type = original.type.argument_promoted_type
-      if original.type.same_as?(promoted_type)
-        original
+    def do_default_argument_promotion(org_var)
+      promoted_type = org_var.type.argument_promoted_type
+      if org_var.type.same_as?(promoted_type)
+        org_var
       else
-        do_conversion(original, promoted_type) || original
+        do_conversion(org_var, promoted_type) || org_var
       end
     end
 
-    def untyped_pointer_conversion?(from_type, to_type, from_value)
+    def untyped_pointer_conversion?(from_type, to_type, from_val)
       return false unless to_type.pointer?
 
       # NOTE: Untyped pointer conversion is defined as below;
@@ -97,8 +98,8 @@ module C #:nodoc:
       #        void pointer     | non-void pointer | true
       #        non-void pointer | void pointer     | true
       #        non-void pointer | non-void pointer | false
-      #        non-enum integer | void pointer     | from_value == 0
-      #        non-enum integer | non-void pointer | from_value == 0
+      #        non-enum integer | void pointer     | from_val == 0
+      #        non-enum integer | non-void pointer | from_val == 0
       #        enum             | void pointer     | false
       #        enum             | non-void pointer | false
       #        other            | void pointer     | true
@@ -107,41 +108,41 @@ module C #:nodoc:
       when from_type.pointer?
         void_pointer?(from_type) || void_pointer?(to_type)
       when from_type.integer?
-        !from_type.enum? && from_value.must_be_equal_to?(ScalarValue.of(0))
+        !from_type.enum? && from_val.must_be_equal_to?(scalar_value_of(0))
       else
         void_pointer?(to_type)
       end
     end
 
     private
-    def wrap_around_value(original, to_type)
-      return original.value unless original.type.scalar? && to_type.scalar?
+    def wrap_around_value(org_var, to_type)
+      return org_var.value unless org_var.type.scalar? && to_type.scalar?
 
       case
-      when original.type.signed? && to_type.unsigned?
-        min = ScalarValue.of(to_type.min_value)
-        if (original.value < min).may_be_true?
-          return min - original.value + ScalarValue.of(1)
+      when org_var.type.signed? && to_type.unsigned?
+        min_val = scalar_value_of(to_type.min)
+        if (org_var.value < min_val).may_be_true?
+          return min_val - org_var.value + scalar_value_of(1)
         end
-      when original.type.unsigned? && to_type.signed?
-        max = ScalarValue.of(to_type.max_value)
-        if (original.value > max).may_be_true?
-          return max - original.value + ScalarValue.of(1)
+      when org_var.type.unsigned? && to_type.signed?
+        max_val = scalar_value_of(to_type.max)
+        if (org_var.value > max_val).may_be_true?
+          return max_val - org_var.value + scalar_value_of(1)
         end
       end
 
-      original.value
+      org_var.value
     end
 
     def void_pointer?(type)
-      unqualified_type = type.unqualify
-      unqualified_type.pointer? && unqualified_type.base_type.void?
+      unqual_type = type.unqualify
+      unqual_type.pointer? && unqual_type.base_type.void?
     end
   end
 
   # Host class of this module must include StandardTypeCatalogAccessor.
   module UsualArithmeticTypeConversion
-    def do_usual_arithmetic_type_conversion(lhs_type, rhs_type)
+    def do_usual_arithmetic_type_conversion(lhs, rhs)
       # NOTE: The ISO C99 standard says;
       #
       # 6.3.1.8 Usual arithmetic conversions
@@ -194,46 +195,43 @@ module C #:nodoc:
       #       type corresponding to the type of the operand with signed integer
       #       type.
 
-      if lhs_type.same_as?(long_double_type) ||
-          rhs_type.same_as?(long_double_type)
-        return long_double_type
+      if lhs.same_as?(long_double_t) || rhs.same_as?(long_double_t)
+        return long_double_t
       end
 
-      if lhs_type.same_as?(double_type) || rhs_type.same_as?(double_type)
-        return double_type
+      if lhs.same_as?(double_t) || rhs.same_as?(double_t)
+        return double_t
       end
 
-      if lhs_type.same_as?(float_type) || rhs_type.same_as?(float_type)
-        return float_type
+      if lhs.same_as?(float_t) || rhs.same_as?(float_t)
+        return float_t
       end
 
-      lhs_promoted_type = lhs_type.integer_promoted_type
-      rhs_promoted_type = rhs_type.integer_promoted_type
+      lhs_promoted = lhs.integer_promoted_type
+      rhs_promoted = rhs.integer_promoted_type
 
-      return lhs_promoted_type if lhs_promoted_type.same_as?(rhs_promoted_type)
+      return lhs_promoted if lhs_promoted.same_as?(rhs_promoted)
 
-      lhs_rank = lhs_promoted_type.integer_conversion_rank
-      rhs_rank = rhs_promoted_type.integer_conversion_rank
+      lhs_rank = lhs_promoted.integer_conversion_rank
+      rhs_rank = rhs_promoted.integer_conversion_rank
 
       case
-      when lhs_promoted_type.signed? && rhs_promoted_type.signed?
-        return lhs_rank < rhs_rank ? rhs_promoted_type : lhs_promoted_type
-      when lhs_promoted_type.unsigned? && rhs_promoted_type.unsigned?
-        return lhs_rank < rhs_rank ? rhs_promoted_type : lhs_promoted_type
-      when lhs_promoted_type.unsigned? && lhs_rank >= rhs_rank
-        return lhs_promoted_type
-      when rhs_promoted_type.unsigned? && lhs_rank <= rhs_rank
-        return rhs_promoted_type
-      when lhs_promoted_type.signed? &&
-           rhs_promoted_type.compatible?(lhs_promoted_type)
-        return lhs_promoted_type
-      when rhs_promoted_type.signed? &&
-           lhs_promoted_type.compatible?(rhs_promoted_type)
-        return rhs_promoted_type
-      when lhs_promoted_type.signed?
-        return lhs_promoted_type.corresponding_unsigned_type
-      when rhs_promoted_type.signed?
-        return rhs_promoted_type.corresponding_unsigned_type
+      when lhs_promoted.signed? && rhs_promoted.signed?
+        return lhs_rank < rhs_rank ? rhs_promoted : lhs_promoted
+      when lhs_promoted.unsigned? && rhs_promoted.unsigned?
+        return lhs_rank < rhs_rank ? rhs_promoted : lhs_promoted
+      when lhs_promoted.unsigned? && lhs_rank >= rhs_rank
+        return lhs_promoted
+      when rhs_promoted.unsigned? && lhs_rank <= rhs_rank
+        return rhs_promoted
+      when lhs_promoted.signed? && rhs_promoted.compatible?(lhs_promoted)
+        return lhs_promoted
+      when rhs_promoted.signed? && lhs_promoted.compatible?(rhs_promoted)
+        return rhs_promoted
+      when lhs_promoted.signed?
+        return lhs_promoted.corresponding_unsigned_type
+      when rhs_promoted.signed?
+        return rhs_promoted.corresponding_unsigned_type
       end
 
       raise TypeError, "cannot do usual arithmetic conversion."

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

@@ -1,7 +1,7 @@
 # Controlling expression of selection-statements and iteration-statements.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -29,16 +29,16 @@
 #
 #++
 
-require "adlint/c/syntax"
-require "adlint/c/object"
-require "adlint/c/mediator"
-require "adlint/c/expr"
-require "adlint/c/conv"
-require "adlint/c/operator"
-require "adlint/c/seqp"
+require "adlint/cc1/syntax"
+require "adlint/cc1/object"
+require "adlint/cc1/mediator"
+require "adlint/cc1/expr"
+require "adlint/cc1/conv"
+require "adlint/cc1/operator"
+require "adlint/cc1/seqp"
 
 module AdLint #:nodoc:
-module C #:nodoc:
+module Cc1 #:nodoc:
 
   # == DESCRIPTION
   # === Class structure
@@ -59,15 +59,15 @@ module C #:nodoc:
   class ControllingExpression
     include SyntaxNodeCollector
 
-    def initialize(interpreter, branch, target_expr = nil)
-      @interpreter  = interpreter
+    def initialize(interp, branch, target_expr = nil)
+      @interpreter  = interp
       @branch       = branch
       @target_expr  = target_expr
       @manipulators = []
     end
 
     def ensure_true_by_narrowing(alt_expr = nil)
-      target_expr = alt_expr ? alt_expr : @target_expr
+      target_expr = alt_expr || @target_expr
 
       if target_expr
         new_manip = ValueDomainNarrower.new(@interpreter, target_expr)
@@ -85,7 +85,7 @@ module C #:nodoc:
     end
 
     def ensure_true_by_widening(alt_expr = nil)
-      target_expr = alt_expr ? alt_expr : @target_expr
+      target_expr = alt_expr || @target_expr
 
       if target_expr
         new_manip = ValueDomainWidener.new(@interpreter, target_expr)
@@ -145,8 +145,8 @@ module C #:nodoc:
     include ExpressionEvaluator::Impl
     include MonitorUtil
 
-    def initialize(interpreter, target_expr)
-      @interpreter        = interpreter
+    def initialize(interp, target_expr)
+      @interpreter        = interp
       @target_expr        = target_expr
       @affected_variables = []
       @narrowing          = nil
@@ -165,7 +165,7 @@ module C #:nodoc:
 
     def commit!
       if @narrowing
-        @narrowing.ensure_result_equal_to(ScalarValue.of_true)
+        @narrowing.ensure_result_equal_to(scalar_value_of_true)
       end
 
       commit_changes(@narrowing)
@@ -179,7 +179,7 @@ module C #:nodoc:
     def rollback!
       # NOTE: Rollback narrowed version to cut out the value-domain to enter
       #       the current branch.
-      @affected_variables.each { |variable| variable.value.rollback! }
+      @affected_variables.each { |var| var.value.rollback! }
     end
 
     def save!
@@ -213,8 +213,7 @@ module C #:nodoc:
 
     def visit_array_subscript_expression(node)
       checkpoint(node.location)
-
-      obj_manip = node.expression.accept(self)
+      obj_manip  = node.expression.accept(self)
       subs_manip = node.array_subscript.accept(self)
 
       DelayedObjectDerivation.new(self, node, obj_manip, subs_manip) do
@@ -227,7 +226,6 @@ module C #:nodoc:
 
     def visit_function_call_expression(node)
       checkpoint(node.location)
-
       obj_manip  = node.expression.accept(self)
       arg_manips = node.argument_expressions.map { |expr| expr.accept(self) }
 
@@ -241,7 +239,6 @@ module C #:nodoc:
 
     def visit_member_access_by_value_expression(node)
       checkpoint(node.location)
-
       obj_manip = node.expression.accept(self)
 
       DelayedObjectDerivation.new(self, node, obj_manip) do
@@ -253,7 +250,6 @@ module C #:nodoc:
 
     def visit_member_access_by_pointer_expression(node)
       checkpoint(node.location)
-
       obj_manip = node.expression.accept(self)
 
       DelayedObjectDerivation.new(self, node, obj_manip) do
@@ -268,7 +264,6 @@ module C #:nodoc:
 
     def visit_postfix_increment_expression(node)
       checkpoint(node.location)
-
       obj_manip = node.operand.accept(self)
 
       DelayedObjectDerivation.new(self, node, obj_manip) do
@@ -280,7 +275,6 @@ module C #:nodoc:
 
     def visit_postfix_decrement_expression(node)
       checkpoint(node.location)
-
       obj_manip = node.operand.accept(self)
 
       DelayedObjectDerivation.new(self, node, obj_manip) do
@@ -294,7 +288,6 @@ module C #:nodoc:
 
     def visit_prefix_increment_expression(node)
       checkpoint(node.location)
-
       obj_manip = node.operand.accept(self)
 
       DelayedObjectDerivation.new(self, node, obj_manip) do
@@ -306,7 +299,6 @@ module C #:nodoc:
 
     def visit_prefix_decrement_expression(node)
       checkpoint(node.location)
-
       obj_manip = node.operand.accept(self)
 
       DelayedObjectDerivation.new(self, node, obj_manip) do
@@ -320,7 +312,6 @@ module C #:nodoc:
 
     def visit_indirection_expression(node)
       checkpoint(node.location)
-
       obj_manip = node.operand.accept(self)
 
       DelayedObjectDerivation.new(self, node, obj_manip) do
@@ -332,7 +323,6 @@ module C #:nodoc:
 
     def visit_unary_arithmetic_expression(node)
       checkpoint(node.location)
-
       obj_manip = node.operand.accept(self)
 
       DelayedObjectDerivation.new(self, node, obj_manip) do
@@ -349,7 +339,6 @@ module C #:nodoc:
 
     def visit_cast_expression(node)
       checkpoint(node.location)
-
       obj_manip = node.operand.accept(self)
 
       DelayedObjectDerivation.new(self, node, obj_manip) do
@@ -361,7 +350,6 @@ module C #:nodoc:
 
     def visit_multiplicative_expression(node)
       checkpoint(node.location)
-
       lhs_manip = node.lhs_operand.accept(self)
       rhs_manip = node.rhs_operand.accept(self)
 
@@ -375,7 +363,6 @@ module C #:nodoc:
 
     def visit_additive_expression(node)
       checkpoint(node.location)
-
       lhs_manip = node.lhs_operand.accept(self)
       rhs_manip = node.rhs_operand.accept(self)
 
@@ -389,7 +376,6 @@ module C #:nodoc:
 
     def visit_shift_expression(node)
       checkpoint(node.location)
-
       lhs_manip = node.lhs_operand.accept(self)
       rhs_manip = node.rhs_operand.accept(self)
 
@@ -415,7 +401,6 @@ module C #:nodoc:
 
     def visit_and_expression(node)
       checkpoint(node.location)
-
       lhs_manip = node.lhs_operand.accept(self)
       rhs_manip = node.rhs_operand.accept(self)
 
@@ -429,7 +414,6 @@ module C #:nodoc:
 
     def visit_exclusive_or_expression(node)
       checkpoint(node.location)
-
       lhs_manip = node.lhs_operand.accept(self)
       rhs_manip = node.rhs_operand.accept(self)
 
@@ -443,7 +427,6 @@ module C #:nodoc:
 
     def visit_inclusive_or_expression(node)
       checkpoint(node.location)
-
       lhs_manip = node.lhs_operand.accept(self)
       rhs_manip = node.rhs_operand.accept(self)
 
@@ -471,7 +454,6 @@ module C #:nodoc:
 
     def visit_simple_assignment_expression(node)
       checkpoint(node.location)
-
       lhs_manip = node.lhs_operand.accept(self)
       rhs_manip = node.rhs_operand.accept(self)
 
@@ -485,7 +467,6 @@ module C #:nodoc:
 
     def visit_compound_assignment_expression(node)
       checkpoint(node.location)
-
       lhs_manip = node.lhs_operand.accept(self)
       rhs_manip = node.rhs_operand.accept(self)
 
@@ -499,7 +480,6 @@ module C #:nodoc:
 
     def visit_comma_separated_expression(node)
       checkpoint(node.location)
-
       obj_manips = node.expressions.map { |expr| expr.accept(self) }
 
       DelayedObjectDerivation.new(self, node, *obj_manips) do
@@ -512,6 +492,11 @@ module C #:nodoc:
     def commit_changes(manip)
       subclass_responsibility
     end
+
+    extend Forwardable
+
+    def_delegator :@interpreter, :monitor
+    private :monitor
   end
 
   class ValueDomainNarrower < ValueDomainManipulator
@@ -533,9 +518,9 @@ module C #:nodoc:
   end
 
   class NilValueDomainNarrower < ValueDomainManipulator
-    def initialize(interpreter, branch_group)
-      super(interpreter, nil)
-      @branch_group = branch_group
+    def initialize(interp, br_group)
+      super(interp, nil)
+      @branch_group = br_group
     end
 
     def prepare!
@@ -552,9 +537,9 @@ module C #:nodoc:
   end
 
   class NilValueDomainWidener < ValueDomainManipulator
-    def initialize(interpreter, branch_group)
-      super(interpreter, nil)
-      @branch_group = branch_group
+    def initialize(interp, br_group)
+      super(interp, nil)
+      @branch_group = br_group
     end
 
     def prepare!
@@ -599,8 +584,8 @@ module C #:nodoc:
         @narrowed_values = manip.narrowed_values.merge(@narrowed_values)
       end
     ensure
-      if result && result.variable?
-        notify_variable_value_referred(node, result)
+      if @result && @result.variable?
+        notify_variable_value_referred(node, @result)
       end
       if seqp = node.subsequent_sequence_point
         notify_sequence_point_reached(seqp)
@@ -663,9 +648,9 @@ module C #:nodoc:
       rhs_vals = rhs_manip.narrowed_values
 
       @narrowed_values = lhs_vals.merge(rhs_vals) { |key, lhs_val, rhs_val|
-        result = lhs_val.dup
-        result.narrow_domain!(Operator::EQ, rhs_val)
-        result
+        res_val = lhs_val.dup
+        res_val.narrow_domain!(Operator::EQ, rhs_val)
+        res_val
       }
     end
 
@@ -674,18 +659,16 @@ module C #:nodoc:
       rhs_vals = rhs_manip.narrowed_values
 
       @narrowed_values = lhs_vals.merge(rhs_vals) { |key, lhs_val, rhs_val|
-        result = lhs_val.dup
-        result.widen_domain!(Operator::EQ, rhs_val)
-        result
+        res_val = lhs_val.dup
+        res_val.widen_domain!(Operator::EQ, rhs_val)
+        res_val
       }
     end
 
-    def interpreter
-      # NOTE: This is private attr_reader for InterpreterMediator.
-      #       This attribute is read via a normal method to suppress
-      #       `private attribute?' warning.
-      @manipulator.interpreter
-    end
+    extend Forwardable
+
+    def_delegator :@manipulator, :interpreter
+    private :interpreter
   end
 
   class ValueComparison < ValueDomainNarrowing
@@ -705,11 +688,11 @@ module C #:nodoc:
       rhs_var = object_to_variable(@rhs_manip.result)
 
       unless lhs_var.type.scalar? && rhs_var.type.scalar?
-        return create_tempvar(int_type)
+        return create_tmpvar(int_t)
       end
 
       unless lhs_var.value.scalar? && rhs_var.value.scalar?
-        return create_tempvar(int_type)
+        return create_tmpvar(int_t)
       end
 
       lhs_conved, rhs_conved =
@@ -720,17 +703,17 @@ module C #:nodoc:
 
       case @operator
       when Operator::EQ
-        result = create_tempvar(int_type, lhs_val == rhs_val)
+        res_var = create_tmpvar(int_t, lhs_val == rhs_val)
       when Operator::NE
-        result = create_tempvar(int_type, lhs_val != rhs_val)
+        res_var = create_tmpvar(int_t, lhs_val != rhs_val)
       when Operator::LT
-        result = create_tempvar(int_type, lhs_val <  rhs_val)
+        res_var = create_tmpvar(int_t, lhs_val <  rhs_val)
       when Operator::GT
-        result = create_tempvar(int_type, lhs_val >  rhs_val)
+        res_var = create_tmpvar(int_t, lhs_val >  rhs_val)
       when Operator::LE
-        result = create_tempvar(int_type, lhs_val <= rhs_val)
+        res_var = create_tmpvar(int_t, lhs_val <= rhs_val)
       when Operator::GE
-        result = create_tempvar(int_type, lhs_val >= rhs_val)
+        res_var = create_tmpvar(int_t, lhs_val >= rhs_val)
       else
         __NOTREACHED__
       end
@@ -740,9 +723,9 @@ module C #:nodoc:
 
       case @operator
       when Operator::EQ, Operator::NE
-        notify_equality_expr_evaled(@node, lhs_conved, rhs_conved, result)
+        notify_equality_expr_evaled(@node, lhs_conved, rhs_conved, res_var)
       when Operator::LT, Operator::GT, Operator::LE, Operator::GE
-        notify_relational_expr_evaled(@node, lhs_conved, rhs_conved, result)
+        notify_relational_expr_evaled(@node, lhs_conved, rhs_conved, res_var)
       else
         __NOTREACHED__
       end
@@ -756,7 +739,7 @@ module C #:nodoc:
         # NOTE: Domain of the rvalue should not be narrowed.
       end
 
-      result
+      res_var
     end
   end
 
@@ -770,7 +753,7 @@ module C #:nodoc:
     private
     def do_narrowing
       @lhs_manip.execute!
-      @lhs_manip.ensure_result_equal_to(ScalarValue.of_true)
+      @lhs_manip.ensure_result_equal_to(scalar_value_of_true)
       lhs_var = object_to_variable(@lhs_manip.result)
 
       # NOTE: The ISO C99 standard says;
@@ -788,7 +771,7 @@ module C #:nodoc:
       # TODO: Must look about the short-circuit evaluation.
       @rhs_manip.load_original_values!(@lhs_manip)
       @rhs_manip.execute!
-      @rhs_manip.ensure_result_equal_to(ScalarValue.of_true)
+      @rhs_manip.ensure_result_equal_to(scalar_value_of_true)
       rhs_var = object_to_variable(@rhs_manip.result)
 
       notify_sequence_point_reached(SequencePoint.new(@node.rhs_operand))
@@ -798,11 +781,11 @@ module C #:nodoc:
       notify_variable_value_referred(@node, rhs_var)
 
       unless lhs_var.type.scalar? && rhs_var.type.scalar?
-        return create_tempvar(int_type)
+        return create_tmpvar(int_t)
       end
 
       unless lhs_var.value.scalar? && rhs_var.value.scalar?
-        return create_tempvar(int_type)
+        return create_tmpvar(int_t)
       end
 
       lhs_conved, rhs_conved =
@@ -811,9 +794,9 @@ module C #:nodoc:
       lhs_val = lhs_conved.value
       rhs_val = rhs_conved.value
 
-      result = create_tempvar(int_type, lhs_val.logical_and(rhs_val))
-      notify_logical_and_expr_evaled(@node, lhs_conved, rhs_conved, result)
-      result
+      res_var = create_tmpvar(int_t, lhs_val.logical_and(rhs_val))
+      notify_logical_and_expr_evaled(@node, lhs_conved, rhs_conved, res_var)
+      res_var
     end
   end
 
@@ -827,7 +810,7 @@ module C #:nodoc:
     private
     def do_narrowing
       @lhs_manip.execute!
-      @lhs_manip.ensure_result_equal_to(ScalarValue.of_true)
+      @lhs_manip.ensure_result_equal_to(scalar_value_of_true)
       lhs_var = object_to_variable(@lhs_manip.result)
 
       # NOTE: The ISO C99 standard says;
@@ -846,7 +829,7 @@ module C #:nodoc:
       # FIXME: Base value of the RHS narrowing should be updated to ensure that
       #        the LHS condition is false.
       @rhs_manip.execute!
-      @rhs_manip.ensure_result_equal_to(ScalarValue.of_true)
+      @rhs_manip.ensure_result_equal_to(scalar_value_of_true)
       rhs_var = object_to_variable(@rhs_manip.result)
 
       notify_sequence_point_reached(SequencePoint.new(@node.rhs_operand))
@@ -856,11 +839,11 @@ module C #:nodoc:
       notify_variable_value_referred(@node, rhs_var)
 
       unless lhs_var.type.scalar? && rhs_var.type.scalar?
-        return create_tempvar(int_type)
+        return create_tmpvar(int_t)
       end
 
       unless lhs_var.value.scalar? && rhs_var.value.scalar?
-        return create_tempvar(int_type)
+        return create_tmpvar(int_t)
       end
 
       lhs_conved, rhs_conved =
@@ -869,9 +852,9 @@ module C #:nodoc:
       lhs_val = lhs_conved.value
       rhs_val = rhs_conved.value
 
-      result = create_tempvar(int_type, lhs_val.logical_or(rhs_val))
-      notify_logical_or_expr_evaled(@node, lhs_conved, rhs_conved, result)
-      result
+      res_var = create_tmpvar(int_t, lhs_val.logical_or(rhs_val))
+      notify_logical_or_expr_evaled(@node, lhs_conved, rhs_conved, res_var)
+      res_var
     end
   end
 
@@ -884,8 +867,8 @@ module C #:nodoc:
     private
     def do_narrowing
       if @object.variable? && @object.named?
-        if orig_val = original_value_of(@object)
-          @object = PhantomVariable.new(@object, orig_val)
+        if org_val = original_value_of(@object)
+          @object = PhantomVariable.new(@object, org_val)
         end
       end
       @object