adlint-postfilter 0.9.1

data/lib/adlint/postfilter/annotate.rb

@@ -0,0 +1,143 @@
+# Message control annotations.
+#
+# Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# License::   GPLv3+: GNU General Public License version 3 or later
+#
+# Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+
+#--
+#     ___    ____  __    ___   _________
+#    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
+#   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
+#  / __  |/ /_/ / /___/ / /|  /  / /
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+#
+# This file is part of adlint-postfilter.
+#
+# adlint-postfilter is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# adlint-postfilter is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# adlint-postfilter.  If not, see <http://www.gnu.org/licenses/>.
+#
+#++
+
+require "adlint/postfilter/suppress"
+
+module AdLint #:nodoc:
+module Postfilter #:nodoc:
+
+  class MessageControlAnnotation
+    def initialize(message_controller_str)
+      @message_controller = MessageController.new(message_controller_str)
+    end
+
+    attr_reader :message_controller
+  end
+
+  class TranslationUnitWideAnnotation < MessageControlAnnotation
+    def self.detect(str, composing_fpaths)
+      str =~ /ADLINT:TUNIT:\[.*\]/ ? new($&, composing_fpaths) : nil
+    end
+
+    def initialize(message_controller_str, composing_fpaths)
+      super(message_controller_str)
+      @composing_fpaths = composing_fpaths
+    end
+    private_class_method :new
+
+    def generate_suppressions
+      message_controller.message_control_list.map { |mesg_ctrl|
+        @composing_fpaths.map do |fpath|
+          FileWiseSuppression.new(mesg_ctrl.message_id, fpath,
+                                  mesg_ctrl.suppression_activation?)
+        end
+      }.flatten
+    end
+  end
+
+  class LineWiseAnnotation < MessageControlAnnotation
+    def self.detect(str, fpath, line_no)
+      str =~ /(?:ADLINT:LINE:|ADLINT::)\[.*\]/ ? new($&, fpath, line_no) : nil
+    end
+
+    def initialize(message_controller_str, fpath, line_no)
+      super(message_controller_str)
+      @fpath, @line_no = fpath, line_no
+    end
+    private_class_method :new
+
+    def generate_suppressions
+      message_controller.message_control_list.map do |mesg_ctrl|
+        LineWiseSuppression.new(mesg_ctrl.message_id, @fpath, @line_no,
+                                mesg_ctrl.suppression_activation?)
+      end
+    end
+  end
+
+  class MessageController
+    def initialize(message_controller_str)
+      @message_control_list = parse_message_controller(message_controller_str)
+    end
+
+    attr_reader :message_control_list
+
+    private
+    def parse_message_controller(message_controller_str)
+      if message_controller_str =~ /\[(.*)\]/
+        parse_message_control_list($1)
+      else
+        []
+      end
+    end
+
+    def parse_message_control_list(message_control_list_str)
+      message_control_list_str.scan(/([+-])([WC]\d{4})/).map do |op, mesg_id|
+        case op
+        when "-"
+          MessageSuppressionActivation.new(mesg_id)
+        when "+"
+          MessageSuppressionDeactivation.new(mesg_id)
+        end
+      end
+    end
+  end
+
+  class MessageControl
+    def initialize(message_id_str)
+      @message_id = message_id_str.to_sym
+    end
+
+    attr_reader :message_id
+
+    def suppression_activation?
+      subclass_responsibility
+    end
+
+    def suppression_deactivation?
+      !suppression_activation?
+    end
+  end
+
+  class MessageSuppressionActivation < MessageControl
+    def suppression_activation?
+      true
+    end
+  end
+
+  class MessageSuppressionDeactivation < MessageControl
+    def suppression_activation?
+      false
+    end
+  end
+
+end
+end

data/lib/adlint/postfilter/command.rb

@@ -0,0 +1,184 @@
+# AdLint analysis commands.
+#
+# Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# License::   GPLv3+: GNU General Public License version 3 or later
+#
+# Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+
+#--
+#     ___    ____  __    ___   _________
+#    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
+#   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
+#  / __  |/ /_/ / /___/ / /|  /  / /
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+#
+# This file is part of adlint-postfilter.
+#
+# adlint-postfilter is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# adlint-postfilter is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# adlint-postfilter.  If not, see <http://www.gnu.org/licenses/>.
+#
+#++
+
+require "fileutils"
+require "getoptlong"
+require "pathname"
+
+require "adlint/postfilter/config"
+require "adlint/postfilter/content"
+require "adlint/postfilter/filter"
+
+module AdLint #:nodoc:
+module Postfilter #:nodoc:
+
+  class AnalysisCommand
+    def self.for(command_line, config_fpath, src_vpath = nil)
+      case name = command_line.split.first
+      when "adlint"
+        ADLINT.new(command_line, config_fpath, src_vpath)
+      when "adlint_sma"
+        ADLINT_SMA.new(command_line, config_fpath, src_vpath)
+      when "adlint_cma"
+        ADLINT_CMA.new(command_line, config_fpath, src_vpath)
+      when "adlint_chk"
+        ADLINT_CHK.new(command_line, config_fpath, src_vpath)
+      else
+        raise "unknown command `#{name}'"
+      end
+    end
+
+    def initialize(command_line, config_fpath, src_vpath = nil)
+      @command_line = command_line
+      @config_fpath = config_fpath
+      @src_vpath = src_vpath
+
+      @traits_fpath, @strip_num, @output_dpath, @src_fpaths =
+        parse_adlint_command_line(@command_line, @src_vpath)
+    end
+
+    def execute
+      status, stderr_content = exec_adlint_command(@command_line)
+      filter_results(create_filters, stderr_content)
+      status
+    end
+
+    private
+    def exec_adlint_command(command_line)
+      system("#{command_line} 2>#{stderr_fpath}")
+      return $?, StderrContent.new(File.read(stderr_fpath))
+    ensure
+      FileUtils.rm_f(stderr_fpath)
+    end
+
+    def filter_results(filters, stderr_content)
+      filters.each { |filter| filter.execute(stderr_content) }
+      stderr_content.overwrite!
+    end
+
+    def create_filters
+      subclass_responsibility
+    end
+
+    def parse_adlint_command_line(command_line, src_vpath = nil)
+      parser = GetoptLong.new(
+        ["--traits", "-t", GetoptLong::REQUIRED_ARGUMENT],
+        ["--list-file", "-l", GetoptLong::REQUIRED_ARGUMENT],
+        ["--output-dir", "-o", GetoptLong::REQUIRED_ARGUMENT],
+        ["--strip", "-p", GetoptLong::REQUIRED_ARGUMENT],
+        ["--verbose", "-v", GetoptLong::NO_ARGUMENT])
+      parser.quiet = true
+
+      begin
+        traits_fpath = nil
+        output_dpath = nil
+        strip_num = src_vpath ? src_vpath.components.size : 0
+
+        ARGV.replace(command_line.split).shift
+
+        parser.each_option do |optname, optarg|
+          case optname
+          when "--traits"
+            traits_fpath = Pathname.new(optarg)
+          when "--output-dir"
+            output_dpath = Pathname.new(optarg)
+          when "--strip"
+            strip_num = optarg.to_i
+          end
+        end
+      rescue
+        # NOTE: If the AdLint's command line is invalid, child analysis command
+        #       will encounter the same problem and will notice it.
+        #       So, nothing to be done.
+      end
+
+      src_fpaths = ARGV.map { |str|
+        if str.end_with?(".c.met.csv")
+          @src_vpath.join(Pathname.new(str.sub(/.met.csv\z/, "")))
+        else
+          Pathname.new(str)
+        end
+      }
+
+      return traits_fpath, strip_num, output_dpath, src_fpaths
+    end
+
+    def create_sma_filters
+      create_sma_configs.map { |sma_config| MessageFilter.new(sma_config) }
+    end
+
+    def create_cma_filter
+      MessageFilter.new(create_cma_config)
+    end
+
+    def create_sma_configs
+      @src_fpaths.map do |src_fpath|
+        SmaConfig.new(@config_fpath, @traits_fpath, src_fpath, @strip_num,
+                      @output_dpath)
+      end
+    end
+
+    def create_cma_config
+      CmaConfig.new(@config_fpath, @traits_fpath, @strip_num, @output_dpath,
+                    create_sma_configs)
+    end
+
+    def stderr_fpath
+      Pathname.new("./adlint_postfilter.#{$$}.stderr")
+    end
+  end
+
+  class ADLINT < AnalysisCommand
+    private
+    def create_filters
+      create_sma_filters + [create_cma_filter]
+    end
+  end
+
+  class ADLINT_SMA < AnalysisCommand
+    private
+    def create_filters
+      create_sma_filters
+    end
+  end
+
+  class ADLINT_CMA < AnalysisCommand
+    private
+    def create_filters
+      [create_cma_filter]
+    end
+  end
+
+  class ADLINT_CHK < ADLINT_SMA; end
+
+end
+end

data/lib/adlint/postfilter/config.rb

@@ -0,0 +1,266 @@
+# Message suppression configuration.
+#
+# Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# License::   GPLv3+: GNU General Public License version 3 or later
+#
+# Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+
+#--
+#     ___    ____  __    ___   _________
+#    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
+#   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
+#  / __  |/ /_/ / /___/ / /|  /  / /
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+#
+# This file is part of adlint-postfilter.
+#
+# adlint-postfilter is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# adlint-postfilter is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# adlint-postfilter.  If not, see <http://www.gnu.org/licenses/>.
+#
+#++
+
+require "yaml"
+require "pathname"
+
+require "adlint/postfilter/suppress"
+require "adlint/postfilter/annotate"
+require "adlint/postfilter/path"
+
+module AdLint #:nodoc:
+module Postfilter #:nodoc:
+
+  class Config
+    def initialize(config_fpath, traits_fpath, strip_num)
+      load_postfilter_config(config_fpath)
+      load_adlint_traits(traits_fpath)
+
+      @initial_header_suppression =
+        create_adlint_initial_header_suppression
+      @platform_header_suppression =
+        create_platform_header_supression(strip_num)
+      @project_wide_suppressions = create_project_wide_suppressions
+    end
+
+    def individual_suppression_control_enabled?
+      @@config_yaml["message_traits"]["enable_individual_suppression_control"]
+    end
+
+    def msg_fpath
+      subclass_responsibility
+    end
+
+    def suppression_list
+      subclass_responsibility
+    end
+
+    private
+    def create_adlint_initial_header_suppression
+      AdLintInitialHeaderSuppression.new(
+        Pathname.new(adlint_traits.of_compiler.initial_header).realpath,
+        Pathname.new(adlint_traits.of_project.initial_header).realpath)
+    end
+
+    def create_platform_header_supression(strip_num)
+      root_dpath = Pathname.getwd.realpath
+      strip_num.times { root_dpath = root_dpath.parent }
+      PlatformHeaderSuppression.new(root_dpath)
+    end
+
+    def create_project_wide_suppressions
+      list = @@config_yaml["message_traits"]["suppression_list"] || []
+      list.map { |mesg_id| ProjectWideSuppression.new(mesg_id.to_sym) }
+    end
+
+    def adlint_traits
+      @@adlint_traits
+    end
+
+    def load_postfilter_config(config_fpath)
+      return if defined?(@@config_yaml)
+
+      # NOTE: Psych::SyntaxError is a subclass of the builtin ::SyntaxError.
+      #       The rescue clause without error_type is equivalent to
+      #       `rescue StandardError'.  So, the rescue clause without error_type
+      #       cannot catch Psych::SyntaxError.
+      begin
+        @@config_yaml = File.open(config_fpath, "r:utf-8") { |io|
+          case array_or_stream = YAML.load_stream(io)
+          when Array
+            # NOTE: YAML.load_stream returns Array in Ruby 1.9.3-preview1.
+            array_or_stream.first
+          when YAML::Stream
+            array_or_stream.documents.first
+          end
+        }
+      rescue SyntaxError, StandardError => ex
+        $stderr.puts "#{command}: Failed to read `#{config_fpath}'."
+        $stderr.puts
+        $stderr.puts "Detailed message is below;"
+        $stderr.puts ex.message, ex.backtrace
+        $stderr.puts
+        exit 11
+      end
+    end
+
+    def load_adlint_traits(traits_fpath)
+      return if defined?(@@adlint_traits)
+
+      # NOTE: Psych::SyntaxError is a subclass of the builtin ::SyntaxError.
+      #       The rescue clause without error_type is equivalent to
+      #       `rescue StandardError'.  So, the rescue clause without error_type
+      #       cannot catch Psych::SyntaxError.
+      begin
+        @@adlint_traits = Traits.instance
+        @@adlint_traits.read_from(traits_fpath)
+      rescue SyntaxError, StandardError
+        # NOTE: If the AdLint's traits file is invalid, child analysis command
+        #       will encounter the same problem and will notice it.
+        #       So, nothing to be done.
+      end
+    end
+  end
+
+  class SmaConfig < Config
+    include PathUtil
+
+    def initialize(config_fpath, traits_fpath,
+                   src_fpath, strip_num, output_dpath = nil)
+      super(config_fpath, traits_fpath, strip_num)
+
+      @msg_fpath = sma_msg_fpath_of(src_fpath, strip_num, output_dpath)
+      @suppression_list =
+        create_suppression_list(src_fpath, strip_num, output_dpath)
+    end
+
+    attr_reader :msg_fpath
+    attr_reader :suppression_list
+    attr_reader :tunit_wide_suppressions
+    attr_reader :line_wise_suppressions
+
+    private
+    def create_suppression_list(src_fpath, strip_num, output_dpath)
+      @tunit_wide_suppressions = 
+        create_tunit_wide_suppressions(src_fpath, strip_num, output_dpath)
+      @line_wise_suppressions =
+        create_line_wise_suppressions(src_fpath, strip_num, output_dpath)
+
+      MessageSuppressionList.new(@initial_header_suppression,
+                                 @platform_header_suppression,
+                                 @project_wide_suppressions,
+                                 @tunit_wide_suppressions,
+                                 @line_wise_suppressions)
+    end
+
+    def create_tunit_wide_suppressions(src_fpath, strip_num, output_dpath)
+      return [] unless individual_suppression_control_enabled?
+
+      i_fpath = i_fpath_of(src_fpath, strip_num, output_dpath)
+      if ann = find_effective_tunit_wide_annotation(src_fpath, i_fpath)
+        ann.generate_suppressions
+      else
+        []
+      end
+    end
+
+    def create_line_wise_suppressions(src_fpath, strip_num, output_dpath)
+      return [] unless individual_suppression_control_enabled?
+
+      i_fpath = i_fpath_of(src_fpath, strip_num, output_dpath)
+      collect_composing_fpaths_in(i_fpath).each_with_object([]) do |fpath, ary|
+        collect_line_wise_annotations(fpath).each do |ann, line_no|
+          ary.concat(ann.generate_suppressions)
+        end
+      end
+    end
+
+    def find_effective_tunit_wide_annotation(src_fpath, i_fpath)
+      composing_fpaths = collect_composing_fpaths_in(i_fpath)
+
+      # NOTE: If multiple tunit-wide-annotations are written in the source
+      #       file, the first one will be treated as effective.
+      File.open(src_fpath, "r:binary") do |io|
+        io.each_line do |line|
+          if ann = TranslationUnitWideAnnotation.detect(line, composing_fpaths)
+            return ann
+          end
+        end
+      end
+      nil
+    end
+
+    def collect_composing_fpaths_in(i_fpath)
+      File.open(i_fpath, "r:binary") do |io|
+        io.each_line.with_object([]) { |line, composing_fpaths|
+          if line =~ /\A# \d+ "(.*)"/
+            composing_fpaths.push(Pathname.new($1).realpath)
+          end
+        }.uniq
+      end
+    end
+
+    def collect_line_wise_annotations(fpath)
+      File.open(fpath, "r:binary") do |io|
+        io.each_line.with_index.with_object([]) do |(line, index), annotations|
+          if ann = LineWiseAnnotation.detect(line, fpath, index + 1)
+            annotations.push(ann)
+          end
+        end
+      end
+    end
+  end
+
+  class CmaConfig < Config
+    include PathUtil
+
+    def initialize(config_fpath, traits_fpath,
+                   strip_num, output_dpath, sma_configs)
+      super(config_fpath, traits_fpath, strip_num)
+
+      project_name = adlint_traits.of_project.project_name
+      @msg_fpath = cma_msg_fpath_of(project_name, output_dpath)
+      @suppression_list = create_suppression_list(sma_configs)
+    end
+
+    attr_reader :msg_fpath
+    attr_reader :suppression_list
+
+    private
+    def create_suppression_list(sma_configs)
+      tunit_wide_suppressions =
+        collect_all_tunit_wide_suppressions(sma_configs)
+      line_wise_suppressions = collect_all_line_wise_suppressions(sma_configs)
+
+      MessageSuppressionList.new(@initial_header_suppression,
+                                 @platform_header_suppression,
+                                 @project_wide_suppressions,
+                                 tunit_wide_suppressions,
+                                 line_wise_suppressions)
+    end
+
+    def collect_all_tunit_wide_suppressions(sma_configs)
+      sma_configs.map { |sma_config|
+        sma_config.tunit_wide_suppressions
+      }.flatten
+    end
+
+    def collect_all_line_wise_suppressions(sma_configs)
+      sma_configs.map { |sma_config|
+        sma_config.line_wise_suppressions
+      }.flatten
+    end
+  end
+
+end
+end
+