adlint 2.6.14 → 3.0.0

data/lib/adlint/exam/c_builtin/ld_metric.rb

@@ -1,7 +1,7 @@
 # Metric measurements (ld-phase) of adlint-exam-c_builtin package.
 #
 # 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.
 #
@@ -40,20 +40,20 @@ module CBuiltin #:nodoc:
   class FN_CALL < MetricMeasurement
     def_registrant_phase Ld::PreparePhase
 
-    def initialize(context)
+    def initialize(phase_ctxt)
       super
-      @context = context
-      @context[:ld_function_traversal].on_definition += method(:measure)
+      @phase_ctxt = phase_ctxt
+      @phase_ctxt[:ld_function_traversal].on_definition += T(:measure)
     end
 
     private
-    def do_prepare(context) end
-    def do_execute(context) end
+    def do_prepare(*) end
+    def do_execute(*) end
 
-    def measure(function)
-      call_graph = @context[:ld_function_call_graph]
-      FN_CALL(FunctionIdentifier.new(function.name, function.signature),
-              function.location, call_graph.all_callers_of(function).size)
+    def measure(fun)
+      call_graph = @phase_ctxt[:ld_function_call_graph]
+      FN_CALL(FunctionId.new(fun.name, fun.signature),
+              fun.location, call_graph.all_callers_of(fun).size)
     end
   end
 

data/lib/adlint/lang.rb

@@ -1,7 +1,7 @@
 # Programming language detection mechanism.
 #
 # 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.
 #
@@ -31,8 +31,8 @@
 
 require "adlint/cpp/scanner"
 require "adlint/cpp/phase"
-require "adlint/c/scanner"
-require "adlint/c/phase"
+require "adlint/cc1/scanner"
+require "adlint/cc1/phase"
 
 module AdLint #:nodoc:
 
@@ -53,7 +53,7 @@ module AdLint #:nodoc:
     end
 
     class Cpp
-      extend AdLint::Cpp::Scanner
+      extend ::AdLint::Cpp::Scanner
 
       class << self
         def single_module_phases; [] end
@@ -62,35 +62,35 @@ module AdLint #:nodoc:
     end
 
     class C
-      include AdLint::C::ScannerConstants
-      extend AdLint::C::Scanner
+      include Cc1::ScannerConstants
+      extend  Cc1::Scanner
 
       class << self
         def single_module_phases
           [
-            AdLint::Cpp::Prepare1Phase,
-            AdLint::Cpp::Prepare2Phase,
-            AdLint::Cpp::EvalPhase,
-            AdLint::Cpp::SubstPhase,
-            AdLint::C::Prepare1Phase,
-            AdLint::C::ParsePhase,
-            AdLint::C::ResolvePhase,
-            AdLint::C::Prepare2Phase,
-            AdLint::C::InterpPhase,
-            AdLint::Cpp::ReviewPhase,
-            AdLint::C::ReviewPhase,
-            AdLint::Cpp::ExaminationPhase,
-            AdLint::C::ExaminationPhase
+            ::AdLint::Cpp::Prepare1Phase,
+            ::AdLint::Cpp::Prepare2Phase,
+            ::AdLint::Cpp::EvalPhase,
+            ::AdLint::Cpp::SubstPhase,
+            ::AdLint::Cc1::Prepare1Phase,
+            ::AdLint::Cc1::ParsePhase,
+            ::AdLint::Cc1::ResolvePhase,
+            ::AdLint::Cc1::Prepare2Phase,
+            ::AdLint::Cc1::InterpPhase,
+            ::AdLint::Cpp::ReviewPhase,
+            ::AdLint::Cc1::ReviewPhase,
+            ::AdLint::Cpp::ExaminationPhase,
+            ::AdLint::Cc1::ExaminationPhase
           ].freeze
         end
 
         def check_phases
           [
-            AdLint::Cpp::Prepare1Phase,
-            AdLint::Cpp::EvalPhase,
-            AdLint::Cpp::SubstPhase,
-            AdLint::C::Prepare1Phase,
-            AdLint::C::ParsePhase
+            ::AdLint::Cpp::Prepare1Phase,
+            ::AdLint::Cpp::EvalPhase,
+            ::AdLint::Cpp::SubstPhase,
+            ::AdLint::Cc1::Prepare1Phase,
+            ::AdLint::Cc1::ParsePhase
           ].freeze
         end
       end

data/lib/adlint/ld.rb

@@ -1,7 +1,7 @@
 # AdLint::Ld package loader.
 #
 # 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.
 #

data/lib/adlint/ld/object.rb

@@ -1,7 +1,7 @@
 # C runtime object 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,6 +29,7 @@
 #
 #++
 
+require "adlint/location"
 require "adlint/metric"
 require "adlint/util"
 
@@ -36,24 +37,26 @@ module AdLint #:nodoc:
 module Ld #:nodoc:
 
   class Variable
-    def initialize(variable_definition_record)
-      @metric_record = variable_definition_record
+    include LocationHolder
+
+    def initialize(var_def_rec)
+      @met_record = var_def_rec
     end
 
     def location
-      @metric_record.location
+      @met_record.location
     end
 
     def name
-      @metric_record.variable_name
+      @met_record.variable_name
     end
 
     def type
-      @metric_record.type_rep
+      @met_record.type_rep
     end
 
     def extern?
-      @metric_record.var_linkage_type == "X"
+      @met_record.variable_linkage_type == "X"
     end
 
     def eql?(rhs)
@@ -68,20 +71,22 @@ module Ld #:nodoc:
   end
 
   class VariableDeclaration
-    def initialize(global_variable_declaration_record)
-      @metric_record = global_variable_declaration_record
+    include LocationHolder
+
+    def initialize(gvar_dcl_rec)
+      @met_record = gvar_dcl_rec
     end
 
     def location
-      @metric_record.location
+      @met_record.location
     end
 
     def name
-      @metric_record.variable_name
+      @met_record.variable_name
     end
 
     def type
-      @metric_record.type_rep
+      @met_record.type_rep
     end
 
     def extern?
@@ -101,36 +106,37 @@ module Ld #:nodoc:
 
   class VariableMapping
     def initialize
-      @variable_index = Hash.new { |hash, key| hash[key] = Set.new }
-      @declaration_index = Hash.new { |hash, key| hash[key] = Set.new }
+      @def_index = Hash.new { |hash, key| hash[key] = Set.new }
+      @dcl_index = Hash.new { |hash, key| hash[key] = Set.new }
+      @composing_fpaths = Set.new
     end
 
-    def add_variable(variable)
-      @variable_index[variable.name].add(variable)
+    attr_reader :composing_fpaths
+
+    def add_variable(var)
+      @def_index[var.name].add(var)
+      @composing_fpaths.add(var.location.fpath)
     end
 
-    def add_variable_declaration(variable_declaration)
-      @declaration_index[variable_declaration.name].add(variable_declaration)
+    def add_variable_declaration(var_dcl)
+      @dcl_index[var_dcl.name].add(var_dcl)
+      @composing_fpaths.add(var_dcl.location.fpath)
     end
 
     def all_variables
-      @variable_index.values.reduce(Set.new) { |all, variables|
-        all + variables
-      }.to_a
+      @def_index.values.reduce(Set.new) { |all, vars| all + vars }.to_a
     end
 
     def all_variable_declarations
-      @declaration_index.values.reduce(Set.new) { |all, declarations|
-        all + declarations
-      }.to_a
+      @dcl_index.values.reduce(Set.new) { |all, dcls| all + dcls }.to_a
     end
 
-    def lookup_variables(variable_name)
-      @variable_index[variable_name].to_a
+    def lookup_variables(var_name)
+      @def_index[var_name].to_a
     end
 
-    def lookup_variable_declarations(variable_name)
-      @declaration_index[variable_name].to_a
+    def lookup_variable_declarations(var_name)
+      @dcl_index[var_name].to_a
     end
   end
 
@@ -141,26 +147,31 @@ module Ld #:nodoc:
 
     attr_reader :result
 
-    def execute(metric_fpath)
-      CSV.foreach(metric_fpath) do |row|
-        record = MetricRecord.of(row)
+    def execute(met_fpath)
+      sma_wd = Pathname.pwd
+      CSV.foreach(met_fpath) do |csv_row|
+        rec = MetricRecord.of(csv_row, sma_wd)
         case
-        when record.variable_definition?
-          if record.var_linkage_type == "X"
-            @result.add_variable(Variable.new(record))
+        when rec.version?
+          sma_wd = Pathname.new(rec.exec_working_directory)
+        when rec.variable_definition?
+          if rec.variable_linkage_type == "X"
+            @result.add_variable(Variable.new(rec))
           end
-        when record.global_variable_declaration?
-          @result.add_variable_declaration(VariableDeclaration.new(record))
+        when rec.global_variable_declaration?
+          @result.add_variable_declaration(VariableDeclaration.new(rec))
         end
       end
     end
   end
 
   class VariableReference
-    def initialize(function, variable, location)
-      @function = function
-      @variable = variable
-      @location = location
+    include LocationHolder
+
+    def initialize(fun, var, loc)
+      @function = fun
+      @variable = var
+      @location = loc
     end
 
     attr_reader :function
@@ -168,70 +179,71 @@ module Ld #:nodoc:
     attr_reader :location
 
     def eql?(rhs)
-      @function == rhs.function && @variable == rhs.variable &&
-        @location == rhs.location
+      to_a == rhs.to_a
     end
 
     alias :== :eql?
 
     def hash
-      [@function, @variable, @location].hash
+      to_a.hash
+    end
+
+    def to_a
+      [@function, @variable, @location]
     end
   end
 
   class VariableReferenceGraph
-    extend Memoizable
-
-    def initialize(function_call_graph)
-      @function_call_graph = function_call_graph
-      @referrer_index = Hash.new { |hash, key| hash[key] = Set.new }
-      @variable_index = Hash.new { |hash, key| hash[key] = Set.new }
+    def initialize(funcall_graph)
+      @funcall_graph = funcall_graph
+      @ref_index = Hash.new { |hash, key| hash[key] = Set.new }
+      @var_index = Hash.new { |hash, key| hash[key] = Set.new }
     end
 
-    def add(variable_reference)
-      @referrer_index[variable_reference.function].add(variable_reference)
-      @variable_index[variable_reference.variable].add(variable_reference)
+    def add(var_ref)
+      @ref_index[var_ref.function].add(var_ref)
+      @var_index[var_ref.variable].add(var_ref)
     end
 
-    def all_referrers_of(variable)
-      direct_referrers_of(variable) + indirect_referrers_of(variable)
+    def all_referrers_of(var)
+      direct_referrers_of(var) + indirect_referrers_of(var)
     end
 
-    def direct_referrers_of(variable)
-      @variable_index[variable].map { |varref| varref.function }.to_set
+    def direct_referrers_of(var)
+      @var_index[var].map { |var_ref| var_ref.function }.to_set
     end
 
-    def indirect_referrers_of(variable)
-      direct_referrers = direct_referrers_of(variable)
-      direct_referrers.reduce(Set.new) do |result, function|
-        result + @function_call_graph.all_callers_of(function)
+    def indirect_referrers_of(var)
+      direct_referrers = direct_referrers_of(var)
+      direct_referrers.reduce(Set.new) do |result, fun|
+        result + @funcall_graph.all_callers_of(fun)
       end
     end
   end
 
   class VariableReferenceGraphBuilder
-    def initialize(variable_mapping, function_mapping, function_call_graph)
-      @variable_mapping = variable_mapping
-      @function_mapping = function_mapping
-      @result = VariableReferenceGraph.new(function_call_graph)
+    def initialize(var_mapping, fun_mapping, funcall_graph)
+      @variable_mapping = var_mapping
+      @function_mapping = fun_mapping
+      @result = VariableReferenceGraph.new(funcall_graph)
     end
 
     attr_reader :result
 
-    def execute(metric_fpath)
-      CSV.foreach(metric_fpath) do |row|
-        record = MetricRecord.of(row)
+    def execute(met_fpath)
+      sma_wd = Pathname.pwd
+      CSV.foreach(met_fpath) do |csv_row|
+        rec = MetricRecord.of(csv_row, sma_wd)
         case
-        when record.variable_xref?
-          function = @function_mapping.lookup_functions(
-            record.accessor_function.name).first
-
-          variable = @variable_mapping.lookup_variables(
-            record.accessee_variable).first
-
-          if function && variable
-            @result.add(VariableReference.new(
-              function, variable, record.location))
+        when rec.version?
+          sma_wd = Pathname.new(rec.exec_working_directory)
+        when rec.variable_xref?
+          fun = @function_mapping.lookup_functions(
+            rec.accessor_function.name).first
+          var = @variable_mapping.lookup_variables(rec.accessee_variable).first
+
+          if fun && var
+            @result.add(VariableReference.new(fun, var, rec.location))
           end
         end
       end
@@ -239,8 +251,8 @@ module Ld #:nodoc:
   end
 
   class VariableTraversal
-    def initialize(variable_mapping)
-      @variable_mapping = variable_mapping
+    def initialize(var_mapping)
+      @variable_mapping = var_mapping
     end
 
     extend Pluggable
@@ -249,35 +261,37 @@ module Ld #:nodoc:
     def_plugin :on_definition
 
     def execute
-      @variable_mapping.all_variable_declarations.each do |declaration|
-        on_declaration.invoke(declaration)
+      @variable_mapping.all_variable_declarations.each do |var_dcl|
+        on_declaration.invoke(var_dcl)
       end
 
-      @variable_mapping.all_variables.each do |definition|
-        on_definition.invoke(definition)
+      @variable_mapping.all_variables.each do |var_def|
+        on_definition.invoke(var_def)
       end
     end
   end
 
   class Function
-    def initialize(function_definition_record)
-      @metric_record = function_definition_record
+    include LocationHolder
+
+    def initialize(fun_def_rec)
+      @met_record = fun_def_rec
     end
 
     def location
-      @metric_record.location
+      @met_record.location
     end
 
     def signature
-      @metric_record.function_identifier.signature
+      @met_record.function_id.signature
     end
 
     def name
-      @metric_record.function_identifier.name
+      @met_record.function_id.name
     end
 
     def extern?
-      @metric_record.function_linkage_type == "X"
+      @met_record.function_linkage_type == "X"
     end
 
     def eql?(rhs)
@@ -292,24 +306,34 @@ module Ld #:nodoc:
   end
 
   class FunctionDeclaration
-    def initialize(function_declaration_record)
-      @metric_record = function_declaration_record
+    include LocationHolder
+
+    def initialize(fun_dcl_rec)
+      @met_record = fun_dcl_rec
     end
 
     def location
-      @metric_record.location
+      @met_record.location
     end
 
     def signature
-      @metric_record.function_identifier.signature
+      @met_record.function_id.signature
     end
 
     def name
-      @metric_record.function_identifier.name
+      @met_record.function_id.name
     end
 
     def extern?
-      @metric_record.function_linkage_type == "X"
+      @met_record.function_linkage_type == "X"
+    end
+
+    def explicit?
+      @met_record.function_declaration_type == "E"
+    end
+
+    def implicit?
+      @met_record.function_declaration_type == "I"
     end
 
     def eql?(rhs)
@@ -325,36 +349,37 @@ module Ld #:nodoc:
 
   class FunctionMapping
     def initialize
-      @function_index = Hash.new { |hash, key| hash[key] = Set.new }
-      @declaration_index = Hash.new { |hash, key| hash[key] = Set.new }
+      @def_index = Hash.new { |hash, key| hash[key] = Set.new }
+      @dcl_index = Hash.new { |hash, key| hash[key] = Set.new }
+      @composing_fpaths = Set.new
     end
 
-    def add_function(function)
-      @function_index[function.name].add(function)
+    attr_reader :composing_fpaths
+
+    def add_function(fun)
+      @def_index[fun.name].add(fun)
+      @composing_fpaths.add(fun.location.fpath)
     end
 
-    def add_function_declaration(function_declaration)
-      @declaration_index[function_declaration.name].add(function_declaration)
+    def add_function_declaration(fun_dcl)
+      @dcl_index[fun_dcl.name].add(fun_dcl)
+      @composing_fpaths.add(fun_dcl.location.fpath)
     end
 
     def all_functions
-      @function_index.values.reduce(Set.new) { |all, functions|
-        all + functions
-      }.to_a
+      @def_index.values.reduce(Set.new) { |all, funs| all + funs }.to_a
     end
 
     def all_function_declarations
-      @declaration_index.values.reduce(Set.new) { |all, declarations|
-        all + declarations
-      }.to_a
+      @dcl_index.values.reduce(Set.new) { |all, dcls| all + dcls }.to_a
     end
 
-    def lookup_functions(function_name)
-      @function_index[function_name].to_a
+    def lookup_functions(fun_name)
+      @def_index[fun_name].to_a
     end
 
-    def lookup_function_declarations(function_name)
-      @declaration_index[function_name].to_a
+    def lookup_function_declarations(fun_name)
+      @dcl_index[fun_name].to_a
     end
   end
 
@@ -365,83 +390,87 @@ module Ld #:nodoc:
 
     attr_reader :result
 
-    def execute(metric_fpath)
-      CSV.foreach(metric_fpath) do |row|
-        record = MetricRecord.of(row)
+    def execute(met_fpath)
+      sma_wd = Pathname.pwd
+      CSV.foreach(met_fpath) do |csv_row|
+        rec = MetricRecord.of(csv_row, sma_wd)
         case
-        when record.function_definition?
-          @result.add_function(Function.new(record))
-        when record.function_declaration?
-          @result.add_function_declaration(FunctionDeclaration.new(record))
+        when rec.version?
+          sma_wd = Pathname.new(rec.exec_working_directory)
+        when rec.function_definition?
+          @result.add_function(Function.new(rec))
+        when rec.function_declaration?
+          @result.add_function_declaration(FunctionDeclaration.new(rec))
         end
       end
     end
   end
 
   class FunctionCall
-    def initialize(caller_function, callee_function)
-      @caller_function = caller_function
-      @callee_function = callee_function
+    def initialize(caller_fun, callee_fun)
+      @caller_function = caller_fun
+      @callee_function = callee_fun
     end
 
     attr_reader :caller_function
     attr_reader :callee_function
 
     def eql?(rhs)
-      @caller_function == rhs.caller_function &&
-        @callee_function == rhs.callee_function
+      to_a == rhs.to_a
     end
 
     alias :== :eql?
 
     def hash
-      [@caller_function, @callee_function].hash
+      to_a.hash
+    end
+
+    def to_a
+      [@caller_function, @callee_function]
     end
   end
 
   class FunctionCallGraph
-    extend Memoizable
-
     def initialize
       @caller_index = Hash.new { |hash, key| hash[key] = Set.new }
       @callee_index = Hash.new { |hash, key| hash[key] = Set.new }
     end
 
-    def add(function_call)
-      @caller_index[function_call.caller_function].add(function_call)
-      @callee_index[function_call.callee_function].add(function_call)
+    def add(funcall)
+      @caller_index[funcall.caller_function].add(funcall)
+      @callee_index[funcall.callee_function].add(funcall)
     end
 
-    def all_callers_of(callee_function)
-      direct_callers_of(callee_function) + indirect_callers_of(callee_function)
+    def all_callers_of(callee_fun)
+      direct_callers_of(callee_fun) + indirect_callers_of(callee_fun)
     end
     memoize :all_callers_of
 
-    def direct_callers_of(callee_function)
-      @callee_index[callee_function].map { |funcall|
+    def direct_callers_of(callee_fun)
+      @callee_index[callee_fun].map { |funcall|
         funcall.caller_function
       }.to_set
     end
     memoize :direct_callers_of
 
-    def indirect_callers_of(callee_function)
-      direct_callers = direct_callers_of(callee_function)
-      direct_callers.reduce(Set.new) do |all_callers, function|
-        all_callers + collect_callers_of(function, all_callers)
+    def indirect_callers_of(callee_fun)
+      direct_callers = direct_callers_of(callee_fun)
+      direct_callers.reduce(Set.new) do |all_callers, fun|
+        all_callers + collect_callers_of(fun, all_callers)
       end
     end
     memoize :indirect_callers_of
 
     private
-    def collect_callers_of(callee_function, exclusion_list)
-      direct_callers = direct_callers_of(callee_function)
+    def collect_callers_of(callee_fun, exclusion_list)
+      direct_callers = direct_callers_of(callee_fun)
 
-      direct_callers.reduce(Set.new) do |all_callers, function|
-        if exclusion_list.include?(function)
-          all_callers.add(function)
+      direct_callers.reduce(Set.new) do |all_callers, fun|
+        if exclusion_list.include?(fun)
+          all_callers.add(fun)
         else
-          all_callers.add(function) +
-            collect_callers_of(function, exclusion_list + all_callers)
+          all_callers.add(fun) +
+            collect_callers_of(fun, exclusion_list + all_callers)
         end
       end
     end
@@ -449,77 +478,80 @@ module Ld #:nodoc:
   end
 
   class FunctionCallGraphBuilder
-    def initialize(function_mapping)
-      @function_mapping = function_mapping
+    def initialize(fun_mapping)
+      @function_mapping = fun_mapping
       @result = FunctionCallGraph.new
     end
 
     attr_reader :result
 
-    def execute(metric_fpath)
-      CSV.foreach(metric_fpath) do |row|
-        record = MetricRecord.of(row)
+    def execute(met_fpath)
+      sma_wd = Pathname.pwd
+      CSV.foreach(met_fpath) do |csv_row|
+        rec = MetricRecord.of(csv_row, sma_wd)
         case
-        when record.function_call?
-          caller_function, callee_function = lookup_functions_by_call(record)
-          if caller_function && callee_function
-            @result.add(FunctionCall.new(caller_function, callee_function))
+        when rec.version?
+          sma_wd = Pathname.new(rec.exec_working_directory)
+        when rec.function_call?
+          caller_fun, callee_fun = lookup_functions_by_call(rec)
+          if caller_fun && callee_fun
+            @result.add(FunctionCall.new(caller_fun, callee_fun))
           end
-        when record.function_xref?
-          caller_function, callee_function = lookup_functions_by_xref(record)
-          if caller_function && callee_function
-            @result.add(FunctionCall.new(caller_function, callee_function))
+        when rec.function_xref?
+          caller_fun, callee_fun = lookup_functions_by_xref(rec)
+          if caller_fun && callee_fun
+            @result.add(FunctionCall.new(caller_fun, callee_fun))
           end
         end
       end
     end
 
-    def lookup_functions_by_call(function_call_record)
-      caller_function = @function_mapping.lookup_functions(
-        function_call_record.caller_function.name).find { |function|
-          function.location.fpath == function_call_record.location.fpath
+    def lookup_functions_by_call(funcall_rec)
+      caller_fun = @function_mapping.lookup_functions(
+        funcall_rec.caller_function.name).find { |fun|
+          fun.location.fpath == funcall_rec.location.fpath
       }
-      return nil, nil unless caller_function
+      return nil, nil unless caller_fun
 
-      callee_functions = @function_mapping.lookup_functions(
-        function_call_record.callee_function.name)
+      callee_funs = @function_mapping.lookup_functions(
+        funcall_rec.callee_function.name)
 
-      callee_function = callee_functions.first
-      callee_functions.each do |function|
-        if function.location.fpath == caller_function.location.fpath
-          callee_function = function
+      callee_fun = callee_funs.first
+      callee_funs.each do |fun|
+        if fun.location.fpath == caller_fun.location.fpath
+          callee_fun = fun
           break
         end
       end
 
-      return caller_function, callee_function
+      return caller_fun, callee_fun
     end
 
-    def lookup_functions_by_xref(function_xref_record)
-      caller_function = @function_mapping.lookup_functions(
-        function_xref_record.accessor_function.name).find { |function|
-          function.location.fpath == function_xref_record.location.fpath
+    def lookup_functions_by_xref(fun_xref_rec)
+      caller_fun = @function_mapping.lookup_functions(
+        fun_xref_rec.accessor_function.name).find { |fun|
+          fun.location.fpath == fun_xref_rec.location.fpath
       }
-      return nil, nil unless caller_function
+      return nil, nil unless caller_fun
 
-      callee_functions = @function_mapping.lookup_functions(
-        function_xref_record.accessee_function.name)
+      callee_funs = @function_mapping.lookup_functions(
+        fun_xref_rec.accessee_function.name)
 
-      callee_function = callee_functions.first
-      callee_functions.each do |function|
-        if function.location.fpath == caller_function.location.fpath
-          callee_function = function
+      callee_fun = callee_funs.first
+      callee_funs.each do |fun|
+        if fun.location.fpath == caller_fun.location.fpath
+          callee_fun = fun
           break
         end
       end
 
-      return caller_function, callee_function
+      return caller_fun, callee_fun
     end
   end
 
   class FunctionTraversal
-    def initialize(function_mapping)
-      @function_mapping = function_mapping
+    def initialize(fun_mapping)
+      @function_mapping = fun_mapping
     end
 
     extend Pluggable
@@ -528,12 +560,12 @@ module Ld #:nodoc:
     def_plugin :on_definition
 
     def execute
-      @function_mapping.all_function_declarations.each do |declaration|
-        on_declaration.invoke(declaration)
+      @function_mapping.all_function_declarations.each do |fun_dcl|
+        on_declaration.invoke(fun_dcl)
       end
 
-      @function_mapping.all_functions.each do |definition|
-        on_definition.invoke(definition)
+      @function_mapping.all_functions.each do |fun_def|
+        on_definition.invoke(fun_def)
       end
     end
   end