adlint 3.0.4 → 3.0.8

data/lib/adlint/cpp/eval.rb

@@ -363,24 +363,27 @@ module Cpp #:nodoc:
       end
       discard_extra_tokens_until_newline(pp_ctxt)
       PPTokensNormalizer.normalize(pp_toks, pp_ctxt)
-      return nil if pp_toks.tokens.empty?
-      case param = pp_toks.tokens.map { |tok| tok.value }.join
-      when /\A".*"\z/
-        usr_include_line = UserIncludeLine.new(
-          keyword, Token.new(:USR_HEADER_NAME, param,
-                             pp_toks.tokens.first.location),
-          pp_ctxt.include_depth)
-        include_first_user_header(usr_include_line, pp_ctxt)
-        return usr_include_line
-      when /\A<.*>\z/
-        sys_include_line = SystemIncludeLine.new(
-          keyword, Token.new(:SYS_HEADER_NAME, param,
-                             pp_toks.tokens.first.location),
-          pp_ctxt.include_depth)
-        include_first_system_header(sys_include_line, pp_ctxt)
-        return sys_include_line
+      unless pp_toks.tokens.empty?
+        case param = pp_toks.tokens.map { |tok| tok.value }.join
+        when /\A".*"\z/
+          usr_include_line = UserIncludeLine.new(
+            keyword, Token.new(:USR_HEADER_NAME, param,
+                               pp_toks.tokens.first.location),
+            pp_ctxt.include_depth)
+          include_first_user_header(usr_include_line, pp_ctxt)
+          return usr_include_line
+        when /\A<.*>\z/
+          sys_include_line = SystemIncludeLine.new(
+            keyword, Token.new(:SYS_HEADER_NAME, param,
+                               pp_toks.tokens.first.location),
+            pp_ctxt.include_depth)
+          include_first_system_header(sys_include_line, pp_ctxt)
+          return sys_include_line
+        end
       end
-      nil
+      E(:E0017, keyword.location)
+      raise IllformedIncludeDirectiveError.new(
+        keyword.location, pp_ctxt.msg_fpath, pp_ctxt.log_fpath)
     end
 
     def macro_include_next_line(pp_ctxt, keyword)
@@ -815,10 +818,10 @@ module Cpp #:nodoc:
       on_extra_tokens_found.invoke(extra_toks)
     end
 
-    def handle_unterminated_block_comment(pp_ctxt, loc)
+    def handle_unterminated_block_comment(loc)
       E(:E0016, loc)
-      raise UnterminatedCommentError.new(loc, pp_ctxt.msg_fpath,
-                                         pp_ctxt.log_fpath)
+      raise UnterminatedCommentError.new(loc, @pp_ctxt.msg_fpath,
+                                         @pp_ctxt.log_fpath)
     end
 
     extend Forwardable
@@ -879,12 +882,15 @@ module Cpp #:nodoc:
     end
 
     def top_token
-      return nil if @lexer_stack.empty?
-      unless tok = @lexer_stack.last.top_token
-        @lexer_stack.pop
-        top_token
+      unless @lexer_stack.empty?
+        unless tok = @lexer_stack.last.top_token
+          @lexer_stack.pop
+          top_token
+        else
+          tok
+        end
       else
-        tok
+        nil
       end
     end
 

data/lib/adlint/cpp/lexer.rb

@@ -165,19 +165,25 @@ module Cpp #:nodoc:
 
     def scan_block_comment(cont)
       comment = ""
-      block_depth = 0
+      nest_depth = 0
       until cont.empty?
         loc = cont.location
         case
-        when cont.scan(/\/\*/)
-          block_depth += 1
+        when nest_depth == 0 && cont.scan(/\/\*/)
+          nest_depth = 1
           comment += "/*"
-          notify_nested_block_comment_found(loc) if block_depth > 1
+        when nest_depth > 0 && cont.check(/\/\*\//)
+          comment += cont.scan(/\//)
+        when nest_depth > 0 && cont.check(/\/\*/)
+          nest_depth += 1
+          comment += cont.scan(/\/\*/)
+          notify_nested_block_comment_found(loc)
         when cont.scan(/\*\//)
           comment += "*/"
           break
+        when nest_depth == 0
+          return nil
         else
-          return nil if block_depth == 0
           if scanned = cont.scan(/.*?(?=\/\*|\*\/)/m)
             comment += scanned
           else

data/lib/adlint/cpp/macro.rb

@@ -343,26 +343,53 @@ module Cpp #:nodoc:
       #   order of evaluation of ## operators is unspecified.
 
       if lhs = res_toks.pop
-        if rhs = arg_toks.first
+        unless arg_toks.empty?
           # NOTE: To avoid syntax error when the concatenated token can be
           #       retokenize to two or more tokens.
-          new_toks = StringToPPTokensLexer.new(lhs.value + rhs.value).execute
+          unlexed_arg = unlex_tokens(arg_toks)
+          new_toks = StringToPPTokensLexer.new(lhs.value + unlexed_arg).execute
           new_toks.map! do |tok|
             ReplacedToken.new(tok.type, tok.value, expansion_loc,
                               tok.type_hint, false)
           end
           res_toks.concat(new_toks)
-          res_toks.concat(arg_toks[1..-1].map { |tok|
-            ReplacedToken.new(tok.type, tok.value, expansion_loc,
-                              tok.type_hint, false)
-          })
+
+          macro_tbl.notify_sharpsharp_operator_evaled(
+            lhs, Token.new(:MACRO_ARG, unlexed_arg, arg_toks.first.location),
+            new_toks)
         else
           new_toks = [ReplacedToken.new(lhs.type, lhs.value, expansion_loc,
                                         lhs.type_hint, false)]
           res_toks.concat(new_toks)
         end
+      end
+    end
+
+    def unlex_tokens(arg_toks)
+      # NOTE: To regenerate source string from pp_tokens in preparation for
+      #       the argument substitution.
 
-        macro_tbl.notify_sharpsharp_operator_evaled(lhs, rhs, new_toks)
+      # 6.10.3 Macro replacement
+      #
+      # Semantics
+      #
+      # 11 The sequence of preprocessing tokens bounded by the outside-most
+      #    matching parentheses forms the list of arguments for the
+      #    function-like macro.  The individual arguments within the list are
+      #    separated by comma preprocessing tokens, but comma preprocessing
+      #    tokens between matching inner parentheses do not separate arguments.
+      #    If there are sequences of preprocessing tokens within the list of
+      #    arguments that would otherwise act as preprocessing directives, the
+      #    behavior is undefined.
+
+      arg_toks.each_cons(2).reduce(arg_toks.first.value) do |str, (lhs, rhs)|
+        lhs_loc, rhs_loc = lhs.location, rhs.location
+        if lhs_loc.line_no == rhs_loc.line_no
+          tok_gap = rhs_loc.column_no - lhs_loc.column_no - lhs.value.length
+          str + " " * [tok_gap, 0].max + rhs.value
+        else
+          "#{str} #{rhs.value}"
+        end
       end
     end
   end

data/lib/adlint/cpp/phase.rb

@@ -52,10 +52,10 @@ module Cpp #:nodoc:
     private
     def do_execute(phase_ctxt, *)
       root_src = phase_ctxt[:sources].first
-      phase_ctxt[:cc1_source]      = PreprocessedSource.new(root_src)
-      phase_ctxt[:cpp_macro_table] = MacroTable.new
-      phase_ctxt[:cpp_interpreter] = Preprocessor.new
-      phase_ctxt[:cpp_visitor]     = SyntaxTreeMulticastVisitor.new
+      phase_ctxt[:cc1_source]        = PreprocessedSource.new(root_src)
+      phase_ctxt[:cpp_macro_table]   = MacroTable.new
+      phase_ctxt[:cpp_interpreter]   = Preprocessor.new
+      phase_ctxt[:cpp_ast_traversal] = SyntaxTreeMulticastVisitor.new
       register_annotation_parser
     end
 
@@ -105,7 +105,7 @@ module Cpp #:nodoc:
       else
         init_header = EmptySource.new
       end
-      phase_ctxt[:cpp_syntax_tree] =
+      phase_ctxt[:cpp_ast] =
         phase_ctxt[:cpp_interpreter].execute(pp_ctxt, init_header)
     end
 
@@ -116,13 +116,13 @@ module Cpp #:nodoc:
       else
         init_header = EmptySource.new
       end
-      phase_ctxt[:cpp_syntax_tree].concat(
+      phase_ctxt[:cpp_ast].concat(
         phase_ctxt[:cpp_interpreter].execute(pp_ctxt, init_header))
     end
 
     def process_target_source(phase_ctxt, pp_ctxt)
       root_src = phase_ctxt[:sources].first
-      phase_ctxt[:cpp_syntax_tree].concat(
+      phase_ctxt[:cpp_ast].concat(
         phase_ctxt[:cpp_interpreter].execute(pp_ctxt, root_src))
     end
   end
@@ -145,7 +145,7 @@ module Cpp #:nodoc:
 
     private
     def do_execute(phase_ctxt, *)
-      phase_ctxt[:cpp_syntax_tree].accept(phase_ctxt[:cpp_visitor])
+      phase_ctxt[:cpp_ast].accept(phase_ctxt[:cpp_ast_traversal])
     end
   end
 

data/lib/adlint/error.rb

@@ -151,6 +151,12 @@ module AdLint #:nodoc:
     end
   end
 
+  class IllformedIncludeDirectiveError < FatalError
+    def initialize(loc, msg_fpath, log_fpath)
+      super("#include expects a filename", loc, msg_fpath, log_fpath)
+    end
+  end
+
   class UnterminatedCommentError < FatalError
     def initialize(loc, msg_fpath, log_fpath)
       super("unterminated comment block found.", loc, msg_fpath, log_fpath)