adlint 2.6.14 → 3.0.0

data/lib/adlint/{c → cc1}/object.rb

@@ -1,7 +1,7 @@
 # C runtime object model.
 #
 # Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
-# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# Copyright:: Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 # License::   GPLv3+: GNU General Public License version 3 or later
 #
 # Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
@@ -11,7 +11,7 @@
 #    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
 #   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
 #  / __  |/ /_/ / /___/ / /|  /  / /
-# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2013, OGIS-RI Co.,Ltd.
 #
 # This file is part of AdLint.
 #
@@ -30,14 +30,14 @@
 #++
 
 require "adlint/util"
-require "adlint/c/syntax"
-require "adlint/c/value"
-require "adlint/c/scope"
-require "adlint/c/seqp"
-require "adlint/c/operator"
+require "adlint/cc1/syntax"
+require "adlint/cc1/value"
+require "adlint/cc1/scope"
+require "adlint/cc1/seqp"
+require "adlint/cc1/operator"
 
 module AdLint #:nodoc:
-module C #:nodoc:
+module Cc1 #:nodoc:
 
   module Bindable
     attr_accessor :binding
@@ -51,10 +51,10 @@ module C #:nodoc:
       end
     end
 
-    def be_alias_to(memory)
-      case memory
+    def be_alias_to(mem)
+      case mem
       when Memory
-        Binding.create_alias(self, memory)
+        Binding.create_alias(self, mem)
       else
         raise TypeError, "an object cannot be an alias to other objects."
       end
@@ -62,22 +62,22 @@ module C #:nodoc:
   end
 
   class Binding
-    def self.bind(object, memory)
-      binding = new(object, memory)
-      object.binding = binding
-      memory.binding = binding
+    def self.bind(obj, mem)
+      binding = new(obj, mem)
+      obj.binding = binding
+      mem.binding = binding
       binding
     end
 
-    def self.create_alias(object, memory)
-      binding = new(object, memory)
-      object.binding = binding
+    def self.create_alias(obj, mem)
+      binding = new(obj, mem)
+      obj.binding = binding
       binding
     end
 
-    def initialize(object, memory)
-      @object = object
-      @memory = memory
+    def initialize(obj, mem)
+      @object = obj
+      @memory = mem
     end
     private_class_method :new
 
@@ -88,36 +88,33 @@ module C #:nodoc:
   class Object
     include Bindable
 
-    def initialize(declaration_or_definition = nil)
-      @declarations_and_definitions = [declaration_or_definition].compact
+    def initialize(dcl_or_def = nil)
+      @declarations_and_definitions = [dcl_or_def].compact
     end
 
     attr_reader :declarations_and_definitions
 
     def storage_class_specifiers
-      @declarations_and_definitions.map { |decl_or_def|
-        decl_or_def.storage_class_specifier
+      @declarations_and_definitions.map { |dcl_or_def|
+        dcl_or_def.storage_class_specifier
       }.compact
     end
 
     def declared_as_extern?
-      first_sc_spec = first_storage_class_specifier
-      first_sc_spec.nil? || first_sc_spec.type == :EXTERN
+      sc_spec = first_storage_class_specifier
+      sc_spec.nil? || sc_spec.type == :EXTERN
     end
 
     def declared_as_static?
-      first_sc_spec = first_storage_class_specifier and
-        first_sc_spec.type == :STATIC
+      sc_spec = first_storage_class_specifier and sc_spec.type == :STATIC
     end
 
     def declared_as_auto?
-      first_sc_spec = first_storage_class_specifier and
-        first_sc_spec.type == :AUTO
+      sc_spec = first_storage_class_specifier and sc_spec.type == :AUTO
     end
 
     def declared_as_register?
-      first_sc_spec = first_storage_class_specifier and
-        first_sc_spec.type == :REGISTER
+      sc_spec = first_storage_class_specifier and sc_spec.type == :REGISTER
     end
 
     def designated_by_lvalue?
@@ -151,8 +148,8 @@ module C #:nodoc:
   end
 
   class TypedObject < Object
-    def initialize(type, declaration_or_definition = nil)
-      super(declaration_or_definition)
+    def initialize(type, dcl_or_def = nil)
+      super(dcl_or_def)
       @type = type
     end
 
@@ -162,19 +159,18 @@ module C #:nodoc:
   # == DESCRIPTION
   # === Variable class hierarchy
   #  Variable
-  #    <--- ScopedVariable
-  #           <--- OuterVariable
-  #                  <--- NamedVariable --------- Nameable <<module>>
-  #                         <--- AliasVariable       |
-  #                  <--- TemporaryVariable          |
-  #                  <--- InnerVariable -------------+
-  #                         <--- ArrayElementVariable
-  #                         <--- CompositeMemberVariable
+  #    <-- ScopedVariable
+  #          <-- OuterVariable
+  #                <-- NamedVariable --------> Nameable <<module>>
+  #                      <-- AliasVariable        ^
+  #                <-- TemporaryVariable          |
+  #                <-- InnerVariable -------------+
+  #                      <-- ArrayElementVariable
+  #                      <-- CompositeMemberVariable
   class Variable < TypedObject
-    def initialize(memory, declaration_or_definition, type)
-      super(type, declaration_or_definition)
-
-      relate_to_memory(memory)
+    def initialize(mem, dcl_or_def, type)
+      super(type, dcl_or_def)
+      relate_to_memory(mem)
     end
 
     def function?
@@ -205,28 +201,28 @@ module C #:nodoc:
       binding.memory.read
     end
 
-    def assign!(value)
+    def assign!(val)
       # NOTE: Length of the incomplete array type should be deducted while
       #       initializer evaluation.  So, adjustment of the assigning value
       #       can be done at this point by Value#coerce_to(type).
       # NOTE: Domain of the assigning value must be narrowed before writing to
       #       the memory by Value#coerce_to(type).
-      binding.memory.write(value.coerce_to(type))
+      binding.memory.write(val.coerce_to(type))
     end
 
     def uninitialize!
       assign!(self.type.undefined_value)
     end
 
-    def narrow_value_domain!(operator, value)
+    def narrow_value_domain!(op, val)
       assign!(type.arbitrary_value) unless self.value
-      self.value.narrow_domain!(operator, value.coerce_to(type))
+      self.value.narrow_domain!(op, val.coerce_to(type))
       self.value.exist?
     end
 
-    def widen_value_domain!(operator, value)
+    def widen_value_domain!(op, val)
       assign!(type.nil_value) unless self.value
-      self.value.widen_domain!(operator, value.coerce_to(type))
+      self.value.widen_domain!(op, val.coerce_to(type))
       self.value.exist?
     end
 
@@ -255,14 +251,14 @@ module C #:nodoc:
     end
 
     private
-    def relate_to_memory(memory)
-      bind_to(memory)
+    def relate_to_memory(mem)
+      bind_to(mem)
     end
   end
 
   class ScopedVariable < Variable
-    def initialize(memory, declaration_or_definition, type, scope)
-      super(memory, declaration_or_definition, type)
+    def initialize(mem, dcl_or_def, type, scope)
+      super(mem, dcl_or_def, type)
       @scope = scope
     end
 
@@ -272,8 +268,7 @@ module C #:nodoc:
       if @scope.global?
         super
       else
-      first_sc_spec = first_storage_class_specifier and
-        first_sc_spec.type == :EXTERN
+      sc_spec = first_storage_class_specifier and sc_spec.type == :EXTERN
       end
     end
 
@@ -281,16 +276,15 @@ module C #:nodoc:
       if @scope.global?
         super
       else
-        first_sc_spec = first_storage_class_specifier
-        first_sc_spec.nil? || first_sc_spec.type == :AUTO
+        sc_spec = first_storage_class_specifier
+        sc_spec.nil? || sc_spec.type == :AUTO
       end
     end
   end
 
   class OuterVariable < ScopedVariable
-    def initialize(memory, declaration_or_definition, type, scope)
-      super(memory, declaration_or_definition, type, scope)
-
+    def initialize(mem, dcl_or_def, type, scope)
+      super(mem, dcl_or_def, type, scope)
       # TODO: If too slow, make an index of inner variables.
       @inner_variables = create_inner_variables(type.unqualify, scope)
     end
@@ -353,12 +347,12 @@ module C #:nodoc:
       false
     end
 
-    def inner_variable_at(index)
+    def inner_variable_at(idx)
       if @type.array?
         # TODO: If linear searching is too slow, use an index of inner
         #       variables.
-        target_name = ArrayElementVariable.component_name_of(index)
-        @inner_variables.find { |iv| iv.component_name == target_name }
+        target_name = ArrayElementVariable.component_name_of(idx)
+        @inner_variables.find { |inner| inner.component_name == target_name }
       else
         nil
       end
@@ -369,7 +363,7 @@ module C #:nodoc:
         # TODO: If linear searching is too slow, use an index of inner
         #       variables.
         target_name = CompositeMemberVariable.component_name_of(name)
-        @inner_variables.find { |iv| iv.component_name == target_name }
+        @inner_variables.find { |inner| inner.component_name == target_name }
       else
         nil
       end
@@ -387,21 +381,21 @@ module C #:nodoc:
       end
     end
 
-    def create_array_elements(type, scope, memory)
+    def create_array_elements(type, scope, mem)
       offset = 0
-      type.impl_length.times.map do |index|
-        window = memory.create_window(offset, type.base_type.aligned_byte_size)
-        offset += window.byte_size
-        ArrayElementVariable.new(window, self, type.base_type, index)
+      type.impl_length.times.map do |idx|
+        win = mem.create_window(offset, type.base_type.aligned_byte_size)
+        offset += win.byte_size
+        ArrayElementVariable.new(win, self, type.base_type, idx)
       end
     end
 
-    def create_composite_members(type, scope, memory)
+    def create_composite_members(type, scope, mem)
       offset = 0
-      type.members.map do |member|
-        window = memory.create_window(offset, member.type.aligned_byte_size)
-        offset += window.byte_size
-        CompositeMemberVariable.new(window, self, member.type, member.name)
+      type.members.map do |memb|
+        win = mem.create_window(offset, memb.type.aligned_byte_size)
+        offset += win.byte_size
+        CompositeMemberVariable.new(win, self, memb.type, memb.name)
       end
     end
   end
@@ -423,11 +417,9 @@ module C #:nodoc:
   class NamedVariable < OuterVariable
     include Nameable
 
-    def initialize(memory, declaration_or_definition, scope)
-      self.name = declaration_or_definition.identifier.value
-
-      super(memory, declaration_or_definition, declaration_or_definition.type,
-            scope)
+    def initialize(mem, dcl_or_def, scope)
+      self.name = dcl_or_def.identifier.value
+      super(mem, dcl_or_def, dcl_or_def.type, scope)
     end
 
     def temporary?
@@ -451,8 +443,8 @@ module C #:nodoc:
   end
 
   class TemporaryVariable < OuterVariable
-    def initialize(memory, type, scope)
-      super(memory, nil, type, scope)
+    def initialize(mem, type, scope)
+      super(mem, nil, type, scope)
     end
 
     def temporary?
@@ -477,12 +469,11 @@ module C #:nodoc:
   class InnerVariable < OuterVariable
     include Nameable
 
-    def initialize(memory, outer_variable, type, component_name)
-      @owner = outer_variable
+    def initialize(mem, outer_var, type, component_name)
+      @owner = outer_var
       @component_name = component_name
-      self.name = create_qualified_name(outer_variable, component_name)
-
-      super(memory, nil, type, outer_variable.scope)
+      self.name = create_qualified_name(outer_var, component_name)
+      super(mem, nil, type, outer_var.scope)
     end
 
     attr_reader :owner
@@ -529,9 +520,9 @@ module C #:nodoc:
     end
 
     private
-    def create_qualified_name(outer_variable, component_name)
-      if outer_variable.named?
-        "#{outer_variable.name}#{component_name}"
+    def create_qualified_name(outer_var, component_name)
+      if outer_var.named?
+        "#{outer_var.name}#{component_name}"
       else
         "__adlint__tempvar#{component_name}"
       end
@@ -539,12 +530,12 @@ module C #:nodoc:
   end
 
   class ArrayElementVariable < InnerVariable
-    def self.component_name_of(index)
-      "[#{index}]"
+    def self.component_name_of(idx)
+      "[#{idx}]"
     end
 
-    def initialize(memory, outer_variable, type, index)
-      super(memory, outer_variable, type, self.class.component_name_of(index))
+    def initialize(mem, outer_var, type, idx)
+      super(mem, outer_var, type, self.class.component_name_of(idx))
     end
   end
 
@@ -553,29 +544,29 @@ module C #:nodoc:
       ".#{name}"
     end
 
-    def initialize(memory, outer_variable, type, name)
-      super(memory, outer_variable, type, self.class.component_name_of(name))
+    def initialize(mem, outer_var, type, name)
+      super(mem, outer_var, type, self.class.component_name_of(name))
     end
   end
 
   class AliasVariable < NamedVariable
-    def initialize(variable)
-      super(variable.binding.memory,
-            variable.declarations_and_definitions.first, variable.scope)
+    def initialize(var)
+      super(var.binding.memory,
+            var.declarations_and_definitions.first, var.scope)
     end
 
     private
-    def relate_to_memory(memory)
-      be_alias_to(memory)
+    def relate_to_memory(mem)
+      be_alias_to(mem)
     end
   end
 
   class VariableTable
-    def initialize(memory_pool)
-      @memory_pool = memory_pool
+    def initialize(mem_pool)
+      @memory_pool     = mem_pool
       @named_variables = [{}]
-      @temporary_variables = [[]]
-      @scope_stack = [GlobalScope.new]
+      @temp_variables  = [[]]
+      @scope_stack     = [GlobalScope.new]
     end
 
     def all_named_variables
@@ -584,69 +575,69 @@ module C #:nodoc:
 
     def enter_scope
       @named_variables.push({})
-      @temporary_variables.push([])
+      @temp_variables.push([])
       @scope_stack.push(Scope.new(@scope_stack.size))
     end
 
     def leave_scope
-      @named_variables.pop.each_value do |variable|
-        @memory_pool.free(variable.binding.memory)
+      @named_variables.pop.each_value do |var|
+        @memory_pool.free(var.binding.memory)
       end
-      @temporary_variables.pop.each do |variable|
-        @memory_pool.free(variable.binding.memory)
+      @temp_variables.pop.each do |var|
+        @memory_pool.free(var.binding.memory)
       end
+
       @scope_stack.pop
       rollback_all_global_variables_value! if current_scope.global?
     end
 
-    def declare(declaration)
-      if variable = lookup(declaration.identifier.value)
-        variable.declarations_and_definitions.push(declaration)
-        return variable
+    def declare(dcl)
+      if var = lookup(dcl.identifier.value)
+        var.declarations_and_definitions.push(dcl)
+        return var
       end
 
       # NOTE: External variable may have undefined values.
-      define_variable(declaration, declaration.type,
-                      allocate_memory(declaration),
-                      declaration.type.undefined_value)
+      define_variable(dcl, dcl.type, allocate_memory(dcl),
+                      dcl.type.undefined_value)
     end
 
-    def define(definition, init_value = nil)
-      if storage_duration_of(definition) == :static
+    def define(dcl_or_def, init_val = nil)
+      if storage_duration_of(dcl_or_def) == :static
         # NOTE: Value of the static duration object should be arbitrary because
         #       execution of its accessors are out of order.
         #       So, a value of the initializer should be ignored.
-        init_value = definition.type.arbitrary_value
+        init_val = dcl_or_def.type.arbitrary_value
       else
-        init_value ||= definition.type.undefined_value
+        init_val ||= dcl_or_def.type.undefined_value
       end
 
-      if variable = lookup(definition.identifier.value)
-        if variable.scope == current_scope
-          variable.declarations_and_definitions.push(definition)
-          variable.assign!(init_value)
-          return variable
+      if var = lookup(dcl_or_def.identifier.value)
+        if var.scope == current_scope
+          var.declarations_and_definitions.push(dcl_or_def)
+          var.assign!(init_val)
+          return var
         end
       end
 
       # NOTE: Domain of the init-value will be restricted by type's min-max in
       #       define_variable.
-      define_variable(definition, definition.type,
-                      allocate_memory(definition), init_value)
+      define_variable(dcl_or_def, dcl_or_def.type,
+                      allocate_memory(dcl_or_def), init_val)
     end
 
-    def define_temporary(type, init_value)
-      memory = @memory_pool.allocate_dynamic(type.aligned_byte_size)
+    def define_temporary(type, init_val)
+      mem = @memory_pool.allocate_dynamic(type.aligned_byte_size)
 
       # NOTE: Domain of the init-value will be restricted by type's min-max in
       #       define_variable.
-      define_variable(nil, type, memory, init_value)
+      define_variable(nil, type, mem, init_val)
     end
 
     def lookup(name_str)
       @named_variables.reverse_each do |hash|
-        if variable = hash[name_str]
-          return variable
+        if var = hash[name_str]
+          return var
         end
       end
       nil
@@ -654,39 +645,37 @@ module C #:nodoc:
 
     def enter_variables_value_versioning_group
       @named_variables.each do |hash|
-        hash.each_value { |variable| variable.enter_value_versioning_group }
+        hash.each_value { |var| var.enter_value_versioning_group }
       end
     end
 
     def leave_variables_value_versioning_group(raise_complement)
       @named_variables.each do |hash|
-        hash.each_value do |variable|
-          variable.leave_value_versioning_group(raise_complement)
+        hash.each_value do |var|
+          var.leave_value_versioning_group(raise_complement)
         end
       end
     end
 
     def begin_variables_value_versioning
       @named_variables.each do |hash|
-        hash.each_value { |variable| variable.begin_value_versioning }
+        hash.each_value { |var| var.begin_value_versioning }
       end
     end
 
     def end_variables_value_versioning
       @named_variables.each do |hash|
-        hash.each_value { |variable| variable.end_value_versioning }
+        hash.each_value { |var| var.end_value_versioning }
       end
     end
 
     def thin_latest_variables_value_version!(with_rollback)
       @named_variables.each do |hash|
-        hash.each_value do |variable|
-          variable.thin_latest_value_version!(with_rollback)
-        end
+        hash.each_value { |var| var.thin_latest_value_version!(with_rollback) }
       end
     end
 
-    def storage_duration_of(declaration_or_definition)
+    def storage_duration_of(dcl_or_def)
       # NOTE: The ISO C99 standard says;
       #
       # 6.2.2 Linkages of identifiers
@@ -734,9 +723,8 @@ module C #:nodoc:
       # 4 An object whose identifier is declared with no linkage and without
       #   the storage-class specifier static has automatic storage duration.
 
-      sc_specifier = declaration_or_definition.storage_class_specifier
-      if sc_specifier &&
-          (sc_specifier.type == :EXTERN || sc_specifier.type == :STATIC)
+      if sc_spec = dcl_or_def.storage_class_specifier and
+          sc_spec.type == :EXTERN || sc_spec.type == :STATIC
         :static
       else
         current_scope.global? ? :static : :automatic
@@ -744,33 +732,33 @@ module C #:nodoc:
     end
 
     private
-    def define_variable(declaration_or_definition, type, memory, init_value)
-      variable = create_variable(declaration_or_definition, type, memory)
-      variable.assign!(init_value)
+    def define_variable(dcl_or_def, type, mem, init_val)
+      var = create_variable(dcl_or_def, type, mem)
+      var.assign!(init_val)
 
-      if variable.named?
-        @named_variables.last[variable.name] = variable
+      if var.named?
+        @named_variables.last[var.name] = var
       else
-        @temporary_variables.last.push(variable)
+        @temp_variables.last.push(var)
       end
 
-      variable
+      var
     end
 
-    def allocate_memory(declaration_or_definition)
-      byte_size = declaration_or_definition.type.aligned_byte_size
-      if storage_duration_of(declaration_or_definition) == :static
+    def allocate_memory(dcl_or_def)
+      byte_size = dcl_or_def.type.aligned_byte_size
+      if storage_duration_of(dcl_or_def) == :static
         @memory_pool.allocate_static(byte_size)
       else
         @memory_pool.allocate_dynamic(byte_size)
       end
     end
 
-    def create_variable(declaration_or_definition, type, memory)
-      if declaration_or_definition
-        NamedVariable.new(memory, declaration_or_definition, current_scope)
+    def create_variable(dcl_or_def, type, mem)
+      if dcl_or_def
+        NamedVariable.new(mem, dcl_or_def, current_scope)
       else
-        TemporaryVariable.new(memory, type, current_scope)
+        TemporaryVariable.new(mem, type, current_scope)
       end
     end
 
@@ -779,8 +767,8 @@ module C #:nodoc:
     end
 
     def rollback_all_global_variables_value!
-      @named_variables.first.each_value do |variable|
-        variable.rollback_all_value_versions!
+      @named_variables.first.each_value do |var|
+        var.rollback_all_value_versions!
       end
     end
   end
@@ -788,14 +776,14 @@ module C #:nodoc:
   # == DESCRIPTION
   # === Function class hierarchy
   #  Function
-  #    <--- NamedFunction --- Nameable <<module>>
-  #           <--- ExplicitFunction
-  #           <--- ImplicitFunction
-  #           <--- BuiltinFunction
-  #    <--- AnonymousFunction
+  #    <-- NamedFunction ------> Nameable <<module>>
+  #          <-- ExplicitFunction
+  #          <-- ImplicitFunction
+  #          <-- BuiltinFunction
+  #    <-- AnonymousFunction
   class Function < TypedObject
-    def initialize(declaration_or_definition, type)
-      super(type, declaration_or_definition)
+    def initialize(dcl_or_def, type)
+      super(type, dcl_or_def)
     end
 
     def name
@@ -830,15 +818,15 @@ module C #:nodoc:
       subclass_responsibility
     end
 
-    def call(interpreter, funcall_expr, args)
-      assign_arguments_to_parameters(interpreter, args)
-      return_values_via_pointer_arguments(interpreter, funcall_expr, args)
+    def call(interp, funcall_expr, args)
+      assign_arguments_to_parameters(interp, args)
+      return_values_via_pointer_arguments(interp, funcall_expr, args)
 
       if type.return_type.function?
-        interpreter.create_tempvar
+        interp.create_tmpvar
       else
-        return_type = type.return_type
-        interpreter.create_tempvar(return_type, return_type.return_value)
+        retn_type = type.return_type
+        interp.create_tmpvar(retn_type, retn_type.return_value)
       end
     end
 
@@ -847,44 +835,44 @@ module C #:nodoc:
     end
 
     private
-    def assign_arguments_to_parameters(interpreter, args)
+    def assign_arguments_to_parameters(interp, args)
       args.zip(type.parameter_types).each do |(arg, expr), param_type|
         if param_type
           case
           when arg.type.array? && param_type.pointer?
-            arg_value = interpreter.pointer_value_of(arg)
-            converted = interpreter.create_tempvar(param_type, arg_value)
+            conved = interp.create_tmpvar(param_type,
+                                          interp.pointer_value_of(arg))
           when arg.type.pointer? && param_type.array?
-            converted = interpreter.pointee_of(arg)
+            conved = interp.pointee_of(arg)
           when arg.type.function? && param_type.pointer?
-            arg_value = interpreter.pointer_value_of(arg)
-            converted = interpreter.create_tempvar(param_type, arg_value)
+            conved = interp.create_tmpvar(param_type,
+                                          interp.pointer_value_of(arg))
           when arg.variable? && !arg.type.same_as?(param_type)
-            converted = interpreter.do_conversion(arg, param_type) ||
-                        interpreter.create_tempvar(param_type)
+            conved = interp.do_conversion(arg, param_type) ||
+                     interp.create_tmpvar(param_type)
           else
-            converted = arg
+            conved = arg
           end
         else
-          converted = interpreter.do_default_argument_promotion(arg)
+          conved = interp.do_default_argument_promotion(arg)
         end
 
         # NOTE: Value of the argument is referred when the assignment to the
         #       parameter is performed.
         if arg.variable? && !arg.type.array?
-          interpreter.notify_variable_value_referred(expr, arg)
+          interp.notify_variable_value_referred(expr, arg)
         end
 
-        if converted && arg != converted
-          interpreter.notify_implicit_conv_performed(expr, arg, converted)
+        if conved && arg != conved
+          interp.notify_implicit_conv_performed(expr, arg, conved)
         end
       end
     end
 
-    def return_values_via_pointer_arguments(interpreter, funcall_expr, args)
+    def return_values_via_pointer_arguments(interp, funcall_expr, args)
       args.zip(type.parameter_types).each do |(arg, expr), param_type|
         next if param_type && param_type.void?
-        next unless arg.variable? && (arg.type.pointer? || arg.type.array?)
+        next unless arg.variable? and arg.type.pointer? || arg.type.array?
 
         param_type = param_type.unqualify if param_type
 
@@ -898,7 +886,7 @@ module C #:nodoc:
 
         case
         when arg.type.pointer?
-          pointee = interpreter.pointee_of(arg)
+          pointee = interp.pointee_of(arg)
           if pointee && pointee.designated_by_lvalue? && pointee.variable?
             sink = pointee
           else
@@ -909,14 +897,14 @@ module C #:nodoc:
         end
 
         sink.assign!(sink.type.return_value)
-        interpreter.notify_variable_value_updated(expr, sink)
+        interp.notify_variable_value_updated(expr, sink)
 
         # NOTE: Returning a value via a pointer parameter can be considered as
         #       an evaluation of a statement-expression with a
         #       simple-assignment-expression.
         #       Control will reach to a sequence-point at the end of a full
         #       expression.
-        interpreter.notify_sequence_point_reached(
+        interp.notify_sequence_point_reached(
           SequencePoint.new(funcall_expr, false))
       end
     end
@@ -925,9 +913,8 @@ module C #:nodoc:
   class NamedFunction < Function
     include Nameable
 
-    def initialize(declaration_or_definition, type, name)
-      super(declaration_or_definition, type)
-
+    def initialize(dcl_or_def, type, name)
+      super(dcl_or_def, type)
       self.name = name
     end
 
@@ -935,7 +922,7 @@ module C #:nodoc:
       true
     end
 
-    def call(interpreter, funcall_expr, args)
+    def call(*)
       case name
       when "exit", "_exit", "abort"
         BreakEvent.of_return.throw
@@ -952,9 +939,8 @@ module C #:nodoc:
   end
 
   class ExplicitFunction < NamedFunction
-    def initialize(declaration_or_definition)
-      super(declaration_or_definition, declaration_or_definition.type,
-            declaration_or_definition.identifier.value)
+    def initialize(dcl_or_def)
+      super(dcl_or_def, dcl_or_def.type, dcl_or_def.identifier.value)
     end
 
     def explicit?
@@ -998,14 +984,14 @@ module C #:nodoc:
     end
 
     def signature
-      FunctionSignature.new("__adlint__anonymous_func", type)
+      FunctionSignature.new("__adlint__anon_func", type)
     end
   end
 
   class FunctionTable
-    def initialize(memory_pool)
-      @memory_pool = memory_pool
-      @functions = [{}]
+    def initialize(mem_pool)
+      @memory_pool = mem_pool
+      @functions   = [{}]
       @scope_stack = [GlobalScope.new]
     end
 
@@ -1015,34 +1001,46 @@ module C #:nodoc:
     end
 
     def leave_scope
-      @functions.pop.each_value do |function|
-        @memory_pool.free(function.binding.memory)
+      @functions.pop.each_value do |fun|
+        @memory_pool.free(fun.binding.memory)
       end
       @scope_stack.pop
     end
 
-    def declare(declaration)
-      if function = lookup(declaration.identifier.value)
-        function.declarations_and_definitions.push(declaration)
-        return function
+    def declare_explicitly(dcl)
+      if fun = lookup(dcl.identifier.value) and fun.explicit?
+        fun.declarations_and_definitions.push(dcl)
+        return fun
       end
 
-      define(ExplicitFunction.new(declaration))
+      define(ExplicitFunction.new(dcl))
     end
 
-    def define(function)
+    def declare_implicitly(fun)
+      if fun.named? && fun.implicit?
+        define(fun, true)
+      end
+      fun
+    end
+
+    def define(fun, in_global_scope = false)
       # NOTE: A function has a starting address in the TEXT segment.
       #       This is ad-hoc implementation, but it's enough for analysis.
-      function.bind_to(@memory_pool.allocate_static(0))
+      fun.bind_to(@memory_pool.allocate_static(0))
 
-      @functions.last[function.name] = function if function.named?
-      function
+      if in_global_scope
+        @functions.first[fun.name] = fun
+      else
+        @functions.last[fun.name] = fun if fun.named?
+      end
+
+      fun
     end
 
     def lookup(name_str)
       @functions.reverse_each do |hash|
-        if function = hash[name_str]
-          return function
+        if fun = hash[name_str]
+          return fun
         end
       end
       nil
@@ -1052,10 +1050,10 @@ module C #:nodoc:
   class Memory
     include Bindable
 
-    def initialize(address, byte_size)
-      @address = address
+    def initialize(addr, byte_size)
+      @address   = addr
       @byte_size = byte_size
-      @value = nil
+      @value     = nil
     end
 
     attr_reader :address
@@ -1073,39 +1071,38 @@ module C #:nodoc:
       @value
     end
 
-    def write(value)
+    def write(val)
       if @value
-        @value.overwrite!(value)
+        @value.overwrite!(val)
       else
-        @value = VersionedValue.new(value)
+        @value = VersionedValue.new(val)
       end
     end
   end
 
   class MemoryBlock < Memory
-    def initialize(address, byte_size)
+    def initialize(addr, byte_size)
       super
-
       @windows = []
     end
 
     attr_reader :windows
 
     def create_window(offset, byte_size)
-      window = MemoryWindow.new(self, @address + offset, byte_size)
-      window.on_written += method(:handle_written_through_window)
-      @windows.push(window)
-      window
+      win = MemoryWindow.new(self, @address + offset, byte_size)
+      win.on_written += method(:handle_written_through_window)
+      @windows.push(win)
+      win
     end
 
-    def write(value)
+    def write(val)
       super
       if !@windows.empty? and
-          @value.array? && value.array? or
-          @value.composite? && value.composite?
-        single_value = value.to_single_value
-        @windows.zip(single_value.values).each do |window, inner_value|
-          window.write(inner_value, false)
+          @value.array? && val.array? or
+          @value.composite? && val.composite?
+        single_val = val.to_single_value
+        @windows.zip(single_val.values).each do |win, inner_val|
+          win.write(inner_val, false)
         end
       end
     end
@@ -1123,20 +1120,20 @@ module C #:nodoc:
     end
 
     private
-    def handle_written_through_window(window)
-      value = create_value_from_windows
+    def handle_written_through_window(*)
+      val = create_value_from_windows
 
       if @value
-        @value.overwrite!(value)
+        @value.overwrite!(val)
       else
-        @value = VersionedValue.new(value)
+        @value = VersionedValue.new(val)
       end
     end
   end
 
   class MemoryWindow < MemoryBlock
-    def initialize(owner, address, byte_size)
-      super(address, byte_size)
+    def initialize(owner, addr, byte_size)
+      super(addr, byte_size)
       @owner = owner
     end
 
@@ -1152,13 +1149,13 @@ module C #:nodoc:
       @owner.dynamic?
     end
 
-    def write(value, cascade = true)
-      super(value)
+    def write(val, cascade = true)
+      super(val)
       on_written.invoke(self) if cascade
     end
 
     private
-    def handle_written_through_window(window)
+    def handle_written_through_window(*)
       super
       on_written.invoke(self)
     end
@@ -1186,40 +1183,40 @@ module C #:nodoc:
 
   class MemoryPool
     def initialize
-      @memory_blocks = {}
+      @memory_blocks  = {}
       @address_ranges = []
       # NOTE: To make room for NULL and controlling expressions.
       @free_address = 10
     end
 
     def allocate_static(byte_size)
-      memory_block = StaticMemoryBlock.new(@free_address, byte_size)
+      mem_block = StaticMemoryBlock.new(@free_address, byte_size)
       @free_address += allocating_byte_size(byte_size)
-      @memory_blocks[memory_block.address] = memory_block
-      @address_ranges.push(memory_block.address...@free_address)
-      memory_block
+      @memory_blocks[mem_block.address] = mem_block
+      @address_ranges.push(mem_block.address...@free_address)
+      mem_block
     end
 
     def allocate_dynamic(byte_size)
-      memory_block = DynamicMemoryBlock.new(@free_address, byte_size)
+      mem_block = DynamicMemoryBlock.new(@free_address, byte_size)
       @free_address += allocating_byte_size(byte_size)
-      @memory_blocks[memory_block.address] = memory_block
-      @address_ranges.push(memory_block.address...@free_address)
-      memory_block
+      @memory_blocks[mem_block.address] = mem_block
+      @address_ranges.push(mem_block.address...@free_address)
+      mem_block
     end
 
-    def free(memory_block)
-      @memory_blocks.delete(memory_block.address)
-      @address_ranges.reject! { |range| range.include?(memory_block.address) }
+    def free(mem_block)
+      @memory_blocks.delete(mem_block.address)
+      @address_ranges.reject! { |range| range.include?(mem_block.address) }
     end
 
-    def lookup(address)
-      if memory_block = @memory_blocks[address]
-        return memory_block
+    def lookup(addr)
+      if mem_block = @memory_blocks[addr]
+        return mem_block
       else
-        if addr_range = @address_ranges.find { |r| r.include?(address) }
-          memory_block = @memory_blocks[addr_range.first]
-          return memory_block.windows.find { |w| w.address == address }
+        if addr_range = @address_ranges.find { |r| r.include?(addr) }
+          mem_block = @memory_blocks[addr_range.first]
+          return mem_block.windows.find { |w| w.address == addr }
         end
       end
       nil