adlint 2.6.14 → 3.0.0

data/lib/adlint/report.rb

@@ -1,7 +1,7 @@
 # Analysis report and its manipulation utility.
 #
 # 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,7 +29,6 @@
 #
 #++
 
-require "adlint/exam"
 require "adlint/message"
 require "adlint/code"
 require "adlint/metric"
@@ -37,19 +36,16 @@ require "adlint/util"
 
 module AdLint #:nodoc:
 
-  # == DESCRIPTION
-  # Report information collector.
   class Report
-    # === DESCRIPTION
-    # Constructs an empty report.
-    def initialize(msg_fpath, met_fpath, &block)
-      @msg_fpath = msg_fpath
-      @msg_file = open_message_file(msg_fpath)
-
-      @met_fpath = met_fpath
-      @met_file = open_metric_file(met_fpath)
-
-      @unique_messages = Set.new
+    def initialize(msg_fpath, met_fpath, log_fpath, verbose, &block)
+      @msg_fpath     = msg_fpath
+      @msg_file      = open_msg_file(msg_fpath)
+      @met_fpath     = met_fpath
+      @met_file      = open_met_file(met_fpath)
+      @log_fpath     = log_fpath
+      @verbose       = verbose
+      @unique_msgs   = Set.new
+      @deferred_msgs = []
 
       yield(self)
     ensure
@@ -59,55 +55,77 @@ module AdLint #:nodoc:
 
     attr_reader :msg_fpath
     attr_reader :met_fpath
+    attr_reader :log_fpath
 
     # === DESCRIPTION
-    # Adds a message to this report.
+    # Writes a message on this report.
     #
     # === PARAMETER
-    # _message_:: Message -- Message to be added.
+    # _message_:: Message -- Message to be written.
     #
     # === RETURN VALUE
     # Report -- Self.
-    def add_message(message)
-      @msg_file.puts(message.to_csv)
-      $stderr.puts(message.to_s) unless verbose?
+    def write_message(msg, suppressors = nil)
+      if suppressors.nil? || !suppressors.suppress?(msg)
+        unless msg.must_be_unique? && !@unique_msgs.add?(msg)
+          if msg.must_be_deferred?
+            @deferred_msgs.push(msg)
+          else
+            rawrite_message(msg)
+          end
+        end
+      end
       self
     end
 
-    def add_unique_message(message)
-      if @unique_messages.add?(message)
-        add_message(message)
+    def flush_deferred_messages(suppressors)
+      @deferred_msgs.each do |msg|
+        rawrite_message(msg) unless suppressors.suppress?(msg)
       end
+      @deferred_msgs.clear
       self
     end
 
     # === DESCRIPTION
-    # Adds code structure information to this report.
+    # Writes a code structure information on this report.
     #
     # === PARAMETER
-    # _code_struct_:: CodeStructure -- Code structure information to be added.
+    # _code_struct_:: CodeStructure -- Code structure info to be written.
     #
     # === RETURN VALUE
     # Report -- Self.
-    def add_code_struct(code_struct)
-      @met_file.puts(code_struct.to_csv)
+    def write_code_struct(code_struct)
+      code_struct.print_as_csv(@met_file)
       self
     end
 
-    def add_code_metric(code_metric)
-      @met_file.puts(code_metric.to_csv)
+    # === DESCRIPTION
+    # Writes a code quality metric on this report.
+    #
+    # === PARAMETER
+    # _code_metric_:: CodeMetric -- Code metric information to be written.
+    #
+    # === RETURN VALUE
+    # Report -- Self.
+    def write_code_metric(code_metric)
+      code_metric.print_as_csv(@met_file)
       self
     end
 
     private
-    def open_message_file(fpath)
+    def rawrite_message(msg)
+      msg.print_as_csv(@msg_file)
+      msg.print_as_str($stderr) unless @verbose
+    end
+
+    def open_msg_file(fpath)
       File.open(fpath, "w").tap do |io|
         io.set_encoding(Encoding.default_external)
         io.puts(["V", SHORT_VERSION, Time.now.to_s, Dir.getwd].to_csv)
       end
     end
 
-    def open_metric_file(fpath)
+    def open_met_file(fpath)
       File.open(fpath, "w").tap do |io|
         io.set_encoding(Encoding.default_external)
         io.puts(["VER", SHORT_VERSION, Time.now.to_s, Dir.getwd].to_csv)
@@ -115,513 +133,416 @@ module AdLint #:nodoc:
     end
   end
 
-  module MessageUniqueness
-    @@messages_to_be_unique = Set.new
-
-    def ensure_uniqueness_of(message_id)
-      @@messages_to_be_unique.add(message_id)
-      nil
-    end
-
-    def must_be_unique?(message_id)
-      @@messages_to_be_unique.include?(message_id)
-    end
-    module_function :must_be_unique?
-  end
-
-  # == DESCRIPTION
-  # Report manipulation utility.
   module ReportUtil
+    # NOTE: Host class must respond to #report.
+    # NOTE: Host class must respond to #message_catalog.
+    # NOTE: Host class which needs #write_warning_message must respond to
+    #       #suppressors.
+
     # === DESCRIPTION
-    # Adds an error message to the report.
+    # Writes an error message on the report.
     #
     # Abbreviation below is available.
-    #  add_error_message(id, location, ...) => E(id, location, ...)
+    #  write_error_message(msg_name, loc, ...) => E(msg_name, loc, ...)
     #
     # === PARAMETER
-    # _id_:: String -- Message id string.
-    # _location_:: Location -- Location where the message detected.
+    # _msg_name_:: Symbol -- Message name.
+    # _loc_:: Location -- Location where the message points to.
     # _parts_:: Array< Object > -- Message formatting parts.
     #
     # === RETURN VALUE
     # None.
-    def add_error_message(id, location, *parts)
-      add_message(ErrorMessage.new(id, location, *parts))
+    def write_error_message(msg_name, loc, *parts)
+      report.write_message(
+        ErrorMessage.new(message_catalog, msg_name, loc, *parts))
     end
-    alias :E :add_error_message
-    module_function :add_error_message, :E
+    alias :E :write_error_message
 
     # === DESCRIPTION
-    # Adds a warning message to the report.
+    # Writes a warning message on the report.
     #
     # Abbreviation below is available.
-    #  add_warning_message(id, location, ...) => W(id, location, ...)
+    #  write_warning_message(loc, ...) => W(loc, ...)
     #
     # === PARAMETER
-    # _id_:: String -- Message id string.
-    # _location_:: Location -- Location where the message detected.
-    # _parts_:: Array< Object > -- Message formatting parts.
+    # _loc_:: Location -- Location where the message points to.
     #
     # === RETURN VALUE
     # None.
-    def add_warning_message(package, id, location, *parts)
-      add_message(WarningMessage.new(package, id, location, *parts))
-    end
-    module_function :add_warning_message
+    def write_warning_message(*args)
+      check_class = self.class
+      check_class = check_class.outer_module until check_class < CodeCheck
+
+      head_msg = nil
+      args.chunk { |arg| arg.kind_of?(Message) }.each do |*, chunk|
+        case chunk.first
+        when Message
+          if head_msg
+            chunk.each { |ctxt_msg| head_msg.complement_with(ctxt_msg) }
+          end
+        else
+          head_msg = WarningMessage.new(message_catalog, check_class, *chunk)
+        end
+      end
 
-    def W(id, location, *parts)
-      add_warning_message(PackageResolver.package_name_of(self.class),
-                          id, location, *parts)
+      report.write_message(head_msg, suppressors) if head_msg
     end
-    module_function :W
+    alias :W :write_warning_message
 
     # === DESCRIPTION
-    # Adds a context message to the report.
+    # Creates a context message.
     #
     # Abbreviation below is available.
-    #  add_context_message(id, location, ...) => C(id, location, ...)
+    #  create_context_message(msg_name, loc, ...) => C(msg_name, loc, ...)
     #
     # === PARAMETER
-    # _id_:: String -- Message id string.
-    # _location_:: Location -- Location where the message detected.
+    # _msg_name_:: Symbol -- Message name.
+    # _loc_:: Location -- Location where the message points to.
     # _parts_:: Array< Object > -- Message formatting parts.
     #
     # === RETURN VALUE
-    # None.
-    def add_context_message(package, id, location, *parts)
-      add_message(ContextMessage.new(package, id, location, *parts))
-    end
-    module_function :add_context_message
-
-    def C(id, location, *parts)
-      add_context_message(PackageResolver.package_name_of(self.class),
-                          id, location, *parts)
+    # ContextMessage -- New context message.
+    def create_context_message(msg_name, loc, *parts)
+      ContextMessage.new(message_catalog, msg_name, self.class, loc, *parts)
     end
-    module_function :C
+    alias :C :create_context_message
 
     # === DESCRIPTION
-    # Adds a message to the report.
-    #
-    # === PARAMETER
-    # _message_:: Message -- Message to be added.
-    #
-    # === RETURN VALUE
-    # None.
-    def add_message(message)
-      if MessageUniqueness.must_be_unique?(message.id)
-        report.add_unique_message(message)
-      else
-        report.add_message(message)
-      end
-      nil
-    end
-    module_function :add_message
-
-    # === DESCRIPTION
-    # Adds type declaration information to the report.
+    # Writes a type declaration information on the report.
     #
     # Abbreviation below is available.
-    #  add_typedcl(...) => TYPEDCL(...)
+    #  write_typedcl(...) => TYPEDCL(...)
     #
     # === PARAMETER
-    # _location_:: Location -- Location where the declaration appears.
-    # _typedcl_type_:: String -- Type declaration type.
+    # _loc_:: Location -- Location where the declaration appears.
+    # _dcl_type_:: String -- Type declaration type.
     # _type_name_:: String -- Type name.
     # _type_rep_:: String -- Type representation string.
     #
     # === RETURN VALUE
     # None.
-    def add_typedcl(location, typedcl_type, type_name, type_rep)
-      add_code_struct(TypeDcl.new(location, typedcl_type, type_name, type_rep))
+    def write_typedcl(loc, dcl_type, type_name, type_rep)
+      write_code_struct(TypeDcl.new(loc, dcl_type, type_name, type_rep))
     end
-    alias :TYPEDCL :add_typedcl
-    module_function :add_typedcl, :TYPEDCL
+    alias :TYPEDCL :write_typedcl
 
     # === DESCRIPTION
-    # Adds global variable decaration information to the report.
+    # Writes a global variable decaration information on the report.
     #
     # Abbreviation below is available.
-    #  add_gvardcl(...) => GVARDCL(...)
+    #  write_gvardcl(...) => GVARDCL(...)
     #
     # === PARAMETER
-    # _location_:: Location -- Location where the declaration appears.
-    # _variable_name_:: String -- Global variable name.
+    # _loc_:: Location -- Location where the declaration appears.
+    # _var_name_:: String -- Global variable name.
     # _type_rep_:: String -- Type representation string.
     #
     # === RETURN VALUE
     # None.
-    def add_gvardcl(location, variable_name, type_rep)
-      add_code_struct(GVarDcl.new(location, variable_name, type_rep))
+    def write_gvardcl(loc, var_name, type_rep)
+      write_code_struct(GVarDcl.new(loc, var_name, type_rep))
     end
-    alias :GVARDCL :add_gvardcl
-    module_function :add_gvardcl, :GVARDCL
+    alias :GVARDCL :write_gvardcl
 
     # === DESCRIPTION
-    # Adds function declaration information to the report.
+    # Writes a function declaration information on the report.
     #
     # Abbreviation below is available.
-    #  add_funcdcl(...) => FUNCDCL(...)
+    #  write_funcdcl(...) => FUNCDCL(...)
     #
     # === PARAMETER
-    # _location_:: Location -- Location where the declaration appears.
-    # _function_linkage_type_:: String -- Function linkage type string.
-    # _function_scope_type_:: String -- Declaration scope type string.
-    # _function_identifier_:: String -- Function identifier.
+    # _loc_:: Location -- Location where the declaration appears.
+    # _linkage_:: String -- Function linkage type string.
+    # _scope_type_:: String -- Declaration scope type string.
+    # _dcl_type_:: String -- Declaration type string.
+    # _fun_id_:: FunctionId -- Identifier of the function.
     #
     # === RETURN VALUE
     # None.
-    def add_funcdcl(location, function_linkage_type, function_scope_type,
-                    function_identifier)
-      add_code_struct(FuncDcl.new(location, function_linkage_type,
-                                  function_scope_type, function_identifier))
+    def write_funcdcl(loc, linkage, scope_type, dcl_type, fun_id)
+      write_code_struct(FuncDcl.new(loc, linkage, scope_type, dcl_type,
+                                    fun_id))
     end
-    alias :FUNCDCL :add_funcdcl
-    module_function :add_funcdcl, :FUNCDCL
+    alias :FUNCDCL :write_funcdcl
 
     # === DESCRIPTION
-    # Adds variable definition information to the report.
+    # Writes a variable definition information on the report.
     #
     # Abbreviation below is available.
-    #  add_vardef(...) => VARDEF(...)
+    #  write_vardef(...) => VARDEF(...)
     #
     # === PARAMETER
-    # _location_:: Location -- Location where the definition appears.
-    # _var_linkage_type_:: String -- Variable linkage type string.
-    # _var_scope_type_:: String -- Variable scope type string.
-    # _storage_class_type_:: String -- Variable storage class type.
-    # _variable_name_:: String -- Variable name.
+    # _loc_:: Location -- Location where the definition appears.
+    # _linkage_type_:: String -- Variable linkage type string.
+    # _scope_type_:: String -- Variable scope type string.
+    # _sc_type_:: String -- Variable storage class type.
+    # _var_name_:: String -- Variable name.
     # _type_rep_:: String -- Variable type representation string.
     #
     # === RETURN VALUE
     # None.
-    def add_vardef(location, var_linkage_type, var_scope_type,
-                   storage_class_type, variable_name, type_rep)
-      add_code_struct(VarDef.new(location, var_linkage_type, var_scope_type,
-                                 storage_class_type, variable_name, type_rep))
+    def write_vardef(loc, linkage, scope_type, sc_type, var_name, type_rep)
+      write_code_struct(VarDef.new(loc, linkage, scope_type, sc_type, var_name,
+                                   type_rep))
     end
-    alias :VARDEF :add_vardef
-    module_function :add_vardef, :VARDEF
+    alias :VARDEF :write_vardef
 
     # === DESCRIPTION
-    # Adds function definition information to the report.
+    # Writes a function definition information on the report.
     #
     # Abbreviation below is available.
-    #  add_funcdef(...) => FUNCDEF(...)
+    #  write_funcdef(...) => FUNCDEF(...)
     #
     # === PARAMETER
-    # _location_:: Location -- Location where the definition appears.
-    # _function_linkage_type_:: String -- Function linkage type string.
-    # _function_scope_type_:: String -- Definition scope type string.
-    # _function_identifier_:: String -- Function identifier.
+    # _loc_:: Location -- Location where the definition appears.
+    # _linkage_:: String -- Function linkage type string.
+    # _scope_type_:: String -- Definition scope type string.
+    # _fun_id_:: FunctionId -- Identifier of the function.
     # _lines_:: Integer -- Physical lines.
     #
     # === RETURN VALUE
     # None.
-    def add_funcdef(location, function_linkage_type, function_scope_type,
-                    function_identifier, lines)
-      add_code_struct(FuncDef.new(location, function_linkage_type,
-                                  function_scope_type, function_identifier,
-                                  lines))
+    def write_funcdef(loc, linkage, scope_type, fun_id, lines)
+      write_code_struct(FuncDef.new(loc, linkage, scope_type, fun_id, lines))
     end
-    alias :FUNCDEF :add_funcdef
-    module_function :add_funcdef, :FUNCDEF
+    alias :FUNCDEF :write_funcdef
 
     # === DESCRIPTION
-    # Adds macro definition information to the report.
+    # Writes a macro definition information on the report.
     #
     # Abbreviation below is available.
-    #  add_macrodef(...) => MACRODEF(...)
+    #  write_macrodef(...) => MACRODEF(...)
     #
     # === PARAMETER
-    # _location_:: Location -- Location where the definition appears.
+    # _loc_:: Location -- Location where the definition appears.
     # _macro_name_:: String -- Macro name.
     # _macro_type_:: String -- Macro type string.
     #
     # === RETURN VALUE
     # None.
-    def add_macrodef(location, macro_name, macro_type)
-      add_code_struct(MacroDef.new(location, macro_name, macro_type))
+    def write_macrodef(loc, macro_name, macro_type)
+      write_code_struct(MacroDef.new(loc, macro_name, macro_type))
     end
-    alias :MACRODEF :add_macrodef
-    module_function :add_macrodef, :MACRODEF
+    alias :MACRODEF :write_macrodef
 
     # === DESCRIPTION
-    # Adds label definition information to the report.
+    # Writes a label definition information on the report.
     #
     # Abbreviation below is available.
-    #  add_labeldef(...) => LABELDEF(...)
+    #  write_labeldef(...) => LABELDEF(...)
     #
     # === PARAMETER
-    # _location_:: Location -- Location where the definition appears.
+    # _loc_:: Location -- Location where the definition appears.
     # _label_name_:: String -- Label name.
     #
     # === RETURN VALUE
     # None.
-    def add_labeldef(location, label_name)
-      add_code_struct(LabelDef.new(location, label_name))
+    def write_labeldef(loc, label_name)
+      write_code_struct(LabelDef.new(loc, label_name))
     end
-    alias :LABELDEF :add_labeldef
-    module_function :add_labeldef, :LABELDEF
+    alias :LABELDEF :write_labeldef
 
     # === DESCRIPTION
-    # Adds initialization information to the report.
+    # Writes an initialization information on the report.
     #
     # Abbreviation below is available.
-    #  add_initialization(...) => INITIALIZATION(...)
+    #  write_initialization(...) => INITIALIZATION(...)
     #
     # === PARAMETER
-    # _location_:: Location -- Location where the variable appears.
-    # _variable_name_:: String -- Initialized variable name.
-    # _initializer_rep_:: String -- Initializer representation.
+    # _loc_:: Location -- Location where the variable appears.
+    # _var_name_:: String -- Initialized variable name.
+    # _init_rep_:: String -- String representation of the initializer.
     #
     # === RETURN VALUE
     # None.
-    def add_initialization(location, variable_name, initializer_rep)
-      add_code_struct(Initialization.new(location, variable_name,
-                                         initializer_rep))
+    def write_initialization(loc, var_name, init_rep)
+      write_code_struct(Initialization.new(loc, var_name, init_rep))
     end
-    alias :INITIALIZATION :add_initialization
-    module_function :add_initialization, :INITIALIZATION
+    alias :INITIALIZATION :write_initialization
 
     # === DESCRIPTION
-    # Adds assignment information to the report.
+    # Writes an assignment information on the report.
     #
     # Abbreviation below is available.
-    #  add_assignment(...) => ASSIGNMENT(...)
+    #  write_assignment(...) => ASSIGNMENT(...)
     #
     # === PARAMETER
-    # _location_:: Location -- Location where the variable appears.
-    # _variable_name_:: String -- Assigned variable name.
-    # _assignment_rep_:: String -- Assignment expression representation.
+    # _loc_:: Location -- Location where the variable appears.
+    # _var_name_:: String -- Assigned variable name.
+    # _assign_rep_:: String -- String representation of the assignment.
     #
     # === RETURN VALUE
     # None.
-    def add_assignment(location, variable_name, assignment_rep)
-      add_code_struct(Assignment.new(location, variable_name,
-                                     assignment_rep))
+    def write_assignment(loc, var_name, assign_rep)
+      write_code_struct(Assignment.new(loc, var_name, assign_rep))
     end
-    alias :ASSIGNMENT :add_assignment
-    module_function :add_assignment, :ASSIGNMENT
+    alias :ASSIGNMENT :write_assignment
 
     # === DESCRIPTION
-    # Adds header include information to the report.
+    # Writes a header include information on the report.
     #
     # Abbreviation below is available.
-    #  add_include(...) => INCLUDE(...)
+    #  write_include(...) => INCLUDE(...)
     #
     # === PARAMETER
-    # _location_:: Location -- Location where the directive appears.
-    # _included_fpath_:: Pathname -- Path name of the included file.
+    # _loc_:: Location -- Location where the directive appears.
+    # _fpath_:: Pathname -- Path name of the included file.
     #
     # === RETURN VALUE
     # None.
-    def add_include(location, included_fpath)
-      add_code_struct(Include.new(location, included_fpath))
+    def write_include(loc, fpath)
+      write_code_struct(Include.new(loc, fpath))
     end
-    alias :INCLUDE :add_include
-    module_function :add_include, :INCLUDE
+    alias :INCLUDE :write_include
 
     # === DESCRIPTION
-    # Adds function call information to the report.
+    # Writes a function call information on the report.
     #
     # Abbreviation below is available.
-    #  add_call(...) => CALL(...)
+    #  write_call(...) => CALL(...)
     #
     # === PARAMETER
-    # _location_:: Location -- Location where the function call appears.
-    # _caller_function_:: FunctionIdentifier -- Calling function identifier.
-    # _callee_function_:: FunctionIdentifier -- Called function identifier.
-    def add_call(location, caller_function, callee_function)
-      add_code_struct(Call.new(location, caller_function, callee_function))
+    # _loc_:: Location -- Location where the function call appears.
+    # _caller_fun_:: FunctionId -- Calling function identifier.
+    # _callee_fun_:: FunctionId -- Called function identifier.
+    def write_call(loc, caller_fun, callee_fun)
+      write_code_struct(Call.new(loc, caller_fun, callee_fun))
     end
-    alias :CALL :add_call
-    module_function :add_call, :CALL
+    alias :CALL :write_call
 
     # === DESCRIPTION
-    # Adds variable cross reference information to the report.
+    # Writes a variable cross reference information on the report.
     #
     # Abbreviation below is available.
-    #  add_xref_variable(...) => XREF_VAR(...)
+    #  write_xref_variable(...) => XREF_VAR(...)
     #
     # === PARAMETER
-    # _location_:: Location -- Location where the cross-ref appears.
-    # _accessor_function_:: FunctionIdentifier -- Accessing function
-    #                       identifier.
-    # _access_type_:: String -- Access type string.
-    # _accessee_variable_:: String -- Accessed variable name.
+    # _loc_:: Location -- Location where the cross-ref appears.
+    # _referrer_:: FunctionId -- Accessing function identifier.
+    # _ref_type_:: String -- Access type string.
+    # _var_name_:: String -- Accessed variable name.
     #
     # === RETURN VALUE
     # None.
-    def add_xref_variable(location, accessor_function, access_type,
-                          accessee_variable)
-      add_code_struct(XRefVar.new(location, accessor_function, access_type,
-                                  accessee_variable))
+    def write_xref_variable(loc, referrer, ref_type, var_name)
+      write_code_struct(XRefVar.new(loc, referrer, ref_type, var_name))
     end
-    alias :XREF_VAR :add_xref_variable
-    module_function :add_xref_variable, :XREF_VAR
+    alias :XREF_VAR :write_xref_variable
 
     # === DESCRIPTION
-    # Adds function cross reference information to the report.
+    # Writes a function cross reference information on the report.
     #
     # Abbreviation below is available.
-    #  add_xref_function(...) => XREF_FUNC(...)
+    #  write_xref_function(...) => XREF_FUNC(...)
     #
     # === PARAMETER
-    # _location_:: Location -- Location where the cross-ref appears.
-    # _accessor_function_:: FunctionIdentifier -- Accessing function
-    #                       identifier.
-    # _access_type_:: String -- Access type string.
-    # _accessee_function_:: FunctionIdentifier -- Accessed function identifier.
+    # _loc_:: Location -- Location where the cross-ref appears.
+    # _referrer_:: FunctionId -- Accessing function identifier.
+    # _ref_type_:: String -- Access type string.
+    # _fun_:: FunctionId -- Accessed function identifier.
     #
     # === RETURN VALUE
     # None.
-    def add_xref_function(location, accessor_function, access_type,
-                          accessee_function)
-      add_code_struct(XRefFunc.new(location, accessor_function, access_type,
-                                   accessee_function))
+    def write_xref_function(loc, referrer, ref_type, fun)
+      write_code_struct(XRefFunc.new(loc, referrer, ref_type, fun))
     end
-    alias :XREF_FUNC :add_xref_function
-    module_function :add_xref_function, :XREF_FUNC
+    alias :XREF_FUNC :write_xref_function
 
-    def add_literal(location, literal_type, literal_prefix, literal_suffix,
-                    literal_value)
-      add_code_struct(Literal.new(location, literal_type, literal_prefix,
-                                  literal_suffix, literal_value))
+    def write_literal(loc, lit_type, prefix, suffix, value)
+      write_code_struct(Literal.new(loc, lit_type, prefix, suffix, value))
     end
-    alias :LIT :add_literal
-    module_function :add_literal, :LIT
+    alias :LIT :write_literal
 
-    def add_pp_directive(location, pp_directive, pp_tokens)
-      add_code_struct(PPDirective.new(location, pp_directive, pp_tokens))
+    def write_pp_directive(loc, pp_dire, pp_tokens)
+      write_code_struct(PPDirective.new(loc, pp_dire, pp_tokens))
     end
-    alias :PP_DIRECTIVE :add_pp_directive
-    module_function :add_pp_directive, :PP_DIRECTIVE
+    alias :PP_DIRECTIVE :write_pp_directive
 
-    # === DESCRIPTION
-    # Adds code structure information to the report.
-    #
-    # === PARAMETER
-    # _code_struct_:: CodeStructure -- Code structure information to be added.
-    #
-    # === RETURN VALUE
-    # None.
-    def add_code_struct(code_struct)
-      report.add_code_struct(code_struct)
-      nil
+    def write_FL_STMT(fpath, stmt_cnt)
+      write_code_metric(FL_STMT_Metric.new(fpath, stmt_cnt))
     end
-    module_function :add_code_struct
+    alias :FL_STMT :write_FL_STMT
 
-    def add_FL_STMT(fpath, statement_count)
-      add_code_metric(FL_STMT_Metric.new(fpath, statement_count))
+    def write_FL_FUNC(fpath, fun_cnt)
+      write_code_metric(FL_FUNC_Metric.new(fpath, fun_cnt))
     end
-    alias :FL_STMT :add_FL_STMT
-    module_function :add_FL_STMT, :FL_STMT
+    alias :FL_FUNC :write_FL_FUNC
 
-    def add_FL_FUNC(fpath, function_count)
-      add_code_metric(FL_FUNC_Metric.new(fpath, function_count))
+    def write_FN_STMT(fun_id, loc, stmt_cnt)
+      write_code_metric(FN_STMT_Metric.new(fun_id, loc, stmt_cnt))
     end
-    alias :FL_FUNC :add_FL_FUNC
-    module_function :add_FL_FUNC, :FL_FUNC
+    alias :FN_STMT :write_FN_STMT
 
-    def add_FN_STMT(function_identifier, location, statement_count)
-      add_code_metric(FN_STMT_Metric.new(function_identifier, location,
-                                         statement_count))
+    def write_FN_UNRC(fun_id, loc, unreached_stmt_cnt)
+      write_code_metric(FN_UNRC_Metric.new(fun_id, loc, unreached_stmt_cnt))
     end
-    alias :FN_STMT :add_FN_STMT
-    module_function :add_FN_STMT, :FN_STMT
+    alias :FN_UNRC :write_FN_UNRC
 
-    def add_FN_UNRC(function_identifier, location, unreached_statement_count)
-      add_code_metric(FN_UNRC_Metric.new(function_identifier, location,
-                                         unreached_statement_count))
+    def write_FN_LINE(fun_id, loc, fun_lines)
+      write_code_metric(FN_LINE_Metric.new(fun_id, loc, fun_lines))
     end
-    alias :FN_UNRC :add_FN_UNRC
-    module_function :add_FN_UNRC, :FN_UNRC
+    alias :FN_LINE :write_FN_LINE
 
-    def add_FN_LINE(function_identifier, location, total_lines)
-      add_code_metric(FN_LINE_Metric.new(function_identifier, location,
-                                         total_lines))
+    def write_FN_PARA(fun_id, loc, param_cnt)
+      write_code_metric(FN_PARA_Metric.new(fun_id, loc, param_cnt))
     end
-    alias :FN_LINE :add_FN_LINE
-    module_function :add_FN_LINE, :FN_LINE
+    alias :FN_PARA :write_FN_PARA
 
-    def add_FN_PARA(function_identifier, location, parameter_count)
-      add_code_metric(FN_PARA_Metric.new(function_identifier, location,
-                                         parameter_count))
+    def write_FN_UNUV(fun_id, loc, useless_var_cnt)
+      write_code_metric(FN_UNUV_Metric.new(fun_id, loc, useless_var_cnt))
     end
-    alias :FN_PARA :add_FN_PARA
-    module_function :add_FN_PARA, :FN_PARA
+    alias :FN_UNUV :write_FN_UNUV
 
-    def add_FN_UNUV(function_identifier, location, useless_variable_count)
-      add_code_metric(FN_UNUV_Metric.new(function_identifier, location,
-                                         useless_variable_count))
+    def write_FN_CSUB(fun_id, loc, funcall_cnt)
+      write_code_metric(FN_CSUB_Metric.new(fun_id, loc, funcall_cnt))
     end
-    alias :FN_UNUV :add_FN_UNUV
-    module_function :add_FN_UNUV, :FN_UNUV
+    alias :FN_CSUB :write_FN_CSUB
 
-    def add_FN_CSUB(function_identifier, location, function_call_count)
-      add_code_metric(FN_CSUB_Metric.new(function_identifier, location,
-                                         function_call_count))
+    def write_FN_GOTO(fun_id, loc, goto_cnt)
+      write_code_metric(FN_GOTO_Metric.new(fun_id, loc, goto_cnt))
     end
-    alias :FN_CSUB :add_FN_CSUB
-    module_function :add_FN_CSUB, :FN_CSUB
+    alias :FN_GOTO :write_FN_GOTO
 
-    def add_FN_GOTO(function_identifier, location, goto_count)
-      add_code_metric(FN_GOTO_Metric.new(function_identifier, location,
-                                         goto_count))
+    def write_FN_RETN(fun_id, loc, retn_cnt)
+      write_code_metric(FN_RETN_Metric.new(fun_id, loc, retn_cnt))
     end
-    alias :FN_GOTO :add_FN_GOTO
-    module_function :add_FN_GOTO, :FN_GOTO
+    alias :FN_RETN :write_FN_RETN
 
-    def add_FN_RETN(function_identifier, location, return_count)
-      add_code_metric(FN_RETN_Metric.new(function_identifier, location,
-                                         return_count))
+    def write_FN_UELS(fun_id, loc, if_stmt_cnt)
+      write_code_metric(FN_UELS_Metric.new(fun_id, loc, if_stmt_cnt))
     end
-    alias :FN_RETN :add_FN_RETN
-    module_function :add_FN_RETN, :FN_RETN
+    alias :FN_UELS :write_FN_UELS
 
-    def add_FN_UELS(function_identifier, location, if_statement_count)
-      add_code_metric(FN_UELS_Metric.new(function_identifier, location,
-                                         if_statement_count))
+    def write_FN_NEST(fun_id, loc, max_nest)
+      write_code_metric(FN_NEST_Metric.new(fun_id, loc, max_nest))
     end
-    alias :FN_UELS :add_FN_UELS
-    module_function :add_FN_UELS, :FN_UELS
+    alias :FN_NEST :write_FN_NEST
 
-    def add_FN_NEST(function_identifier, location, max_nest_level)
-      add_code_metric(FN_NEST_Metric.new(function_identifier, location,
-                                         max_nest_level))
+    def write_FN_PATH(fun_id, loc, path_cnt)
+      write_code_metric(FN_PATH_Metric.new(fun_id, loc, path_cnt))
     end
-    alias :FN_NEST :add_FN_NEST
-    module_function :add_FN_NEST, :FN_NEST
+    alias :FN_PATH :write_FN_PATH
 
-    def add_FN_PATH(function_identifier, location, path_count)
-      add_code_metric(FN_PATH_Metric.new(function_identifier, location,
-                                         path_count))
+    def write_FN_CYCM(fun_id, loc, cycl_compl)
+      write_code_metric(FN_CYCM_Metric.new(fun_id, loc, cycl_compl))
     end
-    alias :FN_PATH :add_FN_PATH
-    module_function :add_FN_PATH, :FN_PATH
+    alias :FN_CYCM :write_FN_CYCM
 
-    def add_FN_CYCM(function_identifier, location, cyclomatic_complexity)
-      add_code_metric(FN_CYCM_Metric.new(function_identifier, location,
-                                         cyclomatic_complexity))
+    def write_FN_CALL(fun_sig, loc, caller_cnt)
+      write_code_metric(FN_CALL_Metric.new(fun_sig, loc, caller_cnt))
     end
-    alias :FN_CYCM :add_FN_CYCM
-    module_function :add_FN_CYCM, :FN_CYCM
+    alias :FN_CALL :write_FN_CALL
 
-    def add_FN_CALL(function_signature, location, caller_count)
-      add_code_metric(FN_CALL_Metric.new(function_signature, location,
-                                         caller_count))
+    private
+    def write_code_struct(code_struct)
+      report.write_code_struct(code_struct)
+      nil
     end
-    alias :FN_CALL :add_FN_CALL
-    module_function :add_FN_CALL, :FN_CALL
 
-    def add_code_metric(code_metric)
-      report.add_code_metric(code_metric)
+    def write_code_metric(code_metric)
+      report.write_code_metric(code_metric)
       nil
     end
-    module_function :add_code_metric
   end
 
-  Examination.class_eval { include ReportUtil }
-  CodeCheck.class_eval { extend MessageUniqueness }
-
 end