note
	description: "[
		Checks a set of (standard) rules (see {CA_STANDARD_RULE}). The rules have to
		register their AST visitor agents here.
	]"
	author: "Stefan Zurfluh", "Eiffel Software"
	revised_by: "Alexander Kogtenkov"
	date: "$Date$"
	revision: "$Revision$"

class
	CA_ALL_RULES_CHECKER

inherit

	AST_ITERATOR
		export {NONE}
			process_none_id_as,
			process_typed_char_as,
			process_agent_routine_creation_as,
			process_inline_agent_creation_as,
			process_keyword_as,
			process_symbol_as,
			process_break_as,
			process_leaf_stub_as,
			process_symbol_stub_as,
			process_keyword_stub_as
		redefine
			process_access_feat_as,
			process_access_id_as,
			process_address_as,
			process_agent_routine_creation_as,
			process_array_as,
			process_assign_as,
			process_assigner_call_as,
			process_binary_as,
			process_bin_eq_as,
			process_bin_ge_as,
			process_bin_gt_as,
			process_bin_le_as,
			process_bin_lt_as,
			process_bin_ne_as,
			process_bin_not_tilde_as,
			process_bin_tilde_as,
			process_body_as,
			process_bracket_as,
			process_case_as,
			process_converted_expr_as,
			process_create_as,
			process_creation_as,
			process_do_as,
			process_eiffel_list,
			process_elseif_as,
			process_expr_call_as,
			process_feature_as,
			process_feature_clause_as,
			process_guard_as,
			process_id_as,
			process_if_as,
			process_if_expression_as,
			process_inline_agent_creation_as,
			process_inspect_as,
			process_instr_call_as,
			process_integer_as,
			process_invariant_as,
			process_loop_as,
			process_nested_expr_as,
			process_object_test_as,
			process_once_as,
			process_parameter_list_as,
			process_paran_as,
			process_precursor_as,
			process_predecessor_as,
			process_real_as,
			process_routine_as,
			process_static_access_as,
			process_unary_as,
			process_un_not_as
		end

create
	make

feature {NONE} -- Initialization

	make
		do
			create_action_lists
		end

	create_action_lists
			-- Creates all the lists of agents that will be called when visiting
			-- certain AST nodes.
		do
			create access_feat_pre_actions
			create access_feat_post_actions
			create access_id_pre_actions
			create access_id_post_actions
			create address_pre_actions
			create address_post_actions
			create agent_routine_pre_action
			create agent_routine_post_action
			create array_pre_actions
			create array_post_actions
			create assign_pre_actions
			create assign_post_actions
			create assigner_call_pre_actions
			create assigner_call_post_actions
			create binary_pre_actions
			create binary_post_actions
			create bin_eq_pre_actions
			create bin_eq_post_actions
			create bin_ge_pre_actions
			create bin_ge_post_actions
			create bin_gt_pre_actions
			create bin_gt_post_actions
			create bin_le_pre_actions
			create bin_le_post_actions
			create bin_lt_pre_actions
			create bin_lt_post_actions
			create bin_ne_pre_actions
			create bin_ne_post_actions
			create bin_not_tilde_pre_actions
			create bin_not_tilde_post_actions
			create bin_tilde_pre_actions
			create bin_tilde_post_actions
			create body_pre_actions
			create body_post_actions
			create bracket_pre_actions
			create bracket_post_actions
			create case_pre_actions
			create case_post_actions
			create class_pre_actions
			create class_post_actions
			create converted_expr_pre_actions
			create converted_expr_post_actions
			create create_pre_actions
			create create_post_actions
			create creation_pre_actions
			create creation_post_actions
			create do_pre_actions
			create do_post_actions
			create eiffel_list_pre_actions
			create eiffel_list_post_actions
			create elseif_pre_actions
			create elseif_post_actions
			create expression_call_pre_actions
			create expression_call_post_actions
			create feature_pre_actions
			create feature_post_actions
			create feature_clause_pre_actions
			create feature_clause_post_actions
			create guard_pre_actions
			create guard_post_actions
			create id_pre_actions
			create id_post_actions
			create if_pre_actions
			create if_post_actions
			create if_expression_pre_actions
			create if_expression_post_actions
			create inline_agent_creation_pre_actions
			create inline_agent_creation_post_actions
			create inspect_pre_actions
			create inspect_post_actions
			create instruction_call_pre_actions
			create instruction_call_post_actions
			create invariant_pre_actions
			create invariant_post_actions
			create loop_pre_actions
			create loop_post_actions
			create loop_iteration_pre_actions
			create loop_iteration_post_actions
			create loop_from_pre_actions
			create loop_from_post_actions
			create loop_invariant_pre_actions
			create loop_invariant_post_actions
			create loop_exit_pre_actions
			create loop_exit_post_actions
			create loop_body_pre_actions
			create loop_body_post_actions
			create loop_variant_pre_actions
			create loop_variant_post_actions
			create nested_expr_pre_actions
			create nested_expr_post_actions
			create object_test_pre_actions
			create object_test_post_actions
			create once_pre_actions
			create once_post_actions
			create parameter_list_pre_actions
			create parameter_list_post_actions
			create paran_pre_actions
			create paran_post_actions
			create precursor_pre_actions
			create precursor_post_actions
			create predecessor_pre_actions
			create predecessor_post_actions
			create routine_pre_actions
			create routine_post_actions
			create static_access_pre_actions
			create static_access_post_actions
			create unary_pre_actions
			create unary_post_actions
			create un_not_pre_actions
			create un_not_post_actions
			create integer_pre_actions
			create integer_post_actions
			create real_pre_actions
			create real_post_actions
		end

feature {CA_RULE} -- State

	is_assign: BOOLEAN
			-- Is target of an assignment or a creation instruction being processed?

	is_assigner_call: BOOLEAN
			-- Is current call an assigner call?

feature {CA_STANDARD_RULE} -- Adding agents

	add_access_feat_pre_action (a_action: attached PROCEDURE [ACCESS_FEAT_AS])
		do
			access_feat_pre_actions.extend (a_action)
		end

	add_access_feat_post_action (a_action: attached PROCEDURE [ACCESS_FEAT_AS])
		do
			access_feat_post_actions.extend (a_action)
		end

	add_access_id_pre_action (a_action: attached PROCEDURE [ACCESS_ID_AS])
		do
			access_id_pre_actions.extend (a_action)
		end

	add_access_id_post_action (a_action: attached PROCEDURE [ACCESS_ID_AS])
		do
			access_id_post_actions.extend (a_action)
		end

	add_address_pre_action (a: PROCEDURE [ADDRESS_AS])
		do
			address_pre_actions.extend (a)
		end

	add_address_post_action (a: PROCEDURE [ADDRESS_AS])
		do
			address_post_actions.extend (a)
		end

	add_array_pre_action (a: PROCEDURE [ARRAY_AS])
		do
			array_pre_actions.extend (a)
		end

	add_array_post_action (a: PROCEDURE [ARRAY_AS])
		do
			array_post_actions.extend (a)
		end

	add_assign_pre_action (a_action: attached PROCEDURE [ASSIGN_AS])
		do
			assign_pre_actions.extend (a_action)
		end

	add_assign_post_action (a_action: attached PROCEDURE [ASSIGN_AS])
		do
			assign_post_actions.extend (a_action)
		end

	add_assigner_call_pre_action (a_action: attached PROCEDURE [ASSIGNER_CALL_AS])
		do
			assigner_call_pre_actions.extend (a_action)
		end

	add_assigner_call_post_action (a_action: attached PROCEDURE [ASSIGNER_CALL_AS])
		do
			assigner_call_post_actions.extend (a_action)
		end

	add_binary_pre_action (a_action: attached PROCEDURE [BINARY_AS])
		do
			binary_pre_actions.extend (a_action)
		end

	add_binary_post_action (a_action: attached PROCEDURE [BINARY_AS])
		do
			binary_post_actions.extend (a_action)
		end

	add_bin_eq_pre_action (a_action: attached PROCEDURE [BIN_EQ_AS])
		do
			bin_eq_pre_actions.extend (a_action)
		end

	add_bin_eq_post_action (a_action: attached PROCEDURE [BIN_EQ_AS])
		do
			bin_eq_post_actions.extend (a_action)
		end

	add_bin_ge_pre_action (a_action: attached PROCEDURE [BIN_GE_AS])
		do
			bin_ge_pre_actions.extend (a_action)
		end

	add_bin_ge_post_action (a_action: attached PROCEDURE [BIN_GE_AS])
		do
			bin_ge_post_actions.extend (a_action)
		end

	add_bin_gt_pre_action (a_action: attached PROCEDURE [BIN_GT_AS])
		do
			bin_gt_pre_actions.extend (a_action)
		end

	add_bin_gt_post_action (a_action: attached PROCEDURE [BIN_GT_AS])
		do
			bin_gt_post_actions.extend (a_action)
		end

	add_bin_le_pre_action (a_action: attached PROCEDURE [BIN_LE_AS])
		do
			bin_le_pre_actions.extend (a_action)
		end

	add_bin_le_post_action (a_action: attached PROCEDURE [BIN_LE_AS])
		do
			bin_le_post_actions.extend (a_action)
		end

	add_bin_lt_pre_action (a_action: attached PROCEDURE [BIN_LT_AS])
		do
			bin_lt_pre_actions.extend (a_action)
		end

	add_bin_lt_post_action (a_action: attached PROCEDURE [BIN_LT_AS])
		do
			bin_lt_post_actions.extend (a_action)
		end

	add_bin_ne_pre_action (a_action: attached PROCEDURE [BIN_NE_AS])
		do
			bin_ne_pre_actions.extend (a_action)
		end

	add_bin_ne_post_action (a_action: attached PROCEDURE [BIN_NE_AS])
		do
			bin_ne_post_actions.extend (a_action)
		end

	add_bin_not_tilde_pre_action (a: PROCEDURE [BIN_NOT_TILDE_AS])
		do
			bin_not_tilde_pre_actions.extend (a)
		end

	add_bin_not_tilde_post_action (a: PROCEDURE [BIN_NOT_TILDE_AS])
		do
			bin_not_tilde_post_actions.extend (a)
		end

	add_bin_tilde_pre_action (a: PROCEDURE [BIN_TILDE_AS])
		do
			bin_tilde_pre_actions.extend (a)
		end

	add_bin_tilde_post_action (a: PROCEDURE [BIN_TILDE_AS])
		do
			bin_tilde_post_actions.extend (a)
		end

	add_body_pre_action (a_action: attached PROCEDURE [BODY_AS])
		do
			body_pre_actions.extend (a_action)
		end

	add_body_post_action (a_action: attached PROCEDURE [BODY_AS])
		do
			body_post_actions.extend (a_action)
		end

	add_bracket_pre_action (a_action: attached PROCEDURE [BRACKET_AS])
		do
			bracket_pre_actions.extend (a_action)
		end

	add_bracket_post_action (a_action: attached PROCEDURE [BRACKET_AS])
		do
			bracket_post_actions.extend (a_action)
		end

	add_case_pre_action (a_action: attached PROCEDURE [CASE_AS])
		do
			case_pre_actions.extend (a_action)
		end

	add_case_post_action (a_action: attached PROCEDURE [CASE_AS])
		do
			case_post_actions.extend (a_action)
		end

	add_class_pre_action (a_action: attached PROCEDURE [CLASS_AS])
		do
			class_pre_actions.extend (a_action)
		end

	add_class_post_action (a_action: attached PROCEDURE [CLASS_AS])
		do
			class_post_actions.extend (a_action)
		end

	add_converted_expr_pre_action (a_action: attached PROCEDURE [CONVERTED_EXPR_AS])
		do
			converted_expr_pre_actions.extend (a_action)
		end

	add_converted_expr_post_action (a_action: attached PROCEDURE [CONVERTED_EXPR_AS])
		do
			converted_expr_post_actions.extend (a_action)
		end

	add_create_pre_action (a_action: attached PROCEDURE [CREATE_AS])
		do
			create_pre_actions.extend (a_action)
		end

	add_create_post_action (a_action: attached PROCEDURE [CREATE_AS])
		do
			create_post_actions.extend (a_action)
		end

	add_creation_pre_action (a_action: attached PROCEDURE [CREATION_AS])
		do
			creation_pre_actions.extend (a_action)
		end

	add_creation_post_action (a_action: attached PROCEDURE [CREATION_AS])
		do
			creation_post_actions.extend (a_action)
		end

	add_do_pre_action (a_action: attached PROCEDURE [DO_AS])
		do
			do_pre_actions.extend (a_action)
		end

	add_do_post_action (a_action: attached PROCEDURE [DO_AS])
		do
			do_post_actions.extend (a_action)
		end

	add_eiffel_list_pre_action (a_action: attached PROCEDURE [EIFFEL_LIST [AST_EIFFEL]])
		do
			eiffel_list_pre_actions.extend (a_action)
		end

	add_eiffel_list_post_action (a_action: attached PROCEDURE [EIFFEL_LIST [AST_EIFFEL]])
		do
			eiffel_list_post_actions.extend (a_action)
		end

	add_elseif_pre_action (a_action: attached PROCEDURE [ELSIF_AS])
		do
			elseif_pre_actions.extend (a_action)
		end

	add_elseif_post_action (a_action: attached PROCEDURE [ELSIF_AS])
		do
			elseif_post_actions.extend (a_action)
		end

	add_expression_call_pre_action (a: attached PROCEDURE [EXPR_CALL_AS])
		do
			expression_call_pre_actions.extend (a)
		end

	add_expression_call_post_action (a: attached PROCEDURE [EXPR_CALL_AS])
		do
			expression_call_post_actions.extend (a)
		end

	add_feature_pre_action (a_action: attached PROCEDURE [FEATURE_AS])
		do
			feature_pre_actions.extend (a_action)
		end

	add_feature_post_action (a_action: attached PROCEDURE [FEATURE_AS])
		do
			feature_post_actions.extend (a_action)
		end

	add_feature_clause_pre_action (a_action: attached PROCEDURE [FEATURE_CLAUSE_AS])
		do
			feature_clause_pre_actions.extend (a_action)
		end

	add_feature_clause_post_action (a_action: attached PROCEDURE [FEATURE_CLAUSE_AS])
		do
			feature_clause_post_actions.extend (a_action)
		end

	add_guard_pre_action (a: PROCEDURE [GUARD_AS])
		do
			guard_pre_actions.extend (a)
		end

	add_guard_post_action (a: PROCEDURE [GUARD_AS])
		do
			guard_post_actions.extend (a)
		end

	add_id_pre_action (a_action: attached PROCEDURE [ID_AS])
		do
			id_pre_actions.extend (a_action)
		end

	add_id_post_action (a_action: attached PROCEDURE [ID_AS])
		do
			id_post_actions.extend (a_action)
		end

	add_if_pre_action (a_action: attached PROCEDURE [IF_AS])
		do
			if_pre_actions.extend (a_action)
		end

	add_if_post_action (a_action: attached PROCEDURE [IF_AS])
		do
			if_post_actions.extend (a_action)
		end

	add_if_expression_pre_action (a: attached PROCEDURE [IF_EXPRESSION_AS])
		do
			if_expression_pre_actions.extend (a)
		end

	add_if_expression_post_action (a: attached PROCEDURE [IF_EXPRESSION_AS])
		do
			if_expression_post_actions.extend (a)
		end

	add_inline_agent_creation_pre_action (a_action: PROCEDURE [INLINE_AGENT_CREATION_AS])
		do
			inline_agent_creation_pre_actions.extend (a_action)
		end

	add_inline_agent_creation_post_action (a_action: PROCEDURE [INLINE_AGENT_CREATION_AS])
		do
			inline_agent_creation_post_actions.extend (a_action)
		end

	add_inspect_pre_action (a_action: attached PROCEDURE [INSPECT_AS])
		do
			inspect_pre_actions.extend (a_action)
		end

	add_inspect_post_action (a_action: attached PROCEDURE [INSPECT_AS])
		do
			inspect_post_actions.extend (a_action)
		end

	add_instruction_call_pre_action (a_action: attached PROCEDURE [INSTR_CALL_AS])
		do
			instruction_call_pre_actions.extend (a_action)
		end

	add_instruction_call_post_action (a_action: attached PROCEDURE [INSTR_CALL_AS])
		do
			instruction_call_post_actions.extend (a_action)
		end

	add_invariant_pre_action (a: PROCEDURE [INVARIANT_AS])
		do
			invariant_pre_actions.extend (a)
		end

	add_invariant_post_action (a: PROCEDURE [INVARIANT_AS])
		do
			invariant_post_actions.extend (a)
		end

	add_loop_pre_action (a: PROCEDURE [LOOP_AS])
		do
			loop_pre_actions.extend (a)
		end

	add_loop_post_action (a: PROCEDURE [LOOP_AS])
		do
			loop_post_actions.extend (a)
		end

	add_loop_iteration_pre_action (a: PROCEDURE [ITERATION_AS, LOOP_AS])
		do
			loop_iteration_pre_actions.extend (a)
		end

	add_loop_iteration_post_action (a: PROCEDURE [ITERATION_AS, LOOP_AS])
		do
			loop_iteration_post_actions.extend (a)
		end

	add_loop_from_pre_action (a: PROCEDURE [EIFFEL_LIST [INSTRUCTION_AS], LOOP_AS])
		do
			loop_from_pre_actions.extend (a)
		end

	add_loop_from_post_action (a: PROCEDURE [EIFFEL_LIST [INSTRUCTION_AS], LOOP_AS])
		do
			loop_from_post_actions.extend (a)
		end

	add_loop_invariant_pre_action (a: PROCEDURE [EIFFEL_LIST [TAGGED_AS], LOOP_AS])
		do
			loop_invariant_pre_actions.extend (a)
		end

	add_loop_invariant_post_action (a: PROCEDURE [EIFFEL_LIST [TAGGED_AS], LOOP_AS])
		do
			loop_invariant_post_actions.extend (a)
		end

	add_loop_exit_pre_action (a: PROCEDURE [EXPR_AS, LOOP_AS])
		do
			loop_exit_pre_actions.extend (a)
		end

	add_loop_exit_post_action (a: PROCEDURE [EXPR_AS, LOOP_AS])
		do
			loop_exit_post_actions.extend (a)
		end

	add_loop_body_pre_action (a: PROCEDURE [EIFFEL_LIST [INSTRUCTION_AS], LOOP_AS])
		do
			loop_body_pre_actions.extend (a)
		end

	add_loop_body_post_action (a: PROCEDURE [EIFFEL_LIST [INSTRUCTION_AS], LOOP_AS])
		do
			loop_body_post_actions.extend (a)
		end

	add_loop_variant_pre_action (a: PROCEDURE [VARIANT_AS, LOOP_AS])
		do
			loop_variant_pre_actions.extend (a)
		end

	add_loop_variant_post_action (a: PROCEDURE [VARIANT_AS, LOOP_AS])
		do
			loop_variant_post_actions.extend (a)
		end

	add_nested_expr_pre_action (a: PROCEDURE [NESTED_EXPR_AS])
		do
			nested_expr_pre_actions.extend (a)
		end

	add_nested_expr_post_action (a: PROCEDURE [NESTED_EXPR_AS])
		do
			nested_expr_post_actions.extend (a)
		end

	add_object_test_pre_action (a_action: attached PROCEDURE [OBJECT_TEST_AS])
		do
			object_test_pre_actions.extend (a_action)
		end

	add_object_test_post_action (a_action: attached PROCEDURE [OBJECT_TEST_AS])
		do
			object_test_post_actions.extend (a_action)
		end

	add_once_pre_action (a_action: attached PROCEDURE [ONCE_AS])
		do
			once_pre_actions.extend (a_action)
		end

	add_once_post_action (a_action: attached PROCEDURE [ONCE_AS])
		do
			once_post_actions.extend (a_action)
		end

	add_parameter_list_pre_action (a_action: attached PROCEDURE [PARAMETER_LIST_AS])
		do
			parameter_list_pre_actions.extend (a_action)
		end

	add_parameter_list_post_action (a_action: attached PROCEDURE [PARAMETER_LIST_AS])
		do
			parameter_list_post_actions.extend (a_action)
		end

	add_paran_pre_action (a_action: attached PROCEDURE [PARAN_AS])
		do
			paran_pre_actions.extend (a_action)
		end

	add_paran_post_action (a_action: attached PROCEDURE [PARAN_AS])
		do
			paran_post_actions.extend (a_action)
		end

	add_precursor_pre_action (a: PROCEDURE [PRECURSOR_AS])
		do
			precursor_pre_actions.extend (a)
		end

	add_precursor_post_action (a: PROCEDURE [PRECURSOR_AS])
		do
			precursor_post_actions.extend (a)
		end

	add_predecessor_pre_action (a: PROCEDURE [PREDECESSOR_AS])
		do
			predecessor_pre_actions.extend (a)
		end

	add_predecessor_post_action (a: PROCEDURE [PREDECESSOR_AS])
		do
			predecessor_post_actions.extend (a)
		end

	add_routine_agent_pre_action (a_action:  PROCEDURE [AGENT_ROUTINE_CREATION_AS])
		do
			agent_routine_pre_action.extend (a_action)
		end

	add_routine_agent_post_action (a_action:  PROCEDURE [AGENT_ROUTINE_CREATION_AS])
		do
			agent_routine_post_action.extend (a_action)
		end

	add_routine_pre_action (a_action: attached PROCEDURE [ROUTINE_AS])
		do
			routine_pre_actions.extend (a_action)
		end

	add_routine_post_action (a_action: attached PROCEDURE [ROUTINE_AS])
		do
			routine_post_actions.extend (a_action)
		end

	add_static_access_pre_action (a: PROCEDURE [STATIC_ACCESS_AS])
		do
			static_access_pre_actions.extend (a)
		end

	add_static_access_post_action (a: PROCEDURE [STATIC_ACCESS_AS])
		do
			static_access_post_actions.extend (a)
		end

	add_unary_pre_action (a_action: attached PROCEDURE [UNARY_AS])
		do
			unary_pre_actions.extend (a_action)
		end

	add_unary_post_action (a_action: attached PROCEDURE [UNARY_AS])
		do
			unary_post_actions.extend (a_action)
		end

	add_un_not_pre_action (a_action: attached PROCEDURE [UN_NOT_AS])
		do
			un_not_pre_actions.extend (a_action)
		end

	add_un_not_post_action (a_action: attached PROCEDURE [UN_NOT_AS])
		do
			un_not_post_actions.extend (a_action)
		end

	add_integer_pre_action (a_action: attached PROCEDURE [INTEGER_AS])
		do
			integer_pre_actions.extend (a_action)
		end

	add_integer_post_action (a_action: attached PROCEDURE [INTEGER_AS])
		do
			integer_post_actions.extend (a_action)
		end

	add_real_pre_action (a_action: attached PROCEDURE [REAL_AS])
		do
			real_pre_actions.extend (a_action)
		end

	add_real_post_action (a_action: attached PROCEDURE [REAL_AS])
		do
			real_post_actions.extend (a_action)
		end

feature {NONE} -- Agent lists

	access_feat_pre_actions, access_feat_post_actions: ACTION_SEQUENCE [TUPLE [ACCESS_FEAT_AS]]

	access_id_pre_actions, access_id_post_actions: ACTION_SEQUENCE [TUPLE [ACCESS_ID_AS]]

	address_pre_actions, address_post_actions: ACTION_SEQUENCE [TUPLE [ADDRESS_AS]]

	agent_routine_pre_action, agent_routine_post_action: ACTION_SEQUENCE [TUPLE [AGENT_ROUTINE_CREATION_AS]]

	array_pre_actions, array_post_actions: ACTION_SEQUENCE [TUPLE [ARRAY_AS]]

	assign_pre_actions, assign_post_actions: ACTION_SEQUENCE [TUPLE [ASSIGN_AS]]

	assigner_call_pre_actions, assigner_call_post_actions: ACTION_SEQUENCE [TUPLE [ASSIGNER_CALL_AS]]

	binary_pre_actions, binary_post_actions: ACTION_SEQUENCE [TUPLE [BINARY_AS]]

	bin_eq_pre_actions, bin_eq_post_actions: ACTION_SEQUENCE [TUPLE [BIN_EQ_AS]]

	bin_ge_pre_actions, bin_ge_post_actions: ACTION_SEQUENCE [TUPLE [BIN_GE_AS]]

	bin_gt_pre_actions, bin_gt_post_actions: ACTION_SEQUENCE [TUPLE [BIN_GT_AS]]

	bin_le_pre_actions, bin_le_post_actions: ACTION_SEQUENCE [TUPLE [BIN_LE_AS]]

	bin_lt_pre_actions, bin_lt_post_actions: ACTION_SEQUENCE [TUPLE [BIN_LT_AS]]

	bin_ne_pre_actions, bin_ne_post_actions: ACTION_SEQUENCE [TUPLE [BIN_NE_AS]]

	bin_not_tilde_pre_actions, bin_not_tilde_post_actions: ACTION_SEQUENCE [TUPLE [BIN_NOT_TILDE_AS]]

	bin_tilde_pre_actions, bin_tilde_post_actions: ACTION_SEQUENCE [TUPLE [BIN_TILDE_AS]]

	body_pre_actions, body_post_actions: ACTION_SEQUENCE [TUPLE [BODY_AS]]

	bracket_pre_actions, bracket_post_actions: ACTION_SEQUENCE [TUPLE [BRACKET_AS]]

	case_pre_actions, case_post_actions: ACTION_SEQUENCE [TUPLE [CASE_AS]]

	class_pre_actions, class_post_actions: ACTION_SEQUENCE [TUPLE [CLASS_AS]]

	converted_expr_pre_actions, converted_expr_post_actions: ACTION_SEQUENCE [TUPLE [CONVERTED_EXPR_AS]]

	create_pre_actions, create_post_actions: ACTION_SEQUENCE [TUPLE [CREATE_AS]]

	creation_pre_actions, creation_post_actions: ACTION_SEQUENCE [TUPLE [CREATION_AS]]

	do_pre_actions, do_post_actions: ACTION_SEQUENCE [TUPLE [DO_AS]]

	eiffel_list_pre_actions, eiffel_list_post_actions: ACTION_SEQUENCE [TUPLE [EIFFEL_LIST [AST_EIFFEL]]]

	elseif_pre_actions, elseif_post_actions: ACTION_SEQUENCE [TUPLE [ELSIF_AS]]

	expression_call_pre_actions, expression_call_post_actions: ACTION_SEQUENCE [EXPR_CALL_AS]

	feature_pre_actions, feature_post_actions: ACTION_SEQUENCE [TUPLE [FEATURE_AS]]

	feature_clause_pre_actions, feature_clause_post_actions: ACTION_SEQUENCE [TUPLE [FEATURE_CLAUSE_AS]]

	guard_pre_actions, guard_post_actions: ACTION_SEQUENCE [TUPLE [GUARD_AS]]

	id_pre_actions, id_post_actions: ACTION_SEQUENCE [TUPLE [ID_AS]]

	if_pre_actions, if_post_actions: ACTION_SEQUENCE [TUPLE [IF_AS]]

	if_expression_pre_actions, if_expression_post_actions: ACTION_SEQUENCE [TUPLE [IF_EXPRESSION_AS]]

	inline_agent_creation_pre_actions, inline_agent_creation_post_actions: ACTION_SEQUENCE [TUPLE [INLINE_AGENT_CREATION_AS]]

	inspect_pre_actions, inspect_post_actions: ACTION_SEQUENCE [TUPLE [INSPECT_AS]]

	instruction_call_pre_actions, instruction_call_post_actions: ACTION_SEQUENCE [TUPLE [INSTR_CALL_AS]]

	invariant_pre_actions, invariant_post_actions: ACTION_SEQUENCE [INVARIANT_AS]

	loop_pre_actions, loop_post_actions: ACTION_SEQUENCE [TUPLE [LOOP_AS]]

	loop_iteration_pre_actions, loop_iteration_post_actions: ACTION_SEQUENCE [TUPLE [ITERATION_AS, LOOP_AS]]

	loop_from_pre_actions, loop_from_post_actions: ACTION_SEQUENCE [TUPLE [EIFFEL_LIST [INSTRUCTION_AS], LOOP_AS]]

	loop_invariant_pre_actions, loop_invariant_post_actions: ACTION_SEQUENCE [TUPLE [EIFFEL_LIST [TAGGED_AS], LOOP_AS]]

	loop_exit_pre_actions, loop_exit_post_actions: ACTION_SEQUENCE [TUPLE [EXPR_AS, LOOP_AS]]

	loop_body_pre_actions, loop_body_post_actions: ACTION_SEQUENCE [TUPLE [EIFFEL_LIST [INSTRUCTION_AS], LOOP_AS]]

	loop_variant_pre_actions, loop_variant_post_actions: ACTION_SEQUENCE [TUPLE [VARIANT_AS, LOOP_AS]]

	nested_expr_pre_actions, nested_expr_post_actions: ACTION_SEQUENCE [NESTED_EXPR_AS]

	object_test_pre_actions, object_test_post_actions: ACTION_SEQUENCE [TUPLE [OBJECT_TEST_AS]]

	once_pre_actions, once_post_actions: ACTION_SEQUENCE [TUPLE [ONCE_AS]]

	paran_pre_actions, paran_post_actions: ACTION_SEQUENCE [TUPLE [PARAN_AS]]

	parameter_list_pre_actions, parameter_list_post_actions: ACTION_SEQUENCE [TUPLE [PARAMETER_LIST_AS]]

	precursor_pre_actions, precursor_post_actions: ACTION_SEQUENCE [TUPLE [PRECURSOR_AS]]

	predecessor_pre_actions, predecessor_post_actions: ACTION_SEQUENCE [TUPLE [PREDECESSOR_AS]]

	routine_pre_actions, routine_post_actions: ACTION_SEQUENCE [TUPLE [ROUTINE_AS]]

	static_access_pre_actions, static_access_post_actions: ACTION_SEQUENCE [TUPLE [STATIC_ACCESS_AS]]

	unary_pre_actions, unary_post_actions: ACTION_SEQUENCE [TUPLE [UNARY_AS]]

	un_not_pre_actions, un_not_post_actions: ACTION_SEQUENCE [TUPLE [UN_NOT_AS]]

	integer_pre_actions, integer_post_actions: ACTION_SEQUENCE [TUPLE [INTEGER_AS]]

	real_pre_actions, real_post_actions: ACTION_SEQUENCE [TUPLE [REAL_AS]]

feature {CA_RULE_CHECKING_TASK} -- Execution Commands

	run_on_class (a_class_to_check: CLASS_C)
			-- Check all rules that have added their agents.
		local
			l_ast: CLASS_AS
		do
			l_ast := a_class_to_check.ast
			class_pre_actions.call (l_ast)
			process_class_as (l_ast)
			class_post_actions.call (l_ast)
		end

feature {NONE} -- Processing

	process_access_feat_as (a_id: ACCESS_FEAT_AS)
		local
			old_is_assigner_call: BOOLEAN
		do
			access_feat_pre_actions.call ([a_id])
			old_is_assigner_call := is_assigner_call
			is_assigner_call := False
			Precursor (a_id)
			is_assigner_call := old_is_assigner_call
			access_feat_post_actions.call ([a_id])
		end

	process_access_id_as (a_id: ACCESS_ID_AS)
		do
			access_id_pre_actions.call ([a_id])
			Precursor (a_id)
			access_id_post_actions.call ([a_id])
		end

	process_address_as (a: ADDRESS_AS)
		do
			address_pre_actions.call (a)
			Precursor (a)
			address_post_actions.call (a)
		end

	process_agent_routine_creation_as (a: AGENT_ROUTINE_CREATION_AS)
		do
			agent_routine_pre_action.call (a)
			Precursor (a)
			agent_routine_post_action.call (a)
		end

	process_array_as (a: ARRAY_AS)
			-- <Precursor>
		do
			array_pre_actions.call (a)
			Precursor (a)
			array_post_actions.call (a)
		end

	process_assign_as (a: ASSIGN_AS)
			-- <Precursor>
		do
			assign_pre_actions.call (a)
			is_assign := True
			a.target.process (Current)
			is_assign := False
			a.source.process (Current)
			assign_post_actions.call (a)
		end

	process_assigner_call_as (a: ASSIGNER_CALL_AS)
		do
			assigner_call_pre_actions.call (a)
			a.source.process (Current)
			is_assigner_call := True
			a.target.process (Current)
			is_assigner_call := False
			assigner_call_post_actions.call (a)
		end

	process_binary_as (a: BINARY_AS)
		local
			old_is_assigner_call: BOOLEAN
		do
			binary_pre_actions.call ([a])
			old_is_assigner_call := is_assigner_call
			is_assigner_call := False
			Precursor (a)
			is_assigner_call := old_is_assigner_call
			binary_post_actions.call ([a])
		end

	process_bin_eq_as (a: BIN_EQ_AS)
		do
			bin_eq_pre_actions.call (a)
			a.left.process (Current)
			a.right.process (Current)
			bin_eq_post_actions.call (a)
		end

	process_bin_ge_as (a_bin_ge: BIN_GE_AS)
		do
			bin_ge_pre_actions.call ([a_bin_ge])
			Precursor (a_bin_ge)
			bin_ge_post_actions.call ([a_bin_ge])
		end

	process_bin_gt_as (a_bin_gt: BIN_GT_AS)
		do
			bin_gt_pre_actions.call ([a_bin_gt])
			Precursor (a_bin_gt)
			bin_gt_post_actions.call ([a_bin_gt])
		end

	process_bin_le_as (a_bin_le: BIN_LE_AS)
		do
			bin_le_pre_actions.call ([a_bin_le])
			Precursor (a_bin_le)
			bin_le_post_actions.call ([a_bin_le])
		end

	process_bin_lt_as (a_bin_lt: BIN_LT_AS)
		do
			bin_lt_pre_actions.call ([a_bin_lt])
			Precursor (a_bin_lt)
			bin_lt_post_actions.call ([a_bin_lt])
		end

	process_bin_ne_as (a: BIN_NE_AS)
		do
			bin_ne_pre_actions.call (a)
			a.left.process (Current)
			a.right.process (Current)
			bin_ne_post_actions.call (a)
		end

	process_bin_not_tilde_as (a: BIN_NOT_TILDE_AS)
			-- <Precursor>
		do
			bin_not_tilde_pre_actions.call (a)
			a.left.process (Current)
			a.right.process (Current)
			bin_not_tilde_post_actions.call (a)
		end

	process_bin_tilde_as (a: BIN_TILDE_AS)
			-- <Precursor>
		do
			bin_tilde_pre_actions.call (a)
			a.left.process (Current)
			a.right.process (Current)
			bin_tilde_post_actions.call (a)
		end

	process_body_as (a_body: BODY_AS)
		do
			body_pre_actions.call ([a_body])
			Precursor (a_body)
			body_post_actions.call ([a_body])
		end

	process_bracket_as (a: BRACKET_AS)
		local
			old_is_assigner_call: BOOLEAN
		do
			bracket_pre_actions.call ([a])
			old_is_assigner_call := is_assigner_call
			is_assigner_call := False
			Precursor (a)
			is_assigner_call := old_is_assigner_call
			bracket_post_actions.call ([a])
		end

	process_case_as (a_case: CASE_AS)
		do
			case_pre_actions.call ([a_case])
			Precursor (a_case)
			case_post_actions.call ([a_case])
		end

	process_converted_expr_as (a_conv: CONVERTED_EXPR_AS)
		do
			converted_expr_pre_actions.call ([a_conv])
			Precursor (a_conv)
			converted_expr_post_actions.call ([a_conv])
		end

	process_create_as (a_create: CREATE_AS)
		do
			create_pre_actions.call ([a_create])
			Precursor (a_create)
			create_post_actions.call ([a_create])
		end

	process_creation_as (a: CREATION_AS)
		do
			creation_pre_actions.call (a)
			is_assign := True
			a.target.process (Current)
			is_assign := False
			safe_process (a.type)
			safe_process (a.call)
			creation_post_actions.call (a)
		end

	process_do_as (a_do: DO_AS)
		do
			do_pre_actions.call ([a_do])
			Precursor (a_do)
			do_post_actions.call ([a_do])
		end

	process_eiffel_list (a_list: EIFFEL_LIST [AST_EIFFEL])
		do
			eiffel_list_pre_actions.call ([a_list])
			Precursor (a_list)
			eiffel_list_post_actions.call ([a_list])
		end

	process_elseif_as (a_elseif: ELSIF_AS)
		do
			elseif_pre_actions.call ([a_elseif])
			Precursor (a_elseif)
			elseif_post_actions.call ([a_elseif])
		end

	process_expr_call_as (a: EXPR_CALL_AS)
			-- <Precursor>
		do
			expression_call_pre_actions.call (a)
			Precursor (a)
			expression_call_post_actions.call (a)
		end

	process_feature_as (a_feature: FEATURE_AS)
		do
			feature_pre_actions.call ([a_feature])
			Precursor (a_feature)
			feature_post_actions.call ([a_feature])
		end

	process_feature_clause_as (a_clause: FEATURE_CLAUSE_AS)
		do
			feature_clause_pre_actions.call ([a_clause])
			Precursor (a_clause)
			feature_clause_post_actions.call ([a_clause])
		end

	process_guard_as (a: GUARD_AS)
		do
			guard_pre_actions.call (a)
			Precursor (a)
			guard_post_actions.call (a)
		end

	process_id_as (a_id: ID_AS)
		do
			id_pre_actions.call ([a_id])
			Precursor (a_id)
			id_post_actions.call ([a_id])
		end

	process_if_as (a_if: IF_AS)
		do
			if_pre_actions.call ([a_if])
			Precursor (a_if)
			if_post_actions.call ([a_if])
		end

	process_if_expression_as (a: IF_EXPRESSION_AS)
		do
			if_expression_pre_actions.call (a)
			Precursor (a)
			if_expression_post_actions.call (a)
		end

	process_inline_agent_creation_as (a: INLINE_AGENT_CREATION_AS)
		do
			inline_agent_creation_pre_actions.call (a)
			Precursor (a)
			inline_agent_creation_post_actions.call (a)
		end

	process_inspect_as (a_inspect: INSPECT_AS)
		do
			inspect_pre_actions.call ([a_inspect])
			Precursor (a_inspect)
			inspect_post_actions.call ([a_inspect])
		end

	process_instr_call_as (a_call: INSTR_CALL_AS)
		do
			instruction_call_pre_actions.call ([a_call])
			Precursor (a_call)
			instruction_call_post_actions.call ([a_call])
		end

	process_invariant_as (a: INVARIANT_AS)
		do
			invariant_pre_actions.call (a)
			Precursor (a)
			invariant_post_actions.call (a)
		end

	process_loop_as (a: LOOP_AS)
			-- <Precursor>
		do
			loop_pre_actions.call (a)
			if attached a.iteration as p then
				loop_iteration_pre_actions.call (p, a)
				p.process (Current)
				loop_iteration_post_actions.call (p, a)
			end
			if attached a.from_part as p then
				loop_from_pre_actions.call (p, a)
				p.process (Current)
				loop_from_post_actions.call (p, a)
			end
			if attached a.invariant_part as p then
				loop_invariant_pre_actions.call (p, a)
				p.process (Current)
				loop_invariant_post_actions.call (p, a)
			end
			if attached a.stop as p then
				loop_exit_pre_actions.call (p, a)
				p.process (Current)
				loop_exit_post_actions.call (p, a)
			end
			if attached a.compound as p then
				loop_body_pre_actions.call (p, a)
				p.process (Current)
				loop_body_post_actions.call (p, a)
			end
			if attached a.variant_part as p then
				loop_variant_pre_actions.call (p, a)
				p.process (Current)
				loop_variant_post_actions.call (p, a)
			end
			loop_post_actions.call (a)
		end

	process_nested_expr_as (a: NESTED_EXPR_AS)
		local
			old_is_assigner_call: BOOLEAN
		do
			nested_expr_pre_actions.call (a)
			old_is_assigner_call := is_assigner_call
			is_assigner_call := False
			a.target.process (Current)
			is_assigner_call := old_is_assigner_call
			a.message.process (Current)
			nested_expr_post_actions.call (a)
		end

	process_object_test_as (a_ot: OBJECT_TEST_AS)
		do
			object_test_pre_actions.call ([a_ot])
			Precursor (a_ot)
			object_test_post_actions.call ([a_ot])
		end

	process_once_as (a_once: ONCE_AS)
		do
			once_pre_actions.call ([a_once])
			Precursor (a_once)
			once_post_actions.call ([a_once])
		end

	process_parameter_list_as (a: PARAMETER_LIST_AS)
		do
			parameter_list_pre_actions.call ([a])
			Precursor (a)
			parameter_list_post_actions.call ([a])
		end

	process_paran_as (a_paran: PARAN_AS)
		do
			paran_pre_actions.call ([a_paran])
			Precursor (a_paran)
			paran_post_actions.call ([a_paran])
		end

	process_precursor_as (a: PRECURSOR_AS)
		do
			precursor_pre_actions.call (a)
			Precursor (a)
			precursor_post_actions.call (a)
		end

	process_predecessor_as (a: PREDECESSOR_AS)
		do
			predecessor_pre_actions.call (a)
			Precursor (a)
			predecessor_post_actions.call (a)
		end

	process_routine_as (a_routine: ROUTINE_AS)
		do
			routine_pre_actions.call ([a_routine])
			Precursor (a_routine)
			routine_post_actions.call ([a_routine])
		end

	process_static_access_as (a: STATIC_ACCESS_AS)
		do
			static_access_pre_actions.call (a)
			Precursor (a)
			static_access_post_actions.call (a)
		end

	process_un_not_as (a_un_not: UN_NOT_AS)
		do
			un_not_pre_actions.call ([a_un_not])
			Precursor (a_un_not)
			un_not_post_actions.call ([a_un_not])
		end

	process_unary_as (a_unary: UNARY_AS)
		local
			old_is_assigner_call: BOOLEAN
		do
			unary_pre_actions.call ([a_unary])
			old_is_assigner_call := is_assigner_call
			is_assigner_call := False
			Precursor (a_unary)
			is_assigner_call := old_is_assigner_call
			unary_post_actions.call ([a_unary])
		end

	process_integer_as (a_integer: INTEGER_AS)
		do
			integer_pre_actions.call ([a_integer])
			Precursor (a_integer)
			integer_post_actions.call ([a_integer])
		end

	process_real_as (a_real: REAL_AS)
		do
			real_pre_actions.call ([a_real])
			Precursor (a_real)
			real_post_actions.call ([a_real])
		end

note
	ca_ignore: "CA033", "CA033: very long class"
	copyright:	"Copyright (c) 2014-2020, Eiffel Software"
	license:	"GPL version 2 (see http://www.eiffel.com/licensing/gpl.txt)"
	licensing_options:	"http://www.eiffel.com/licensing"
	copying: "[
			This file is part of Eiffel Software's Eiffel Development Environment.
			
			Eiffel Software's Eiffel Development Environment 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, version 2 of the License
			(available at the URL listed under "license" above).
			
			Eiffel Software's Eiffel Development Environment 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 Eiffel Software's Eiffel Development
			Environment; if not, write to the Free Software Foundation,
			Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
		]"
	source: "[
			Eiffel Software
			5949 Hollister Ave., Goleta, CA 93117 USA
			Telephone 805-685-1006, Fax 805-685-6869
			Website http://www.eiffel.com
			Customer support http://support.eiffel.com
		]"

end