adlint 1.14.0 → 1.16.0

data/lib/adlint/cpp/lexer.rb

@@ -63,6 +63,7 @@ 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 next_token
       if @top_token
@@ -125,6 +126,10 @@ module Cpp #:nodoc:
       on_unlexable_char_found.invoke(char, location)
     end
 
+    def notify_illformed_newline_escape_found(location)
+      on_illformed_newline_escape_found.invoke(location)
+    end
+
     GROUP_DIRECTIVE_RE =
       /.*?(?=^[ \t]*#[ \t]*(?:if|ifdef|ifndef|asm|else|elif|endif|endasm)\b)/m
     private_constant :GROUP_DIRECTIVE_RE
@@ -200,7 +205,16 @@ module Cpp #:nodoc:
     end
 
     def scan_escaped_newline(content)
-      content.scan(/\\[ \t]*\n/)
+      location = content.location
+      case
+      when escaped_newline = content.scan(/\\\n/)
+        escaped_newline
+      when escaped_newline = content.scan(/\\[ \t]+\n/)
+        @lexer.notify_illformed_newline_escape_found(location)
+        escaped_newline
+      else
+        nil
+      end
     end
 
     def tokenize_pp_token(content)
@@ -259,6 +273,15 @@ module Cpp #:nodoc:
       end
       nil
     end
+
+    def tokenize_extra_token(content)
+      # NOTE: #tokenize_pp_token can tokenize almost all types of tokens.
+      if token = tokenize_pp_token(content)
+        Token.new(:EXTRA_TOKEN, token.value, token.location)
+      else
+        nil
+      end
+    end
   end
 
   class Initial < LexerState
@@ -301,7 +324,8 @@ module Cpp #:nodoc:
         when token = tokenize_endasm_directive(@lexer.content)
           @lexer.transit(InEndasmDirective.new(@lexer))
         else
-          token = tokenize_null_directive(@lexer.content)
+          token = tokenize_null_directive(@lexer.content) ||
+                  tokenize_unknown_directive(@lexer.content)
         end
       else
         token = tokenize_text_line(@lexer.content)
@@ -433,21 +457,28 @@ module Cpp #:nodoc:
     end
 
     def tokenize_null_directive(content)
+      location = content.location
+      if value = content.scan(/[ \t]*#[ \t]\n/)
+        return Token.new(:NULL_DIRECTIVE, value, location)
+      end
+      nil
+    end
+
+    def tokenize_unknown_directive(content)
       location = content.location
       value = content.scan(/[ \t]*#/)
       until content.empty?
-        if token = content.scan(/.*?(?=\\[ \t]*\n|\n)/)
-          value += token
-        end
+        next if discard_heading_comments || scan_escaped_newline(content)
 
-        next if scan_escaped_newline(content)
-
-        if new_line = content.scan(/\n/)
-          value += new_line
+        case
+        when str = content.scan(/.+?(?=\/\*|\/\/|\\[ \t]*\n|L?"|L?'|\n)/i)
+          value += str
+        when str = content.scan(/\n/)
+          value += str
           break
         end
       end
-      Token.new(:NULL_DIRECTIVE, value, location)
+      Token.new(:UNKNOWN_DIRECTIVE, value, location)
     end
 
     def tokenize_text_line(content)
@@ -487,11 +518,13 @@ module Cpp #:nodoc:
   class InIfDirective < LexerState
     def next_token
       until @lexer.content.empty?
-        next if discard_heading_comments
-        next if scan_escaped_newline(@lexer.content)
+        if discard_heading_comments || scan_escaped_newline(@lexer.content)
+          next
+        end
 
         token = tokenize_pp_token(@lexer.content) ||
-                tokenize_new_line(@lexer.content)
+                tokenize_new_line(@lexer.content) ||
+                tokenize_extra_token(@lexer.content)
 
         if token
           break
@@ -516,11 +549,13 @@ module Cpp #:nodoc:
   class InIfdefDirective < LexerState
     def next_token
       until @lexer.content.empty?
-        next if discard_heading_comments
-        next if scan_escaped_newline(@lexer.content)
+        if discard_heading_comments || scan_escaped_newline(@lexer.content)
+          next
+        end
 
         token = tokenize_identifier(@lexer.content) ||
-                tokenize_new_line(@lexer.content)
+                tokenize_new_line(@lexer.content)   ||
+                tokenize_extra_token(@lexer.content)
 
         if token
           break
@@ -549,10 +584,14 @@ module Cpp #:nodoc:
   class InElseDirective < LexerState
     def next_token
       until @lexer.content.empty?
-        next if discard_heading_comments
-        next if scan_escaped_newline(@lexer.content)
+        if discard_heading_comments || scan_escaped_newline(@lexer.content)
+          next
+        end
 
-        if token = tokenize_new_line(@lexer.content)
+        token = tokenize_new_line(@lexer.content) ||
+                tokenize_extra_token(@lexer.content)
+
+        if token
           break
         else
           @lexer.content.eat!
@@ -577,12 +616,14 @@ module Cpp #:nodoc:
   class InIncludeDirective < LexerState
     def next_token
       until @lexer.content.empty?
-        next if discard_heading_comments
-        next if scan_escaped_newline(@lexer.content)
+        if discard_heading_comments || scan_escaped_newline(@lexer.content)
+          next
+        end
 
         token = tokenize_header_name(@lexer.content) ||
                 tokenize_pp_token(@lexer.content)    ||
-                tokenize_new_line(@lexer.content)
+                tokenize_new_line(@lexer.content)    ||
+                tokenize_extra_token(@lexer.content)
 
         if token
           break
@@ -626,7 +667,8 @@ module Cpp #:nodoc:
     private
     def tokenize_macro_name(content)
       until content.empty?
-        next if discard_heading_comments
+        next if discard_heading_comments || scan_escaped_newline(content)
+
         if token = tokenize_identifier(content)
           @tokens.push(token)
           break
@@ -639,8 +681,7 @@ module Cpp #:nodoc:
 
       paren_depth = 0
       until content.empty?
-        next if discard_heading_comments
-        next if scan_escaped_newline(content)
+        next if discard_heading_comments || scan_escaped_newline(content)
 
         if token = tokenize_identifier(content)
           @tokens.push(token)
@@ -670,8 +711,7 @@ module Cpp #:nodoc:
 
     def tokenize_pp_tokens(content)
       until content.empty?
-        next if discard_heading_comments
-        next if scan_escaped_newline(content)
+        next if discard_heading_comments || scan_escaped_newline(content)
 
         token = tokenize_pp_token(content) || tokenize_new_line(content)
 
@@ -746,7 +786,8 @@ module Cpp #:nodoc:
                  tokenize_string_literal(context) ||
                  tokenize_null_constant(context)  ||
                  tokenize_identifier(context)     ||
-                 tokenize_punctuator(context)
+                 tokenize_punctuator(context)     ||
+                 tokenize_backslash(context)
 
       if pp_token
         token_array.push(pp_token)
@@ -839,6 +880,19 @@ module Cpp #:nodoc:
 
       nil
     end
+
+    def tokenize_backslash(context)
+      location = context.location
+
+      backslash = context.content.scan(/\\/)
+
+      if backslash
+        context.last_symbol = :BACKSLASH
+        return Token.new(:PP_TOKEN, backslash, location, backslash)
+      end
+
+      nil
+    end
   end
 
   class TextLineToPPTokensLexer < StringToPPTokensLexer

data/lib/adlint/cpp/macro.rb

@@ -33,6 +33,7 @@ require "adlint/token"
 require "adlint/report"
 require "adlint/util"
 require "adlint/cpp/syntax"
+require "adlint/cpp/lexer"
 
 module AdLint #:nodoc:
 module Cpp #:nodoc:
@@ -76,16 +77,18 @@ module Cpp #:nodoc:
 
     def expand(tokens, macro_table, context)
       super
-      macro_table.notify_object_like_macro_replacement(self, tokens)
 
       if replacement_list
         location = tokens.first.location
-        replacement_list.tokens.map { |t|
+        result = replacement_list.tokens.map { |t|
           ReplacedToken.new(t.type, t.value, location, t.type_hint, false)
         }
       else
-        []
+        result = []
       end
+
+      macro_table.notify_object_like_macro_replacement(self, tokens, result)
+      result
     end
 
     def function_like?; false end
@@ -105,22 +108,22 @@ module Cpp #:nodoc:
 
     def replaceable_size(tokens)
       return 0 unless name.value == tokens.first.value
-      arg_array, index = parse_arguments(tokens, 1)
-      arg_array && @parameter_names.size >= arg_array.size ? index + 1 : 0
+      args, index = parse_arguments(tokens, 1)
+      args && @parameter_names.size >= args.size ? index + 1 : 0
     end
 
     def expand(tokens, macro_table, context)
       super
-      arg_array = parse_arguments(tokens, 1).first
-      macro_table.notify_function_like_macro_replacement(self, tokens)
 
-      args = {}
-      @parameter_names.each_with_index do |param, i|
-        arg = arg_array[i] and args[param] = arg
-      end
+      args, * = parse_arguments(tokens, 1)
+      result = expand_replacement_list(
+        @parameter_names.each_with_index.with_object({}) { |(name, i), hash|
+          arg = args[i] and hash[name] = arg
+        }, tokens.first.location, macro_table, context)
 
-      location = tokens.first.location
-      expand_replacement_list(args, location, macro_table, context)
+      macro_table.notify_function_like_macro_replacement(self, tokens, args,
+                                                         result)
+      result
     end
 
     def function_like?; true end
@@ -186,7 +189,7 @@ module Cpp #:nodoc:
       return (arg.empty? ? nil : arg), index
     end
 
-    def expand_replacement_list(args, expansion_location, macro_table, context)
+    def expand_replacement_list(args, location, macro_table, context)
       return [] unless replacement_list
 
       result = []
@@ -200,27 +203,27 @@ module Cpp #:nodoc:
                               macro_table, context)
         when curr_token.value == "#"
           if next_token and arg = args[next_token.value]
-            result.push(stringize_argument(arg, expansion_location))
+            stringized = stringize_argument(arg, location, macro_table)
+            result.push(stringized)
             index += 1
           end
         when curr_token.value == "##" && next_token.value == "#"
           if next_next_token = replacement_list.tokens[index + 2] and
               arg = args[next_next_token.value]
-            stringized = stringize_argument(arg, expansion_location)
-            concat_with_last_token([stringized], expansion_location, result)
+            stringized = stringize_argument(arg, location, macro_table)
+            concat_with_last_token([stringized], location, result, macro_table)
             index += 2
           end
         when curr_token.value == "##"
           if next_token and arg = args[next_token.value]
-            concat_with_last_token(arg, expansion_location, result)
+            concat_with_last_token(arg, location, result, macro_table)
           else
-            concat_with_last_token([next_token], expansion_location, result)
+            concat_with_last_token([next_token], location, result, macro_table)
           end
           index += 1
         else
           result.push(ReplacedToken.new(curr_token.type, curr_token.value,
-                                        expansion_location,
-                                        curr_token.type_hint, false))
+                                        location, curr_token.type_hint, false))
         end
         index += 1
       end
@@ -254,7 +257,7 @@ module Cpp #:nodoc:
       end
     end
 
-    def stringize_argument(arg, expansion_location)
+    def stringize_argument(arg, expansion_location, macro_table)
       # NOTE: The ISO C99 standard saids;
       #
       # 6.10.3.2 The # operator
@@ -290,12 +293,18 @@ module Cpp #:nodoc:
       # NOTE: This code does not concern about contents of the string literal.
       #       But, it is enough for analysis.
 
-      ReplacedToken.new(:PP_TOKEN,
-                        "\"#{arg.map { |token| token.value }.join(' ')}\"",
-                        expansion_location, :STRING_LITERAL, false)
+      str = arg.map { |token| token.value }.join
+      if str =~ /((:?\\*))\\\z/ && $1.length.even?
+        str.chop!
+        macro_table.notify_last_backslash_ignored(arg.last)
+      end
+
+      ReplacedToken.new(:PP_TOKEN, "\"#{str}\"", expansion_location,
+                        :STRING_LITERAL, false)
     end
 
-    def concat_with_last_token(tokens, expansion_location, result)
+    def concat_with_last_token(arg_tokens, expansion_location, result_tokens,
+                               macro_table)
       # NOTE: The ISO C99 standard saids;
       #
       # 6.10.3.3 The ## operator
@@ -327,12 +336,18 @@ module Cpp #:nodoc:
       #   The resulting token is available for further macro replacement.  The
       #   order of evaluation of ## operators is unspecified.
 
-      if last_token = result.pop
-        result.push(
-          ReplacedToken.new(:PP_TOKEN, last_token.value + tokens.first.value,
-                            expansion_location, nil, false))
+      if lhs = result_tokens.pop and rhs = arg_tokens.first
+        # NOTE: To avoid syntax error when the concatenated token can be
+        #       retokenize to two or more tokens.
+        new_tokens = StringToPPTokensLexer.new(lhs.value + rhs.value).execute
+        new_tokens.map! do |token|
+          ReplacedToken.new(token.type, token.value, expansion_location,
+                            token.type_hint, false)
+        end
+        macro_table.notify_sharpsharp_operator_evaled(lhs, rhs, new_tokens)
 
-        result.concat(tokens[1..-1].map { |token|
+        result_tokens.concat(new_tokens)
+        result_tokens.concat(arg_tokens[1..-1].map { |token|
           ReplacedToken.new(token.type, token.value, expansion_location,
                             token.type_hint, false)
         })
@@ -528,6 +543,8 @@ module Cpp #:nodoc:
 
     def_plugin :on_object_like_macro_replacement
     def_plugin :on_function_like_macro_replacement
+    def_plugin :on_sharpsharp_operator_evaled
+    def_plugin :on_last_backslash_ignored
 
     def define(macro)
       @macros[macro.name.value] = macro
@@ -569,12 +586,24 @@ module Cpp #:nodoc:
       replaced
     end
 
-    def notify_object_like_macro_replacement(macro, tokens)
-      on_object_like_macro_replacement.invoke(macro, tokens)
+    def notify_object_like_macro_replacement(macro, replacing_tokens,
+                                             result_tokens)
+      on_object_like_macro_replacement.invoke(macro, replacing_tokens,
+                                              result_tokens)
+    end
+
+    def notify_function_like_macro_replacement(macro, replacing_tokens, args,
+                                               result_tokens)
+      on_function_like_macro_replacement.invoke(macro, replacing_tokens, args,
+                                                result_tokens)
+    end
+
+    def notify_sharpsharp_operator_evaled(lhs_token, rhs_token, new_tokens)
+      on_sharpsharp_operator_evaled.invoke(lhs_token, rhs_token, new_tokens)
     end
 
-    def notify_function_like_macro_replacement(macro, tokens)
-      on_function_like_macro_replacement.invoke(macro, tokens)
+    def notify_last_backslash_ignored(token)
+      on_last_backslash_ignored.invoke(token)
     end
 
     private

data/lib/adlint/cpp/message.rb

@@ -221,8 +221,10 @@ module Cpp #:nodoc:
     end
 
     private
-    def check(macro, tokens)
-      W(:W0057, tokens.first.location) if macro.parameter_names.size > 31
+    def check(macro, replacing_tokens, *)
+      if macro.parameter_names.size > 31
+        W(:W0057, replacing_tokens.first.location)
+      end
     end
   end
 
@@ -1025,6 +1027,55 @@ module Cpp #:nodoc:
     end
   end
 
+  class W0643 < PassiveMessageDetection
+    # NOTE: W0643 may be duplicative when the same header which has references
+    #       to the undefined macro is included twice or more.
+    ensure_uniqueness_of :W0643
+
+    def initialize(context)
+      super
+      macro_table = context[:cpp_macro_table]
+      macro_table.on_last_backslash_ignored +=
+        lambda { |token| W(:W0643, token.location) }
+    end
+  end
+
+  class W0691 < PassiveMessageDetection
+    # NOTE: W0691 may be duplicative when the same header which has references
+    #       to the undefined macro is included twice or more.
+    ensure_uniqueness_of :W0691
+
+    def initialize(context)
+      super
+      macro_table = context[:cpp_macro_table]
+      macro_table.on_sharpsharp_operator_evaled += method(:check)
+    end
+
+    private
+    def check(lhs_token, rhs_token, new_tokens)
+      W(:W0691, new_tokens.first.location) if new_tokens.size > 1
+    end
+  end
+
+  class W0692 < PassiveMessageDetection
+    # NOTE: W0692 may be duplicative when the same header which has references
+    #       to the undefined macro is included twice or more.
+    ensure_uniqueness_of :W0692
+
+    def initialize(context)
+      super
+      macro_table = context[:cpp_macro_table]
+      macro_table.on_function_like_macro_replacement += method(:check)
+    end
+
+    private
+    def check(macro, replacing_tokens, args, *)
+      if args.empty?
+        W(:W0692, replacing_tokens.first.location, macro.name.value)
+      end
+    end
+  end
+
   class W0696 < PassiveMessageDetection
     # NOTE: W0696 may be duplicative when the same header which has references
     #       to the undefined macro is included twice or more.
@@ -1045,8 +1096,43 @@ module Cpp #:nodoc:
 
     def initialize(context)
       super
-      context[:cpp_interpreter].on_illformed_defined_op_found +=
-        lambda { |location| W(:W0804, location) }
+      context[:cpp_interpreter].on_illformed_defined_op_found += method(:check)
+    end
+
+    private
+    def check(location, *)
+      W(:W0804, location)
+    end
+  end
+
+  class W0805 < W0804
+    # NOTE: W0805 may be duplicative when the same header which causes this
+    #       warning is included twice or more.
+    ensure_uniqueness_of :W0805
+
+    private
+    def check(location, no_args)
+      W(:W0805, location) unless no_args
+    end
+  end
+
+  class W0811 < PassiveMessageDetection
+    # NOTE: W0811 may be duplicative when the same header which causes this
+    #       warning is included twice or more.
+    ensure_uniqueness_of :W0811
+
+    def initialize(context)
+      super
+      macro_table = context[:cpp_macro_table]
+      macro_table.on_object_like_macro_replacement += method(:check)
+      macro_table.on_function_like_macro_replacement += method(:check)
+    end
+
+    private
+    def check(*, result_tokens)
+      if defined_token = result_tokens.find { |t| t.value == "defined" }
+        W(:W0811, defined_token.location)
+      end
     end
   end
 
@@ -1067,6 +1153,53 @@ module Cpp #:nodoc:
     end
   end
 
+  class W1040 < PassiveMessageDetection
+    # NOTE: W1040 may be duplicative when the same header which causes this
+    #       warning is included twice or more.
+    ensure_uniqueness_of :W1040
+
+    def initialize(context)
+      super
+      interp = context[:cpp_interpreter]
+      interp.on_extra_tokens_found += method(:check)
+    end
+
+    private
+    def check(extra_tokens)
+      W(:W1040, extra_tokens.first.location)
+    end
+  end
+
+  class W1041 < PassiveMessageDetection
+    # NOTE: W1041 may be duplicative when the same header which causes this
+    #       warning is included twice or more.
+    ensure_uniqueness_of :W1041
+
+    def initialize(context)
+      super
+      visitor = context[:cpp_visitor]
+      visitor.enter_unknown_directive += method(:check)
+    end
+
+    private
+    def check(node)
+      W(:W1041, node.location, node.token.value.chomp.strip)
+    end
+  end
+
+  class W1046 < PassiveMessageDetection
+    # NOTE: W1046 may be duplicative when the same header which causes this
+    #       warning is included twice or more.
+    ensure_uniqueness_of :W1046
+
+    def initialize(context)
+      super
+      interp = context[:cpp_interpreter]
+      interp.on_illformed_newline_escape_found +=
+        lambda { |location| W(:W1046, location) }
+    end
+  end
+
   class W0832 < PassiveMessageDetection
     # NOTE: W0832 may be duplicative when the same header which causes this
     #       warning is included twice or more.