adlint 2.6.14 → 3.0.0

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

@@ -1,7 +1,7 @@
 # C Enumerators.
 #
 # 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,7 +30,7 @@
 #++
 
 module AdLint #:nodoc:
-module C #:nodoc:
+module Cc1 #:nodoc:
 
   class EnumeratorTable
     def initialize

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

@@ -1,7 +1,7 @@
 # C runtime environment.
 #
 # 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,14 +29,14 @@
 #
 #++
 
-require "adlint/c/enum"
-require "adlint/c/object"
-require "adlint/c/builtin"
-require "adlint/c/branch"
-require "adlint/c/mediator"
+require "adlint/cc1/enum"
+require "adlint/cc1/object"
+require "adlint/cc1/builtin"
+require "adlint/cc1/branch"
+require "adlint/cc1/mediator"
 
 module AdLint #:nodoc:
-module C #:nodoc:
+module Cc1 #:nodoc:
 
   class Environment
     include TypeTableMediator
@@ -45,11 +45,11 @@ module C #:nodoc:
     include FunctionTableMediator
     include EnumeratorTableMediator
 
-    def initialize(type_table)
-      @type_table = type_table
-      @memory_pool = MemoryPool.new
-      @variable_table = VariableTable.new(@memory_pool)
-      @function_table = FunctionTable.new(@memory_pool)
+    def initialize(type_tbl)
+      @type_table       = type_tbl
+      @memory_pool      = MemoryPool.new
+      @variable_table   = VariableTable.new(@memory_pool)
+      @function_table   = FunctionTable.new(@memory_pool)
       @enumerator_table = EnumeratorTable.new
       install_builtin_functions
       reset
@@ -64,7 +64,7 @@ module C #:nodoc:
 
     def reset
       @current_scope = GlobalScope.new
-      @branch_depth = 0
+      @branch_depth  = 0
       @branch_groups = {}
     end
 
@@ -80,8 +80,8 @@ module C #:nodoc:
       @function_table.leave_scope
     end
 
-    def enter_branch_group(*options)
-      @branch_groups[@branch_depth] = BranchGroup.new(self, *options)
+    def enter_branch_group(*opts)
+      @branch_groups[@branch_depth] = BranchGroup.new(self, *opts)
     end
 
     def current_branch_group
@@ -92,15 +92,15 @@ module C #:nodoc:
       @branch_groups.delete(@branch_depth)
     end
 
-    def enter_branch(*options)
+    def enter_branch(*opts)
       @branch_depth += 1
 
       if group = current_branch_group
-        group.add_options(*options)
-        group.create_trailing_branch(*options)
+        group.add_options(*opts)
+        group.create_trailing_branch(*opts)
       else
-        group = enter_branch_group(*options)
-        group.create_first_branch(*options)
+        group = enter_branch_group(*opts)
+        group.create_first_branch(*opts)
       end
     end
 

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

@@ -1,7 +1,7 @@
 # C expression evaluator.
 #
 # 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,13 +29,13 @@
 #
 #++
 
-require "adlint/c/mediator"
-require "adlint/c/const"
-require "adlint/c/conv"
-require "adlint/c/seqp"
+require "adlint/cc1/mediator"
+require "adlint/cc1/const"
+require "adlint/cc1/conv"
+require "adlint/cc1/seqp"
 
 module AdLint #:nodoc:
-module C #:nodoc:
+module Cc1 #:nodoc:
 
   module ExpressionEvaluator
     # NOTE: Host class of this module must include InterpreterMediator and
@@ -47,7 +47,7 @@ module C #:nodoc:
 
     def visit_error_expression(node)
       checkpoint(node.location)
-      create_tempvar
+      create_tmpvar
     end
 
     def visit_object_specifier(node)
@@ -62,7 +62,7 @@ module C #:nodoc:
         notify_constant_referred(node, const_var)
         const_var
       else
-        create_tempvar
+        create_tmpvar
       end
     end
 
@@ -71,13 +71,13 @@ module C #:nodoc:
 
       case node.literal.value
       when /\A"(.*)"\z/
-        create_tempvar(array_type(char_type, $1.length + 1),
-                       create_array_value_of_string($1))
+        create_tmpvar(array_type(char_t, $1.length + 1),
+                      create_array_value_of_string($1))
       when /\AL"(.*)"\z/i
-        create_tempvar(array_type(wchar_type, $1.length + 1),
-                       create_array_value_of_string($1))
+        create_tmpvar(array_type(wchar_t, $1.length + 1),
+                      create_array_value_of_string($1))
       else
-        create_tempvar(array_type(char_type))
+        create_tmpvar(array_type(char_t))
       end
     end
 
@@ -85,7 +85,7 @@ module C #:nodoc:
       checkpoint(node.location)
       # TODO: NULL may not be 0 on some environments.
       #       Representation of NULL should be configurable?
-      create_tempvar(pointer_type(void_type), ScalarValue.of(0))
+      create_tmpvar(pointer_type(void_t), scalar_value_of(0))
     end
 
     def visit_grouped_expression(node)
@@ -118,13 +118,13 @@ module C #:nodoc:
     def visit_bit_access_by_value_expression(node)
       checkpoint(node.location)
       # TODO: Should support the GCC extension.
-      create_tempvar
+      create_tmpvar
     end
 
     def visit_bit_access_by_pointer_expression(node)
       checkpoint(node.location)
       # TODO: Should support the GCC extension.
-      create_tempvar
+      create_tmpvar
     end
 
     def visit_postfix_increment_expression(node)
@@ -140,7 +140,7 @@ module C #:nodoc:
     def visit_compound_literal_expression(node)
       checkpoint(node.location)
       # TODO: Should support C99 features.
-      create_tempvar(node.type_name.type)
+      create_tmpvar(node.type_name.type)
     end
 
     def visit_prefix_increment_expression(node)
@@ -171,48 +171,48 @@ module C #:nodoc:
     def visit_sizeof_expression(node)
       checkpoint(node.location)
 
-      operand_obj = result_var = nil
+      ope_obj = res_var = nil
       eval_without_side_effect do
-        result_type = type_of(UserTypeId.new("size_t")) || unsigned_long_type
-        operand_obj = node.operand.accept(self)
-        if operand_obj.variable?
-          size = operand_obj.type.aligned_byte_size
-          result_var = create_tempvar(result_type, ScalarValue.of(size))
+        res_type = type_of(UserTypeId.new("size_t")) || unsigned_long_t
+        ope_obj = node.operand.accept(self)
+        if ope_obj.variable?
+          size = ope_obj.type.aligned_byte_size
+          res_var = create_tmpvar(res_type, scalar_value_of(size))
         else
-          return create_tempvar(result_type)
+          return create_tmpvar(res_type)
         end
       end
 
-      notify_sizeof_expr_evaled(node, operand_obj, result_var)
-      result_var
+      notify_sizeof_expr_evaled(node, ope_obj, res_var)
+      res_var
     end
 
     def visit_sizeof_type_expression(node)
       checkpoint(node.location)
       resolve_unresolved_type(node.operand)
 
-      result_var = nil
+      res_var = nil
       eval_without_side_effect do
-        result_type = type_of(UserTypeId.new("size_t")) || unsigned_long_type
+        res_type = type_of(UserTypeId.new("size_t")) || unsigned_long_t
         size = node.operand.type.aligned_byte_size
-        result_var = create_tempvar(result_type, ScalarValue.of(size))
+        res_var = create_tmpvar(res_type, scalar_value_of(size))
       end
 
-      notify_sizeof_type_expr_evaled(node, node.operand.type, result_var)
-      result_var
+      notify_sizeof_type_expr_evaled(node, node.operand.type, res_var)
+      res_var
     end
 
     def visit_alignof_expression(node)
       checkpoint(node.location)
 
       eval_without_side_effect do
-        result_type = type_of(UserTypeId.new("size_t")) || unsigned_long_type
-        operand_obj = node.operand.accept(self)
-        if operand_obj.variable?
-          align = operand_obj.type.byte_alignment
-          create_tempvar(result_type, ScalarValue.of(align))
+        res_type = type_of(UserTypeId.new("size_t")) || unsigned_long_t
+        ope_obj = node.operand.accept(self)
+        if ope_obj.variable?
+          align = ope_obj.type.byte_alignment
+          create_tmpvar(res_type, scalar_value_of(align))
         else
-          create_tempvar(result_type)
+          create_tmpvar(res_type)
         end
       end
     end
@@ -222,9 +222,9 @@ module C #:nodoc:
       resolve_unresolved_type(node.operand)
 
       eval_without_side_effect do
-        result_type = type_of(UserTypeId.new("size_t")) || unsigned_long_type
+        res_type = type_of(UserTypeId.new("size_t")) || unsigned_long_t
         align = node.operand.type.aligned_byte_size
-        create_tempvar(result_type, ScalarValue.of(align))
+        create_tmpvar(res_type, scalar_value_of(align))
       end
     end
 
@@ -288,7 +288,7 @@ module C #:nodoc:
       if lhs_obj.variable?
         lhs_var = lhs_obj
       else
-        return create_tempvar(int_type)
+        return create_tmpvar(int_t)
       end
 
       # NOTE: The ISO C99 standard says;
@@ -307,14 +307,14 @@ module C #:nodoc:
       if lhs_val.scalar? && lhs_val.must_be_false?
         # NOTE: Doing the short-circuit evaluation.
         notify_variable_value_referred(node, lhs_var)
-        return create_tempvar(int_type, ScalarValue.of_false)
+        return create_tmpvar(int_t, scalar_value_of_false)
       end
 
       rhs_obj = node.rhs_operand.accept(self)
       if rhs_obj.variable?
         rhs_var = rhs_obj
       else
-        return create_tempvar(int_type)
+        return create_tmpvar(int_t)
       end
 
       notify_sequence_point_reached(SequencePoint.new(node.rhs_operand))
@@ -322,15 +322,15 @@ module C #:nodoc:
 
       if lhs_val.scalar? && rhs_val.scalar?
         # NOTE: No usual-arithmetic-conversion.
-        result_var = create_tempvar(int_type, lhs_val.logical_and(rhs_val))
+        res_var = create_tmpvar(int_t, lhs_val.logical_and(rhs_val))
       else
-        result_var = create_tempvar(int_type)
+        res_var = create_tmpvar(int_t)
       end
       notify_variable_value_referred(node, lhs_var)
       notify_variable_value_referred(node, rhs_var)
 
-      notify_logical_and_expr_evaled(node, lhs_var, rhs_var, result_var)
-      result_var
+      notify_logical_and_expr_evaled(node, lhs_var, rhs_var, res_var)
+      res_var
     end
 
     def visit_logical_or_expression(node)
@@ -340,7 +340,7 @@ module C #:nodoc:
       if lhs_obj.variable?
         lhs_var = lhs_obj
       else
-        return create_tempvar(int_type)
+        return create_tmpvar(int_t)
       end
 
       # NOTE: The ISO C99 standard says;
@@ -359,14 +359,14 @@ module C #:nodoc:
       if lhs_val.scalar? && lhs_val.must_be_true?
         # NOTE: Doing the short-circuit evaluation.
         notify_variable_value_referred(node, lhs_var)
-        return create_tempvar(int_type, ScalarValue.of_true)
+        return create_tmpvar(int_t, scalar_value_of_true)
       end
 
       rhs_obj = node.rhs_operand.accept(self)
       if rhs_obj.variable?
         rhs_var = rhs_obj
       else
-        return create_tempvar(int_type)
+        return create_tmpvar(int_t)
       end
 
       notify_sequence_point_reached(SequencePoint.new(node.rhs_operand))
@@ -374,15 +374,15 @@ module C #:nodoc:
 
       if lhs_val.scalar? && rhs_val.scalar?
         # NOTE: No usual-arithmetic-conversion.
-        result_var = create_tempvar(int_type, lhs_val.logical_or(rhs_val))
+        res_var = create_tmpvar(int_t, lhs_val.logical_or(rhs_val))
       else
-        result_var = create_tempvar(int_type)
+        res_var = create_tmpvar(int_t)
       end
       notify_variable_value_referred(node, lhs_var)
       notify_variable_value_referred(node, rhs_var)
 
-      notify_logical_or_expr_evaled(node, lhs_var, rhs_var, result_var)
-      result_var
+      notify_logical_or_expr_evaled(node, lhs_var, rhs_var, res_var)
+      res_var
     end
 
     def visit_simple_assignment_expression(node)
@@ -421,8 +421,8 @@ module C #:nodoc:
     end
 
     def create_array_value_of_string(str)
-      ArrayValue.new(str.chars.map { |ch| ScalarValue.of(ch.ord) } +
-                     [ScalarValue.of("\0".ord)])
+      ArrayValue.new(str.chars.map { |ch| scalar_value_of(ch.ord) } +
+                     [scalar_value_of("\0".ord)])
     end
 
     module Impl
@@ -441,38 +441,40 @@ module C #:nodoc:
           return var
         end
 
-        if func = function_named(node.identifier.value)
-          func.declarations_and_definitions.each do |dcl_or_def|
+        if fun = function_named(node.identifier.value)
+          fun.declarations_and_definitions.each do |dcl_or_def|
             dcl_or_def.mark_as_referred_by(node.identifier)
           end
-          _notify_object_referred(node, func)
-          return func
+          _notify_object_referred(node, fun)
+          return fun
         end
 
         if enum = enumerator_named(node.identifier.value)
           enum.mark_as_referred_by(node.identifier)
-          return create_tempvar(enum.type, ScalarValue.of(enum.value))
+          return create_tmpvar(enum.type, scalar_value_of(enum.value))
         end
 
-        define_implicit_function(node.identifier.value)
+        fun = declare_implicit_function(node.identifier.value)
+        _notify_implicit_function_declared(node, fun)
+        _notify_object_referred(node, fun)
+        fun
       end
 
       def eval_array_subscript_expr(node, obj, subs)
         unless obj.variable? && (obj.type.array? || obj.type.pointer?)
-          return create_tempvar
+          return create_tmpvar
         end
 
-        ary_or_ptr = obj
-        result_type = ary_or_ptr.type.unqualify.base_type
+        res_type = obj.type.unqualify.base_type
 
         case
-        when ary_or_ptr.type.array?
-          ary = ary_or_ptr
+        when obj.type.array?
+          ary = obj
           # NOTE: An array-subscript-expression with an array object only
           #       refers the array object, never refer the value of the array
           #       object.
-        when ary_or_ptr.type.pointer?
-          ptr = ary_or_ptr
+        when obj.type.pointer?
+          ptr = obj
           if pointee = pointee_of(ptr) and pointee.type.array?
             ary = pointee
           end
@@ -484,18 +486,18 @@ module C #:nodoc:
         unless subs.variable? and
             subs.value.scalar? && subs.value.exist? or subs.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar(result_type)
+          return create_tmpvar(res_type)
         end
         _notify_variable_value_referred(node, subs)
 
         # NOTE: An array subscript converted to `int' implicitly.
-        unless subs.type.same_as?(int_type)
-          if int_subs = do_conversion(subs, int_type)
+        unless subs.type.same_as?(int_t)
+          if int_subs = do_conversion(subs, int_t)
             notify_implicit_conv_performed(node.array_subscript,
                                            subs, int_subs)
             subs = int_subs
           else
-            return create_tempvar(result_type)
+            return create_tmpvar(res_type)
           end
         end
 
@@ -503,28 +505,27 @@ module C #:nodoc:
         subs_val = subs.value.unique_sample
         if ary and inner_var = ary.inner_variable_at(subs_val)
           _notify_object_referred(node, inner_var)
-          if inner_var.type.same_as?(result_type)
-            result_var = inner_var
+          if inner_var.type.same_as?(res_type)
+            res_var = inner_var
           end
         end
-        result_var ||= create_tempvar(result_type)
+        res_var ||= create_tmpvar(res_type)
 
-        notify_array_subscript_expr_evaled(node, ary_or_ptr, subs, ary,
-                                           result_var)
-        result_var
+        notify_array_subscript_expr_evaled(node, obj, subs, ary, res_var)
+        res_var
       end
 
       def eval_function_call_expr(node, obj, args)
         if obj.function?
-          func = obj
+          fun = obj
         else
-          return create_tempvar unless obj.type.pointer?
+          return create_tmpvar unless obj.type.pointer?
           obj_base_type = obj.type.unqualify.base_type
           if obj_base_type.function?
             if pointee = pointee_of(obj) and pointee.function?
-              func = pointee
+              fun = pointee
             else
-              func = define_anonymous_function(obj_base_type)
+              fun = define_anonymous_function(obj_base_type)
             end
           end
         end
@@ -543,20 +544,28 @@ module C #:nodoc:
           notify_sequence_point_reached(SequencePoint.new(node))
         end
 
-        result_var = func.call(interpreter, node, args)
-        unless func.builtin?
+        res_var = nil
+        break_event = BreakEvent.catch {
+          res_var = fun.call(interpreter, node, args)
+        }
+
+        unless fun.builtin?
           arg_vars = args.map { |arg_obj, *| object_to_variable(arg_obj) }
-          notify_function_call_expr_evaled(node, func, arg_vars, result_var)
+          notify_function_call_expr_evaled(node, fun, arg_vars, res_var)
         end
 
-        result_var
+        if break_event
+          break_event.throw
+        else
+          res_var
+        end
       end
 
       def eval_member_access_by_value_expr(node, obj)
         if obj.variable? && obj.type.composite?
           outer_var = obj
         else
-          return create_tempvar
+          return create_tmpvar
         end
 
         memb_var = outer_var.inner_variable_named(node.identifier.value)
@@ -571,7 +580,7 @@ module C #:nodoc:
           _notify_object_referred(node, memb_var)
           memb_var
         else
-          create_tempvar
+          create_tmpvar
         end
       end
 
@@ -580,7 +589,7 @@ module C #:nodoc:
         if obj.variable? && obj_type.pointer? && obj_type.base_type.composite?
           ptr = obj
         else
-          return create_tempvar
+          return create_tmpvar
         end
 
         if pointee = pointee_of(ptr)
@@ -588,7 +597,7 @@ module C #:nodoc:
             if first_elem = pointee.inner_variable_at(0)
               pointee = first_elem
             else
-              pointee = create_tempvar(obj_type.base_type)
+              pointee = create_tmpvar(obj_type.base_type)
             end
           end
         end
@@ -601,7 +610,7 @@ module C #:nodoc:
           memb_var = outer_var.inner_variable_named(node.identifier.value)
         else
           if memb = obj_type.base_type.member_named(node.identifier.value)
-            memb_var = create_tempvar(memb.type)
+            memb_var = create_tmpvar(memb.type)
           end
         end
 
@@ -613,7 +622,7 @@ module C #:nodoc:
           _notify_object_referred(node, memb_var)
           memb_var
         else
-          create_tempvar
+          create_tmpvar
         end
       end
 
@@ -621,10 +630,10 @@ module C #:nodoc:
         if obj.variable? && obj.type.scalar?
           var = obj
         else
-          return create_tempvar
+          return create_tmpvar
         end
 
-        result_var = create_tempvar(var.type, var.value.dup)
+        res_var = create_tmpvar(var.type, var.value.dup)
 
         # NOTE: Value of the variable is referred at this point.  But value
         #       reference should not be notified not to confuse sequence-point
@@ -632,22 +641,22 @@ module C #:nodoc:
         # _notify_variable_value_referred(node, var)
 
         if var.value.scalar?
-          var.assign!(var.value + ScalarValue.of(1))
+          var.assign!(var.value + scalar_value_of(1))
           _notify_variable_value_updated(node, var)
         end
 
-        notify_postfix_increment_expr_evaled(node, var, result_var)
-        result_var
+        notify_postfix_increment_expr_evaled(node, var, res_var)
+        res_var
       end
 
       def eval_postfix_decrement_expr(node, obj)
         if obj.variable? && obj.type.scalar?
           var = obj
         else
-          return create_tempvar
+          return create_tmpvar
         end
 
-        result_var = create_tempvar(var.type, var.value.dup)
+        res_var = create_tmpvar(var.type, var.value.dup)
 
         # NOTE: Value of the variable is referred at this point.  But value
         #       reference should not be notified not to confuse sequence-point
@@ -655,22 +664,22 @@ module C #:nodoc:
         # _notify_variable_value_referred(node, var)
 
         if var.value.scalar?
-          var.assign!(var.value - ScalarValue.of(1))
+          var.assign!(var.value - scalar_value_of(1))
           _notify_variable_value_updated(node, var)
         end
 
-        notify_postfix_decrement_expr_evaled(node, var, result_var)
-        result_var
+        notify_postfix_decrement_expr_evaled(node, var, res_var)
+        res_var
       end
 
       def eval_prefix_increment_expr(node, obj)
         if obj.variable? && obj.type.scalar?
           var = obj
         else
-          return create_tempvar
+          return create_tmpvar
         end
 
-        orig_val = var.value.dup
+        org_val = var.value.dup
 
         # NOTE: Value of the variable is referred at this point.  But value
         #       reference should not be notified not to confuse sequence-point
@@ -678,22 +687,22 @@ module C #:nodoc:
         # _notify_variable_value_referred(node, var)
 
         if var.value.scalar?
-          var.assign!(var.value + ScalarValue.of(1))
+          var.assign!(var.value + scalar_value_of(1))
           _notify_variable_value_updated(node, var)
         end
 
-        notify_prefix_increment_expr_evaled(node, var, orig_val)
-        create_tempvar(var.type, var.value)
+        notify_prefix_increment_expr_evaled(node, var, org_val)
+        create_tmpvar(var.type, var.value)
       end
 
       def eval_prefix_decrement_expr(node, obj)
         if obj.variable? && obj.type.scalar?
           var = obj
         else
-          return create_tempvar
+          return create_tmpvar
         end
 
-        orig_val = var.value.dup
+        org_val = var.value.dup
 
         # NOTE: Value of the variable is referred at this point.  But value
         #       reference should not be notified not to confuse sequence-point
@@ -701,12 +710,12 @@ module C #:nodoc:
         # _notify_variable_value_referred(node, var)
 
         if var.value.scalar?
-          var.assign!(var.value - ScalarValue.of(1))
+          var.assign!(var.value - scalar_value_of(1))
           _notify_variable_value_updated(node, var)
         end
 
-        notify_prefix_decrement_expr_evaled(node, var, orig_val)
-        create_tempvar(var.type, var.value)
+        notify_prefix_decrement_expr_evaled(node, var, org_val)
+        create_tmpvar(var.type, var.value)
       end
 
       def eval_address_expr(node, obj)
@@ -715,7 +724,7 @@ module C #:nodoc:
         #       variable cross-references.
         _notify_variable_value_referred(node, obj)
 
-        ptr = create_tempvar(pointer_type(obj.type), pointer_value_of(obj))
+        ptr = create_tmpvar(pointer_type(obj.type), pointer_value_of(obj))
         notify_address_expr_evaled(node, obj, ptr)
         ptr
       end
@@ -724,7 +733,7 @@ module C #:nodoc:
         if obj.variable? && obj.type.pointer?
           ptr = obj
         else
-          return create_tempvar
+          return create_tmpvar
         end
 
         pointee = pointee_of(ptr)
@@ -739,18 +748,18 @@ module C #:nodoc:
             if first_elem = pointee.inner_variable_at(0)
               pointee = first_elem
             else
-              pointee = create_tempvar(ptr_base_type)
+              pointee = create_tmpvar(ptr_base_type)
             end
           end
 
           unless ptr_base_type.same_as?(pointee.type)
             pointee = do_conversion(pointee, ptr_base_type) ||
-                      create_tempvar(ptr_base_type)
+                      create_tmpvar(ptr_base_type)
           end
         when ptr_base_type.function?
           pointee = define_anonymous_function(ptr_base_type)
         else
-          pointee = create_tempvar(ptr_base_type)
+          pointee = create_tmpvar(ptr_base_type)
         end
 
         notify_indirection_expr_evaled(node, ptr, pointee)
@@ -762,44 +771,44 @@ module C #:nodoc:
         case
         when !var.type.scalar? && !var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar
+          return create_tmpvar
         when var != obj
           notify_implicit_conv_performed(node.operand, obj, var)
         end
 
         case node.operator.type
         when "+"
-          result_var = create_tempvar(var.type, +var.value)
+          res_var = create_tmpvar(var.type, +var.value)
         when "-"
-          result_var = create_tempvar(var.type, -var.value)
+          res_var = create_tmpvar(var.type, -var.value)
         when "~"
-          result_var = create_tempvar(var.type, ~var.value)
+          res_var = create_tmpvar(var.type, ~var.value)
         when "!"
-          result_var = create_tempvar(int_type, !var.value)
+          res_var = create_tmpvar(int_t, !var.value)
         else
           __NOTREACHED__
         end
         _notify_variable_value_referred(node, var)
 
-        notify_unary_arithmetic_expr_evaled(node, var, result_var)
-        result_var
+        notify_unary_arithmetic_expr_evaled(node, var, res_var)
+        res_var
       end
 
       def eval_cast_expr(node, obj)
         resolve_unresolved_type(node.type_name)
 
         var = object_to_variable(obj)
-        result_var = do_conversion(var, node.type_name.type) ||
-                     create_tempvar(node.type_name.type)
+        res_var = do_conversion(var, node.type_name.type) ||
+                  create_tmpvar(node.type_name.type)
 
-        notify_explicit_conv_performed(node, var, result_var)
+        notify_explicit_conv_performed(node, var, res_var)
 
         # NOTE: A cast-expression does not refer a source value essentially.
         #       But, to avoid misunderstand that a return value of a function
         #       is discarded when the return value is casted before assigning
         #       to a variable.
         _notify_variable_value_referred(node, var)
-        result_var
+        res_var
       end
 
       def eval_multiplicative_expr(node, lhs_obj, rhs_obj)
@@ -807,7 +816,7 @@ module C #:nodoc:
         case
         when !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar
+          return create_tmpvar
         when lhs_var != lhs_obj
           notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
         end
@@ -816,7 +825,7 @@ module C #:nodoc:
         case
         when !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar
+          return create_tmpvar
         when rhs_var != rhs_obj
           notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
         end
@@ -838,27 +847,27 @@ module C #:nodoc:
         when "*"
           # NOTE: Domain of the arithmetic result value will be restricted by
           #       min-max of the variable type.
-          result_var = create_tempvar(lhs_conved.type, lhs_val * rhs_val)
+          res_var = create_tmpvar(lhs_conved.type, lhs_val * rhs_val)
         when "/"
           # NOTE: Domain of the arithmetic result value will be restricted by
           #       min-max of the variable type.
           # NOTE: "Div by 0" semantics is implemented in value-value
           #       arithmetic.
-          result_var = create_tempvar(lhs_conved.type, lhs_val / rhs_val)
+          res_var = create_tmpvar(lhs_conved.type, lhs_val / rhs_val)
         when "%"
           # NOTE: Domain of the arithmetic result value will be restricted by
           #       min-max of the variable type.
           # NOTE: "Div by 0" semantics is implemented in value-value
           #       arithmetic.
-          result_var = create_tempvar(lhs_conved.type, lhs_val % rhs_val)
+          res_var = create_tmpvar(lhs_conved.type, lhs_val % rhs_val)
         else
           __NOTREACHED__
         end
         _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, result_var)
-        result_var
+        notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, res_var)
+        res_var
       end
 
       def eval_additive_expr(node, lhs_obj, rhs_obj)
@@ -866,7 +875,7 @@ module C #:nodoc:
         case
         when !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar
+          return create_tmpvar
         when lhs_var != lhs_obj
           notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
         end
@@ -875,7 +884,7 @@ module C #:nodoc:
         case
         when !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar
+          return create_tmpvar
         when rhs_var != rhs_obj
           notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
         end
@@ -897,19 +906,19 @@ module C #:nodoc:
         when "+"
           # NOTE: Domain of the arithmetic result value will be restricted by
           #       min-max of the variable type.
-          result_var = create_tempvar(lhs_conved.type, lhs_val + rhs_val)
+          res_var = create_tmpvar(lhs_conved.type, lhs_val + rhs_val)
         when "-"
           # NOTE: Domain of the arithmetic result value will be restricted by
           #       min-max of the variable type.
-          result_var = create_tempvar(lhs_conved.type, lhs_val - rhs_val)
+          res_var = create_tmpvar(lhs_conved.type, lhs_val - rhs_val)
         else
           __NOTREACHED__
         end
         _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_additive_expr_evaled(node, lhs_var, rhs_var, result_var)
-        result_var
+        notify_additive_expr_evaled(node, lhs_var, rhs_var, res_var)
+        res_var
       end
 
       def eval_shift_expr(node, lhs_obj, rhs_obj)
@@ -917,7 +926,7 @@ module C #:nodoc:
         case
         when !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar
+          return create_tmpvar
         when lhs_var != lhs_obj
           notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
         end
@@ -926,7 +935,7 @@ module C #:nodoc:
         case
         when !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar
+          return create_tmpvar
         when rhs_var != rhs_obj
           notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
         end
@@ -958,19 +967,19 @@ module C #:nodoc:
         when "<<"
           # NOTE: Domain of the arithmetic result value will be restricted by
           #       min-max of the variable type.
-          result_var = create_tempvar(lhs_conved.type, lhs_val << rhs_val)
+          res_var = create_tmpvar(lhs_conved.type, lhs_val << rhs_val)
         when ">>"
           # NOTE: Domain of the arithmetic result value will be restricted by
           #       min-max of the variable type.
-          result_var = create_tempvar(lhs_conved.type, lhs_val >> rhs_val)
+          res_var = create_tmpvar(lhs_conved.type, lhs_val >> rhs_val)
         else
           __NOTREACHED__
         end
         _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_shift_expr_evaled(node, lhs_var, rhs_var, result_var)
-        result_var
+        notify_shift_expr_evaled(node, lhs_var, rhs_var, res_var)
+        res_var
       end
 
       def eval_relational_expr(node, lhs_obj, rhs_obj)
@@ -978,7 +987,7 @@ module C #:nodoc:
         case
         when !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar(int_type, ScalarValue.of_arbitrary)
+          return create_tmpvar(int_t, scalar_value_of_arbitrary)
         when lhs_var != lhs_obj
           notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
         end
@@ -987,7 +996,7 @@ module C #:nodoc:
         case
         when !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar(int_type, ScalarValue.of_arbitrary)
+          return create_tmpvar(int_t, scalar_value_of_arbitrary)
         when rhs_var != rhs_obj
           notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
         end
@@ -1007,21 +1016,21 @@ module C #:nodoc:
 
         case node.operator.type
         when "<"
-          result_var = create_tempvar(int_type, lhs_val <  rhs_val)
+          res_var = create_tmpvar(int_t, lhs_val <  rhs_val)
         when ">"
-          result_var = create_tempvar(int_type, lhs_val >  rhs_val)
+          res_var = create_tmpvar(int_t, lhs_val >  rhs_val)
         when "<="
-          result_var = create_tempvar(int_type, lhs_val <= rhs_val)
+          res_var = create_tmpvar(int_t, lhs_val <= rhs_val)
         when ">="
-          result_var = create_tempvar(int_type, lhs_val >= rhs_val)
+          res_var = create_tmpvar(int_t, lhs_val >= rhs_val)
         else
           __NOTREACHED__
         end
         _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_relational_expr_evaled(node, lhs_var, rhs_var, result_var)
-        result_var
+        notify_relational_expr_evaled(node, lhs_var, rhs_var, res_var)
+        res_var
       end
 
       def eval_equality_expr(node, lhs_obj, rhs_obj)
@@ -1029,7 +1038,7 @@ module C #:nodoc:
         case
         when !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar(int_type, ScalarValue.of_arbitrary)
+          return create_tmpvar(int_t, scalar_value_of_arbitrary)
         when lhs_var != lhs_obj
           notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
         end
@@ -1038,7 +1047,7 @@ module C #:nodoc:
         case
         when !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar(int_type, ScalarValue.of_arbitrary)
+          return create_tmpvar(int_t, scalar_value_of_arbitrary)
         when rhs_var != rhs_obj
           notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
         end
@@ -1058,17 +1067,17 @@ module C #:nodoc:
 
         case node.operator.type
         when "=="
-          result_var = create_tempvar(int_type, lhs_val == rhs_val)
+          res_var = create_tmpvar(int_t, lhs_val == rhs_val)
         when "!="
-          result_var = create_tempvar(int_type, lhs_val != rhs_val)
+          res_var = create_tmpvar(int_t, lhs_val != rhs_val)
         else
           __NOTREACHED__
         end
         _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_equality_expr_evaled(node, lhs_var, rhs_var, result_var)
-        result_var
+        notify_equality_expr_evaled(node, lhs_var, rhs_var, res_var)
+        res_var
       end
 
       def eval_and_expr(node, lhs_obj, rhs_obj)
@@ -1076,7 +1085,7 @@ module C #:nodoc:
         case
         when !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar
+          return create_tmpvar
         when lhs_var != lhs_obj
           notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
         end
@@ -1085,7 +1094,7 @@ module C #:nodoc:
         case
         when !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar
+          return create_tmpvar
         when rhs_var != rhs_obj
           notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
         end
@@ -1105,12 +1114,12 @@ module C #:nodoc:
 
         # NOTE: Domain of the arithmetic result value will be restricted by
         #       min-max of the variable type.
-        result_var = create_tempvar(lhs_conved.type, lhs_val & rhs_val)
+        res_var = create_tmpvar(lhs_conved.type, lhs_val & rhs_val)
         _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_and_expr_evaled(node, lhs_var, rhs_var, result_var)
-        result_var
+        notify_and_expr_evaled(node, lhs_var, rhs_var, res_var)
+        res_var
       end
 
       def eval_exclusive_or_expr(node, lhs_obj, rhs_obj)
@@ -1118,7 +1127,7 @@ module C #:nodoc:
         case
         when !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar
+          return create_tmpvar
         when lhs_var != lhs_obj
           notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
         end
@@ -1127,7 +1136,7 @@ module C #:nodoc:
         case
         when !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar
+          return create_tmpvar
         when rhs_var != rhs_obj
           notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
         end
@@ -1147,12 +1156,12 @@ module C #:nodoc:
 
         # NOTE: Domain of the arithmetic result value will be restricted by
         #       min-max of the variable type.
-        result_var = create_tempvar(lhs_conved.type, lhs_val ^ rhs_val)
+        res_var = create_tmpvar(lhs_conved.type, lhs_val ^ rhs_val)
         _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_exclusive_or_expr_evaled(node, lhs_var, rhs_var, result_var)
-        result_var
+        notify_exclusive_or_expr_evaled(node, lhs_var, rhs_var, res_var)
+        res_var
       end
 
       def eval_inclusive_or_expr(node, lhs_obj, rhs_obj)
@@ -1160,7 +1169,7 @@ module C #:nodoc:
         case
         when !lhs_var.type.scalar? && !lhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar
+          return create_tmpvar
         when lhs_var != lhs_obj
           notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
         end
@@ -1169,7 +1178,7 @@ module C #:nodoc:
         case
         when !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar
+          return create_tmpvar
         when rhs_var != rhs_obj
           notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
         end
@@ -1189,12 +1198,12 @@ module C #:nodoc:
 
         # NOTE: Domain of the arithmetic result value will be restricted by
         #       min-max of the variable type.
-        result_var = create_tempvar(lhs_conved.type, lhs_val | rhs_val)
+        res_var = create_tmpvar(lhs_conved.type, lhs_val | rhs_val)
         _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_inclusive_or_expr_evaled(node, lhs_var, rhs_var, result_var)
-        result_var
+        notify_inclusive_or_expr_evaled(node, lhs_var, rhs_var, res_var)
+        res_var
       end
 
       def eval_simple_assignment_expr(node, lhs_obj, rhs_obj)
@@ -1213,7 +1222,7 @@ module C #:nodoc:
           rhs_conved = rhs_var
         else
           rhs_conved = do_conversion(rhs_var, lhs_var.type) ||
-                       create_tempvar(lhs_var.type)
+                       create_tmpvar(lhs_var.type)
           notify_implicit_conv_performed(node.rhs_operand, rhs_var, rhs_conved)
         end
 
@@ -1241,7 +1250,7 @@ module C #:nodoc:
         case
         when !rhs_var.type.scalar? && !rhs_var.type.void?
           # NOTE: To detect bad value reference of `void' expressions.
-          return create_tempvar
+          return create_tmpvar
         when rhs_var != rhs_obj
           notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
         end
@@ -1278,7 +1287,7 @@ module C #:nodoc:
 
         lhs_val = lhs_conved.value
         rhs_val = rhs_conved.value
-        result_var = create_tempvar(lhs_conved.type, lhs_val * rhs_val)
+        res_var = create_tmpvar(lhs_conved.type, lhs_val * rhs_val)
 
         # NOTE: Value of the lhs_var is referred at this point.  But value
         #       reference should not be notified not to confuse sequence-point
@@ -1286,9 +1295,9 @@ module C #:nodoc:
         # _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, result_var)
+        notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, res_var)
 
-        _do_assign(node, lhs_var, result_var)
+        _do_assign(node, lhs_var, res_var)
       end
 
       def _do_div_then_assign(node, lhs_var, rhs_var)
@@ -1297,7 +1306,7 @@ module C #:nodoc:
         lhs_val = lhs_conved.value
         rhs_val = rhs_conved.value
         # NOTE: "Div by 0" semantics is implemented in value-value arithmetic.
-        result_var = create_tempvar(lhs_conved.type, lhs_val / rhs_val)
+        res_var = create_tmpvar(lhs_conved.type, lhs_val / rhs_val)
 
         # NOTE: Value of the lhs_var is referred at this point.  But value
         #       reference should not be notified not to confuse sequence-point
@@ -1305,9 +1314,9 @@ module C #:nodoc:
         # _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, result_var)
+        notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, res_var)
 
-        _do_assign(node, lhs_var, result_var)
+        _do_assign(node, lhs_var, res_var)
       end
 
       def _do_mod_then_assign(node, lhs_var, rhs_var)
@@ -1316,7 +1325,7 @@ module C #:nodoc:
         lhs_val = lhs_conved.value
         rhs_val = rhs_conved.value
         # NOTE: "Div by 0" semantics is implemented in value-value arithmetic.
-        result_var = create_tempvar(lhs_conved.type, lhs_val % rhs_val)
+        res_var = create_tmpvar(lhs_conved.type, lhs_val % rhs_val)
 
         # NOTE: Value of the lhs_var is referred at this point.  But value
         #       reference should not be notified not to confuse sequence-point
@@ -1324,9 +1333,9 @@ module C #:nodoc:
         # _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, result_var)
+        notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, res_var)
 
-        _do_assign(node, lhs_var, result_var)
+        _do_assign(node, lhs_var, res_var)
       end
 
       def _do_add_then_assign(node, lhs_var, rhs_var)
@@ -1334,7 +1343,7 @@ module C #:nodoc:
 
         lhs_val = lhs_conved.value
         rhs_val = rhs_conved.value
-        result_var = create_tempvar(lhs_conved.type, lhs_val + rhs_val)
+        res_var = create_tmpvar(lhs_conved.type, lhs_val + rhs_val)
 
         # NOTE: Value of the lhs_var is referred at this point.  But value
         #       reference should not be notified not to confuse sequence-point
@@ -1342,9 +1351,9 @@ module C #:nodoc:
         # _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_additive_expr_evaled(node, lhs_var, rhs_var, result_var)
+        notify_additive_expr_evaled(node, lhs_var, rhs_var, res_var)
 
-        _do_assign(node, lhs_var, result_var)
+        _do_assign(node, lhs_var, res_var)
       end
 
       def _do_sub_then_assign(node, lhs_var, rhs_var)
@@ -1352,7 +1361,7 @@ module C #:nodoc:
 
         lhs_val = lhs_conved.value
         rhs_val = rhs_conved.value
-        result_var = create_tempvar(lhs_conved.type, lhs_val - rhs_val)
+        res_var = create_tmpvar(lhs_conved.type, lhs_val - rhs_val)
 
         # NOTE: Value of the lhs_var is referred at this point.  But value
         #       reference should not be notified not to confuse sequence-point
@@ -1360,9 +1369,9 @@ module C #:nodoc:
         # _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_additive_expr_evaled(node, lhs_var, rhs_var, result_var)
+        notify_additive_expr_evaled(node, lhs_var, rhs_var, res_var)
 
-        _do_assign(node, lhs_var, result_var)
+        _do_assign(node, lhs_var, res_var)
       end
 
       def _do_shl_then_assign(node, lhs_var, rhs_var)
@@ -1379,7 +1388,7 @@ module C #:nodoc:
 
         lhs_val = lhs_conved.value
         rhs_val = rhs_conved.value
-        result_var = create_tempvar(lhs_conved.type, lhs_val << rhs_val)
+        res_var = create_tmpvar(lhs_conved.type, lhs_val << rhs_val)
 
         # NOTE: Value of the lhs_var is referred at this point.  But value
         #       reference should not be notified not to confuse sequence-point
@@ -1387,9 +1396,9 @@ module C #:nodoc:
         # _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_shift_expr_evaled(node, lhs_var, rhs_var, result_var)
+        notify_shift_expr_evaled(node, lhs_var, rhs_var, res_var)
 
-        _do_assign(node, lhs_var, result_var)
+        _do_assign(node, lhs_var, res_var)
       end
 
       def _do_shr_then_assign(node, lhs_var, rhs_var)
@@ -1406,7 +1415,7 @@ module C #:nodoc:
 
         lhs_val = lhs_conved.value
         rhs_val = rhs_conved.value
-        result_var = create_tempvar(lhs_conved.type, lhs_val >> rhs_val)
+        res_var = create_tmpvar(lhs_conved.type, lhs_val >> rhs_val)
 
         # NOTE: Value of the lhs_var is referred at this point.  But value
         #       reference should not be notified not to confuse sequence-point
@@ -1414,9 +1423,9 @@ module C #:nodoc:
         # _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_shift_expr_evaled(node, lhs_var, rhs_var, result_var)
+        notify_shift_expr_evaled(node, lhs_var, rhs_var, res_var)
 
-        _do_assign(node, lhs_var, result_var)
+        _do_assign(node, lhs_var, res_var)
       end
 
       def _do_and_then_assign(node, lhs_var, rhs_var)
@@ -1424,7 +1433,7 @@ module C #:nodoc:
 
         lhs_val = lhs_conved.value
         rhs_val = rhs_conved.value
-        result_var = create_tempvar(lhs_conved.type, lhs_val & rhs_val)
+        res_var = create_tmpvar(lhs_conved.type, lhs_val & rhs_val)
 
         # NOTE: Value of the lhs_var is referred at this point.  But value
         #       reference should not be notified not to confuse sequence-point
@@ -1432,9 +1441,9 @@ module C #:nodoc:
         # _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_and_expr_evaled(node, lhs_var, rhs_var, result_var)
+        notify_and_expr_evaled(node, lhs_var, rhs_var, res_var)
 
-        _do_assign(node, lhs_var, result_var)
+        _do_assign(node, lhs_var, res_var)
       end
 
       def _do_xor_then_assign(node, lhs_var, rhs_var)
@@ -1442,7 +1451,7 @@ module C #:nodoc:
 
         lhs_val = lhs_conved.value
         rhs_val = rhs_conved.value
-        result_var = create_tempvar(lhs_conved.type, lhs_val ^ rhs_val)
+        res_var = create_tmpvar(lhs_conved.type, lhs_val ^ rhs_val)
 
         # NOTE: Value of the lhs_var is referred at this point.  But value
         #       reference should not be notified not to confuse sequence-point
@@ -1450,9 +1459,9 @@ module C #:nodoc:
         # _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_exclusive_or_expr_evaled(node, lhs_var, rhs_var, result_var)
+        notify_exclusive_or_expr_evaled(node, lhs_var, rhs_var, res_var)
 
-        _do_assign(node, lhs_var, result_var)
+        _do_assign(node, lhs_var, res_var)
       end
 
       def _do_ior_then_assign(node, lhs_var, rhs_var)
@@ -1460,7 +1469,7 @@ module C #:nodoc:
 
         lhs_val = lhs_conved.value
         rhs_val = rhs_conved.value
-        result_var = create_tempvar(lhs_conved.type, lhs_val | rhs_val)
+        res_var = create_tmpvar(lhs_conved.type, lhs_val | rhs_val)
 
         # NOTE: Value of the lhs_var is referred at this point.  But value
         #       reference should not be notified not to confuse sequence-point
@@ -1468,9 +1477,9 @@ module C #:nodoc:
         # _notify_variable_value_referred(node, lhs_var)
         _notify_variable_value_referred(node, rhs_var)
 
-        notify_inclusive_or_expr_evaled(node, lhs_var, rhs_var, result_var)
+        notify_inclusive_or_expr_evaled(node, lhs_var, rhs_var, res_var)
 
-        _do_assign(node, lhs_var, result_var)
+        _do_assign(node, lhs_var, res_var)
       end
 
       def _do_uarith_conversion(node, lhs_var, rhs_var)
@@ -1501,22 +1510,21 @@ module C #:nodoc:
         return lhs_conved, rhs_conved
       end
 
-      def _do_assign(node, lhs_var, result_var)
-        if result_var.type.same_as?(lhs_var.type)
-          result_conved = result_var
+      def _do_assign(node, lhs_var, rhs_var)
+        if rhs_var.type.same_as?(lhs_var.type)
+          rhs_conved = rhs_var
         else
-          result_conved = do_conversion(result_var, lhs_var.type) ||
-                          create_tempvar(lhs_var.type)
-          notify_implicit_conv_performed(node.lhs_operand,
-                                         result_var, result_conved)
+          rhs_conved = do_conversion(rhs_var, lhs_var.type) ||
+                       create_tmpvar(lhs_var.type)
+          notify_implicit_conv_performed(node.lhs_operand, rhs_var, rhs_conved)
         end
 
         # NOTE: Domain of the arithmetic result value will be restricted by
         #       min-max of the variable type.
-        lhs_var.assign!(result_conved.value.to_defined_value)
+        lhs_var.assign!(rhs_conved.value.to_defined_value)
         _notify_variable_value_updated(node, lhs_var)
 
-        notify_assignment_expr_evaled(node, lhs_var, result_conved)
+        notify_assignment_expr_evaled(node, lhs_var, rhs_conved)
       end
 
       def _notify_object_referred(node, obj)
@@ -1549,6 +1557,12 @@ module C #:nodoc:
           end
         end
       end
+
+      def _notify_implicit_function_declared(node, obj)
+        if obj.function? && obj.implicit?
+          interpreter.notify_implicit_function_declared(node, obj)
+        end
+      end
     end
 
     include Impl