adlint 1.8.2 → 1.8.10

data/lib/adlint/c/conv.rb

@@ -48,7 +48,7 @@ module C #:nodoc:
       return original unless original.type.integer?
 
       promoted_type = original.type.integer_promoted_type
-      if original.type.same_as?(promoted_type)
+      if promoted_type.same_as?(original.type)
         original
       else
         do_conversion(original, promoted_type) || original
@@ -62,13 +62,13 @@ module C #:nodoc:
 
       arith_type = lhs_original.type.arithmetic_type_with(rhs_original.type)
 
-      if lhs_original.type.same_as?(arith_type)
+      if arith_type.same_as?(lhs_original.type)
         lhs_converted = lhs_original
       else
         lhs_converted = do_conversion(lhs_original, arith_type) || lhs_original
       end
 
-      if rhs_original.type.same_as?(arith_type)
+      if arith_type.same_as?(rhs_original.type)
         rhs_converted = rhs_original
       else
         rhs_converted = do_conversion(rhs_original, arith_type) || rhs_original
@@ -79,7 +79,7 @@ module C #:nodoc:
 
     def do_default_argument_promotion(original)
       promoted_type = original.type.argument_promoted_type
-      if original.type.same_as?(promoted_type)
+      if promoted_type.same_as?(original.type)
         original
       else
         do_conversion(original, promoted_type) || original

data/lib/adlint/c/ctrlexpr.rb

@@ -62,7 +62,6 @@ module C #:nodoc:
     def ensure_true_by_narrowing(expression = nil)
       if expression
         new_manip = ValueDomainNarrower.new(@interpreter, expression)
-        @manipulators.push(new_manip)
         begin
           if @branch.implicit_condition?
             @interpreter._suppress_notification = true
@@ -783,7 +782,14 @@ module C #:nodoc:
         # NOTREACHED
       end
 
-      notify_equality_expr_evaled(@node, lhs_converted, rhs_converted, result)
+      case @operator_symbol
+      when :==, :!=
+        notify_equality_expr_evaled(@node,
+                                    lhs_converted, rhs_converted, result)
+      when :<, :>, :<=, :>=
+        notify_relational_expr_evaled(@node,
+                                      lhs_converted, rhs_converted, result)
+      end
 
       case
       when lhs_converted.designated_by_lvalue?

data/lib/adlint/c/domain.rb

@@ -537,7 +537,30 @@ module C #:nodoc:
     end
 
     def *(rhs_domain)
-      self / (ValueDomain.equal_to(1.0) / rhs_domain)
+      # NOTE: Operator * cannot be defined by `LHS / (1.0 / RHS)'.
+      #       Because `1.0 / RHS' will make NaN, when the value domain of the
+      #       right hand side contains 0.
+      subclass_responsibility
+    end
+
+    def _mul_nil(lhs_domain, rhs_domain = self)
+      subclass_responsibility
+    end
+
+    def _mul_unlimited(lhs_domain, rhs_domain = self)
+      subclass_responsibility
+    end
+
+    def _mul_equal_to(lhs_domain, rhs_domain = self)
+      subclass_responsibility
+    end
+
+    def _mul_less_than(lhs_domain, rhs_domain = self)
+      subclass_responsibility
+    end
+
+    def _mul_greater_than(lhs_domain, rhs_domain = self)
+      subclass_responsibility
     end
 
     def /(rhs_domain)
@@ -1252,6 +1275,48 @@ module C #:nodoc:
       rhs_domain
     end
 
+    def *(rhs_domain)
+      rhs_domain._mul_nil(self)
+    end
+
+    def _mul_nil(lhs_domain, rhs_domain = self)
+      # NOTE: NilValueDomain contains no values.
+      #       So, any arithmetic operation with NilValueDomain makes
+      #       NilValueDomain.
+      lhs_domain
+    end
+
+    def _mul_unlimited(lhs_domain, rhs_domain = self)
+      # NOTE: NilValueDomain contains no values.
+      #       So, any arithmetic operation with NilValueDomain makes
+      #       NilValueDomain.
+      # NOTE: NaN is a subclass of UnlimitedValueDomain.
+      #       Arithmetic operation with UnlimitedValueDomain should make
+      #       UnlimitedValueDomain, and with NaN should make NaN.
+      rhs_domain
+    end
+
+    def _mul_equal_to(lhs_domain, rhs_domain = self)
+      # NOTE: NilValueDomain contains no values.
+      #       So, any arithmetic operation with NilValueDomain makes
+      #       NilValueDomain.
+      rhs_domain
+    end
+
+    def _mul_less_than(lhs_domain, rhs_domain = self)
+      # NOTE: NilValueDomain contains no values.
+      #       So, any arithmetic operation with NilValueDomain makes
+      #       NilValueDomain.
+      rhs_domain
+    end
+
+    def _mul_greater_than(lhs_domain, rhs_domain = self)
+      # NOTE: NilValueDomain contains no values.
+      #       So, any arithmetic operation with NilValueDomain makes
+      #       NilValueDomain.
+      rhs_domain
+    end
+
     def /(rhs_domain)
       rhs_domain._div_nil(self)
     end
@@ -2068,6 +2133,47 @@ module C #:nodoc:
       rhs_domain
     end
 
+    def *(rhs_domain)
+      rhs_domain._mul_unlimited(self)
+    end
+
+    def _mul_nil(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes NilValueDomain#_mul_unlimited.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_unlimited(lhs_domain, rhs_domain = self)
+      # NOTE: UnlimitedValueDomain contains everything.
+      #       So, this arithmetic operation with UnlimitedValueDomain makes
+      #       UnlimitedValueDomain.
+      # NOTE: NaN is a subclass of UnlimitedValueDomain.
+      #       Arithmetic operation with UnlimitedValueDomain should make
+      #       UnlimitedValueDomain, and with NaN should make NaN.
+      lhs_domain.nan? ? lhs_domain : rhs_domain
+    end
+
+    def _mul_equal_to(lhs_domain, rhs_domain = self)
+      # NOTE: UnlimitedValueDomain contains everything.
+      #       So, this arithmetic operation with UnlimitedValueDomain makes
+      #       UnlimitedValueDomain.
+      rhs_domain
+    end
+
+    def _mul_less_than(lhs_domain, rhs_domain = self)
+      # NOTE: UnlimitedValueDomain contains everything.
+      #       So, this arithmetic operation with UnlimitedValueDomain makes
+      #       UnlimitedValueDomain.
+      rhs_domain
+    end
+
+    def _mul_greater_than(lhs_domain, rhs_domain = self)
+      # NOTE: UnlimitedValueDomain contains everything.
+      #       So, this arithmetic operation with UnlimitedValueDomain makes
+      #       UnlimitedValueDomain.
+      rhs_domain
+    end
+
     def /(rhs_domain)
       rhs_domain._div_unlimited(self)
     end
@@ -2947,6 +3053,60 @@ module C #:nodoc:
       ValueDomain.greater_than(lhs_domain.value + rhs_domain.value)
     end
 
+    def *(rhs_domain)
+      rhs_domain._mul_equal_to(self)
+    end
+
+    def _mul_nil(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes NilValueDomain#_mul_equal_to.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_unlimited(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes UnlimitedValueDomain#_mul_equal_to.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_equal_to(lhs_domain, rhs_domain = self)
+      ValueDomain.equal_to(lhs_domain.value * rhs_domain.value)
+    end
+
+    def _mul_less_than(lhs_domain, rhs_domain = self)
+      if rhs_domain.value == 0
+        ValueDomain.equal_to(0)
+      else
+        case
+        when lhs_domain.value <= 0 && rhs_domain.value < 0
+          ValueDomain.greater_than(lhs_domain.value * rhs_domain.value)
+        when lhs_domain.value > 0 && rhs_domain.value < 0
+          ValueDomain.of_unlimited
+        when lhs_domain.value <= 0 && rhs_domain.value > 0
+          ValueDomain.less_than(lhs_domain.value * rhs_domain.value)
+        when lhs_domain.value > 0 && rhs_domain.value > 0
+          ValueDomain.of_unlimited
+        end
+      end
+    end
+
+    def _mul_greater_than(lhs_domain, rhs_domain = self)
+      if rhs_domain.value == 0
+        ValueDomain.equal_to(0)
+      else
+        case
+        when lhs_domain.value >= 0 && rhs_domain.value < 0
+          ValueDomain.less_than(lhs_domain.value * rhs_domain.value)
+        when lhs_domain.value < 0 && rhs_domain.value < 0
+          ValueDomain.of_unlimited
+        when lhs_domain.value >= 0 && rhs_domain.value > 0
+          ValueDomain.greater_than(lhs_domain.value * rhs_domain.value)
+        when lhs_domain.value < 0 && rhs_domain.value > 0
+          ValueDomain.of_unlimited
+        end
+      end
+    end
+
     def /(rhs_domain)
       rhs_domain._div_equal_to(self)
     end
@@ -3758,6 +3918,54 @@ module C #:nodoc:
       ValueDomain.of_unlimited
     end
 
+    def *(rhs_domain)
+      rhs_domain._mul_less_than(self)
+    end
+
+    def _mul_nil(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes NilValueDomain#_mul_less_than.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_unlimited(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes UnlimitedValueDomain#_mul_less_than.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_equal_to(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes EqualToValueDomain#_mul_less_than.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_less_than(lhs_domain, rhs_domain = self)
+      if rhs_domain.value > 0
+        ValueDomain.of_unlimited
+      else
+        case
+        when lhs_domain.value <= 0
+          ValueDomain.greater_than(0)
+        when lhs_domain.value > 0
+          ValueDomain.less_than(0)
+        end
+      end
+    end
+
+    def _mul_greater_than(lhs_domain, rhs_domain = self)
+      if rhs_domain.value > 0
+        ValueDomain.of_unlimited
+      else
+        case
+        when lhs_domain.value >= 0
+          ValueDomain.less_than(0)
+        when lhs_domain.value < 0
+          ValueDomain.greater_than(0)
+        end
+      end
+    end
+
     def /(rhs_domain)
       rhs_domain._div_less_than(self)
     end
@@ -4608,6 +4816,47 @@ module C #:nodoc:
       ValueDomain.greater_than(lhs_domain.value + rhs_domain.value)
     end
 
+    def *(rhs_domain)
+      rhs_domain._mul_greater_than(self)
+    end
+
+    def _mul_nil(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes NilValueDomain#_mul_greater_than.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_unlimited(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes UnlimitedValueDomain#_mul_greater_than.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_equal_to(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes EqualToValueDomain#_mul_greater_than.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_less_than(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes LessThanValueDomain#_mul_greater_than.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_greater_than(lhs_domain, rhs_domain = self)
+      if rhs_domain.value < 0
+        ValueDomain.of_unlimited
+      else
+        case
+        when lhs_domain.value < 0
+          ValueDomain.of_unlimited
+        when lhs_domain.value >= 0
+          ValueDomain.greater_than(0)
+        end
+      end
+    end
+
     def /(rhs_domain)
       rhs_domain._div_greater_than(self)
     end
@@ -5343,6 +5592,36 @@ module C #:nodoc:
       rhs_domain + lhs_domain
     end
 
+    def _mul_nil(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes CompositeValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_unlimited(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes CompositeValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_equal_to(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes CompositeValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_less_than(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes CompositeValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_greater_than(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes CompositeValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
     def _div_nil(lhs_domain, rhs_domain = self)
       _div(lhs_domain, rhs_domain)
     end
@@ -5813,6 +6092,11 @@ module C #:nodoc:
       new_sub_domains.first.intersection(new_sub_domains.last)
     end
 
+    def *(rhs_domain)
+      new_sub_domains = domain_pair.map { |lhs| lhs * rhs_domain }
+      new_sub_domains.first.intersection(new_sub_domains.last)
+    end
+
     def /(rhs_domain)
       new_sub_domains = domain_pair.map { |lhs| lhs / rhs_domain }
       new_sub_domains.first.intersection(new_sub_domains.last)
@@ -6091,6 +6375,11 @@ module C #:nodoc:
       new_sub_domains.first.union(new_sub_domains.last)
     end
 
+    def *(rhs_domain)
+      new_sub_domains = domain_pair.map { |lhs| lhs * rhs_domain }
+      new_sub_domains.first.union(new_sub_domains.last)
+    end
+
     def /(rhs_domain)
       new_sub_domains = domain_pair.map { |lhs| lhs / rhs_domain }
       new_sub_domains.first.union(new_sub_domains.last)
@@ -6309,7 +6598,7 @@ module C #:nodoc:
     def_delegator :@domain, :_intersect_greater_than?
 
     def _narrow_by_eq(rhs_domain, lhs_domain = self)
-      ValueDomain.of_undefined(rhs_domain._narrow_by_eq(lhs_domain.domain))
+      ValueDomain.of_undefined(lhs_domain.domain._narrow_by_eq(rhs_domain))
     end
 
     def_delegator :@domain, :_narrow_nil_by_eq
@@ -6319,7 +6608,7 @@ module C #:nodoc:
     def_delegator :@domain, :_narrow_greater_than_by_eq
 
     def _narrow_by_ne(rhs_domain, lhs_domain = self)
-      ValueDomain.of_undefined(rhs_domain._narrow_by_ne(lhs_domain.domain))
+      ValueDomain.of_undefined(lhs_domain.domain._narrow_by_ne(rhs_domain))
     end
 
     def_delegator :@domain, :_narrow_nil_by_ne
@@ -6329,7 +6618,7 @@ module C #:nodoc:
     def_delegator :@domain, :_narrow_greater_than_by_ne
 
     def _narrow_by_lt(rhs_domain, lhs_domain = self)
-      ValueDomain.of_undefined(rhs_domain._narrow_by_lt(lhs_domain.domain))
+      ValueDomain.of_undefined(lhs_domain.domain._narrow_by_lt(rhs_domain))
     end
 
     def_delegator :@domain, :_narrow_nil_by_lt
@@ -6339,7 +6628,7 @@ module C #:nodoc:
     def_delegator :@domain, :_narrow_greater_than_by_lt
 
     def _narrow_by_gt(rhs_domain, lhs_domain = self)
-      ValueDomain.of_undefined(rhs_domain._narrow_by_gt(lhs_domain.domain))
+      ValueDomain.of_undefined(lhs_domain.domain._narrow_by_gt(rhs_domain))
     end
 
     def_delegator :@domain, :_narrow_nil_by_gt
@@ -6348,6 +6637,13 @@ module C #:nodoc:
     def_delegator :@domain, :_narrow_less_than_by_gt
     def_delegator :@domain, :_narrow_greater_than_by_gt
 
+    def_delegator :@domain, :_widen_by_eq
+    def_delegator :@domain, :_widen_by_ne
+    def_delegator :@domain, :_widen_by_lt
+    def_delegator :@domain, :_widen_by_gt
+    def_delegator :@domain, :_widen_by_le
+    def_delegator :@domain, :_widen_by_ge
+
     def inversion
       ValueDomain.of_undefined(@domain.inversion)
     end
@@ -6398,6 +6694,40 @@ module C #:nodoc:
       rhs_domain + lhs_domain
     end
 
+    def *(rhs_domain)
+      ValueDomain.of_undefined(@domain * rhs_domain)
+    end
+
+    def _mul_nil(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes UndefinedValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_unlimited(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes UndefinedValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_equal_to(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes UndefinedValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_less_than(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes UndefinedValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_greater_than(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes UndefinedValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
     def /(rhs_domain)
       ValueDomain.of_undefined(@domain / rhs_domain)
     end
@@ -6883,6 +7213,34 @@ module C #:nodoc:
       ValueDomain.of_ambiguous(@undefined)
     end
 
+    def widen(operator_symbol, operand_value_domain)
+      self
+    end
+
+    def _widen_by_eq(rhs_domain, lhs_domain = self)
+      ValueDomain.of_ambiguous(@undefined)
+    end
+
+    def _widen_by_ne(rhs_domain, lhs_domain = self)
+      ValueDomain.of_ambiguous(@undefined)
+    end
+
+    def _widen_by_lt(rhs_domain, lhs_domain = self)
+      ValueDomain.of_ambiguous(@undefined)
+    end
+
+    def _widen_by_gt(rhs_domain, lhs_domain = self)
+      ValueDomain.of_ambiguous(@undefined)
+    end
+
+    def _widen_by_le(rhs_domain, lhs_domain = self)
+      ValueDomain.of_ambiguous(@undefined)
+    end
+
+    def _widen_by_ge(rhs_domain, lhs_domain = self)
+      ValueDomain.of_ambiguous(@undefined)
+    end
+
     def inversion
       self
     end
@@ -6933,6 +7291,40 @@ module C #:nodoc:
       rhs_domain + lhs_domain
     end
 
+    def *(rhs_domain)
+      self
+    end
+
+    def _mul_nil(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes AmbiguousValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_unlimited(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes AmbiguousValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_equal_to(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes AmbiguousValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_less_than(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes AmbiguousValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
+    def _mul_greater_than(lhs_domain, rhs_domain = self)
+      # NOTE: `LHS * RHS' equals to `RHS * LHS'.
+      #       This method invokes AmbiguousValueDomain#*.
+      rhs_domain * lhs_domain
+    end
+
     def /(rhs_domain)
       self
     end
@@ -7496,4 +7888,12 @@ if $0 == __FILE__
   d2 = ValueDomain.equal_to(127)
   p d1, d2
   p d1 < d2
+
+  puts "---"
+  d1 = ValueDomain.greater_than_or_equal_to(-2147483648)
+  d1 = d1.intersection(ValueDomain.less_than_or_equal_to(2147483647))
+  d1 = ValueDomain.of_undefined(d1)
+  d2 = ValueDomain.equal_to(1)
+  p d1, d2
+  p d1.narrow(:!=, d2)
 end