adlint 1.14.0 → 1.16.0

data/features/message_detection/W1077.feature

@@ -0,0 +1,105 @@
+Feature: W1077
+
+  W1077 detects that an array variable declared without number of its elements.
+
+  Scenario: 1-dimensional array variable declaration without size
+    Given a target source named "W1077.c" with:
+      """
+      extern int a[]; /* W1077 */
+      """
+    When I successfully run `adlint W1077.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0118 | 1    | 12     |
+      | W1077 | 1    | 12     |
+
+  Scenario: 1-dimensional array variable declaration with size
+    Given a target source named "W1077.c" with:
+      """
+      extern int a[3]; /* OK */
+      """
+    When I successfully run `adlint W1077.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0118 | 1    | 12     |
+
+  Scenario: 2-dimensional array variable declaration without all sizes
+    Given a target source named "W1077.c" with:
+      """
+      extern int a[][]; /* W1077 */
+      """
+    When I successfully run `adlint W1077.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0118 | 1    | 12     |
+      | W1028 | 1    | 12     |
+      | W1077 | 1    | 12     |
+
+  Scenario: 2-dimensional array variable declaration without outer size
+    Given a target source named "W1077.c" with:
+      """
+      extern int a[][3]; /* W1077 */
+      """
+    When I successfully run `adlint W1077.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0118 | 1    | 12     |
+      | W1077 | 1    | 12     |
+
+  Scenario: 2-dimensional array variable declaration with all sizes
+    Given a target source named "W1077.c" with:
+      """
+      extern int a[2][3]; /* OK */
+      """
+    When I successfully run `adlint W1077.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0118 | 1    | 12     |
+
+  Scenario: 3-dimensional array variable declaration without all sizes
+    Given a target source named "W1077.c" with:
+      """
+      extern int a[][][]; /* W1077 */
+      """
+    When I successfully run `adlint W1077.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0118 | 1    | 12     |
+      | W1028 | 1    | 12     |
+      | W1077 | 1    | 12     |
+
+  Scenario: 3-dimensional array variable declaration with all sizes
+    Given a target source named "W1077.c" with:
+      """
+      extern int a[1][2][3]; /* OK */
+      """
+    When I successfully run `adlint W1077.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0118 | 1    | 12     |
+
+  Scenario: cv-qualified 3-dimensional array variable declaration without all
+            sizes
+    Given a target source named "W1077.c" with:
+      """
+      extern const int a[][][]; /* W1077 */
+      """
+    When I successfully run `adlint W1077.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0118 | 1    | 18     |
+      | W1028 | 1    | 18     |
+      | W1077 | 1    | 18     |
+
+  Scenario: cv-qualified 3-dimensional array variable declaration with all
+            sizes
+    Given a target source named "W1077.c" with:
+      """
+      extern const int a[1][2][3]; /* OK */
+      """
+    When I successfully run `adlint W1077.c` on noarch
+    Then the output should exactly match with:
+      | mesg  | line | column |
+      | W0118 | 1    | 18     |
+
+# vim:ts=2:sw=2:sts=2:et:

data/features/message_detection/W9003.feature

@@ -22,6 +22,7 @@ Feature: W9003
     And the output should exactly match with:
       | mesg  | line | column |
       | W0118 | 4    | 13     |
+      | W1076 | 6    | 13     |
       | W9003 | 8    | 9      |
       | W0728 | 8    | 9      |
       | W0629 | 6    | 13     |
@@ -44,6 +45,7 @@ Feature: W9003
     And the output should exactly match with:
       | mesg  | line | column |
       | W0118 | 3    | 13     |
+      | W1076 | 5    | 13     |
       | W9003 | 7    | 9      |
       | W1059 | 7    | 9      |
       | W0629 | 5    | 13     |
@@ -66,6 +68,7 @@ Feature: W9003
     And the output should exactly match with:
       | mesg  | line | column |
       | W0118 | 3    | 13     |
+      | W1076 | 5    | 13     |
       | W9003 | 7    | 9      |
       | W1053 | 7    | 9      |
       | W0629 | 5    | 13     |
@@ -116,6 +119,7 @@ Feature: W9003
     Then the output should match with /6:.*:W9003/
     And the output should exactly match with:
       | mesg  | line | column |
+      | W1076 | 3    | 12     |
       | W0727 | 6    | 20     |
       | W9003 | 6    | 20     |
       | W9003 | 6    | 18     |

data/lib/adlint/c/ctrlexpr.rb

@@ -787,6 +787,9 @@ module C #:nodoc:
         __NOTREACHED__
       end
 
+      notify_variable_value_referred(@node, lhs_var)
+      notify_variable_value_referred(@node, rhs_var)
+
       case @operator
       when Operator::EQ, Operator::NE
         notify_equality_expr_evaled(@node, lhs_conv, rhs_conv, result)

data/lib/adlint/c/interp.rb

@@ -162,15 +162,15 @@ module C #:nodoc:
     #       a constant temporary variable.
     def_plugin_and_notifier :constant_referred, :constant_specifier, :variable
 
-    # NOTE: Notified when the interpreter refer to a value of a variable while
+    # NOTE: Notified when the interpreter refers to a value of a variable while
     #       evaluating an expression.
     def_plugin_and_notifier :variable_value_referred, :expression, :variable
 
-    # NOTE: Notified when the interpreter overwrite a value of a variable while
-    #       evaluating an expression.
+    # NOTE: Notified when the interpreter overwrites a value of a variable
+    #       while evaluating an expression.
     def_plugin_and_notifier :variable_value_updated, :expression, :variable
 
-    # NOTE: Notified when the interpreter refer to a function object while
+    # NOTE: Notified when the interpreter refers to a function object while
     #       evaluating an expression.
     def_plugin_and_notifier :function_referred, :expression, :function
 
@@ -421,7 +421,7 @@ module C #:nodoc:
     # NOTE: Notified when the interpreter ends execution of a translation-unit.
     def_plugin_and_notifier :translation_unit_ended, :translation_unit
 
-    # NOTE: Notified when control reaches to a sequence-point.
+    # NOTE: Notified when the control reaches to a sequence-point.
     def_plugin_and_notifier :sequence_point_reached, :sequence_point
 
     def execute(node, *options)
@@ -1582,6 +1582,12 @@ module C #:nodoc:
       when then_var && else_var
         result_val = then_var.value.single_value_unified_with(else_var.value)
         result = temporary_variable(then_var.type, result_val)
+        # FIXME: Not to over-warn about discarding a function return value.
+        #        Because the unified result is a new temporary variable, it is
+        #        impossible to relate a reference of the unified result and a
+        #        reference of the 2nd or 3rd expression's value.
+        notify_variable_value_referred(node, then_var)
+        notify_variable_value_referred(node, else_var)
       when then_var
         result = then_var
       when else_var

data/lib/adlint/c/lexer.rb

@@ -30,6 +30,7 @@
 #++
 
 require "adlint/lexer"
+require "adlint/util"
 require "adlint/c/scanner"
 require "adlint/c/scope"
 
@@ -50,6 +51,10 @@ module C #:nodoc:
 
     attr_reader :translation_unit_fpath
 
+    extend Pluggable
+
+    def_plugin :on_string_literals_concatenated
+
     def add_typedef_name(token)
       @typedef_names.add(token.value)
     end
@@ -140,9 +145,11 @@ module C #:nodoc:
       until context.content.empty?
         next_token = tokenize(context)
         if next_token.type == :STRING_LITERAL
-          return token.class.new(token.type, token.value.sub(/"\z/, "") +
-                                 next_token.value.sub(/\AL?"/, ""),
-                                 token.location)
+          result = token.class.new(token.type, token.value.sub(/"\z/, "") +
+                                   next_token.value.sub(/\AL?"/, ""),
+                                   token.location)
+          notify_string_literals_concatenated(token, next_token, result)
+          return result
         else
           @next_token = next_token
           break
@@ -210,6 +217,10 @@ module C #:nodoc:
         nil
       end
     end
+
+    def notify_string_literals_concatenated(former, latter, result)
+      on_string_literals_concatenated.invoke(former, latter, result)
+    end
   end
 
   class ScopedNameSet

data/lib/adlint/c/message.rb

@@ -11561,6 +11561,22 @@ module C #:nodoc:
     end
   end
 
+  class W0646 < PassiveMessageDetection
+    def initialize(context)
+      super
+      parser = context[:c_parser]
+      parser.on_string_literals_concatenated += method(:check)
+    end
+
+    private
+    def check(former, latter, *)
+      if former.value =~ /\A"/ && latter.value =~ /\AL"/i or
+          former.value =~ /\AL"/i && latter.value =~ /\A"/
+        W(:W0646, latter.location)
+      end
+    end
+  end
+
   class W0653 < PassiveMessageDetection
     def initialize(context)
       super
@@ -12102,6 +12118,21 @@ module C #:nodoc:
     end
   end
 
+  class W0694 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_function_call_expr_evaled += method(:check)
+    end
+
+    private
+    def check(function_call_expression, function, *)
+      if function.named? && function.name == "assert"
+        W(:W0694, function_call_expression.location)
+      end
+    end
+  end
+
   class W0703 < PassiveMessageDetection
     def initialize(context)
       super
@@ -14994,6 +15025,167 @@ module C #:nodoc:
     end
   end
 
+  class W1073 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_function_started += method(:enter_function)
+      interp.on_function_ended += method(:leave_function)
+      interp.on_function_call_expr_evaled += method(:add_return_value)
+      interp.on_variable_value_referred += method(:refer_return_value)
+      @current_function = nil
+    end
+
+    private
+    def enter_function(function_definition, *)
+      @current_function = function_definition
+      @return_values = {}
+    end
+
+    def leave_function(*)
+      if @current_function
+        @return_values.each_value do |retval|
+          unless retval[0]
+            fun_name = retval[2].named? ? retval[2].name : "(anonymous)"
+            W(:W1073, retval[1].location, fun_name)
+          end
+        end
+      end
+      @current_function = nil
+      @return_values = nil
+    end
+
+    def add_return_value(expr, function, arg_variables, result)
+      if @current_function
+        unless function.type.return_type.void?
+          @return_values[result] = [false, expr, function]
+        end
+      end
+    end
+
+    def refer_return_value(expr, variable)
+      if @current_function
+        if retval = @return_values[variable]
+          retval[0] = true
+        end
+      end
+    end
+  end
+
+  class W1074 < PassiveMessageDetection
+    def initialize(context)
+      super
+      visitor = context[:c_visitor]
+      visitor.enter_sizeof_expression += method(:check)
+    end
+
+    private
+    def check(sizeof_expression)
+      if sizeof_expression.operand.have_side_effect?
+        W(:W1074, sizeof_expression.operand.location)
+      end
+    end
+  end
+
+  class W1075 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_variable_declared += method(:declare_variable)
+      interp.on_variable_defined += method(:define_variable)
+      interp.on_function_declared += method(:declare_function)
+      interp.on_function_defined += method(:define_function)
+    end
+
+    private
+    def declare_variable(variable_declaration, variable)
+      if variable.named?
+        if variable.declared_as_static?
+          sc_specifier = variable_declaration.storage_class_specifier
+          unless sc_specifier && sc_specifier.type == :STATIC
+            W(:W1075, variable_declaration.location, variable.name)
+          end
+        end
+      end
+    end
+
+    def define_variable(variable_definition, variable)
+      if variable.named?
+        if variable.declared_as_static?
+          sc_specifier = variable_definition.storage_class_specifier
+          unless sc_specifier && sc_specifier.type == :STATIC
+            W(:W1075, variable_definition.location, variable.name)
+          end
+        end
+      end
+    end
+
+    def declare_function(function_declaration, function)
+      if function.named?
+        if function.declared_as_static?
+          sc_specifier = function_declaration.storage_class_specifier
+          unless sc_specifier && sc_specifier.type == :STATIC
+            W(:W1075, function_declaration.location, function.name)
+          end
+        end
+      end
+    end
+
+    def define_function(function_definition, function)
+      if function.named?
+        if function.declared_as_static?
+          sc_specifier = function_definition.storage_class_specifier
+          unless sc_specifier && sc_specifier.type == :STATIC
+            W(:W1075, function_definition.location, function.name)
+          end
+        end
+      end
+    end
+  end
+
+  class W1076 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_function_defined += method(:define_function)
+    end
+
+    private
+    def define_function(function_definition, function)
+      if function.named? && function.declared_as_static?
+        anterior_decls = function.declarations_and_definitions.reject { |decl|
+          decl == function_definition
+        }
+        if anterior_decls.empty?
+          W(:W1076, function_definition.location, function.name)
+        end
+      end
+    end
+  end
+
+  class W1077 < PassiveMessageDetection
+    def initialize(context)
+      super
+      interp = context[:c_interpreter]
+      interp.on_variable_declared += method(:check)
+    end
+
+    private
+    def check(variable_declaration, *)
+      type = variable_declaration.type
+      begin
+        if type.array?
+          unless type.length
+            W(:W1077, variable_declaration.location)
+            break
+          end
+        else
+          break
+        end
+      end while type = type.base_type
+    end
+  end
+
   class W9001 < PassiveMessageDetection
     def initialize(context)
       super

data/lib/adlint/c/parser.rb

@@ -10,20 +10,22 @@ require 'racc/parser.rb'
 require "adlint/error"
 require "adlint/symbol"
 require "adlint/monitor"
+require "adlint/util"
+require "adlint/c/lexer"
 require "adlint/c/syntax"
 
 module AdLint
   module C
     class Parser < Racc::Parser
 
-module_eval(<<'...end parser.y/module_eval...', 'parser.y', 2028)
+module_eval(<<'...end parser.y/module_eval...', 'parser.y', 2030)
 
 include MonitorUtil
 include ReportUtil
 
-def initialize(context, lexer)
+def initialize(context)
   @context = context
-  @lexer = lexer
+  @lexer = create_lexer(context[:c_source])
   @symbol_table = context[:symbol_table]
   @token_array = []
   @unnamed_tag_no = 0
@@ -35,7 +37,21 @@ def execute
   do_parse
 end
 
+extend Pluggable
+
+def_plugin :on_string_literals_concatenated
+
 private
+def create_lexer(c_source)
+  Lexer.new(c_source).tap { |lexer| attach_lexer_plugin(lexer) }
+end
+
+def attach_lexer_plugin(lexer)
+  lexer.on_string_literals_concatenated += lambda { |*args|
+    on_string_literals_concatenated.invoke(*args)
+  }
+end
+
 def next_token
   if token = @lexer.next_token
     @token_array.push(token)