adlint 1.0.0 → 1.2.0

data/lib/adlint/c/mediator.rb

@@ -240,6 +240,7 @@ module C #:nodoc:
     def_delegator :interpreter, :notify_branch_ended
     def_delegator :interpreter, :notify_translation_unit_started
     def_delegator :interpreter, :notify_translation_unit_ended
+    def_delegator :interpreter, :notify_sequence_point_reached
 
     private
     def interpreter

data/lib/adlint/c/message.rb

@@ -6998,7 +6998,6 @@ module C #:nodoc:
     private
     def check(expression, variable)
       return if variable.scope.global? || variable.binding.memory.static?
-      return if variable.temporary?
 
       if variable.named? && variable.value.must_be_undefined?
         W(:W0459, expression.location, variable.name)
@@ -10544,6 +10543,150 @@ module C #:nodoc:
     end
   end
 
+  class W0597 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_sequence_point_reached += method(:commit_changes)
+      interp.on_variable_value_updated += method(:update_variable)
+      @update_count = Hash.new(0)
+    end
+
+    private
+    def commit_changes(sequence_point)
+      @update_count.each do |var, count|
+        W(:W0597, sequence_point.last_node.location, var.name) if count > 1
+      end
+      @update_count = Hash.new(0)
+    end
+
+    def update_variable(expression, variable)
+      @update_count[variable] += 1 if variable.named?
+    end
+  end
+
+  class W0598 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_sequence_point_reached += method(:commit_changes)
+      interp.on_variable_value_updated += method(:update_variable)
+      @update_count = [Hash.new(0)]
+    end
+
+    private
+    def commit_changes(sequence_point)
+      if sequence_point.obvious?
+        updated_vars = @update_count.map { |hash| hash.keys }.flatten.uniq
+        updated_vars.each do |var|
+          if @update_count.count { |hash| hash.include?(var) } > 1
+            if @update_count.map { |hash| hash[var] }.max == 1
+              W(:W0598, sequence_point.last_node.location, var.name)
+            end
+          end
+        end
+        @update_count = [Hash.new(0)]
+      else
+        @update_count.push(Hash.new(0))
+      end
+    end
+
+    def update_variable(expression, variable)
+      @update_count.last[variable] += 1 if variable.named?
+    end
+  end
+
+  class W0599 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_sequence_point_reached += method(:commit_changes)
+      interp.on_variable_value_referred += method(:refer_variable)
+      interp.on_variable_value_updated += method(:update_variable)
+      @refer_count = Hash.new(0)
+      @update_count = Hash.new(0)
+    end
+
+    private
+    def commit_changes(sequence_point)
+      (@refer_count.keys & @update_count.keys).each do |var|
+        if @refer_count[var] > 0 && @update_count[var] > 0
+          W(:W0599, sequence_point.last_node.location, var.name)
+        end
+      end
+      @refer_count = Hash.new(0)
+      @update_count = Hash.new(0)
+    end
+
+    def refer_variable(expression, variable)
+      @refer_count[variable] += 1 if variable.named?
+    end
+
+    def update_variable(expression, variable)
+      if variable.named?
+        case expression
+        when SimpleAssignmentExpression, CompoundAssignmentExpression
+          # NOTE: The expression-statement `i = i + j;' should not be warned.
+          #       But the expression-statement `i = i++ + j;' should be warned.
+          #       So, side-effects of the assignment-expression are given
+          #       special treatment.
+        else
+          @update_count[variable] += 1
+        end
+      end
+    end
+  end
+
+  class W0600 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_sequence_point_reached += method(:commit_changes)
+      interp.on_variable_value_referred += method(:refer_variable)
+      interp.on_variable_value_updated += method(:update_variable)
+      @refer_count = [Hash.new(0)]
+      @update_count = [Hash.new(0)]
+    end
+
+    private
+    def commit_changes(sequence_point)
+      if sequence_point.obvious?
+        updated_vars = @update_count.map { |hash| hash.keys }.flatten.uniq
+        access_count = @refer_count.zip(@update_count)
+
+        updated_vars.each do |var|
+          count = access_count.count { |rhash, uhash|
+            rhash.include?(var) && !uhash.include?(var)
+          }
+          W(:W0600, sequence_point.last_node.location, var.name) if count > 0
+        end
+        @refer_count = [Hash.new(0)]
+        @update_count = [Hash.new(0)]
+      else
+        @refer_count.push(Hash.new(0))
+        @update_count.push(Hash.new(0))
+      end
+    end
+
+    def refer_variable(expression, variable)
+      @refer_count.last[variable] += 1 if variable.named?
+    end
+
+    def update_variable(expression, variable)
+      if variable.named?
+        case expression
+        when SimpleAssignmentExpression, CompoundAssignmentExpression
+          # NOTE: The expression-statement `i = i + j;' should not be warned.
+          #       But the expression-statement `i = i++ + j;' should be warned.
+          #       So, side-effects of the assignment-expression are given
+          #       special treatment.
+        else
+          @update_count.last[variable] += 1
+        end
+      end
+    end
+  end
+
   class W0605 < PassiveMessageDetection
     def initialize(context)
       super

data/lib/adlint/c/object.rb

@@ -32,6 +32,7 @@
 require "adlint/util"
 require "adlint/c/value"
 require "adlint/c/scope"
+require "adlint/c/seqp"
 
 module AdLint #:nodoc:
 module C #:nodoc:
@@ -221,7 +222,7 @@ module C #:nodoc:
 
     def inner_variable_at(index)
       if @type.array?
-        # TODO: If linear serching is too slow, use an index of inner
+        # TODO: If linear searching is too slow, use an index of inner
         #       variables.
         target_name = ArrayElementVariable.component_name_of(index)
         @inner_variables.find { |iv| iv.component_name == target_name }
@@ -232,7 +233,7 @@ module C #:nodoc:
 
     def inner_variable_named(name)
       if @type.composite?
-        # TODO: If linear serching is too slow, use an index of inner
+        # TODO: If linear searching is too slow, use an index of inner
         #       variables.
         target_name = CompositeMemberVariable.component_name_of(name)
         @inner_variables.find { |iv| iv.component_name == target_name }
@@ -624,9 +625,9 @@ module C #:nodoc:
       subclass_responsibility
     end
 
-    def call(interpreter, args)
+    def call(interpreter, funcall_expr, args)
       assign_arguments_to_parameters(interpreter, args)
-      return_values_via_pointer_arguments(interpreter, args)
+      return_values_via_pointer_arguments(interpreter, funcall_expr, args)
 
       if type.return_type.function?
         interpreter.temporary_variable
@@ -673,7 +674,7 @@ module C #:nodoc:
       end
     end
 
-    def return_values_via_pointer_arguments(interpreter, args)
+    def return_values_via_pointer_arguments(interpreter, funcall_expr, args)
       args.zip(type.parameter_types).each do |(arg, expr), param_type|
         next if param_type && param_type.void?
         next unless arg.variable? && arg.value.scalar?
@@ -686,6 +687,14 @@ module C #:nodoc:
               pointee.designated_by_lvalue? && pointee.variable?
             pointee.assign!(pointee.type.return_value)
             interpreter.notify_variable_value_updated(expr, pointee)
+
+            # NOTE: Returning a value via a pointer parameter can be considered
+            #       as an evaluation of a statement-expression with a
+            #       simple-assignment-expression.
+            #       Control will reach to a sequence-point at the end of a full
+            #       expression.
+            interpreter.notify_sequence_point_reached(
+              SequencePoint.new(funcall_expr, false))
           end
         end
       end
@@ -705,7 +714,7 @@ module C #:nodoc:
       true
     end
 
-    def call(interpreter, args)
+    def call(interpreter, funcall_expr, args)
       case name
       when "exit", "_exit", "abort"
         BreakEvent.of_return.throw