adlint 1.10.0 → 1.12.0

data/lib/adlint/c/ctrlexpr.rb

@@ -34,6 +34,7 @@ require "adlint/c/object"
 require "adlint/c/mediator"
 require "adlint/c/expr"
 require "adlint/c/conv"
+require "adlint/c/operator"
 
 module AdLint #:nodoc:
 module C #:nodoc:
@@ -569,7 +570,7 @@ module C #:nodoc:
     private
     def commit_changes(narrowing)
       narrowing.narrowed_values.each do |variable, narrowed_value|
-        variable.narrow_value_domain!(:==, narrowed_value)
+        variable.narrow_value_domain!(Operator::EQ, narrowed_value)
       end
     end
   end
@@ -578,7 +579,7 @@ module C #:nodoc:
     private
     def commit_changes(narrowing)
       narrowing.narrowed_values.each do |variable, narrowed_value|
-        variable.widen_value_domain!(:==, narrowed_value)
+        variable.widen_value_domain!(Operator::EQ, narrowed_value)
       end
     end
   end
@@ -596,7 +597,8 @@ module C #:nodoc:
     private
     def commit_changes(narrowing)
       @branch_group.all_controlling_variables.each do |variable|
-        variable.narrow_value_domain!(:==, variable.type.arbitrary_value)
+        variable.narrow_value_domain!(Operator::EQ,
+                                      variable.type.arbitrary_value)
       end
       true
     end
@@ -615,7 +617,8 @@ module C #:nodoc:
     private
     def commit_changes(narrowing)
       @branch_group.all_controlling_variables.each do |variable|
-        variable.widen_value_domain!(:==, variable.type.arbitrary_value)
+        variable.widen_value_domain!(Operator::EQ,
+                                     variable.type.arbitrary_value)
       end
       true
     end
@@ -658,7 +661,7 @@ module C #:nodoc:
     def ensure_result_equal_to(value)
       if @result.variable? && @result.designated_by_lvalue?
         if @result.value.scalar? && value.scalar?
-          ensure_relation(@result, :==, value)
+          ensure_relation(@result, Operator::EQ, value)
         end
       end
     end
@@ -688,10 +691,14 @@ module C #:nodoc:
       return lhs_result, rhs_result
     end
 
-    def ensure_relation(variable, operator_symbol, value)
-      target_value = save_original_value(variable).dup
-      target_value.narrow_domain!(operator_symbol, value)
-      update_narrowed_value(variable, target_value)
+    def ensure_relation(variable, operator, value)
+      # NOTE: To avoid over-narrowing.
+      if value.definite? or
+          variable.value.contain?(value) && !value.contain?(variable.value)
+        target_value = save_original_value(variable).dup
+        target_value.narrow_domain!(operator, value)
+        update_narrowed_value(variable, target_value)
+      end
     end
 
     def save_original_value(variable)
@@ -712,7 +719,7 @@ module C #:nodoc:
 
       @narrowed_values = lhs_values.merge(rhs_values) { |key, lhs_val, rhs_val|
         result = lhs_val.dup
-        result.narrow_domain!(:==, rhs_val)
+        result.narrow_domain!(Operator::EQ, rhs_val)
         result
       }
     end
@@ -723,7 +730,7 @@ module C #:nodoc:
 
       @narrowed_values = lhs_values.merge(rhs_values) { |key, lhs_val, rhs_val|
         result = lhs_val.dup
-        result.widen_domain!(:==, rhs_val)
+        result.widen_domain!(Operator::EQ, rhs_val)
         result
       }
     end
@@ -739,7 +746,7 @@ module C #:nodoc:
   class ValueComparison < ValueDomainNarrowing
     def initialize(value_domain_manip, node, lhs_narrowing, rhs_narrowing)
       super
-      @operator_symbol = node.operator.type.to_sym
+      @operator = ComparisonOperator.new(node.operator)
       @lhs_narrowing = lhs_narrowing
       @rhs_narrowing = rhs_narrowing
     end
@@ -747,59 +754,53 @@ module C #:nodoc:
     private
     def do_narrowing
       @lhs_narrowing.execute!
-      lhs_variable = object_to_variable(@lhs_narrowing.result)
+      lhs_var = object_to_variable(@lhs_narrowing.result)
 
       @rhs_narrowing.execute!
-      rhs_variable = object_to_variable(@rhs_narrowing.result)
+      rhs_var = object_to_variable(@rhs_narrowing.result)
 
-      unless lhs_variable.type.scalar? && rhs_variable.type.scalar?
+      unless lhs_var.type.scalar? && rhs_var.type.scalar?
         return temporary_variable(int_type)
       end
 
-      unless lhs_variable.value.scalar? && rhs_variable.value.scalar?
+      unless lhs_var.value.scalar? && rhs_var.value.scalar?
         return temporary_variable(int_type)
       end
 
-      lhs_converted, rhs_converted =
-        do_logical_arithmetic_conversion(@node, lhs_variable, rhs_variable)
-
-      case @operator_symbol
-      when :==
-        result = temporary_variable(int_type,
-                                    lhs_converted.value == rhs_converted.value)
-      when :!=
-        result = temporary_variable(int_type,
-                                    lhs_converted.value != rhs_converted.value)
-      when :<
-        result = temporary_variable(int_type,
-                                    lhs_converted.value < rhs_converted.value)
-      when :>
-        result = temporary_variable(int_type,
-                                    lhs_converted.value > rhs_converted.value)
-      when :<=
-        result = temporary_variable(int_type,
-                                    lhs_converted.value <= rhs_converted.value)
-      when :>=
-        result = temporary_variable(int_type,
-                                    lhs_converted.value >= rhs_converted.value)
+      lhs_conv, rhs_conv =
+        do_logical_arithmetic_conversion(@node, lhs_var, rhs_var)
+
+      case @operator
+      when Operator::EQ
+        result = temporary_variable(int_type, lhs_conv.value == rhs_conv.value)
+      when Operator::NE
+        result = temporary_variable(int_type, lhs_conv.value != rhs_conv.value)
+      when Operator::LT
+        result = temporary_variable(int_type, lhs_conv.value < rhs_conv.value)
+      when Operator::GT
+        result = temporary_variable(int_type, lhs_conv.value > rhs_conv.value)
+      when Operator::LE
+        result = temporary_variable(int_type, lhs_conv.value <= rhs_conv.value)
+      when Operator::GE
+        result = temporary_variable(int_type, lhs_conv.value >= rhs_conv.value)
       else
-        # NOTREACHED
+        __NOTREACHED__
       end
 
-      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)
+      case @operator
+      when Operator::EQ, Operator::NE
+        notify_equality_expr_evaled(@node, lhs_conv, rhs_conv, result)
+      when Operator::LT, Operator::GT, Operator::LE, Operator::GE
+        notify_relational_expr_evaled(@node, lhs_conv, rhs_conv, result)
+      else
+        __NOTREACHED__
       end
 
       case
-      when lhs_converted.designated_by_lvalue?
-        ensure_relation(lhs_converted, @operator_symbol, rhs_converted.value)
-      when rhs_converted.designated_by_lvalue?
-        ensure_relation(rhs_converted, @operator_symbol, lhs_converted.value)
+      when lhs_conv.designated_by_lvalue?
+        ensure_relation(lhs_conv, @operator, rhs_conv.value)
+      when rhs_conv.designated_by_lvalue?
+        ensure_relation(rhs_conv, @operator.for_commutation, lhs_conv.value)
       else
         # NOTE: Domain of the rvalue should not be narrowed.
       end