adlint 1.0.0 → 1.2.0

data/lib/adlint/c/parser.y

@@ -852,6 +852,7 @@ type_specifier
       {
         checkpoint(val[0].location)
 
+        val[2].full = true
         result = TypeofTypeSpecifier.new(val[2], nil)
         result.head_token = val[0]
         result.tail_token = val[3]
@@ -1054,6 +1055,7 @@ struct_declarator
       {
         checkpoint(val[0].location)
 
+        val[1].full = true
         result = StructDeclarator.new(nil, val[1])
         result.head_token = val[0]
         result.tail_token = val[1].tail_token
@@ -1062,6 +1064,7 @@ struct_declarator
       {
         checkpoint(val[0].location)
 
+        val[2].full = true
         result = StructDeclarator.new(val[0], val[2])
         result.head_token = val[0].head_token
         result.tail_token = val[2].tail_token
@@ -1139,6 +1142,7 @@ enumerator
       {
         checkpoint(val[0].location)
 
+        val[2].full = true
         symbol = @symbol_table.create_new_symbol(EnumeratorName, val[0])
         result = Enumerator.new(val[0], val[2], symbol)
         result.head_token = val[0]
@@ -1164,8 +1168,15 @@ declarator
         result = val[1]
         result.pointer = val[0]
         result.head_token = val[0].first
+        result.full = true
       }
     | direct_declarator
+      {
+        checkpoint(val[0].location)
+
+        result = val[0]
+        result.full = true
+      }
     ;
 
 direct_declarator
@@ -1190,6 +1201,7 @@ direct_declarator
       {
         checkpoint(val[0].location)
 
+        val[3].full = true
         result = ArrayDeclarator.new(val[0], val[3])
         result.head_token = val[0].head_token
         result.tail_token = val[4]
@@ -1206,6 +1218,7 @@ direct_declarator
       {
         checkpoint(val[0].location)
 
+        val[2].full = true
         result = ArrayDeclarator.new(val[0], val[2])
         result.head_token = val[0].head_token
         result.tail_token = val[3]
@@ -1215,6 +1228,7 @@ direct_declarator
       {
         checkpoint(val[0].location)
 
+        val[3].full = true
         result = ArrayDeclarator.new(val[0], val[4])
         result.head_token = val[0].head_token
         result.tail_token = val[5]
@@ -1224,6 +1238,7 @@ direct_declarator
       {
         checkpoint(val[0].location)
 
+        val[4].full = true
         result = ArrayDeclarator.new(val[0], val[4])
         result.head_token = val[0].head_token
         result.tail_token = val[5]
@@ -1429,6 +1444,7 @@ abstract_declarator
         result = PointerAbstractDeclarator.new(nil, val[0])
         result.head_token = val[0].first
         result.tail_token = val[0].last
+        result.full = true
       }
     | pointer direct_abstract_declarator
       {
@@ -1437,8 +1453,15 @@ abstract_declarator
         result = PointerAbstractDeclarator.new(val[1], val[0])
         result.head_token = val[0].first
         result.tail_token = val[1].tail_token
+        result.full = true
       }
     | direct_abstract_declarator
+      {
+        checkpoint(val[0].location)
+
+        result = val[0]
+        result.full = true
+      }
     ;
 
 direct_abstract_declarator
@@ -1468,6 +1491,7 @@ direct_abstract_declarator
 
         @lexer.start_identifier_translation
 
+        val[1].full = true
         result = ArrayAbstractDeclarator.new(nil, val[1])
         result.head_token = val[0]
         result.tail_token = val[2]
@@ -1484,6 +1508,7 @@ direct_abstract_declarator
       {
         checkpoint(val[0].location)
 
+        val[2].full = true
         result = ArrayAbstractDeclarator.new(val[0], val[2])
         result.head_token = val[0].head_token
         result.tail_token = val[3]
@@ -1549,6 +1574,7 @@ initializer
       {
         checkpoint(val[0].location)
 
+        val[0].full = true
         result = Initializer.new(val[0], nil)
         result.head_token = val[0].head_token
         result.tail_token = val[0].tail_token
@@ -1645,6 +1671,7 @@ labeled_statement
       {
         checkpoint(val[0].location)
 
+        val[1].full = true
         result = CaseLabeledStatement.new(val[1], val[3])
         result.head_token = val[0]
         result.tail_token = val[3].tail_token
@@ -1711,6 +1738,7 @@ expression_statement
       {
         checkpoint(val[0].location)
 
+        val[0].full = true
         result = ExpressionStatement.new(val[0])
         result.head_token = val[0].head_token
         result.tail_token = val[1]
@@ -1722,6 +1750,7 @@ selection_statement
       {
         checkpoint(val[0].location)
 
+        val[2].full = true
         result = IfStatement.new(val[2], val[4], val[3])
         result.head_token = val[0]
         result.tail_token = val[4].tail_token
@@ -1730,6 +1759,7 @@ selection_statement
       {
         checkpoint(val[0].location)
 
+        val[2].full = true
         result = IfElseStatement.new(val[2], val[4], val[6], val[3], val[5])
         result.head_token = val[0]
         result.tail_token = val[6].tail_token
@@ -1738,6 +1768,7 @@ selection_statement
       {
         checkpoint(val[0].location)
 
+        val[2].full = true
         result = SwitchStatement.new(val[2], val[4])
         result.head_token = val[0]
         result.tail_token = val[4].tail_token
@@ -1749,6 +1780,7 @@ iteration_statement
       {
         checkpoint(val[0].location)
 
+        val[2].full = true
         result = WhileStatement.new(val[2], val[4], val[3])
         result.head_token = val[0]
         result.tail_token = val[4].tail_token
@@ -1757,6 +1789,7 @@ iteration_statement
       {
         checkpoint(val[0].location)
 
+        val[4].full = true
         result = DoStatement.new(val[1], val[4], val[0], val[2])
         result.head_token = val[0]
         result.tail_token = val[6]
@@ -1774,6 +1807,7 @@ iteration_statement
       {
         checkpoint(val[0].location)
 
+        val[4].full = true
         result = ForStatement.new(val[2], val[3], val[4], val[6], val[5])
         result.head_token = val[0]
         result.tail_token = val[6].tail_token
@@ -1790,6 +1824,7 @@ iteration_statement
       {
         checkpoint(val[0].location)
 
+        val[4].full = true
         result = C99ForStatement.new(val[2], val[3], val[4], val[6], val[5])
         result.head_token = val[0]
         result.tail_token = val[6].tail_token
@@ -1842,6 +1877,7 @@ jump_statement
       {
         checkpoint(val[0].location)
 
+        val[1].full = true
         result = ReturnStatement.new(val[1])
         result.head_token = val[0]
         result.tail_token = val[2]

data/lib/adlint/c/phase.rb

@@ -558,6 +558,10 @@ module C #:nodoc:
         W0583.new(context),
         W0584.new(context),
         W0585.new(context),
+        W0597.new(context),
+        W0598.new(context),
+        W0599.new(context),
+        W0600.new(context),
         W0605.new(context),
         W0609.new(context),
         W0610.new(context),

data/lib/adlint/c/seqp.rb

@@ -0,0 +1,72 @@
+# Sequence points of C language evaluation.
+#
+# 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:
+
+  # NOTE: The ISO C99 standard saids;
+  #
+  # Annex C (informative) Sequence points
+  #
+  # 1 The following are the sequence points described in 5.1.2.3:
+  #
+  #   -- The call to a function, after the arguments have been evaluated
+  #      (6.5.2.2).
+  #   -- The end of the first operand of the following operators: logical AND
+  #      && (6.5.13); logical OR || (6.5.14); conditional ? (6.5.15); comma ,
+  #      (6.5.17).
+  #   -- The end of a full declarator: declarators (6.7.5).
+  #   -- The end of a full expression: an initializer (6.7.8); the expression
+  #      in an expression statement (6.8.3); the controlling expression of a
+  #      while or do statement (6.8.5); each of the expressions of a for
+  #      statement (6.8.5.3); the expression in a return statement (6.8.6.4).
+  #   -- Immediately before a library function returns (7.1.4).
+  #   -- After the actions associated with each formatted input/output function
+  #      conversion specifier (7.19.6, 7.24.2).
+  #   -- Immediately before and immediately after each call to a comparison
+  #      function, and also between any call to a comparison function and any
+  #      movement of the objects passed as arguments to that call (7.20.5).
+
+  class SequencePoint
+    def initialize(last_node, obvious = true)
+      @last_node = last_node
+      @obvious = obvious
+    end
+
+    attr_reader :last_node
+
+    def obvious?
+      @obvious
+    end
+  end
+
+end
+end

data/lib/adlint/c/syntax.rb

@@ -31,20 +31,142 @@
 
 require "adlint/symbol"
 require "adlint/util"
+require "adlint/c/seqp"
 
 module AdLint #:nodoc:
 module C #:nodoc:
 
+  # == DESCRIPTION
+  # === SyntaxNode class hierarchy
+  #  SyntaxNode
+  #    <--- Expression
+  #           <--- ErrorExpression
+  #           <--- PrimaryExpression
+  #                  <--- ObjectSpecifier
+  #                  <--- ConstantSpecifier
+  #                  <--- StringLiteralSpecifier
+  #                  <--- NullConstantSpecifier
+  #                  <--- GroupedExpression
+  #           <--- PostfixExpression
+  #                  <--- ArraySubscriptExpression
+  #                  <--- FunctionCallExpression
+  #                  <--- MemberAccessByValueExpression
+  #                  <--- MemberAccessByPointerExpression
+  #                  <--- BitAccessByValueExpression
+  #                  <--- BitAccessByPointerExpression
+  #                  <--- PostfixIncrementExpression
+  #                  <--- PostfixDecrementExpression
+  #                  <--- CompoundLiteralExpression
+  #           <--- UnaryExpression
+  #                  <--- PrefixIncrementExpression
+  #                  <--- PrefixDecrementExpression
+  #                  <--- AddressExpression
+  #                  <--- IndirectionExpression
+  #                  <--- UnaryArithmeticExpression
+  #                  <--- SizeofExpression
+  #                  <--- SizeofTypeExpression
+  #                  <--- AlignofExpression
+  #                  <--- AlignofTypeExpression
+  #           <--- CastExpression
+  #           <--- BinaryExpression
+  #                  <--- MultiplicativeExpression
+  #                  <--- AdditiveExpression
+  #                  <--- ShiftExpression
+  #                  <--- RelationalExpression
+  #                  <--- EqualityExpression
+  #                  <--- AndExpression
+  #                  <--- ExclusiveOrExpression
+  #                  <--- InclusiveOrExpression
+  #                  <--- LogicalAndExpression
+  #                  <--- LogicalOrExpression
+  #                  <--- ConditionalExpression
+  #                  <--- SimpleAssignmentExpression
+  #                  <--- CompoundAssignmentExpression
+  #           <--- CommaSeparatedExpression
+  #    <--- Declaration
+  #    <--- FunctionDeclaration -------------------- SymbolicElement <<module>>
+  #    <--- VariableDeclaration ----------------------+  |  |  |  |
+  #    <--- Definition                                   |  |  |  |
+  #           <--- VariableDefinition -------------------+  |  |  |
+  #                  <--- PseudoVariableDefinition          |  |  |
+  #           <--- FunctionDefinition ----------------------+  |  |
+  #                  <--- KandRFunctionDefinition              |  |
+  #                  <--- AnsiFunctionDefinition               |  |
+  #           <--- ParameterDefinition                         |  |
+  #    <--- TypeDeclaration -----------------------------------+  |
+  #           <--- TypedefDeclaration                             |
+  #           <--- StructTypeDeclaration                          |
+  #                  <--- PseudoStructTypeDeclaration             |
+  #           <--- UnionTypeDeclaration                           |
+  #                  <--- PseudoUnionTypeDeclaration              |
+  #           <--- EnumTypeDeclaration                            |
+  #                  <--- PseudoEnumTypeDeclaration               |
+  #    <--- DeclarationSpecifiers                                 |
+  #    <--- InitDeclarator                                        |
+  #    <--- TypeSpecifier                                         |
+  #           <--- StandardTypeSpecifier                          |
+  #           <--- TypedefTypeSpecifier                           |
+  #           <--- StructSpecifier                                |
+  #           <--- UnionSpecifier                                 |
+  #           <--- TypeofTypeSpecifier                            |
+  #    <--- StructDeclaration                                     |
+  #    <--- MemberDeclaration                                     |
+  #    <--- SpecifierQualifierList                                |
+  #    <--- StructDeclarator                                      |
+  #    <--- EnumSpecifier                                         |
+  #    <--- Enumerator -------------------------------------------+
+  #    <--- Declarator
+  #           <--- IdentifierDeclarator
+  #           <--- GroupedDeclarator
+  #           <--- ArrayDeclarator
+  #           <--- FunctionDeclarator
+  #                  <--- AnsiFunctionDeclarator
+  #                  <--- KandRFunctionDeclarator
+  #                  <--- AbbreviatedFunctionDeclarator
+  #           <--- AbstractDeclarator
+  #                  <--- PointerAbstractDeclarator
+  #                  <--- GroupedAbstractDeclarator
+  #                  <--- ArrayAbstractDeclarator
+  #                  <--- FunctionAbstractDeclarator
+  #    <--- ParameterTypeList
+  #    <--- ParameterDeclaration
+  #    <--- Statement
+  #           <--- ErrorStatement
+  #           <--- LabeledStatement
+  #                  <--- GenericLabeledStatement
+  #                  <--- CaseLabeledStatement
+  #                  <--- DefaultLabeledStatement
+  #           <--- CompoundStatement
+  #           <--- ExpressionStatement
+  #           <--- SelectionStatement
+  #                  <--- IfStatement
+  #                  <--- IfElseStatement
+  #                  <--- SwitchStatement
+  #           <--- IterationStatement
+  #                  <--- WhileStatement
+  #                  <--- DoStatement
+  #                  <--- ForStatement
+  #                  <--- C99ForStatement
+  #           <--- JumpStatement
+  #                  <--- GotoStatement
+  #                  <--- ContinueStatement
+  #                  <--- BreakStatement
+  #                  <--- ReturnStatement
+  #    <--- TranslationUnit
+  #    <--- TypeName
+  #    <--- Initializer
   class SyntaxNode
     include Visitable
 
     def initialize
       @head_token = nil
       @tail_token = nil
+      @subsequent_sequence_point = nil
     end
 
     attr_accessor :head_token
     attr_accessor :tail_token
+    attr_reader :subsequent_sequence_point
 
     def location
       subclass_responsibility
@@ -65,6 +187,19 @@ module C #:nodoc:
     def short_class_name
       self.class.name.sub(/\A.*::/, "")
     end
+
+    protected
+    # === DESCRIPTION
+    # Append a subsequent sequence-point of this node.
+    def append_sequence_point!
+      @subsequent_sequence_point = SequencePoint.new(self)
+    end
+
+    # === DESCRIPTION
+    # Delete a subsequent sequence-point of this node.
+    def delete_sequence_point!
+      @subsequent_sequence_point = nil
+    end
   end
 
   module SyntaxNodeCollector
@@ -246,6 +381,32 @@ module C #:nodoc:
   end
 
   class Expression < SyntaxNode
+    def initialize
+      super
+      @full = false
+    end
+
+    def full=(full_expression)
+      @full = full_expression
+
+      # NOTE: The ISO C99 standard saids;
+      #
+      # Annex C (informative) Sequence points
+      #
+      # 1 The following are the sequence points described in 5.1.2.3:
+      #
+      #   -- The end of a full expression: an initializer (6.7.8); the
+      #      expression in an expression statement (6.8.3); the controlling
+      #      expression of a while or do statement (6.8.5); each of the
+      #      expressions of a for statement (6.8.5.3); the expression in a
+      #      return statement (6.8.6.4).
+      if full_expression
+        append_sequence_point!
+      else
+        delete_sequence_point!
+      end
+    end
+
     def have_side_effect?
       subclass_responsibility
     end
@@ -801,9 +962,41 @@ module C #:nodoc:
 
   class InclusiveOrExpression < BinaryExpression; end
 
-  class LogicalAndExpression < BinaryExpression; end
+  class LogicalAndExpression < BinaryExpression
+    def initialize(operator, lhs_operand, rhs_operand)
+      super
+
+      # NOTE: The ISO C99 standard saids;
+      #
+      # 6.5.13 Logical AND operator
+      #
+      # Semantics
+      #
+      # 4 Unlike the bitwise binary & operator, the && operator guarantees
+      #   left-to-right evaluation; there is a sequence point after the
+      #   evaluation of the first operand.  If the first operand compares equal
+      #   to 0, the second operand is not evaluated.
+      @lhs_operand.append_sequence_point!
+    end
+  end
+
+  class LogicalOrExpression < BinaryExpression
+    def initialize(operator, lhs_operand, rhs_operand)
+      super
 
-  class LogicalOrExpression < BinaryExpression; end
+      # NOTE: The ISO C99 standard saids;
+      #
+      # 6.5.14 Logical OR operator
+      #
+      # Semantics
+      #
+      # 4 Unlike the bitwise | operator, the || operator guarantees
+      #   left-to-right evaluation; there is a sequence point after the
+      #   evaluation of the first operand.  If the first operand compares
+      #   unequal to 0, the second operand is not evaluated.
+      @lhs_operand.append_sequence_point!
+    end
+  end
 
   class ConditionalExpression < Expression
     def initialize(condition, then_expression, else_expression, question_mark)
@@ -812,6 +1005,22 @@ module C #:nodoc:
       @then_expression = then_expression
       @else_expression = else_expression
       @question_mark = question_mark
+
+      # NOTE: The ISO C99 standard saids;
+      #
+      # 6.5.15 Conditional operator
+      #
+      # Semantics
+      #
+      # 4 The first operand is evaluated; there is a sequence poit after its
+      #   evaluation.  The second operand is evaluated only if the first
+      #   compares unequal to 0; the third operand is evaluated only if the
+      #   first compares equal to 0; thre result is the value of the second or
+      #   third operand (whichever is evaluated), converted to the type
+      #   described below.  If an attempt is made to modify the result of a
+      #   conditional operator or to access it after the next sequence point,
+      #   the behavior is undefined.
+      @condition.append_sequence_point!
     end
 
     attr_reader :condition
@@ -856,7 +1065,8 @@ module C #:nodoc:
   class CommaSeparatedExpression < Expression
     def initialize(first_expression)
       super()
-      @expressions = [first_expression]
+      @expressions = []
+      push(first_expression)
     end
 
     attr_reader :expressions
@@ -875,6 +1085,19 @@ module C #:nodoc:
 
     def push(expression)
       @expressions.push(expression)
+
+      # NOTE: The ISO C99 standard saids;
+      #
+      # 6.5.17 Comma operator
+      #
+      # Semantics
+      #
+      # 2 The left operand of a comma operator is evaluated as a void
+      #   expression; there is a sequence point after its evaluation.  Then the
+      #   right operand is evaluated; the result has its type and value.  If an
+      #   attempt is made to modify the result of a comma operator or to access
+      #   it after the next sequence point, the behavior is undefined.
+      @expressions[-2].append_sequence_point! if @expressions.size > 1
       self
     end
 
@@ -1644,6 +1867,7 @@ module C #:nodoc:
     def initialize
       super
       @pointer = nil
+      @full = false
     end
 
     attr_accessor :pointer
@@ -1656,6 +1880,33 @@ module C #:nodoc:
       false
     end
 
+    def full=(full_declarator)
+      @full = full_declarator
+
+      # NOTE: The ISO C99 standard saids;
+      #
+      # 6.7.5 Declarators
+      #
+      # Semantics
+      #
+      # 3 A full declarator is a declarator that is not part of another
+      #   declarator.  The end of a full declarator is a sequence point.  If,
+      #   in the nested sequence of declarators in a full declarator, there is
+      #   a declarator specifying a variable length array type, the type
+      #   specified by the full declarator is said to be variably modified.
+      #   Furthermore, any type derived by declarator type derivation from a
+      #   variably modified type is itself variably modified.
+      if full_declarator
+        append_sequence_point!
+      else
+        delete_sequence_point!
+      end
+    end
+
+    def full?
+      @full
+    end
+
     def base
       subclass_responsibility
     end

data/lib/adlint/c.rb

@@ -50,6 +50,7 @@ require "adlint/c/phase"
 require "adlint/c/resolver"
 require "adlint/c/scanner"
 require "adlint/c/scope"
+require "adlint/c/seqp"
 require "adlint/c/syntax"
 require "adlint/c/type"
 require "adlint/c/util"

data/lib/adlint/cpp/code.rb

@@ -166,7 +166,7 @@ module Cpp #:nodoc:
 
     def extract_line(line_line)
       PP_DIRECTIVE(line_line.location, line_line.keyword.value,
-                   line_line.pp_tokens.tokens.map { |t| t.value }.join(" "))
+                   line_line.pp_tokens ? line_line.pp_tokens.to_s : "")
     end
 
     def extract_error(error_line)
@@ -176,7 +176,7 @@ module Cpp #:nodoc:
 
     def extract_pragma(pragma_line)
       PP_DIRECTIVE(pragma_line.location, pragma_line.keyword.value,
-                   pragma_line.pp_tokens.tokens.map { |t| t.value }.join(" "))
+                   pragma_line.pp_tokens ? pragma_line.pp_tokens.to_s : "")
     end
 
     def extract_null(null_directive)