adlint 1.10.0 → 1.12.0

data/lib/adlint/c/interp.rb

@@ -37,6 +37,7 @@ require "adlint/c/syntax"
 require "adlint/c/expr"
 require "adlint/c/conv"
 require "adlint/c/option"
+require "adlint/c/operator"
 require "adlint/c/util"
 
 module AdLint #:nodoc:
@@ -55,18 +56,13 @@ module C #:nodoc:
     end
 
     class ExecutionDriver < SyntaxTreeVisitor
-      include InterpreterMediator
-
       def initialize(interpreter)
         @interpreter = interpreter
       end
 
-      def visit_declaration(node) interpret(node) end
-      def visit_ansi_function_definition(node) interpret(node) end
-      def visit_kandr_function_definition(node) interpret(node) end
-
-      private
-      def interpreter; @interpreter end
+      def visit_declaration(node) @interpreter.execute(node) end
+      def visit_ansi_function_definition(node) @interpreter.execute(node) end
+      def visit_kandr_function_definition(node) @interpreter.execute(node) end
     end
     private_constant :ExecutionDriver
   end
@@ -1216,16 +1212,17 @@ module C #:nodoc:
       iteration_statement.varying_variable_names.each do |name|
         if variable = variable_named(name)
           varying_vars[variable] = variable.value.dup
-          variable.widen_value_domain!(:==, variable.type.arbitrary_value)
+          variable.widen_value_domain!(Operator::EQ,
+                                       variable.type.arbitrary_value)
         end
       end
 
       varying_vars.each do |variable, orig_value|
         case deduct_variable_varying_path(variable, iteration_statement)
         when :increase
-          variable.narrow_value_domain!(:>=, orig_value)
+          variable.narrow_value_domain!(Operator::GE, orig_value)
         when :decrease
-          variable.narrow_value_domain!(:<=, orig_value)
+          variable.narrow_value_domain!(Operator::LE, orig_value)
         end
       end
     end

data/lib/adlint/c/message.rb

@@ -15024,5 +15024,25 @@ module C #:nodoc:
     end
   end
 
+  class W9003 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_implicit_conv_performed += method(:check)
+    end
+
+    private
+    def check(initializer_or_expression, original_variable, result_variable)
+      from_type = original_variable.type
+      to_type = result_variable.type
+
+      unless from_type.standard? && to_type.standard?
+        unless from_type.convertible?(to_type)
+          W(:W9003, initializer_or_expression.location, from_type.brief_image)
+        end
+      end
+    end
+  end
+
 end
 end

data/lib/adlint/c/message_shima.rb

@@ -308,6 +308,69 @@ module C #:nodoc:
     end
   end
 
+  class W0732 < PassiveMessageDetection
+    def initialize(context)
+      super
+      visitor = context[:c_visitor]
+      visitor.enter_logical_and_expression += method(:check)
+    end
+
+    private
+    def check(expr)
+      if expr.lhs_operand.arithmetic? || expr.lhs_operand.bitwise?
+        if expr.rhs_operand.arithmetic? || expr.rhs_operand.bitwise?
+          W(:W0732, expr.location)
+        end
+      end
+    end
+  end
+
+  class W0733 < PassiveMessageDetection
+    def initialize(context)
+      super
+      visitor = context[:c_visitor]
+      visitor.enter_logical_or_expression += method(:check)
+    end
+
+    private
+    def check(expr)
+      if expr.lhs_operand.arithmetic? || expr.lhs_operand.bitwise?
+        if expr.rhs_operand.arithmetic? || expr.rhs_operand.bitwise?
+          W(:W0733, expr.location)
+        end
+      end
+    end
+  end
+
+  class W0734 < PassiveMessageDetection
+    def initialize(context)
+      super
+      visitor = context[:c_visitor]
+      visitor.enter_logical_and_expression += method(:check)
+      visitor.enter_logical_or_expression += method(:check)
+    end
+
+    private
+    def check(expr)
+      if expr.lhs_operand.arithmetic? || expr.lhs_operand.bitwise?
+        unless expr.rhs_operand.arithmetic? || expr.rhs_operand.bitwise?
+          W(:W0734, expr.lhs_operand.location)
+        end
+      end
+    end
+  end
+
+  class W0735 < W0734
+    private
+    def check(expr)
+      if expr.rhs_operand.arithmetic? || expr.rhs_operand.bitwise?
+        unless expr.lhs_operand.arithmetic? || expr.lhs_operand.bitwise?
+          W(:W0735, expr.rhs_operand.location)
+        end
+      end
+    end
+  end
+
   class W0781 < PassiveMessageDetection
     def initialize(context)
       super

data/lib/adlint/c/object.rb

@@ -34,6 +34,7 @@ require "adlint/c/syntax"
 require "adlint/c/value"
 require "adlint/c/scope"
 require "adlint/c/seqp"
+require "adlint/c/operator"
 
 module AdLint #:nodoc:
 module C #:nodoc:
@@ -209,23 +210,23 @@ module C #:nodoc:
       assign!(self.type.undefined_value)
     end
 
-    def narrow_value_domain!(operator_symbol, value)
+    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_symbol, value.coerce_to(type))
+      self_value.narrow_domain!(operator, value.coerce_to(type))
       self_value.exist?
     end
 
-    def widen_value_domain!(operator_symbol, value)
+    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_symbol, value.coerce_to(type))
+      self_value.widen_domain!(operator, value.coerce_to(type))
       self_value.exist?
     end
 

data/lib/adlint/c/operator.rb

@@ -0,0 +1,99 @@
+# Comparison operator of controlling expressions.
+#
+# Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# License::   GPLv3+: GNU General Public License version 3 or later
+#
+# Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+
+#--
+#     ___    ____  __    ___   _________
+#    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
+#   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
+#  / __  |/ /_/ / /___/ / /|  /  / /
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+#
+# This file is part of AdLint.
+#
+# AdLint is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# AdLint is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# AdLint.  If not, see <http://www.gnu.org/licenses/>.
+#
+#++
+
+module AdLint #:nodoc:
+module C #:nodoc:
+
+  class Operator
+    def initialize(token_or_symbol)
+      case token_or_symbol
+      when Token
+        @sym = token_or_symbol.type.to_sym
+      when ::Symbol
+        @sym = token_or_symbol
+      end
+    end
+
+    def to_sym
+      @sym
+    end
+
+    def eql?(rhs)
+      case rhs
+      when Operator
+        @sym == rhs.to_sym
+      else
+        super
+      end
+    end
+
+    alias :== :eql?
+
+    def hash
+      @sym.hash
+    end
+  end
+
+  class ComparisonOperator < Operator
+    def for_complement
+      case self
+      when Operator::EQ then Operator::NE
+      when Operator::NE then Operator::EQ
+      when Operator::LT then Operator::GE
+      when Operator::GT then Operator::LE
+      when Operator::LE then Operator::GT
+      when Operator::GE then Operator::LT
+      else self
+      end
+    end
+
+    def for_commutation
+      case self
+      when Operator::LT then Operator::GT
+      when Operator::GT then Operator::LT
+      when Operator::LE then Operator::GE
+      when Operator::GE then Operator::LE
+      else self
+      end
+    end
+  end
+
+  class Operator
+    EQ = ComparisonOperator.new(:==)
+    NE = ComparisonOperator.new(:!=)
+    LT = ComparisonOperator.new(:<)
+    GT = ComparisonOperator.new(:>)
+    LE = ComparisonOperator.new(:<=)
+    GE = ComparisonOperator.new(:>=)
+  end
+
+end
+end

data/lib/adlint/c/parser.rb

@@ -1387,7 +1387,7 @@ module_eval(<<'.,.,', 'parser.y', 195)
   def _reduce_15(val, _values, result)
             checkpoint(val[0].location)
 
-        result = PostfixIncrementExpression.new(val[0], val[1])
+        result = PostfixIncrementExpression.new(val[1], val[0])
         result.head_token = val[0].head_token
         result.tail_token = val[1]
       
@@ -1399,7 +1399,7 @@ module_eval(<<'.,.,', 'parser.y', 203)
   def _reduce_16(val, _values, result)
             checkpoint(val[0].location)
 
-        result = PostfixDecrementExpression.new(val[0], val[1])
+        result = PostfixDecrementExpression.new(val[1], val[0])
         result.head_token = val[0].head_token
         result.tail_token = val[1]
       

data/lib/adlint/c/parser.y

@@ -195,7 +195,7 @@ postfix_expression
       {
         checkpoint(val[0].location)
 
-        result = PostfixIncrementExpression.new(val[0], val[1])
+        result = PostfixIncrementExpression.new(val[1], val[0])
         result.head_token = val[0].head_token
         result.tail_token = val[1]
       }
@@ -203,7 +203,7 @@ postfix_expression
       {
         checkpoint(val[0].location)
 
-        result = PostfixDecrementExpression.new(val[0], val[1])
+        result = PostfixDecrementExpression.new(val[1], val[0])
         result.head_token = val[0].head_token
         result.tail_token = val[1]
       }

data/lib/adlint/c/phase.rb

@@ -654,6 +654,10 @@ module C #:nodoc:
         W0729.new(context),
         W0730.new(context),
         W0731.new(context),
+        W0732.new(context),
+        W0733.new(context),
+        W0734.new(context),
+        W0735.new(context),
         W0736.new(context),
         W0737.new(context),
         W0738.new(context),
@@ -741,7 +745,8 @@ module C #:nodoc:
         W1063.new(context),
         W1064.new(context),
         W1065.new(context),
-        W9001.new(context)
+        W9001.new(context),
+        W9003.new(context)
       ]
     end
   end