adlint 1.0.0

data/lib/adlint/c/interp.rb

@@ -0,0 +1,1740 @@
+# Kernel of the abstract interpreter of C language.
+#
+# Author::    Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+# Copyright:: Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+# License::   GPLv3+: GNU General Public License version 3 or later
+#
+# Owner::     Yutaka Yanoh <mailto:yanoh@users.sourceforge.net>
+
+#--
+#     ___    ____  __    ___   _________
+#    /   |  / _  |/ /   / / | / /__  __/           Source Code Static Analyzer
+#   / /| | / / / / /   / /  |/ /  / /                   AdLint - Advanced Lint
+#  / __  |/ /_/ / /___/ / /|  /  / /
+# /_/  |_|_____/_____/_/_/ |_/  /_/   Copyright (C) 2010-2012, OGIS-RI Co.,Ltd.
+#
+# This file is part of AdLint.
+#
+# AdLint is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# AdLint is distributed in the hope that it will be useful, but WITHOUT ANY
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+# A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# AdLint.  If not, see <http://www.gnu.org/licenses/>.
+#
+#++
+
+require "adlint/monitor"
+require "adlint/c/environ"
+require "adlint/c/resolver"
+require "adlint/c/mediator"
+require "adlint/c/syntax"
+require "adlint/c/expr"
+require "adlint/c/conv"
+require "adlint/c/util"
+
+module AdLint #:nodoc:
+module C #:nodoc:
+
+  class Interpreter
+    include InterpreterMediator
+    include Conversion
+
+    def initialize(type_table)
+      type_table = type_table
+      @environment = Environment.new(type_table)
+      @type_resolver = DynamicTypeResolver.new(type_table, self)
+
+      @sub_interpreters = [
+        TranslationUnitInterpreter.new(self),
+        DeclarationInterpreter.new(self),
+        ParameterDefinitionInterpreter.new(self),
+        FunctionInterpreter.new(self),
+        SwitchStatementInterpreter.new(self),
+        StatementInterpreter.new(self),
+        ExpressionInterpreter.new(self)
+      ]
+
+      @suppress_notification = false
+    end
+
+    attr_reader :environment
+    attr_reader :type_resolver
+
+    extend Pluggable
+
+    # NOTE: Notified when the interpreter evaluates an initializer of
+    #       variable-definition.
+    def_plugin :on_variable_initialized
+
+    # NOTE: Notified when the interpreter evaluates a variable-definition.
+    def_plugin :on_variable_defined
+
+    # NOTE: Notified when the interpreter evaluates a function-declaration.
+    def_plugin :on_function_declared
+
+    # NOTE: Notified when the interpreter evaluates a variable-declaration.
+    def_plugin :on_variable_declared
+
+    # NOTE: Notified when the interpreter evaluates a struct-type-declaration.
+    def_plugin :on_struct_declared
+
+    # NOTE: Notified when the interpreter evaluates a union-type-declaration.
+    def_plugin :on_union_declared
+
+    # NOTE: Notified when the interpreter evaluates a enum-type-declaration.
+    def_plugin :on_enum_declared
+
+    # NOTE: Notified when the interpreter evaluates a typedef-declaration.
+    def_plugin :on_typedef_declared
+
+    # NOTE: Notified when the interpreter starts execution of a
+    #       function-definition.
+    def_plugin :on_function_started
+
+    # NOTE: Notified when the interpreter ends execution of a
+    #       function-definition.
+    def_plugin :on_function_ended
+
+    # NOTE: Notified when the interpreter evaluates a parameter-definition at
+    #       beginning of execution of a function-definition.
+    def_plugin :on_parameter_defined
+
+    # NOTE: Notified when the interpreter evaluates an expression which results
+    #       a named variable.
+    def_plugin :on_variable_referred
+
+    # NOTE: Notified when the interpreter evaluates an expression which results
+    #       a constant temporary variable.
+    def_plugin :on_constant_referred
+
+    # NOTE: Notified when the interpreter refer to a value of a variable while
+    #       evaluating an expression.
+    def_plugin :on_variable_value_referred
+
+    # NOTE: Notified when the interpreter overwrite a value of a variable while
+    #       evaluating an expression.
+    def_plugin :on_variable_value_updated
+
+    # NOTE: Notified when the interpreter refer to a function object while
+    #       evaluating an expression.
+    def_plugin :on_function_referred
+
+    # NOTE: Notified when the interpreter evaluates a sizeof-expression.
+    def_plugin :on_sizeof_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a sizeof-type-expression.
+    def_plugin :on_sizeof_type_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a cast-expression.
+    def_plugin :on_explicit_conv_performed
+
+    # NOTE: Notified when the interpreter performs an implicit type conversion
+    #       while evaluating an expression.
+    def_plugin :on_implicit_conv_performed
+
+    # NOTE: Notified when the interpreter evaluates an
+    #       array-subscript-expression.
+    def_plugin :on_array_subscript_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a function-call-expression.
+    def_plugin :on_function_call_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates an
+    #       unary-arithmetic-expression.
+    def_plugin :on_unary_arithmetic_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a
+    #       multiplicative-expression.
+    def_plugin :on_multiplicative_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates an additive-expression.
+    def_plugin :on_additive_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a shift-expression.
+    def_plugin :on_shift_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a relational-expression.
+    def_plugin :on_relational_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates an equality-expression.
+    def_plugin :on_equality_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a bitwise and-expression.
+    def_plugin :on_and_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates an exclusive-or-expression.
+    def_plugin :on_exclusive_or_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a bitwise
+    #       inclusive-or-expression.
+    def_plugin :on_inclusive_or_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a logical-and-expression.
+    def_plugin :on_logical_and_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a logical-or-expression.
+    def_plugin :on_logical_or_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a conditional-expression.
+    def_plugin :on_conditional_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates an indirection-expression.
+    def_plugin :on_indirection_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a
+    #       member-access-by-value-expression or a
+    #       member-access-by-pointer-expression.
+    def_plugin :on_member_access_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a
+    #       prefix-increment-expression.
+    def_plugin :on_prefix_increment_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a
+    #       postfix-increment-expression.
+    def_plugin :on_postfix_increment_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a
+    #       prefix-decrement-expression.
+    def_plugin :on_prefix_decrement_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a
+    #       postfix-decrement-expression.
+    def_plugin :on_postfix_decrement_expr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a
+    #       simple-assignment-expression or a compound-assignment-expression.
+    def_plugin :on_assignment_expr_evaled
+
+    # NOTE: Notified when the interpreter starts execution of a
+    #       while-statement.
+    def_plugin :on_while_stmt_started
+
+    # NOTE: Notified when the interpreter ends execution of a while-statement.
+    def_plugin :on_while_stmt_ended
+
+    # NOTE: Notified when the interpreter starts execution of a do-statement.
+    def_plugin :on_do_stmt_started
+
+    # NOTE: Notified when the interpreter ends execution of a do-statement.
+    def_plugin :on_do_stmt_ended
+
+    # NOTE: Notified when the interpreter starts execution of a for-statement.
+    def_plugin :on_for_stmt_started
+
+    # NOTE: Notified when the interpreter ends execution of a for-statement.
+    def_plugin :on_for_stmt_ended
+
+    # NOTE: Notified when the interpreter starts execution of a
+    #       c99-for-statement.
+    def_plugin :on_c99_for_stmt_started
+
+    # NOTE: Notified when the interpreter ends execution of a
+    #       c99-for-statement.
+    def_plugin :on_c99_for_stmt_ended
+
+    # NOTE: Notified when the interpreter evaluates a goto-statement.
+    def_plugin :on_goto_stmt_evaled
+
+    # NOTE: Notified when the interpreter evaluates a return-statement.
+    def_plugin :on_return_stmt_evaled
+
+    # NOTE: Notified when the interpreter evaluates a controlling expression of
+    #       the if-statement.
+    def_plugin :on_if_ctrlexpr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a controlling expression of
+    #       the if-else-statement.
+    def_plugin :on_if_else_ctrlexpr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a controlling expression of
+    #       the while-statement.
+    def_plugin :on_while_ctrlexpr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a controlling expression of
+    #       the do-statement.
+    def_plugin :on_do_ctrlexpr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a controlling expression of
+    #       the for-statement.
+    def_plugin :on_for_ctrlexpr_evaled
+
+    # NOTE: Notified when the interpreter evaluates a controlling expression of
+    #       the c99-for-statement.
+    def_plugin :on_c99_for_ctrlexpr_evaled
+
+    # NOTE: Notified when the interpreter defines a generic-label.
+    def_plugin :on_label_defined
+
+    # NOTE: Notified when the interpreter starts execution of a
+    #       compound-statement.
+    def_plugin :on_block_started
+
+    # NOTE: Notified when the interpreter ends execution of a
+    #       compound-statement.
+    def_plugin :on_block_ended
+
+    # NOTE: Notified when the interpreter forks execution paths of a
+    #       function-definition.
+    def_plugin :on_branch_started
+
+    # NOTE: Notified when the interpreter joins execution paths of a
+    #       function-definition.
+    def_plugin :on_branch_ended
+
+    # NOTE: Notified when the interpreter starts execution of a
+    #       translation-unit.
+    def_plugin :on_translation_unit_started
+
+    # NOTE: Notified when the interpreter ends execution of a translation-unit.
+    def_plugin :on_translation_unit_ended
+
+    def execute(node, *options)
+      if options.include?(:suppress_notification)
+        @suppress_notification = true
+      end
+
+      node.accept(interpreter_for(node))
+
+    ensure
+      if options.include?(:suppress_notification)
+        @suppress_notification = false
+      end
+    end
+
+    def object_to_variable(object)
+      case
+      when object.function?
+        temporary_variable(pointer_type(object.type), pointer_value_of(object))
+      when object.type.array?
+        temporary_variable(pointer_type(object.type.base_type),
+                           pointer_value_of(object))
+      else
+        object
+      end
+    end
+
+    def value_of(object)
+      if object.type.array? || object.type.function?
+        pointer_value_of(object)
+      else
+        object.value.to_single_value
+      end
+    end
+
+    def pointer_value_of(object)
+      ScalarValue.of(object.binding.memory.address)
+    end
+
+    def notify_variable_initialized(variable_definition,
+                                    variable, init_variable)
+      unless @suppress_notification
+        on_variable_initialized.invoke(variable_definition,
+                                       variable, init_variable)
+      end
+    end
+
+    def notify_variable_defined(variable_definition, variable)
+      unless @suppress_notification
+        on_variable_defined.invoke(variable_definition, variable)
+      end
+    end
+
+    def notify_function_declared(function_declaration, function)
+      unless @suppress_notification
+        on_function_declared.invoke(function_declaration, function)
+      end
+    end
+
+    def notify_variable_declared(variable_declaration, variable)
+      unless @suppress_notification
+        on_variable_declared.invoke(variable_declaration, variable)
+      end
+    end
+
+    def notify_struct_declared(struct_type_declaration)
+      unless @suppress_notification
+        on_struct_declared.invoke(struct_type_declaration)
+      end
+    end
+
+    def notify_union_declared(union_type_declaration)
+      unless @suppress_notification
+        on_union_declared.invoke(union_type_declaration)
+      end
+    end
+
+    def notify_enum_declared(enum_type_declaration)
+      unless @suppress_notification
+        on_enum_declared.invoke(enum_type_declaration)
+      end
+    end
+
+    def notify_typedef_declared(typedef_declaration)
+      unless @suppress_notification
+        on_typedef_declared.invoke(typedef_declaration)
+      end
+    end
+
+    def notify_function_started(function_definition)
+      unless @suppress_notification
+        on_function_started.invoke(function_definition)
+      end
+    end
+
+    def notify_function_ended(function_definition)
+      unless @suppress_notification
+        on_function_ended.invoke(function_definition)
+      end
+    end
+
+    def notify_parameter_defined(parameter_definition, variable)
+      unless @suppress_notification
+        on_parameter_defined.invoke(parameter_definition, variable)
+      end
+    end
+
+    def notify_variable_referred(object_specifier, variable)
+      unless @suppress_notification
+        on_variable_referred.invoke(object_specifier, variable)
+      end
+    end
+
+    def notify_constant_referred(constant_specifier, variable)
+      unless @suppress_notification
+        on_constant_referred.invoke(constant_specifier, variable)
+      end
+    end
+
+    def notify_variable_value_referred(expression, variable)
+      unless @suppress_notification
+        on_variable_value_referred.invoke(expression, variable)
+      end
+    end
+
+    def notify_variable_value_updated(expression, variable)
+      unless @suppress_notification
+        on_variable_value_updated.invoke(expression, variable)
+      end
+    end
+
+    def notify_function_referred(expression, function)
+      unless @suppress_notification
+        on_function_referred.invoke(expression, function)
+      end
+    end
+
+    def notify_sizeof_expr_evaled(expression,
+                                  operand_variable, result_variable)
+      unless @suppress_notification
+        on_sizeof_expr_evaled.invoke(expression,
+                                     operand_variable, result_variable)
+      end
+    end
+
+    def notify_sizeof_type_expr_evaled(expression, type, result_variable)
+      unless @suppress_notification
+        on_sizeof_type_expr_evaled.invoke(expression, type, result_variable)
+      end
+    end
+
+    def notify_explicit_conv_performed(expression,
+                                       original_variable, result_variable)
+      unless @suppress_notification
+        on_explicit_conv_performed.invoke(expression,
+                                          original_variable, result_variable)
+      end
+    end
+
+    def notify_implicit_conv_performed(initializer_or_expression,
+                                       original_variable, result_variable)
+      unless @suppress_notification
+        on_implicit_conv_performed.invoke(initializer_or_expression,
+                                          original_variable, result_variable)
+      end
+    end
+
+    def notify_array_subscript_expr_evaled(array_subscript_expression,
+                                           array_or_pointer_variable,
+                                           subscript_variable,
+                                           array_variable, result_variable)
+      unless @suppress_notification
+        on_array_subscript_expr_evaled.invoke(array_subscript_expression,
+                                              array_or_pointer_variable,
+                                              subscript_variable,
+                                              array_variable, result_variable)
+      end
+    end
+
+    def notify_function_call_expr_evaled(function_call_expression, function,
+                                         arg_variables, result_variable)
+      unless @suppress_notification
+        on_function_call_expr_evaled.invoke(function_call_expression, function,
+                                            arg_variables, result_variable)
+      end
+    end
+
+    def notify_unary_arithmetic_expr_evaled(unary_arithmetic_expression,
+                                            operand_variable, result_variable)
+      unless @suppress_notification
+        on_unary_arithmetic_expr_evaled.invoke(unary_arithmetic_expression,
+                                               operand_variable,
+                                               result_variable)
+      end
+    end
+
+    def notify_multiplicative_expr_evaled(multiplicative_expression,
+                                          lhs_variable, rhs_variable,
+                                          result_variable)
+      unless @suppress_notification
+        on_multiplicative_expr_evaled.invoke(multiplicative_expression,
+                                             lhs_variable, rhs_variable,
+                                             result_variable)
+      end
+    end
+
+    def notify_additive_expr_evaled(additive_expression,
+                                    lhs_variable, rhs_variable,
+                                    result_variable)
+      unless @suppress_notification
+        on_additive_expr_evaled.invoke(additive_expression,
+                                       lhs_variable, rhs_variable,
+                                       result_variable)
+      end
+    end
+
+    def notify_shift_expr_evaled(shift_expression,
+                                 lhs_variable, rhs_variable, result_variable)
+      unless @suppress_notification
+        on_shift_expr_evaled.invoke(shift_expression,
+                                    lhs_variable, rhs_variable,
+                                    result_variable)
+      end
+    end
+
+    def notify_relational_expr_evaled(relational_expression,
+                                      lhs_variable, rhs_variable,
+                                      result_variable)
+      unless @suppress_notification
+        on_relational_expr_evaled.invoke(relational_expression,
+                                         lhs_variable, rhs_variable,
+                                         result_variable)
+      end
+    end
+
+    def notify_equality_expr_evaled(equality_expression,
+                                    lhs_variable, rhs_variable,
+                                    result_variable)
+      unless @suppress_notification
+        on_equality_expr_evaled.invoke(equality_expression,
+                                       lhs_variable, rhs_variable,
+                                       result_variable)
+      end
+    end
+
+    def notify_and_expr_evaled(and_expression,
+                               lhs_variable, rhs_variable, result_variable)
+      unless @suppress_notification
+        on_and_expr_evaled.invoke(and_expression,
+                                  lhs_variable, rhs_variable, result_variable)
+      end
+    end
+
+    def notify_exclusive_or_expr_evaled(exclusive_or_expression,
+                                        lhs_variable, rhs_variable,
+                                        result_variable)
+      unless @suppress_notification
+        on_exclusive_or_expr_evaled.invoke(exclusive_or_expression,
+                                           lhs_variable, rhs_variable,
+                                           result_variable)
+      end
+    end
+
+    def notify_inclusive_or_expr_evaled(inclusive_or_expression,
+                                        lhs_variable, rhs_variable,
+                                        result_variable)
+      unless @suppress_notification
+        on_inclusive_or_expr_evaled.invoke(inclusive_or_expression,
+                                           lhs_variable, rhs_variable,
+                                           result_variable)
+      end
+    end
+
+    def notify_logical_and_expr_evaled(logical_and_expression,
+                                       lhs_variable, rhs_variable,
+                                       result_variable)
+      unless @suppress_notification
+        on_logical_and_expr_evaled.invoke(logical_and_expression,
+                                          lhs_variable, rhs_variable,
+                                          result_variable)
+      end
+    end
+
+    def notify_logical_or_expr_evaled(logical_or_expression,
+                                      lhs_variable, rhs_variable,
+                                      result_variable)
+      unless @suppress_notification
+        on_logical_or_expr_evaled.invoke(logical_or_expression,
+                                         lhs_variable, rhs_variable,
+                                         result_variable)
+      end
+    end
+
+    def notify_conditional_expr_evaled(conditional_expression,
+                                       condition_variable, result_variable)
+      unless @suppress_notification
+        on_conditional_expr_evaled.invoke(conditional_expression,
+                                          condition_variable, result_variable)
+      end
+    end
+
+    def notify_indirection_expr_evaled(indirection_expression,
+                                       pointer_variable, dereferenced_variable)
+      unless @suppress_notification
+        on_indirection_expr_evaled.invoke(indirection_expression,
+                                          pointer_variable,
+                                          dereferenced_variable)
+      end
+    end
+
+    def notify_member_access_expr_evaled(member_access_expression,
+                                         outer_variable, member_variable)
+      unless @suppress_notification
+        on_member_access_expr_evaled.invoke(member_access_expression,
+                                            outer_variable, member_variable)
+      end
+    end
+
+    def notify_prefix_increment_expr_evaled(prefix_increment_expression,
+                                            operand_variable, original_value)
+      unless @suppress_notification
+        on_prefix_increment_expr_evaled.invoke(prefix_increment_expression,
+                                               operand_variable,
+                                               original_value)
+      end
+    end
+
+    def notify_postfix_increment_expr_evaled(postfix_increment_expression,
+                                             operand_variable, result_variable)
+      unless @suppress_notification
+        on_postfix_increment_expr_evaled.invoke(postfix_increment_expression,
+                                                operand_variable,
+                                                result_variable)
+      end
+    end
+
+    def notify_prefix_decrement_expr_evaled(prefix_decrement_expression,
+                                            operand_variable, original_value)
+      unless @suppress_notification
+        on_prefix_decrement_expr_evaled.invoke(prefix_decrement_expression,
+                                               operand_variable,
+                                               original_value)
+      end
+    end
+
+    def notify_postfix_decrement_expr_evaled(postfix_decrement_expression,
+                                             operand_variable, result_variable)
+      unless @suppress_notification
+        on_postfix_decrement_expr_evaled.invoke(postfix_decrement_expression,
+                                                operand_variable,
+                                                result_variable)
+      end
+    end
+
+    def notify_assignment_expr_evaled(assignment_expression,
+                                      lhs_variable, rhs_variable)
+      unless @suppress_notification
+        on_assignment_expr_evaled.invoke(assignment_expression,
+                                         lhs_variable, rhs_variable)
+      end
+    end
+
+    def notify_while_stmt_started(while_statement)
+      unless @suppress_notification
+        on_while_stmt_started.invoke(while_statement)
+      end
+    end
+
+    def notify_while_stmt_ended(while_statement)
+      unless @suppress_notification
+        on_while_stmt_ended.invoke(while_statement)
+      end
+    end
+
+    def notify_do_stmt_started(do_statement)
+      unless @suppress_notification
+        on_do_stmt_started.invoke(do_statement)
+      end
+    end
+
+    def notify_do_stmt_ended(do_statement)
+      unless @suppress_notification
+        on_do_stmt_ended.invoke(do_statement)
+      end
+    end
+
+    def notify_for_stmt_started(for_statement)
+      unless @suppress_notification
+        on_for_stmt_started.invoke(for_statement)
+      end
+    end
+
+    def notify_for_stmt_ended(for_statement)
+      unless @suppress_notification
+        on_for_stmt_ended.invoke(for_statement)
+      end
+    end
+
+    def notify_c99_for_stmt_started(c99_for_statement)
+      unless @suppress_notification
+        on_c99_for_stmt_started.invoke(c99_for_statement)
+      end
+    end
+
+    def notify_c99_for_stmt_ended(c99_for_statement)
+      unless @suppress_notification
+        on_c99_for_stmt_ended.invoke(c99_for_statement)
+      end
+    end
+
+    def notify_goto_stmt_evaled(goto_statement, label_name)
+      unless @suppress_notification
+        on_goto_stmt_evaled.invoke(goto_statement, label_name)
+      end
+    end
+
+    def notify_return_stmt_evaled(return_statement, result_variable)
+      unless @suppress_notification
+        on_return_stmt_evaled.invoke(return_statement, result_variable)
+      end
+    end
+
+    def notify_if_ctrlexpr_evaled(if_statement, ctrlexpr_value)
+      unless @suppress_notification
+        on_if_ctrlexpr_evaled.invoke(if_statement, ctrlexpr_value)
+      end
+    end
+
+    def notify_if_else_ctrlexpr_evaled(if_else_statement, ctrlexpr_value)
+      unless @suppress_notification
+        on_if_else_ctrlexpr_evaled.invoke(if_else_statement, ctrlexpr_value)
+      end
+    end
+
+    def notify_while_ctrlexpr_evaled(while_statement, ctrlexpr_value)
+      unless @suppress_notification
+        on_while_ctrlexpr_evaled.invoke(while_statement, ctrlexpr_value)
+      end
+    end
+
+    def notify_do_ctrlexpr_evaled(do_statement, ctrlexpr_value)
+      unless @suppress_notification
+        on_do_ctrlexpr_evaled.invoke(do_statement, ctrlexpr_value)
+      end
+    end
+
+    def notify_for_ctrlexpr_evaled(for_statement, ctrlexpr_value)
+      unless @suppress_notification
+        on_for_ctrlexpr_evaled.invoke(for_statement, ctrlexpr_value)
+      end
+    end
+
+    def notify_c99_for_ctrlexpr_evaled(c99_for_statement, ctrlexpr_value)
+      unless @suppress_notification
+        on_c99_for_ctrlexpr_evaled.invoke(c99_for_statement, ctrlexpr_value)
+      end
+    end
+
+    def notify_label_defined(generic_labeled_statement)
+      unless @suppress_notification
+        on_label_defined.invoke(generic_labeled_statement)
+      end
+    end
+
+    def notify_block_started(compound_statement)
+      unless @suppress_notification
+        on_block_started.invoke(compound_statement)
+      end
+    end
+
+    def notify_block_ended(compound_statement)
+      unless @suppress_notification
+        on_block_ended.invoke(compound_statement)
+      end
+    end
+
+    def notify_branch_started(branch)
+      unless @suppress_notification
+        on_branch_started.invoke(branch)
+      end
+    end
+
+    def notify_branch_ended(branch)
+      unless @suppress_notification
+        on_branch_ended.invoke(branch)
+      end
+    end
+
+    def notify_translation_unit_started(translation_unit)
+      unless @suppress_notification
+        on_translation_unit_started.invoke(translation_unit)
+      end
+    end
+
+    def notify_translation_unit_ended(translation_unit)
+      unless @suppress_notification
+        on_translation_unit_ended.invoke(translation_unit)
+      end
+    end
+
+    def _suppress_notification=(suppress_notification)
+      # NOTE: This method is called only from ControllingExpression.
+      @suppress_notification = suppress_notification
+    end
+
+    private
+    def interpreter_for(node)
+      @sub_interpreters.find do |interp|
+        node.kind_of?(interp.target_node_class)
+      end
+    end
+
+    def interpreter
+      # NOTE: This method is of the requirement for including
+      #       InterpreterMediator.
+      self
+    end
+  end
+
+  class SubInterpreter < SyntaxTreeVisitor
+    include InterpreterMediator
+    include NotifierMediator
+    include Conversion
+    include MonitorUtil
+
+    def initialize(owner, target_node_class)
+      @owner = owner
+      @target_node_class = target_node_class
+    end
+
+    attr_reader :target_node_class
+
+    private
+    def interpreter
+      @owner
+    end
+  end
+
+  class TranslationUnitInterpreter < SubInterpreter
+    def initialize(owner)
+      super(owner, TranslationUnit)
+    end
+
+    def visit_declaration(node)
+      checkpoint(node.location)
+
+      interpret(node)
+    end
+
+    def visit_translation_unit(node)
+      checkpoint(node.location)
+
+      notify_translation_unit_started(node)
+      super
+      notify_translation_unit_ended(node)
+    end
+
+    def visit_ansi_function_definition(node)
+      checkpoint(node.location)
+
+      interpret(node)
+    end
+
+    def visit_kandr_function_definition(node)
+      checkpoint(node.location)
+
+      interpret(node)
+    end
+  end
+
+  class DeclarationInterpreter < SubInterpreter
+    def initialize(owner)
+      super(owner, Declaration)
+    end
+
+    def visit_function_declaration(node)
+      checkpoint(node.location)
+
+      resolve_unresolved_type(node)
+
+      node.type.declarations.each do |decl|
+        decl.mark_as_referred_by(node.identifier)
+      end
+
+      function = define_explicit_function(node)
+      notify_function_declared(node, function)
+    end
+
+    def visit_variable_declaration(node)
+      checkpoint(node.location)
+
+      resolve_unresolved_type(node)
+
+      node.type.declarations.each do |decl|
+        decl.mark_as_referred_by(node.identifier)
+      end
+
+      variable = declare_variable(node)
+      notify_variable_declared(node, variable)
+    end
+
+    def visit_variable_definition(node)
+      checkpoint(node.location)
+
+      resolve_unresolved_type(node)
+
+      node.type.declarations.each do |decl|
+        decl.mark_as_referred_by(node.identifier)
+      end
+
+      if initializer = node.initializer
+        init_variable = evaluate_initializer(initializer, node.type)
+
+        if node.type.same_as?(init_variable.type)
+          converted = init_variable
+        else
+          converted =
+            do_conversion(init_variable, node.type) ||
+            temporary_variable(node.type)
+          notify_implicit_conv_performed(initializer, init_variable, converted)
+        end
+
+        variable = define_variable(node, converted.value.to_defined_value)
+        notify_variable_defined(node, variable)
+        notify_variable_initialized(node, variable, init_variable)
+      else
+        variable = define_variable(node)
+        notify_variable_defined(node, variable)
+      end
+    end
+
+    def visit_struct_type_declaration(node)
+      checkpoint(node.location)
+
+      resolve_unresolved_type(node)
+
+      notify_struct_declared(node)
+    end
+
+    def visit_union_type_declaration(node)
+      checkpoint(node.location)
+
+      resolve_unresolved_type(node)
+
+      notify_union_declared(node)
+    end
+
+    def visit_enum_type_declaration(node)
+      checkpoint(node)
+
+      if enumerators = node.enum_specifier.enumerators
+        sequence = 0
+        enumerators.each do |enumerator|
+          if expression = enumerator.expression
+            object = interpret(expression)
+            if object.variable? && object.value.scalar?
+              enumerator.value = object.value.unique_sample
+            end
+          end
+          enumerator.value ||= sequence
+          define_enumerator(enumerator)
+          sequence = enumerator.value + 1
+        end
+      end
+
+      notify_enum_declared(node)
+    end
+
+    def visit_typedef_declaration(node)
+      checkpoint(node.location)
+
+      resolve_unresolved_type(node)
+
+      node.type.real_type.declarations.each do |decl|
+        decl.mark_as_referred_by(node.identifier)
+      end
+
+      notify_typedef_declared(node)
+
+      Analyzer.current.info("user type `#{node.identifier.value}' " +
+                            "defined at #{node.location.to_s}.")
+    end
+
+    private
+    def evaluate_initializer(initializer, variable_type)
+      init_interp = InitializerInterpreter.new(interpreter)
+      object = init_interp.execute(initializer, variable_type)
+
+      case
+      when variable_type.pointer? && object.type.array?
+        init_variable = temporary_variable(variable_type,
+                                           pointer_value_of(object))
+        notify_implicit_conv_performed(initializer, object, init_variable)
+      when variable_type.pointer? && object.type.function?
+        init_variable = temporary_variable(variable_type,
+                                           pointer_value_of(object))
+        notify_implicit_conv_performed(initializer, object, init_variable)
+      when variable_type.array? && object.type.pointer?
+        unless init_variable = pointee_of(object) and init_variable.type.array?
+          init_variable = temporary_variable(variable_type)
+        end
+        deduct_array_length_from_array_variable(variable_type, init_variable)
+      when object.function?
+        init_variable = temporary_variable(variable_type)
+      else
+        init_variable = object
+      end
+
+      init_variable
+    end
+
+    def deduct_array_length_from_array_variable(variable_type, array_variable)
+      variable_type.length ||= array_variable.type.length
+    end
+  end
+
+  class InitializerInterpreter
+    include InterpreterMediator
+    include MonitorUtil
+
+    def initialize(interpreter)
+      @interpreter = interpreter
+    end
+
+    def execute(initializer, variable_type)
+      checkpoint(initializer.location)
+
+      case
+      when expression = initializer.expression
+        evaluate_expression(expression)
+      when initializers = initializer.initializers
+        evaluate_initializers(initializers, variable_type)
+      else
+        temporary_variable(variable_type)
+      end
+    end
+
+    private
+    def evaluate_expression(expression)
+      checkpoint(expression.location)
+
+      object_to_variable(interpret(expression))
+    end
+
+    def evaluate_initializers(initializers, variable_type)
+      case
+      when variable_type.array?
+        deduct_array_length_from_initializers(variable_type, initializers)
+        member_types = [variable_type.base_type] * variable_type.impl_length
+      when variable_type.composite?
+        member_types = variable_type.members.map { |member| member.type }
+      else
+        member_types = [variable_type]
+      end
+
+      values = member_types.zip(initializers).map { |type, initializer|
+        if initializer
+          checkpoint(initializer.location)
+          case
+          when expression = initializer.expression
+            value_of(evaluate_expression(expression))
+          when initializers = initializer.initializers
+            value_of(evaluate_initializers(initializers, type))
+          else
+            type.undefined_value
+          end
+        else
+          type.undefined_value
+        end
+      }
+
+      case
+      when variable_type.array?
+        temporary_variable(variable_type, ArrayValue.new(values))
+      when variable_type.composite?
+        temporary_variable(variable_type, CompositeValue.new(values))
+      else
+        temporary_variable(variable_type, values.first)
+      end
+    end
+
+    def deduct_array_length_from_initializers(variable_type, initializers)
+      variable_type.length ||= initializers.size
+    end
+
+    def interpreter
+      # NOTE: This is private attr_reader for InterpreterMediator.
+      #       This attribute is read via a normal method to suppress
+      #       `private attribute?' warning.
+      @interpreter
+    end
+  end
+
+  class ParameterDefinitionInterpreter < SubInterpreter
+    def initialize(owner)
+      super(owner, ParameterDefinition)
+    end
+
+    def visit_parameter_definition(node)
+      checkpoint(node.location)
+
+      resolve_unresolved_type(node)
+
+      node.type.declarations.each do |decl|
+        if identifier = node.identifier
+          decl.mark_as_referred_by(identifier)
+        else
+          decl.mark_as_referred_by(node.head_token)
+        end
+      end
+
+      if node.identifier
+        variable = define_variable(node.to_variable_definition,
+                                   node.type.parameter_value)
+        notify_parameter_defined(node, variable)
+      end
+    end
+  end
+
+  class FunctionInterpreter < SubInterpreter
+    def initialize(owner)
+      super(owner, FunctionDefinition)
+    end
+
+    def visit_ansi_function_definition(node)
+      interpret_function(node)
+    end
+
+    def visit_kandr_function_definition(node)
+      interpret_function(node)
+    end
+
+    private
+    def interpret_function(node)
+      checkpoint(node.location)
+
+      reset_environment
+      resolve_unresolved_type(node)
+
+      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
+        function.declarations_and_definitions.push(node)
+      else
+        function = define_explicit_function(node)
+      end
+
+      scoped_eval do
+        notify_function_started(node)
+        notify_block_started(node.function_body)
+
+        node.parameter_definitions.each { |pdef| interpret(pdef) }
+
+        BreakEvent.catch do
+          node.function_body.block_items.each { |item| interpret(item) }
+        end
+
+        notify_block_ended(node.function_body)
+        notify_function_ended(node)
+      end
+    end
+  end
+
+  class StatementInterpreter < SubInterpreter
+    include BranchGroup::Option
+    include Branch::Option
+    include SyntaxNodeCollector
+
+    def initialize(owner)
+      super(owner, Statement)
+    end
+
+    def visit_generic_labeled_statement(node)
+      checkpoint(node.location)
+
+      node.executed = true
+      notify_label_defined(node)
+
+      uninitialize_block_local_variables(node)
+      interpret(node.statement)
+    end
+
+    def visit_case_labeled_statement(node)
+      checkpoint(node.location)
+
+      node.executed = true
+      interpret(node.statement)
+    end
+
+    def visit_default_labeled_statement(node)
+      checkpoint(node.location)
+
+      node.executed = true
+      interpret(node.statement)
+    end
+
+    def visit_compound_statement(node)
+      checkpoint(node.location)
+
+      node.executed = true
+      scoped_eval do
+        begin
+          notify_block_started(node)
+          node.block_items.each { |block_item| interpret(block_item) }
+        ensure
+          notify_block_ended(node)
+        end
+      end
+    end
+
+    def visit_expression_statement(node)
+      checkpoint(node.location)
+
+      node.executed = true
+      interpret(node.expression) if node.expression
+    end
+
+    def visit_if_statement(node)
+      checkpoint(node.location)
+
+      node.executed = true
+      ctrlexpr = node.expression
+      ctrlexpr_value = value_of(interpret(ctrlexpr, :suppress_notification))
+      notify_if_ctrlexpr_evaled(node, ctrlexpr_value)
+
+      case
+      when ctrlexpr_value.must_be_true?
+        branched_eval(ctrlexpr, NARROWING, FINAL, COMPLETE) do
+          interpret(node.statement)
+        end
+      when ctrlexpr_value.may_be_true?
+        branched_eval(ctrlexpr, NARROWING, FINAL) do
+          interpret(node.statement)
+        end
+      else
+        # NOTE: To warn about the controlling expression and to end the current
+        #       branch group of else-if sequence.
+        branched_eval(nil, NARROWING, FINAL) do
+          interpret(ctrlexpr)
+        end
+      end
+    end
+
+    def visit_if_else_statement(node)
+      checkpoint(node.location)
+
+      node.executed = true
+      ctrlexpr = node.expression
+      ctrlexpr_value = value_of(interpret(ctrlexpr, :suppress_notification))
+      notify_if_else_ctrlexpr_evaled(node, ctrlexpr_value)
+
+      case
+      when ctrlexpr_value.must_be_true?
+        branched_eval(ctrlexpr, NARROWING, FINAL, COMPLETE) do
+          interpret(node.then_statement)
+        end
+        return
+      when ctrlexpr_value.may_be_true?
+        branched_eval(ctrlexpr, NARROWING) do
+          interpret(node.then_statement)
+        end
+      else
+        # NOTE: To warn about the controlling expression.
+        interpret(ctrlexpr)
+      end
+
+      case node.else_statement
+      when IfStatement, IfElseStatement
+        interpret(node.else_statement)
+      else
+        branched_eval(nil, NARROWING, FINAL, COMPLETE) do
+          interpret(node.else_statement)
+        end
+      end
+    end
+
+    def visit_while_statement(node)
+      checkpoint(node.location)
+
+      node.executed = true
+      notify_while_stmt_started(node)
+
+      widen_varying_variable_value_domain(node)
+      effective_ctrlexpr = deduct_effective_controlling_expression(node)
+
+      ctrlexpr = node.expression
+      ctrlexpr_value = value_of(interpret(ctrlexpr))
+      notify_while_ctrlexpr_evaled(node, ctrlexpr_value)
+
+      case
+      when ctrlexpr_value.must_be_true?
+        branched_eval(effective_ctrlexpr,
+                      NARROWING, FINAL, IMPLICIT_CONDITION, COMPLETE) do
+          interpret(node.statement)
+        end
+      when ctrlexpr_value.may_be_true?
+        branched_eval(effective_ctrlexpr,
+                      NARROWING, FINAL, IMPLICIT_CONDITION) do
+          interpret(node.statement)
+        end
+      end
+    ensure
+      notify_while_stmt_ended(node)
+    end
+
+    def visit_do_statement(node)
+      checkpoint(node.location)
+
+      node.executed = true
+      notify_do_stmt_started(node)
+
+      widen_varying_variable_value_domain(node)
+      effective_ctrlexpr = deduct_effective_controlling_expression(node)
+
+      branched_eval(effective_ctrlexpr,
+                    NARROWING, FINAL, IMPLICIT_CONDITION, COMPLETE) do
+        interpret(node.statement)
+      end
+
+      ctrlexpr_value = value_of(interpret(node.expression))
+      notify_do_ctrlexpr_evaled(node, ctrlexpr_value)
+    ensure
+      notify_do_stmt_ended(node)
+    end
+
+    def visit_for_statement(node)
+      checkpoint(node.location)
+
+      node.executed = true
+      notify_for_stmt_started(node)
+
+      node.initial_statement.accept(self)
+
+      widen_varying_variable_value_domain(node)
+      effective_ctrlexpr = deduct_effective_controlling_expression(node)
+
+      node.condition_statement.executed = true
+      if ctrlexpr = node.condition_statement.expression
+        ctrlexpr_value = value_of(interpret(ctrlexpr))
+        notify_for_ctrlexpr_evaled(node, ctrlexpr_value)
+
+        case
+        when ctrlexpr_value.must_be_true?
+          branched_eval(effective_ctrlexpr,
+                        NARROWING, FINAL, IMPLICIT_CONDITION, COMPLETE) do
+            interpret(node.body_statement)
+            interpret(node.expression) if node.expression
+          end
+        when ctrlexpr_value.may_be_true?
+          branched_eval(effective_ctrlexpr,
+                        NARROWING, FINAL, IMPLICIT_CONDITION) do
+            interpret(node.body_statement)
+            interpret(node.expression) if node.expression
+          end
+        end
+      else
+        branched_eval(effective_ctrlexpr,
+                      NARROWING, FINAL, IMPLICIT_CONDITION, COMPLETE) do
+          interpret(node.body_statement)
+          interpret(node.expression) if node.expression
+        end
+      end
+    ensure
+      notify_for_stmt_ended(node)
+    end
+
+    def visit_c99_for_statement(node)
+      checkpoint(node.location)
+
+      scoped_eval do
+        interpret(node.declaration)
+
+        node.executed = true
+        notify_c99_for_stmt_started(node)
+
+        widen_varying_variable_value_domain(node)
+        effective_ctrlexpr = deduct_effective_controlling_expression(node)
+
+        node.condition_statement.executed = true
+        if ctrlexpr = node.condition_statement.expression
+          ctrlexpr_value = value_of(interpret(ctrlexpr))
+          notify_c99_for_ctrlexpr_evaled(node, ctrlexpr_value)
+
+          case
+          when ctrlexpr_value.must_be_true?
+            branched_eval(effective_ctrlexpr,
+                          NARROWING, FINAL, IMPLICIT_CONDITION, COMPLETE) do
+              interpret(node.body_statement)
+              interpret(node.expression) if node.expression
+            end
+          when ctrlexpr_value.may_be_true?
+            branched_eval(effective_ctrlexpr,
+                          NARROWING, FINAL, IMPLICIT_CONDITION) do
+              interpret(node.body_statement)
+              interpret(node.expression) if node.expression
+            end
+          end
+        else
+          branched_eval(effective_ctrlexpr,
+                        NARROWING, FINAL, IMPLICIT_CONDITION, COMPLETE) do
+            interpret(node.body_statement)
+            interpret(node.expression) if node.expression
+          end
+        end
+      end
+    ensure
+      notify_c99_for_stmt_ended(node)
+    end
+
+    def visit_goto_statement(node)
+      checkpoint(node.location)
+
+      # TODO: Must implement goto semantics.
+      node.executed = true
+      notify_goto_stmt_evaled(node, node.identifier.value)
+    end
+
+    def visit_continue_statement(node)
+      checkpoint(node.location)
+
+      node.executed = true
+      BreakEvent.of_continue.throw
+    end
+
+    def visit_break_statement(node)
+      checkpoint(node.location)
+
+      node.executed = true
+      BreakEvent.of_break.throw
+    end
+
+    def visit_return_statement(node)
+      checkpoint(node.location)
+
+      node.executed = true
+      return_object = node.expression ? interpret(node.expression) : nil
+      notify_return_stmt_evaled(node, return_object)
+      BreakEvent.of_return.throw
+    end
+
+    private
+    def uninitialize_block_local_variables(generic_labeled_statement)
+      related_goto_statements = generic_labeled_statement.referrers
+      return if related_goto_statements.empty?
+
+      local_variables.each do |variable|
+        variable_definition = variable.declarations_and_definitions.first
+
+        anterior_gotos = related_goto_statements.select { |goto|
+          goto.location.line_no < variable_definition.location.line_no
+        }
+
+        unless anterior_gotos.empty?
+          variable.value.begin_versioning_group
+          variable.value.begin_versioning
+          variable.uninitialize!
+          variable.value.end_versioning
+          variable.value.end_versioning_group(true)
+        end
+      end
+    end
+
+    def widen_varying_variable_value_domain(iteration_statement)
+      varying_vars = {}
+      iteration_statement.varying_variable_names.each do |name|
+        if variable = variable_named(name)
+          varying_vars[variable] = variable.value.dup
+          variable.widen_value_domain!(:==, variable.type.arbitrary_value)
+        end
+      end
+
+      varying_vars.each do |variable, orig_value|
+        case deduct_variable_varying_path(variable, iteration_statement)
+        when :increase
+          variable.narrow_value_domain!(:>=, orig_value)
+        when :decrease
+          variable.narrow_value_domain!(:<=, orig_value)
+        end
+      end
+    end
+
+    def deduct_variable_varying_path(variable, iteration_statement)
+      histogram = iteration_statement.varying_expressions.map { |expr|
+        case expr
+        when SimpleAssignmentExpression
+          deduct_ctrl_var_path_by_simple_assignment_expr(variable, expr)
+        when CompoundAssignmentExpression
+          deduct_ctrl_var_path_by_compound_assignment_expr(variable, expr)
+        when PrefixIncrementExpression, PostfixIncrementExpression
+          expr.operand.identifier.value == variable.name ? :increase : nil
+        when PrefixDecrementExpression, PostfixDecrementExpression
+          expr.operand.identifier.value == variable.name ? :decrease : nil
+        else
+          nil
+        end
+      }.compact.each_with_object(Hash.new(0)) { |dir, hash| hash[dir] += 1 }
+
+      if histogram.empty?
+        nil
+      else
+        histogram[:decrease] <= histogram[:increase] ? :increase : :decrease
+      end
+    end
+
+    def deduct_ctrl_var_path_by_simple_assignment_expr(variable, expr)
+      return nil unless expr.lhs_operand.identifier.value == variable.name
+
+      additive_exprs = collect_additive_expressions(expr.rhs_operand)
+      histogram = additive_exprs.map { |additive_expr|
+        if additive_expr.lhs_operand.kind_of?(ObjectSpecifier)
+          lhs_name = additive_expr.lhs_operand.identifier.value
+        end
+
+        if additive_expr.rhs_operand.kind_of?(ObjectSpecifier)
+          rhs_name = additive_expr.rhs_operand.identifier.value
+        end
+
+        unless lhs_name == variable.name || rhs_name == variable.name
+          next nil
+        end
+
+        case additive_expr.operator.type
+        when "+"
+          :increase
+        when "-"
+          :decrease
+        else
+          nil
+        end
+      }.compact.each_with_object(Hash.new(0)) { |dir, hash| hash[dir] += 1 }
+
+      if histogram.empty?
+        nil
+      else
+        histogram[:decrease] <= histogram[:increase] ? :increase : :decrease
+      end
+    end
+
+    def deduct_ctrl_var_path_by_compound_assignment_expr(variable, expr)
+      return nil unless expr.lhs_operand.identifier.value == variable.name
+
+      case expr.operator.type
+      when "+="
+        :increase
+      when "-="
+        :decrease
+      else
+        nil
+      end
+    end
+
+    def deduct_effective_controlling_expression(iteration_statement)
+      if effective_ctrlexpr = iteration_statement.deduct_controlling_expression
+        # TODO: If the controlling expression is `i == 2 || i == 5', this
+        #       expression should not be used.
+        if effective_ctrlexpr.kind_of?(EqualityExpression) &&
+            effective_ctrlexpr.operator.type == "=="
+          effective_ctrlexpr = nil
+        end
+      end
+      effective_ctrlexpr
+    end
+  end
+
+  class SwitchStatementInterpreter < SubInterpreter
+    include BranchGroup::Option
+    include Branch::Option
+
+    def initialize(owner)
+      super(owner, SwitchStatement)
+    end
+
+    def visit_switch_statement(node)
+      checkpoint(node.location)
+
+      node.executed = true
+      object = interpret(node.expression)
+      execute_switch_body(object, node.statement) if object.variable?
+    end
+
+    private
+    def execute_switch_body(variable, node)
+      checkpoint(node.location)
+
+      node.executed = true
+      scoped_eval do
+        begin
+          notify_block_started(node)
+          execute_switch_branches(variable, node.block_items)
+        ensure
+          notify_block_ended(node)
+        end
+      end
+    end
+
+    def execute_switch_branches(variable, block_items)
+      base_options = [SMOTHER_BREAK, IMPLICIT_CONDITION, NARROWING]
+      base_options.push(COMPLETE) if complete?(block_items)
+
+      index = 0
+      while block_item = block_items[index]
+        while block_item.kind_of?(GenericLabeledStatement)
+          block_item.executed = true
+          notify_label_defined(block_item)
+          block_item = block_item.statement
+        end
+
+        case block_item
+        when CaseLabeledStatement, DefaultLabeledStatement
+          options = base_options.dup
+          options.push(FINAL) if final_branch?(block_items, index)
+          index = execute_branch(block_item, block_items, index + 1, options)
+          break unless index
+        else
+          interpret(block_item)
+          index += 1
+        end
+      end
+    end
+
+    def execute_branch(labeled_statement, block_items, index, branch_options)
+      ctrlexpr = labeled_statement.normalized_expression
+      ctrlexpr_value = value_of(interpret(ctrlexpr, :suppress_notification))
+
+      case
+      when ctrlexpr_value.must_be_true?
+        branch_options.push(FINAL, COMPLETE)
+      when ctrlexpr_value.must_be_false?
+        # NOTE: To end the current branch group of switch-statement if this
+        #       case-clause is the final one.
+        branched_eval(ctrlexpr, *branch_options) {}
+        return seek_next_branch(block_items, index)
+      end
+
+      branched_eval(ctrlexpr, *branch_options) do |branch|
+        interpret(labeled_statement)
+        while block_item = block_items[index]
+          while block_item.kind_of?(GenericLabeledStatement)
+            block_item.executed = true
+            notify_label_defined(block_item)
+            block_item = block_item.statement
+          end
+
+          case block_item
+          when CaseLabeledStatement, DefaultLabeledStatement
+            # NOTE: Fall through!
+            prepare_fall_through(branch, branch_options, block_item)
+            branch_options.push(FINAL) if final_branch?(block_items, index)
+            branch.add_options(*branch_options)
+          end
+          interpret(block_item)
+          index += 1
+        end
+        # NOTE: To simulate implicit breaking of the last case-clause.
+        BreakEvent.of_break.throw
+      end
+
+      branch_options.include?(FINAL) ?
+        nil : seek_next_branch(block_items, index)
+    end
+
+    def prepare_fall_through(branch, branch_options, labeled_statement)
+      value_domain_manip = nil
+
+      branch.restart_versioning do
+        ctrlexpr = labeled_statement.normalized_expression
+        ctrlexpr_value = value_of(interpret(ctrlexpr, :suppress_notification))
+
+        case
+        when ctrlexpr_value.must_be_true?
+          branch_options.push(FINAL, COMPLETE)
+        when ctrlexpr_value.must_be_false?
+          return
+        end
+
+        value_domain_manip =
+          branch.controlling_expression.ensure_true_by_widening(ctrlexpr)
+      end
+
+      value_domain_manip.commit!
+    end
+
+    def final_branch?(block_items, index)
+      index += 1
+      while block_item = block_items[index]
+        while block_item.kind_of?(GenericLabeledStatement)
+          block_item = block_item.statement
+        end
+
+        case block_item
+        when CaseLabeledStatement, DefaultLabeledStatement
+          return false
+        else
+          index += 1
+        end
+      end
+      true
+    end
+
+    def complete?(block_items)
+      index = 0
+      while block_item = block_items[index]
+        while block_item.kind_of?(GenericLabeledStatement)
+          block_item = block_item.statement
+        end
+
+        case block_item
+        when DefaultLabeledStatement
+          return true
+        else
+          index += 1
+        end
+      end
+      false
+    end
+
+    def seek_next_branch(block_items, index)
+      while block_item = block_items[index]
+        while block_item.kind_of?(GenericLabeledStatement)
+          notify_label_defined(block_item)
+          block_item = block_item.statement
+        end
+
+        case block_item
+        when CaseLabeledStatement, DefaultLabeledStatement
+          break
+        else
+          index += 1
+        end
+      end
+      index
+    end
+  end
+
+  class ExpressionInterpreter < SubInterpreter
+    include ExpressionEvaluator
+
+    def initialize(owner)
+      super(owner, Expression)
+    end
+  end
+
+end
+end