adlint 2.4.0 → 2.4.6

data/lib/adlint/c/interp.rb

@@ -947,6 +947,10 @@ module C #:nodoc:
 
     def initialize(owner)
       super(owner, Statement)
+
+      # NOTE: All effective controlling expressions in the executing
+      #       iteration-statements.
+      @effective_ctrlexpr_stack = []
     end
 
     def visit_generic_labeled_statement(node)
@@ -1002,25 +1006,29 @@ module C #:nodoc:
       checkpoint(node.location)
 
       node.executed = true
-      ctrlexpr = node.expression
-      ctrlexpr_value = value_of(interpret(ctrlexpr, QUIET))
+
+      orig_ctrlexpr = node.expression
+      if orig_ctrlexpr == effective_ctrlexpr
+        ctrlexpr_value = ScalarValue.of_arbitrary
+        ctrlexpr = nil
+      else
+        ctrlexpr_value = value_of(interpret(orig_ctrlexpr))
+        ctrlexpr = orig_ctrlexpr.to_normalized_logical
+      end
       notify_if_ctrlexpr_evaled(node, ctrlexpr_value)
 
       case
       when ctrlexpr_value.must_be_true?
-        branched_eval(ctrlexpr, NARROWING, FINAL, COMPLETE) do
+        branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND, COMPLETE) do
           interpret(node.statement)
         end
       when ctrlexpr_value.may_be_true?
-        branched_eval(ctrlexpr, NARROWING, FINAL) do
+        branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND) do
           interpret(node.statement)
         end
       else
-        # NOTE: To warn about the controlling expression and to end the current
-        #       branch group of else-if sequence.
-        branched_eval(nil, NARROWING, FINAL) do
-          interpret(ctrlexpr)
-        end
+        # NOTE: To end the current branch group of else-if sequence.
+        branched_eval(nil, NARROWING, FINAL) {}
       end
     end
 
@@ -1028,23 +1036,27 @@ module C #:nodoc:
       checkpoint(node.location)
 
       node.executed = true
-      ctrlexpr = node.expression
-      ctrlexpr_value = value_of(interpret(ctrlexpr, QUIET))
+
+      orig_ctrlexpr = node.expression
+      if orig_ctrlexpr == effective_ctrlexpr
+        ctrlexpr_value = ScalarValue.of_arbitrary
+        ctrlexpr = nil
+      else
+        ctrlexpr_value = value_of(interpret(orig_ctrlexpr))
+        ctrlexpr = orig_ctrlexpr.to_normalized_logical
+      end
       notify_if_else_ctrlexpr_evaled(node, ctrlexpr_value)
 
       case
       when ctrlexpr_value.must_be_true?
-        branched_eval(ctrlexpr, NARROWING, FINAL, COMPLETE) do
+        branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND, COMPLETE) do
           interpret(node.then_statement)
         end
         return
       when ctrlexpr_value.may_be_true?
-        branched_eval(ctrlexpr, NARROWING) do
+        branched_eval(ctrlexpr, NARROWING, IMPLICIT_COND) do
           interpret(node.then_statement)
         end
-      else
-        # NOTE: To warn about the controlling expression.
-        interpret(ctrlexpr)
       end
 
       case node.else_statement
@@ -1064,22 +1076,30 @@ module C #:nodoc:
       notify_while_stmt_started(node)
 
       widen_varying_variable_value_domain(node)
-      effective_ctrlexpr = deduct_effective_controlling_expression(node)
 
-      ctrlexpr = node.expression
-      ctrlexpr_value = value_of(interpret(ctrlexpr))
+      ctrlexpr_value = value_of(interpret(node.expression))
       notify_while_ctrlexpr_evaled(node, ctrlexpr_value)
 
+      orig_ctrlexpr, ctrlexpr = node.deduct_controlling_expression
+
       case
       when ctrlexpr_value.must_be_true?
-        branched_eval(effective_ctrlexpr,
-                      NARROWING, FINAL, IMPLICIT_CONDITION, COMPLETE) do
-          interpret(node.statement)
+        begin
+          enter_iteration_statement(orig_ctrlexpr)
+          branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND, COMPLETE) do
+            interpret(node.statement)
+          end
+        ensure
+          leave_iteration_statement(orig_ctrlexpr)
         end
       when ctrlexpr_value.may_be_true?
-        branched_eval(effective_ctrlexpr,
-                      NARROWING, FINAL, IMPLICIT_CONDITION) do
-          interpret(node.statement)
+        begin
+          enter_iteration_statement(orig_ctrlexpr)
+          branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND) do
+            interpret(node.statement)
+          end
+        ensure
+          leave_iteration_statement(orig_ctrlexpr)
         end
       end
     ensure
@@ -1093,11 +1113,16 @@ module C #:nodoc:
       notify_do_stmt_started(node)
 
       widen_varying_variable_value_domain(node)
-      effective_ctrlexpr = deduct_effective_controlling_expression(node)
 
-      branched_eval(effective_ctrlexpr,
-                    NARROWING, FINAL, IMPLICIT_CONDITION, COMPLETE) do
-        interpret(node.statement)
+      orig_ctrlexpr, ctrlexpr = node.deduct_controlling_expression
+
+      begin
+        enter_iteration_statement(orig_ctrlexpr)
+        branched_eval(ctrlexpr, NARROWING, FINAL, IMPLICIT_COND, COMPLETE) do
+          interpret(node.statement)
+        end
+      ensure
+        leave_iteration_statement(orig_ctrlexpr)
       end
 
       ctrlexpr_value = value_of(interpret(node.expression))
@@ -1115,47 +1140,21 @@ module C #:nodoc:
       node.initial_statement.accept(self)
 
       widen_varying_variable_value_domain(node)
-      effective_ctrlexpr = deduct_effective_controlling_expression(node)
+      orig_ctrlexpr, ctrlexpr = node.deduct_controlling_expression
 
       node.condition_statement.executed = true
-      if ctrlexpr = node.condition_statement.expression
-        ctrlexpr_value = value_of(interpret(ctrlexpr))
+      if explicit_ctrlexpr = node.condition_statement.expression
+        ctrlexpr_value = value_of(interpret(explicit_ctrlexpr))
         notify_for_ctrlexpr_evaled(node, ctrlexpr_value)
-
-        case
-        when ctrlexpr_value.must_be_true?
-          branched_eval(effective_ctrlexpr,
-                        NARROWING, FINAL, IMPLICIT_CONDITION, COMPLETE) do
-            interpret(node.body_statement)
-            interpret(node.expression) if node.expression
-            # NOTE: To avoid that value of the controlling variable is marked
-            #       as updated at end of the for-statement.  Value of the
-            #       controlling variable is referred by the controlling
-            #       expression at the last iteration.
-            # FIXME: This re-interpretation of the controlling expression may
-            #        causes duplicative warning messages.
-            interpret(ctrlexpr)
-          end
-        when ctrlexpr_value.may_be_true?
-          branched_eval(effective_ctrlexpr,
-                        NARROWING, FINAL, IMPLICIT_CONDITION) do
-            interpret(node.body_statement)
-            interpret(node.expression) if node.expression
-            # NOTE: To avoid that value of the controlling variable is marked
-            #       as updated at end of the for-statement.  Value of the
-            #       controlling variable is referred by the controlling
-            #       expression at the last iteration.
-            # FIXME: This re-interpretation of the controlling expression may
-            #        causes duplicative warning messages.
-            interpret(ctrlexpr)
-          end
-        end
       else
-        branched_eval(effective_ctrlexpr,
-                      NARROWING, FINAL, IMPLICIT_CONDITION, COMPLETE) do
-          interpret(node.body_statement)
-          interpret(node.expression) if node.expression
-        end
+        ctrlexpr_value = ScalarValue.of_true
+      end
+
+      case
+      when ctrlexpr_value.must_be_true?
+        interpret_for_body_statement(node, orig_ctrlexpr, ctrlexpr, true)
+      when ctrlexpr_value.may_be_true?
+        interpret_for_body_statement(node, orig_ctrlexpr, ctrlexpr, false)
       end
     ensure
       notify_for_stmt_ended(node)
@@ -1171,47 +1170,21 @@ module C #:nodoc:
         notify_c99_for_stmt_started(node)
 
         widen_varying_variable_value_domain(node)
-        effective_ctrlexpr = deduct_effective_controlling_expression(node)
+        orig_ctrlexpr, ctrlexpr = node.deduct_controlling_expression
 
         node.condition_statement.executed = true
-        if ctrlexpr = node.condition_statement.expression
-          ctrlexpr_value = value_of(interpret(ctrlexpr))
+        if explicit_ctrlexpr = node.condition_statement.expression
+          ctrlexpr_value = value_of(interpret(explicit_ctrlexpr))
           notify_c99_for_ctrlexpr_evaled(node, ctrlexpr_value)
-
-          case
-          when ctrlexpr_value.must_be_true?
-            branched_eval(effective_ctrlexpr,
-                          NARROWING, FINAL, IMPLICIT_CONDITION, COMPLETE) do
-              interpret(node.body_statement)
-              interpret(node.expression) if node.expression
-              # NOTE: To avoid that value of the controlling variable is marked
-              #       as updated at end of the c99-for-statement.  Value of the
-              #       controlling variable is referred by the controlling
-              #       expression at the last iteration.
-              # FIXME: This re-interpretation of the controlling expression may
-              #        causes duplicative warning messages.
-              interpret(ctrlexpr)
-            end
-          when ctrlexpr_value.may_be_true?
-            branched_eval(effective_ctrlexpr,
-                          NARROWING, FINAL, IMPLICIT_CONDITION) do
-              interpret(node.body_statement)
-              interpret(node.expression) if node.expression
-              # NOTE: To avoid that value of the controlling variable is marked
-              #       as updated at end of the c99-for-statement.  Value of the
-              #       controlling variable is referred by the controlling
-              #       expression at the last iteration.
-              # FIXME: This re-interpretation of the controlling expression may
-              #        causes duplicative warning messages.
-              interpret(ctrlexpr)
-            end
-          end
         else
-          branched_eval(effective_ctrlexpr,
-                        NARROWING, FINAL, IMPLICIT_CONDITION, COMPLETE) do
-            interpret(node.body_statement)
-            interpret(node.expression) if node.expression
-          end
+          ctrlexpr_value = ScalarValue.of_true
+        end
+
+        case
+        when ctrlexpr_value.must_be_true?
+          interpret_for_body_statement(node, orig_ctrlexpr, ctrlexpr, true)
+        when ctrlexpr_value.may_be_true?
+          interpret_for_body_statement(node, orig_ctrlexpr, ctrlexpr, false)
         end
       end
     ensure
@@ -1277,6 +1250,33 @@ module C #:nodoc:
     end
 
     private
+    def interpret_for_body_statement(node, orig_ctrlexpr, ctrlexpr, complete)
+      enter_iteration_statement(orig_ctrlexpr)
+
+      if complete
+        branch_options = [NARROWING, FINAL, IMPLICIT_COND, COMPLETE]
+      else
+        branch_options = [NARROWING, FINAL, IMPLICIT_COND]
+      end
+
+      branched_eval(ctrlexpr, *branch_options) do
+        interpret(node.body_statement)
+        interpret(node.expression) if node.expression
+
+        if explicit_ctrlexpr = node.condition_statement.expression
+          # NOTE: To avoid that value of the controlling variable is marked
+          #       as updated at end of the for-statement.  Value of the
+          #       controlling variable is referred by the controlling
+          #       expression at the last iteration.
+          # FIXME: This re-interpretation of the controlling expression may
+          #        causes duplicative warning messages.
+          interpret(explicit_ctrlexpr)
+        end
+      end
+    ensure
+      leave_iteration_statement(orig_ctrlexpr)
+    end
+
     def uninitialize_block_local_variables(generic_labeled_statement)
       related_goto_statements = generic_labeled_statement.referrers
       return if related_goto_statements.empty?
@@ -1388,16 +1388,16 @@ module C #:nodoc:
       end
     end
 
-    def deduct_effective_controlling_expression(iteration_statement)
-      if effective_ctrlexpr = iteration_statement.deduct_controlling_expression
-        # TODO: If the controlling expression is `i == 2 || i == 5', this
-        #       expression should not be used.
-        if effective_ctrlexpr.kind_of?(EqualityExpression) &&
-            effective_ctrlexpr.operator.type == "=="
-          effective_ctrlexpr = nil
-        end
-      end
-      effective_ctrlexpr
+    def effective_ctrlexpr
+      @effective_ctrlexpr_stack.last
+    end
+
+    def enter_iteration_statement(effective_ctrlexpr)
+      @effective_ctrlexpr_stack.push(effective_ctrlexpr)
+    end
+
+    def leave_iteration_statement(effective_ctrlexpr)
+      @effective_ctrlexpr_stack.pop
     end
   end
 
@@ -1440,7 +1440,7 @@ module C #:nodoc:
     end
 
     def execute_switch_branches(variable, block_items)
-      base_options = [SMOTHER_BREAK, IMPLICIT_CONDITION, NARROWING]
+      base_options = [SMOTHER_BREAK, IMPLICIT_COND, NARROWING]
       base_options.push(COMPLETE) if complete?(block_items)
 
       index = 0

data/lib/adlint/c/object.rb

@@ -219,23 +219,15 @@ module C #:nodoc:
     end
 
     def narrow_value_domain!(operator, value)
-      unless self_value = modifiable_value
-        assign!(type.arbitrary_value)
-        self_value = modifiable_value
-      end
-
-      self_value.narrow_domain!(operator, value.coerce_to(type))
-      self_value.exist?
+      assign!(type.arbitrary_value) unless self.value
+      self.value.narrow_domain!(operator, value.coerce_to(type))
+      self.value.exist?
     end
 
     def widen_value_domain!(operator, value)
-      unless self_value = modifiable_value
-        assign!(type.nil_value)
-        self_value = modifiable_value
-      end
-
-      self_value.widen_domain!(operator, value.coerce_to(type))
-      self_value.exist?
+      assign!(type.nil_value) unless self.value
+      self.value.widen_domain!(operator, value.coerce_to(type))
+      self.value.exist?
     end
 
     def enter_value_versioning_group
@@ -266,10 +258,6 @@ module C #:nodoc:
     def relate_to_memory(memory)
       bind_to(memory)
     end
-
-    def modifiable_value
-      binding.memory.read_modifiable
-    end
   end
 
   class ScopedVariable < Variable
@@ -1081,10 +1069,6 @@ module C #:nodoc:
     end
 
     def read
-      @value ? @frozen_value ||= FrozenValue.new(@value) : nil
-    end
-
-    def read_modifiable
       @value
     end
 

data/lib/adlint/c/operator.rb

@@ -46,6 +46,10 @@ module C #:nodoc:
       @sym
     end
 
+    def to_s
+      @sym.to_s
+    end
+
     def eql?(rhs)
       case rhs
       when Operator

data/lib/adlint/c/option.rb

@@ -43,7 +43,7 @@ module C #:nodoc:
     FIRST = :first
     FINAL = :final
     SMOTHER_BREAK = :smother_break
-    IMPLICIT_CONDITION = :implicit_condition
+    IMPLICIT_COND = :implicit_cond
   end
 
   module BranchGroupOptions

data/lib/adlint/c/parser.rb

@@ -2796,7 +2796,7 @@ module_eval(<<'.,.,', 'parser.y', 1229)
   def _reduce_166(val, _values, result)
             checkpoint(val[0].location)
 
-        val[3].full = true
+        val[4].full = true
         result = ArrayDeclarator.new(val[0], val[4])
         result.head_token = val[0].head_token
         result.tail_token = val[5]

data/lib/adlint/c/parser.y

@@ -1229,7 +1229,7 @@ direct_declarator
       {
         checkpoint(val[0].location)
 
-        val[3].full = true
+        val[4].full = true
         result = ArrayDeclarator.new(val[0], val[4])
         result.head_token = val[0].head_token
         result.tail_token = val[5]