adlint 2.6.14 → 3.0.0

data/lib/adlint/ld/phase.rb

@@ -1,7 +1,7 @@
 # Phases of cross module analysis.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -30,6 +30,8 @@
 #++
 
 require "adlint/phase"
+require "adlint/annot"
+require "adlint/cpp/lexer"
 require "adlint/ld/object"
 require "adlint/ld/typedef"
 require "adlint/ld/util"
@@ -38,153 +40,182 @@ module AdLint #:nodoc:
 module Ld #:nodoc:
 
   class LdPhase < Phase
-    def initialize(context, phase_name)
-      super(context, "ld", phase_name)
+    def initialize(phase_ctxt, phase_name)
+      super(phase_ctxt, "ld", phase_name)
     end
   end
 
   class MapTypedefPhase < LdPhase
-    def initialize(context)
-      super(context, "mtd")
+    def initialize(phase_ctxt)
+      super(phase_ctxt, "mtd")
     end
 
     private
-    def do_execute(context, monitor)
+    def do_execute(phase_ctxt, monitor)
       mapper = TypedefMapper.new
-      context[:metric_fpaths].each do |fpath|
+      phase_ctxt[:metric_fpaths].each do |fpath|
         mapper.execute(fpath)
-        monitor.progress += 1.0 / context[:metric_fpaths].size
+        monitor.progress += 1.0 / phase_ctxt[:metric_fpaths].size
       end
-      context[:ld_typedef_mapping] = mapper.result
+      phase_ctxt[:ld_typedef_mapping] = mapper.result
     end
   end
 
   class MapFunctionPhase < LdPhase
-    def initialize(context)
-      super(context, "mfn")
+    def initialize(phase_ctxt)
+      super(phase_ctxt, "mfn")
     end
 
     private
-    def do_execute(context, monitor)
+    def do_execute(phase_ctxt, monitor)
       mapper = FunctionMapper.new
-      context[:metric_fpaths].each do |fpath|
+      phase_ctxt[:metric_fpaths].each do |fpath|
         mapper.execute(fpath)
-        monitor.progress += 1.0 / context[:metric_fpaths].size
+        monitor.progress += 1.0 / phase_ctxt[:metric_fpaths].size
       end
-      context[:ld_function_mapping] = mapper.result
+      phase_ctxt[:ld_function_mapping] = mapper.result
     end
   end
 
   class MapVariablePhase < LdPhase
-    def initialize(context)
-      super(context, "mvr")
+    def initialize(phase_ctxt)
+      super(phase_ctxt, "mvr")
     end
 
     private
-    def do_execute(context, monitor)
+    def do_execute(phase_ctxt, monitor)
       mapper = VariableMapper.new
-      context[:metric_fpaths].each do |fpath|
+      phase_ctxt[:metric_fpaths].each do |fpath|
         mapper.execute(fpath)
-        monitor.progress += 1.0 / context[:metric_fpaths].size
+        monitor.progress += 1.0 / phase_ctxt[:metric_fpaths].size
       end
-      context[:ld_variable_mapping] = mapper.result
+      phase_ctxt[:ld_variable_mapping] = mapper.result
     end
   end
 
   class LinkFunctionPhase < LdPhase
-    def initialize(context)
-      super(context, "lfn")
+    def initialize(phase_ctxt)
+      super(phase_ctxt, "lfn")
     end
 
     private
-    def do_execute(context, monitor)
-      builder = FunctionCallGraphBuilder.new(context[:ld_function_mapping])
-      context[:metric_fpaths].each do |fpath|
+    def do_execute(phase_ctxt, monitor)
+      builder = FunctionCallGraphBuilder.new(phase_ctxt[:ld_function_mapping])
+      phase_ctxt[:metric_fpaths].each do |fpath|
         builder.execute(fpath)
-        monitor.progress += 1.0 / context[:metric_fpaths].size
+        monitor.progress += 1.0 / phase_ctxt[:metric_fpaths].size
       end
-      context[:ld_function_call_graph] = builder.result
+      phase_ctxt[:ld_function_call_graph] = builder.result
     ensure
-      DebugUtil.dump_function_call_graph(context)
+      DebugUtil.dump_function_call_graph(phase_ctxt)
     end
   end
 
   class LinkVariablePhase < LdPhase
-    def initialize(context)
-      super(context, "lvr")
+    def initialize(phase_ctxt)
+      super(phase_ctxt, "lvr")
     end
 
     private
-    def do_execute(context, monitor)
+    def do_execute(phase_ctxt, monitor)
       builder = VariableReferenceGraphBuilder.new(
-        context[:ld_variable_mapping], context[:ld_function_mapping],
-        context[:ld_function_call_graph])
-      context[:metric_fpaths].each do |fpath|
+        phase_ctxt[:ld_variable_mapping], phase_ctxt[:ld_function_mapping],
+        phase_ctxt[:ld_function_call_graph])
+      phase_ctxt[:metric_fpaths].each do |fpath|
         builder.execute(fpath)
-        monitor.progress += 1.0 / context[:metric_fpaths].size
+        monitor.progress += 1.0 / phase_ctxt[:metric_fpaths].size
       end
-      context[:ld_variable_reference_graph] = builder.result
+      phase_ctxt[:ld_variable_reference_graph] = builder.result
     ensure
-      DebugUtil.dump_variable_reference_graph(context)
+      DebugUtil.dump_variable_reference_graph(phase_ctxt)
     end
   end
 
   class PreparePhase < LdPhase
-    def initialize(context)
-      super(context, "pre")
+    def initialize(phase_ctxt)
+      super(phase_ctxt, "pre")
     end
 
     private
-    def do_execute(context, *)
-      context[:ld_typedef_traversal] =
-        TypedefTraversal.new(context[:ld_typedef_mapping])
-      context[:ld_function_traversal] =
-        FunctionTraversal.new(context[:ld_function_mapping])
-      context[:ld_variable_traversal] =
-        VariableTraversal.new(context[:ld_variable_mapping])
+    def do_execute(phase_ctxt, *)
+      collect_annotations
+      phase_ctxt[:ld_typedef_traversal] =
+        TypedefTraversal.new(phase_ctxt[:ld_typedef_mapping])
+      phase_ctxt[:ld_function_traversal] =
+        FunctionTraversal.new(phase_ctxt[:ld_function_mapping])
+      phase_ctxt[:ld_variable_traversal] =
+        VariableTraversal.new(phase_ctxt[:ld_variable_mapping])
+    end
+
+    def collect_annotations
+      composing_fpaths.each do |fpath|
+        lexer = Cpp::Lexer.new(
+          Source.new(fpath, traits.of_project.file_encoding), traits)
+
+        parser = method(:parse_annotation)
+        lexer.on_line_comment_found  += parser
+        lexer.on_block_comment_found += parser
+        while lexer.next_token; end
+      end
+    end
+
+    def composing_fpaths
+      @phase_ctxt[:ld_function_mapping].composing_fpaths +
+      @phase_ctxt[:ld_variable_mapping].composing_fpaths +
+      @phase_ctxt[:ld_typedef_mapping].composing_fpaths
+    end
+
+    def parse_annotation(comment, loc)
+      if annot = Annotation.parse(comment, loc)
+        @phase_ctxt[:annotations].push(annot)
+        if annot.message_suppression_specifier? &&
+            traits.of_message.individual_suppression
+          @phase_ctxt[:suppressors].add(annot.create_suppressor)
+        end
+      end
     end
   end
 
   class TypedefReviewPhase < LdPhase
-    def initialize(context)
-      super(context, "rtd")
+    def initialize(phase_ctxt)
+      super(phase_ctxt, "rtd")
     end
 
     private
-    def do_execute(context, *)
-      context[:ld_typedef_traversal].execute
+    def do_execute(phase_ctxt, *)
+      phase_ctxt[:ld_typedef_traversal].execute
     end
   end
 
   class FunctionReviewPhase < LdPhase
-    def initialize(context)
-      super(context, "rfn")
+    def initialize(phase_ctxt)
+      super(phase_ctxt, "rfn")
     end
 
     private
-    def do_execute(context, *)
-      context[:ld_function_traversal].execute
+    def do_execute(phase_ctxt, *)
+      phase_ctxt[:ld_function_traversal].execute
     end
   end
 
   class VariableReviewPhase < LdPhase
-    def initialize(context)
-      super(context, "rvr")
+    def initialize(phase_ctxt)
+      super(phase_ctxt, "rvr")
     end
 
     private
-    def do_execute(context, *)
-      context[:ld_variable_traversal].execute
+    def do_execute(phase_ctxt, *)
+      phase_ctxt[:ld_variable_traversal].execute
     end
   end
 
   class ExaminationPhase < LdPhase
-    def initialize(context)
-      super(context, "exm")
+    def initialize(phase_ctxt)
+      super(phase_ctxt, "exm")
     end
 
     private
-    def do_execute(context, *)
+    def do_execute(phase_ctxt, *)
       examinations.each { |exam| exam.execute }
     end
   end

data/lib/adlint/ld/typedef.rb

@@ -1,7 +1,7 @@
 # C typedef models for cross module analysis.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -29,15 +29,18 @@
 #
 #++
 
+require "adlint/location"
 require "adlint/metric"
 
 module AdLint #:nodoc:
 module Ld #:nodoc:
 
   class Typedef
-    def initialize(name, location)
+    include LocationHolder
+
+    def initialize(name, loc)
       @name = name
-      @location = location
+      @location = loc
     end
 
     attr_reader :name
@@ -57,10 +60,14 @@ module Ld #:nodoc:
   class TypedefMapping
     def initialize
       @name_index = Hash.new { |hash, key| hash[key] = Set.new }
+      @composing_fpaths = Set.new
     end
 
+    attr_reader :composing_fpaths
+
     def add(typedef)
       @name_index[typedef.name].add(typedef)
+      @composing_fpaths.add(typedef.location.fpath)
     end
 
     def all_typedefs
@@ -81,11 +88,15 @@ module Ld #:nodoc:
 
     attr_reader :result
 
-    def execute(metric_fpath)
-      CSV.foreach(metric_fpath) do |row|
-        record = MetricRecord.of(row)
-        if record.typedef_declaration?
-          @result.add(Typedef.new(record.type_name, record.location))
+    def execute(met_fpath)
+      sma_wd = Pathname.pwd
+      CSV.foreach(met_fpath) do |csv_row|
+        rec = MetricRecord.of(csv_row, sma_wd)
+        case
+        when rec.version?
+          sma_wd = Pathname.new(rec.exec_working_directory)
+        when rec.typedef_declaration?
+          @result.add(Typedef.new(rec.type_name, rec.location))
         end
       end
     end
@@ -98,10 +109,10 @@ module Ld #:nodoc:
 
     extend Pluggable
 
-    def_plugin :listeners
+    def_plugin :on_declaration
 
     def execute
-      @typedef_mapping.all_typedefs.each { |tdef| listeners.invoke(tdef) }
+      @typedef_mapping.all_typedefs.each { |tdef| on_declaration.invoke(tdef) }
     end
   end
 

data/lib/adlint/ld/util.rb

@@ -1,7 +1,7 @@
 # Miscellaneous utilities for cross module analysis.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -33,51 +33,59 @@ module AdLint #:nodoc:
 module Ld #:nodoc:
 
   module DebugUtil
-    def dump_function_call_graph(context)
-      return unless $DEBUG
+    def dump_function_call_graph(phase_ctxt)
+      if $DEBUG
+        proj_name = phase_ctxt.traits.of_project.project_name
+        map_fname = Pathname.new("#{proj_name}.map")
+        map_fpath = map_fname.expand_path(phase_ctxt.msg_fpath.dirname)
 
-      File.open("#{context[:project_name]}.map", "w") do |io|
-        mapping = context[:ld_function_mapping]
-        call_graph = context[:ld_function_call_graph]
+        mapping = phase_ctxt[:ld_function_mapping]
+        call_graph = phase_ctxt[:ld_function_call_graph]
         return unless mapping && call_graph
 
-        io.puts("-- Function Call Graph --")
-        mapping.all_functions.each do |callee|
-          io.puts("DC of #{callee.signature}")
-          call_graph.direct_callers_of(callee).each do |f|
-            io.puts(" #{f.signature}")
+        File.open(map_fpath, "w") do |io|
+          io.puts("-- Function Call Graph --")
+          mapping.all_functions.each do |callee|
+            io.puts("DC of #{callee.signature}")
+            call_graph.direct_callers_of(callee).each do |fun|
+              io.puts(" #{fun.signature}")
+            end
+            io.puts
+            io.puts("IC of #{callee.signature}")
+            call_graph.indirect_callers_of(callee).each do |fun|
+              io.puts(" #{fun.signature}")
+            end
+            io.puts
           end
-          io.puts
-          io.puts("IC of #{callee.signature}")
-          call_graph.indirect_callers_of(callee).each do |f|
-            io.puts(" #{f.signature}")
-          end
-          io.puts
         end
       end
     end
     module_function :dump_function_call_graph
 
-    def dump_variable_reference_graph(context)
-      return unless $DEBUG
+    def dump_variable_reference_graph(phase_ctxt)
+      if $DEBUG
+        proj_name = phase_ctxt.traits.of_project.project_name
+        map_fname = Pathname.new("#{proj_name}.map")
+        map_fpath = map_fname.expand_path(phase_ctxt.msg_fpath.dirname)
 
-      File.open("#{context[:project_name]}.map", "a") do |io|
-        mapping = context[:ld_variable_mapping]
-        reference_graph = context[:ld_variable_reference_graph]
-        return unless mapping && reference_graph
+        mapping = phase_ctxt[:ld_variable_mapping]
+        ref_graph = phase_ctxt[:ld_variable_reference_graph]
+        return unless mapping && ref_graph
 
-        io.puts("-- Variable Reference Graph --")
-        mapping.all_variables.each do |variable|
-          io.puts("DR of #{variable.name}")
-          reference_graph.direct_referrers_of(variable).each do |f|
-            io.puts(" #{f.signature}")
-          end
-          io.puts
-          io.puts("IR or #{variable.signature}")
-          reference_graph.indirect_referrers_of(variable).each do |f|
-            io.puts(" #{f.signature}")
+        File.open(map_fpath, "a") do |io|
+          io.puts("-- Variable Reference Graph --")
+          mapping.all_variables.each do |accessee|
+            io.puts("DR of #{accessee.name}")
+            ref_graph.direct_referrers_of(accessee).each do |fun|
+              io.puts(" #{fun.signature}")
+            end
+            io.puts
+            io.puts("IR or #{accessee.signature}")
+            ref_graph.indirect_referrers_of(accessee).each do |fun|
+              io.puts(" #{fun.signature}")
+            end
+            io.puts
           end
-          io.puts
         end
       end
     end