pascalabcnet/SyntaxTree/tree/HierarchyVisitor.cs

namespace PascalABCCompiler.SyntaxTree
{

	public class HierarchyVisitor: AbstractVisitor
	{

		public virtual void pre_do_visit(expression _expression)
		{
		}

		public virtual void post_do_visit(expression _expression)
		{
		}

		public virtual void pre_do_visit(syntax_tree_node _syntax_tree_node)
		{
		}

		public virtual void post_do_visit(syntax_tree_node _syntax_tree_node)
		{
		}

		public virtual void pre_do_visit(statement _statement)
		{
		}

		public virtual void post_do_visit(statement _statement)
		{
		}

		public virtual void pre_do_visit(statement_list _statement_list)
		{
		}

		public virtual void post_do_visit(statement_list _statement_list)
		{
		}

		public virtual void pre_do_visit(ident _ident)
		{
		}

		public virtual void post_do_visit(ident _ident)
		{
		}

		public virtual void pre_do_visit(assign _assign)
		{
		}

		public virtual void post_do_visit(assign _assign)
		{
		}

		public virtual void pre_do_visit(bin_expr _bin_expr)
		{
		}

		public virtual void post_do_visit(bin_expr _bin_expr)
		{
		}

		public virtual void pre_do_visit(un_expr _un_expr)
		{
		}

		public virtual void post_do_visit(un_expr _un_expr)
		{
		}

		public virtual void pre_do_visit(const_node _const_node)
		{
		}

		public virtual void post_do_visit(const_node _const_node)
		{
		}

		public virtual void pre_do_visit(bool_const _bool_const)
		{
		}

		public virtual void post_do_visit(bool_const _bool_const)
		{
		}

		public virtual void pre_do_visit(int32_const _int32_const)
		{
		}

		public virtual void post_do_visit(int32_const _int32_const)
		{
		}

		public virtual void pre_do_visit(double_const _double_const)
		{
		}

		public virtual void post_do_visit(double_const _double_const)
		{
		}

		public virtual void pre_do_visit(subprogram_body _subprogram_body)
		{
		}

		public virtual void post_do_visit(subprogram_body _subprogram_body)
		{
		}

		public virtual void pre_do_visit(addressed_value _addressed_value)
		{
		}

		public virtual void post_do_visit(addressed_value _addressed_value)
		{
		}

		public virtual void pre_do_visit(type_definition _type_definition)
		{
		}

		public virtual void post_do_visit(type_definition _type_definition)
		{
		}

		public virtual void pre_do_visit(roof_dereference _roof_dereference)
		{
		}

		public virtual void post_do_visit(roof_dereference _roof_dereference)
		{
		}

		public virtual void pre_do_visit(named_type_reference _named_type_reference)
		{
		}

		public virtual void post_do_visit(named_type_reference _named_type_reference)
		{
		}

		public virtual void pre_do_visit(variable_definitions _variable_definitions)
		{
		}

		public virtual void post_do_visit(variable_definitions _variable_definitions)
		{
		}

		public virtual void pre_do_visit(ident_list _ident_list)
		{
		}

		public virtual void post_do_visit(ident_list _ident_list)
		{
		}

		public virtual void pre_do_visit(var_def_statement _var_def_statement)
		{
		}

		public virtual void post_do_visit(var_def_statement _var_def_statement)
		{
		}

		public virtual void pre_do_visit(declaration _declaration)
		{
		}

		public virtual void post_do_visit(declaration _declaration)
		{
		}

		public virtual void pre_do_visit(declarations _declarations)
		{
		}

		public virtual void post_do_visit(declarations _declarations)
		{
		}

		public virtual void pre_do_visit(program_tree _program_tree)
		{
		}

		public virtual void post_do_visit(program_tree _program_tree)
		{
		}

		public virtual void pre_do_visit(program_name _program_name)
		{
		}

		public virtual void post_do_visit(program_name _program_name)
		{
		}

		public virtual void pre_do_visit(string_const _string_const)
		{
		}

		public virtual void post_do_visit(string_const _string_const)
		{
		}

		public virtual void pre_do_visit(expression_list _expression_list)
		{
		}

		public virtual void post_do_visit(expression_list _expression_list)
		{
		}

		public virtual void pre_do_visit(dereference _dereference)
		{
		}

		public virtual void post_do_visit(dereference _dereference)
		{
		}

		public virtual void pre_do_visit(indexer _indexer)
		{
		}

		public virtual void post_do_visit(indexer _indexer)
		{
		}

		public virtual void pre_do_visit(for_node _for_node)
		{
		}

		public virtual void post_do_visit(for_node _for_node)
		{
		}

		public virtual void pre_do_visit(repeat_node _repeat_node)
		{
		}

		public virtual void post_do_visit(repeat_node _repeat_node)
		{
		}

		public virtual void pre_do_visit(while_node _while_node)
		{
		}

		public virtual void post_do_visit(while_node _while_node)
		{
		}

		public virtual void pre_do_visit(if_node _if_node)
		{
		}

		public virtual void post_do_visit(if_node _if_node)
		{
		}

		public virtual void pre_do_visit(ref_type _ref_type)
		{
		}

		public virtual void post_do_visit(ref_type _ref_type)
		{
		}

		public virtual void pre_do_visit(diapason _diapason)
		{
		}

		public virtual void post_do_visit(diapason _diapason)
		{
		}

		public virtual void pre_do_visit(indexers_types _indexers_types)
		{
		}

		public virtual void post_do_visit(indexers_types _indexers_types)
		{
		}

		public virtual void pre_do_visit(array_type _array_type)
		{
		}

		public virtual void post_do_visit(array_type _array_type)
		{
		}

		public virtual void pre_do_visit(label_definitions _label_definitions)
		{
		}

		public virtual void post_do_visit(label_definitions _label_definitions)
		{
		}

		public virtual void pre_do_visit(procedure_attribute _procedure_attribute)
		{
		}

		public virtual void post_do_visit(procedure_attribute _procedure_attribute)
		{
		}

		public virtual void pre_do_visit(typed_parameters _typed_parameters)
		{
		}

		public virtual void post_do_visit(typed_parameters _typed_parameters)
		{
		}

		public virtual void pre_do_visit(formal_parameters _formal_parameters)
		{
		}

		public virtual void post_do_visit(formal_parameters _formal_parameters)
		{
		}

		public virtual void pre_do_visit(procedure_attributes_list _procedure_attributes_list)
		{
		}

		public virtual void post_do_visit(procedure_attributes_list _procedure_attributes_list)
		{
		}

		public virtual void pre_do_visit(procedure_header _procedure_header)
		{
		}

		public virtual void post_do_visit(procedure_header _procedure_header)
		{
		}

		public virtual void pre_do_visit(function_header _function_header)
		{
		}

		public virtual void post_do_visit(function_header _function_header)
		{
		}

		public virtual void pre_do_visit(procedure_definition _procedure_definition)
		{
		}

		public virtual void post_do_visit(procedure_definition _procedure_definition)
		{
		}

		public virtual void pre_do_visit(type_declaration _type_declaration)
		{
		}

		public virtual void post_do_visit(type_declaration _type_declaration)
		{
		}

		public virtual void pre_do_visit(type_declarations _type_declarations)
		{
		}

		public virtual void post_do_visit(type_declarations _type_declarations)
		{
		}

		public virtual void pre_do_visit(simple_const_definition _simple_const_definition)
		{
		}

		public virtual void post_do_visit(simple_const_definition _simple_const_definition)
		{
		}

		public virtual void pre_do_visit(typed_const_definition _typed_const_definition)
		{
		}

		public virtual void post_do_visit(typed_const_definition _typed_const_definition)
		{
		}

		public virtual void pre_do_visit(const_definition _const_definition)
		{
		}

		public virtual void post_do_visit(const_definition _const_definition)
		{
		}

		public virtual void pre_do_visit(consts_definitions_list _consts_definitions_list)
		{
		}

		public virtual void post_do_visit(consts_definitions_list _consts_definitions_list)
		{
		}

		public virtual void pre_do_visit(unit_name _unit_name)
		{
		}

		public virtual void post_do_visit(unit_name _unit_name)
		{
		}

		public virtual void pre_do_visit(unit_or_namespace _unit_or_namespace)
		{
		}

		public virtual void post_do_visit(unit_or_namespace _unit_or_namespace)
		{
		}

		public virtual void pre_do_visit(uses_unit_in _uses_unit_in)
		{
		}

		public virtual void post_do_visit(uses_unit_in _uses_unit_in)
		{
		}

		public virtual void pre_do_visit(uses_list _uses_list)
		{
		}

		public virtual void post_do_visit(uses_list _uses_list)
		{
		}

		public virtual void pre_do_visit(program_body _program_body)
		{
		}

		public virtual void post_do_visit(program_body _program_body)
		{
		}

		public virtual void pre_do_visit(compilation_unit _compilation_unit)
		{
		}

		public virtual void post_do_visit(compilation_unit _compilation_unit)
		{
		}

		public virtual void pre_do_visit(unit_module _unit_module)
		{
		}

		public virtual void post_do_visit(unit_module _unit_module)
		{
		}

		public virtual void pre_do_visit(program_module _program_module)
		{
		}

		public virtual void post_do_visit(program_module _program_module)
		{
		}

		public virtual void pre_do_visit(hex_constant _hex_constant)
		{
		}

		public virtual void post_do_visit(hex_constant _hex_constant)
		{
		}

		public virtual void pre_do_visit(get_address _get_address)
		{
		}

		public virtual void post_do_visit(get_address _get_address)
		{
		}

		public virtual void pre_do_visit(case_variant _case_variant)
		{
		}

		public virtual void post_do_visit(case_variant _case_variant)
		{
		}

		public virtual void pre_do_visit(case_node _case_node)
		{
		}

		public virtual void post_do_visit(case_node _case_node)
		{
		}

		public virtual void pre_do_visit(method_name _method_name)
		{
		}

		public virtual void post_do_visit(method_name _method_name)
		{
		}

		public virtual void pre_do_visit(dot_node _dot_node)
		{
		}

		public virtual void post_do_visit(dot_node _dot_node)
		{
		}

		public virtual void pre_do_visit(empty_statement _empty_statement)
		{
		}

		public virtual void post_do_visit(empty_statement _empty_statement)
		{
		}

		public virtual void pre_do_visit(goto_statement _goto_statement)
		{
		}

		public virtual void post_do_visit(goto_statement _goto_statement)
		{
		}

		public virtual void pre_do_visit(labeled_statement _labeled_statement)
		{
		}

		public virtual void post_do_visit(labeled_statement _labeled_statement)
		{
		}

		public virtual void pre_do_visit(with_statement _with_statement)
		{
		}

		public virtual void post_do_visit(with_statement _with_statement)
		{
		}

		public virtual void pre_do_visit(method_call _method_call)
		{
		}

		public virtual void post_do_visit(method_call _method_call)
		{
		}

		public virtual void pre_do_visit(pascal_set_constant _pascal_set_constant)
		{
		}

		public virtual void post_do_visit(pascal_set_constant _pascal_set_constant)
		{
		}

		public virtual void pre_do_visit(array_const _array_const)
		{
		}

		public virtual void post_do_visit(array_const _array_const)
		{
		}

		public virtual void pre_do_visit(write_accessor_name _write_accessor_name)
		{
		}

		public virtual void post_do_visit(write_accessor_name _write_accessor_name)
		{
		}

		public virtual void pre_do_visit(read_accessor_name _read_accessor_name)
		{
		}

		public virtual void post_do_visit(read_accessor_name _read_accessor_name)
		{
		}

		public virtual void pre_do_visit(property_accessors _property_accessors)
		{
		}

		public virtual void post_do_visit(property_accessors _property_accessors)
		{
		}

		public virtual void pre_do_visit(simple_property _simple_property)
		{
		}

		public virtual void post_do_visit(simple_property _simple_property)
		{
		}

		public virtual void pre_do_visit(index_property _index_property)
		{
		}

		public virtual void post_do_visit(index_property _index_property)
		{
		}

		public virtual void pre_do_visit(class_members _class_members)
		{
		}

		public virtual void post_do_visit(class_members _class_members)
		{
		}

		public virtual void pre_do_visit(access_modifer_node _access_modifer_node)
		{
		}

		public virtual void post_do_visit(access_modifer_node _access_modifer_node)
		{
		}

		public virtual void pre_do_visit(class_body_list _class_body_list)
		{
		}

		public virtual void post_do_visit(class_body_list _class_body_list)
		{
		}

		public virtual void pre_do_visit(class_definition _class_definition)
		{
		}

		public virtual void post_do_visit(class_definition _class_definition)
		{
		}

		public virtual void pre_do_visit(default_indexer_property_node _default_indexer_property_node)
		{
		}

		public virtual void post_do_visit(default_indexer_property_node _default_indexer_property_node)
		{
		}

		public virtual void pre_do_visit(known_type_definition _known_type_definition)
		{
		}

		public virtual void post_do_visit(known_type_definition _known_type_definition)
		{
		}

		public virtual void pre_do_visit(set_type_definition _set_type_definition)
		{
		}

		public virtual void post_do_visit(set_type_definition _set_type_definition)
		{
		}

		public virtual void pre_do_visit(record_const_definition _record_const_definition)
		{
		}

		public virtual void post_do_visit(record_const_definition _record_const_definition)
		{
		}

		public virtual void pre_do_visit(record_const _record_const)
		{
		}

		public virtual void post_do_visit(record_const _record_const)
		{
		}

		public virtual void pre_do_visit(record_type _record_type)
		{
		}

		public virtual void post_do_visit(record_type _record_type)
		{
		}

		public virtual void pre_do_visit(enum_type_definition _enum_type_definition)
		{
		}

		public virtual void post_do_visit(enum_type_definition _enum_type_definition)
		{
		}

		public virtual void pre_do_visit(char_const _char_const)
		{
		}

		public virtual void post_do_visit(char_const _char_const)
		{
		}

		public virtual void pre_do_visit(raise_statement _raise_statement)
		{
		}

		public virtual void post_do_visit(raise_statement _raise_statement)
		{
		}

		public virtual void pre_do_visit(sharp_char_const _sharp_char_const)
		{
		}

		public virtual void post_do_visit(sharp_char_const _sharp_char_const)
		{
		}

		public virtual void pre_do_visit(literal_const_line _literal_const_line)
		{
		}

		public virtual void post_do_visit(literal_const_line _literal_const_line)
		{
		}

		public virtual void pre_do_visit(string_num_definition _string_num_definition)
		{
		}

		public virtual void post_do_visit(string_num_definition _string_num_definition)
		{
		}

		public virtual void pre_do_visit(variant _variant)
		{
		}

		public virtual void post_do_visit(variant _variant)
		{
		}

		public virtual void pre_do_visit(variant_list _variant_list)
		{
		}

		public virtual void post_do_visit(variant_list _variant_list)
		{
		}

		public virtual void pre_do_visit(variant_type _variant_type)
		{
		}

		public virtual void post_do_visit(variant_type _variant_type)
		{
		}

		public virtual void pre_do_visit(variant_types _variant_types)
		{
		}

		public virtual void post_do_visit(variant_types _variant_types)
		{
		}

		public virtual void pre_do_visit(variant_record_type _variant_record_type)
		{
		}

		public virtual void post_do_visit(variant_record_type _variant_record_type)
		{
		}

		public virtual void pre_do_visit(procedure_call _procedure_call)
		{
		}

		public virtual void post_do_visit(procedure_call _procedure_call)
		{
		}

		public virtual void pre_do_visit(class_predefinition _class_predefinition)
		{
		}

		public virtual void post_do_visit(class_predefinition _class_predefinition)
		{
		}

		public virtual void pre_do_visit(nil_const _nil_const)
		{
		}

		public virtual void post_do_visit(nil_const _nil_const)
		{
		}

		public virtual void pre_do_visit(file_type_definition _file_type_definition)
		{
		}

		public virtual void post_do_visit(file_type_definition _file_type_definition)
		{
		}

		public virtual void pre_do_visit(constructor _constructor)
		{
		}

		public virtual void post_do_visit(constructor _constructor)
		{
		}

		public virtual void pre_do_visit(destructor _destructor)
		{
		}

		public virtual void post_do_visit(destructor _destructor)
		{
		}

		public virtual void pre_do_visit(inherited_method_call _inherited_method_call)
		{
		}

		public virtual void post_do_visit(inherited_method_call _inherited_method_call)
		{
		}

		public virtual void pre_do_visit(typecast_node _typecast_node)
		{
		}

		public virtual void post_do_visit(typecast_node _typecast_node)
		{
		}

		public virtual void pre_do_visit(interface_node _interface_node)
		{
		}

		public virtual void post_do_visit(interface_node _interface_node)
		{
		}

		public virtual void pre_do_visit(implementation_node _implementation_node)
		{
		}

		public virtual void post_do_visit(implementation_node _implementation_node)
		{
		}

		public virtual void pre_do_visit(diap_expr _diap_expr)
		{
		}

		public virtual void post_do_visit(diap_expr _diap_expr)
		{
		}

		public virtual void pre_do_visit(block _block)
		{
		}

		public virtual void post_do_visit(block _block)
		{
		}

		public virtual void pre_do_visit(proc_block _proc_block)
		{
		}

		public virtual void post_do_visit(proc_block _proc_block)
		{
		}

		public virtual void pre_do_visit(array_of_named_type_definition _array_of_named_type_definition)
		{
		}

		public virtual void post_do_visit(array_of_named_type_definition _array_of_named_type_definition)
		{
		}

		public virtual void pre_do_visit(array_of_const_type_definition _array_of_const_type_definition)
		{
		}

		public virtual void post_do_visit(array_of_const_type_definition _array_of_const_type_definition)
		{
		}

		public virtual void pre_do_visit(literal _literal)
		{
		}

		public virtual void post_do_visit(literal _literal)
		{
		}

		public virtual void pre_do_visit(case_variants _case_variants)
		{
		}

		public virtual void post_do_visit(case_variants _case_variants)
		{
		}

		public virtual void pre_do_visit(diapason_expr _diapason_expr)
		{
		}

		public virtual void post_do_visit(diapason_expr _diapason_expr)
		{
		}

		public virtual void pre_do_visit(var_def_list_for_record _var_def_list_for_record)
		{
		}

		public virtual void post_do_visit(var_def_list_for_record _var_def_list_for_record)
		{
		}

		public virtual void pre_do_visit(record_type_parts _record_type_parts)
		{
		}

		public virtual void post_do_visit(record_type_parts _record_type_parts)
		{
		}

		public virtual void pre_do_visit(property_array_default _property_array_default)
		{
		}

		public virtual void post_do_visit(property_array_default _property_array_default)
		{
		}

		public virtual void pre_do_visit(property_interface _property_interface)
		{
		}

		public virtual void post_do_visit(property_interface _property_interface)
		{
		}

		public virtual void pre_do_visit(property_parameter _property_parameter)
		{
		}

		public virtual void post_do_visit(property_parameter _property_parameter)
		{
		}

		public virtual void pre_do_visit(property_parameter_list _property_parameter_list)
		{
		}

		public virtual void post_do_visit(property_parameter_list _property_parameter_list)
		{
		}

		public virtual void pre_do_visit(inherited_ident _inherited_ident)
		{
		}

		public virtual void post_do_visit(inherited_ident _inherited_ident)
		{
		}

		public virtual void pre_do_visit(format_expr _format_expr)
		{
		}

		public virtual void post_do_visit(format_expr _format_expr)
		{
		}

		public virtual void pre_do_visit(initfinal_part _initfinal_part)
		{
		}

		public virtual void post_do_visit(initfinal_part _initfinal_part)
		{
		}

		public virtual void pre_do_visit(token_info _token_info)
		{
		}

		public virtual void post_do_visit(token_info _token_info)
		{
		}

		public virtual void pre_do_visit(raise_stmt _raise_stmt)
		{
		}

		public virtual void post_do_visit(raise_stmt _raise_stmt)
		{
		}

		public virtual void pre_do_visit(op_type_node _op_type_node)
		{
		}

		public virtual void post_do_visit(op_type_node _op_type_node)
		{
		}

		public virtual void pre_do_visit(file_type _file_type)
		{
		}

		public virtual void post_do_visit(file_type _file_type)
		{
		}

		public virtual void pre_do_visit(known_type_ident _known_type_ident)
		{
		}

		public virtual void post_do_visit(known_type_ident _known_type_ident)
		{
		}

		public virtual void pre_do_visit(exception_handler _exception_handler)
		{
		}

		public virtual void post_do_visit(exception_handler _exception_handler)
		{
		}

		public virtual void pre_do_visit(exception_ident _exception_ident)
		{
		}

		public virtual void post_do_visit(exception_ident _exception_ident)
		{
		}

		public virtual void pre_do_visit(exception_handler_list _exception_handler_list)
		{
		}

		public virtual void post_do_visit(exception_handler_list _exception_handler_list)
		{
		}

		public virtual void pre_do_visit(exception_block _exception_block)
		{
		}

		public virtual void post_do_visit(exception_block _exception_block)
		{
		}

		public virtual void pre_do_visit(try_handler _try_handler)
		{
		}

		public virtual void post_do_visit(try_handler _try_handler)
		{
		}

		public virtual void pre_do_visit(try_handler_finally _try_handler_finally)
		{
		}

		public virtual void post_do_visit(try_handler_finally _try_handler_finally)
		{
		}

		public virtual void pre_do_visit(try_handler_except _try_handler_except)
		{
		}

		public virtual void post_do_visit(try_handler_except _try_handler_except)
		{
		}

		public virtual void pre_do_visit(try_stmt _try_stmt)
		{
		}

		public virtual void post_do_visit(try_stmt _try_stmt)
		{
		}

		public virtual void pre_do_visit(inherited_message _inherited_message)
		{
		}

		public virtual void post_do_visit(inherited_message _inherited_message)
		{
		}

		public virtual void pre_do_visit(external_directive _external_directive)
		{
		}

		public virtual void post_do_visit(external_directive _external_directive)
		{
		}

		public virtual void pre_do_visit(using_list _using_list)
		{
		}

		public virtual void post_do_visit(using_list _using_list)
		{
		}

		public virtual void pre_do_visit(jump_stmt _jump_stmt)
		{
		}

		public virtual void post_do_visit(jump_stmt _jump_stmt)
		{
		}

		public virtual void pre_do_visit(loop_stmt _loop_stmt)
		{
		}

		public virtual void post_do_visit(loop_stmt _loop_stmt)
		{
		}

		public virtual void pre_do_visit(foreach_stmt _foreach_stmt)
		{
		}

		public virtual void post_do_visit(foreach_stmt _foreach_stmt)
		{
		}

		public virtual void pre_do_visit(addressed_value_funcname _addressed_value_funcname)
		{
		}

		public virtual void post_do_visit(addressed_value_funcname _addressed_value_funcname)
		{
		}

		public virtual void pre_do_visit(named_type_reference_list _named_type_reference_list)
		{
		}

		public virtual void post_do_visit(named_type_reference_list _named_type_reference_list)
		{
		}

		public virtual void pre_do_visit(template_param_list _template_param_list)
		{
		}

		public virtual void post_do_visit(template_param_list _template_param_list)
		{
		}

		public virtual void pre_do_visit(template_type_reference _template_type_reference)
		{
		}

		public virtual void post_do_visit(template_type_reference _template_type_reference)
		{
		}

		public virtual void pre_do_visit(int64_const _int64_const)
		{
		}

		public virtual void post_do_visit(int64_const _int64_const)
		{
		}

		public virtual void pre_do_visit(uint64_const _uint64_const)
		{
		}

		public virtual void post_do_visit(uint64_const _uint64_const)
		{
		}

		public virtual void pre_do_visit(new_expr _new_expr)
		{
		}

		public virtual void post_do_visit(new_expr _new_expr)
		{
		}

		public virtual void pre_do_visit(where_type_specificator_list _where_type_specificator_list)
		{
		}

		public virtual void post_do_visit(where_type_specificator_list _where_type_specificator_list)
		{
		}

		public virtual void pre_do_visit(where_definition _where_definition)
		{
		}

		public virtual void post_do_visit(where_definition _where_definition)
		{
		}

		public virtual void pre_do_visit(where_definition_list _where_definition_list)
		{
		}

		public virtual void post_do_visit(where_definition_list _where_definition_list)
		{
		}

		public virtual void pre_do_visit(sizeof_operator _sizeof_operator)
		{
		}

		public virtual void post_do_visit(sizeof_operator _sizeof_operator)
		{
		}

		public virtual void pre_do_visit(typeof_operator _typeof_operator)
		{
		}

		public virtual void post_do_visit(typeof_operator _typeof_operator)
		{
		}

		public virtual void pre_do_visit(compiler_directive _compiler_directive)
		{
		}

		public virtual void post_do_visit(compiler_directive _compiler_directive)
		{
		}

		public virtual void pre_do_visit(operator_name_ident _operator_name_ident)
		{
		}

		public virtual void post_do_visit(operator_name_ident _operator_name_ident)
		{
		}

		public virtual void pre_do_visit(var_statement _var_statement)
		{
		}

		public virtual void post_do_visit(var_statement _var_statement)
		{
		}

		public virtual void pre_do_visit(question_colon_expression _question_colon_expression)
		{
		}

		public virtual void post_do_visit(question_colon_expression _question_colon_expression)
		{
		}

		public virtual void pre_do_visit(expression_as_statement _expression_as_statement)
		{
		}

		public virtual void post_do_visit(expression_as_statement _expression_as_statement)
		{
		}

		public virtual void pre_do_visit(c_scalar_type _c_scalar_type)
		{
		}

		public virtual void post_do_visit(c_scalar_type _c_scalar_type)
		{
		}

		public virtual void pre_do_visit(c_module _c_module)
		{
		}

		public virtual void post_do_visit(c_module _c_module)
		{
		}

		public virtual void pre_do_visit(declarations_as_statement _declarations_as_statement)
		{
		}

		public virtual void post_do_visit(declarations_as_statement _declarations_as_statement)
		{
		}

		public virtual void pre_do_visit(array_size _array_size)
		{
		}

		public virtual void post_do_visit(array_size _array_size)
		{
		}

		public virtual void pre_do_visit(enumerator _enumerator)
		{
		}

		public virtual void post_do_visit(enumerator _enumerator)
		{
		}

		public virtual void pre_do_visit(enumerator_list _enumerator_list)
		{
		}

		public virtual void post_do_visit(enumerator_list _enumerator_list)
		{
		}

		public virtual void pre_do_visit(c_for_cycle _c_for_cycle)
		{
		}

		public virtual void post_do_visit(c_for_cycle _c_for_cycle)
		{
		}

		public virtual void pre_do_visit(switch_stmt _switch_stmt)
		{
		}

		public virtual void post_do_visit(switch_stmt _switch_stmt)
		{
		}

		public virtual void pre_do_visit(type_definition_attr_list _type_definition_attr_list)
		{
		}

		public virtual void post_do_visit(type_definition_attr_list _type_definition_attr_list)
		{
		}

		public virtual void pre_do_visit(type_definition_attr _type_definition_attr)
		{
		}

		public virtual void post_do_visit(type_definition_attr _type_definition_attr)
		{
		}

		public virtual void pre_do_visit(lock_stmt _lock_stmt)
		{
		}

		public virtual void post_do_visit(lock_stmt _lock_stmt)
		{
		}

		public virtual void pre_do_visit(compiler_directive_list _compiler_directive_list)
		{
		}

		public virtual void post_do_visit(compiler_directive_list _compiler_directive_list)
		{
		}

		public virtual void pre_do_visit(compiler_directive_if _compiler_directive_if)
		{
		}

		public virtual void post_do_visit(compiler_directive_if _compiler_directive_if)
		{
		}

		public virtual void pre_do_visit(documentation_comment_list _documentation_comment_list)
		{
		}

		public virtual void post_do_visit(documentation_comment_list _documentation_comment_list)
		{
		}

		public virtual void pre_do_visit(documentation_comment_tag _documentation_comment_tag)
		{
		}

		public virtual void post_do_visit(documentation_comment_tag _documentation_comment_tag)
		{
		}

		public virtual void pre_do_visit(documentation_comment_tag_param _documentation_comment_tag_param)
		{
		}

		public virtual void post_do_visit(documentation_comment_tag_param _documentation_comment_tag_param)
		{
		}

		public virtual void pre_do_visit(documentation_comment_section _documentation_comment_section)
		{
		}

		public virtual void post_do_visit(documentation_comment_section _documentation_comment_section)
		{
		}

		public virtual void pre_do_visit(token_taginfo _token_taginfo)
		{
		}

		public virtual void post_do_visit(token_taginfo _token_taginfo)
		{
		}

		public virtual void pre_do_visit(declaration_specificator _declaration_specificator)
		{
		}

		public virtual void post_do_visit(declaration_specificator _declaration_specificator)
		{
		}

		public virtual void pre_do_visit(ident_with_templateparams _ident_with_templateparams)
		{
		}

		public virtual void post_do_visit(ident_with_templateparams _ident_with_templateparams)
		{
		}

		public virtual void pre_do_visit(template_type_name _template_type_name)
		{
		}

		public virtual void post_do_visit(template_type_name _template_type_name)
		{
		}

		public virtual void pre_do_visit(default_operator _default_operator)
		{
		}

		public virtual void post_do_visit(default_operator _default_operator)
		{
		}

		public virtual void pre_do_visit(bracket_expr _bracket_expr)
		{
		}

		public virtual void post_do_visit(bracket_expr _bracket_expr)
		{
		}

		public virtual void pre_do_visit(attribute _attribute)
		{
		}

		public virtual void post_do_visit(attribute _attribute)
		{
		}

		public virtual void pre_do_visit(simple_attribute_list _simple_attribute_list)
		{
		}

		public virtual void post_do_visit(simple_attribute_list _simple_attribute_list)
		{
		}

		public virtual void pre_do_visit(attribute_list _attribute_list)
		{
		}

		public virtual void post_do_visit(attribute_list _attribute_list)
		{
		}

		public virtual void pre_do_visit(function_lambda_definition _function_lambda_definition)
		{
		}

		public virtual void post_do_visit(function_lambda_definition _function_lambda_definition)
		{
		}

		public virtual void pre_do_visit(function_lambda_call _function_lambda_call)
		{
		}

		public virtual void post_do_visit(function_lambda_call _function_lambda_call)
		{
		}

		public virtual void pre_do_visit(semantic_check _semantic_check)
		{
		}

		public virtual void post_do_visit(semantic_check _semantic_check)
		{
		}

		public virtual void pre_do_visit(lambda_inferred_type _lambda_inferred_type)
		{
		}

		public virtual void post_do_visit(lambda_inferred_type _lambda_inferred_type)
		{
		}

		public virtual void pre_do_visit(same_type_node _same_type_node)
		{
		}

		public virtual void post_do_visit(same_type_node _same_type_node)
		{
		}

		public virtual void pre_do_visit(name_assign_expr _name_assign_expr)
		{
		}

		public virtual void post_do_visit(name_assign_expr _name_assign_expr)
		{
		}

		public virtual void pre_do_visit(name_assign_expr_list _name_assign_expr_list)
		{
		}

		public virtual void post_do_visit(name_assign_expr_list _name_assign_expr_list)
		{
		}

		public virtual void pre_do_visit(unnamed_type_object _unnamed_type_object)
		{
		}

		public virtual void post_do_visit(unnamed_type_object _unnamed_type_object)
		{
		}

		public virtual void pre_do_visit(semantic_type_node _semantic_type_node)
		{
		}

		public virtual void post_do_visit(semantic_type_node _semantic_type_node)
		{
		}

		public virtual void pre_do_visit(short_func_definition _short_func_definition)
		{
		}

		public virtual void post_do_visit(short_func_definition _short_func_definition)
		{
		}

		public virtual void pre_do_visit(no_type_foreach _no_type_foreach)
		{
		}

		public virtual void post_do_visit(no_type_foreach _no_type_foreach)
		{
		}

		public virtual void pre_do_visit(matching_expression _matching_expression)
		{
		}

		public virtual void post_do_visit(matching_expression _matching_expression)
		{
		}

		public virtual void pre_do_visit(closure_substituting_node _closure_substituting_node)
		{
		}

		public virtual void post_do_visit(closure_substituting_node _closure_substituting_node)
		{
		}

		public virtual void pre_do_visit(sequence_type _sequence_type)
		{
		}

		public virtual void post_do_visit(sequence_type _sequence_type)
		{
		}

		public virtual void pre_do_visit(modern_proc_type _modern_proc_type)
		{
		}

		public virtual void post_do_visit(modern_proc_type _modern_proc_type)
		{
		}

		public virtual void pre_do_visit(yield_node _yield_node)
		{
		}

		public virtual void post_do_visit(yield_node _yield_node)
		{
		}

		public virtual void pre_do_visit(template_operator_name _template_operator_name)
		{
		}

		public virtual void post_do_visit(template_operator_name _template_operator_name)
		{
		}

		public virtual void pre_do_visit(semantic_addr_value _semantic_addr_value)
		{
		}

		public virtual void post_do_visit(semantic_addr_value _semantic_addr_value)
		{
		}

		public virtual void pre_do_visit(pair_type_stlist _pair_type_stlist)
		{
		}

		public virtual void post_do_visit(pair_type_stlist _pair_type_stlist)
		{
		}

		public virtual void pre_do_visit(assign_tuple _assign_tuple)
		{
		}

		public virtual void post_do_visit(assign_tuple _assign_tuple)
		{
		}

		public virtual void pre_do_visit(addressed_value_list _addressed_value_list)
		{
		}

		public virtual void post_do_visit(addressed_value_list _addressed_value_list)
		{
		}

		public virtual void pre_do_visit(tuple_node _tuple_node)
		{
		}

		public virtual void post_do_visit(tuple_node _tuple_node)
		{
		}

		public virtual void pre_do_visit(uses_closure _uses_closure)
		{
		}

		public virtual void post_do_visit(uses_closure _uses_closure)
		{
		}

		public virtual void pre_do_visit(dot_question_node _dot_question_node)
		{
		}

		public virtual void post_do_visit(dot_question_node _dot_question_node)
		{
		}

		public virtual void pre_do_visit(slice_expr _slice_expr)
		{
		}

		public virtual void post_do_visit(slice_expr _slice_expr)
		{
		}

		public virtual void pre_do_visit(no_type _no_type)
		{
		}

		public virtual void post_do_visit(no_type _no_type)
		{
		}

		public virtual void pre_do_visit(yield_unknown_ident _yield_unknown_ident)
		{
		}

		public virtual void post_do_visit(yield_unknown_ident _yield_unknown_ident)
		{
		}

		public virtual void pre_do_visit(yield_unknown_expression_type _yield_unknown_expression_type)
		{
		}

		public virtual void post_do_visit(yield_unknown_expression_type _yield_unknown_expression_type)
		{
		}

		public virtual void pre_do_visit(yield_unknown_foreach_type _yield_unknown_foreach_type)
		{
		}

		public virtual void post_do_visit(yield_unknown_foreach_type _yield_unknown_foreach_type)
		{
		}

		public virtual void pre_do_visit(yield_sequence_node _yield_sequence_node)
		{
		}

		public virtual void post_do_visit(yield_sequence_node _yield_sequence_node)
		{
		}

		public virtual void pre_do_visit(assign_var_tuple _assign_var_tuple)
		{
		}

		public virtual void post_do_visit(assign_var_tuple _assign_var_tuple)
		{
		}

		public virtual void pre_do_visit(slice_expr_question _slice_expr_question)
		{
		}

		public virtual void post_do_visit(slice_expr_question _slice_expr_question)
		{
		}

		public virtual void pre_do_visit(semantic_check_sugared_statement_node _semantic_check_sugared_statement_node)
		{
		}

		public virtual void post_do_visit(semantic_check_sugared_statement_node _semantic_check_sugared_statement_node)
		{
		}

		public virtual void pre_do_visit(sugared_expression _sugared_expression)
		{
		}

		public virtual void post_do_visit(sugared_expression _sugared_expression)
		{
		}

		public virtual void pre_do_visit(sugared_addressed_value _sugared_addressed_value)
		{
		}

		public virtual void post_do_visit(sugared_addressed_value _sugared_addressed_value)
		{
		}

		public virtual void pre_do_visit(double_question_node _double_question_node)
		{
		}

		public virtual void post_do_visit(double_question_node _double_question_node)
		{
		}

		public virtual void pre_do_visit(typeclass_restriction _typeclass_restriction)
		{
		}

		public virtual void post_do_visit(typeclass_restriction _typeclass_restriction)
		{
		}

		public virtual void pre_do_visit(instance_definition _instance_definition)
		{
		}

		public virtual void post_do_visit(instance_definition _instance_definition)
		{
		}

		public virtual void pre_do_visit(typeclass_definition _typeclass_definition)
		{
		}

		public virtual void post_do_visit(typeclass_definition _typeclass_definition)
		{
		}

		public override void visit(expression _expression)
		{
			DefaultVisit(_expression);
			pre_do_visit(_expression);
			post_do_visit(_expression);
		}

		public override void visit(syntax_tree_node _syntax_tree_node)
		{
			DefaultVisit(_syntax_tree_node);
			pre_do_visit(_syntax_tree_node);
			post_do_visit(_syntax_tree_node);
		}

		public override void visit(statement _statement)
		{
			DefaultVisit(_statement);
			pre_do_visit(_statement);
			post_do_visit(_statement);
		}

		public override void visit(statement_list _statement_list)
		{
			DefaultVisit(_statement_list);
			pre_do_visit(_statement_list);
			for (int i = 0; i < subnodes.Count; i++)
				visit(statement_list.subnodes[i]);
			visit(statement_list.left_logical_bracket);
			visit(statement_list.right_logical_bracket);
			post_do_visit(_statement_list);
		}

		public override void visit(ident _ident)
		{
			DefaultVisit(_ident);
			pre_do_visit(_ident);
			post_do_visit(_ident);
		}

		public override void visit(assign _assign)
		{
			DefaultVisit(_assign);
			pre_do_visit(_assign);
			visit(assign.to);
			visit(assign.from);
			post_do_visit(_assign);
		}

		public override void visit(bin_expr _bin_expr)
		{
			DefaultVisit(_bin_expr);
			pre_do_visit(_bin_expr);
			visit(bin_expr.left);
			visit(bin_expr.right);
			post_do_visit(_bin_expr);
		}

		public override void visit(un_expr _un_expr)
		{
			DefaultVisit(_un_expr);
			pre_do_visit(_un_expr);
			visit(un_expr.subnode);
			post_do_visit(_un_expr);
		}

		public override void visit(const_node _const_node)
		{
			DefaultVisit(_const_node);
			pre_do_visit(_const_node);
			post_do_visit(_const_node);
		}

		public override void visit(bool_const _bool_const)
		{
			DefaultVisit(_bool_const);
			pre_do_visit(_bool_const);
			post_do_visit(_bool_const);
		}

		public override void visit(int32_const _int32_const)
		{
			DefaultVisit(_int32_const);
			pre_do_visit(_int32_const);
			post_do_visit(_int32_const);
		}

		public override void visit(double_const _double_const)
		{
			DefaultVisit(_double_const);
			pre_do_visit(_double_const);
			post_do_visit(_double_const);
		}

		public override void visit(subprogram_body _subprogram_body)
		{
			DefaultVisit(_subprogram_body);
			pre_do_visit(_subprogram_body);
			visit(subprogram_body.subprogram_code);
			visit(subprogram_body.subprogram_defs);
			post_do_visit(_subprogram_body);
		}

		public override void visit(addressed_value _addressed_value)
		{
			DefaultVisit(_addressed_value);
			pre_do_visit(_addressed_value);
			post_do_visit(_addressed_value);
		}

		public override void visit(type_definition _type_definition)
		{
			DefaultVisit(_type_definition);
			pre_do_visit(_type_definition);
			visit(type_definition.attr_list);
			post_do_visit(_type_definition);
		}

		public override void visit(roof_dereference _roof_dereference)
		{
			DefaultVisit(_roof_dereference);
			pre_do_visit(_roof_dereference);
			post_do_visit(_roof_dereference);
		}

		public override void visit(named_type_reference _named_type_reference)
		{
			DefaultVisit(_named_type_reference);
			pre_do_visit(_named_type_reference);
			for (int i = 0; i < names.Count; i++)
				visit(named_type_reference.names[i]);
			post_do_visit(_named_type_reference);
		}

		public override void visit(variable_definitions _variable_definitions)
		{
			DefaultVisit(_variable_definitions);
			pre_do_visit(_variable_definitions);
			for (int i = 0; i < var_definitions.Count; i++)
				visit(variable_definitions.var_definitions[i]);
			post_do_visit(_variable_definitions);
		}

		public override void visit(ident_list _ident_list)
		{
			DefaultVisit(_ident_list);
			pre_do_visit(_ident_list);
			for (int i = 0; i < idents.Count; i++)
				visit(ident_list.idents[i]);
			post_do_visit(_ident_list);
		}

		public override void visit(var_def_statement _var_def_statement)
		{
			DefaultVisit(_var_def_statement);
			pre_do_visit(_var_def_statement);
			visit(var_def_statement.vars);
			visit(var_def_statement.vars_type);
			visit(var_def_statement.inital_value);
			post_do_visit(_var_def_statement);
		}

		public override void visit(declaration _declaration)
		{
			DefaultVisit(_declaration);
			pre_do_visit(_declaration);
			visit(declaration.attributes);
			post_do_visit(_declaration);
		}

		public override void visit(declarations _declarations)
		{
			DefaultVisit(_declarations);
			pre_do_visit(_declarations);
			for (int i = 0; i < defs.Count; i++)
				visit(declarations.defs[i]);
			post_do_visit(_declarations);
		}

		public override void visit(program_tree _program_tree)
		{
			DefaultVisit(_program_tree);
			pre_do_visit(_program_tree);
			for (int i = 0; i < compilation_units.Count; i++)
				visit(program_tree.compilation_units[i]);
			post_do_visit(_program_tree);
		}

		public override void visit(program_name _program_name)
		{
			DefaultVisit(_program_name);
			pre_do_visit(_program_name);
			visit(program_name.prog_name);
			post_do_visit(_program_name);
		}

		public override void visit(string_const _string_const)
		{
			DefaultVisit(_string_const);
			pre_do_visit(_string_const);
			post_do_visit(_string_const);
		}

		public override void visit(expression_list _expression_list)
		{
			DefaultVisit(_expression_list);
			pre_do_visit(_expression_list);
			for (int i = 0; i < expressions.Count; i++)
				visit(expression_list.expressions[i]);
			post_do_visit(_expression_list);
		}

		public override void visit(dereference _dereference)
		{
			DefaultVisit(_dereference);
			pre_do_visit(_dereference);
			visit(dereference.dereferencing_value);
			post_do_visit(_dereference);
		}

		public override void visit(indexer _indexer)
		{
			DefaultVisit(_indexer);
			pre_do_visit(_indexer);
			visit(indexer.indexes);
			post_do_visit(_indexer);
		}

		public override void visit(for_node _for_node)
		{
			DefaultVisit(_for_node);
			pre_do_visit(_for_node);
			visit(for_node.loop_variable);
			visit(for_node.initial_value);
			visit(for_node.finish_value);
			visit(for_node.statements);
			visit(for_node.increment_value);
			visit(for_node.type_name);
			post_do_visit(_for_node);
		}

		public override void visit(repeat_node _repeat_node)
		{
			DefaultVisit(_repeat_node);
			pre_do_visit(_repeat_node);
			visit(repeat_node.statements);
			visit(repeat_node.expr);
			post_do_visit(_repeat_node);
		}

		public override void visit(while_node _while_node)
		{
			DefaultVisit(_while_node);
			pre_do_visit(_while_node);
			visit(while_node.expr);
			visit(while_node.statements);
			post_do_visit(_while_node);
		}

		public override void visit(if_node _if_node)
		{
			DefaultVisit(_if_node);
			pre_do_visit(_if_node);
			visit(if_node.condition);
			visit(if_node.then_body);
			visit(if_node.else_body);
			post_do_visit(_if_node);
		}

		public override void visit(ref_type _ref_type)
		{
			DefaultVisit(_ref_type);
			pre_do_visit(_ref_type);
			visit(ref_type.pointed_to);
			post_do_visit(_ref_type);
		}

		public override void visit(diapason _diapason)
		{
			DefaultVisit(_diapason);
			pre_do_visit(_diapason);
			visit(diapason.left);
			visit(diapason.right);
			post_do_visit(_diapason);
		}

		public override void visit(indexers_types _indexers_types)
		{
			DefaultVisit(_indexers_types);
			pre_do_visit(_indexers_types);
			for (int i = 0; i < indexers.Count; i++)
				visit(indexers_types.indexers[i]);
			post_do_visit(_indexers_types);
		}

		public override void visit(array_type _array_type)
		{
			DefaultVisit(_array_type);
			pre_do_visit(_array_type);
			visit(array_type.indexers);
			visit(array_type.elements_type);
			post_do_visit(_array_type);
		}

		public override void visit(label_definitions _label_definitions)
		{
			DefaultVisit(_label_definitions);
			pre_do_visit(_label_definitions);
			visit(label_definitions.labels);
			post_do_visit(_label_definitions);
		}

		public override void visit(procedure_attribute _procedure_attribute)
		{
			DefaultVisit(_procedure_attribute);
			pre_do_visit(_procedure_attribute);
			post_do_visit(_procedure_attribute);
		}

		public override void visit(typed_parameters _typed_parameters)
		{
			DefaultVisit(_typed_parameters);
			pre_do_visit(_typed_parameters);
			visit(typed_parameters.idents);
			visit(typed_parameters.vars_type);
			visit(typed_parameters.inital_value);
			post_do_visit(_typed_parameters);
		}

		public override void visit(formal_parameters _formal_parameters)
		{
			DefaultVisit(_formal_parameters);
			pre_do_visit(_formal_parameters);
			for (int i = 0; i < params_list.Count; i++)
				visit(formal_parameters.params_list[i]);
			post_do_visit(_formal_parameters);
		}

		public override void visit(procedure_attributes_list _procedure_attributes_list)
		{
			DefaultVisit(_procedure_attributes_list);
			pre_do_visit(_procedure_attributes_list);
			for (int i = 0; i < proc_attributes.Count; i++)
				visit(procedure_attributes_list.proc_attributes[i]);
			post_do_visit(_procedure_attributes_list);
		}

		public override void visit(procedure_header _procedure_header)
		{
			DefaultVisit(_procedure_header);
			pre_do_visit(_procedure_header);
			visit(procedure_header.parameters);
			visit(procedure_header.proc_attributes);
			visit(procedure_header.name);
			visit(procedure_header.template_args);
			visit(procedure_header.where_defs);
			post_do_visit(_procedure_header);
		}

		public override void visit(function_header _function_header)
		{
			DefaultVisit(_function_header);
			pre_do_visit(_function_header);
			visit(function_header.return_type);
			post_do_visit(_function_header);
		}

		public override void visit(procedure_definition _procedure_definition)
		{
			DefaultVisit(_procedure_definition);
			pre_do_visit(_procedure_definition);
			visit(procedure_definition.proc_header);
			visit(procedure_definition.proc_body);
			post_do_visit(_procedure_definition);
		}

		public override void visit(type_declaration _type_declaration)
		{
			DefaultVisit(_type_declaration);
			pre_do_visit(_type_declaration);
			visit(type_declaration.type_name);
			visit(type_declaration.type_def);
			post_do_visit(_type_declaration);
		}

		public override void visit(type_declarations _type_declarations)
		{
			DefaultVisit(_type_declarations);
			pre_do_visit(_type_declarations);
			for (int i = 0; i < types_decl.Count; i++)
				visit(type_declarations.types_decl[i]);
			post_do_visit(_type_declarations);
		}

		public override void visit(simple_const_definition _simple_const_definition)
		{
			DefaultVisit(_simple_const_definition);
			pre_do_visit(_simple_const_definition);
			post_do_visit(_simple_const_definition);
		}

		public override void visit(typed_const_definition _typed_const_definition)
		{
			DefaultVisit(_typed_const_definition);
			pre_do_visit(_typed_const_definition);
			visit(typed_const_definition.const_type);
			post_do_visit(_typed_const_definition);
		}

		public override void visit(const_definition _const_definition)
		{
			DefaultVisit(_const_definition);
			pre_do_visit(_const_definition);
			visit(const_definition.const_name);
			visit(const_definition.const_value);
			post_do_visit(_const_definition);
		}

		public override void visit(consts_definitions_list _consts_definitions_list)
		{
			DefaultVisit(_consts_definitions_list);
			pre_do_visit(_consts_definitions_list);
			for (int i = 0; i < const_defs.Count; i++)
				visit(consts_definitions_list.const_defs[i]);
			post_do_visit(_consts_definitions_list);
		}

		public override void visit(unit_name _unit_name)
		{
			DefaultVisit(_unit_name);
			pre_do_visit(_unit_name);
			visit(unit_name.idunit_name);
			post_do_visit(_unit_name);
		}

		public override void visit(unit_or_namespace _unit_or_namespace)
		{
			DefaultVisit(_unit_or_namespace);
			pre_do_visit(_unit_or_namespace);
			visit(unit_or_namespace.name);
			post_do_visit(_unit_or_namespace);
		}

		public override void visit(uses_unit_in _uses_unit_in)
		{
			DefaultVisit(_uses_unit_in);
			pre_do_visit(_uses_unit_in);
			visit(uses_unit_in.in_file);
			post_do_visit(_uses_unit_in);
		}

		public override void visit(uses_list _uses_list)
		{
			DefaultVisit(_uses_list);
			pre_do_visit(_uses_list);
			for (int i = 0; i < units.Count; i++)
				visit(uses_list.units[i]);
			post_do_visit(_uses_list);
		}

		public override void visit(program_body _program_body)
		{
			DefaultVisit(_program_body);
			pre_do_visit(_program_body);
			visit(program_body.used_units);
			visit(program_body.program_definitions);
			visit(program_body.program_code);
			visit(program_body.using_list);
			post_do_visit(_program_body);
		}

		public override void visit(compilation_unit _compilation_unit)
		{
			DefaultVisit(_compilation_unit);
			pre_do_visit(_compilation_unit);
			for (int i = 0; i < compiler_directives.Count; i++)
				visit(compilation_unit.compiler_directives[i]);
			post_do_visit(_compilation_unit);
		}

		public override void visit(unit_module _unit_module)
		{
			DefaultVisit(_unit_module);
			pre_do_visit(_unit_module);
			visit(unit_module.unit_name);
			visit(unit_module.interface_part);
			visit(unit_module.implementation_part);
			visit(unit_module.initialization_part);
			visit(unit_module.finalization_part);
			visit(unit_module.attributes);
			post_do_visit(_unit_module);
		}

		public override void visit(program_module _program_module)
		{
			DefaultVisit(_program_module);
			pre_do_visit(_program_module);
			visit(program_module.program_name);
			visit(program_module.used_units);
			visit(program_module.program_block);
			visit(program_module.using_namespaces);
			post_do_visit(_program_module);
		}

		public override void visit(hex_constant _hex_constant)
		{
			DefaultVisit(_hex_constant);
			pre_do_visit(_hex_constant);
			post_do_visit(_hex_constant);
		}

		public override void visit(get_address _get_address)
		{
			DefaultVisit(_get_address);
			pre_do_visit(_get_address);
			visit(get_address.address_of);
			post_do_visit(_get_address);
		}

		public override void visit(case_variant _case_variant)
		{
			DefaultVisit(_case_variant);
			pre_do_visit(_case_variant);
			visit(case_variant.conditions);
			visit(case_variant.exec_if_true);
			post_do_visit(_case_variant);
		}

		public override void visit(case_node _case_node)
		{
			DefaultVisit(_case_node);
			pre_do_visit(_case_node);
			visit(case_node.param);
			visit(case_node.conditions);
			visit(case_node.else_statement);
			post_do_visit(_case_node);
		}

		public override void visit(method_name _method_name)
		{
			DefaultVisit(_method_name);
			pre_do_visit(_method_name);
			for (int i = 0; i < ln.Count; i++)
				visit(method_name.ln[i]);
			visit(method_name.class_name);
			visit(method_name.meth_name);
			visit(method_name.explicit_interface_name);
			post_do_visit(_method_name);
		}

		public override void visit(dot_node _dot_node)
		{
			DefaultVisit(_dot_node);
			pre_do_visit(_dot_node);
			visit(dot_node.left);
			visit(dot_node.right);
			post_do_visit(_dot_node);
		}

		public override void visit(empty_statement _empty_statement)
		{
			DefaultVisit(_empty_statement);
			pre_do_visit(_empty_statement);
			post_do_visit(_empty_statement);
		}

		public override void visit(goto_statement _goto_statement)
		{
			DefaultVisit(_goto_statement);
			pre_do_visit(_goto_statement);
			visit(goto_statement.label);
			post_do_visit(_goto_statement);
		}

		public override void visit(labeled_statement _labeled_statement)
		{
			DefaultVisit(_labeled_statement);
			pre_do_visit(_labeled_statement);
			visit(labeled_statement.label_name);
			visit(labeled_statement.to_statement);
			post_do_visit(_labeled_statement);
		}

		public override void visit(with_statement _with_statement)
		{
			DefaultVisit(_with_statement);
			pre_do_visit(_with_statement);
			visit(with_statement.what_do);
			visit(with_statement.do_with);
			post_do_visit(_with_statement);
		}

		public override void visit(method_call _method_call)
		{
			DefaultVisit(_method_call);
			pre_do_visit(_method_call);
			visit(method_call.parameters);
			post_do_visit(_method_call);
		}

		public override void visit(pascal_set_constant _pascal_set_constant)
		{
			DefaultVisit(_pascal_set_constant);
			pre_do_visit(_pascal_set_constant);
			visit(pascal_set_constant.values);
			post_do_visit(_pascal_set_constant);
		}

		public override void visit(array_const _array_const)
		{
			DefaultVisit(_array_const);
			pre_do_visit(_array_const);
			visit(array_const.elements);
			post_do_visit(_array_const);
		}

		public override void visit(write_accessor_name _write_accessor_name)
		{
			DefaultVisit(_write_accessor_name);
			pre_do_visit(_write_accessor_name);
			visit(write_accessor_name.accessor_name);
			post_do_visit(_write_accessor_name);
		}

		public override void visit(read_accessor_name _read_accessor_name)
		{
			DefaultVisit(_read_accessor_name);
			pre_do_visit(_read_accessor_name);
			visit(read_accessor_name.accessor_name);
			post_do_visit(_read_accessor_name);
		}

		public override void visit(property_accessors _property_accessors)
		{
			DefaultVisit(_property_accessors);
			pre_do_visit(_property_accessors);
			visit(property_accessors.read_accessor);
			visit(property_accessors.write_accessor);
			post_do_visit(_property_accessors);
		}

		public override void visit(simple_property _simple_property)
		{
			DefaultVisit(_simple_property);
			pre_do_visit(_simple_property);
			visit(simple_property.property_name);
			visit(simple_property.property_type);
			visit(simple_property.index_expression);
			visit(simple_property.accessors);
			visit(simple_property.array_default);
			visit(simple_property.parameter_list);
			post_do_visit(_simple_property);
		}

		public override void visit(index_property _index_property)
		{
			DefaultVisit(_index_property);
			pre_do_visit(_index_property);
			visit(index_property.property_parametres);
			visit(index_property.is_default);
			post_do_visit(_index_property);
		}

		public override void visit(class_members _class_members)
		{
			DefaultVisit(_class_members);
			pre_do_visit(_class_members);
			for (int i = 0; i < members.Count; i++)
				visit(class_members.members[i]);
			visit(class_members.access_mod);
			post_do_visit(_class_members);
		}

		public override void visit(access_modifer_node _access_modifer_node)
		{
			DefaultVisit(_access_modifer_node);
			pre_do_visit(_access_modifer_node);
			post_do_visit(_access_modifer_node);
		}

		public override void visit(class_body_list _class_body_list)
		{
			DefaultVisit(_class_body_list);
			pre_do_visit(_class_body_list);
			for (int i = 0; i < class_def_blocks.Count; i++)
				visit(class_body_list.class_def_blocks[i]);
			post_do_visit(_class_body_list);
		}

		public override void visit(class_definition _class_definition)
		{
			DefaultVisit(_class_definition);
			pre_do_visit(_class_definition);
			visit(class_definition.class_parents);
			visit(class_definition.body);
			visit(class_definition.template_args);
			visit(class_definition.where_section);
			post_do_visit(_class_definition);
		}

		public override void visit(default_indexer_property_node _default_indexer_property_node)
		{
			DefaultVisit(_default_indexer_property_node);
			pre_do_visit(_default_indexer_property_node);
			post_do_visit(_default_indexer_property_node);
		}

		public override void visit(known_type_definition _known_type_definition)
		{
			DefaultVisit(_known_type_definition);
			pre_do_visit(_known_type_definition);
			visit(known_type_definition.unit_name);
			post_do_visit(_known_type_definition);
		}

		public override void visit(set_type_definition _set_type_definition)
		{
			DefaultVisit(_set_type_definition);
			pre_do_visit(_set_type_definition);
			visit(set_type_definition.of_type);
			post_do_visit(_set_type_definition);
		}

		public override void visit(record_const_definition _record_const_definition)
		{
			DefaultVisit(_record_const_definition);
			pre_do_visit(_record_const_definition);
			visit(record_const_definition.name);
			visit(record_const_definition.val);
			post_do_visit(_record_const_definition);
		}

		public override void visit(record_const _record_const)
		{
			DefaultVisit(_record_const);
			pre_do_visit(_record_const);
			for (int i = 0; i < rec_consts.Count; i++)
				visit(record_const.rec_consts[i]);
			post_do_visit(_record_const);
		}

		public override void visit(record_type _record_type)
		{
			DefaultVisit(_record_type);
			pre_do_visit(_record_type);
			visit(record_type.parts);
			visit(record_type.base_type);
			post_do_visit(_record_type);
		}

		public override void visit(enum_type_definition _enum_type_definition)
		{
			DefaultVisit(_enum_type_definition);
			pre_do_visit(_enum_type_definition);
			visit(enum_type_definition.enumerators);
			post_do_visit(_enum_type_definition);
		}

		public override void visit(char_const _char_const)
		{
			DefaultVisit(_char_const);
			pre_do_visit(_char_const);
			post_do_visit(_char_const);
		}

		public override void visit(raise_statement _raise_statement)
		{
			DefaultVisit(_raise_statement);
			pre_do_visit(_raise_statement);
			visit(raise_statement.excep);
			post_do_visit(_raise_statement);
		}

		public override void visit(sharp_char_const _sharp_char_const)
		{
			DefaultVisit(_sharp_char_const);
			pre_do_visit(_sharp_char_const);
			post_do_visit(_sharp_char_const);
		}

		public override void visit(literal_const_line _literal_const_line)
		{
			DefaultVisit(_literal_const_line);
			pre_do_visit(_literal_const_line);
			for (int i = 0; i < literals.Count; i++)
				visit(literal_const_line.literals[i]);
			post_do_visit(_literal_const_line);
		}

		public override void visit(string_num_definition _string_num_definition)
		{
			DefaultVisit(_string_num_definition);
			pre_do_visit(_string_num_definition);
			visit(string_num_definition.num_of_symbols);
			visit(string_num_definition.name);
			post_do_visit(_string_num_definition);
		}

		public override void visit(variant _variant)
		{
			DefaultVisit(_variant);
			pre_do_visit(_variant);
			visit(variant.vars);
			visit(variant.vars_type);
			post_do_visit(_variant);
		}

		public override void visit(variant_list _variant_list)
		{
			DefaultVisit(_variant_list);
			pre_do_visit(_variant_list);
			for (int i = 0; i < vars.Count; i++)
				visit(variant_list.vars[i]);
			post_do_visit(_variant_list);
		}

		public override void visit(variant_type _variant_type)
		{
			DefaultVisit(_variant_type);
			pre_do_visit(_variant_type);
			visit(variant_type.case_exprs);
			visit(variant_type.parts);
			post_do_visit(_variant_type);
		}

		public override void visit(variant_types _variant_types)
		{
			DefaultVisit(_variant_types);
			pre_do_visit(_variant_types);
			for (int i = 0; i < vars.Count; i++)
				visit(variant_types.vars[i]);
			post_do_visit(_variant_types);
		}

		public override void visit(variant_record_type _variant_record_type)
		{
			DefaultVisit(_variant_record_type);
			pre_do_visit(_variant_record_type);
			visit(variant_record_type.var_name);
			visit(variant_record_type.var_type);
			visit(variant_record_type.vars);
			post_do_visit(_variant_record_type);
		}

		public override void visit(procedure_call _procedure_call)
		{
			DefaultVisit(_procedure_call);
			pre_do_visit(_procedure_call);
			visit(procedure_call.func_name);
			post_do_visit(_procedure_call);
		}

		public override void visit(class_predefinition _class_predefinition)
		{
			DefaultVisit(_class_predefinition);
			pre_do_visit(_class_predefinition);
			visit(class_predefinition.class_name);
			post_do_visit(_class_predefinition);
		}

		public override void visit(nil_const _nil_const)
		{
			DefaultVisit(_nil_const);
			pre_do_visit(_nil_const);
			post_do_visit(_nil_const);
		}

		public override void visit(file_type_definition _file_type_definition)
		{
			DefaultVisit(_file_type_definition);
			pre_do_visit(_file_type_definition);
			visit(file_type_definition.elem_type);
			post_do_visit(_file_type_definition);
		}

		public override void visit(constructor _constructor)
		{
			DefaultVisit(_constructor);
			pre_do_visit(_constructor);
			post_do_visit(_constructor);
		}

		public override void visit(destructor _destructor)
		{
			DefaultVisit(_destructor);
			pre_do_visit(_destructor);
			post_do_visit(_destructor);
		}

		public override void visit(inherited_method_call _inherited_method_call)
		{
			DefaultVisit(_inherited_method_call);
			pre_do_visit(_inherited_method_call);
			visit(inherited_method_call.method_name);
			visit(inherited_method_call.exprs);
			post_do_visit(_inherited_method_call);
		}

		public override void visit(typecast_node _typecast_node)
		{
			DefaultVisit(_typecast_node);
			pre_do_visit(_typecast_node);
			visit(typecast_node.expr);
			visit(typecast_node.type_def);
			post_do_visit(_typecast_node);
		}

		public override void visit(interface_node _interface_node)
		{
			DefaultVisit(_interface_node);
			pre_do_visit(_interface_node);
			visit(interface_node.interface_definitions);
			visit(interface_node.uses_modules);
			visit(interface_node.using_namespaces);
			post_do_visit(_interface_node);
		}

		public override void visit(implementation_node _implementation_node)
		{
			DefaultVisit(_implementation_node);
			pre_do_visit(_implementation_node);
			visit(implementation_node.uses_modules);
			visit(implementation_node.implementation_definitions);
			visit(implementation_node.using_namespaces);
			post_do_visit(_implementation_node);
		}

		public override void visit(diap_expr _diap_expr)
		{
			DefaultVisit(_diap_expr);
			pre_do_visit(_diap_expr);
			visit(diap_expr.left);
			visit(diap_expr.right);
			post_do_visit(_diap_expr);
		}

		public override void visit(block _block)
		{
			DefaultVisit(_block);
			pre_do_visit(_block);
			visit(block.defs);
			visit(block.program_code);
			post_do_visit(_block);
		}

		public override void visit(proc_block _proc_block)
		{
			DefaultVisit(_proc_block);
			pre_do_visit(_proc_block);
			post_do_visit(_proc_block);
		}

		public override void visit(array_of_named_type_definition _array_of_named_type_definition)
		{
			DefaultVisit(_array_of_named_type_definition);
			pre_do_visit(_array_of_named_type_definition);
			visit(array_of_named_type_definition.type_name);
			post_do_visit(_array_of_named_type_definition);
		}

		public override void visit(array_of_const_type_definition _array_of_const_type_definition)
		{
			DefaultVisit(_array_of_const_type_definition);
			pre_do_visit(_array_of_const_type_definition);
			post_do_visit(_array_of_const_type_definition);
		}

		public override void visit(literal _literal)
		{
			DefaultVisit(_literal);
			pre_do_visit(_literal);
			post_do_visit(_literal);
		}

		public override void visit(case_variants _case_variants)
		{
			DefaultVisit(_case_variants);
			pre_do_visit(_case_variants);
			for (int i = 0; i < variants.Count; i++)
				visit(case_variants.variants[i]);
			post_do_visit(_case_variants);
		}

		public override void visit(diapason_expr _diapason_expr)
		{
			DefaultVisit(_diapason_expr);
			pre_do_visit(_diapason_expr);
			visit(diapason_expr.left);
			visit(diapason_expr.right);
			post_do_visit(_diapason_expr);
		}

		public override void visit(var_def_list_for_record _var_def_list_for_record)
		{
			DefaultVisit(_var_def_list_for_record);
			pre_do_visit(_var_def_list_for_record);
			for (int i = 0; i < vars.Count; i++)
				visit(var_def_list_for_record.vars[i]);
			post_do_visit(_var_def_list_for_record);
		}

		public override void visit(record_type_parts _record_type_parts)
		{
			DefaultVisit(_record_type_parts);
			pre_do_visit(_record_type_parts);
			visit(record_type_parts.fixed_part);
			visit(record_type_parts.variant_part);
			post_do_visit(_record_type_parts);
		}

		public override void visit(property_array_default _property_array_default)
		{
			DefaultVisit(_property_array_default);
			pre_do_visit(_property_array_default);
			post_do_visit(_property_array_default);
		}

		public override void visit(property_interface _property_interface)
		{
			DefaultVisit(_property_interface);
			pre_do_visit(_property_interface);
			visit(property_interface.parameter_list);
			visit(property_interface.property_type);
			visit(property_interface.index_expression);
			post_do_visit(_property_interface);
		}

		public override void visit(property_parameter _property_parameter)
		{
			DefaultVisit(_property_parameter);
			pre_do_visit(_property_parameter);
			visit(property_parameter.names);
			visit(property_parameter.type);
			post_do_visit(_property_parameter);
		}

		public override void visit(property_parameter_list _property_parameter_list)
		{
			DefaultVisit(_property_parameter_list);
			pre_do_visit(_property_parameter_list);
			for (int i = 0; i < parameters.Count; i++)
				visit(property_parameter_list.parameters[i]);
			post_do_visit(_property_parameter_list);
		}

		public override void visit(inherited_ident _inherited_ident)
		{
			DefaultVisit(_inherited_ident);
			pre_do_visit(_inherited_ident);
			post_do_visit(_inherited_ident);
		}

		public override void visit(format_expr _format_expr)
		{
			DefaultVisit(_format_expr);
			pre_do_visit(_format_expr);
			visit(format_expr.expr);
			visit(format_expr.format1);
			visit(format_expr.format2);
			post_do_visit(_format_expr);
		}

		public override void visit(initfinal_part _initfinal_part)
		{
			DefaultVisit(_initfinal_part);
			pre_do_visit(_initfinal_part);
			visit(initfinal_part.initialization_sect);
			visit(initfinal_part.finalization_sect);
			post_do_visit(_initfinal_part);
		}

		public override void visit(token_info _token_info)
		{
			DefaultVisit(_token_info);
			pre_do_visit(_token_info);
			post_do_visit(_token_info);
		}

		public override void visit(raise_stmt _raise_stmt)
		{
			DefaultVisit(_raise_stmt);
			pre_do_visit(_raise_stmt);
			visit(raise_stmt.expr);
			visit(raise_stmt.address);
			post_do_visit(_raise_stmt);
		}

		public override void visit(op_type_node _op_type_node)
		{
			DefaultVisit(_op_type_node);
			pre_do_visit(_op_type_node);
			post_do_visit(_op_type_node);
		}

		public override void visit(file_type _file_type)
		{
			DefaultVisit(_file_type);
			pre_do_visit(_file_type);
			visit(file_type.file_of_type);
			post_do_visit(_file_type);
		}

		public override void visit(known_type_ident _known_type_ident)
		{
			DefaultVisit(_known_type_ident);
			pre_do_visit(_known_type_ident);
			post_do_visit(_known_type_ident);
		}

		public override void visit(exception_handler _exception_handler)
		{
			DefaultVisit(_exception_handler);
			pre_do_visit(_exception_handler);
			visit(exception_handler.variable);
			visit(exception_handler.type_name);
			visit(exception_handler.statements);
			post_do_visit(_exception_handler);
		}

		public override void visit(exception_ident _exception_ident)
		{
			DefaultVisit(_exception_ident);
			pre_do_visit(_exception_ident);
			visit(exception_ident.variable);
			visit(exception_ident.type_name);
			post_do_visit(_exception_ident);
		}

		public override void visit(exception_handler_list _exception_handler_list)
		{
			DefaultVisit(_exception_handler_list);
			pre_do_visit(_exception_handler_list);
			for (int i = 0; i < handlers.Count; i++)
				visit(exception_handler_list.handlers[i]);
			post_do_visit(_exception_handler_list);
		}

		public override void visit(exception_block _exception_block)
		{
			DefaultVisit(_exception_block);
			pre_do_visit(_exception_block);
			visit(exception_block.stmt_list);
			visit(exception_block.handlers);
			visit(exception_block.else_stmt_list);
			post_do_visit(_exception_block);
		}

		public override void visit(try_handler _try_handler)
		{
			DefaultVisit(_try_handler);
			pre_do_visit(_try_handler);
			post_do_visit(_try_handler);
		}

		public override void visit(try_handler_finally _try_handler_finally)
		{
			DefaultVisit(_try_handler_finally);
			pre_do_visit(_try_handler_finally);
			visit(try_handler_finally.stmt_list);
			post_do_visit(_try_handler_finally);
		}

		public override void visit(try_handler_except _try_handler_except)
		{
			DefaultVisit(_try_handler_except);
			pre_do_visit(_try_handler_except);
			visit(try_handler_except.except_block);
			post_do_visit(_try_handler_except);
		}

		public override void visit(try_stmt _try_stmt)
		{
			DefaultVisit(_try_stmt);
			pre_do_visit(_try_stmt);
			visit(try_stmt.stmt_list);
			visit(try_stmt.handler);
			post_do_visit(_try_stmt);
		}

		public override void visit(inherited_message _inherited_message)
		{
			DefaultVisit(_inherited_message);
			pre_do_visit(_inherited_message);
			post_do_visit(_inherited_message);
		}

		public override void visit(external_directive _external_directive)
		{
			DefaultVisit(_external_directive);
			pre_do_visit(_external_directive);
			visit(external_directive.modulename);
			visit(external_directive.name);
			post_do_visit(_external_directive);
		}

		public override void visit(using_list _using_list)
		{
			DefaultVisit(_using_list);
			pre_do_visit(_using_list);
			for (int i = 0; i < namespaces.Count; i++)
				visit(using_list.namespaces[i]);
			post_do_visit(_using_list);
		}

		public override void visit(jump_stmt _jump_stmt)
		{
			DefaultVisit(_jump_stmt);
			pre_do_visit(_jump_stmt);
			visit(jump_stmt.expr);
			post_do_visit(_jump_stmt);
		}

		public override void visit(loop_stmt _loop_stmt)
		{
			DefaultVisit(_loop_stmt);
			pre_do_visit(_loop_stmt);
			visit(loop_stmt.count);
			visit(loop_stmt.stmt);
			post_do_visit(_loop_stmt);
		}

		public override void visit(foreach_stmt _foreach_stmt)
		{
			DefaultVisit(_foreach_stmt);
			pre_do_visit(_foreach_stmt);
			visit(foreach_stmt.identifier);
			visit(foreach_stmt.type_name);
			visit(foreach_stmt.in_what);
			visit(foreach_stmt.stmt);
			post_do_visit(_foreach_stmt);
		}

		public override void visit(addressed_value_funcname _addressed_value_funcname)
		{
			DefaultVisit(_addressed_value_funcname);
			pre_do_visit(_addressed_value_funcname);
			post_do_visit(_addressed_value_funcname);
		}

		public override void visit(named_type_reference_list _named_type_reference_list)
		{
			DefaultVisit(_named_type_reference_list);
			pre_do_visit(_named_type_reference_list);
			for (int i = 0; i < types.Count; i++)
				visit(named_type_reference_list.types[i]);
			post_do_visit(_named_type_reference_list);
		}

		public override void visit(template_param_list _template_param_list)
		{
			DefaultVisit(_template_param_list);
			pre_do_visit(_template_param_list);
			for (int i = 0; i < params_list.Count; i++)
				visit(template_param_list.params_list[i]);
			post_do_visit(_template_param_list);
		}

		public override void visit(template_type_reference _template_type_reference)
		{
			DefaultVisit(_template_type_reference);
			pre_do_visit(_template_type_reference);
			visit(template_type_reference.name);
			visit(template_type_reference.params_list);
			post_do_visit(_template_type_reference);
		}

		public override void visit(int64_const _int64_const)
		{
			DefaultVisit(_int64_const);
			pre_do_visit(_int64_const);
			post_do_visit(_int64_const);
		}

		public override void visit(uint64_const _uint64_const)
		{
			DefaultVisit(_uint64_const);
			pre_do_visit(_uint64_const);
			post_do_visit(_uint64_const);
		}

		public override void visit(new_expr _new_expr)
		{
			DefaultVisit(_new_expr);
			pre_do_visit(_new_expr);
			visit(new_expr.type);
			visit(new_expr.params_list);
			visit(new_expr.array_init_expr);
			post_do_visit(_new_expr);
		}

		public override void visit(where_type_specificator_list _where_type_specificator_list)
		{
			DefaultVisit(_where_type_specificator_list);
			pre_do_visit(_where_type_specificator_list);
			for (int i = 0; i < defs.Count; i++)
				visit(where_type_specificator_list.defs[i]);
			post_do_visit(_where_type_specificator_list);
		}

		public override void visit(where_definition _where_definition)
		{
			DefaultVisit(_where_definition);
			pre_do_visit(_where_definition);
			visit(where_definition.names);
			visit(where_definition.types);
			post_do_visit(_where_definition);
		}

		public override void visit(where_definition_list _where_definition_list)
		{
			DefaultVisit(_where_definition_list);
			pre_do_visit(_where_definition_list);
			for (int i = 0; i < defs.Count; i++)
				visit(where_definition_list.defs[i]);
			post_do_visit(_where_definition_list);
		}

		public override void visit(sizeof_operator _sizeof_operator)
		{
			DefaultVisit(_sizeof_operator);
			pre_do_visit(_sizeof_operator);
			visit(sizeof_operator.type_def);
			visit(sizeof_operator.expr);
			post_do_visit(_sizeof_operator);
		}

		public override void visit(typeof_operator _typeof_operator)
		{
			DefaultVisit(_typeof_operator);
			pre_do_visit(_typeof_operator);
			visit(typeof_operator.type_name);
			post_do_visit(_typeof_operator);
		}

		public override void visit(compiler_directive _compiler_directive)
		{
			DefaultVisit(_compiler_directive);
			pre_do_visit(_compiler_directive);
			visit(compiler_directive.Name);
			visit(compiler_directive.Directive);
			post_do_visit(_compiler_directive);
		}

		public override void visit(operator_name_ident _operator_name_ident)
		{
			DefaultVisit(_operator_name_ident);
			pre_do_visit(_operator_name_ident);
			post_do_visit(_operator_name_ident);
		}

		public override void visit(var_statement _var_statement)
		{
			DefaultVisit(_var_statement);
			pre_do_visit(_var_statement);
			visit(var_statement.var_def);
			post_do_visit(_var_statement);
		}

		public override void visit(question_colon_expression _question_colon_expression)
		{
			DefaultVisit(_question_colon_expression);
			pre_do_visit(_question_colon_expression);
			visit(question_colon_expression.condition);
			visit(question_colon_expression.ret_if_true);
			visit(question_colon_expression.ret_if_false);
			post_do_visit(_question_colon_expression);
		}

		public override void visit(expression_as_statement _expression_as_statement)
		{
			DefaultVisit(_expression_as_statement);
			pre_do_visit(_expression_as_statement);
			visit(expression_as_statement.expr);
			post_do_visit(_expression_as_statement);
		}

		public override void visit(c_scalar_type _c_scalar_type)
		{
			DefaultVisit(_c_scalar_type);
			pre_do_visit(_c_scalar_type);
			post_do_visit(_c_scalar_type);
		}

		public override void visit(c_module _c_module)
		{
			DefaultVisit(_c_module);
			pre_do_visit(_c_module);
			visit(c_module.defs);
			visit(c_module.used_units);
			post_do_visit(_c_module);
		}

		public override void visit(declarations_as_statement _declarations_as_statement)
		{
			DefaultVisit(_declarations_as_statement);
			pre_do_visit(_declarations_as_statement);
			visit(declarations_as_statement.defs);
			post_do_visit(_declarations_as_statement);
		}

		public override void visit(array_size _array_size)
		{
			DefaultVisit(_array_size);
			pre_do_visit(_array_size);
			visit(array_size.max_value);
			post_do_visit(_array_size);
		}

		public override void visit(enumerator _enumerator)
		{
			DefaultVisit(_enumerator);
			pre_do_visit(_enumerator);
			visit(enumerator.name);
			visit(enumerator.value);
			post_do_visit(_enumerator);
		}

		public override void visit(enumerator_list _enumerator_list)
		{
			DefaultVisit(_enumerator_list);
			pre_do_visit(_enumerator_list);
			for (int i = 0; i < enumerators.Count; i++)
				visit(enumerator_list.enumerators[i]);
			post_do_visit(_enumerator_list);
		}

		public override void visit(c_for_cycle _c_for_cycle)
		{
			DefaultVisit(_c_for_cycle);
			pre_do_visit(_c_for_cycle);
			visit(c_for_cycle.expr1);
			visit(c_for_cycle.expr2);
			visit(c_for_cycle.expr3);
			visit(c_for_cycle.stmt);
			post_do_visit(_c_for_cycle);
		}

		public override void visit(switch_stmt _switch_stmt)
		{
			DefaultVisit(_switch_stmt);
			pre_do_visit(_switch_stmt);
			visit(switch_stmt.condition);
			visit(switch_stmt.stmt);
			post_do_visit(_switch_stmt);
		}

		public override void visit(type_definition_attr_list _type_definition_attr_list)
		{
			DefaultVisit(_type_definition_attr_list);
			pre_do_visit(_type_definition_attr_list);
			for (int i = 0; i < attributes.Count; i++)
				visit(type_definition_attr_list.attributes[i]);
			post_do_visit(_type_definition_attr_list);
		}

		public override void visit(type_definition_attr _type_definition_attr)
		{
			DefaultVisit(_type_definition_attr);
			pre_do_visit(_type_definition_attr);
			post_do_visit(_type_definition_attr);
		}

		public override void visit(lock_stmt _lock_stmt)
		{
			DefaultVisit(_lock_stmt);
			pre_do_visit(_lock_stmt);
			visit(lock_stmt.lock_object);
			visit(lock_stmt.stmt);
			post_do_visit(_lock_stmt);
		}

		public override void visit(compiler_directive_list _compiler_directive_list)
		{
			DefaultVisit(_compiler_directive_list);
			pre_do_visit(_compiler_directive_list);
			for (int i = 0; i < directives.Count; i++)
				visit(compiler_directive_list.directives[i]);
			post_do_visit(_compiler_directive_list);
		}

		public override void visit(compiler_directive_if _compiler_directive_if)
		{
			DefaultVisit(_compiler_directive_if);
			pre_do_visit(_compiler_directive_if);
			visit(compiler_directive_if.if_part);
			visit(compiler_directive_if.elseif_part);
			post_do_visit(_compiler_directive_if);
		}

		public override void visit(documentation_comment_list _documentation_comment_list)
		{
			DefaultVisit(_documentation_comment_list);
			pre_do_visit(_documentation_comment_list);
			for (int i = 0; i < sections.Count; i++)
				visit(documentation_comment_list.sections[i]);
			post_do_visit(_documentation_comment_list);
		}

		public override void visit(documentation_comment_tag _documentation_comment_tag)
		{
			DefaultVisit(_documentation_comment_tag);
			pre_do_visit(_documentation_comment_tag);
			for (int i = 0; i < parameters.Count; i++)
				visit(documentation_comment_tag.parameters[i]);
			post_do_visit(_documentation_comment_tag);
		}

		public override void visit(documentation_comment_tag_param _documentation_comment_tag_param)
		{
			DefaultVisit(_documentation_comment_tag_param);
			pre_do_visit(_documentation_comment_tag_param);
			post_do_visit(_documentation_comment_tag_param);
		}

		public override void visit(documentation_comment_section _documentation_comment_section)
		{
			DefaultVisit(_documentation_comment_section);
			pre_do_visit(_documentation_comment_section);
			for (int i = 0; i < tags.Count; i++)
				visit(documentation_comment_section.tags[i]);
			post_do_visit(_documentation_comment_section);
		}

		public override void visit(token_taginfo _token_taginfo)
		{
			DefaultVisit(_token_taginfo);
			pre_do_visit(_token_taginfo);
			post_do_visit(_token_taginfo);
		}

		public override void visit(declaration_specificator _declaration_specificator)
		{
			DefaultVisit(_declaration_specificator);
			pre_do_visit(_declaration_specificator);
			post_do_visit(_declaration_specificator);
		}

		public override void visit(ident_with_templateparams _ident_with_templateparams)
		{
			DefaultVisit(_ident_with_templateparams);
			pre_do_visit(_ident_with_templateparams);
			visit(ident_with_templateparams.name);
			visit(ident_with_templateparams.template_params);
			post_do_visit(_ident_with_templateparams);
		}

		public override void visit(template_type_name _template_type_name)
		{
			DefaultVisit(_template_type_name);
			pre_do_visit(_template_type_name);
			visit(template_type_name.template_args);
			post_do_visit(_template_type_name);
		}

		public override void visit(default_operator _default_operator)
		{
			DefaultVisit(_default_operator);
			pre_do_visit(_default_operator);
			visit(default_operator.type_name);
			post_do_visit(_default_operator);
		}

		public override void visit(bracket_expr _bracket_expr)
		{
			DefaultVisit(_bracket_expr);
			pre_do_visit(_bracket_expr);
			visit(bracket_expr.expr);
			post_do_visit(_bracket_expr);
		}

		public override void visit(attribute _attribute)
		{
			DefaultVisit(_attribute);
			pre_do_visit(_attribute);
			visit(attribute.qualifier);
			visit(attribute.type);
			visit(attribute.arguments);
			post_do_visit(_attribute);
		}

		public override void visit(simple_attribute_list _simple_attribute_list)
		{
			DefaultVisit(_simple_attribute_list);
			pre_do_visit(_simple_attribute_list);
			for (int i = 0; i < attributes.Count; i++)
				visit(simple_attribute_list.attributes[i]);
			post_do_visit(_simple_attribute_list);
		}

		public override void visit(attribute_list _attribute_list)
		{
			DefaultVisit(_attribute_list);
			pre_do_visit(_attribute_list);
			for (int i = 0; i < attributes.Count; i++)
				visit(attribute_list.attributes[i]);
			post_do_visit(_attribute_list);
		}

		public override void visit(function_lambda_definition _function_lambda_definition)
		{
			DefaultVisit(_function_lambda_definition);
			pre_do_visit(_function_lambda_definition);
			visit(function_lambda_definition.ident_list);
			visit(function_lambda_definition.return_type);
			visit(function_lambda_definition.formal_parameters);
			visit(function_lambda_definition.proc_body);
			visit(function_lambda_definition.proc_definition);
			visit(function_lambda_definition.parameters);
			for (int i = 0; i < defs.Count; i++)
				visit(function_lambda_definition.defs[i]);
			visit(function_lambda_definition.substituting_node);
			post_do_visit(_function_lambda_definition);
		}

		public override void visit(function_lambda_call _function_lambda_call)
		{
			DefaultVisit(_function_lambda_call);
			pre_do_visit(_function_lambda_call);
			visit(function_lambda_call.f_lambda_def);
			visit(function_lambda_call.parameters);
			post_do_visit(_function_lambda_call);
		}

		public override void visit(semantic_check _semantic_check)
		{
			DefaultVisit(_semantic_check);
			pre_do_visit(_semantic_check);
			for (int i = 0; i < param.Count; i++)
				visit(semantic_check.param[i]);
			post_do_visit(_semantic_check);
		}

		public override void visit(lambda_inferred_type _lambda_inferred_type)
		{
			DefaultVisit(_lambda_inferred_type);
			pre_do_visit(_lambda_inferred_type);
			post_do_visit(_lambda_inferred_type);
		}

		public override void visit(same_type_node _same_type_node)
		{
			DefaultVisit(_same_type_node);
			pre_do_visit(_same_type_node);
			visit(same_type_node.ex);
			post_do_visit(_same_type_node);
		}

		public override void visit(name_assign_expr _name_assign_expr)
		{
			DefaultVisit(_name_assign_expr);
			pre_do_visit(_name_assign_expr);
			visit(name_assign_expr.name);
			visit(name_assign_expr.expr);
			post_do_visit(_name_assign_expr);
		}

		public override void visit(name_assign_expr_list _name_assign_expr_list)
		{
			DefaultVisit(_name_assign_expr_list);
			pre_do_visit(_name_assign_expr_list);
			for (int i = 0; i < name_expr.Count; i++)
				visit(name_assign_expr_list.name_expr[i]);
			post_do_visit(_name_assign_expr_list);
		}

		public override void visit(unnamed_type_object _unnamed_type_object)
		{
			DefaultVisit(_unnamed_type_object);
			pre_do_visit(_unnamed_type_object);
			visit(unnamed_type_object.ne_list);
			visit(unnamed_type_object.new_ex);
			post_do_visit(_unnamed_type_object);
		}

		public override void visit(semantic_type_node _semantic_type_node)
		{
			DefaultVisit(_semantic_type_node);
			pre_do_visit(_semantic_type_node);
			post_do_visit(_semantic_type_node);
		}

		public override void visit(short_func_definition _short_func_definition)
		{
			DefaultVisit(_short_func_definition);
			pre_do_visit(_short_func_definition);
			visit(short_func_definition.procdef);
			post_do_visit(_short_func_definition);
		}

		public override void visit(no_type_foreach _no_type_foreach)
		{
			DefaultVisit(_no_type_foreach);
			pre_do_visit(_no_type_foreach);
			post_do_visit(_no_type_foreach);
		}

		public override void visit(matching_expression _matching_expression)
		{
			DefaultVisit(_matching_expression);
			pre_do_visit(_matching_expression);
			visit(matching_expression.left);
			visit(matching_expression.right);
			post_do_visit(_matching_expression);
		}

		public override void visit(closure_substituting_node _closure_substituting_node)
		{
			DefaultVisit(_closure_substituting_node);
			pre_do_visit(_closure_substituting_node);
			visit(closure_substituting_node.substitution);
			post_do_visit(_closure_substituting_node);
		}

		public override void visit(sequence_type _sequence_type)
		{
			DefaultVisit(_sequence_type);
			pre_do_visit(_sequence_type);
			visit(sequence_type.elements_type);
			post_do_visit(_sequence_type);
		}

		public override void visit(modern_proc_type _modern_proc_type)
		{
			DefaultVisit(_modern_proc_type);
			pre_do_visit(_modern_proc_type);
			visit(modern_proc_type.aloneparam);
			visit(modern_proc_type.el);
			visit(modern_proc_type.res);
			post_do_visit(_modern_proc_type);
		}

		public override void visit(yield_node _yield_node)
		{
			DefaultVisit(_yield_node);
			pre_do_visit(_yield_node);
			visit(yield_node.ex);
			post_do_visit(_yield_node);
		}

		public override void visit(template_operator_name _template_operator_name)
		{
			DefaultVisit(_template_operator_name);
			pre_do_visit(_template_operator_name);
			visit(template_operator_name.opname);
			post_do_visit(_template_operator_name);
		}

		public override void visit(semantic_addr_value _semantic_addr_value)
		{
			DefaultVisit(_semantic_addr_value);
			pre_do_visit(_semantic_addr_value);
			post_do_visit(_semantic_addr_value);
		}

		public override void visit(pair_type_stlist _pair_type_stlist)
		{
			DefaultVisit(_pair_type_stlist);
			pre_do_visit(_pair_type_stlist);
			visit(pair_type_stlist.tn);
			visit(pair_type_stlist.exprs);
			post_do_visit(_pair_type_stlist);
		}

		public override void visit(assign_tuple _assign_tuple)
		{
			DefaultVisit(_assign_tuple);
			pre_do_visit(_assign_tuple);
			visit(assign_tuple.vars);
			visit(assign_tuple.expr);
			post_do_visit(_assign_tuple);
		}

		public override void visit(addressed_value_list _addressed_value_list)
		{
			DefaultVisit(_addressed_value_list);
			pre_do_visit(_addressed_value_list);
			for (int i = 0; i < variables.Count; i++)
				visit(addressed_value_list.variables[i]);
			post_do_visit(_addressed_value_list);
		}

		public override void visit(tuple_node _tuple_node)
		{
			DefaultVisit(_tuple_node);
			pre_do_visit(_tuple_node);
			visit(tuple_node.el);
			post_do_visit(_tuple_node);
		}

		public override void visit(uses_closure _uses_closure)
		{
			DefaultVisit(_uses_closure);
			pre_do_visit(_uses_closure);
			for (int i = 0; i < listunitsections.Count; i++)
				visit(uses_closure.listunitsections[i]);
			post_do_visit(_uses_closure);
		}

		public override void visit(dot_question_node _dot_question_node)
		{
			DefaultVisit(_dot_question_node);
			pre_do_visit(_dot_question_node);
			visit(dot_question_node.left);
			visit(dot_question_node.right);
			post_do_visit(_dot_question_node);
		}

		public override void visit(slice_expr _slice_expr)
		{
			DefaultVisit(_slice_expr);
			pre_do_visit(_slice_expr);
			visit(slice_expr.v);
			visit(slice_expr.from);
			visit(slice_expr.to);
			visit(slice_expr.step);
			post_do_visit(_slice_expr);
		}

		public override void visit(no_type _no_type)
		{
			DefaultVisit(_no_type);
			pre_do_visit(_no_type);
			post_do_visit(_no_type);
		}

		public override void visit(yield_unknown_ident _yield_unknown_ident)
		{
			DefaultVisit(_yield_unknown_ident);
			pre_do_visit(_yield_unknown_ident);
			post_do_visit(_yield_unknown_ident);
		}

		public override void visit(yield_unknown_expression_type _yield_unknown_expression_type)
		{
			DefaultVisit(_yield_unknown_expression_type);
			pre_do_visit(_yield_unknown_expression_type);
			post_do_visit(_yield_unknown_expression_type);
		}

		public override void visit(yield_unknown_foreach_type _yield_unknown_foreach_type)
		{
			DefaultVisit(_yield_unknown_foreach_type);
			pre_do_visit(_yield_unknown_foreach_type);
			post_do_visit(_yield_unknown_foreach_type);
		}

		public override void visit(yield_sequence_node _yield_sequence_node)
		{
			DefaultVisit(_yield_sequence_node);
			pre_do_visit(_yield_sequence_node);
			visit(yield_sequence_node.ex);
			post_do_visit(_yield_sequence_node);
		}

		public override void visit(assign_var_tuple _assign_var_tuple)
		{
			DefaultVisit(_assign_var_tuple);
			pre_do_visit(_assign_var_tuple);
			visit(assign_var_tuple.idents);
			visit(assign_var_tuple.expr);
			post_do_visit(_assign_var_tuple);
		}

		public override void visit(slice_expr_question _slice_expr_question)
		{
			DefaultVisit(_slice_expr_question);
			pre_do_visit(_slice_expr_question);
			post_do_visit(_slice_expr_question);
		}

		public override void visit(semantic_check_sugared_statement_node _semantic_check_sugared_statement_node)
		{
			DefaultVisit(_semantic_check_sugared_statement_node);
			pre_do_visit(_semantic_check_sugared_statement_node);
			for (int i = 0; i < lst.Count; i++)
				visit(semantic_check_sugared_statement_node.lst[i]);
			post_do_visit(_semantic_check_sugared_statement_node);
		}

		public override void visit(sugared_expression _sugared_expression)
		{
			DefaultVisit(_sugared_expression);
			pre_do_visit(_sugared_expression);
			visit(sugared_expression.new_expr);
			post_do_visit(_sugared_expression);
		}

		public override void visit(sugared_addressed_value _sugared_addressed_value)
		{
			DefaultVisit(_sugared_addressed_value);
			pre_do_visit(_sugared_addressed_value);
			visit(sugared_addressed_value.new_addr_value);
			post_do_visit(_sugared_addressed_value);
		}

		public override void visit(double_question_node _double_question_node)
		{
			DefaultVisit(_double_question_node);
			pre_do_visit(_double_question_node);
			visit(double_question_node.left);
			visit(double_question_node.right);
			post_do_visit(_double_question_node);
		}

		public override void visit(typeclass_restriction _typeclass_restriction)
		{
			DefaultVisit(_typeclass_restriction);
			pre_do_visit(_typeclass_restriction);
			visit(typeclass_restriction.restriction_args);
			post_do_visit(_typeclass_restriction);
		}

		public override void visit(instance_definition _instance_definition)
		{
			DefaultVisit(_instance_definition);
			pre_do_visit(_instance_definition);
			visit(instance_definition.body);
			post_do_visit(_instance_definition);
		}

		public override void visit(typeclass_definition _typeclass_definition)
		{
			DefaultVisit(_typeclass_definition);
			pre_do_visit(_typeclass_definition);
			visit(typeclass_definition.additional_restrictions);
			visit(typeclass_definition.body);
			post_do_visit(_typeclass_definition);
		}
	}


}