adlint 1.0.0 → 1.2.0

data/lib/adlint/c/interp.rb

@@ -68,232 +68,304 @@ module C #:nodoc:
 
     extend Pluggable
 
+    def self.def_plugin_and_notifier(event_name, *arg_names)
+      class_eval <<-EOS
+        def_plugin :on_#{event_name}
+        def notify_#{event_name}(#{arg_names.join(",")})
+          unless @suppress_notification
+            on_#{event_name}.invoke(#{arg_names.join(",")})
+          end
+        end
+      EOS
+    end
+    private_class_method :def_plugin_and_notifier
+
     # NOTE: Notified when the interpreter evaluates an initializer of
     #       variable-definition.
-    def_plugin :on_variable_initialized
+    def_plugin_and_notifier :variable_initialized,
+                            :variable_definition, :variable, :init_variable
 
     # NOTE: Notified when the interpreter evaluates a variable-definition.
-    def_plugin :on_variable_defined
+    def_plugin_and_notifier :variable_defined, :variable_definition, :variable
 
     # NOTE: Notified when the interpreter evaluates a function-declaration.
-    def_plugin :on_function_declared
+    def_plugin_and_notifier :function_declared,
+                            :function_declaration, :function
 
     # NOTE: Notified when the interpreter evaluates a variable-declaration.
-    def_plugin :on_variable_declared
+    def_plugin_and_notifier :variable_declared,
+                            :variable_declaration, :variable
 
     # NOTE: Notified when the interpreter evaluates a struct-type-declaration.
-    def_plugin :on_struct_declared
+    def_plugin_and_notifier :struct_declared, :struct_type_declaration
 
     # NOTE: Notified when the interpreter evaluates a union-type-declaration.
-    def_plugin :on_union_declared
+    def_plugin_and_notifier :union_declared, :union_type_declaration
 
     # NOTE: Notified when the interpreter evaluates a enum-type-declaration.
-    def_plugin :on_enum_declared
+    def_plugin_and_notifier :enum_declared, :enum_type_declaration
 
     # NOTE: Notified when the interpreter evaluates a typedef-declaration.
-    def_plugin :on_typedef_declared
+    def_plugin_and_notifier :typedef_declared, :typedef_declaration
 
     # NOTE: Notified when the interpreter starts execution of a
     #       function-definition.
-    def_plugin :on_function_started
+    def_plugin_and_notifier :function_started, :function_definition
 
     # NOTE: Notified when the interpreter ends execution of a
     #       function-definition.
-    def_plugin :on_function_ended
+    def_plugin_and_notifier :function_ended, :function_definition
 
     # NOTE: Notified when the interpreter evaluates a parameter-definition at
     #       beginning of execution of a function-definition.
-    def_plugin :on_parameter_defined
+    def_plugin_and_notifier :parameter_defined,
+                            :parameter_definition, :variable
 
     # NOTE: Notified when the interpreter evaluates an expression which results
     #       a named variable.
-    def_plugin :on_variable_referred
+    def_plugin_and_notifier :variable_referred, :object_specifier, :variable
 
     # NOTE: Notified when the interpreter evaluates an expression which results
     #       a constant temporary variable.
-    def_plugin :on_constant_referred
+    def_plugin_and_notifier :constant_referred, :constant_specifier, :variable
 
     # NOTE: Notified when the interpreter refer to a value of a variable while
     #       evaluating an expression.
-    def_plugin :on_variable_value_referred
+    def_plugin_and_notifier :variable_value_referred, :expression, :variable
 
     # NOTE: Notified when the interpreter overwrite a value of a variable while
     #       evaluating an expression.
-    def_plugin :on_variable_value_updated
+    def_plugin_and_notifier :variable_value_updated, :expression, :variable
 
     # NOTE: Notified when the interpreter refer to a function object while
     #       evaluating an expression.
-    def_plugin :on_function_referred
+    def_plugin_and_notifier :function_referred, :expression, :function
 
     # NOTE: Notified when the interpreter evaluates a sizeof-expression.
-    def_plugin :on_sizeof_expr_evaled
+    def_plugin_and_notifier :sizeof_expr_evaled,
+                            :expression, :operand_variable, :result_variable
 
     # NOTE: Notified when the interpreter evaluates a sizeof-type-expression.
-    def_plugin :on_sizeof_type_expr_evaled
+    def_plugin_and_notifier :sizeof_type_expr_evaled,
+                            :expression, :type, :result_variable
 
     # NOTE: Notified when the interpreter evaluates a cast-expression.
-    def_plugin :on_explicit_conv_performed
+    def_plugin_and_notifier :explicit_conv_performed,
+                            :expression, :original_variable, :result_variable
 
     # NOTE: Notified when the interpreter performs an implicit type conversion
     #       while evaluating an expression.
-    def_plugin :on_implicit_conv_performed
+    def_plugin_and_notifier :implicit_conv_performed,
+                            :initializer_or_expression, :original_variable,
+                            :result_variable
 
     # NOTE: Notified when the interpreter evaluates an
     #       array-subscript-expression.
-    def_plugin :on_array_subscript_expr_evaled
+    def_plugin_and_notifier :array_subscript_expr_evaled,
+                            :array_subscript_expression,
+                            :array_or_pointer_variable, :subscript_variable,
+                            :array_variable, :result_variable
 
     # NOTE: Notified when the interpreter evaluates a function-call-expression.
-    def_plugin :on_function_call_expr_evaled
+    def_plugin_and_notifier :function_call_expr_evaled,
+                            :function_call_expression, :function,
+                            :arg_variables, :result_variable
 
     # NOTE: Notified when the interpreter evaluates an
     #       unary-arithmetic-expression.
-    def_plugin :on_unary_arithmetic_expr_evaled
+    def_plugin_and_notifier :unary_arithmetic_expr_evaled,
+                            :unary_arithmetic_expression, :operand_variable,
+                            :result_variable
 
     # NOTE: Notified when the interpreter evaluates a
     #       multiplicative-expression.
-    def_plugin :on_multiplicative_expr_evaled
+    def_plugin_and_notifier :multiplicative_expr_evaled,
+                            :multiplicative_expression, :lhs_variable,
+                            :rhs_variable, :result_variable
 
     # NOTE: Notified when the interpreter evaluates an additive-expression.
-    def_plugin :on_additive_expr_evaled
+    def_plugin_and_notifier :additive_expr_evaled,
+                            :additive_expression, :lhs_variable, :rhs_variable,
+                            :result_variable
 
     # NOTE: Notified when the interpreter evaluates a shift-expression.
-    def_plugin :on_shift_expr_evaled
+    def_plugin_and_notifier :shift_expr_evaled,
+                            :shift_expression, :lhs_variable, :rhs_variable,
+                            :result_variable
 
     # NOTE: Notified when the interpreter evaluates a relational-expression.
-    def_plugin :on_relational_expr_evaled
+    def_plugin_and_notifier :relational_expr_evaled,
+                            :relational_expression, :lhs_variable,
+                            :rhs_variable, :result_variable
 
     # NOTE: Notified when the interpreter evaluates an equality-expression.
-    def_plugin :on_equality_expr_evaled
+    def_plugin_and_notifier :equality_expr_evaled,
+                            :equality_expression, :lhs_variable, :rhs_variable,
+                            :result_variable
 
     # NOTE: Notified when the interpreter evaluates a bitwise and-expression.
-    def_plugin :on_and_expr_evaled
+    def_plugin_and_notifier :and_expr_evaled,
+                            :and_expression, :lhs_variable, :rhs_variable,
+                            :result_variable
 
     # NOTE: Notified when the interpreter evaluates an exclusive-or-expression.
-    def_plugin :on_exclusive_or_expr_evaled
+    def_plugin_and_notifier :exclusive_or_expr_evaled,
+                            :exclusive_or_expression, :lhs_variable,
+                            :rhs_variable, :result_variable
 
     # NOTE: Notified when the interpreter evaluates a bitwise
     #       inclusive-or-expression.
-    def_plugin :on_inclusive_or_expr_evaled
+    def_plugin_and_notifier :inclusive_or_expr_evaled,
+                            :inclusive_or_expression, :lhs_variable,
+                            :rhs_variable, :result_variable
 
     # NOTE: Notified when the interpreter evaluates a logical-and-expression.
-    def_plugin :on_logical_and_expr_evaled
+    def_plugin_and_notifier :logical_and_expr_evaled,
+                            :logical_and_expression, :lhs_variable,
+                            :rhs_variable, :result_variable
 
     # NOTE: Notified when the interpreter evaluates a logical-or-expression.
-    def_plugin :on_logical_or_expr_evaled
+    def_plugin_and_notifier :logical_or_expr_evaled,
+                            :logical_or_expression, :lhs_variable,
+                            :rhs_variable, :result_variable
 
     # NOTE: Notified when the interpreter evaluates a conditional-expression.
-    def_plugin :on_conditional_expr_evaled
+    def_plugin_and_notifier :conditional_expr_evaled,
+                            :conditional_expression, :condition_variable,
+                            :result_variable
 
     # NOTE: Notified when the interpreter evaluates an indirection-expression.
-    def_plugin :on_indirection_expr_evaled
+    def_plugin_and_notifier :indirection_expr_evaled,
+                            :indirection_expression, :pointer_variable,
+                            :dereferenced_variable
 
     # 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
+    def_plugin_and_notifier :member_access_expr_evaled,
+                            :member_access_expression, :outer_variable,
+                            :member_variable
 
     # NOTE: Notified when the interpreter evaluates a
     #       prefix-increment-expression.
-    def_plugin :on_prefix_increment_expr_evaled
+    def_plugin_and_notifier :prefix_increment_expr_evaled,
+                            :prefix_increment_expression, :operand_variable,
+                            :original_value
 
     # NOTE: Notified when the interpreter evaluates a
     #       postfix-increment-expression.
-    def_plugin :on_postfix_increment_expr_evaled
+    def_plugin_and_notifier :postfix_increment_expr_evaled,
+                            :postfix_increment_expression, :operand_variable,
+                            :result_variable
 
     # NOTE: Notified when the interpreter evaluates a
     #       prefix-decrement-expression.
-    def_plugin :on_prefix_decrement_expr_evaled
+    def_plugin_and_notifier :prefix_decrement_expr_evaled,
+                            :prefix_decrement_expression, :operand_variable,
+                            :original_value
 
     # NOTE: Notified when the interpreter evaluates a
     #       postfix-decrement-expression.
-    def_plugin :on_postfix_decrement_expr_evaled
+    def_plugin_and_notifier :postfix_decrement_expr_evaled,
+                            :postfix_decrement_expression, :operand_variable,
+                            :result_variable
 
     # NOTE: Notified when the interpreter evaluates a
     #       simple-assignment-expression or a compound-assignment-expression.
-    def_plugin :on_assignment_expr_evaled
+    def_plugin_and_notifier :assignment_expr_evaled,
+                            :assignment_expression, :lhs_variable,
+                            :rhs_variable
 
     # NOTE: Notified when the interpreter starts execution of a
     #       while-statement.
-    def_plugin :on_while_stmt_started
+    def_plugin_and_notifier :while_stmt_started, :while_statement
 
     # NOTE: Notified when the interpreter ends execution of a while-statement.
-    def_plugin :on_while_stmt_ended
+    def_plugin_and_notifier :while_stmt_ended, :while_statement
 
     # NOTE: Notified when the interpreter starts execution of a do-statement.
-    def_plugin :on_do_stmt_started
+    def_plugin_and_notifier :do_stmt_started, :do_statement
 
     # NOTE: Notified when the interpreter ends execution of a do-statement.
-    def_plugin :on_do_stmt_ended
+    def_plugin_and_notifier :do_stmt_ended, :do_statement
 
     # NOTE: Notified when the interpreter starts execution of a for-statement.
-    def_plugin :on_for_stmt_started
+    def_plugin_and_notifier :for_stmt_started, :for_statement
 
     # NOTE: Notified when the interpreter ends execution of a for-statement.
-    def_plugin :on_for_stmt_ended
+    def_plugin_and_notifier :for_stmt_ended, :for_statement
 
     # NOTE: Notified when the interpreter starts execution of a
     #       c99-for-statement.
-    def_plugin :on_c99_for_stmt_started
+    def_plugin_and_notifier :c99_for_stmt_started, :c99_for_statement
 
     # NOTE: Notified when the interpreter ends execution of a
     #       c99-for-statement.
-    def_plugin :on_c99_for_stmt_ended
+    def_plugin_and_notifier :c99_for_stmt_ended, :c99_for_statement
 
     # NOTE: Notified when the interpreter evaluates a goto-statement.
-    def_plugin :on_goto_stmt_evaled
+    def_plugin_and_notifier :goto_stmt_evaled, :goto_statement, :label_name
 
     # NOTE: Notified when the interpreter evaluates a return-statement.
-    def_plugin :on_return_stmt_evaled
+    def_plugin_and_notifier :return_stmt_evaled,
+                            :return_statement, :result_variable
 
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the if-statement.
-    def_plugin :on_if_ctrlexpr_evaled
+    def_plugin_and_notifier :if_ctrlexpr_evaled, :if_statement, :ctrlexpr_value
 
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the if-else-statement.
-    def_plugin :on_if_else_ctrlexpr_evaled
+    def_plugin_and_notifier :if_else_ctrlexpr_evaled,
+                            :if_else_statement, :ctrlexpr_value
 
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the while-statement.
-    def_plugin :on_while_ctrlexpr_evaled
+    def_plugin_and_notifier :while_ctrlexpr_evaled,
+                            :while_statement, :ctrlexpr_value
 
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the do-statement.
-    def_plugin :on_do_ctrlexpr_evaled
+    def_plugin_and_notifier :do_ctrlexpr_evaled, :do_statement, :ctrlexpr_value
 
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the for-statement.
-    def_plugin :on_for_ctrlexpr_evaled
+    def_plugin_and_notifier :for_ctrlexpr_evaled,
+                            :for_statement, :ctrlexpr_value
 
     # NOTE: Notified when the interpreter evaluates a controlling expression of
     #       the c99-for-statement.
-    def_plugin :on_c99_for_ctrlexpr_evaled
+    def_plugin_and_notifier :c99_for_ctrlexpr_evaled,
+                            :c99_for_statement, :ctrlexpr_value
 
     # NOTE: Notified when the interpreter defines a generic-label.
-    def_plugin :on_label_defined
+    def_plugin_and_notifier :label_defined, :generic_labeled_statement
 
     # NOTE: Notified when the interpreter starts execution of a
     #       compound-statement.
-    def_plugin :on_block_started
+    def_plugin_and_notifier :block_started, :compound_statement
 
     # NOTE: Notified when the interpreter ends execution of a
     #       compound-statement.
-    def_plugin :on_block_ended
+    def_plugin_and_notifier :block_ended, :compound_statement
 
     # NOTE: Notified when the interpreter forks execution paths of a
     #       function-definition.
-    def_plugin :on_branch_started
+    def_plugin_and_notifier :branch_started, :branch
 
     # NOTE: Notified when the interpreter joins execution paths of a
     #       function-definition.
-    def_plugin :on_branch_ended
+    def_plugin_and_notifier :branch_ended, :branch
 
     # NOTE: Notified when the interpreter starts execution of a
     #       translation-unit.
-    def_plugin :on_translation_unit_started
+    def_plugin_and_notifier :translation_unit_started, :translation_unit
 
     # NOTE: Notified when the interpreter ends execution of a translation-unit.
-    def_plugin :on_translation_unit_ended
+    def_plugin_and_notifier :translation_unit_ended, :translation_unit
+
+    # NOTE: Notified when control reaches to a sequence-point.
+    def_plugin_and_notifier :sequence_point_reached, :sequence_point
 
     def execute(node, *options)
       if options.include?(:suppress_notification)
@@ -332,467 +404,6 @@ module C #:nodoc:
       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
@@ -879,6 +490,8 @@ module C #:nodoc:
 
       function = define_explicit_function(node)
       notify_function_declared(node, function)
+
+      evaluate_sequence_point(node.init_declarator.declarator)
     end
 
     def visit_variable_declaration(node)
@@ -892,6 +505,8 @@ module C #:nodoc:
 
       variable = declare_variable(node)
       notify_variable_declared(node, variable)
+
+      evaluate_sequence_point(node.declarator)
     end
 
     def visit_variable_definition(node)
@@ -915,6 +530,8 @@ module C #:nodoc:
           notify_implicit_conv_performed(initializer, init_variable, converted)
         end
 
+        notify_variable_value_referred(node, init_variable)
+
         variable = define_variable(node, converted.value.to_defined_value)
         notify_variable_defined(node, variable)
         notify_variable_initialized(node, variable, init_variable)
@@ -922,6 +539,8 @@ module C #:nodoc:
         variable = define_variable(node)
         notify_variable_defined(node, variable)
       end
+
+      evaluate_sequence_point(node.init_declarator.declarator)
     end
 
     def visit_struct_type_declaration(node)
@@ -972,6 +591,8 @@ module C #:nodoc:
 
       notify_typedef_declared(node)
 
+      evaluate_sequence_point(node.init_declarator.declarator)
+
       Analyzer.current.info("user type `#{node.identifier.value}' " +
                             "defined at #{node.location.to_s}.")
     end
@@ -1007,6 +628,12 @@ module C #:nodoc:
     def deduct_array_length_from_array_variable(variable_type, array_variable)
       variable_type.length ||= array_variable.type.length
     end
+
+    def evaluate_sequence_point(full_declarator)
+      if sequence_point = full_declarator.subsequent_sequence_point
+        notify_sequence_point_reached(sequence_point)
+      end
+    end
   end
 
   class InitializerInterpreter
@@ -1341,12 +968,26 @@ module C #:nodoc:
                         NARROWING, FINAL, IMPLICIT_CONDITION, COMPLETE) do
             interpret(node.body_statement)
             interpret(node.expression) if node.expression
+            # NOTE: To avoid that value of the controlling variable is marked
+            #       as updated at end of the for-statement.  Value of the
+            #       controlling variable is referred by the controlling
+            #       expression at the last iteration.
+            # FIXME: This re-interpretation of the controlling expression may
+            #        causes duplicative warning messages.
+            interpret(ctrlexpr)
           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
+            # NOTE: To avoid that value of the controlling variable is marked
+            #       as updated at end of the for-statement.  Value of the
+            #       controlling variable is referred by the controlling
+            #       expression at the last iteration.
+            # FIXME: This re-interpretation of the controlling expression may
+            #        causes duplicative warning messages.
+            interpret(ctrlexpr)
           end
         end
       else
@@ -1383,12 +1024,26 @@ module C #:nodoc:
                           NARROWING, FINAL, IMPLICIT_CONDITION, COMPLETE) do
               interpret(node.body_statement)
               interpret(node.expression) if node.expression
+              # NOTE: To avoid that value of the controlling variable is marked
+              #       as updated at end of the for-statement.  Value of the
+              #       controlling variable is referred by the controlling
+              #       expression at the last iteration.
+              # FIXME: This re-interpretation of the controlling expression may
+              #        causes duplicative warning messages.
+              interpret(ctrlexpr)
             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
+              # NOTE: To avoid that value of the controlling variable is marked
+              #       as updated at end of the for-statement.  Value of the
+              #       controlling variable is referred by the controlling
+              #       expression at the last iteration.
+              # FIXME: This re-interpretation of the controlling expression may
+              #        causes duplicative warning messages.
+              interpret(ctrlexpr)
             end
           end
         else
@@ -1734,6 +1389,59 @@ module C #:nodoc:
     def initialize(owner)
       super(owner, Expression)
     end
+
+    def self.def_eval_with_sequence_point(method_name)
+      class_eval <<-EOS
+        def #{method_name}(node)
+          super
+        ensure
+          if sequence_point = node.subsequent_sequence_point
+            notify_sequence_point_reached(sequence_point)
+          end
+        end
+      EOS
+    end
+    private_class_method :def_eval_with_sequence_point
+
+    def_eval_with_sequence_point :visit_error_expression
+    def_eval_with_sequence_point :visit_object_specifier
+    def_eval_with_sequence_point :visit_constant_specifier
+    def_eval_with_sequence_point :visit_string_literal_specifier
+    def_eval_with_sequence_point :visit_null_constant_specifier
+    def_eval_with_sequence_point :visit_grouped_expression
+    def_eval_with_sequence_point :visit_array_subscript_expression
+    def_eval_with_sequence_point :visit_function_call_expression
+    def_eval_with_sequence_point :visit_member_access_by_value_expression
+    def_eval_with_sequence_point :visit_member_access_by_pointer_expression
+    def_eval_with_sequence_point :visit_bit_access_by_value_expression
+    def_eval_with_sequence_point :visit_bit_access_by_pointer_expression
+    def_eval_with_sequence_point :visit_postfix_increment_expression
+    def_eval_with_sequence_point :visit_postfix_decrement_expression
+    def_eval_with_sequence_point :visit_compound_literal_expression
+    def_eval_with_sequence_point :visit_prefix_increment_expression
+    def_eval_with_sequence_point :visit_prefix_decrement_expression
+    def_eval_with_sequence_point :visit_address_expression
+    def_eval_with_sequence_point :visit_indirection_expression
+    def_eval_with_sequence_point :visit_unary_arithmetic_expression
+    def_eval_with_sequence_point :visit_sizeof_expression
+    def_eval_with_sequence_point :visit_sizeof_type_expression
+    def_eval_with_sequence_point :visit_alignof_expression
+    def_eval_with_sequence_point :visit_alignof_type_expression
+    def_eval_with_sequence_point :visit_cast_expression
+    def_eval_with_sequence_point :visit_multiplicative_expression
+    def_eval_with_sequence_point :visit_additive_expression
+    def_eval_with_sequence_point :visit_shift_expression
+    def_eval_with_sequence_point :visit_relational_expression
+    def_eval_with_sequence_point :visit_equality_expression
+    def_eval_with_sequence_point :visit_and_expression
+    def_eval_with_sequence_point :visit_exclusive_or_expression
+    def_eval_with_sequence_point :visit_inclusive_or_expression
+    def_eval_with_sequence_point :visit_logical_and_expression
+    def_eval_with_sequence_point :visit_logical_or_expression
+    def_eval_with_sequence_point :visit_conditional_expression
+    def_eval_with_sequence_point :visit_simple_assignment_expression
+    def_eval_with_sequence_point :visit_compound_assignment_expression
+    def_eval_with_sequence_point :visit_comma_separated_expression
   end
 
 end