adlint 2.6.14 → 3.0.0

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

@@ -1,7 +1,7 @@
 # Miscellaneous utilities for C language.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -30,7 +30,7 @@
 #++
 
 module AdLint #:nodoc:
-module C #:nodoc:
+module Cc1 #:nodoc:
 
   class EscapeSequence
     def initialize(str)
@@ -66,21 +66,29 @@ module C #:nodoc:
   end
 
   module DebugUtil
-    def dump_syntax_tree(context)
-      return unless $DEBUG
+    def dump_syntax_tree(phase_ctxt)
+      if $DEBUG
+        ast_fname = phase_ctxt[:sources].first.fpath.basename.add_ext(".ast")
+        ast_fpath = ast_fname.expand_path(phase_ctxt.msg_fpath.dirname)
 
-      File.open(context[:sources].first.fpath.add_ext(".ast"), "w") do |io|
-        PP.pp(context[:c_syntax_tree], io)
+        File.open(ast_fpath, "w") do |io|
+          if phase_ctxt[:cc1_syntax_tree]
+            PP.pp(phase_ctxt[:cc1_syntax_tree], io)
+          end
+        end
       end
     end
     module_function :dump_syntax_tree
 
-    def dump_token_array(context)
-      return unless $DEBUG
+    def dump_token_array(phase_ctxt)
+      if $DEBUG
+        tok_fname = phase_ctxt[:sources].first.fpath.basename.add_ext(".tok")
+        tok_fpath = tok_fname.expand_path(phase_ctxt.msg_fpath.dirname)
 
-      File.open(context[:sources].first.fpath.add_ext(".tok"), "w") do |io|
-        if context[:c_token_array]
-          context[:c_token_array].each { |t| io.puts(t.inspect) }
+        File.open(tok_fpath, "w") do |io|
+          if phase_ctxt[:cc1_token_array]
+            phase_ctxt[:cc1_token_array].each { |tok| io.puts(tok.inspect) }
+          end
         end
       end
     end

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

@@ -1,7 +1,7 @@
 # Values associated with memory blocks.
 #
 # 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,11 +29,11 @@
 #
 #++
 
-require "adlint/c/domain"
-require "adlint/c/operator"
+require "adlint/cc1/domain"
+require "adlint/cc1/operator"
 
 module AdLint #:nodoc:
-module C #:nodoc:
+module Cc1 #:nodoc:
 
   module BuggyValueSampler
     def unique_sample
@@ -46,12 +46,12 @@ module C #:nodoc:
   # == DESCRIPTION
   # === Value class hierarchy
   #  Value
-  #    <--- SingleValue
-  #           <--- ScalarValue
-  #           <--- ArrayValue
-  #           <--- CompositeValue
-  #    <--- MultipleValue
-  #           <--- VersionedValue
+  #    <-- SingleValue
+  #          <-- ScalarValue
+  #          <-- ArrayValue
+  #          <-- CompositeValue
+  #    <-- MultipleValue
+  #          <-- VersionedValue
   class Value
     include BuggyValueSampler
 
@@ -83,7 +83,7 @@ module C #:nodoc:
       subclass_responsibility
     end
 
-    def contain?(value)
+    def contain?(val)
       subclass_responsibility
     end
 
@@ -91,15 +91,15 @@ module C #:nodoc:
       subclass_responsibility
     end
 
-    def overwrite!(value)
+    def overwrite!(val)
       subclass_responsibility
     end
 
-    def narrow_domain!(operator, operand_value)
+    def narrow_domain!(op, ope_val)
       subclass_responsibility
     end
 
-    def widen_domain!(operator, operand_value)
+    def widen_domain!(op, ope_val)
       subclass_responsibility
     end
 
@@ -107,7 +107,7 @@ module C #:nodoc:
       subclass_responsibility
     end
 
-    def single_value_unified_with(rhs_value)
+    def single_value_unified_with(rhs_val)
       subclass_responsibility
     end
 
@@ -123,43 +123,43 @@ module C #:nodoc:
       subclass_responsibility
     end
 
-    def +(rhs_value)
+    def +(rhs_val)
       subclass_responsibility
     end
 
-    def -(rhs_value)
+    def -(rhs_val)
       subclass_responsibility
     end
 
-    def *(rhs_value)
+    def *(rhs_val)
       subclass_responsibility
     end
 
-    def /(rhs_value)
+    def /(rhs_val)
       subclass_responsibility
     end
 
-    def %(rhs_value)
+    def %(rhs_val)
       subclass_responsibility
     end
 
-    def &(rhs_value)
+    def &(rhs_val)
       subclass_responsibility
     end
 
-    def |(rhs_value)
+    def |(rhs_val)
       subclass_responsibility
     end
 
-    def ^(rhs_value)
+    def ^(rhs_val)
       subclass_responsibility
     end
 
-    def <<(rhs_value)
+    def <<(rhs_val)
       subclass_responsibility
     end
 
-    def >>(rhs_value)
+    def >>(rhs_val)
       subclass_responsibility
     end
 
@@ -167,69 +167,69 @@ module C #:nodoc:
       subclass_responsibility
     end
 
-    def <(rhs_value)
+    def <(rhs_val)
       subclass_responsibility
     end
 
-    def >(rhs_value)
+    def >(rhs_val)
       subclass_responsibility
     end
 
-    def ==(rhs_value)
+    def ==(rhs_val)
       subclass_responsibility
     end
 
-    def !=(rhs_value)
+    def !=(rhs_val)
       subclass_responsibility
     end
 
-    def <=(rhs_value)
+    def <=(rhs_val)
       subclass_responsibility
     end
 
-    def >=(rhs_value)
+    def >=(rhs_val)
       subclass_responsibility
     end
 
-    def logical_and(rhs_value)
+    def logical_and(rhs_val)
       # NOTE: Operator && cannot be defined as a method in Ruby.
       subclass_responsibility
     end
 
-    def logical_or(rhs_value)
+    def logical_or(rhs_val)
       # NOTE: Operator || cannot be defined as a method in Ruby.
       subclass_responsibility
     end
 
-    def must_be_equal_to?(value)
+    def must_be_equal_to?(val)
       subclass_responsibility
     end
 
-    def may_be_equal_to?(value)
+    def may_be_equal_to?(val)
       subclass_responsibility
     end
 
-    def must_not_be_equal_to?(value)
+    def must_not_be_equal_to?(val)
       subclass_responsibility
     end
 
-    def may_not_be_equal_to?(value)
+    def may_not_be_equal_to?(val)
       subclass_responsibility
     end
 
-    def must_be_less_than?(value)
+    def must_be_less_than?(val)
       subclass_responsibility
     end
 
-    def may_be_less_than?(value)
+    def may_be_less_than?(val)
       subclass_responsibility
     end
 
-    def must_be_greater_than?(value)
+    def must_be_greater_than?(val)
       subclass_responsibility
     end
 
-    def may_be_greater_than?(value)
+    def may_be_greater_than?(val)
       subclass_responsibility
     end
 
@@ -273,7 +273,7 @@ module C #:nodoc:
       subclass_responsibility
     end
 
-    def eql?(rhs_value)
+    def eql?(rhs_val)
       subclass_responsibility
     end
 
@@ -305,58 +305,87 @@ module C #:nodoc:
     def to_single_value
       self
     end
+
+    private
+    def scalar_value_of_true
+      ScalarValue.of_true(logical_shr?)
+    end
+
+    def scalar_value_of_false
+      ScalarValue.of_false(logical_shr?)
+    end
+
+    def scalar_value_of_nil
+      ScalarValue.of_nil(logical_shr?)
+    end
+
+    def logical_shr?
+      subclass_responsibility
+    end
   end
 
-  class ScalarValue < SingleValue
-    def self.of(numeric_or_range)
+  module ScalarValueFactory
+    def of(numeric_or_range, logical_shr)
       case numeric_or_range
       when Numeric
-        new(ValueDomain.equal_to(numeric_or_range))
+        new(ValueDomain.equal_to(numeric_or_range, logical_shr))
       when Range
-        lower = ValueDomain.greater_than_or_equal_to(numeric_or_range.first)
-        higher = ValueDomain.less_than_or_equal_to(numeric_or_range.last)
-        new(lower.intersection(higher))
+        new(ValueDomain.greater_than_or_equal_to(
+          numeric_or_range.first, logical_shr
+        ).intersection(ValueDomain.less_than_or_equal_to(
+          numeric_or_range.last, logical_shr
+        )))
       else
         raise TypeError, "argument must be a Numeric or a Range."
       end
     end
 
-    def self.not_of(numeric_or_range)
+    def not_of(numeric_or_range, logical_shr)
       case numeric_or_range
       when Numeric
-        new(ValueDomain.not_equal_to(numeric_or_range))
+        new(ValueDomain.not_equal_to(numeric_or_range, logical_shr))
       when Range
-        lower = ValueDomain.less_than(numeric_or_range.first)
-        higher = ValueDomain.greater_than(numeric_or_range.last)
-        new(lower.union(higher))
+        new(ValueDomain.less_than(
+          numeric_or_range.first, logical_shr
+        ).union(ValueDomain.greater_than(
+          numeric_or_range.last, logical_shr
+        )))
       else
         raise TypeError, "argument must be a Numeric or a Range."
       end
     end
 
-    def self.of_true
-      not_of(0)
+    def of_true(logical_shr)
+      not_of(0, logical_shr)
     end
 
-    def self.of_false
-      of(0)
+    def of_false(logical_shr)
+      of(0, logical_shr)
     end
 
-    def self.of_arbitrary
-      new(ValueDomain.of_unlimited)
+    def of_arbitrary(logical_shr)
+      new(ValueDomain.of_unlimited(logical_shr))
     end
 
-    def self.of_undefined(range)
-      new(ValueDomain.of_undefined(range))
+    def of_undefined(range, logical_shr)
+      new(ValueDomain.of_undefined(ValueDomain.greater_than_or_equal_to(
+        range.first, logical_shr
+      ).intersection(ValueDomain.less_than_or_equal_to(
+        range.last, logical_shr
+      ))))
     end
 
-    def self.of_nil
-      new(ValueDomain.of_nil)
+    def of_nil(logical_shr)
+      new(ValueDomain.of_nil(logical_shr))
     end
 
-    def self.of_nan
-      new(ValueDomain.of_nan)
+    def of_nan(logical_shr)
+      new(ValueDomain.of_nan(logical_shr))
     end
+  end
+
+  class ScalarValue < SingleValue
+    extend ScalarValueFactory
 
     def initialize(domain)
       @domain = domain
@@ -382,10 +411,10 @@ module C #:nodoc:
       @domain.kind_of?(EqualToValueDomain)
     end
 
-    def contain?(value)
-      case single_value = value.to_single_value
+    def contain?(val)
+      case single_val = val.to_single_value
       when ScalarValue
-        @domain.contain?(single_value.domain)
+        @domain.contain?(single_val.domain)
       else
         false
       end
@@ -399,32 +428,32 @@ module C #:nodoc:
       @domain.ambiguous?
     end
 
-    def overwrite!(value)
-      case single_value = value.to_single_value
+    def overwrite!(val)
+      case single_val = val.to_single_value
       when ScalarValue
-        @domain = single_value.domain
+        @domain = single_val.domain
       else
         raise TypeError, "cannot overwrite scalar with non-scalar."
       end
     end
 
-    def narrow_domain!(operator, operand_value)
-      case operand_single_value = operand_value.to_single_value
+    def narrow_domain!(op, ope_val)
+      case ope_single_val = ope_val.to_single_value
       when ScalarValue
-        orig_domain = @domain
-        @domain = @domain.narrow(operator, operand_single_value.domain)
-        !@domain.equal?(orig_domain)
+        org_dom = @domain
+        @domain = @domain.narrow(op, ope_single_val.domain)
+        !@domain.equal?(org_dom)
       else
         raise TypeError, "cannot narrow scalar value domain with non-scalar."
       end
     end
 
-    def widen_domain!(operator, operand_value)
-      case operand_single_value = operand_value.to_single_value
+    def widen_domain!(op, ope_val)
+      case ope_single_val = ope_val.to_single_value
       when ScalarValue
-        orig_domain = @domain
-        @domain = @domain.widen(operator, operand_single_value.domain)
-        !@domain.equal?(orig_domain)
+        org_dom = @domain
+        @domain = @domain.widen(op, ope_single_val.domain)
+        !@domain.equal?(org_dom)
       else
         raise TypeError, "cannot widen scalar value domain with non-scalar."
       end
@@ -434,10 +463,10 @@ module C #:nodoc:
       @domain = @domain.inversion
     end
 
-    def single_value_unified_with(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def single_value_unified_with(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain.union(rhs_single_value.domain))
+        ScalarValue.new(@domain.union(rhs_single_val.domain))
       else
         raise TypeError, "cannot unify scalar value with non-scalar."
       end
@@ -455,91 +484,91 @@ module C #:nodoc:
       ScalarValue.new(-@domain)
     end
 
-    def +(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def +(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain + rhs_single_value.domain)
+        ScalarValue.new(@domain + rhs_single_val.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
-    def -(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def -(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain - rhs_single_value.domain)
+        ScalarValue.new(@domain - rhs_single_val.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
-    def *(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def *(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain * rhs_single_value.domain)
+        ScalarValue.new(@domain * rhs_single_val.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
-    def /(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def /(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain / rhs_single_value.domain)
+        ScalarValue.new(@domain / rhs_single_val.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
-    def %(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def %(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain % rhs_single_value.domain)
+        ScalarValue.new(@domain % rhs_single_val.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
-    def &(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def &(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain & rhs_single_value.domain)
+        ScalarValue.new(@domain & rhs_single_val.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
-    def |(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def |(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain | rhs_single_value.domain)
+        ScalarValue.new(@domain | rhs_single_val.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
-    def ^(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def ^(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain ^ rhs_single_value.domain)
+        ScalarValue.new(@domain ^ rhs_single_val.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
-    def <<(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def <<(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain << rhs_single_value.domain)
+        ScalarValue.new(@domain << rhs_single_val.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
     end
 
-    def >>(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def >>(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain >> rhs_single_value.domain)
+        ScalarValue.new(@domain >> rhs_single_val.domain)
       else
         raise TypeError, "binary operation between scalar and non-scalar."
       end
@@ -549,177 +578,177 @@ module C #:nodoc:
       ScalarValue.new(!@domain)
     end
 
-    def <(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def <(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain < rhs_single_value.domain)
+        ScalarValue.new(@domain < rhs_single_val.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def >(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def >(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain > rhs_single_value.domain)
+        ScalarValue.new(@domain > rhs_single_val.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def ==(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def ==(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain == rhs_single_value.domain)
+        ScalarValue.new(@domain == rhs_single_val.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def !=(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def !=(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain != rhs_single_value.domain)
+        ScalarValue.new(@domain != rhs_single_val.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def <=(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def <=(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain <= rhs_single_value.domain)
+        ScalarValue.new(@domain <= rhs_single_val.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def >=(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def >=(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain >= rhs_single_value.domain)
+        ScalarValue.new(@domain >= rhs_single_val.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def logical_and(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def logical_and(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain.logical_and(rhs_single_value.domain))
+        ScalarValue.new(@domain.logical_and(rhs_single_val.domain))
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def logical_or(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def logical_or(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ScalarValue
-        ScalarValue.new(@domain.logical_or(rhs_single_value.domain))
+        ScalarValue.new(@domain.logical_or(rhs_single_val.domain))
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def must_be_equal_to?(value)
-      case single_value = value.to_single_value.dup
+    def must_be_equal_to?(val)
+      case single_val = val.to_single_value.dup
       when ScalarValue
-        comp_result = (self == single_value)
-        single_value.invert_domain!
-        single_value.narrow_domain!(Operator::EQ, self)
-        comp_result.domain.intersect?(ScalarValue.of_true.domain) &&
-          !comp_result.domain.contain?(ScalarValue.of_false.domain) &&
-          !@domain.intersect?(single_value.domain)
+        comp_val = (self == single_val)
+        single_val.invert_domain!
+        single_val.narrow_domain!(Operator::EQ, self)
+        comp_val.domain.intersect?(scalar_value_of_true.domain) &&
+          !comp_val.domain.contain?(scalar_value_of_false.domain) &&
+          !@domain.intersect?(single_val.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def may_be_equal_to?(value)
-      case single_value = value.to_single_value
+    def may_be_equal_to?(val)
+      case single_val = val.to_single_value
       when ScalarValue
-        (self == single_value).domain.intersect?(ScalarValue.of_true.domain)
+        (self == single_val).domain.intersect?(scalar_value_of_true.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def must_not_be_equal_to?(value)
-      case single_value = value.to_single_value
+    def must_not_be_equal_to?(val)
+      case single_val = val.to_single_value
       when ScalarValue
-        comp_result = (self != single_value)
-        comp_result.domain.intersect?(ScalarValue.of_true.domain) &&
-          !comp_result.domain.contain?(ScalarValue.of_false.domain) &&
-          !@domain.intersect?(single_value.domain)
+        comp_val = (self != single_val)
+        comp_val.domain.intersect?(scalar_value_of_true.domain) &&
+          !comp_val.domain.contain?(scalar_value_of_false.domain) &&
+          !@domain.intersect?(single_val.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def may_not_be_equal_to?(value)
-      case single_value = value.to_single_value
+    def may_not_be_equal_to?(val)
+      case single_val = val.to_single_value
       when ScalarValue
-        (self != single_value).domain.intersect?(ScalarValue.of_true.domain)
+        (self != single_val).domain.intersect?(scalar_value_of_true.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def must_be_less_than?(value)
-      case single_value = value.to_single_value
+    def must_be_less_than?(val)
+      case single_val = val.to_single_value
       when ScalarValue
-        comp_result = (self < single_value)
-        comp_result.domain.intersect?(ScalarValue.of_true.domain) &&
-          !comp_result.domain.contain?(ScalarValue.of_false.domain)
+        comp_val = (self < single_val)
+        comp_val.domain.intersect?(scalar_value_of_true.domain) &&
+          !comp_val.domain.contain?(scalar_value_of_false.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def may_be_less_than?(value)
-      case single_value = value.to_single_value
+    def may_be_less_than?(val)
+      case single_val = val.to_single_value
       when ScalarValue
-        (self < single_value).domain.intersect?(ScalarValue.of_true.domain)
+        (self < single_val).domain.intersect?(scalar_value_of_true.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def must_be_greater_than?(value)
-      case single_value = value.to_single_value
+    def must_be_greater_than?(val)
+      case single_val = val.to_single_value
       when ScalarValue
-        comp_result = (self > single_value)
-        comp_result.domain.intersect?(ScalarValue.of_true.domain) &&
-          !comp_result.domain.contain?(ScalarValue.of_false.domain)
+        comp_val = (self > single_val)
+        comp_val.domain.intersect?(scalar_value_of_true.domain) &&
+          !comp_val.domain.contain?(scalar_value_of_false.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
-    def may_be_greater_than?(value)
-      case single_value = value.to_single_value
+    def may_be_greater_than?(val)
+      case single_val = val.to_single_value
       when ScalarValue
-        (self > single_value).domain.intersect?(ScalarValue.of_true.domain)
+        (self > single_val).domain.intersect?(scalar_value_of_true.domain)
       else
         raise TypeError, "comparison between scalar and non-scalar."
       end
     end
 
     def must_be_true?
-      self.may_be_equal_to?(ScalarValue.of_true) &&
-        self.must_not_be_equal_to?(ScalarValue.of_false)
+      self.may_be_equal_to?(scalar_value_of_true) &&
+        self.must_not_be_equal_to?(scalar_value_of_false)
     end
 
     def may_be_true?
-      self.may_be_equal_to?(ScalarValue.of_true)
+      self.may_be_equal_to?(scalar_value_of_true)
     end
 
     def must_be_false?
-      self.must_be_equal_to?(ScalarValue.of_false)
+      self.must_be_equal_to?(scalar_value_of_false)
     end
 
     def may_be_false?
-      self.may_be_equal_to?(ScalarValue.of_false)
+      self.may_be_equal_to?(scalar_value_of_false)
     end
 
     def coerce_to(type)
@@ -734,8 +763,8 @@ module C #:nodoc:
       ScalarValue.new(@domain.to_defined_domain)
     end
 
-    def eql?(rhs_value)
-      rhs_value.kind_of?(ScalarValue) && @domain.eql?(rhs_value.domain)
+    def eql?(rhs_val)
+      rhs_val.kind_of?(ScalarValue) && @domain.eql?(rhs_val.domain)
     end
 
     def hash
@@ -748,11 +777,16 @@ module C #:nodoc:
 
     protected
     attr_reader :domain
+
+    private
+    def logical_shr?
+      @domain.logical_shr?
+    end
   end
 
   class ArrayValue < SingleValue
-    def initialize(values)
-      @values = values
+    def initialize(vals)
+      @values = vals
     end
 
     attr_reader :values
@@ -770,18 +804,18 @@ module C #:nodoc:
     end
 
     def exist?
-      @values.empty? ? true : @values.all? { |value| value.exist? }
+      @values.empty? ? true : @values.all? { |val| val.exist? }
     end
 
     def definite?
-      @values.empty? ? true : @values.all? { |value| value.definite? }
+      @values.empty? ? true : @values.all? { |val| val.definite? }
     end
 
-    def contain?(value)
-      case single_value = value.to_single_value
+    def contain?(val)
+      case single_val = val.to_single_value
       when ArrayValue
-        if @values.size == single_value.values.size
-          @values.zip(single_value.values).all? do |lhs, rhs|
+        if @values.size == single_val.values.size
+          @values.zip(single_val.values).all? do |lhs, rhs|
             lhs.contain?(rhs)
           end
         else
@@ -793,17 +827,17 @@ module C #:nodoc:
     end
 
     def undefined?
-      @values.empty? ? false : @values.all? { |value| value.undefined? }
+      @values.empty? ? false : @values.all? { |val| val.undefined? }
     end
 
     def ambiguous?
-      @values.empty? ? false : @values.all? { |value| value.ambiguous? }
+      @values.empty? ? false : @values.all? { |val| val.ambiguous? }
     end
 
-    def overwrite!(value)
-      case single_value = value.to_single_value
+    def overwrite!(val)
+      case single_val = val.to_single_value
       when ArrayValue
-        @values.zip(single_value.values).each do |lhs, rhs|
+        @values.zip(single_val.values).each do |lhs, rhs|
           rhs && lhs.overwrite!(rhs)
         end
       else
@@ -811,12 +845,12 @@ module C #:nodoc:
       end
     end
 
-    def narrow_domain!(operator, operand_value)
-      case operand_single_value = operand_value.to_single_value
+    def narrow_domain!(op, ope_val)
+      case ope_single_val = ope_val.to_single_value
       when ArrayValue
-        @values.zip(operand_single_value.values).map { |lhs, rhs|
+        @values.zip(ope_single_val.values).map { |lhs, rhs|
           if rhs
-            lhs.narrow_domain!(operator, rhs)
+            lhs.narrow_domain!(op, rhs)
           else
             next
           end
@@ -826,12 +860,12 @@ module C #:nodoc:
       end
     end
 
-    def widen_domain!(operator, operand_value)
-      case operand_single_value = operand_value.to_single_value
+    def widen_domain!(op, ope_val)
+      case ope_single_val = ope_val.to_single_value
       when ArrayValue
-        @values.zip(operand_single_value.values).map { |lhs, rhs|
+        @values.zip(ope_single_val.values).map { |lhs, rhs|
           if rhs
-            lhs.widen_domain!(operator, rhs)
+            lhs.widen_domain!(op, rhs)
           else
             next
           end
@@ -842,13 +876,13 @@ module C #:nodoc:
     end
 
     def invert_domain!
-      @values.each { |value| value.invert_domain! }
+      @values.each { |val| val.invert_domain! }
     end
 
-    def single_value_unified_with(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def single_value_unified_with(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when ArrayValue
-        ArrayValue.new(@values.zip(rhs_single_value.values).map { |lhs, rhs|
+        ArrayValue.new(@values.zip(rhs_single_val.values).map { |lhs, rhs|
           lhs.single_value_unified_with(rhs)
         })
       else
@@ -877,70 +911,70 @@ module C #:nodoc:
       dup # NOTREACHED
     end
 
-    def +(rhs_value)
+    def +(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       dup # NOTREACHED
     end
 
-    def -(rhs_value)
+    def -(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       dup # NOTREACHED
     end
 
-    def *(rhs_value)
+    def *(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       dup # NOTREACHED
     end
 
-    def /(rhs_value)
+    def /(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       dup # NOTREACHED
     end
 
-    def %(rhs_value)
+    def %(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       dup # NOTREACHED
     end
 
-    def &(rhs_value)
+    def &(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       dup # NOTREACHED
     end
 
-    def |(rhs_value)
+    def |(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       dup # NOTREACHED
     end
 
-    def ^(rhs_value)
+    def ^(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       dup # NOTREACHED
     end
 
-    def <<(rhs_value)
+    def <<(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       dup # NOTREACHED
     end
 
-    def >>(rhs_value)
+    def >>(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
@@ -951,236 +985,236 @@ module C #:nodoc:
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
-      ScalarValue.of_false # NOTREACHED
+      scalar_value_of_false # NOTREACHED
     end
 
-    def <(rhs_value)
+    def <(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when ArrayValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs < rhs)
+        if @values.size == rhs_single_val.values.size
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs < rhs)
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def >(rhs_value)
+    def >(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when ArrayValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs > rhs)
+        if @values.size == rhs_single_val.values.size
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs > rhs)
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def ==(rhs_value)
+    def ==(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when ArrayValue
         if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs == rhs)
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs == rhs)
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def !=(rhs_value)
+    def !=(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when ArrayValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs != rhs)
+        if @values.size == rhs_single_val.values.size
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs != rhs)
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def <=(rhs_value)
+    def <=(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when ArrayValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs <= rhs)
+        if @values.size == rhs_single_val.values.size
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs <= rhs)
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def >=(rhs_value)
+    def >=(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when ArrayValue
         if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs >= rhs)
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs >= rhs)
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def logical_and(rhs_value)
+    def logical_and(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when ArrayValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs.logical_and(rhs))
+        if @values.size == rhs_single_val.values.size
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs.logical_and(rhs))
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def logical_or(rhs_value)
+    def logical_or(rhs_val)
       # NOTE: When an array variable appears in expressions, object-specifier
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this comparison operator should not be reached.
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when ArrayValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs.logical_or(rhs))
+        if @values.size == rhs_single_val.values.size
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs.logical_or(rhs))
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def must_be_equal_to?(value)
-      case single_value = value.to_single_value
+    def must_be_equal_to?(val)
+      case single_val = val.to_single_value
       when ArrayValue
-        (self == single_value).must_be_true?
+        (self == single_val).must_be_true?
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def may_be_equal_to?(value)
-      case single_value = value.to_single_value
+    def may_be_equal_to?(val)
+      case single_val = val.to_single_value
       when ArrayValue
-        (self == single_value).may_be_true?
+        (self == single_val).may_be_true?
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def must_not_be_equal_to?(value)
-      case single_value = value.to_single_value
+    def must_not_be_equal_to?(val)
+      case single_val = val.to_single_value
       when ArrayValue
-        (self != single_value).must_be_true?
+        (self != single_val).must_be_true?
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def may_not_be_equal_to?(value)
-      case single_value = value.to_single_value
+    def may_not_be_equal_to?(val)
+      case single_val = val.to_single_value
       when ArrayValue
-        (self != single_value).may_be_true?
+        (self != single_val).may_be_true?
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def must_be_less_than?(value)
-      case single_value = value.to_single_value
+    def must_be_less_than?(val)
+      case single_val = value.to_single_value
       when ArrayValue
-        (self < single_value).must_be_true?
+        (self < single_val).must_be_true?
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def may_be_less_than?(value)
-      case single_value = value.to_single_value
+    def may_be_less_than?(val)
+      case single_val = val.to_single_value
       when ArrayValue
-        (self < single_value).may_be_true?
+        (self < single_val).may_be_true?
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def must_be_greater_than?(value)
-      case single_value = value.to_single_value
+    def must_be_greater_than?(val)
+      case single_val = val.to_single_value
       when ArrayValue
-        (self > single_value).must_be_true?
+        (self > single_val).must_be_true?
       else
         raise TypeError, "comparison between array and non-array."
       end
     end
 
-    def may_be_greater_than?(value)
-      case single_value = value.to_single_value
+    def may_be_greater_than?(val)
+      case single_val = val.to_single_value
       when ArrayValue
-        (self > single_value).may_be_true?
+        (self > single_val).may_be_true?
       else
         raise TypeError, "comparison between array and non-array."
       end
@@ -1191,7 +1225,7 @@ module C #:nodoc:
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this method should not be reached.
-      @values.all? { |value| value.must_be_true? }
+      @values.all? { |val| val.must_be_true? }
     end
 
     def may_be_true?
@@ -1199,7 +1233,7 @@ module C #:nodoc:
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this method should not be reached.
-      @values.all? { |value| value.may_be_true? }
+      @values.all? { |val| val.may_be_true? }
     end
 
     def must_be_false?
@@ -1207,7 +1241,7 @@ module C #:nodoc:
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this method should not be reached.
-      @values.all? { |value| value.must_be_false? }
+      @values.all? { |val| val.must_be_false? }
     end
 
     def may_be_false?
@@ -1215,7 +1249,7 @@ module C #:nodoc:
       #       of an array variable should be evaluated into a pointer to the
       #       array body.
       #       So, this method should not be reached.
-      @values.all? { |value| value.may_be_false? }
+      @values.all? { |val| val.may_be_false? }
     end
 
     def coerce_to(type)
@@ -1224,15 +1258,15 @@ module C #:nodoc:
 
     def to_enum
       # FIXME: This method generates only one of sample values.
-      @values.map { |value| value.to_enum.first }
+      @values.map { |val| val.to_enum.first }
     end
 
     def to_defined_value
-      ArrayValue.new(@values.map { |value| value.to_defined_value })
+      ArrayValue.new(@values.map { |val| val.to_defined_value })
     end
 
-    def eql?(rhs_value)
-      rhs_value.kind_of?(ArrayValue) && @values.eql?(rhs_value.values)
+    def eql?(rhs_val)
+      rhs_val.kind_of?(ArrayValue) && @values.eql?(rhs_val.values)
     end
 
     def hash
@@ -1240,13 +1274,19 @@ module C #:nodoc:
     end
 
     def dup
-      ArrayValue.new(@values.map { |value| value.dup })
+      ArrayValue.new(@values.map { |val| val.dup })
     end
+
+    private
+    def logical_shr?
+      @values.all? { |val| val.logical_shr? }
+    end
+    memoize :logical_shr?
   end
 
   class CompositeValue < SingleValue
-    def initialize(values)
-      @values = values
+    def initialize(vals)
+      @values = vals
     end
 
     attr_reader :values
@@ -1264,18 +1304,18 @@ module C #:nodoc:
     end
 
     def exist?
-      @values.empty? ? true : @values.all? { |value| value.exist? }
+      @values.empty? ? true : @values.all? { |val| val.exist? }
     end
 
     def definite?
-      @values.empty? ? true : @values.all? { |value| value.definite? }
+      @values.empty? ? true : @values.all? { |val| val.definite? }
     end
 
-    def contain?(value)
-      case single_value = value.to_single_value
+    def contain?(val)
+      case single_val = val.to_single_value
       when CompositeValue
-        if @values.size == single_value.values.size
-          @values.zip(single_value.values).all? do |lhs, rhs|
+        if @values.size == single_val.values.size
+          @values.zip(single_val.values).all? do |lhs, rhs|
             lhs.contain?(rhs)
           end
         else
@@ -1287,17 +1327,17 @@ module C #:nodoc:
     end
 
     def undefined?
-      @values.empty? ? false : @values.all? { |value| value.undefined? }
+      @values.empty? ? false : @values.all? { |val| val.undefined? }
     end
 
     def ambiguous?
-      @values.empty? ? false : @values.all? { |value| value.ambiguous? }
+      @values.empty? ? false : @values.all? { |val| val.ambiguous? }
     end
 
-    def overwrite!(value)
-      case single_value = value.to_single_value
+    def overwrite!(val)
+      case single_val = val.to_single_value
       when CompositeValue
-        @values.zip(single_value.values).each do |lhs, rhs|
+        @values.zip(single_val.values).each do |lhs, rhs|
           rhs && lhs.overwrite!(rhs)
         end
       else
@@ -1305,12 +1345,12 @@ module C #:nodoc:
       end
     end
 
-    def narrow_domain!(operator, operand_value)
-      case operand_single_value = operand_value.to_single_value
+    def narrow_domain!(op, ope_val)
+      case ope_single_val = ope_val.to_single_value
       when CompositeValue
-        @values.zip(operand_single_value.values).map { |lhs, rhs|
+        @values.zip(ope_single_val.values).map { |lhs, rhs|
           if rhs
-            lhs.narrow_domain!(operator, rhs)
+            lhs.narrow_domain!(op, rhs)
           else
             next
           end
@@ -1321,12 +1361,12 @@ module C #:nodoc:
       end
     end
 
-    def widen_domain!(operator, operand_value)
-      case operand_single_value = operand_value.to_single_value
+    def widen_domain!(op, ope_val)
+      case ope_single_val = ope_val.to_single_value
       when CompositeValue
-        @values.zip(operand_single_value.values).map { |lhs, rhs|
+        @values.zip(ope_single_val.values).map { |lhs, rhs|
           if rhs
-            lhs.widen_domain!(operator, rhs)
+            lhs.widen_domain!(op, rhs)
           else
             next
           end
@@ -1338,14 +1378,14 @@ module C #:nodoc:
     end
 
     def invert_domain!
-      @values.each { |value| value.invert_domain! }
+      @values.each { |val| val.invert_domain! }
     end
 
-    def single_value_unified_with(rhs_value)
-      case rhs_single_value = rhs_value.to_single_value
+    def single_value_unified_with(rhs_val)
+      case rhs_single_val = rhs_val.to_single_value
       when CompositeValue
         CompositeValue.new(
-          @values.zip(rhs_single_value.values).map { |lhs, rhs|
+          @values.zip(rhs_single_val.values).map { |lhs, rhs|
             lhs.single_value_unified_with(rhs)
           })
       else
@@ -1371,61 +1411,61 @@ module C #:nodoc:
       dup # NOTREACHED
     end
 
-    def +(rhs_value)
+    def +(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
       dup # NOTREACHED
     end
 
-    def -(rhs_value)
+    def -(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
       dup # NOTREACHED
     end
 
-    def *(rhs_value)
+    def *(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
       dup # NOTREACHED
     end
 
-    def /(rhs_value)
+    def /(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
       dup # NOTREACHED
     end
 
-    def %(rhs_value)
+    def %(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
       dup # NOTREACHED
     end
 
-    def &(rhs_value)
+    def &(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
       dup # NOTREACHED
     end
 
-    def |(rhs_value)
+    def |(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
       dup # NOTREACHED
     end
 
-    def ^(rhs_value)
+    def ^(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
       dup # NOTREACHED
     end
 
-    def <<(rhs_value)
+    def <<(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
       dup # NOTREACHED
     end
 
-    def >>(rhs_value)
+    def >>(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
       dup # NOTREACHED
@@ -1434,220 +1474,220 @@ module C #:nodoc:
     def !
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      ScalarValue.of_false # NOTREACHED
+      scalar_value_of_false # NOTREACHED
     end
 
-    def <(rhs_value)
+    def <(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs < rhs)
+        if @values.size == rhs_single_val.values.size
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs < rhs)
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def >(rhs_value)
+    def >(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs > rhs)
+        if @values.size == rhs_single_val.values.size
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs > rhs)
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def ==(rhs_value)
+    def ==(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs == rhs)
+        if @values.size == rhs_single_val.values.size
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs == rhs)
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def !=(rhs_value)
+    def !=(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs != rhs)
+        if @values.size == rhs_single_val.values.size
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs != rhs)
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def <=(rhs_value)
+    def <=(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs <= rhs)
+        if @values.size == rhs_single_val.values.size
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs <= rhs)
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def >=(rhs_value)
+    def >=(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs >= rhs)
+        if @values.size == rhs_single_val.values.size
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs >= rhs)
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def logical_and(rhs_value)
+    def logical_and(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs.logical_and(rhs))
+        if @values.size == rhs_single_val.values.size
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs.logical_and(rhs))
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def logical_or(rhs_value)
+    def logical_or(rhs_val)
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      case rhs_single_value = rhs_value.to_single_value
+      case rhs_single_val = rhs_val.to_single_value
       when CompositeValue
-        if @values.size == rhs_single_value.values.size
-          zipped = @values.zip(rhs_single_value.values)
-          zipped.reduce(ScalarValue.of_nil) do |result, (lhs, rhs)|
-            result.single_value_unified_with(lhs.logical_or(rhs))
+        if @values.size == rhs_single_val.values.size
+          zipped = @values.zip(rhs_single_val.values)
+          zipped.reduce(scalar_value_of_nil) do |res_val, (lhs, rhs)|
+            res_val.single_value_unified_with(lhs.logical_or(rhs))
           end
         else
-          ScalarValue.of_false
+          scalar_value_of_false
         end
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def must_be_equal_to?(value)
-      case single_value = value.to_single_value
+    def must_be_equal_to?(val)
+      case single_val = val.to_single_value
       when CompositeValue
-        (self == single_value).must_be_true?
+        (self == single_val).must_be_true?
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def may_be_equal_to?(value)
-      case single_value = value.to_single_value
+    def may_be_equal_to?(val)
+      case single_val = val.to_single_value
       when CompositeValue
-        (self == single_value).may_be_true?
+        (self == single_val).may_be_true?
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def must_not_be_equal_to?(value)
-      case single_value = value.to_single_value
+    def must_not_be_equal_to?(val)
+      case single_val = val.to_single_value
       when CompositeValue
-        (self != single_value).must_be_true?
+        (self != single_val).must_be_true?
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def may_not_be_equal_to?(value)
-      case single_value = value.to_single_value
+    def may_not_be_equal_to?(val)
+      case single_val = val.to_single_value
       when CompositeValue
-        (self != single_value).may_be_true?
+        (self != single_val).may_be_true?
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def must_be_less_than?(value)
-      case single_value = value.to_single_value
+    def must_be_less_than?(val)
+      case single_val = val.to_single_value
       when CompositeValue
-        (self < single_value).must_be_true?
+        (self < single_val).must_be_true?
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def may_be_less_than?(value)
-      case single_value = value.to_single_value
+    def may_be_less_than?(val)
+      case single_val = val.to_single_value
       when CompositeValue
-        (self < single_value).may_be_true?
+        (self < single_val).may_be_true?
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def must_be_greater_than?(value)
-      case single_value = value.to_single_value
+    def must_be_greater_than?(val)
+      case single_val = val.to_single_value
       when CompositeValue
-        (self > single_value).must_be_true?
+        (self > single_val).must_be_true?
       else
         raise TypeError, "comparison between composite and non-composite."
       end
     end
 
-    def may_be_greater_than?(value)
-      case single_value = value.to_single_value
+    def may_be_greater_than?(val)
+      case single_val = val.to_single_value
       when CompositeValue
-        (self > single_value).may_be_true?
+        (self > single_val).may_be_true?
       else
         raise TypeError, "comparison between composite and non-composite."
       end
@@ -1656,25 +1696,25 @@ module C #:nodoc:
     def must_be_true?
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      @values.all? { |value| value.must_be_true? }
+      @values.all? { |val| val.must_be_true? }
     end
 
     def may_be_true?
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      @values.all? { |value| value.may_be_true? }
+      @values.all? { |val| val.may_be_true? }
     end
 
     def must_be_false?
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      @values.all? { |value| value.must_be_false? }
+      @values.all? { |val| val.must_be_false? }
     end
 
     def may_be_false?
       # NOTE: A composite variable cannot appear in expressions except the
       #       primary-expression(object-specifier followed by `.').
-      @values.all? { |value| value.may_be_false? }
+      @values.all? { |val| val.may_be_false? }
     end
 
     def coerce_to(type)
@@ -1683,15 +1723,15 @@ module C #:nodoc:
 
     def to_enum
       # FIXME: This method generates only one of sample values.
-      @values.map { |value| value.to_enum.first }
+      @values.map { |val| val.to_enum.first }
     end
 
     def to_defined_value
-      CompositeValue.new(@values.map { |value| value.to_defined_value })
+      CompositeValue.new(@values.map { |val| val.to_defined_value })
     end
 
-    def eql?(rhs_value)
-      rhs_value.kind_of?(CompositeValue) && @values.eql?(rhs_value.values)
+    def eql?(rhs_val)
+      rhs_val.kind_of?(CompositeValue) && @values.eql?(rhs_val.values)
     end
 
     def hash
@@ -1699,13 +1739,19 @@ module C #:nodoc:
     end
 
     def dup
-      CompositeValue.new(@values.map { |value| value.dup })
+      CompositeValue.new(@values.map { |val| val.dup })
+    end
+
+    private
+    def logical_shr?
+      @values.all? { |val| val.logical_shr? }
     end
+    memoize :logical_shr?
   end
 
   class MultipleValue < Value
-    def initialize(value, ancestor)
-      @base_value = value.to_single_value
+    def initialize(val, ancestor)
+      @base_value = val.to_single_value
       @ancestor = ancestor
       @descendants = []
     end
@@ -1719,25 +1765,25 @@ module C #:nodoc:
     def_delegator :@base_value, :composite?
 
     def undefined?
-      effective_values.all? { |multi_value| multi_value.base_value.undefined? }
+      effective_values.all? { |multi_val| multi_val.base_value.undefined? }
     end
 
     def ambiguous?
-      effective_values.all? { |multi_value| multi_value.base_value.ambiguous? }
+      effective_values.all? { |multi_val| multi_val.base_value.ambiguous? }
     end
 
     def exist?
-      effective_values.any? { |multi_value| multi_value.base_value.exist? }
+      effective_values.any? { |multi_val| multi_val.base_value.exist? }
     end
 
     def definite?
-      effective_values.all? { |multi_value| multi_value.base_value.definite? }
+      effective_values.all? { |multi_val| multi_val.base_value.definite? }
     end
 
-    def contain?(value)
-      single_value = value.to_single_value
-      effective_values.all? do |multi_value|
-        multi_value.base_value.contain?(single_value)
+    def contain?(val)
+      single_val = val.to_single_value
+      effective_values.all? do |multi_val|
+        multi_val.base_value.contain?(single_val)
       end
     end
 
@@ -1745,51 +1791,47 @@ module C #:nodoc:
       true
     end
 
-    def overwrite!(value)
-      single_value = value.to_single_value
-      effective_values.each do |multi_value|
-        multi_value.base_value.overwrite!(single_value)
+    def overwrite!(val)
+      single_val = val.to_single_value
+      effective_values.each do |multi_val|
+        multi_val.base_value.overwrite!(single_val)
       end
     end
 
-    def narrow_domain!(operator, operand_value)
-      operand_single_value = operand_value.to_single_value
-      effective_values.map { |multi_value|
-        if ancestor = multi_value.ancestor
-          ancestor.base_value.narrow_domain!(operator.for_complement,
-                                             operand_single_value)
+    def narrow_domain!(op, ope_val)
+      ope_single_val = ope_val.to_single_value
+      effective_values.map { |multi_val|
+        if anc = multi_val.ancestor
+          anc.base_value.narrow_domain!(op.for_complement, ope_single_val)
         end
-        multi_value.base_value.narrow_domain!(operator, operand_single_value)
+        multi_val.base_value.narrow_domain!(op, ope_single_val)
       }.any?
     end
 
-    def widen_domain!(operator, operand_value)
-      operand_single_value = operand_value.to_single_value
-      effective_values.map { |multi_value|
-        if ancestor = multi_value.ancestor
-          ancestor.base_value.narrow_domain!(operator.for_complement,
-                                             operand_single_value)
+    def widen_domain!(op, ope_val)
+      ope_single_val = ope_val.to_single_value
+      effective_values.map { |multi_val|
+        if anc = multi_val.ancestor
+          anc.base_value.narrow_domain!(op.for_complement, ope_single_val)
         end
-        multi_value.base_value.widen_domain!(operator, operand_single_value)
+        multi_val.base_value.widen_domain!(op, ope_single_val)
       }.any?
     end
 
     def invert_domain!
-      effective_values.each do |multi_value|
-        multi_value.base_value.invert_domain!
+      effective_values.each do |multi_val|
+        multi_val.base_value.invert_domain!
       end
     end
 
-    def single_value_unified_with(rhs_value)
-      to_single_value.single_value_unified_with(rhs_value)
+    def single_value_unified_with(rhs_val)
+      to_single_value.single_value_unified_with(rhs_val)
     end
 
     def fork
-      same_value = @descendants.find { |multi_value|
-        multi_value.eql?(@base_value)
-      }
-      if same_value
-        same_value
+      same_val = @descendants.find { |multi_val| multi_val.eql?(@base_value) }
+      if same_val
+        same_val
       else
         new_descendant = MultipleValue.new(@base_value.dup, self)
         @descendants.push(new_descendant)
@@ -1817,201 +1859,214 @@ module C #:nodoc:
       -to_single_value
     end
 
-    def +(rhs_value)
-      to_single_value + rhs_value.to_single_value
+    def +(rhs_val)
+      to_single_value + rhs_val.to_single_value
     end
 
-    def -(rhs_value)
-      to_single_value - rhs_value.to_single_value
+    def -(rhs_val)
+      to_single_value - rhs_val.to_single_value
     end
 
-    def *(rhs_value)
-      to_single_value * rhs_value.to_single_value
+    def *(rhs_val)
+      to_single_value * rhs_val.to_single_value
     end
 
-    def /(rhs_value)
-      to_single_value / rhs_value.to_single_value
+    def /(rhs_val)
+      to_single_value / rhs_val.to_single_value
     end
 
-    def %(rhs_value)
-      to_single_value % rhs_value.to_single_value
+    def %(rhs_val)
+      to_single_value % rhs_val.to_single_value
     end
 
-    def &(rhs_value)
-      to_single_value & rhs_value.to_single_value
+    def &(rhs_val)
+      to_single_value & rhs_val.to_single_value
     end
 
-    def |(rhs_value)
-      to_single_value | rhs_value.to_single_value
+    def |(rhs_val)
+      to_single_value | rhs_val.to_single_value
     end
 
-    def ^(rhs_value)
-      to_single_value ^ rhs_value.to_single_value
+    def ^(rhs_val)
+      to_single_value ^ rhs_val.to_single_value
     end
 
-    def <<(rhs_value)
-      to_single_value << rhs_value.to_single_value
+    def <<(rhs_val)
+      to_single_value << rhs_val.to_single_value
     end
 
-    def >>(rhs_value)
-      to_single_value >> rhs_value.to_single_value
+    def >>(rhs_val)
+      to_single_value >> rhs_val.to_single_value
     end
 
     def !
       !to_single_value
     end
 
-    def <(rhs_value)
-      to_single_value < rhs_value.to_single_value
+    def <(rhs_val)
+      to_single_value < rhs_val.to_single_value
     end
 
-    def >(rhs_value)
-      to_single_value > rhs_value.to_single_value
+    def >(rhs_val)
+      to_single_value > rhs_val.to_single_value
     end
 
-    def ==(rhs_value)
-      to_single_value == rhs_value.to_single_value
+    def ==(rhs_val)
+      to_single_value == rhs_val.to_single_value
     end
 
-    def !=(rhs_value)
-      to_single_value != rhs_value.to_single_value
+    def !=(rhs_val)
+      to_single_value != rhs_val.to_single_value
     end
 
-    def <=(rhs_value)
-      to_single_value <= rhs_value.to_single_value
+    def <=(rhs_val)
+      to_single_value <= rhs_val.to_single_value
     end
 
-    def >=(rhs_value)
-      to_single_value >= rhs_value.to_single_value
+    def >=(rhs_val)
+      to_single_value >= rhs_val.to_single_value
     end
 
-    def logical_and(rhs_value)
-      to_single_value.logical_and(rhs_value.to_single_value)
+    def logical_and(rhs_val)
+      to_single_value.logical_and(rhs_val.to_single_value)
     end
 
-    def logical_or(rhs_value)
-      to_single_value.logical_or(rhs_value.to_single_value)
+    def logical_or(rhs_val)
+      to_single_value.logical_or(rhs_val.to_single_value)
     end
 
-    def must_be_equal_to?(value)
-      single_value = value.to_single_value
-      non_nil_values = effective_values.select { |multi_value|
-        multi_value.base_value.exist?
+    def must_be_equal_to?(val)
+      single_val = val.to_single_value
+      non_nil_vals = effective_values.select { |multi_val|
+        multi_val.base_value.exist?
       }
-      return false if non_nil_values.empty?
 
-      non_nil_values.all? do |multi_value|
-        multi_value.base_value.must_be_equal_to?(single_value)
+      if non_nil_vals.empty?
+        false
+      else
+        non_nil_vals.all? do |multi_val|
+          multi_val.base_value.must_be_equal_to?(single_val)
+        end
       end
     end
 
-    def may_be_equal_to?(value)
-      single_value = value.to_single_value
-      effective_values.any? do |multi_value|
-        multi_value.base_value.may_be_equal_to?(single_value)
+    def may_be_equal_to?(val)
+      single_val = val.to_single_value
+      effective_values.any? do |multi_val|
+        multi_val.base_value.may_be_equal_to?(single_val)
       end
     end
 
-    def must_not_be_equal_to?(value)
-      single_value = value.to_single_value
-      non_nil_values = effective_values.select { |multi_value|
-        multi_value.base_value.exist?
+    def must_not_be_equal_to?(val)
+      single_val = val.to_single_value
+      non_nil_vals = effective_values.select { |multi_val|
+        multi_val.base_value.exist?
       }
-      return false if non_nil_values.empty?
-
-      non_nil_values.all? do |multi_value|
-        multi_value.base_value.must_not_be_equal_to?(single_value)
+      if non_nil_vals.empty?
+        false
+      else
+        non_nil_vals.all? do |multi_val|
+          multi_val.base_value.must_not_be_equal_to?(single_val)
+        end
       end
     end
 
-    def may_not_be_equal_to?(value)
-      single_value = value.to_single_value
-      effective_values.any? do |multi_value|
-        multi_value.base_value.may_not_be_equal_to?(single_value)
+    def may_not_be_equal_to?(val)
+      single_val = val.to_single_value
+      effective_values.any? do |multi_val|
+        multi_val.base_value.may_not_be_equal_to?(single_val)
       end
     end
 
-    def must_be_less_than?(value)
-      single_value = value.to_single_value
-      non_nil_values = effective_values.select { |multi_value|
-        multi_value.base_value.exist?
+    def must_be_less_than?(val)
+      single_val = val.to_single_value
+      non_nil_vals = effective_values.select { |multi_val|
+        multi_val.base_value.exist?
       }
-      return false if non_nil_values.empty?
-
-      non_nil_values.all? do |multi_value|
-        multi_value.base_value.must_be_less_than?(single_value)
+      if non_nil_vals.empty?
+        false
+      else
+        non_nil_vals.all? do |multi_val|
+          multi_val.base_value.must_be_less_than?(single_val)
+        end
       end
     end
 
-    def may_be_less_than?(value)
-      single_value = value.to_single_value
-      effective_values.any? do |multi_value|
-        multi_value.base_value.may_be_less_than?(single_value)
+    def may_be_less_than?(val)
+      single_val = val.to_single_value
+      effective_values.any? do |multi_val|
+        multi_val.base_value.may_be_less_than?(single_val)
       end
     end
 
-    def must_be_greater_than?(value)
-      single_value = value.to_single_value
-      non_nil_values = effective_values.select { |multi_value|
-        multi_value.base_value.exist?
+    def must_be_greater_than?(val)
+      single_val = val.to_single_value
+      non_nil_vals = effective_values.select { |multi_val|
+        multi_val.base_value.exist?
       }
-      return false if non_nil_values.empty?
-
-      non_nil_values.all? do |multi_value|
-        multi_value.base_value.must_be_greater_than?(single_value)
+      if non_nil_vals.empty?
+        false
+      else
+        non_nil_vals.all? do |multi_val|
+          multi_val.base_value.must_be_greater_than?(single_val)
+        end
       end
     end
 
-    def may_be_greater_than?(value)
-      single_value = value.to_single_value
-      effective_values.any? do |multi_value|
-        multi_value.base_value.may_be_greater_than?(single_value)
+    def may_be_greater_than?(val)
+      single_val = val.to_single_value
+      effective_values.any? do |multi_val|
+        multi_val.base_value.may_be_greater_than?(single_val)
       end
     end
 
     def must_be_undefined?
-      effective_values.all? do |multi_value|
-        multi_value.base_value.must_be_undefined?
+      effective_values.all? do |multi_val|
+        multi_val.base_value.must_be_undefined?
       end
     end
 
     def may_be_undefined?
-      effective_values.any? do |multi_value|
-        multi_value.base_value.may_be_undefined?
+      effective_values.any? do |multi_val|
+        multi_val.base_value.may_be_undefined?
       end
     end
 
     def must_be_true?
-      non_nil_values = effective_values.select { |multi_value|
-        multi_value.base_value.exist?
+      non_nil_vals = effective_values.select { |multi_val|
+        multi_val.base_value.exist?
       }
-      return false if non_nil_values.empty?
-
-      non_nil_values.all? do |multi_value|
-        multi_value.base_value.must_be_true?
+      if non_nil_vals.empty?
+        false
+      else
+        non_nil_vals.all? do |multi_val|
+          multi_val.base_value.must_be_true?
+        end
       end
     end
 
     def may_be_true?
-      effective_values.any? do |multi_value|
-        multi_value.base_value.may_be_true?
+      effective_values.any? do |multi_val|
+        multi_val.base_value.may_be_true?
       end
     end
 
     def must_be_false?
-      non_nil_values = effective_values.select { |multi_value|
-        multi_value.base_value.exist?
+      non_nil_vals = effective_values.select { |multi_val|
+        multi_val.base_value.exist?
       }
-      return false if non_nil_values.empty?
-
-      non_nil_values.all? do |multi_value|
-        multi_value.base_value.must_be_false?
+      if non_nil_vals.empty?
+        false
+      else
+        non_nil_vals.all? do |multi_val|
+          multi_val.base_value.must_be_false?
+        end
       end
     end
 
     def may_be_false?
-      effective_values.any? do |multi_value|
-        multi_value.base_value.may_be_false?
+      effective_values.any? do |multi_val|
+        multi_val.base_value.may_be_false?
       end
     end
 
@@ -2025,10 +2080,10 @@ module C #:nodoc:
 
     def to_single_value
       # NOTE: The base_value of the MultipleValue object must be a SingleValue.
-      effective_values.map { |multi_value|
-        multi_value.base_value
-      }.reduce do |unified_value, single_value|
-        unified_value.single_value_unified_with(single_value)
+      effective_values.map { |multi_val|
+        multi_val.base_value
+      }.reduce do |unified_val, single_val|
+        unified_val.single_value_unified_with(single_val)
       end
     end
 
@@ -2036,8 +2091,8 @@ module C #:nodoc:
       to_single_value.to_defined_value
     end
 
-    def eql?(rhs_value)
-      to_single_value.eql?(rhs_value.to_single_value)
+    def eql?(rhs_val)
+      to_single_value.eql?(rhs_val.to_single_value)
     end
 
     def hash
@@ -2056,7 +2111,7 @@ module C #:nodoc:
       if @descendants.empty?
         [self]
       else
-        @descendants.map { |multi_value| multi_value.descendants }.flatten.uniq
+        @descendants.map { |multi_val| multi_val.descendants }.flatten.uniq
       end
     end
 
@@ -2065,10 +2120,10 @@ module C #:nodoc:
   end
 
   class VersionedValue < MultipleValue
-    def initialize(original_value)
-      # NOTE: `original_value.to_single_value' will be done in
+    def initialize(org_val)
+      # NOTE: `org_val.to_single_value' will be done in
       #       MultipleValue#initialize.
-      super(original_value, nil)
+      super(org_val, nil)
 
       @version_controller = ValueVersionController.new(self)
     end
@@ -2094,36 +2149,35 @@ module C #:nodoc:
     end
 
     def thin_latest_version!(with_rollback)
-      if @version_controller.thin_current_version(with_rollback)
-        invalidate_memo!
-      end
+      @version_controller.thin_current_version(with_rollback)
+      invalidate_memo!
     end
 
     def rollback_all_versions!
       delete_descendants!
-      original_value = @version_controller.original_value
+      org_val = @version_controller.original_value
       @version_controller = nil
-      _orig_overwrite!(original_value)
+      _org_overwrite!(org_val)
       @version_controller = ValueVersionController.new(self)
       invalidate_memo!
     end
 
-    alias :_orig_overwrite! :overwrite!
+    alias :_org_overwrite! :overwrite!
 
-    def overwrite!(value)
+    def overwrite!(val)
       @version_controller.fork_current_version
-      super(value.to_single_value)
+      super(val.to_single_value)
       @version_controller.mark_current_versioning_group_as_sticky
       invalidate_memo!
     end
 
-    def narrow_domain!(operator, operand_value)
+    def narrow_domain!(op, ope_val)
       @version_controller.fork_current_version
       super
       invalidate_memo!
     end
 
-    def widen_domain!(operator, operand_value)
+    def widen_domain!(op, ope_val)
       @version_controller.fork_current_version
       super
       invalidate_memo!
@@ -2143,25 +2197,23 @@ module C #:nodoc:
       @version_controller ? @version_controller.current_values : [self]
     end
 
-    extend Memoizable
-
     memoize :to_single_value
 
     def invalidate_memo!
-      forget_to_single_value_memo
+      forget_memo_of__to_single_value
     end
 
     private
     def compact_descendants!
-      @descendants = @version_controller.current_values.reject { |multi_value|
-        multi_value.equal?(self)
+      @descendants = @version_controller.current_values.reject { |multi_val|
+        multi_val.equal?(self)
       }.uniq
     end
   end
 
   class ValueVersionController
-    def initialize(original_value)
-      @versioning_group_stack = [RootVersioningGroup.new(original_value)]
+    def initialize(org_val)
+      @versioning_group_stack = [RootVersioningGroup.new(org_val)]
     end
 
     def original_value
@@ -2195,26 +2247,28 @@ module C #:nodoc:
 
     def thin_current_version(with_rollback)
       # NOTE: This method must be called in the forking section.
-      return false unless current_version.forked?
+
+      forked = current_version.forked?
 
       if with_rollback
-        initial_values = current_version.initial_values
-        current_versioning_group.delete_current_version
-        base_values = current_versioning_group.base_values
-        base_values.zip(initial_values).each do |multi_value, init_value|
-          multi_value.rollback!
-          multi_value.overwrite!(init_value) if init_value
+        initial_vals = current_version.initial_values
+        current_versioning_group.delete_current_version_completely
+        base_vals = current_versioning_group.base_values
+        base_vals.zip(initial_vals).each do |multi_val, initial_val|
+          forked and multi_val.rollback!
+          initial_val and multi_val.overwrite!(initial_val)
         end
+        begin_forking
       else
         current_versioning_group.delete_current_version
-        current_versioning_group.base_values.each do |multi_value|
-          multi_value.rollback!
+        if forked
+          current_versioning_group.base_values.each do |multi_val|
+            multi_val.rollback!
+          end
         end
       end
 
-      begin_forking
       mark_current_versioning_group_as_sticky
-      true
     end
 
     def mark_current_versioning_group_as_sticky
@@ -2232,40 +2286,39 @@ module C #:nodoc:
 
       # NOTE: This method must be called between ending of the forking section
       #       and ending of the versioning group.
-      current_values.each do |multi_value|
-        base_value = multi_value.base_value
-        already_exist = multi_value.descendants.any? { |desc_multi_value|
-          !desc_multi_value.equal?(multi_value) &&
-            desc_multi_value.eql?(base_value)
+      current_values.each do |multi_val|
+        base_val = multi_val.base_value
+        already_exist = multi_val.descendants.any? { |desc_multi_val|
+          !desc_multi_val.equal?(multi_val) && desc_multi_val.eql?(base_val)
         }
-        multi_value.fork unless already_exist
+        multi_val.fork unless already_exist
       end
     end
 
     def merge_forked_versions
       # NOTE: This method must be called between ending of the forking section
       #       and ending of the versioning group.
-      base_version = current_versioning_group.base_version
+      base_ver = current_versioning_group.base_version
 
       case
       when current_versioning_group.sticky?
         fork_all_versions
-        base_version.values = base_version.values.map { |base_multi_value|
-          base_multi_value.descendants
+        base_ver.values = base_ver.values.map { |base_multi_val|
+          base_multi_val.descendants
         }.flatten.uniq
       when current_versioning_group.versions_forked?
         # NOTE: When versions in the current versioning group have been forked,
         #       base_version of the current versioning group has already been
         #       forked.  So, it is safe to overwrite the base_version's values
         #       with the current versioning group's initial snapshot values.
-        initial_values = current_versioning_group.initial_values
-        values = base_version.values.zip(initial_values)
-        values.each do |base_multi_value, initial_single_value|
-          base_multi_value.delete_descendants!
-          if base_multi_value.kind_of?(VersionedValue)
-            base_multi_value._orig_overwrite!(initial_single_value)
+        initial_vals = current_versioning_group.initial_values
+        vals = base_ver.values.zip(initial_vals)
+        vals.each do |base_multi_val, initial_single_val|
+          base_multi_val.delete_descendants!
+          if base_multi_val.kind_of?(VersionedValue)
+            base_multi_val._org_overwrite!(initial_single_val)
           else
-            base_multi_value.overwrite!(initial_single_value)
+            base_multi_val.overwrite!(initial_single_val)
           end
         end
       else
@@ -2301,12 +2354,12 @@ module C #:nodoc:
     end
 
     class VersioningGroup
-      def initialize(base_version, sticky = false)
-        @base_version = base_version
+      def initialize(base_ver, sticky = false)
+        @base_version = base_ver
         @sticky = sticky
 
-        @initial_values = base_version.values.map { |multi_value|
-          multi_value.base_value.dup
+        @initial_values = base_ver.values.map { |multi_val|
+          multi_val.base_value.dup
         }
         @version_stack = []
         @all_versions = []
@@ -2321,7 +2374,7 @@ module C #:nodoc:
       end
 
       def versions_forked?
-        @all_versions.any? { |version| version.forked? }
+        @all_versions.any? { |ver| ver.forked? }
       end
 
       def base_values
@@ -2337,36 +2390,40 @@ module C #:nodoc:
       end
 
       def begin_new_version
-        new_version = Version.new(base_values)
-        @version_stack.push(new_version)
-        @all_versions.push(new_version)
+        new_ver = Version.new(base_values)
+        @version_stack.push(new_ver)
+        @all_versions.push(new_ver)
       end
 
       def end_current_version
         @version_stack.pop
       end
 
-      def delete_current_version
+      def delete_current_version_completely
         end_current_version
+        delete_current_version
+      end
+
+      def delete_current_version
         @all_versions.pop
       end
 
       def fork_all_versions
-        @all_versions.each { |version| version.fork_from(@base_version) }
+        @all_versions.each { |ver| ver.fork_from(@base_version) }
       end
     end
     private_constant :VersioningGroup
 
     class RootVersioningGroup < VersioningGroup
-      def initialize(original_value)
-        super(Version.new([original_value], true), true)
+      def initialize(org_val)
+        super(Version.new([org_val], true), true)
       end
     end
     private_constant :RootVersioningGroup
 
     class Version
-      def initialize(values, original = false)
-        @values = values
+      def initialize(vals, original = false)
+        @values = vals
         @initial_values = []
         @state = original ? :original : :forking
       end
@@ -2386,11 +2443,11 @@ module C #:nodoc:
         @state == :forked
       end
 
-      def fork_from(base_version)
+      def fork_from(base_ver)
         if forking?
-          @values = base_version.values.map { |multi_value| multi_value.fork }
-          @initial_values = @values.each_with_object([]) { |value, ary|
-            ary.push(value.to_single_value.dup)
+          @values = base_ver.values.map { |multi_val| multi_val.fork }
+          @initial_values = @values.each_with_object([]) { |val, ary|
+            ary.push(val.to_single_value.dup)
           }
           @state = :forked
         end