adlint 2.6.0 → 2.6.2

data/lib/adlint/c/expr.rb

@@ -37,1926 +37,1521 @@ require "adlint/c/seqp"
 module AdLint #:nodoc:
 module C #:nodoc:
 
-  module ExpressionUtil
-    # NOTE: Host class of this module must include InterpreterMediator,
-    #       NotifierMediator and Conversion.
-
-    def execute_object_specifier(node)
-      if variable = variable_named(node.identifier.value)
-        variable.declarations_and_definitions.each do |decl_or_def|
-          decl_or_def.mark_as_referred_by(node.identifier)
-        end
-        _notify_object_referred(node, variable)
-        # NOTE: Array object will be converted into its start address by the
-        #       outer expression.  So, it is correct to return an array object
-        #       itself.
-        return variable
-      end
-
-      if function = function_named(node.identifier.value)
-        function.declarations_and_definitions.each do |decl_or_def|
-          decl_or_def.mark_as_referred_by(node.identifier)
-        end
-        _notify_object_referred(node, function)
-        return function
-      end
-
-      if enumerator = enumerator_named(node.identifier.value)
-        enumerator.mark_as_referred_by(node.identifier)
-        return temporary_variable(enumerator.type,
-                                  ScalarValue.of(enumerator.value))
-      end
-
-      define_implicit_function(node.identifier.value)
-    end
-
-    def execute_array_subscript_expression(node, object, subscript)
-      unless object.variable? && (object.type.array? || object.type.pointer?)
-        return temporary_variable
-      end
-
-      array_or_pointer = object
-      result_type = array_or_pointer.type.unqualify.base_type
-
-      case
-      when array_or_pointer.type.array?
-        array = array_or_pointer
-        # NOTE: An array-subscript-expression with an array object only refers
-        #       the array object, never refer the value of the array object.
-      when array_or_pointer.type.pointer?
-        if pointee = pointee_of(array_or_pointer) and pointee.type.array?
-          array = pointee
-        end
-        # NOTE: An array-subscript-expression with a pointer object do refers
-        #       the value of the pointer object.
-        _notify_variable_value_referred(node, array_or_pointer)
-      end
-
-      unless subscript.variable? and
-          subscript.value.scalar? && subscript.value.exist? or
-          subscript.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable(result_type)
-      end
-      _notify_variable_value_referred(node, subscript)
-
-      # NOTE: An array subscript converted to `int' implicitly.
-      if subscript.type.same_as?(int_type)
-        int_subscript = subscript
-      else
-        if int_subscript = do_conversion(subscript, int_type)
-          notify_implicit_conv_performed(node.array_subscript,
-                                         subscript, int_subscript)
-        else
-          return temporary_variable(result_type)
-        end
-      end
-
-      # FIXME: Domain of the subscript may have multiple values.
-      subscript_value = int_subscript.value.unique_sample
-      if array and inner_variable = array.inner_variable_at(subscript_value)
-        _notify_object_referred(node, inner_variable)
-        if inner_variable.type.same_as?(result_type)
-          result = inner_variable
-        end
-      end
-      result ||= temporary_variable(result_type)
-
-      notify_array_subscript_expr_evaled(node, array_or_pointer,
-                                         int_subscript, array, result)
-      result
-    end
-
-    def execute_function_call_expression(node, object, args)
-      if object.function?
-        function = object
-      else
-        if object.type.pointer? && object.type.unqualify.base_type.function?
-          if pointee = pointee_of(object) and pointee.function?
-            function = pointee
-          else
-            function_type = object.type.unqualify.base_type
-            function = define_anonymous_function(function_type)
-          end
-        else
-          return temporary_variable
-        end
-      end
-      _notify_variable_value_referred(node, object)
-
-      # NOTE: The ISO C99 standard saids;
-      #
-      # 6.5.2.2 Function calls
-      #
-      # Semantics
-      #
-      # 10 The order of evaluation of the function designator, the actual
-      #    arguments, and subexpressions within the actual arguments is
-      #    unspecified, but there is a sequence point before the actual call.
-      notify_sequence_point_reached(SequencePoint.new(node)) unless args.empty?
-
-      result = function.call(interpreter, node, args)
-      unless function.builtin?
-        arg_variables = args.map { |arg, expr| object_to_variable(arg) }
-        notify_function_call_expr_evaled(node, function, arg_variables, result)
-      end
-
-      result
-    end
-
-    def execute_member_access_by_value_expression(node, object)
-      unless object.variable? && object.type.composite?
-        return temporary_variable
-      end
-      variable = object
-
-      member_variable = variable.inner_variable_named(node.identifier.value)
-      # NOTE: A member-access-by-value-expression only refers the composite
-      #       object, never refer the value of the composite object.
-
-      # NOTE: `member_variable' is nil when this expression represents the
-      #       direct member access extension.
-      notify_member_access_expr_evaled(node, variable, member_variable)
-
-      if member_variable
-        _notify_object_referred(node, member_variable)
-        member_variable
-      else
-        temporary_variable
-      end
-    end
-
-    def execute_member_access_by_pointer_expression(node, object)
-      unqualified_type = object.type.unqualify
-
-      unless object.variable? && unqualified_type.pointer? &&
-          unqualified_type.base_type.composite?
-        return temporary_variable
-      end
-      pointer = object
-
-      if pointee = pointee_of(pointer)
-        if pointee.type.array?
-          if first_element = pointee.inner_variable_at(0)
-            pointee = first_element
-          else
-            pointee = temporary_variable(object.type.unqualify.base_type)
-          end
-        end
-      end
-      # NOTE: A member-access-by-pointer-expression do refers the value of the
-      #       pointer object.
-      _notify_variable_value_referred(node, pointer)
-
-      if pointee && pointee.type.composite?
-        member_variable = pointee.inner_variable_named(node.identifier.value)
-      else
-        member = unqualified_type.base_type.member_named(node.identifier.value)
-        member_variable = temporary_variable(member.type) if member
-      end
-
-      # NOTE: `member_variable' is nil when this expression represents the
-      #       direct member access extension.
-      notify_member_access_expr_evaled(node, pointer, member_variable)
-
-      if member_variable
-        _notify_object_referred(node, member_variable)
-        member_variable
-      else
-        temporary_variable
-      end
-    end
-
-    def execute_postfix_increment_expression(node, object)
-      return temporary_variable unless object.variable? && object.type.scalar?
-      variable = object
-
-      result = temporary_variable(variable.type, variable.value.dup)
-
-      # NOTE: Value of the variable is referred at this point.  But value
-      #       reference should not be notified not to confuse sequence-point
-      #       warning detections.
-      # _notify_variable_value_referred(node, variable)
-
-      if variable.value.scalar?
-        variable.assign!(variable.value + ScalarValue.of(1))
-        _notify_variable_value_updated(node, variable)
-      end
-
-      notify_postfix_increment_expr_evaled(node, variable, result)
-
-      result
-    end
-
-    def execute_postfix_decrement_expression(node, object)
-      return temporary_variable unless object.variable? && object.type.scalar?
-      variable = object
-
-      result = temporary_variable(variable.type, variable.value.dup)
-
-      # NOTE: Value of the variable is referred at this point.  But value
-      #       reference should not be notified not to confuse sequence-point
-      #       warnings detections.
-      # _notify_variable_value_referred(node, variable)
-
-      if variable.value.scalar?
-        variable.assign!(variable.value - ScalarValue.of(1))
-        _notify_variable_value_updated(node, variable)
-      end
-
-      notify_postfix_decrement_expr_evaled(node, variable, result)
-
-      result
-    end
-
-    def execute_prefix_increment_expression(node, object)
-      return temporary_variable unless object.variable? && object.type.scalar?
-      variable = object
-
-      original_value = variable.value.dup
-
-      # NOTE: Value of the variable is referred at this point.  But value
-      #       reference should not be notified not to confuse sequence-point
-      #       warnings detections.
-      # _notify_variable_value_referred(node, variable)
-
-      if variable.value.scalar?
-        variable.assign!(variable.value + ScalarValue.of(1))
-        _notify_variable_value_updated(node, variable)
-      end
-
-      notify_prefix_increment_expr_evaled(node, variable, original_value)
-
-      temporary_variable(variable.type, variable.value)
-    end
-
-    def execute_prefix_decrement_expression(node, object)
-      return temporary_variable unless object.variable? && object.type.scalar?
-      variable = object
-
-      original_value = variable.value.dup
-
-      # NOTE: Value of the variable is referred at this point.  But value
-      #       reference should not be notified not to confuse sequence-point
-      #       warning detections.
-      # _notify_variable_value_referred(node, variable)
-
-      if variable.value.scalar?
-        variable.assign!(variable.value - ScalarValue.of(1))
-        _notify_variable_value_updated(node, variable)
-      end
-
-      notify_prefix_decrement_expr_evaled(node, variable, original_value)
-
-      temporary_variable(variable.type, variable.value)
-    end
-
-    def execute_address_expression(node, object)
-      # NOTE: An address-expression does not read the value of the object.  But
-      #       value reference should be notified to emphasize global variable
-      #       cross-references.
-      _notify_variable_value_referred(node, object)
-
-      pointer = temporary_variable(pointer_type(object.type),
-                                   pointer_value_of(object))
-
-      notify_address_expr_evaled(node, object, pointer)
-      pointer
-    end
-
-    def execute_indirection_expression(node, object)
-      return temporary_variable unless object.variable? && object.type.pointer?
-      pointer = object
-
-      unqualified_type = pointer.type.unqualify
-      pointee = pointee_of(pointer)
-      _notify_variable_value_referred(node, pointer)
-
-      case
-      when pointee
-        _notify_object_referred(node, pointee)
-        if pointee.type.array?
-          if first_element = pointee.inner_variable_at(0)
-            pointee = first_element
-          else
-            pointee = temporary_variable(unqualified_type.base_type)
-          end
-        end
-
-        unless unqualified_type.base_type.same_as?(pointee.type)
-          pointee =
-            do_conversion(pointee, unqualified_type.base_type) ||
-            temporary_variable(unqualified_type.base_type)
-        end
-      when unqualified_type.base_type.function?
-        pointee = define_anonymous_function(unqualified_type.base_type)
-      else
-        pointee = temporary_variable(unqualified_type.base_type)
-      end
-
-      notify_indirection_expr_evaled(node, pointer, pointee)
-
-      pointee
-    end
-
-    def execute_unary_arithmetic_expression(node, object)
-      variable = object_to_variable(object)
-      unless variable.type.scalar? || variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable
-      end
-
-      unless variable == object
-        notify_implicit_conv_performed(node.operand, object, variable)
-      end
-
-      case node.operator.type
-      when "+"
-        result = temporary_variable(variable.type, +variable.value)
-      when "-"
-        result = temporary_variable(variable.type, -variable.value)
-      when "~"
-        result = temporary_variable(variable.type, ~variable.value)
-      when "!"
-        result = temporary_variable(int_type, !variable.value)
-      else
-        __NOTREACHED__
-      end
-      _notify_variable_value_referred(node, variable)
+  module ExpressionEvaluator
+    # NOTE: Host class of this module must include InterpreterMediator and
+    #       MonitorUtil.
 
-      notify_unary_arithmetic_expr_evaled(node, variable, result)
+    include NotifierMediator
+    include ConstantEvaluator
+    include Conversion
 
-      result
+    def visit_error_expression(node)
+      checkpoint(node.location)
+      create_tempvar
     end
 
-    def execute_cast_expression(node, object)
-      resolve_unresolved_type(node.type_name)
-
-      variable = object_to_variable(object)
-      converted =
-        do_conversion(variable, node.type_name.type) ||
-        temporary_variable(node.type_name.type)
-
-      notify_explicit_conv_performed(node, variable, converted)
-
-      # 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, variable)
-
-      converted
+    def visit_object_specifier(node)
+      checkpoint(node.location)
+      eval_object_specifier(node)
     end
 
-    def execute_multiplicative_expression(node, lhs_object, rhs_object)
-      lhs_variable = object_to_variable(lhs_object)
-      unless lhs_variable.type.scalar? || lhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable
-      end
-
-      unless lhs_variable == lhs_object
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_object, lhs_variable)
-      end
-
-      rhs_variable = object_to_variable(rhs_object)
-      unless rhs_variable.type.scalar? || rhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable
-      end
-
-      unless rhs_variable == rhs_object
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_object, rhs_variable)
-      end
-
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
-
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
-
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
+    def visit_constant_specifier(node)
+      checkpoint(node.location)
 
-      case node.operator.type
-      when "*"
-        # NOTE: Domain of the arithmetic result value will be restricted by
-        #       min-max of the variable type.
-        result = temporary_variable(lhs_converted.type,
-                                    lhs_converted.value * rhs_converted.value)
-      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 = temporary_variable(lhs_converted.type,
-                                    lhs_converted.value / rhs_converted.value)
-      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 = temporary_variable(lhs_converted.type,
-                                    lhs_converted.value % rhs_converted.value)
+      if const_var = eval_constant(node)
+        notify_constant_referred(node, const_var)
+        const_var
       else
-        __NOTREACHED__
+        create_tempvar
       end
-      _notify_variable_value_referred(node, lhs_variable)
-      _notify_variable_value_referred(node, rhs_variable)
-
-      notify_multiplicative_expr_evaled(node, lhs_variable, rhs_variable,
-                                        result)
-      result
     end
 
-    def execute_additive_expression(node, lhs_object, rhs_object)
-      lhs_variable = object_to_variable(lhs_object)
-      unless lhs_variable.type.scalar? || lhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable
-      end
-
-      unless lhs_variable == lhs_object
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_object, lhs_variable)
-      end
-
-      rhs_variable = object_to_variable(rhs_object)
-      unless rhs_variable.type.scalar? || rhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable
-      end
-
-      unless rhs_variable == rhs_object
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_object, rhs_variable)
-      end
-
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
-
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
-
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
+    def visit_string_literal_specifier(node)
+      checkpoint(node.location)
 
-      case node.operator.type
-      when "+"
-        # NOTE: Domain of the arithmetic result value will be restricted by
-        #       min-max of the variable type.
-        result = temporary_variable(lhs_converted.type,
-                                    lhs_converted.value + rhs_converted.value)
-      when "-"
-        # NOTE: Domain of the arithmetic result value will be restricted by
-        #       min-max of the variable type.
-        result = temporary_variable(lhs_converted.type,
-                                    lhs_converted.value - rhs_converted.value)
+      case node.literal.value
+      when /\A"(.*)"\z/
+        create_tempvar(array_type(char_type, $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))
       else
-        __NOTREACHED__
+        create_tempvar(array_type(char_type))
       end
-      _notify_variable_value_referred(node, lhs_variable)
-      _notify_variable_value_referred(node, rhs_variable)
-
-      notify_additive_expr_evaled(node, lhs_variable, rhs_variable, result)
-
-      result
     end
 
-    def execute_shift_expression(node, lhs_object, rhs_object)
-      lhs_variable = object_to_variable(lhs_object)
-      unless lhs_variable.type.scalar? || lhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable
-      end
-
-      unless lhs_variable == lhs_object
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_object, lhs_variable)
-      end
-
-      rhs_variable = object_to_variable(rhs_object)
-      unless rhs_variable.type.scalar? || rhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable
-      end
-
-      unless rhs_variable == rhs_object
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_object, rhs_variable)
-      end
-
-      # NOTE: The ISO C99 standard saids;
-      #
-      # 6.5.7 Bitwise shift operators
-      #
-      # 3 The integer promotions are performed on each of the operands.  The
-      #   type of the result is that of the promoted left operand.  If the
-      #   value of the right operand is negative or is greater than or equal to
-      #   the width of the promoted left operand, the behavior is undefined.
-
-      lhs_converted = do_integer_promotion(lhs_variable)
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
-
-      rhs_converted = do_integer_promotion(rhs_variable)
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
-
-      case node.operator.type
-      when "<<"
-        # NOTE: Domain of the arithmetic result value will be restricted by
-        #       min-max of the variable type.
-        result = temporary_variable(lhs_converted.type,
-                                    lhs_converted.value << rhs_converted.value)
-      when ">>"
-        # NOTE: Domain of the arithmetic result value will be restricted by
-        #       min-max of the variable type.
-        result = temporary_variable(lhs_converted.type,
-                                    lhs_converted.value >> rhs_converted.value)
-      else
-        __NOTREACHED__
-      end
-      _notify_variable_value_referred(node, lhs_variable)
-      _notify_variable_value_referred(node, rhs_variable)
-
-      notify_shift_expr_evaled(node, lhs_variable, rhs_variable, result)
-
-      result
+    def visit_null_constant_specifier(node)
+      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))
     end
 
-    def execute_relational_expression(node, lhs_object, rhs_object)
-      lhs_variable = object_to_variable(lhs_object)
-      unless lhs_variable.type.scalar? || lhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable(int_type, ScalarValue.of_arbitrary)
-      end
-
-      unless lhs_variable == lhs_object
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_object, lhs_variable)
-      end
-
-      rhs_variable = object_to_variable(rhs_object)
-      unless rhs_variable.type.scalar? || rhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable(int_type, ScalarValue.of_arbitrary)
-      end
-
-      unless rhs_variable == rhs_object
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_object, rhs_variable)
-      end
-
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
-
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
-
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
-
-      case node.operator.type
-      when "<"
-        result = temporary_variable(int_type,
-                                    lhs_converted.value < rhs_converted.value)
-      when ">"
-        result = temporary_variable(int_type,
-                                    lhs_converted.value > rhs_converted.value)
-      when "<="
-        result = temporary_variable(int_type,
-                                    lhs_converted.value <= rhs_converted.value)
-      when ">="
-        result = temporary_variable(int_type,
-                                    lhs_converted.value >= rhs_converted.value)
-      else
-        __NOTREACHED__
-      end
-      _notify_variable_value_referred(node, lhs_variable)
-      _notify_variable_value_referred(node, rhs_variable)
-
-      notify_relational_expr_evaled(node, lhs_variable, rhs_variable, result)
-
-      result
+    def visit_grouped_expression(node)
+      checkpoint(node.location)
+      node.expression.accept(self)
     end
 
-    def execute_equality_expression(node, lhs_object, rhs_object)
-      lhs_variable = object_to_variable(lhs_object)
-      unless lhs_variable.type.scalar? || lhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable(int_type, ScalarValue.of_arbitrary)
-      end
-
-      unless lhs_variable == lhs_object
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_object, lhs_variable)
-      end
-
-      rhs_variable = object_to_variable(rhs_object)
-      unless rhs_variable.type.scalar? || rhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable(int_type, ScalarValue.of_arbitrary)
-      end
-
-      unless rhs_variable == rhs_object
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_object, rhs_variable)
-      end
-
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
-
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
-
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
-
-      case node.operator.type
-      when "=="
-        result = temporary_variable(int_type,
-                                    lhs_converted.value == rhs_converted.value)
-      when "!="
-        result = temporary_variable(int_type,
-                                    lhs_converted.value != rhs_converted.value)
-      else
-        __NOTREACHED__
-      end
-      _notify_variable_value_referred(node, lhs_variable)
-      _notify_variable_value_referred(node, rhs_variable)
-
-      notify_equality_expr_evaled(node, lhs_variable, rhs_variable, result)
-
-      result
+    def visit_array_subscript_expression(node)
+      checkpoint(node.location)
+      eval_array_subscript_expr(node, node.expression.accept(self),
+                                node.array_subscript.accept(self))
     end
 
-    def execute_and_expression(node, lhs_object, rhs_object)
-      lhs_variable = object_to_variable(lhs_object)
-      unless lhs_variable.type.scalar? || lhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable
-      end
-
-      unless lhs_variable == lhs_object
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_object, lhs_variable)
-      end
-
-      rhs_variable = object_to_variable(rhs_object)
-      unless rhs_variable.type.scalar? || rhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable
-      end
-
-      unless rhs_variable == rhs_object
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_object, rhs_variable)
-      end
-
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
-
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
-
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
-
-      # NOTE: Domain of the arithmetic result value will be restricted by
-      #       min-max of the variable type.
-      result = temporary_variable(lhs_converted.type,
-                                  lhs_converted.value & rhs_converted.value)
-      _notify_variable_value_referred(node, lhs_variable)
-      _notify_variable_value_referred(node, rhs_variable)
-
-      notify_and_expr_evaled(node, lhs_variable, rhs_variable, result)
-
-      result
+    def visit_function_call_expression(node)
+      checkpoint(node.location)
+      args = node.argument_expressions.map { |expr| [expr.accept(self), expr] }
+      eval_function_call_expr(node, node.expression.accept(self), args)
     end
 
-    def execute_exclusive_or_expression(node, lhs_object, rhs_object)
-      lhs_variable = object_to_variable(lhs_object)
-      unless lhs_variable.type.scalar? || lhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable
-      end
-
-      unless lhs_variable == lhs_object
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_object, lhs_variable)
-      end
-
-      rhs_variable = object_to_variable(rhs_object)
-      unless rhs_variable.type.scalar? || rhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable
-      end
-
-      unless rhs_variable == rhs_object
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_object, rhs_variable)
-      end
-
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
-
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
-
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
-
-      # NOTE: Domain of the arithmetic result value will be restricted by
-      #       min-max of the variable type.
-      result = temporary_variable(lhs_converted.type,
-                                  lhs_converted.value ^ rhs_converted.value)
-      _notify_variable_value_referred(node, lhs_variable)
-      _notify_variable_value_referred(node, rhs_variable)
-
-      notify_exclusive_or_expr_evaled(node, lhs_variable, rhs_variable, result)
-
-      result
+    def visit_member_access_by_value_expression(node)
+      checkpoint(node.location)
+      eval_member_access_by_value_expr(node, node.expression.accept(self))
     end
 
-    def execute_inclusive_or_expression(node, lhs_object, rhs_object)
-      lhs_variable = object_to_variable(lhs_object)
-      unless lhs_variable.type.scalar? || lhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable
-      end
-
-      unless lhs_variable == lhs_object
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_object, lhs_variable)
-      end
-
-      rhs_variable = object_to_variable(rhs_object)
-      unless rhs_variable.type.scalar? || rhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable
-      end
-
-      unless rhs_variable == rhs_object
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_object, rhs_variable)
-      end
-
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
-
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
-
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
-
-      # NOTE: Domain of the arithmetic result value will be restricted by
-      #       min-max of the variable type.
-      result = temporary_variable(lhs_converted.type,
-                                  lhs_converted.value | rhs_converted.value)
-      _notify_variable_value_referred(node, lhs_variable)
-      _notify_variable_value_referred(node, rhs_variable)
-
-      notify_inclusive_or_expr_evaled(node, lhs_variable, rhs_variable, result)
-
-      result
+    def visit_member_access_by_pointer_expression(node)
+      checkpoint(node.location)
+      eval_member_access_by_pointer_expr(node,node.expression.accept(self))
     end
 
-    def execute_simple_assignment_expression(node, lhs_object, rhs_object)
-      return lhs_object unless lhs_object.variable?
-      lhs_variable = lhs_object
-
-      rhs_variable = object_to_variable(rhs_object)
-      unless rhs_variable == rhs_object
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_object, rhs_variable)
-      end
-
-      if rhs_variable.type.same_as?(lhs_variable.type)
-        rhs_converted = rhs_variable
-      else
-        rhs_converted =
-          do_conversion(rhs_variable, lhs_variable.type) ||
-          temporary_variable(lhs_variable.type)
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
-
-      # NOTE: Domain of the arithmetic result value will be restricted by
-      #       min-max of the variable type.
-      # NOTE: Even if rhs_object is a NamedVariable, new value will be
-      #       instantiated in value-coercing.
-      #       So, value-aliasing never occurs.
-      lhs_variable.assign!(rhs_converted.value.to_defined_value)
-      _notify_variable_value_referred(node, rhs_variable)
-      _notify_variable_value_updated(node, lhs_variable)
-
-      notify_assignment_expr_evaled(node, lhs_variable, rhs_variable)
-
-      lhs_variable
+    def visit_bit_access_by_value_expression(node)
+      checkpoint(node.location)
+      # TODO: Should support the GCC extension.
+      create_tempvar
     end
 
-    def execute_compound_assignment_expression(node, lhs_object, rhs_object)
-      unless lhs_object.variable? && lhs_object.type.scalar?
-        return temporary_variable
-      end
-      lhs_variable = lhs_object
-
-      rhs_variable = object_to_variable(rhs_object)
-      unless rhs_variable.type.scalar? || rhs_variable.type.void?
-        # NOTE: To detect bad value reference of `void' expressions.
-        return temporary_variable
-      end
-
-      unless rhs_variable == rhs_object
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_object, rhs_variable)
-      end
-
-      case node.operator.type
-      when "*="
-        execute_mul_then_assign_expression(node, lhs_variable, rhs_variable)
-      when "/="
-        execute_div_then_assign_expression(node, lhs_variable, rhs_variable)
-      when "%="
-        execute_mod_then_assign_expression(node, lhs_variable, rhs_variable)
-      when "+="
-        execute_add_then_assign_expression(node, lhs_variable, rhs_variable)
-      when "-="
-        execute_sub_then_assign_expression(node, lhs_variable, rhs_variable)
-      when "<<="
-        execute_shl_then_assign_expression(node, lhs_variable, rhs_variable)
-      when ">>="
-        execute_shr_then_assign_expression(node, lhs_variable, rhs_variable)
-      when "&="
-        execute_and_then_assign_expression(node, lhs_variable, rhs_variable)
-      when "^="
-        execute_xor_then_assign_expression(node, lhs_variable, rhs_variable)
-      when "|="
-        execute_ior_then_assign_expression(node, lhs_variable, rhs_variable)
-      end
-
-      lhs_variable
+    def visit_bit_access_by_pointer_expression(node)
+      checkpoint(node.location)
+      # TODO: Should support the GCC extension.
+      create_tempvar
     end
 
-    def execute_mul_then_assign_expression(node, lhs_variable, rhs_variable)
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
-
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
-
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
-
-      if lhs_converted.value.scalar? && rhs_converted.value.scalar?
-        result_value = lhs_converted.value * rhs_converted.value
-      else
-        result_value = lhs_converted.value
-      end
-
-      # NOTE: Value of the lhs_variable is referred at this point.  But value
-      #       reference should not be notified not to confuse sequence-point
-      #       warning detections.
-      # _notify_variable_value_referred(node, lhs_variable)
-
-      _notify_variable_value_referred(node, rhs_variable)
-
-      result_variable = temporary_variable(lhs_converted.type, result_value)
-
-      notify_multiplicative_expr_evaled(node, lhs_variable, rhs_variable,
-                                        result_variable)
-
-      if result_variable.type.same_as?(lhs_variable.type)
-        result_converted = result_variable
-      else
-        result_converted =
-          do_conversion(result_variable, lhs_variable.type) ||
-          temporary_variable(lhs_variable.type)
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       result_variable, result_converted)
-      end
-
-      # NOTE: Domain of the arithmetic result value will be restricted by
-      #       min-max of the variable type.
-      lhs_variable.assign!(result_converted.value)
-      _notify_variable_value_updated(node, lhs_variable)
-
-      notify_assignment_expr_evaled(node, lhs_variable, result_converted)
+    def visit_postfix_increment_expression(node)
+      checkpoint(node.location)
+      eval_postfix_increment_expr(node, node.operand.accept(self))
     end
 
-    def execute_div_then_assign_expression(node, lhs_variable, rhs_variable)
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
-
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
-
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
-
-      if lhs_converted.value.scalar? && rhs_converted.value.scalar?
-        # NOTE: "Div by 0" semantics is implemented in value-value arithmetic.
-        result_value = lhs_converted.value / rhs_converted.value
-      else
-        result_value = lhs_converted.value
-      end
-
-      # NOTE: Value of the lhs_variable is referred at this point.  But value
-      #       reference should not be notified not to confuse sequence-point
-      #       warning detections.
-      # _notify_variable_value_referred(node, lhs_variable)
-
-      _notify_variable_value_referred(node, rhs_variable)
-
-      result_variable = temporary_variable(lhs_converted.type, result_value)
-
-      notify_multiplicative_expr_evaled(node, lhs_variable, rhs_variable,
-                                        result_variable)
-
-      if result_variable.type.same_as?(lhs_variable.type)
-        result_converted = result_variable
-      else
-        result_converted =
-          do_conversion(result_variable, lhs_variable.type) ||
-          temporary_variable(lhs_variable.type)
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       result_variable, result_converted)
-      end
-
-      # NOTE: Domain of the arithmetic result value will be restricted by
-      #       min-max of the variable type.
-      lhs_variable.assign!(result_converted.value)
-      _notify_variable_value_updated(node, lhs_variable)
-
-      notify_assignment_expr_evaled(node, lhs_variable, result_converted)
+    def visit_postfix_decrement_expression(node)
+      checkpoint(node.location)
+      eval_postfix_decrement_expr(node, node.operand.accept(self))
     end
 
-    def execute_mod_then_assign_expression(node, lhs_variable, rhs_variable)
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
-
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
-
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
-
-      if lhs_converted.value.scalar? && rhs_converted.value.scalar?
-        # NOTE: "Div by 0" semantics is implemented in value-value arithmetic.
-        result_value = lhs_converted.value % rhs_converted.value
-      else
-        result_value = lhs_converted.value
-      end
-
-      # NOTE: Value of the lhs_variable is referred at this point.  But value
-      #       reference should not be notified not to confuse sequence-point
-      #       warning detections.
-      # _notify_variable_value_referred(node, lhs_variable)
-
-      _notify_variable_value_referred(node, rhs_variable)
+    def visit_compound_literal_expression(node)
+      checkpoint(node.location)
+      # TODO: Should support C99 features.
+      create_tempvar(node.type_name.type)
+    end
 
-      result_variable = temporary_variable(lhs_converted.type, result_value)
+    def visit_prefix_increment_expression(node)
+      checkpoint(node.location)
+      eval_prefix_increment_expr(node, node.operand.accept(self))
+    end
 
-      notify_multiplicative_expr_evaled(node, lhs_variable, rhs_variable,
-                                        result_variable)
+    def visit_prefix_decrement_expression(node)
+      checkpoint(node.location)
+      eval_prefix_decrement_expr(node, node.operand.accept(self))
+    end
 
-      if result_variable.type.same_as?(lhs_variable.type)
-        result_converted = result_variable
-      else
-        result_converted =
-          do_conversion(result_variable, lhs_variable.type) ||
-          temporary_variable(lhs_variable.type)
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       result_variable, result_converted)
-      end
+    def visit_address_expression(node)
+      checkpoint(node.location)
+      eval_address_expr(node, node.operand.accept(self))
+    end
 
-      # NOTE: Domain of the arithmetic result value will be restricted by
-      #       min-max of the variable type.
-      lhs_variable.assign!(result_converted.value)
-      _notify_variable_value_updated(node, lhs_variable)
+    def visit_indirection_expression(node)
+      checkpoint(node.location)
+      eval_indirection_expr(node, node.operand.accept(self))
+    end
 
-      notify_assignment_expr_evaled(node, lhs_variable, result_converted)
+    def visit_unary_arithmetic_expression(node)
+      checkpoint(node.location)
+      eval_unary_arithmetic_expr(node, node.operand.accept(self))
     end
 
-    def execute_add_then_assign_expression(node, lhs_variable, rhs_variable)
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
+    def visit_sizeof_expression(node)
+      checkpoint(node.location)
 
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
+      operand_obj = result_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))
+        else
+          return create_tempvar(result_type)
+        end
       end
 
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
+      notify_sizeof_expr_evaled(node, operand_obj, result_var)
+      result_var
+    end
 
-      if lhs_converted.value.scalar? && rhs_converted.value.scalar?
-        result_value = lhs_converted.value + rhs_converted.value
-      else
-        result_value = lhs_converted.value
+    def visit_sizeof_type_expression(node)
+      checkpoint(node.location)
+      resolve_unresolved_type(node.operand)
+
+      result_var = nil
+      eval_without_side_effect do
+        result_type = type_of(UserTypeId.new("size_t")) || unsigned_long_type
+        size = node.operand.type.aligned_byte_size
+        result_var = create_tempvar(result_type, ScalarValue.of(size))
       end
 
-      # NOTE: Value of the lhs_variable is referred at this point.  But value
-      #       reference should not be notified not to confuse sequence-point
-      #       warning detections.
-      # _notify_variable_value_referred(node, lhs_variable)
+      notify_sizeof_type_expr_evaled(node, node.operand.type, result_var)
+      result_var
+    end
 
-      _notify_variable_value_referred(node, rhs_variable)
+    def visit_alignof_expression(node)
+      checkpoint(node.location)
 
-      result_variable = temporary_variable(lhs_converted.type, result_value)
+      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))
+        else
+          create_tempvar(result_type)
+        end
+      end
+    end
 
-      notify_additive_expr_evaled(node, lhs_variable, rhs_variable,
-                                  result_variable)
+    def visit_alignof_type_expression(node)
+      checkpoint(node.location)
+      resolve_unresolved_type(node.operand)
 
-      if result_variable.type.same_as?(lhs_variable.type)
-        result_converted = result_variable
-      else
-        result_converted =
-          do_conversion(result_variable, lhs_variable.type) ||
-          temporary_variable(lhs_variable.type)
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       result_variable, result_converted)
+      eval_without_side_effect do
+        result_type = type_of(UserTypeId.new("size_t")) || unsigned_long_type
+        align = node.operand.type.aligned_byte_size
+        create_tempvar(result_type, ScalarValue.of(align))
       end
+    end
 
-      # NOTE: Domain of the arithmetic result value will be restricted by
-      #       min-max of the variable type.
-      lhs_variable.assign!(result_converted.value)
-      _notify_variable_value_updated(node, lhs_variable)
+    def visit_cast_expression(node)
+      checkpoint(node.location)
+      eval_cast_expr(node, node.operand.accept(self))
+    end
 
-      notify_assignment_expr_evaled(node, lhs_variable, result_converted)
+    def visit_multiplicative_expression(node)
+      checkpoint(node.location)
+      eval_multiplicative_expr(node, node.lhs_operand.accept(self),
+                               node.rhs_operand.accept(self))
     end
 
-    def execute_sub_then_assign_expression(node, lhs_variable, rhs_variable)
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
+    def visit_additive_expression(node)
+      checkpoint(node.location)
+      eval_additive_expr(node, node.lhs_operand.accept(self),
+                         node.rhs_operand.accept(self))
+    end
 
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
+    def visit_shift_expression(node)
+      checkpoint(node.location)
+      eval_shift_expr(node, node.lhs_operand.accept(self),
+                      node.rhs_operand.accept(self))
+    end
 
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
+    def visit_relational_expression(node)
+      checkpoint(node.location)
+      eval_relational_expr(node, node.lhs_operand.accept(self),
+                           node.rhs_operand.accept(self))
+    end
 
-      if lhs_converted.value.scalar? && rhs_converted.value.scalar?
-        result_value = lhs_converted.value - rhs_converted.value
-      else
-        result_value = lhs_converted.value
-      end
+    def visit_equality_expression(node)
+      checkpoint(node.location)
+      eval_equality_expr(node, node.lhs_operand.accept(self),
+                         node.rhs_operand.accept(self))
+    end
 
-      # NOTE: Value of the lhs_variable is referred at this point.  But value
-      #       reference should not be notified not to confuse sequence-point
-      #       warning detections.
-      # _notify_variable_value_referred(node, lhs_variable)
+    def visit_and_expression(node)
+      checkpoint(node.location)
+      eval_and_expr(node, node.lhs_operand.accept(self),
+                    node.rhs_operand.accept(self))
+    end
 
-      _notify_variable_value_referred(node, rhs_variable)
+    def visit_exclusive_or_expression(node)
+      checkpoint(node.location)
+      eval_exclusive_or_expr(node, node.lhs_operand.accept(self),
+                             node.rhs_operand.accept(self))
+    end
 
-      result_variable = temporary_variable(lhs_converted.type, result_value)
+    def visit_inclusive_or_expression(node)
+      checkpoint(node.location)
+      eval_inclusive_or_expr(node, node.lhs_operand.accept(self),
+                             node.rhs_operand.accept(self))
+    end
 
-      notify_additive_expr_evaled(node, lhs_variable, rhs_variable,
-                                  result_variable)
+    def visit_logical_and_expression(node)
+      checkpoint(node.location)
 
-      if result_variable.type.same_as?(lhs_variable.type)
-        result_converted = result_variable
+      lhs_obj = node.lhs_operand.accept(self)
+      if lhs_obj.variable?
+        lhs_var = lhs_obj
       else
-        result_converted =
-          do_conversion(result_variable, lhs_variable.type) ||
-          temporary_variable(lhs_variable.type)
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       result_variable, result_converted)
+        return create_tempvar(int_type)
       end
 
-      # NOTE: Domain of the arithmetic result value will be restricted by
-      #       min-max of the variable type.
-      lhs_variable.assign!(result_converted.value)
-      _notify_variable_value_updated(node, lhs_variable)
-
-      notify_assignment_expr_evaled(node, lhs_variable, result_converted)
-    end
-
-    def execute_shl_then_assign_expression(node, lhs_variable, rhs_variable)
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
+      #
+      # 6.5.13 Logical AND operator
       #
-      # 6.5.7 Bitwise shift operators
+      # Semantics
       #
-      # 3 The integer promotions are performed on each of the operands.  The
-      #   type of the result is that of the promoted left operand.  If the
-      #   value of the right operand is negative or is greater than or equal to
-      #   the width of the promoted left operand, the behavior is undefined.
-
-      lhs_converted = do_integer_promotion(lhs_variable)
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
+      # 4 Unlike the bitwise binary & operator, the && operator guarantees
+      #   left-to-right evaluation; there is a sequence point after the
+      #   evaluation of the first operand.  If the first operand compares equal
+      #   to 0, the second operand is not evaluated.
+      notify_sequence_point_reached(SequencePoint.new(node.lhs_operand))
+      lhs_val = lhs_var.value
 
-      rhs_converted = do_integer_promotion(rhs_variable)
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
+      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)
       end
 
-      if lhs_converted.value.scalar? && rhs_converted.value.scalar?
-        result_value = lhs_converted.value << rhs_converted.value
+      rhs_obj = node.rhs_operand.accept(self)
+      if rhs_obj.variable?
+        rhs_var = rhs_obj
       else
-        result_value = lhs_converted.value
+        return create_tempvar(int_type)
       end
 
-      # NOTE: Value of the lhs_variable is referred at this point.  But value
-      #       reference should not be notified not to confuse sequence-point
-      #       warning detections.
-      # _notify_variable_value_referred(node, lhs_variable)
+      notify_sequence_point_reached(SequencePoint.new(node.rhs_operand))
+      rhs_val = rhs_var.value
 
-      _notify_variable_value_referred(node, rhs_variable)
+      if lhs_val.scalar? && rhs_val.scalar?
+        # NOTE: No usual-arithmetic-conversion.
+        result_var = create_tempvar(int_type, lhs_val.logical_and(rhs_val))
+      else
+        result_var = create_tempvar(int_type)
+      end
+      notify_variable_value_referred(node, lhs_var)
+      notify_variable_value_referred(node, rhs_var)
 
-      result_variable = temporary_variable(lhs_converted.type, result_value)
+      notify_logical_and_expr_evaled(node, lhs_var, rhs_var, result_var)
+      result_var
+    end
 
-      notify_shift_expr_evaled(node, lhs_variable, rhs_variable,
-                               result_variable)
+    def visit_logical_or_expression(node)
+      checkpoint(node.location)
 
-      if result_variable.type.same_as?(lhs_variable.type)
-        result_converted = result_variable
+      lhs_obj = node.lhs_operand.accept(self)
+      if lhs_obj.variable?
+        lhs_var = lhs_obj
       else
-        result_converted =
-          do_conversion(result_variable, lhs_variable.type) ||
-          temporary_variable(lhs_variable.type)
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       result_variable, result_converted)
+        return create_tempvar(int_type)
       end
 
-      # NOTE: Domain of the arithmetic result value will be restricted by
-      #       min-max of the variable type.
-      lhs_variable.assign!(result_converted.value)
-      _notify_variable_value_updated(node, lhs_variable)
-
-      notify_assignment_expr_evaled(node, lhs_variable, result_converted)
-    end
-
-    def execute_shr_then_assign_expression(node, lhs_variable, rhs_variable)
-      # NOTE: The ISO C99 standard saids;
+      # NOTE: The ISO C99 standard says;
+      #
+      # 6.5.14 Logical OR operator
       #
-      # 6.5.7 Bitwise shift operators
+      # Semantics
       #
-      # 3 The integer promotions are performed on each of the operands.  The
-      #   type of the result is that of the promoted left operand.  If the
-      #   value of the right operand is negative or is greater than or equal to
-      #   the width of the promoted left operand, the behavior is undefined.
-
-      lhs_converted = do_integer_promotion(lhs_variable)
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
+      # 4 Unlike the bitwise | operator, the || operator guarantees
+      #   left-to-right evaluation; there is a sequence point after the
+      #   evaluation of the first operand.  If the first operand compares
+      #   unequal to 0, the second operand is not evaluated.
+      notify_sequence_point_reached(SequencePoint.new(node.lhs_operand))
+      lhs_val = lhs_var.value
 
-      rhs_converted = do_integer_promotion(rhs_variable)
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
+      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)
       end
 
-      if lhs_converted.value.scalar? && rhs_converted.value.scalar?
-        result_value = lhs_converted.value >> rhs_converted.value
+      rhs_obj = node.rhs_operand.accept(self)
+      if rhs_obj.variable?
+        rhs_var = rhs_obj
       else
-        result_value = lhs_converted.value
+        return create_tempvar(int_type)
       end
 
-      # NOTE: Value of the lhs_variable is referred at this point.  But value
-      #       reference should not be notified not to confuse sequence-point
-      #       warning detections.
-      # _notify_variable_value_referred(node, lhs_variable)
-
-      _notify_variable_value_referred(node, rhs_variable)
-
-      result_variable = temporary_variable(lhs_converted.type, result_value)
-
-      notify_shift_expr_evaled(node, lhs_variable, rhs_variable,
-                               result_variable)
+      notify_sequence_point_reached(SequencePoint.new(node.rhs_operand))
+      rhs_val = rhs_var.value
 
-      if result_variable.type.same_as?(lhs_variable.type)
-        result_converted = result_variable
+      if lhs_val.scalar? && rhs_val.scalar?
+        # NOTE: No usual-arithmetic-conversion.
+        result_var = create_tempvar(int_type, lhs_val.logical_or(rhs_val))
       else
-        result_converted =
-          do_conversion(result_variable, lhs_variable.type) ||
-          temporary_variable(lhs_variable.type)
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       result_variable, result_converted)
+        result_var = create_tempvar(int_type)
       end
+      notify_variable_value_referred(node, lhs_var)
+      notify_variable_value_referred(node, rhs_var)
 
-      # NOTE: Domain of the arithmetic result value will be restricted by
-      #       min-max of the variable type.
-      lhs_variable.assign!(result_converted.value)
-      _notify_variable_value_updated(node, lhs_variable)
+      notify_logical_or_expr_evaled(node, lhs_var, rhs_var, result_var)
+      result_var
+    end
 
-      notify_assignment_expr_evaled(node, lhs_variable, result_converted)
+    def visit_simple_assignment_expression(node)
+      checkpoint(node.location)
+      eval_simple_assignment_expr(node, node.lhs_operand.accept(self),
+                                  node.rhs_operand.accept(self))
     end
 
-    def execute_and_then_assign_expression(node, lhs_variable, rhs_variable)
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
+    def visit_compound_assignment_expression(node)
+      checkpoint(node.location)
+      eval_compound_assignment_expr(node, node.lhs_operand.accept(self),
+                                    node.rhs_operand.accept(self))
+    end
 
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
+    def visit_comma_separated_expression(node)
+      checkpoint(node.location)
+      node.expressions.map { |expr| expr.accept(self) }.last
+    end
 
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
+    private
+    def eval_without_side_effect(&block)
+      originally_quiet = interpreter.quiet_without_side_effect?
+      unless originally_quiet
+        interpreter._quiet_without_side_effect = true
       end
-
-      if lhs_converted.value.scalar? && rhs_converted.value.scalar?
-        result_value = lhs_converted.value & rhs_converted.value
-      else
-        result_value = lhs_converted.value
+      yield
+    ensure
+      unless originally_quiet
+        interpreter._quiet_without_side_effect = false
+        # FIXME: Evaluation of an object-specifier doesn't refer to value
+        #        of a variable.  Thus, no cross-reference record on a
+        #        sizeof-expression because cross-reference extraction
+        #        watches variable value reference not variable reference.
+        # collect_object_specifiers(node).each { |os| os.accept(self) }
       end
+    end
+
+    def create_array_value_of_string(str)
+      ArrayValue.new(str.chars.map { |ch| ScalarValue.of(ch.ord) } +
+                     [ScalarValue.of("\0".ord)])
+    end
 
-      # NOTE: Value of the lhs_variable is referred at this point.  But value
-      #       reference should not be notified not to confuse sequence-point
-      #       warning detections.
-      # _notify_variable_value_referred(node, lhs_variable)
+    module Impl
+      # NOTE: Host class of this module must include InterpreterMediator,
+      #       NotifierMediator and Conversion.
 
-      _notify_variable_value_referred(node, rhs_variable)
+      def eval_object_specifier(node)
+        if var = variable_named(node.identifier.value)
+          var.declarations_and_definitions.each do |dcl_or_def|
+            dcl_or_def.mark_as_referred_by(node.identifier)
+          end
+          _notify_object_referred(node, var)
+          # NOTE: Array object will be converted into its start address by the
+          #       outer expression.  So, it is correct to return an array
+          #       object itself.
+          return var
+        end
 
-      result_variable = temporary_variable(lhs_converted.type, result_value)
+        if func = function_named(node.identifier.value)
+          func.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
+        end
 
-      notify_and_expr_evaled(node, lhs_variable, rhs_variable, result_variable)
+        if enum = enumerator_named(node.identifier.value)
+          enum.mark_as_referred_by(node.identifier)
+          return create_tempvar(enum.type, ScalarValue.of(enum.value))
+        end
 
-      if result_variable.type.same_as?(lhs_variable.type)
-        result_converted = result_variable
-      else
-        result_converted =
-          do_conversion(result_variable, lhs_variable.type) ||
-          temporary_variable(lhs_variable.type)
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       result_variable, result_converted)
+        define_implicit_function(node.identifier.value)
       end
 
-      # NOTE: Domain of the arithmetic result value will be restricted by
-      #       min-max of the variable type.
-      lhs_variable.assign!(result_converted.value)
-      _notify_variable_value_updated(node, lhs_variable)
+      def eval_array_subscript_expr(node, obj, subs)
+        unless obj.variable? && (obj.type.array? || obj.type.pointer?)
+          return create_tempvar
+        end
 
-      notify_assignment_expr_evaled(node, lhs_variable, result_converted)
-    end
+        ary_or_ptr = obj
+        result_type = ary_or_ptr.type.unqualify.base_type
+
+        case
+        when ary_or_ptr.type.array?
+          ary = ary_or_ptr
+          # 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
+          if pointee = pointee_of(ptr) and pointee.type.array?
+            ary = pointee
+          end
+          # NOTE: An array-subscript-expression with a pointer object do refers
+          #       the value of the pointer object.
+          _notify_variable_value_referred(node, ptr)
+        end
 
-    def execute_xor_then_assign_expression(node, lhs_variable, rhs_variable)
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
+        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)
+        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)
+            notify_implicit_conv_performed(node.array_subscript,
+                                           subs, int_subs)
+            subs = int_subs
+          else
+            return create_tempvar(result_type)
+          end
+        end
 
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
+        # FIXME: Domain of the subscript may have multiple values.
+        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
+          end
+        end
+        result_var ||= create_tempvar(result_type)
 
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
+        notify_array_subscript_expr_evaled(node, ary_or_ptr, subs, ary,
+                                           result_var)
+        result_var
       end
 
-      if lhs_converted.value.scalar? && rhs_converted.value.scalar?
-        result_value = lhs_converted.value ^ rhs_converted.value
-      else
-        result_value = lhs_converted.value
-      end
+      def eval_function_call_expr(node, obj, args)
+        if obj.function?
+          func = obj
+        else
+          return create_tempvar 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
+            else
+              func = define_anonymous_function(obj_base_type)
+            end
+          end
+        end
+        _notify_variable_value_referred(node, obj)
+
+        # NOTE: The ISO C99 standard says;
+        #
+        # 6.5.2.2 Function calls
+        #
+        # Semantics
+        #
+        # 10 The order of evaluation of the function designator, the actual
+        #    arguments, and subexpressions within the actual arguments is
+        #    unspecified, but there is a sequence point before the actual call.
+        unless args.empty?
+          notify_sequence_point_reached(SequencePoint.new(node))
+        end
+
+        result_var = func.call(interpreter, node, args)
+        unless func.builtin?
+          arg_vars = args.map { |arg_obj, *| object_to_variable(arg_obj) }
+          notify_function_call_expr_evaled(node, func, arg_vars, result_var)
+        end
 
-      # NOTE: Value of the lhs_variable is referred at this point.  But value
-      #       reference should not be notified not to confuse sequence-point
-      #       warning detections.
-      # _notify_variable_value_referred(node, lhs_variable)
+        result_var
+      end
 
-      _notify_variable_value_referred(node, rhs_variable)
+      def eval_member_access_by_value_expr(node, obj)
+        if obj.variable? && obj.type.composite?
+          outer_var = obj
+        else
+          return create_tempvar
+        end
 
-      result_variable = temporary_variable(lhs_converted.type, result_value)
+        memb_var = outer_var.inner_variable_named(node.identifier.value)
+        # NOTE: A member-access-by-value-expression only refers the composite
+        #       object, never refer the value of the composite object.
 
-      notify_exclusive_or_expr_evaled(node, lhs_variable, rhs_variable,
-                                      result_variable)
+        # NOTE: `memb_var' is nil when this expression represents the direct
+        #       member access extension.
+        notify_member_access_expr_evaled(node, outer_var, memb_var)
 
-      if result_variable.type.same_as?(lhs_variable.type)
-        result_converted = result_variable
-      else
-        result_converted =
-          do_conversion(result_variable, lhs_variable.type) ||
-          temporary_variable(lhs_variable.type)
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       result_variable, result_converted)
+        if memb_var
+          _notify_object_referred(node, memb_var)
+          memb_var
+        else
+          create_tempvar
+        end
       end
 
-      # NOTE: Domain of the arithmetic result value will be restricted by
-      #       min-max of the variable type.
-      lhs_variable.assign!(result_converted.value)
-      _notify_variable_value_updated(node, lhs_variable)
-
-      notify_assignment_expr_evaled(node, lhs_variable, result_converted)
-    end
+      def eval_member_access_by_pointer_expr(node, obj)
+        obj_type = obj.type.unqualify
+        if obj.variable? && obj_type.pointer? && obj_type.base_type.composite?
+          ptr = obj
+        else
+          return create_tempvar
+        end
 
-    def execute_ior_then_assign_expression(node, lhs_variable, rhs_variable)
-      lhs_converted, rhs_converted =
-        do_usual_arithmetic_conversion(lhs_variable, rhs_variable)
+        if pointee = pointee_of(ptr)
+          if pointee.type.array?
+            if first_elem = pointee.inner_variable_at(0)
+              pointee = first_elem
+            else
+              pointee = create_tempvar(obj_type.base_type)
+            end
+          end
+        end
+        # NOTE: A member-access-by-pointer-expression do refers the value of
+        #       the pointer object.
+        _notify_variable_value_referred(node, ptr)
 
-      unless lhs_variable == lhs_converted
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       lhs_variable, lhs_converted)
-      end
+        if pointee && pointee.type.composite?
+          outer_var = pointee
+          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)
+          end
+        end
 
-      unless rhs_variable == rhs_converted
-        notify_implicit_conv_performed(node.rhs_operand,
-                                       rhs_variable, rhs_converted)
-      end
+        # NOTE: `memb_var' is nil when this expression represents the direct
+        #       member access extension.
+        notify_member_access_expr_evaled(node, ptr, memb_var)
 
-      if lhs_converted.value.scalar? && rhs_converted.value.scalar?
-        result_value = lhs_converted.value | rhs_converted.value
-      else
-        result_value = lhs_converted.value
+        if memb_var
+          _notify_object_referred(node, memb_var)
+          memb_var
+        else
+          create_tempvar
+        end
       end
 
-      # NOTE: Value of the lhs_variable is referred at this point.  But value
-      #       reference should not be notified not to confuse sequence-point
-      #       warning detections.
-      # _notify_variable_value_referred(node, lhs_variable)
+      def eval_postfix_increment_expr(node, obj)
+        if obj.variable? && obj.type.scalar?
+          var = obj
+        else
+          return create_tempvar
+        end
 
-      _notify_variable_value_referred(node, rhs_variable)
+        result_var = create_tempvar(var.type, var.value.dup)
 
-      result_variable = temporary_variable(lhs_converted.type, result_value)
+        # NOTE: Value of the variable is referred at this point.  But value
+        #       reference should not be notified not to confuse sequence-point
+        #       warning detections.
+        # _notify_variable_value_referred(node, var)
 
-      notify_inclusive_or_expr_evaled(node, lhs_variable, rhs_variable,
-                                      result_variable)
+        if var.value.scalar?
+          var.assign!(var.value + ScalarValue.of(1))
+          _notify_variable_value_updated(node, var)
+        end
 
-      if result_variable.type.same_as?(lhs_variable.type)
-        result_converted = result_variable
-      else
-        result_converted =
-          do_conversion(result_variable, lhs_variable.type) ||
-          temporary_variable(lhs_variable.type)
-        notify_implicit_conv_performed(node.lhs_operand,
-                                       result_variable, result_converted)
+        notify_postfix_increment_expr_evaled(node, var, result_var)
+        result_var
       end
 
-      # NOTE: Domain of the arithmetic result value will be restricted by
-      #       min-max of the variable type.
-      lhs_variable.assign!(result_converted.value)
-      _notify_variable_value_updated(node, lhs_variable)
+      def eval_postfix_decrement_expr(node, obj)
+        if obj.variable? && obj.type.scalar?
+          var = obj
+        else
+          return create_tempvar
+        end
 
-      notify_assignment_expr_evaled(node, lhs_variable, result_converted)
-    end
+        result_var = create_tempvar(var.type, var.value.dup)
 
-    def _notify_object_referred(node, object)
-      case object
-      when Variable
-        interpreter.notify_variable_referred(node, object)
-      when Function
-        interpreter.notify_function_referred(node, object)
-      end
-    end
+        # NOTE: Value of the variable is referred at this point.  But value
+        #       reference should not be notified not to confuse sequence-point
+        #       warnings detections.
+        # _notify_variable_value_referred(node, var)
+
+        if var.value.scalar?
+          var.assign!(var.value - ScalarValue.of(1))
+          _notify_variable_value_updated(node, var)
+        end
 
-    def _notify_variable_value_referred(node, object)
-      if object.variable?
-        interpreter.notify_variable_value_referred(node, object)
+        notify_postfix_decrement_expr_evaled(node, var, result_var)
+        result_var
       end
 
-      # NOTE: When a value of the inner-variable of array or composite object
-      #       is referred, notification of the outer variable's value has
-      #       already been done in sub expressions.
-    end
+      def eval_prefix_increment_expr(node, obj)
+        if obj.variable? && obj.type.scalar?
+          var = obj
+        else
+          return create_tempvar
+        end
+
+        orig_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
+        #       warnings detections.
+        # _notify_variable_value_referred(node, var)
 
-    def _notify_variable_value_updated(node, object)
-      if object.variable?
-        interpreter.notify_variable_value_updated(node, object)
-        if object.inner?
-          # NOTE: When a value of the inner-variable of array or composite
-          #       object is updated, the outer variable's value should also be
-          #       notified to be updated.
-          _notify_variable_value_updated(node, object.owner)
+        if var.value.scalar?
+          var.assign!(var.value + ScalarValue.of(1))
+          _notify_variable_value_updated(node, var)
         end
+
+        notify_prefix_increment_expr_evaled(node, var, orig_val)
+        create_tempvar(var.type, var.value)
       end
-    end
 
-    def _char_array_value(string_literal)
-      chars = string_literal.chars.map { |ch| ScalarValue.of(ch.ord) }
-      ArrayValue.new(chars + [ScalarValue.of("\0".ord)])
-    end
+      def eval_prefix_decrement_expr(node, obj)
+        if obj.variable? && obj.type.scalar?
+          var = obj
+        else
+          return create_tempvar
+        end
 
-    def _wchar_array_value(string_literal)
-      chars = string_literal.chars.map { |ch| ScalarValue.of(ch.ord) }
-      ArrayValue.new(chars + [ScalarValue.of("\0".ord)])
-    end
-  end
+        orig_val = var.value.dup
 
-  module ExpressionEvaluator
-    # NOTE: Host class of this module must include InterpreterMediator and
-    #       MonitorUtil.
+        # NOTE: Value of the variable is referred at this point.  But value
+        #       reference should not be notified not to confuse sequence-point
+        #       warning detections.
+        # _notify_variable_value_referred(node, var)
 
-    include NotifierMediator
-    include ConstantEvaluator
-    include Conversion
-    include ExpressionUtil
+        if var.value.scalar?
+          var.assign!(var.value - ScalarValue.of(1))
+          _notify_variable_value_updated(node, var)
+        end
 
-    def visit_error_expression(node)
-      checkpoint(node.location)
+        notify_prefix_decrement_expr_evaled(node, var, orig_val)
+        create_tempvar(var.type, var.value)
+      end
 
-      temporary_variable
-    end
+      def eval_address_expr(node, obj)
+        # NOTE: An address-expression does not read the value of the object.
+        #       But value reference should be notified to emphasize global
+        #       variable cross-references.
+        _notify_variable_value_referred(node, obj)
 
-    def visit_object_specifier(node)
-      checkpoint(node.location)
+        ptr = create_tempvar(pointer_type(obj.type), pointer_value_of(obj))
+        notify_address_expr_evaled(node, obj, ptr)
+        ptr
+      end
 
-      execute_object_specifier(node)
-    end
+      def eval_indirection_expr(node, obj)
+        if obj.variable? && obj.type.pointer?
+          ptr = obj
+        else
+          return create_tempvar
+        end
 
-    def visit_constant_specifier(node)
-      checkpoint(node.location)
+        pointee = pointee_of(ptr)
+        _notify_variable_value_referred(node, ptr)
 
-      if variable = eval_constant(node)
-        notify_constant_referred(node, variable)
-        variable
-      else
-        temporary_variable
-      end
-    end
+        ptr_base_type = ptr.type.unqualify.base_type
 
-    def visit_string_literal_specifier(node)
-      checkpoint(node.location)
+        case
+        when pointee
+          _notify_object_referred(node, pointee)
+          if pointee.type.array?
+            if first_elem = pointee.inner_variable_at(0)
+              pointee = first_elem
+            else
+              pointee = create_tempvar(ptr_base_type)
+            end
+          end
 
-      case node.literal.value
-      when /\A"(.*)"\z/
-        temporary_variable(array_type(char_type, $1.length + 1),
-                           _char_array_value($1))
-      when /\AL"(.*)"\z/i
-        temporary_variable(array_type(wchar_type, $1.length + 1),
-                           _wchar_array_value($1))
-      else
-        temporary_variable(array_type(char_type))
+          unless ptr_base_type.same_as?(pointee.type)
+            pointee = do_conversion(pointee, ptr_base_type) ||
+                      create_tempvar(ptr_base_type)
+          end
+        when ptr_base_type.function?
+          pointee = define_anonymous_function(ptr_base_type)
+        else
+          pointee = create_tempvar(ptr_base_type)
+        end
+
+        notify_indirection_expr_evaled(node, ptr, pointee)
+        pointee
       end
-    end
 
-    def visit_null_constant_specifier(node)
-      checkpoint(node.location)
+      def eval_unary_arithmetic_expr(node, obj)
+        var = object_to_variable(obj)
+        case
+        when !var.type.scalar? && !var.type.void?
+          # NOTE: To detect bad value reference of `void' expressions.
+          return create_tempvar
+        when var != obj
+          notify_implicit_conv_performed(node.operand, obj, var)
+        end
 
-      # TODO: NULL may not be 0 on some environments.
-      #       Representation of NULL should be configurable?
-      temporary_variable(pointer_type(void_type), ScalarValue.of(0))
-    end
+        case node.operator.type
+        when "+"
+          result_var = create_tempvar(var.type, +var.value)
+        when "-"
+          result_var = create_tempvar(var.type, -var.value)
+        when "~"
+          result_var = create_tempvar(var.type, ~var.value)
+        when "!"
+          result_var = create_tempvar(int_type, !var.value)
+        else
+          __NOTREACHED__
+        end
+        _notify_variable_value_referred(node, var)
 
-    def visit_grouped_expression(node)
-      checkpoint(node.location)
+        notify_unary_arithmetic_expr_evaled(node, var, result_var)
+        result_var
+      end
 
-      node.expression.accept(self)
-    end
+      def eval_cast_expr(node, obj)
+        resolve_unresolved_type(node.type_name)
 
-    def visit_array_subscript_expression(node)
-      checkpoint(node.location)
+        var = object_to_variable(obj)
+        result_var = do_conversion(var, node.type_name.type) ||
+                     create_tempvar(node.type_name.type)
 
-      execute_array_subscript_expression(
-        node, node.expression.accept(self), node.array_subscript.accept(self))
-    end
+        notify_explicit_conv_performed(node, var, result_var)
 
-    def visit_function_call_expression(node)
-      checkpoint(node.location)
+        # 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
+      end
 
-      object = node.expression.accept(self)
-      args = node.argument_expressions.map { |expr| [expr.accept(self), expr] }
+      def eval_multiplicative_expr(node, lhs_obj, rhs_obj)
+        lhs_var = object_to_variable(lhs_obj)
+        case
+        when !lhs_var.type.scalar? && !lhs_var.type.void?
+          # NOTE: To detect bad value reference of `void' expressions.
+          return create_tempvar
+        when lhs_var != lhs_obj
+          notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
+        end
 
-      execute_function_call_expression(node, object, args)
-    end
+        rhs_var = object_to_variable(rhs_obj)
+        case
+        when !rhs_var.type.scalar? && !rhs_var.type.void?
+          # NOTE: To detect bad value reference of `void' expressions.
+          return create_tempvar
+        when rhs_var != rhs_obj
+          notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
+        end
 
-    def visit_member_access_by_value_expression(node)
-      checkpoint(node.location)
+        lhs_conved, rhs_conved =
+          do_usual_arithmetic_conversion(lhs_var, rhs_var)
 
-      object = node.expression.accept(self)
+        unless lhs_conved == lhs_var
+          notify_implicit_conv_performed(node.lhs_operand, lhs_var, lhs_conved)
+        end
+        unless rhs_conved == rhs_var
+          notify_implicit_conv_performed(node.rhs_operand, rhs_var, rhs_conved)
+        end
 
-      execute_member_access_by_value_expression(node, object)
-    end
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
+
+        case node.operator.type
+        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)
+        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)
+        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)
+        else
+          __NOTREACHED__
+        end
+        _notify_variable_value_referred(node, lhs_var)
+        _notify_variable_value_referred(node, rhs_var)
 
-    def visit_member_access_by_pointer_expression(node)
-      checkpoint(node.location)
+        notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, result_var)
+        result_var
+      end
 
-      object = node.expression.accept(self)
+      def eval_additive_expr(node, lhs_obj, rhs_obj)
+        lhs_var = object_to_variable(lhs_obj)
+        case
+        when !lhs_var.type.scalar? && !lhs_var.type.void?
+          # NOTE: To detect bad value reference of `void' expressions.
+          return create_tempvar
+        when lhs_var != lhs_obj
+          notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
+        end
 
-      execute_member_access_by_pointer_expression(node, object)
-    end
+        rhs_var = object_to_variable(rhs_obj)
+        case
+        when !rhs_var.type.scalar? && !rhs_var.type.void?
+          # NOTE: To detect bad value reference of `void' expressions.
+          return create_tempvar
+        when rhs_var != rhs_obj
+          notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
+        end
 
-    def visit_bit_access_by_value_expression(node)
-      checkpoint(node.location)
+        lhs_conved, rhs_conved =
+          do_usual_arithmetic_conversion(lhs_var, rhs_var)
 
-      # TODO: Should support the GCC extension.
-      temporary_variable
-    end
+        unless lhs_conved == lhs_var
+          notify_implicit_conv_performed(node.lhs_operand, lhs_var, lhs_conved)
+        end
+        unless rhs_conved == rhs_var
+          notify_implicit_conv_performed(node.rhs_operand, rhs_var, rhs_conved)
+        end
 
-    def visit_bit_access_by_pointer_expression(node)
-      checkpoint(node.location)
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
+
+        case node.operator.type
+        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)
+        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)
+        else
+          __NOTREACHED__
+        end
+        _notify_variable_value_referred(node, lhs_var)
+        _notify_variable_value_referred(node, rhs_var)
 
-      # TODO: Should support the GCC extension.
-      temporary_variable
-    end
+        notify_additive_expr_evaled(node, lhs_var, rhs_var, result_var)
+        result_var
+      end
 
-    def visit_postfix_increment_expression(node)
-      checkpoint(node.location)
+      def eval_shift_expr(node, lhs_obj, rhs_obj)
+        lhs_var = object_to_variable(lhs_obj)
+        case
+        when !lhs_var.type.scalar? && !lhs_var.type.void?
+          # NOTE: To detect bad value reference of `void' expressions.
+          return create_tempvar
+        when lhs_var != lhs_obj
+          notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
+        end
 
-      object = node.operand.accept(self)
+        rhs_var = object_to_variable(rhs_obj)
+        case
+        when !rhs_var.type.scalar? && !rhs_var.type.void?
+          # NOTE: To detect bad value reference of `void' expressions.
+          return create_tempvar
+        when rhs_var != rhs_obj
+          notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
+        end
 
-      execute_postfix_increment_expression(node, object)
-    end
+        # NOTE: The ISO C99 standard says;
+        #
+        # 6.5.7 Bitwise shift operators
+        #
+        # 3 The integer promotions are performed on each of the operands.  The
+        #   type of the result is that of the promoted left operand.  If the
+        #   value of the right operand is negative or is greater than or equal
+        #   to the width of the promoted left operand, the behavior is
+        #   undefined.
+
+        lhs_conved = do_integer_promotion(lhs_var)
+        rhs_conved = do_integer_promotion(rhs_var)
+
+        unless lhs_conved == lhs_var
+          notify_implicit_conv_performed(node.lhs_operand, lhs_var, lhs_conved)
+        end
+        unless rhs_conved == rhs_var
+          notify_implicit_conv_performed(node.rhs_operand, rhs_var, rhs_conved)
+        end
 
-    def visit_postfix_decrement_expression(node)
-      checkpoint(node.location)
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
+
+        case node.operator.type
+        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)
+        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)
+        else
+          __NOTREACHED__
+        end
+        _notify_variable_value_referred(node, lhs_var)
+        _notify_variable_value_referred(node, rhs_var)
 
-      object = node.operand.accept(self)
+        notify_shift_expr_evaled(node, lhs_var, rhs_var, result_var)
+        result_var
+      end
 
-      execute_postfix_decrement_expression(node, object)
-    end
+      def eval_relational_expr(node, lhs_obj, rhs_obj)
+        lhs_var = object_to_variable(lhs_obj)
+        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)
+        when lhs_var != lhs_obj
+          notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
+        end
 
-    def visit_compound_literal_expression(node)
-      checkpoint(node.location)
+        rhs_var = object_to_variable(rhs_obj)
+        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)
+        when rhs_var != rhs_obj
+          notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
+        end
 
-      # TODO: Should support C99 features.
-      temporary_variable(node.type_name.type)
-    end
+        lhs_conved, rhs_conved =
+          do_usual_arithmetic_conversion(lhs_var, rhs_var)
 
-    def visit_prefix_increment_expression(node)
-      checkpoint(node.location)
+        unless lhs_conved == lhs_var
+          notify_implicit_conv_performed(node.lhs_operand, lhs_var, lhs_conved)
+        end
+        unless rhs_conved == rhs_var
+          notify_implicit_conv_performed(node.rhs_operand, rhs_var, rhs_conved)
+        end
 
-      object = node.operand.accept(self)
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
+
+        case node.operator.type
+        when "<"
+          result_var = create_tempvar(int_type, lhs_val <  rhs_val)
+        when ">"
+          result_var = create_tempvar(int_type, lhs_val >  rhs_val)
+        when "<="
+          result_var = create_tempvar(int_type, lhs_val <= rhs_val)
+        when ">="
+          result_var = create_tempvar(int_type, lhs_val >= rhs_val)
+        else
+          __NOTREACHED__
+        end
+        _notify_variable_value_referred(node, lhs_var)
+        _notify_variable_value_referred(node, rhs_var)
 
-      execute_prefix_increment_expression(node, object)
-    end
+        notify_relational_expr_evaled(node, lhs_var, rhs_var, result_var)
+        result_var
+      end
 
-    def visit_prefix_decrement_expression(node)
-      checkpoint(node.location)
+      def eval_equality_expr(node, lhs_obj, rhs_obj)
+        lhs_var = object_to_variable(lhs_obj)
+        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)
+        when lhs_var != lhs_obj
+          notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
+        end
 
-      object = node.operand.accept(self)
+        rhs_var = object_to_variable(rhs_obj)
+        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)
+        when rhs_var != rhs_obj
+          notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
+        end
 
-      execute_prefix_decrement_expression(node, object)
-    end
+        lhs_conved, rhs_conved =
+          do_usual_arithmetic_conversion(lhs_var, rhs_var)
 
-    def visit_address_expression(node)
-      checkpoint(node.location)
+        unless lhs_conved == lhs_var
+          notify_implicit_conv_performed(node.lhs_operand, lhs_var, lhs_conved)
+        end
+        unless rhs_conved == rhs_var
+          notify_implicit_conv_performed(node.rhs_operand, rhs_var, rhs_conved)
+        end
 
-      object = node.operand.accept(self)
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
 
-      execute_address_expression(node, object)
-    end
+        case node.operator.type
+        when "=="
+          result_var = create_tempvar(int_type, lhs_val == rhs_val)
+        when "!="
+          result_var = create_tempvar(int_type, lhs_val != rhs_val)
+        else
+          __NOTREACHED__
+        end
+        _notify_variable_value_referred(node, lhs_var)
+        _notify_variable_value_referred(node, rhs_var)
 
-    def visit_indirection_expression(node)
-      checkpoint(node.location)
+        notify_equality_expr_evaled(node, lhs_var, rhs_var, result_var)
+        result_var
+      end
 
-      object = node.operand.accept(self)
+      def eval_and_expr(node, lhs_obj, rhs_obj)
+        lhs_var = object_to_variable(lhs_obj)
+        case
+        when !lhs_var.type.scalar? && !lhs_var.type.void?
+          # NOTE: To detect bad value reference of `void' expressions.
+          return create_tempvar
+        when lhs_var != lhs_obj
+          notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
+        end
 
-      execute_indirection_expression(node, object)
-    end
+        rhs_var = object_to_variable(rhs_obj)
+        case
+        when !rhs_var.type.scalar? && !rhs_var.type.void?
+          # NOTE: To detect bad value reference of `void' expressions.
+          return create_tempvar
+        when rhs_var != rhs_obj
+          notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
+        end
 
-    def visit_unary_arithmetic_expression(node)
-      checkpoint(node.location)
+        lhs_conved, rhs_conved =
+          do_usual_arithmetic_conversion(lhs_var, rhs_var)
 
-      object = node.operand.accept(self)
+        unless lhs_conved == lhs_var
+          notify_implicit_conv_performed(node.lhs_operand, lhs_var, lhs_conved)
+        end
+        unless rhs_conved == rhs_var
+          notify_implicit_conv_performed(node.rhs_operand, rhs_var, rhs_conved)
+        end
 
-      execute_unary_arithmetic_expression(node, object)
-    end
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
 
-    def visit_sizeof_expression(node)
-      checkpoint(node.location)
+        # 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)
+        _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
+      end
+
+      def eval_exclusive_or_expr(node, lhs_obj, rhs_obj)
+        lhs_var = object_to_variable(lhs_obj)
+        case
+        when !lhs_var.type.scalar? && !lhs_var.type.void?
+          # NOTE: To detect bad value reference of `void' expressions.
+          return create_tempvar
+        when lhs_var != lhs_obj
+          notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
+        end
 
-      variable = result = nil
-      eval_without_side_effect do
-        if size_t_type = type_of(UserTypeId.new("size_t"))
-          result_type = size_t_type
-        else
-          result_type = unsigned_long_type
+        rhs_var = object_to_variable(rhs_obj)
+        case
+        when !rhs_var.type.scalar? && !rhs_var.type.void?
+          # NOTE: To detect bad value reference of `void' expressions.
+          return create_tempvar
+        when rhs_var != rhs_obj
+          notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
         end
 
-        object = node.operand.accept(self)
-        if object.variable?
-          variable = object
-          result = temporary_variable(
-            result_type, ScalarValue.of(variable.type.aligned_byte_size))
-        else
-          return temporary_variable(result_type)
+        lhs_conved, rhs_conved =
+          do_usual_arithmetic_conversion(lhs_var, rhs_var)
+
+        unless lhs_conved == lhs_var
+          notify_implicit_conv_performed(node.lhs_operand, lhs_var, lhs_conved)
+        end
+        unless rhs_conved == rhs_var
+          notify_implicit_conv_performed(node.rhs_operand, rhs_var, rhs_conved)
         end
-      end
 
-      notify_sizeof_expr_evaled(node, variable, result)
-      result
-    end
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
 
-    def visit_sizeof_type_expression(node)
-      checkpoint(node.location)
+        # 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)
+        _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
+      end
+
+      def eval_inclusive_or_expr(node, lhs_obj, rhs_obj)
+        lhs_var = object_to_variable(lhs_obj)
+        case
+        when !lhs_var.type.scalar? && !lhs_var.type.void?
+          # NOTE: To detect bad value reference of `void' expressions.
+          return create_tempvar
+        when lhs_var != lhs_obj
+          notify_implicit_conv_performed(node.lhs_operand, lhs_obj, lhs_var)
+        end
 
-      resolve_unresolved_type(node.operand)
+        rhs_var = object_to_variable(rhs_obj)
+        case
+        when !rhs_var.type.scalar? && !rhs_var.type.void?
+          # NOTE: To detect bad value reference of `void' expressions.
+          return create_tempvar
+        when rhs_var != rhs_obj
+          notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
+        end
 
-      result = nil
-      eval_without_side_effect do
-        if size_t_type = type_of(UserTypeId.new("size_t"))
-          result_type = size_t_type
-        else
-          result_type = unsigned_long_type
+        lhs_conved, rhs_conved =
+          do_usual_arithmetic_conversion(lhs_var, rhs_var)
+
+        unless lhs_conved == lhs_var
+          notify_implicit_conv_performed(node.lhs_operand, lhs_var, lhs_conved)
+        end
+        unless rhs_conved == rhs_var
+          notify_implicit_conv_performed(node.rhs_operand, rhs_var, rhs_conved)
         end
 
-        result = temporary_variable(
-          result_type, ScalarValue.of(node.operand.type.aligned_byte_size))
-      end
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
 
-      notify_sizeof_type_expr_evaled(node, node.operand.type, result)
-      result
-    end
+        # 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)
+        _notify_variable_value_referred(node, lhs_var)
+        _notify_variable_value_referred(node, rhs_var)
 
-    def visit_alignof_expression(node)
-      checkpoint(node.location)
+        notify_inclusive_or_expr_evaled(node, lhs_var, rhs_var, result_var)
+        result_var
+      end
 
-      eval_without_side_effect do
-        if size_t_type = type_of(UserTypeId.new("size_t"))
-          result_type = size_t_type
+      def eval_simple_assignment_expr(node, lhs_obj, rhs_obj)
+        if lhs_obj.variable?
+          lhs_var = lhs_obj
         else
-          result_type = unsigned_long_type
+          return lhs_obj
+        end
+
+        rhs_var = object_to_variable(rhs_obj)
+        unless rhs_var == rhs_obj
+          notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
         end
 
-        object = node.operand.accept(self)
-        if object.variable?
-          variable = object
-          temporary_variable(result_type,
-                             ScalarValue.of(variable.type.byte_alignment))
+        if rhs_var.type.same_as?(lhs_var.type)
+          rhs_conved = rhs_var
         else
-          temporary_variable(result_type)
+          rhs_conved = do_conversion(rhs_var, lhs_var.type) ||
+                       create_tempvar(lhs_var.type)
+          notify_implicit_conv_performed(node.rhs_operand, rhs_var, rhs_conved)
         end
-      end
-    end
 
-    def visit_alignof_type_expression(node)
-      checkpoint(node.location)
+        # NOTE: Domain of the arithmetic result value will be restricted by
+        #       min-max of the variable type.
+        # NOTE: Even if rhs_obj is a NamedVariable, new value will be
+        #       instantiated in value-coercing.
+        #       So, value-aliasing never occurs.
+        lhs_var.assign!(rhs_conved.value.to_defined_value)
+        _notify_variable_value_referred(node, rhs_var)
+        _notify_variable_value_updated(node, lhs_var)
 
-      resolve_unresolved_type(node.operand)
+        notify_assignment_expr_evaled(node, lhs_var, rhs_var)
+        lhs_var
+      end
 
-      eval_without_side_effect do
-        if size_t_type = type_of(UserTypeId.new("size_t"))
-          result_type = size_t_type
+      def eval_compound_assignment_expr(node, lhs_obj, rhs_obj)
+        if lhs_obj.variable? && lhs_obj.type.scalar?
+          lhs_var = lhs_obj
         else
-          result_type = unsigned_long_type
+          return lhs_obj
         end
 
-        temporary_variable(result_type,
-                           ScalarValue.of(node.operand.type.aligned_byte_size))
-      end
-    end
+        rhs_var = object_to_variable(rhs_obj)
+        case
+        when !rhs_var.type.scalar? && !rhs_var.type.void?
+          # NOTE: To detect bad value reference of `void' expressions.
+          return create_tempvar
+        when rhs_var != rhs_obj
+          notify_implicit_conv_performed(node.rhs_operand, rhs_obj, rhs_var)
+        end
 
-    def visit_cast_expression(node)
-      checkpoint(node.location)
+        case node.operator.type
+        when "*="
+          _do_mul_then_assign(node, lhs_var, rhs_var)
+        when "/="
+          _do_div_then_assign(node, lhs_var, rhs_var)
+        when "%="
+          _do_mod_then_assign(node, lhs_var, rhs_var)
+        when "+="
+          _do_add_then_assign(node, lhs_var, rhs_var)
+        when "-="
+          _do_sub_then_assign(node, lhs_var, rhs_var)
+        when "<<="
+          _do_shl_then_assign(node, lhs_var, rhs_var)
+        when ">>="
+          _do_shr_then_assign(node, lhs_var, rhs_var)
+        when "&="
+          _do_and_then_assign(node, lhs_var, rhs_var)
+        when "^="
+          _do_xor_then_assign(node, lhs_var, rhs_var)
+        when "|="
+          _do_ior_then_assign(node, lhs_var, rhs_var)
+        end
 
-      object = node.operand.accept(self)
-      execute_cast_expression(node, object)
-    end
+        lhs_var
+      end
 
-    def visit_multiplicative_expression(node)
-      checkpoint(node.location)
+      private
+      def _do_mul_then_assign(node, lhs_var, rhs_var)
+        lhs_conved, rhs_conved = _do_uarith_conversion(node, lhs_var, rhs_var)
 
-      lhs_object = node.lhs_operand.accept(self)
-      rhs_object = node.rhs_operand.accept(self)
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
+        result_var = create_tempvar(lhs_conved.type, lhs_val * rhs_val)
 
-      execute_multiplicative_expression(node, lhs_object, rhs_object)
-    end
+        # NOTE: Value of the lhs_var is referred at this point.  But value
+        #       reference should not be notified not to confuse sequence-point
+        #       warning detections.
+        # _notify_variable_value_referred(node, lhs_var)
+        _notify_variable_value_referred(node, rhs_var)
 
-    def visit_additive_expression(node)
-      checkpoint(node.location)
+        notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, result_var)
 
-      lhs_object = node.lhs_operand.accept(self)
-      rhs_object = node.rhs_operand.accept(self)
+        _do_assign(node, lhs_var, result_var)
+      end
 
-      execute_additive_expression(node, lhs_object, rhs_object)
-    end
+      def _do_div_then_assign(node, lhs_var, rhs_var)
+        lhs_conved, rhs_conved = _do_uarith_conversion(node, lhs_var, rhs_var)
 
-    def visit_shift_expression(node)
-      checkpoint(node.location)
+        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)
 
-      lhs_object = node.lhs_operand.accept(self)
-      rhs_object = node.rhs_operand.accept(self)
+        # NOTE: Value of the lhs_var is referred at this point.  But value
+        #       reference should not be notified not to confuse sequence-point
+        #       warning detections.
+        # _notify_variable_value_referred(node, lhs_var)
+        _notify_variable_value_referred(node, rhs_var)
 
-      execute_shift_expression(node, lhs_object, rhs_object)
-    end
+        notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, result_var)
 
-    def visit_relational_expression(node)
-      checkpoint(node.location)
+        _do_assign(node, lhs_var, result_var)
+      end
 
-      lhs_object = node.lhs_operand.accept(self)
-      rhs_object = node.rhs_operand.accept(self)
+      def _do_mod_then_assign(node, lhs_var, rhs_var)
+        lhs_conved, rhs_conved = _do_uarith_conversion(node, lhs_var, rhs_var)
 
-      execute_relational_expression(node, lhs_object, rhs_object)
-    end
+        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)
 
-    def visit_equality_expression(node)
-      checkpoint(node.location)
+        # NOTE: Value of the lhs_var is referred at this point.  But value
+        #       reference should not be notified not to confuse sequence-point
+        #       warning detections.
+        # _notify_variable_value_referred(node, lhs_var)
+        _notify_variable_value_referred(node, rhs_var)
 
-      lhs_object = node.lhs_operand.accept(self)
-      rhs_object = node.rhs_operand.accept(self)
+        notify_multiplicative_expr_evaled(node, lhs_var, rhs_var, result_var)
 
-      execute_equality_expression(node, lhs_object, rhs_object)
-    end
+        _do_assign(node, lhs_var, result_var)
+      end
 
-    def visit_and_expression(node)
-      checkpoint(node.location)
+      def _do_add_then_assign(node, lhs_var, rhs_var)
+        lhs_conved, rhs_conved = _do_uarith_conversion(node, lhs_var, rhs_var)
 
-      lhs_object = node.lhs_operand.accept(self)
-      rhs_object = node.rhs_operand.accept(self)
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
+        result_var = create_tempvar(lhs_conved.type, lhs_val + rhs_val)
 
-      execute_and_expression(node, lhs_object, rhs_object)
-    end
+        # NOTE: Value of the lhs_var is referred at this point.  But value
+        #       reference should not be notified not to confuse sequence-point
+        #       warning detections.
+        # _notify_variable_value_referred(node, lhs_var)
+        _notify_variable_value_referred(node, rhs_var)
 
-    def visit_exclusive_or_expression(node)
-      checkpoint(node.location)
+        notify_additive_expr_evaled(node, lhs_var, rhs_var, result_var)
 
-      lhs_object = node.lhs_operand.accept(self)
-      rhs_object = node.rhs_operand.accept(self)
+        _do_assign(node, lhs_var, result_var)
+      end
 
-      execute_exclusive_or_expression(node, lhs_object, rhs_object)
-    end
+      def _do_sub_then_assign(node, lhs_var, rhs_var)
+        lhs_conved, rhs_conved = _do_uarith_conversion(node, lhs_var, rhs_var)
 
-    def visit_inclusive_or_expression(node)
-      checkpoint(node.location)
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
+        result_var = create_tempvar(lhs_conved.type, lhs_val - rhs_val)
 
-      lhs_object = node.lhs_operand.accept(self)
-      rhs_object = node.rhs_operand.accept(self)
+        # NOTE: Value of the lhs_var is referred at this point.  But value
+        #       reference should not be notified not to confuse sequence-point
+        #       warning detections.
+        # _notify_variable_value_referred(node, lhs_var)
+        _notify_variable_value_referred(node, rhs_var)
 
-      execute_inclusive_or_expression(node, lhs_object, rhs_object)
-    end
+        notify_additive_expr_evaled(node, lhs_var, rhs_var, result_var)
 
-    def visit_logical_and_expression(node)
-      checkpoint(node.location)
+        _do_assign(node, lhs_var, result_var)
+      end
 
-      lhs_object = node.lhs_operand.accept(self)
-      return temporary_variable(int_type) unless lhs_object.variable?
+      def _do_shl_then_assign(node, lhs_var, rhs_var)
+        # NOTE: The ISO C99 standard says;
+        #
+        # 6.5.7 Bitwise shift operators
+        #
+        # 3 The integer promotions are performed on each of the operands.  The
+        #   type of the result is that of the promoted left operand.  If the
+        #   value of the right operand is negative or is greater than or equal
+        #   to the width of the promoted left operand, the behavior is
+        #   undefined.
+        lhs_conved, rhs_conved = _do_integer_promotions(node, lhs_var, rhs_var)
 
-      lhs_variable = lhs_object
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
+        result_var = create_tempvar(lhs_conved.type, lhs_val << rhs_val)
 
-      # NOTE: The ISO C99 standard saids;
-      #
-      # 6.5.13 Logical AND operator
-      #
-      # Semantics
-      #
-      # 4 Unlike the bitwise binary & operator, the && operator guarantees
-      #   left-to-right evaluation; there is a sequence point after the
-      #   evaluation of the first operand.  If the first operand compares equal
-      #   to 0, the second operand is not evaluated.
-      notify_sequence_point_reached(SequencePoint.new(node.lhs_operand))
+        # NOTE: Value of the lhs_var is referred at this point.  But value
+        #       reference should not be notified not to confuse sequence-point
+        #       warning detections.
+        # _notify_variable_value_referred(node, lhs_var)
+        _notify_variable_value_referred(node, rhs_var)
 
-      if lhs_variable.value.scalar? && lhs_variable.value.must_be_false?
-        # NOTE: Doing the short-circuit evaluation.
-        notify_variable_value_referred(node, lhs_variable)
-        return temporary_variable(int_type, ScalarValue.of_false)
+        notify_shift_expr_evaled(node, lhs_var, rhs_var, result_var)
+
+        _do_assign(node, lhs_var, result_var)
       end
 
-      rhs_object = node.rhs_operand.accept(self)
-      return temporary_variable(int_type) unless rhs_object.variable?
+      def _do_shr_then_assign(node, lhs_var, rhs_var)
+        # NOTE: The ISO C99 standard says;
+        #
+        # 6.5.7 Bitwise shift operators
+        #
+        # 3 The integer promotions are performed on each of the operands.  The
+        #   type of the result is that of the promoted left operand.  If the
+        #   value of the right operand is negative or is greater than or equal
+        #   to the width of the promoted left operand, the behavior is
+        #   undefined.
+        lhs_conved, rhs_conved = _do_integer_promotions(node, lhs_var, rhs_var)
 
-      rhs_variable = rhs_object
-      notify_sequence_point_reached(SequencePoint.new(node.rhs_operand))
-      notify_variable_value_referred(node, lhs_variable)
-      notify_variable_value_referred(node, rhs_variable)
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
+        result_var = create_tempvar(lhs_conved.type, lhs_val >> rhs_val)
 
-      if lhs_variable.value.scalar? && rhs_variable.value.scalar?
-        # NOTE: No usual-arithmetic-conversion.
-        result = temporary_variable(
-          int_type, lhs_variable.value.logical_and(rhs_variable.value))
-      else
-        result = temporary_variable(int_type)
+        # NOTE: Value of the lhs_var is referred at this point.  But value
+        #       reference should not be notified not to confuse sequence-point
+        #       warning detections.
+        # _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)
+
+        _do_assign(node, lhs_var, result_var)
       end
 
-      notify_logical_and_expr_evaled(node, lhs_variable, rhs_variable, result)
-      result
-    end
+      def _do_and_then_assign(node, lhs_var, rhs_var)
+        lhs_conved, rhs_conved = _do_uarith_conversion(node, lhs_var, rhs_var)
 
-    def visit_logical_or_expression(node)
-      checkpoint(node.location)
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
+        result_var = create_tempvar(lhs_conved.type, lhs_val & rhs_val)
 
-      lhs_object = node.lhs_operand.accept(self)
-      return temporary_variable(int_type) unless lhs_object.variable?
+        # NOTE: Value of the lhs_var is referred at this point.  But value
+        #       reference should not be notified not to confuse sequence-point
+        #       warning detections.
+        # _notify_variable_value_referred(node, lhs_var)
+        _notify_variable_value_referred(node, rhs_var)
 
-      lhs_variable = lhs_object
+        notify_and_expr_evaled(node, lhs_var, rhs_var, result_var)
 
-      # NOTE: The ISO C99 standard saids;
-      #
-      # 6.5.14 Logical OR operator
-      #
-      # Semantics
-      #
-      # 4 Unlike the bitwise | operator, the || operator guarantees
-      #   left-to-right evaluation; there is a sequence point after the
-      #   evaluation of the first operand.  If the first operand compares
-      #   unequal to 0, the second operand is not evaluated.
-      notify_sequence_point_reached(SequencePoint.new(node.lhs_operand))
+        _do_assign(node, lhs_var, result_var)
+      end
 
-      if lhs_variable.value.scalar? && lhs_variable.value.must_be_true?
-        # NOTE: Doing the short-circuit evaluation.
-        notify_variable_value_referred(node, lhs_variable)
-        return temporary_variable(int_type, ScalarValue.of_true)
+      def _do_xor_then_assign(node, lhs_var, rhs_var)
+        lhs_conved, rhs_conved = _do_uarith_conversion(node, lhs_var, rhs_var)
+
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
+        result_var = create_tempvar(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
+        #       warning detections.
+        # _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)
+
+        _do_assign(node, lhs_var, result_var)
       end
 
-      rhs_object = node.rhs_operand.accept(self)
-      return temporary_variable(int_type) unless rhs_object.variable?
+      def _do_ior_then_assign(node, lhs_var, rhs_var)
+        lhs_conved, rhs_conved = _do_uarith_conversion(node, lhs_var, rhs_var)
 
-      rhs_variable = rhs_object
-      notify_sequence_point_reached(SequencePoint.new(node.rhs_operand))
-      notify_variable_value_referred(node, lhs_variable)
-      notify_variable_value_referred(node, rhs_variable)
+        lhs_val = lhs_conved.value
+        rhs_val = rhs_conved.value
+        result_var = create_tempvar(lhs_conved.type, lhs_val | rhs_val)
 
-      if lhs_variable.value.scalar? && rhs_variable.value.scalar?
-        # NOTE: No usual-arithmetic-conversion.
-        result = temporary_variable(
-          int_type, lhs_variable.value.logical_or(rhs_variable.value))
-      else
-        result = temporary_variable(int_type)
+        # NOTE: Value of the lhs_var is referred at this point.  But value
+        #       reference should not be notified not to confuse sequence-point
+        #       warning detections.
+        # _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)
+
+        _do_assign(node, lhs_var, result_var)
       end
 
-      notify_logical_or_expr_evaled(node, lhs_variable, rhs_variable, result)
-      result
-    end
+      def _do_uarith_conversion(node, lhs_var, rhs_var)
+        lhs_conved, rhs_conved =
+          do_usual_arithmetic_conversion(lhs_var, rhs_var)
 
-    def visit_simple_assignment_expression(node)
-      checkpoint(node.location)
+        unless lhs_conved == lhs_var
+          notify_implicit_conv_performed(node.lhs_operand, lhs_var, lhs_conved)
+        end
+        unless rhs_conved == rhs_var
+          notify_implicit_conv_performed(node.rhs_operand, rhs_var, rhs_conved)
+        end
 
-      lhs_object = node.lhs_operand.accept(self)
-      rhs_object = node.rhs_operand.accept(self)
+        return lhs_conved, rhs_conved
+      end
 
-      execute_simple_assignment_expression(node, lhs_object, rhs_object)
-    end
+      def _do_integer_promotions(node, lhs_var, rhs_var)
+        lhs_conved = do_integer_promotion(lhs_var)
+        unless lhs_conved == lhs_var
+          notify_implicit_conv_performed(node.lhs_operand, lhs_var, lhs_conved)
+        end
 
-    def visit_compound_assignment_expression(node)
-      checkpoint(node.location)
+        rhs_conved = do_integer_promotion(rhs_var)
+        unless rhs_conved == rhs_var
+          notify_implicit_conv_performed(node.rhs_operand, rhs_var, rhs_conved)
+        end
+
+        return lhs_conved, rhs_conved
+      end
 
-      lhs_object = node.lhs_operand.accept(self)
-      rhs_object = node.rhs_operand.accept(self)
+      def _do_assign(node, lhs_var, result_var)
+        if result_var.type.same_as?(lhs_var.type)
+          result_conved = result_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)
+        end
 
-      execute_compound_assignment_expression(node, lhs_object, rhs_object)
-    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)
+        _notify_variable_value_updated(node, lhs_var)
 
-    def visit_comma_separated_expression(node)
-      checkpoint(node.location)
+        notify_assignment_expr_evaled(node, lhs_var, result_conved)
+      end
 
-      node.expressions.map { |expression| expression.accept(self) }.last
-    end
+      def _notify_object_referred(node, obj)
+        case obj
+        when Variable
+          interpreter.notify_variable_referred(node, obj)
+        when Function
+          interpreter.notify_function_referred(node, obj)
+        end
+      end
 
-    private
-    def eval_without_side_effect(&block)
-      originally_quiet = interpreter.quiet_without_side_effect?
-      unless originally_quiet
-        interpreter._quiet_without_side_effect = true
+      def _notify_variable_value_referred(node, obj)
+        if obj.variable?
+          interpreter.notify_variable_value_referred(node, obj)
+        end
+
+        # NOTE: When a value of the inner-variable of array or composite object
+        #       is referred, notification of the outer variable's value has
+        #       already been done in sub expressions.
       end
-      yield
-    ensure
-      unless originally_quiet
-        interpreter._quiet_without_side_effect = false
-        # FIXME: Evaluation of an object-specifier doesn't refer to value
-        #        of a variable.  Thus, no cross-reference record on a
-        #        sizeof-expression because cross-reference extraction
-        #        watches variable value reference not variable reference.
-        # collect_object_specifiers(node).each { |os| os.accept(self) }
+
+      def _notify_variable_value_updated(node, obj)
+        if obj.variable?
+          interpreter.notify_variable_value_updated(node, obj)
+          if obj.inner?
+            # NOTE: When a value of the inner-variable of array or composite
+            #       object is updated, the outer variable's value should also
+            #       be notified to be updated.
+            _notify_variable_value_updated(node, obj.owner)
+          end
+        end
       end
     end
+
+    include Impl
   end
 
 end