adlint 1.14.0 → 1.16.0

data/lib/adlint/c/parser.y

@@ -2022,6 +2022,8 @@ end
 require "adlint/error"
 require "adlint/symbol"
 require "adlint/monitor"
+require "adlint/util"
+require "adlint/c/lexer"
 require "adlint/c/syntax"
 
 ---- inner
@@ -2029,9 +2031,9 @@ require "adlint/c/syntax"
 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
@@ -2043,7 +2045,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)

data/lib/adlint/c/phase.rb

@@ -49,19 +49,26 @@ module C #:nodoc:
     def do_execute(context)
       monitored_region("pr3") do
         context[:c_visitor] = SyntaxTreeMulticastVisitor.new
+        context[:c_parser] = Parser.new(context)
+        context[:c_commands] = setup_message_detections(context)
       end
     end
+
+    def setup_message_detections(context)
+      [
+        W0646.new(context)
+      ]
+    end
   end
 
   class ParsePhase < Phase
     private
     def do_execute(context)
       monitored_region("prs") do
-        parser = Parser.new(context, Lexer.new(context[:c_source]))
         begin
-          context[:c_syntax_tree] = parser.execute
+          context[:c_syntax_tree] = context[:c_parser].execute
         ensure
-          context[:c_token_array] = parser.token_array
+          context[:c_token_array] = context[:c_parser].token_array
         end
       end
     ensure
@@ -85,9 +92,9 @@ module C #:nodoc:
       monitored_region("pr4") do
         context[:c_interpreter] = Interpreter.new(context[:c_type_table])
 
-        context[:c_commands] = setup_code_extractions(context) +
-                               setup_metric_measurements(context) +
-                               setup_message_detections(context)
+        context[:c_commands] += setup_code_extractions(context) +
+                                setup_metric_measurements(context) +
+                                setup_message_detections(context)
       end
     end
 
@@ -631,6 +638,7 @@ module C #:nodoc:
         W0684.new(context),
         W0685.new(context),
         W0686.new(context),
+        W0694.new(context),
         W0697.new(context),
         W0698.new(context),
         W0699.new(context),
@@ -754,6 +762,11 @@ module C #:nodoc:
         W1069.new(context),
         W1070.new(context),
         W1072.new(context),
+        W1073.new(context),
+        W1074.new(context),
+        W1075.new(context),
+        W1076.new(context),
+        W1077.new(context),
         W9001.new(context),
         W9003.new(context)
       ]

data/lib/adlint/c/syntax.rb

@@ -1534,6 +1534,12 @@ module C #:nodoc:
       #   conditional operator or to access it after the next sequence point,
       #   the behavior is undefined.
       @condition.append_sequence_point!
+
+      # NOTE: Add extra sequence points in order not to warn about side-effects
+      #       in both the 2nd and 3rd expressions because only one of the 2nd
+      #       and 3rd expressions is actually executed.
+      @then_expression.append_sequence_point!
+      @else_expression.append_sequence_point!
     end
 
     attr_reader :condition

data/lib/adlint/c/type.rb

@@ -6863,7 +6863,11 @@ module C #:nodoc:
     def_delegator :@base_type, :bit_alignment
     def_delegator :@base_type, :real_type
     def_delegator :@base_type, :base_type
-    def_delegator :@base_type, :unqualify
+
+    def unqualify
+      self
+    end
+
     def_delegator :@base_type, :incomplete?
     def_delegator :@base_type, :compatible?
     def_delegator :@base_type, :coercible?

data/lib/adlint/cpp/constexpr.rb

@@ -82,8 +82,8 @@ def value_of(token)
   token == "$" ? "EOF" : token.value
 end
 
-def notify_illformed_defined_operator(location)
-  on_illformed_defined_op_found.invoke(location)
+def notify_illformed_defined_operator(location, no_args)
+  on_illformed_defined_op_found.invoke(location, no_args)
 end
 
 def notify_undefined_macro_referred(identifier)
@@ -484,7 +484,7 @@ module_eval(<<'.,.,', 'constexpr.y', 119)
 
 module_eval(<<'.,.,', 'constexpr.y', 129)
   def _reduce_12(val, _values, result)
-            notify_illformed_defined_operator(location_of(val[0]))
+            notify_illformed_defined_operator(location_of(val[0]), val[1] == "$")
         result = ErrorExpression.new(val[1])
       
     result

data/lib/adlint/cpp/constexpr.y

@@ -127,7 +127,7 @@ unary_expression
       }
     | DEFINED error
       {
-        notify_illformed_defined_operator(location_of(val[0]))
+        notify_illformed_defined_operator(location_of(val[0]), val[1] == "$")
         result = ErrorExpression.new(val[1])
       }
     ;
@@ -374,8 +374,8 @@ def value_of(token)
   token == "$" ? "EOF" : token.value
 end
 
-def notify_illformed_defined_operator(location)
-  on_illformed_defined_op_found.invoke(location)
+def notify_illformed_defined_operator(location, no_args)
+  on_illformed_defined_op_found.invoke(location, no_args)
 end
 
 def notify_undefined_macro_referred(identifier)

data/lib/adlint/cpp/eval.rb

@@ -72,8 +72,10 @@ module Cpp #:nodoc:
     def_plugin :on_unlexable_char_found
     def_plugin :on_cr_at_eol_found
     def_plugin :on_eof_mark_at_eof_found
+    def_plugin :on_illformed_newline_escape_found
     def_plugin :on_illformed_defined_op_found
     def_plugin :on_undefined_macro_referred
+    def_plugin :on_extra_tokens_found
 
     private
     def preprocessing_file(context)
@@ -102,6 +104,8 @@ module Cpp #:nodoc:
           return asm_section(context)
         when :NULL_DIRECTIVE
           return NullDirective.new(context.next_token)
+        when :UNKNOWN_DIRECTIVE
+          return UnknownDirective.new(context.next_token)
         when :TEXT_LINE
           text_line = TextLine.new(context.next_token)
           tokens = TextLineNormalizer.normalize(text_line, context)
@@ -161,9 +165,7 @@ module Cpp #:nodoc:
       unless pp_tokens = pp_tokens(context)
         return nil
       end
-      unless new_line = context.next_token and new_line.type == :NEW_LINE
-        return nil
-      end
+      discard_extra_tokens_until_newline(context)
       expression = ExpressionNormalizer.normalize(pp_tokens, context, self)
       if expression.value == 0
         context.skip_group
@@ -179,9 +181,7 @@ module Cpp #:nodoc:
       unless identifier = context.next_token and identifier.type == :IDENTIFIER
         return nil
       end
-      unless new_line = context.next_token and new_line.type == :NEW_LINE
-        return nil
-      end
+      discard_extra_tokens_until_newline(context)
       if macro_defined?(context, identifier)
         group = group(context)
         context.branch_evaluated = true
@@ -196,9 +196,7 @@ module Cpp #:nodoc:
       unless identifier = context.next_token and identifier.type == :IDENTIFIER
         return nil
       end
-      unless new_line = context.next_token and new_line.type == :NEW_LINE
-        return nil
-      end
+      discard_extra_tokens_until_newline(context)
       if macro_defined?(context, identifier)
         context.skip_group
       else
@@ -229,9 +227,7 @@ module Cpp #:nodoc:
           unless pp_tokens = pp_tokens(context)
             return nil
           end
-          unless new_line = context.next_token and new_line.type == :NEW_LINE
-            return nil
-          end
+          discard_extra_tokens_until_newline(context)
           expression = ExpressionNormalizer.normalize(pp_tokens, context, self)
           if context.branch_evaluated? || expression.value == 0
             context.skip_group
@@ -248,9 +244,7 @@ module Cpp #:nodoc:
     def else_group(context)
       if keyword = context.next_token
         if keyword.type == :ELSE
-          unless new_line = context.next_token and new_line.type == :NEW_LINE
-            return nil
-          end
+          discard_extra_tokens_until_newline(context)
           if context.branch_evaluated?
             context.skip_group
           else
@@ -266,9 +260,7 @@ module Cpp #:nodoc:
     def endif_line(context)
       if keyword = context.next_token
         if keyword.type == :ENDIF
-          unless new_line = context.next_token and new_line.type == :NEW_LINE
-            return nil
-          end
+          discard_extra_tokens_until_newline(context)
           return EndifLine.new(keyword)
         end
       end
@@ -329,9 +321,7 @@ module Cpp #:nodoc:
 
     def user_include_line(context, keyword)
       header_name = context.next_token
-      unless new_line = context.next_token and new_line.type == :NEW_LINE
-        return nil
-      end
+      discard_extra_tokens_until_newline(context)
       user_include_line =
         UserIncludeLine.new(keyword, header_name, context.include_depth)
       include_first_user_header(user_include_line, context)
@@ -340,9 +330,7 @@ module Cpp #:nodoc:
 
     def user_include_next_line(context, keyword)
       header_name = context.next_token
-      unless new_line = context.next_token and new_line.type == :NEW_LINE
-        return nil
-      end
+      discard_extra_tokens_until_newline(context)
       user_include_next_line =
         UserIncludeNextLine.new(keyword, header_name, context.include_depth)
       include_next_user_header(user_include_next_line, context)
@@ -351,9 +339,7 @@ module Cpp #:nodoc:
 
     def system_include_line(context, keyword)
       header_name = context.next_token
-      unless new_line = context.next_token and new_line.type == :NEW_LINE
-        return nil
-      end
+      discard_extra_tokens_until_newline(context)
       system_include_line =
         SystemIncludeLine.new(keyword, header_name, context.include_depth)
       include_first_system_header(system_include_line, context)
@@ -362,9 +348,7 @@ module Cpp #:nodoc:
 
     def system_include_next_line(context, keyword)
       header_name = context.next_token
-      unless new_line = context.next_token and new_line.type == :NEW_LINE
-        return nil
-      end
+      discard_extra_tokens_until_newline(context)
       system_include_next_line =
         SystemIncludeNextLine.new(keyword, header_name, context.include_depth)
       include_next_system_header(system_include_next_line, context)
@@ -375,9 +359,7 @@ module Cpp #:nodoc:
       unless pp_tokens = pp_tokens(context)
         return nil
       end
-      unless new_line = context.next_token and new_line.type == :NEW_LINE
-        return nil
-      end
+      discard_extra_tokens_until_newline(context)
       PPTokensNormalizer.normalize(pp_tokens, context)
       return nil if pp_tokens.tokens.empty?
       case parameter = pp_tokens.tokens.map { |t| t.value }.join
@@ -403,9 +385,7 @@ module Cpp #:nodoc:
       unless pp_tokens = pp_tokens(context)
         return nil
       end
-      unless new_line = context.next_token and new_line.type == :NEW_LINE
-        return nil
-      end
+      discard_extra_tokens_until_newline(context)
       PPTokensNormalizer.normalize(pp_tokens, context)
       return nil if pp_tokens.tokens.empty?
       case parameter = pp_tokens.tokens.map { |t| t.value }.join
@@ -454,9 +434,7 @@ module Cpp #:nodoc:
           return nil
         end
         replacement_list = replacement_list(context)
-        unless new_line = context.next_token and new_line.type == :NEW_LINE
-          return nil
-        end
+        discard_extra_tokens_until_newline(context)
         if ellipsis
           define_line = VaFunctionLikeDefineLine.new(keyword, identifier,
                                                      identifier_list,
@@ -472,9 +450,7 @@ module Cpp #:nodoc:
         end
       else
         replacement_list = replacement_list(context)
-        unless new_line = context.next_token and new_line.type == :NEW_LINE
-          return nil
-        end
+        discard_extra_tokens_until_newline(context)
         define_line = ObjectLikeDefineLine.new(keyword, identifier,
                                                replacement_list, symbol)
         macro = ObjectLikeMacro.new(define_line)
@@ -490,9 +466,7 @@ module Cpp #:nodoc:
       unless identifier = context.next_token and identifier.type == :IDENTIFIER
         return nil
       end
-      unless new_line = context.next_token and new_line.type == :NEW_LINE
-        return nil
-      end
+      discard_extra_tokens_until_newline(context)
 
       undef_line = UndefLine.new(keyword, identifier)
       macro = context.macro_table.lookup(identifier.value)
@@ -506,9 +480,7 @@ module Cpp #:nodoc:
     def line_line(context)
       keyword = context.next_token
       pp_tokens = pp_tokens(context)
-      unless new_line = context.next_token and new_line.type == :NEW_LINE
-        return nil
-      end
+      discard_extra_tokens_until_newline(context)
 
       # NOTE: The ISO C99 standard saids;
       #
@@ -532,18 +504,14 @@ module Cpp #:nodoc:
     def error_line(context)
       keyword = context.next_token
       pp_tokens = pp_tokens(context)
-      unless new_line = context.next_token and new_line.type == :NEW_LINE
-        return nil
-      end
+      discard_extra_tokens_until_newline(context)
       ErrorLine.new(keyword, pp_tokens)
     end
 
     def pragma_line(context)
       keyword = context.next_token
       pp_tokens = pp_tokens(context)
-      unless new_line = context.next_token and new_line.type == :NEW_LINE
-        return nil
-      end
+      discard_extra_tokens_until_newline(context)
       pragma_line = PragmaLine.new(keyword, pp_tokens)
       if pp_tokens && pp_tokens.tokens.size == 1 &&
           pp_tokens.tokens.first.value == "once"
@@ -607,9 +575,7 @@ module Cpp #:nodoc:
     def asm_line(context)
       if keyword = context.next_token
         if keyword.type == :ASM
-          unless new_line = context.next_token and new_line.type == :NEW_LINE
-            return nil
-          end
+          discard_extra_tokens_until_newline(context)
           return AsmLine.new(keyword)
         end
       end
@@ -619,9 +585,7 @@ module Cpp #:nodoc:
     def endasm_line(context)
       if keyword = context.next_token
         if keyword.type == :ENDASM
-          unless new_line = context.next_token and new_line.type == :NEW_LINE
-            return nil
-          end
+          discard_extra_tokens_until_newline(context)
           return EndasmLine.new(keyword)
         end
       end
@@ -761,35 +725,41 @@ module Cpp #:nodoc:
       end
     end
 
+    def discard_extra_tokens_until_newline(context)
+      extra_tokens = []
+      while token = context.next_token
+        if token.type == :NEW_LINE
+          break
+        else
+          extra_tokens.push(token)
+        end
+      end
+      notify_extra_tokens_found(extra_tokens) unless extra_tokens.empty?
+    end
+
     def create_lexer(context, source)
       Lexer.new(source).tap { |lexer| attach_lexer_plugin(lexer, context) }
     end
 
     def attach_lexer_plugin(lexer, context)
-      lexer.on_block_comment_found += lambda { |comment, location|
-        on_block_comment_found.invoke(comment, location)
-      }
-      lexer.on_line_comment_found += lambda { |comment, location|
-        on_line_comment_found.invoke(comment, location)
-      }
-      lexer.on_nested_block_comment_found += lambda { |location|
-        on_nested_block_comment_found.invoke(location)
-      }
-      lexer.on_unterminated_block_comment += lambda { |location|
-        handle_unterminated_block_comment(context, location)
-      }
-      lexer.on_eof_newline_not_found += lambda { |location|
-        on_eof_newline_not_found.invoke(location)
-      }
-      lexer.on_unlexable_char_found += lambda { |char, location|
-        on_unlexable_char_found.invoke(char, location)
-      }
-      lexer.on_cr_at_eol_found += lambda { |location|
-        on_cr_at_eol_found.invoke(location)
-      }
-      lexer.on_eof_mark_at_eof_found += lambda { |location|
-        on_eof_mark_at_eof_found.invoke(location)
-      }
+      lexer.on_block_comment_found +=
+        lambda { |*args| on_block_comment_found.invoke(*args) }
+      lexer.on_line_comment_found +=
+        lambda { |*args| on_line_comment_found.invoke(*args) }
+      lexer.on_nested_block_comment_found +=
+        lambda { |*args| on_nested_block_comment_found.invoke(*args) }
+      lexer.on_unterminated_block_comment +=
+        lambda { |*args| handle_unterminated_block_comment(*args) }
+      lexer.on_eof_newline_not_found +=
+        lambda { |*args| on_eof_newline_not_found.invoke(*args) }
+      lexer.on_unlexable_char_found +=
+        lambda { |*args| on_unlexable_char_found.invoke(*args) }
+      lexer.on_cr_at_eol_found +=
+        lambda { |*args| on_cr_at_eol_found.invoke(*args) }
+      lexer.on_eof_mark_at_eof_found +=
+        lambda { |*args| on_eof_mark_at_eof_found.invoke(*args) }
+      lexer.on_illformed_newline_escape_found +=
+        lambda { |*args| on_illformed_newline_escape_found.invoke(*args) }
     end
 
     def notify_user_header_included(user_include_line, user_header)
@@ -828,14 +798,18 @@ module Cpp #:nodoc:
       on_pp_token_extracted.invoke(pp_token)
     end
 
-    def notify_illformed_defined_op_found(location)
-      on_illformed_defined_op_found.invoke(location)
+    def notify_illformed_defined_op_found(location, no_args)
+      on_illformed_defined_op_found.invoke(location, no_args)
     end
 
     def notify_undefined_macro_referred(identifier)
       on_undefined_macro_referred.invoke(identifier)
     end
 
+    def notify_extra_tokens_found(extra_tokens)
+      on_extra_tokens_found.invoke(extra_tokens)
+    end
+
     def handle_unterminated_block_comment(context, location)
       E(:E0016, location)
       raise UnterminatedCommentError.new(location,