adlint 1.0.0

data/lib/adlint/analyzer.rb

@@ -0,0 +1,294 @@
+# Analyzer classes.
+#
+# 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.
+#
+# AdLint 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 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.  If not, see <http://www.gnu.org/licenses/>.
+#
+#++
+
+require "adlint/version"
+require "adlint/traits"
+require "adlint/report"
+require "adlint/metric"
+require "adlint/phase"
+require "adlint/lang"
+require "adlint/source"
+require "adlint/symbol"
+require "adlint/monitor"
+require "adlint/ld/phase"
+
+module AdLint #:nodoc:
+
+  class Analyzer
+    def self.current
+      @@current
+    end
+
+    def self.current=(analyzer)
+      @@current = analyzer
+    end
+
+    def initialize(name, log_base_fpath, output_dpath = nil)
+      @name = name
+      @log_base_fpath = log_base_fpath
+      @output_dpath = output_dpath
+    end
+
+    def run
+      File.open(log_fpath, "w") do |log_io|
+        @logger = Logger.new(log_io)
+        @logger.progname = @name
+        @logger.datetime_format = "%F %T "
+        begin
+          Analyzer.current = self
+          execute
+        rescue => ex
+          fatal(ex)
+          return false
+        ensure
+          Analyzer.current = nil
+        end
+      end
+      true
+    end
+
+    extend Forwardable
+
+    def_delegator :@logger, :fatal
+    def_delegator :@logger, :error
+    def_delegator :@logger, :warn
+    def_delegator :@logger, :info
+    def_delegator :@logger, :debug
+
+    private
+    def execute
+      subclass_responsibility
+    end
+
+    def log_fpath
+      if @output_dpath
+        @output_dpath.join(@log_base_fpath).add_ext(".log")
+      else
+        @log_base_fpath.add_ext(".log")
+      end
+    end
+  end
+
+  # == Single module analysis driver.
+  class SingleModuleAnalyzer < Analyzer
+    def initialize(fpath, strip_num = 0, output_dpath = nil)
+      super("SMA-#{SHORT_VERSION}", fpath.strip(strip_num), output_dpath)
+
+      @fpath = fpath
+      @strip_num = strip_num
+    end
+
+    private
+    def execute
+      lang = Language.of(@fpath)
+      return unless lang
+
+      ProgressMonitor.instance.reset(@fpath, lang.single_module_phases.size)
+
+      Report.new(msg_fpath, met_fpath) do |report|
+        context = PhaseContext.new(report, log_fpath)
+
+        context[:sources] = [Source.new(@fpath)]
+        context[:symbol_table] = SymbolTable.new
+
+        begin
+          lang.single_module_phases.each do |phase_class|
+            phase_class.new(context).execute
+          end
+        ensure
+          File.open(i_fpath, "w") do |io|
+            io.set_encoding(Encoding.default_external)
+            io.puts(context[:c_source].to_s)
+          end
+        end
+      end
+    rescue
+      if verbose?
+        $stderr.puts "An error was occurred while processing `#{@fpath}'."
+        $stderr.puts "See `#{msg_fpath}' and `#{log_fpath}' for more details."
+      end
+      raise
+    end
+
+    def msg_fpath
+      if @output_dpath
+        @output_dpath.join(@fpath.strip(@strip_num)).add_ext(".msg.csv")
+      else
+        @fpath.strip(@strip_num).add_ext(".msg.csv")
+      end
+    end
+
+    def met_fpath
+      if @output_dpath
+        @output_dpath.join(@fpath.strip(@strip_num)).add_ext(".met.csv")
+      else
+        @fpath.strip(@strip_num).add_ext(".met.csv")
+      end
+    end
+
+    def i_fpath
+      if @output_dpath
+        @output_dpath.join(@fpath.strip(@strip_num)).sub_ext(".i")
+      else
+        @fpath.strip(@strip_num).sub_ext(".i")
+      end
+    end
+  end
+
+  class CrossModuleAnalyzer < Analyzer
+    def initialize(fpaths, output_dpath = nil)
+      @project_name = Traits.instance.of_project.project_name
+      super("CMA-#{SHORT_VERSION}", Pathname.new(@project_name), output_dpath)
+
+      @fpaths = fpaths
+    end
+
+    private
+    PHASE_CLASSES = [
+      AdLint::Ld::MapTypedefPhase,
+      AdLint::Ld::MapFunctionPhase,
+      AdLint::Ld::MapVariablePhase,
+      AdLint::Ld::LinkFunctionPhase,
+      AdLint::Ld::LinkVariablePhase,
+      AdLint::Ld::PreparePhase,
+      AdLint::Ld::TypedefReviewPhase,
+      AdLint::Ld::FunctionReviewPhase,
+      AdLint::Ld::VariableReviewPhase,
+      AdLint::Ld::CommandPhase
+    ].freeze
+    private_constant :PHASE_CLASSES
+
+    def execute
+      ProgressMonitor.instance.reset(@project_name, PHASE_CLASSES.size)
+
+      Report.new(msg_fpath, met_fpath) do |report|
+        context = PhaseContext.new(report, log_fpath)
+
+        context[:project_name] = @project_name
+        context[:metric_fpaths] = @fpaths
+
+        PHASE_CLASSES.each do |phase_class|
+          phase_class.new(context).execute
+        end
+      end
+    rescue
+      if verbose?
+        $stderr.puts "An error was occurred while executing " +
+          "cross module analysis."
+        $stderr.puts "See `#{log_fpath}' for more details."
+      end
+      raise
+    end
+
+    def msg_fpath
+      if @output_dpath
+        @output_dpath.join(Pathname.new(@project_name)).add_ext(".msg.csv")
+      else
+        Pathname.new(@project_name).add_ext(".msg.csv")
+      end
+    end
+
+    def met_fpath
+      if @output_dpath
+        @output_dpath.join(Pathname.new(@project_name)).add_ext(".met.csv")
+      else
+        Pathname.new(@project_name).add_ext(".met.csv")
+      end
+    end
+  end
+
+  # == Configuration files validator.
+  class ConfigurationValidator < Analyzer
+    def initialize(fpath, strip_num = 0, output_dpath = nil)
+      super("CHK-#{SHORT_VERSION}", fpath.strip(strip_num), output_dpath)
+
+      @fpath = fpath
+      @strip_num = strip_num
+    end
+
+    private
+    def execute
+      lang = Language.of(@fpath)
+      return unless lang
+
+      ProgressMonitor.instance.reset(@fpath, lang.check_phases.size)
+
+      Report.new(msg_fpath, met_fpath) do |report|
+        context = PhaseContext.new(report, log_fpath)
+
+        context[:sources] = [Source.new(@fpath)]
+        context[:symbol_table] = SymbolTable.new
+
+        begin
+          lang.check_phases.each do |phase_class|
+            phase_class.new(context).execute
+          end
+        ensure
+          File.open(i_fpath, "w") do |io|
+            io.set_encoding(Encoding.default_external)
+            io.puts(context[:c_source].to_s)
+          end
+        end
+      end
+    rescue
+      if verbose?
+        $stderr.puts "An error was occurred while processing `#{@fpath}'."
+        $stderr.puts "See `#{msg_fpath}' and `#{log_fpath}' for more details."
+      end
+      raise
+    end
+
+    def msg_fpath
+      if @output_dpath
+        @output_dpath.join(@fpath.strip(@strip_num)).add_ext(".msg.csv")
+      else
+        @fpath.strip(@strip_num).add_ext(".msg.csv")
+      end
+    end
+
+    def met_fpath
+      if @output_dpath
+        @output_dpath.join(@fpath.strip(@strip_num)).add_ext(".met.csv")
+      else
+        @fpath.strip(@strip_num).add_ext(".met.csv")
+      end
+    end
+
+    def i_fpath
+      if @output_dpath
+        @output_dpath.join(@fpath.strip(@strip_num)).sub_ext(".i")
+      else
+        @fpath.strip(@strip_num).sub_ext(".i")
+      end
+    end
+  end
+
+end

data/lib/adlint/c/branch.rb

@@ -0,0 +1,251 @@
+# C runtime branch of execution path.
+#
+# 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.
+#
+# AdLint 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 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.  If not, see <http://www.gnu.org/licenses/>.
+#
+#++
+
+require "adlint/c/ctrlexpr"
+
+module AdLint #:nodoc:
+module C #:nodoc:
+
+  class Branch
+    module Option
+      NARROWING = :narrowing
+      WIDENING = :widening
+      FIRST = :first
+      FINAL = :final
+      SMOTHER_BREAK = :smother_break
+      IMPLICIT_CONDITION = :implicit_condition
+    end
+
+    def initialize(branch_group, *options)
+      @group = branch_group
+      @options = options
+      @break_event = nil
+      @controlling_expression = nil
+    end
+
+    attr_reader :group
+    attr_reader :break_event
+    attr_reader :controlling_expression
+
+    def add_options(*options)
+      @options = (@options + options).uniq
+      @group.add_options(*options)
+    end
+
+    def narrowing?
+      @options.include?(Option::NARROWING)
+    end
+
+    def widening?
+      @options.include?(Option::WIDENING)
+    end
+
+    def first?
+      @options.include?(Option::FIRST)
+    end
+
+    def final?
+      @options.include?(Option::FINAL)
+    end
+
+    def smother_break?
+      @options.include?(Option::SMOTHER_BREAK)
+    end
+
+    def implicit_condition?
+      @options.include?(Option::IMPLICIT_CONDITION)
+    end
+
+    def execute(interpreter, expression = nil, &block)
+      environment.begin_versioning_group if first?
+      environment.begin_versioning
+
+      @controlling_expression = ControllingExpression.new(interpreter, self)
+      if ensure_condition(@controlling_expression, expression)
+        @break_event = BreakEvent.catch { yield(self) }
+      end
+
+    ensure
+      environment.end_versioning(break_with_return?)
+      environment.end_versioning_group(!@group.complete?) if final?
+
+      if final? && @group.complete?
+        rethrow_break_event
+      end
+    end
+
+    def restart_versioning(&block)
+      @controlling_expression.save_affected_variables
+      environment.end_versioning(false)
+      environment.end_versioning_group(true)
+      environment.begin_versioning_group
+      environment.begin_versioning
+      yield
+      @controlling_expression.restore_affected_variables
+    end
+
+    def break_with_break?
+      @break_event && @break_event.break?
+    end
+
+    def break_with_continue?
+      @break_event && @break_event.continue?
+    end
+
+    def break_with_return?
+      @break_event && @break_event.return?
+    end
+
+    private
+    def ensure_condition(controlling_expression, expression)
+      case
+      when narrowing?
+        controlling_expression.ensure_true_by_narrowing(expression).commit!
+      when widening?
+        controlling_expression.ensure_true_by_widening(expression).commit!
+      else
+        raise "branch must be for narrowing or widening."
+      end
+      @group.all_condition_variables_value_exist?
+    end
+
+    def rethrow_break_event
+      case
+      when @group.all_branches_break_with_break?
+        BreakEvent.of_break.throw unless smother_break?
+      when @group.all_branches_break_with_return?
+        BreakEvent.of_return.throw
+      end
+    end
+
+    def environment
+      @group.environment
+    end
+  end
+
+  class BranchGroup
+    module Option
+      COMPLETE = :complete
+    end
+
+    def initialize(environment, *options)
+      @environment = environment
+      @options = options
+      @branches = []
+    end
+
+    attr_reader :environment
+
+    def add_options(*options)
+      @options = (@options + options).uniq
+    end
+
+    def complete?
+      @options.include?(Option::COMPLETE)
+    end
+
+    def create_first_branch(*options)
+      new_branch = Branch.new(self, Branch::Option::FIRST, *options)
+      @branches.push(new_branch)
+      new_branch
+    end
+
+    def create_trailing_branch(*options)
+      new_branch = Branch.new(self, *options)
+      @branches.push(new_branch)
+      new_branch
+    end
+
+    def all_condition_variables
+      @branches.map { |branch|
+        branch.controlling_expression ?
+          branch.controlling_expression.affected_variables : []
+      }.flatten.uniq
+    end
+
+    def all_condition_variables_value_exist?
+      all_condition_variables.all? { |variable| variable.value.exist? }
+    end
+
+    def all_branches_break_with_break?
+      @branches.all? { |branch| branch.break_with_break? }
+    end
+
+    def all_branches_break_with_continue?
+      @branches.all? { |branch| branch.break_with_continue? }
+    end
+
+    def all_branches_break_with_return?
+      @branches.all? { |branch| branch.break_with_return? }
+    end
+  end
+
+  class BreakEvent
+    def self.catch(&block)
+      Kernel.catch(:break) { yield; nil }
+    end
+
+    def self.of_break
+      @break ||= new(:break)
+    end
+
+    def self.of_continue
+      @continue ||= new(:continue)
+    end
+
+    def self.of_return
+      @return ||= new(:return)
+    end
+
+    def initialize(type)
+      @type = type
+    end
+    private_class_method :new
+
+    def break?
+      @type == :break
+    end
+
+    def continue?
+      @type == :continue
+    end
+
+    def return?
+      @type == :return
+    end
+
+    def throw
+      Kernel.throw(:break, self)
+    end
+  end
+
+end
+end

data/lib/adlint/c/builtin.rb

@@ -0,0 +1,92 @@
+# Builtin functions actually called by the interpreter.
+#
+# 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.
+#
+# AdLint 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 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.  If not, see <http://www.gnu.org/licenses/>.
+#
+#++
+
+require "adlint/c/type"
+require "adlint/c/object"
+
+module AdLint #:nodoc:
+module C #:nodoc:
+
+  class BuiltinFunction < NamedFunction
+    def initialize(type_table, name)
+      super(nil, type_table.builtin_function_type, name)
+    end
+
+    def explicit?
+      true
+    end
+
+    def builtin?
+      true
+    end
+
+    def call(interpreter, args)
+      interpreter.temporary_variable(type.return_type)
+    end
+  end
+
+  class InspectFunction < BuiltinFunction
+    def initialize(type_table)
+      super(type_table, "__adlint__inspect")
+    end
+
+    def call(interpreter, args)
+      puts "__adlint__inspect"
+      args.each { |arg, expr| pp arg }
+      puts "EOM"
+      super
+    end
+  end
+
+  class EvalFunction < BuiltinFunction
+    def initialize(type_table)
+      super(type_table, "__adlint__eval")
+    end
+
+    def call(interpreter, args)
+      puts "__adlint__eval"
+      char_array = interpreter.pointee_of(args.first.first)
+      if char_array.type.array?
+        without_nil = char_array.value.to_single_value.values[0..-2]
+        program_text = without_nil.map { |char| char.unique_sample.chr }.join
+        if program_text.empty?
+          puts "no program text"
+        else
+          eval program_text
+        end
+        puts "EOM"
+      end
+      super
+    end
+  end
+
+end
+end