adlint 2.4.0 → 2.4.6

data/lib/adlint/c/syntax.rb

@@ -32,6 +32,7 @@
 require "adlint/symbol"
 require "adlint/util"
 require "adlint/c/seqp"
+require "adlint/c/operator"
 
 module AdLint #:nodoc:
 module C #:nodoc:
@@ -434,9 +435,9 @@ module C #:nodoc:
     end
 
     def constant?(enumerator_table)
-      object_specifiers.all? { |object_specifier|
+      object_specifiers.all? do |object_specifier|
         enumerator_table.lookup(object_specifier.identifier.value)
-      }
+      end
     end
 
     def logical?
@@ -457,9 +458,25 @@ module C #:nodoc:
       }.object_specifiers
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      subclass_responsibility
+    end
+
+    def to_complemental_logical
+      # NOTE: This method must be invoked on a normalized expression.
+      subclass_responsibility
+    end
+
     def to_s
       subclass_responsibility
     end
+
+    private
+    def create_normalized_logical_of(expression)
+      EqualityExpression.new(Token.new("!=", "!=", expression.location),
+                             GroupedExpression.new(expression),
+                             ConstantSpecifier.of_zero(expression.location))
+    end
   end
 
   class ErrorExpression < Expression
@@ -488,6 +505,14 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      self
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       @error_token.value
     end
@@ -528,6 +553,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       @identifier.value
     end
@@ -539,6 +577,10 @@ module C #:nodoc:
   end
 
   class ConstantSpecifier < PrimaryExpression
+    def self.of_zero(location = nil)
+      self.new(Token.new(:CONSTANT, "0", location || Location.new))
+    end
+
     def initialize(constant)
       super()
       @constant = constant
@@ -578,6 +620,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       @constant.value
     end
@@ -620,6 +675,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       @literal.value
     end
@@ -658,6 +726,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       @token.value
     end
@@ -672,6 +753,8 @@ module C #:nodoc:
     def initialize(expression)
       super()
       @expression = expression
+      self.head_token = expression.head_token
+      self.tail_token = expression.tail_token
     end
 
     attr_reader :expression
@@ -696,6 +779,20 @@ module C #:nodoc:
       @expression.bitwise?
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        GroupedExpression.new(
+          @expression.to_normalized_logical(parent_expression))
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      GroupedExpression.new(@expression.to_complemental_logical)
+    end
+
     def to_s
       "(#{expression.to_s})"
     end
@@ -744,6 +841,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       "#{@expression.to_s}[#{@array_subscript.to_s}]"
     end
@@ -781,6 +891,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       "#{@expression.to_s}(" +
         @argument_expressions.map { |expr| expr.to_s }.join(",") + ")"
@@ -819,6 +942,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       "#{@expression.to_s}.#{@identifier.value}"
     end
@@ -855,6 +991,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       "#{@expression.to_s}->#{@identifier.value}"
     end
@@ -891,6 +1040,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       "#{@expression.to_s}.#{@constant.value}"
     end
@@ -927,6 +1089,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       "#{@expression.to_s}->#{@constant.value}"
     end
@@ -961,6 +1136,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       "#{@operand.to_s}++"
     end
@@ -995,6 +1183,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       "#{@operand.to_s}--"
     end
@@ -1031,6 +1232,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       "(#{@type_name.to_s}){" +
         @initializers.map { |ini| ini.to_s }.join(",") + "}"
@@ -1082,6 +1296,19 @@ module C #:nodoc:
     def bitwise?
       false
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
   end
 
   class PrefixDecrementExpression < UnaryExpression
@@ -1100,6 +1327,19 @@ module C #:nodoc:
     def bitwise?
       false
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
   end
 
   class AddressExpression < UnaryExpression
@@ -1118,6 +1358,19 @@ module C #:nodoc:
     def bitwise?
       false
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
   end
 
   class IndirectionExpression < UnaryExpression
@@ -1136,6 +1389,19 @@ module C #:nodoc:
     def bitwise?
       false
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
   end
 
   class UnaryArithmeticExpression < UnaryExpression
@@ -1154,6 +1420,30 @@ module C #:nodoc:
     def bitwise?
       operator.type == "~"
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      if operator.type == "!"
+        normalized_operand = @operand.to_normalized_logical
+        GroupedExpression.new(normalized_operand.to_complemental_logical)
+      else
+        case parent_expression
+        when nil, LogicalAndExpression, LogicalOrExpression
+          create_normalized_logical_of(self)
+        else
+          self
+        end
+      end
+    end
+
+    def to_complemental_logical
+      if operator.type == "!"
+        # NOTE: `!' expression should be normalized into an equality-expression
+        #       before invoking #to_complemental_logical.
+        __NOTREACHED__
+      else
+        self
+      end
+    end
   end
 
   class SizeofExpression < UnaryExpression
@@ -1173,6 +1463,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       "sizeof(#{@operand.to_s})"
     end
@@ -1195,6 +1498,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       "sizeof(#{@operand.to_s})"
     end
@@ -1217,6 +1533,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       "alignof(#{@operand.to_s})"
     end
@@ -1239,6 +1568,19 @@ module C #:nodoc:
       false
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       "alignof(#{@operand.to_s})"
     end
@@ -1274,6 +1616,19 @@ module C #:nodoc:
       @operand.bitwise?
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       "(#{@type_name.to_s}) #{@operand.to_s}"
     end
@@ -1326,6 +1681,19 @@ module C #:nodoc:
     def bitwise?
       false
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
   end
 
   class AdditiveExpression < BinaryExpression
@@ -1344,6 +1712,19 @@ module C #:nodoc:
     def bitwise?
       false
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
   end
 
   class ShiftExpression < BinaryExpression
@@ -1362,6 +1743,19 @@ module C #:nodoc:
     def bitwise?
       true
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
   end
 
   class RelationalExpression < BinaryExpression
@@ -1380,6 +1774,16 @@ module C #:nodoc:
     def bitwise?
       false
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      self
+    end
+
+    def to_complemental_logical
+      operator = ComparisonOperator.new(@operator).for_complement.to_s
+      operator_token = Token.new(operator, operator, @operator.location)
+      RelationalExpression.new(operator_token, @lhs_operand, @rhs_operand)
+    end
   end
 
   class EqualityExpression < BinaryExpression
@@ -1398,6 +1802,16 @@ module C #:nodoc:
     def bitwise?
       false
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      self
+    end
+
+    def to_complemental_logical
+      operator = ComparisonOperator.new(@operator).for_complement.to_s
+      operator_token = Token.new(operator, operator, @operator.location)
+      EqualityExpression.new(operator_token, @lhs_operand, @rhs_operand)
+    end
   end
 
   class AndExpression < BinaryExpression
@@ -1416,6 +1830,19 @@ module C #:nodoc:
     def bitwise?
       true
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
   end
 
   class ExclusiveOrExpression < BinaryExpression
@@ -1434,6 +1861,19 @@ module C #:nodoc:
     def bitwise?
       true
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
   end
 
   class InclusiveOrExpression < BinaryExpression
@@ -1452,6 +1892,19 @@ module C #:nodoc:
     def bitwise?
       true
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
   end
 
   class LogicalAndExpression < BinaryExpression
@@ -1489,6 +1942,18 @@ module C #:nodoc:
     def bitwise?
       false
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      LogicalAndExpression.new(@operator,
+                               @lhs_operand.to_normalized_logical(self),
+                               @rhs_operand.to_normalized_logical(self))
+    end
+
+    def to_complemental_logical
+      LogicalOrExpression.new(Token.new("||", "||", @operator.location),
+                              @lhs_operand.to_complemental_logical,
+                              @rhs_operand.to_complemental_logical)
+    end
   end
 
   class LogicalOrExpression < BinaryExpression
@@ -1526,6 +1991,18 @@ module C #:nodoc:
     def bitwise?
       false
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      LogicalOrExpression.new(@operator,
+                              @lhs_operand.to_normalized_logical(self),
+                              @rhs_operand.to_normalized_logical(self))
+    end
+
+    def to_complemental_logical
+      LogicalAndExpression.new(Token.new("&&", "&&", @operator.location),
+                               @lhs_operand.to_complemental_logical,
+                               @rhs_operand.to_complemental_logical)
+    end
   end
 
   class ConditionalExpression < Expression
@@ -1585,6 +2062,19 @@ module C #:nodoc:
       @then_expression.bitwise? || @else_expression.bitwise?
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
+
     def to_s
       "#{@condition.to_s} ? " +
         "#{@then_expression.to_s} : #{@else_expression.to_s}"
@@ -1614,6 +2104,19 @@ module C #:nodoc:
     def bitwise?
       rhs_operand.bitwise?
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
   end
 
   class CompoundAssignmentExpression < BinaryExpression
@@ -1632,6 +2135,19 @@ module C #:nodoc:
     def bitwise?
       ["<<=", ">>=", "&=", "^=", "|="].include?(operator.type)
     end
+
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(self)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      self
+    end
   end
 
   class CommaSeparatedExpression < Expression
@@ -1663,6 +2179,19 @@ module C #:nodoc:
       @expressions.last.bitwise?
     end
 
+    def to_normalized_logical(parent_expression = nil)
+      case parent_expression
+      when nil, LogicalAndExpression, LogicalOrExpression
+        create_normalized_logical_of(@expressions.last)
+      else
+        self
+      end
+    end
+
+    def to_complemental_logical
+      @expressions.last.to_complemental_logical
+    end
+
     def to_s
       @expressions.map { |expr| expr.to_s }.join(",")
     end
@@ -3067,10 +3596,10 @@ module C #:nodoc:
     end
 
     private
-    def deduct_controlling_expression_candidates(expressions)
+    def deduct_controlling_expression_candidates(rough_candidates)
       varying_var_names = varying_variable_names
-      expressions.compact.select do |expr|
-        collect_object_specifiers(expr).any? do |os|
+      rough_candidates.select do |expr_pair|
+        collect_object_specifiers(expr_pair.first).any? do |os|
           varying_var_names.include?(os.identifier.value)
         end
       end
@@ -3172,18 +3701,20 @@ module C #:nodoc:
     end
 
     def deduct_controlling_expression
-      selection_stmts = collect_loop_breaking_selection_statements(@statement)
-      expressions = [
-        @expression,
-        *selection_stmts.map { |stmt| stmt.expression }
-      ]
+      selections = collect_loop_breaking_selection_statements(@statement)
+      rough_candidates = [
+        [@expression, @expression]
+      ] + selections.map { |stmt|
+        [stmt.expression,
+          stmt.expression.to_normalized_logical.to_complemental_logical]
+      }
 
       # FIXME: When many loop breaking selection-statements are found, how can
       #        I select one selection-statement?
       # FIXME: When the loop breaking selection-statement is a
       #        if-else-statement and the loop breaking is in the else branch,
       #        the controlling expression should be inverted.
-      deduct_controlling_expression_candidates(expressions).first
+      deduct_controlling_expression_candidates(rough_candidates).first
     end
 
     def inspect(indent = 0)
@@ -3212,18 +3743,20 @@ module C #:nodoc:
     end
 
     def deduct_controlling_expression
-      selection_stmts = collect_loop_breaking_selection_statements(@statement)
-      expressions = [
-        @expression,
-        *selection_stmts.map { |stmt| stmt.expression }
-      ]
+      selections = collect_loop_breaking_selection_statements(@statement)
+      rough_candidates = [
+        [@expression, @expression]
+      ] + selections.map { |stmt|
+        [stmt.expression,
+          stmt.expression.to_normalized_logical.to_complemental_logical]
+      }
 
       # FIXME: When many loop breaking selection-statements are found, how can
       #        I select one selection-statement?
       # FIXME: When the loop breaking selection-statement is a
       #        if-else-statement and the loop breaking is in the else branch,
       #        the controlling expression should be inverted.
-      deduct_controlling_expression_candidates(expressions).first
+      deduct_controlling_expression_candidates(rough_candidates).first
     end
 
     def inspect(indent = 0)
@@ -3255,19 +3788,20 @@ module C #:nodoc:
     end
 
     def deduct_controlling_expression
-      selection_stmts =
-        collect_loop_breaking_selection_statements(@body_statement)
-      expressions = [
-        @condition_statement.expression,
-        *selection_stmts.map { |stmt| stmt.expression }
-      ]
+      selections = collect_loop_breaking_selection_statements(@body_statement)
+      rough_candidates = [
+        [@condition_statement.expression, @condition_statement.expression]
+      ] + selections.map { |stmt|
+        [stmt.expression,
+          stmt.expression.to_normalized_logical.to_complemental_logical]
+      }
 
       # FIXME: When many loop breaking selection-statements are found, how can
       #        I select one selection-statement?
       # FIXME: When the loop breaking selection-statement is a
       #        if-else-statement and the loop breaking is in the else branch,
       #        the controlling expression should be inverted.
-      deduct_controlling_expression_candidates(expressions).first
+      deduct_controlling_expression_candidates(rough_candidates).first
     end
 
     def inspect(indent = 0)
@@ -3301,19 +3835,20 @@ module C #:nodoc:
     end
 
     def deduct_controlling_expression
-      selection_stmts =
-        collect_loop_breaking_selection_statements(@body_statement)
-      expressions = [
-        @condition_statement.expression,
-        *selection_stmts.map { |stmt| stmt.expression }
-      ]
+      selections = collect_loop_breaking_selection_statements(@body_statement)
+      rough_candidates = [
+        [@condition_statement.expression, @condition_statement.expression]
+      ] + selections.map { |stmt|
+        [stmt.expression,
+          stmt.expression.to_normalized_logical.to_complemental_logical]
+      }
 
       # FIXME: When many loop breaking selection-statements are found, how can
       #        I select one selection-statement?
       # FIXME: When the loop breaking selection-statement is a
       #        if-else-statement and the loop breaking is in the else branch,
       #        the controlling expression should be inverted.
-      deduct_controlling_expression_candidates(expressions).first
+      deduct_controlling_expression_candidates(rough_candidates).first
     end
 
     def inspect(indent = 0)