unit SyntaxTree;

interface

uses System.Collections.Generic;

type
   file_position = class
   private
    function get_column_num: Integer;
    function get_line_num: Integer;
    
    // Methods
    public constructor Create(line_num: Integer; column_num: Integer); 

    // Properties
    public property column_num: Integer read get_column_num;
    public property line_num: Integer read get_line_num;

    // Fields
    private _column_num: Integer;
    private _line_num: Integer;

  end;

   SourceContext = class
   private
    function get_begin_position: file_position;
    function get_end_position: file_position;
    function get_FileName: string;
    procedure set_FileName(value: string);
    function get_LeftSourceContext: SourceContext;
    function get_Length: Integer;
    function get_Position: Integer;
    function get_RightSourceContext: SourceContext;

    // Methods
    public constructor Create(left: SourceContext; right: SourceContext); 
    public constructor Create(beg_line_num: Integer; beg_column_num: Integer; end_line_num: Integer; end_column_num: Integer); 
    public constructor Create(beg_line_num: Integer; beg_column_num: Integer; end_line_num: Integer; end_column_num: Integer; _begin_symbol_position: Integer; _end_symbol_position: Integer); 
    public function &In(sc: SourceContext): boolean; 
    public function ToString: string; override; 

    // Properties
    public property begin_position: file_position read get_begin_position;
    public property end_position: file_position read get_end_position;
    public property FileName: string read get_FileName write set_FileName;
    public property LeftSourceContext: SourceContext read get_LeftSourceContext;
    public property Length: Integer read get_Length;
    public property Position: Integer read get_Position;
    public property RightSourceContext: SourceContext read get_RightSourceContext;

    // Fields
    private _begin_position: file_position;
    private _begin_symbol_position: Integer;
    private _end_position: file_position;
    private _end_symbol_position: Integer;
    private _file_name: string;

  end;
  for_cycle_type = (fct_to,fct_downto);
  access_modifer = (public_modifer, protected_modifer, private_modifer, published_modifer, internal_modifer, none);
  c_scalar_sign = (ssNone, ssSigned, ssUnsigned);
  c_scalar_type_name = ( tn_char, tn_int, tn_short, tn_long, tn_short_int, tn_long_int, tn_float, tn_double, tn_void);
  class_keyword = ( ckClass, ckInterface, ckRecord, ckStruct, ckUnion, ckTemplateClass, ckTemplateRecord);
  class_attribute = ( caNone, caSealed);
  parametr_kind = (pk_none, pk_var_parametr, pk_const_parametr, pk_out_parametr, pk_params_parametr );
  type_definition_attribute = ( tdaNone, tdaStatic, tdaExtern, tdaRegister, tdaAuto, tdaVolatile, tdaConst, tdaInline);
  known_type = (string_type,none_type);
  proc_attribute = (attr_stdcall,attr_override,attr_forward,attr_far,attr_virtual,attr_dynamic,attr_cdecl,
		attr_overload,attr_pascal,attr_register,attr_reintroduce,attr_external,attr_export,attr_near,attr_safecall,
		attr_abstract,attr_static);
	
	Operators =
	(                           // Pascal  C
		opUndefined,
        
        //Arithmetic operators
        opPlus,                   //  +       +
        opMinus,                  //  -       -
        opMultiplication,         //  *       *   
        opDivision,               //  /       /
        opModulusRemainder,       //  mod     %
        opAssignmentAddition,     //  +=      +=
        opAssignmentSubtraction,  //  -=      -=
        opAssignmentMultiplication,// *=      *= 
        opAssignmentDivision,     //  /=      /=
        opAssignmentModulus,      //          %=
        opPrefixIncrement,        //          ++()
        opPostfixIncrement, 	    //          ()++
        opPrefixDecrement,        //          --()
        opPostfixDecrement, 	    //          ()--
        
        //Comparison operators
        opLogicalAND,             //  and     &&
        opLogicalOR,              //  or      ||
        opIntegerDivision,        //  div     
        opLess,                   //  <       < 
        opGreater,                //  >       >
        opLessEqual,              //  <=      <= 
        opGreaterEqual,           //  >=      >=
        opEqual,                  //  =       ==
        opNotEqual,               //  <>      !=
        opLogicalNOT,        //  not     !
        
        //Bitwise operators
        opBitwiseLeftShift,       //  shl     <<                 
        opBitwiseRightShift,      //  shr     >>
        opBitwiseAND,             //          &
        opBitwiseOR,              //          |
        opBitwiseXOR,             //  xor     ^
        opBitwiseNOT,             //          ~
        opAssignmentBitwiseLeftShift,//       <<=
        opAssignmentBitwiseRightShift,//      >>=
        opAssignmentBitwiseAND,   //          &=
        opAssignmentBitwiseOR,    //          |=
        opAssignmentBitwiseXOR,   //          ^=

        //Other operators
        opAssignment,             //  :=      =                 
        opIn,                     //  in
        opIs,                     //  is
        opAs,                     //  as
        opDereference,            //  ^       *
        opAddressOf,              //  @       &
        opMemberByPointer,        //          ->
        opMember                  //  .       .
    );
  SwitchPartType = ( sptSwitch, sptCase, sptDefault );
  JumpStmtType = ( jstReturn, jstBreak, jstContinue );
  UnitHeaderKeyword = ( uhkUnit, uhkLibrary);
  WhileCycleType = ( wctWhile, wctDoWhile );
  op_typecast = ( is_op, as_op, typecast );
  oberon_export_marker = (export,export_readonly);
  LanguageId = ( PascalABCNET, C );
  
  IVisitor = class;
  
  
  access_modifer_node = class;
  addressed_value = class;
  addressed_value_funcname = class;
  array_const = class;
  array_of_const_type_definition = class;
  array_of_named_type_definition = class;
  array_size = class;
  array_type = class;
  assign = class;
  bin_expr = class;
  block = class;
  bool_const = class;
  c_for_cycle = class;
  c_module = class;
  c_scalar_type = class;
  case_node = class;
  case_variant = class;
  case_variants = class;
  char_const = class;
  class_body = class;
  class_definition = class;
  class_members = class;
  class_predefinition = class;
  compilation_unit = class;
  compiler_directive = class;
  compiler_directive_if = class;
  compiler_directive_list = class;
  const_definition = class;
  const_node = class;
  &constructor = class;
  consts_definitions_list = class;
  //declaration = class;
  declarations = class;
  declarations_as_statement = class;
  default_indexer_property_node = class;
  dereference = class;
  &destructor = class;
  diap_expr = class;
  diapason = class;
  diapason_expr = class;
  documentation_comment_list = class;
  documentation_comment_section = class;
  documentation_comment_tag = class;
  documentation_comment_tag_param = class;
  dot_node = class;
  double_const = class;
  empty_statement = class;
  enum_type_definition = class;
  enumerator = class;
  enumerator_list = class;
  exception_block = class;
  exception_handler = class;
  exception_handler_list = class;
  exception_ident = class;
  //expression = class;
  expression_as_statement = class;
  expression_list = class;
  external_directive = class;
  file_type = class;
  file_type_definition = class;
  for_node = class;
  foreach_stmt = class;
  formal_parametres = class;
  format_expr = class;
  function_header = class;
  get_address = class;
  goto_statement = class;
  hex_constant = class;
  ident = class;
  ident_list = class;
  if_node = class;
  implementation_node = class;
  index_property = class;
  indexer = class;
  indexers_types = class;
  inherited_ident = class;
  inherited_message = class;
  inherited_method_call = class;
  initfinal_part = class;
  int32_const = class;
  int64_const = class;
  interface_node = class;
  jump_stmt = class;
  known_type_definition = class;
  known_type_ident = class;

  label_definitions = class;

  labeled_statement = class;
  literal = class;

  literal_const_line = class;

  lock_stmt = class;

  loop_stmt = class;

  method_call = class;

  method_name = class;

  named_type_reference = class;

  named_type_reference_list = class;

  new_expr = class;

  nil_const = class;

  oberon_exit_stmt = class;

  oberon_ident_with_export_marker = class;

  oberon_import_module = class;

  oberon_module = class;

  oberon_procedure_header = class;

  oberon_procedure_receiver = class;

  oberon_withstmt = class;

  oberon_withstmt_guardstat = class;

  oberon_withstmt_guardstat_list = class;

  on_exception = class;

  on_exception_list = class;

  op_type_node = class;

  operator_name_ident = class;

  pascal_set_constant = class;

  proc_block = class;

  procedure_attribute = class;

  procedure_attributes_list = class;

  procedure_call = class;

  procedure_definition = class;

  procedure_header = class;

  program_body = class;

  program_module = class;

  program_name = class;

  program_tree = class;

  property_accessors = class;

  property_array_default = class;

  property_interface = class;

  property_parameter = class;

  property_parameter_list = class;

  question_colon_expression = class;

  raise_statement = class;

  raise_stmt = class;

  read_accessor_name = class;

  record_const = class;

  record_const_definition = class;

  record_type = class;

  record_type_parts = class;

  ref_type = class;

  repeat_node = class;

  roof_dereference = class;

  set_type_definition = class;

  sharp_char_const = class;

  simple_const_definition = class;

  simple_property = class;

  sizeof_operator = class;

  //statement = class;

  statement_list = class;

  string_const = class;

  string_num_definition = class;

  subprogram_body = class;
  
  switch_stmt = class;
  
  template_param_list = class;

  template_type_reference = class;
  token_info = class;

  token_taginfo = class;

  try_except_statement = class;

  try_finally_statement = class;

  try_handler = class;

  try_handler_except = class;

  try_handler_finally = class;

  try_statement = class;

 try_stmt = class;

 type_declaration = class;

 type_declarations = class;

 //type_definition = class;

 type_definition_attr = class;

 type_definition_attr_list = class;

 type_definition_list = class;

 typecast_node = class;

 typed_const_definition = class;

 typed_parametres = class;

 typeof_operator = class;

 uint64_const = class;

 un_expr = class;

 unit_module = class;

 unit_name = class;

 unit_or_namespace = class;

 uses_list = class;

 uses_unit_in = class;

 using_list = class;

 var_def_list = class;

 var_def_statement = class;

 var_statement = class;

 variable_definitions = class;

 variant = class;

 variant_list = class;

 variant_record_type = class;

 variant_type = class;

 variant_types = class;

 where_definition = class;

 where_definition_list = class;

 while_node = class;

 with_statement = class;

 write_accessor_name = class;

syntax_tree_node = class
    private _source_context: SourceContext;
    // Methods
    public constructor Create; 
    public constructor Create(_source_context: SourceContext); 
    public procedure visit(visitor: IVisitor); virtual; 

    // Properties
    public property source_context: SourceContext read _source_context write _source_context;

    // Fields
    

  end;
  
  declaration = class(syntax_tree_node)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

  end;
  
  statement = class(declaration)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

  end;
  
  try_statement = class(statement)
    private _statements: statement_list;
    // Methods
    public constructor Create; 
    public constructor Create(_statements: statement_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property statements: statement_list read _statements write _statements;

    // Fields
  end;
  
  expression = class(statement)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

  end;
  
  unit_or_namespace = class(syntax_tree_node)
    private _name: ident_list;
    // Methods
    public constructor Create; 
    public constructor Create(_name: ident_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property name: ident_list read _name write _name;

    // Fields
  end;
  
  token_info = class(syntax_tree_node)
    private _text: string;
    // Methods
    public constructor Create; 
    public constructor Create(_text: string); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property text: string read _text write _text;

    // Fields
  end;
  
  type_definition = class(declaration)
    private _attr_list: type_definition_attr_list;
    // Methods
    public constructor Create; 
    public constructor Create(_attr_list: type_definition_attr_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property attr_list: type_definition_attr_list read _attr_list write _attr_list;

    // Fields
  end;
  
  proc_block = class(syntax_tree_node)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

  end;
  
  addressed_value = class(expression)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

  end;
  
  simple_property = class(declaration)
    private _accessors: property_accessors;
     private _array_default: property_array_default;
     private _index_expression: expression;
     private _parameter_list: property_parameter_list;
     private _property_name: ident;
     private _property_type: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_property_name: ident; _property_type: type_definition; _index_expression: expression; _accessors: property_accessors; _array_default: property_array_default; _parameter_list: property_parameter_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property accessors: property_accessors read _accessors write _accessors;
    public property array_default: property_array_default read _array_default write _array_default;
    public property index_expression: expression read _index_expression write _index_expression;
    public property parameter_list: property_parameter_list read _parameter_list write _parameter_list;
    public property property_name: ident read _property_name write _property_name;
    public property property_type: type_definition read _property_type write _property_type;

    // Fields
    end;

  const_node = class(addressed_value)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

  end;
  
  int64_const = class(const_node)
    private _val: Int64;
    // Methods
    public constructor Create; 
    public constructor Create(_val: Int64); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property val: Int64 read _val write _val;

    // Fields
  end;
  
  compilation_unit = class(syntax_tree_node)
    private _compiler_directives: List<compiler_directive>;
     private _file_name: string;
     private _Language: LanguageId;
    // Methods
    public constructor Create; 
    public constructor Create(_file_name: string; _compiler_directives: List<compiler_directive>; _Language: LanguageId); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property compiler_directives: List<compiler_directive> read _compiler_directives write _compiler_directives;
    public property file_name: string read _file_name write _file_name;
    public property Language: LanguageId read _Language write _Language;

    // Fields

  end;
  
  literal = class(const_node)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

  end;
  
  type_declaration = class(declaration)
    private _type_def: type_definition;
     private _type_name: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_type_name: ident; _type_def: type_definition); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property type_def: type_definition read _type_def write _type_def;
    public property type_name: ident read _type_name write _type_name;

    // Fields
  end;
  
  procedure_header = class(type_definition)
    private _class_keyword: boolean;
     private _name: method_name;
     private _of_object: boolean;
     private _parametres: formal_parametres;
     private _proc_attributes: procedure_attributes_list;
    // Methods
    public constructor Create; 
    public constructor Create(_parametres: formal_parametres; _proc_attributes: procedure_attributes_list; _name: method_name; _of_object: boolean; _class_keyword: boolean); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property class_keyword: boolean read _class_keyword write _class_keyword;
    public property name: method_name read _name write _name;
    public property of_object: boolean read _of_object write _of_object;
    public property parametres: formal_parametres read _parametres write _parametres;
    public property proc_attributes: procedure_attributes_list read _proc_attributes write _proc_attributes;

    // Fields
  end;
  
  IVisitor = class
    // Methods
    procedure visit(_access_modifer_node: access_modifer_node);virtual;
    procedure visit(_addressed_value: addressed_value);virtual;
    procedure visit(_addressed_value_funcname: addressed_value_funcname);virtual;
    procedure visit(_array_const: array_const);virtual;
    procedure visit(_array_of_const_type_definition: array_of_const_type_definition);virtual;
    procedure visit(_array_of_named_type_definition: array_of_named_type_definition);virtual;
    procedure visit(_array_size: array_size);virtual;
    procedure visit(_array_type: array_type);virtual;
    procedure visit(_assign: assign);virtual;
    procedure visit(_bin_expr: bin_expr);virtual;
    procedure visit(_block: block);virtual;
    procedure visit(_bool_const: bool_const);virtual;
    procedure visit(_c_for_cycle: c_for_cycle);virtual;
    procedure visit(_c_module: c_module);virtual;
    procedure visit(_c_scalar_type: c_scalar_type);virtual;
    procedure visit(_case_node: case_node);virtual;
    procedure visit(_case_variant: case_variant);virtual;
    procedure visit(_case_variants: case_variants);virtual;
    procedure visit(_char_const: char_const);virtual;
    procedure visit(_class_body: class_body);virtual;
    procedure visit(_class_definition: class_definition);virtual;
    procedure visit(_class_members: class_members);virtual;
    procedure visit(_class_predefinition: class_predefinition);virtual;
    procedure visit(_compilation_unit: compilation_unit);virtual;
    procedure visit(_compiler_directive: compiler_directive);virtual;
    procedure visit(_compiler_directive_if: compiler_directive_if);virtual;
    procedure visit(_compiler_directive_list: compiler_directive_list);virtual;
    procedure visit(_const_definition: const_definition);virtual;
    procedure visit(_const_node: const_node);virtual;
    procedure visit(_constructor: &constructor);virtual;
    procedure visit(_consts_definitions_list: consts_definitions_list);virtual;
    procedure visit(_declaration: declaration);virtual;
    procedure visit(_declarations: declarations);virtual;
    procedure visit(_declarations_as_statement: declarations_as_statement);virtual;
    procedure visit(_default_indexer_property_node: default_indexer_property_node);virtual;
    procedure visit(_dereference: dereference);virtual;
    procedure visit(_destructor: &destructor);virtual;
    procedure visit(_diap_expr: diap_expr);virtual;
    procedure visit(_diapason: diapason);virtual;
    procedure visit(_diapason_expr: diapason_expr);virtual;
    procedure visit(_documentation_comment_list: documentation_comment_list);virtual;
    procedure visit(_documentation_comment_section: documentation_comment_section);virtual;
    procedure visit(_documentation_comment_tag: documentation_comment_tag);virtual;
    procedure visit(_documentation_comment_tag_param: documentation_comment_tag_param);virtual;
    procedure visit(_dot_node: dot_node);virtual;
    procedure visit(_double_const: double_const);virtual;
    procedure visit(_empty_statement: empty_statement);virtual;
    procedure visit(_enum_type_definition: enum_type_definition);virtual;
    procedure visit(_enumerator: enumerator);virtual;
    procedure visit(_enumerator_list: enumerator_list);virtual;
    procedure visit(_exception_block: exception_block);virtual;
    procedure visit(_exception_handler: exception_handler);virtual;
    procedure visit(_exception_handler_list: exception_handler_list);virtual;
    procedure visit(_exception_ident: exception_ident);virtual;
    procedure visit(_expression: expression);virtual;
    procedure visit(_expression_as_statement: expression_as_statement);virtual;
    procedure visit(_expression_list: expression_list);virtual;
    procedure visit(_external_directive: external_directive);virtual;
    procedure visit(_file_type: file_type);virtual;
    procedure visit(_file_type_definition: file_type_definition);virtual;
    procedure visit(_for_node: for_node);virtual;
    procedure visit(_foreach_stmt: foreach_stmt);virtual;
    procedure visit(_formal_parametres: formal_parametres);virtual;
    procedure visit(_format_expr: format_expr);virtual;
    procedure visit(_function_header: function_header);virtual;
    procedure visit(_get_address: get_address);virtual;
    procedure visit(_goto_statement: goto_statement);virtual;
    procedure visit(_hex_constant: hex_constant);virtual;
    procedure visit(_ident: ident);virtual;
    procedure visit(_ident_list: ident_list);virtual;
    procedure visit(_if_node: if_node);virtual;
    procedure visit(_implementation_node: implementation_node);virtual;
    procedure visit(_index_property: index_property);virtual;
    procedure visit(_indexer: indexer);virtual;
    procedure visit(_indexers_types: indexers_types);virtual;
    procedure visit(_inherited_ident: inherited_ident);virtual;
    procedure visit(_inherited_message: inherited_message);virtual;
    procedure visit(_inherited_method_call: inherited_method_call);virtual;
    procedure visit(_initfinal_part: initfinal_part);virtual;
    procedure visit(_int32_const: int32_const);virtual;
    procedure visit(_int64_const: int64_const);virtual;
    procedure visit(_interface_node: interface_node);virtual;
    procedure visit(_jump_stmt: jump_stmt);virtual;
    procedure visit(_known_type_definition: known_type_definition);virtual;
    procedure visit(_known_type_ident: known_type_ident);virtual;
    procedure visit(_label_definitions: label_definitions);virtual;
    procedure visit(_labeled_statement: labeled_statement);virtual;
    procedure visit(_literal: literal);virtual;
    procedure visit(_literal_const_line: literal_const_line);virtual;
    procedure visit(_lock_stmt: lock_stmt);virtual;
    procedure visit(_loop_stmt: loop_stmt);virtual;
    procedure visit(_method_call: method_call);virtual;
    procedure visit(_method_name: method_name);virtual;
    procedure visit(_named_type_reference: named_type_reference);virtual;
    procedure visit(_named_type_reference_list: named_type_reference_list);virtual;
    procedure visit(_new_expr: new_expr);virtual;
    procedure visit(_nil_const: nil_const);virtual;
    procedure visit(_oberon_exit_stmt: oberon_exit_stmt);virtual;
    procedure visit(_oberon_ident_with_export_marker: oberon_ident_with_export_marker);virtual;
    procedure visit(_oberon_import_module: oberon_import_module);virtual;
    procedure visit(_oberon_module: oberon_module);virtual;
    procedure visit(_oberon_procedure_header: oberon_procedure_header);virtual;
    procedure visit(_oberon_procedure_receiver: oberon_procedure_receiver);virtual;
    procedure visit(_oberon_withstmt: oberon_withstmt);virtual;
    procedure visit(_oberon_withstmt_guardstat: oberon_withstmt_guardstat);virtual;
    procedure visit(_oberon_withstmt_guardstat_list: oberon_withstmt_guardstat_list);virtual;
    procedure visit(_on_exception: on_exception);virtual;
    procedure visit(_on_exception_list: on_exception_list);virtual;
    procedure visit(_op_type_node: op_type_node);virtual;
    procedure visit(_operator_name_ident: operator_name_ident);virtual;
    procedure visit(_pascal_set_constant: pascal_set_constant);virtual;
    procedure visit(_proc_block: proc_block);virtual;
    procedure visit(_procedure_attribute: procedure_attribute);virtual;
    procedure visit(_procedure_attributes_list: procedure_attributes_list);virtual;
    procedure visit(_procedure_call: procedure_call);virtual;
    procedure visit(_procedure_definition: procedure_definition);virtual;
    procedure visit(_procedure_header: procedure_header);virtual;
    procedure visit(_program_body: program_body);virtual;
    procedure visit(_program_module: program_module);virtual;
    procedure visit(_program_name: program_name);virtual;
    procedure visit(_program_tree: program_tree);virtual;
    procedure visit(_property_accessors: property_accessors);virtual;
    procedure visit(_property_array_default: property_array_default);virtual;
    procedure visit(_property_interface: property_interface);virtual;
    procedure visit(_property_parameter: property_parameter);virtual;
    procedure visit(_property_parameter_list: property_parameter_list);virtual;
    procedure visit(_question_colon_expression: question_colon_expression);virtual;
    procedure visit(_raise_statement: raise_statement);virtual;
    procedure visit(_raise_stmt: raise_stmt);virtual;
    procedure visit(_read_accessor_name: read_accessor_name);virtual;
    procedure visit(_record_const: record_const);virtual;
    procedure visit(_record_const_definition: record_const_definition);virtual;
    procedure visit(_record_type: record_type);virtual;
    procedure visit(_record_type_parts: record_type_parts);virtual;
    procedure visit(_ref_type: ref_type);virtual;
    procedure visit(_repeat_node: repeat_node);virtual;
    procedure visit(_roof_dereference: roof_dereference);virtual;
    procedure visit(_set_type_definition: set_type_definition);virtual;
    procedure visit(_sharp_char_const: sharp_char_const);virtual;
    procedure visit(_simple_const_definition: simple_const_definition);virtual;
    procedure visit(_simple_property: simple_property);virtual;
    procedure visit(_sizeof_operator: sizeof_operator);virtual;
    procedure visit(_statement: statement);virtual;
    procedure visit(_statement_list: statement_list);virtual;
    procedure visit(_string_const: string_const);virtual;
    procedure visit(_string_num_definition: string_num_definition);virtual;
    procedure visit(_subprogram_body: subprogram_body);virtual;
    procedure visit(_switch_stmt: switch_stmt);virtual;
    procedure visit(_syntax_tree_node: syntax_tree_node);virtual;
    procedure visit(_template_param_list: template_param_list);virtual;
    procedure visit(_template_type_reference: template_type_reference);virtual;
    procedure visit(_token_info: token_info);virtual;
    procedure visit(_token_taginfo: token_taginfo);virtual;
    procedure visit(_try_except_statement: try_except_statement);virtual;
    procedure visit(_try_finally_statement: try_finally_statement);virtual;
    procedure visit(_try_handler: try_handler);virtual;
    procedure visit(_try_handler_except: try_handler_except);virtual;
    procedure visit(_try_handler_finally: try_handler_finally);virtual;
    procedure visit(_try_statement: try_statement);virtual;
    procedure visit(_try_stmt: try_stmt);virtual;
    procedure visit(_type_declaration: type_declaration);virtual;
    procedure visit(_type_declarations: type_declarations);virtual;
    procedure visit(_type_definition: type_definition);virtual;
    procedure visit(_type_definition_attr: type_definition_attr);virtual;
    procedure visit(_type_definition_attr_list: type_definition_attr_list);virtual;
    procedure visit(_type_definition_list: type_definition_list);virtual;
    procedure visit(_typecast_node: typecast_node);virtual;
    procedure visit(_typed_const_definition: typed_const_definition);virtual;
    procedure visit(_typed_parametres: typed_parametres);virtual;
    procedure visit(_typeof_operator: typeof_operator);virtual;
    procedure visit(_uint64_const: uint64_const);virtual;
    procedure visit(_un_expr: un_expr);virtual;
    procedure visit(_unit_module: unit_module);virtual;
    procedure visit(_unit_name: unit_name);virtual;
    procedure visit(_unit_or_namespace: unit_or_namespace);virtual;
    procedure visit(_uses_list: uses_list);virtual;
    procedure visit(_uses_unit_in: uses_unit_in);virtual;
    procedure visit(_using_list: using_list);virtual;
    procedure visit(_var_def_list: var_def_list);virtual;
    procedure visit(_var_def_statement: var_def_statement);virtual;
    procedure visit(_var_statement: var_statement);virtual;
    procedure visit(_variable_definitions: variable_definitions);virtual;
    procedure visit(_variant: variant);virtual;
    procedure visit(_variant_list: variant_list);virtual;
    procedure visit(_variant_record_type: variant_record_type);virtual;
    procedure visit(_variant_type: variant_type);virtual;
    procedure visit(_variant_types: variant_types);virtual;
    procedure visit(_where_definition: where_definition);virtual;
    procedure visit(_where_definition_list: where_definition_list);virtual;
    procedure visit(_while_node: while_node);virtual;
    procedure visit(_with_statement: with_statement);virtual;
    procedure visit(_write_accessor_name: write_accessor_name);virtual;

end;
  
  
  
  OperatorServices = class
    // Methods
    public constructor Create; 
    public function IsAssigmentOperator(&Operator: Operators): boolean; static; 
    public function ToString(&Operator: Operators; Language: LanguageId): string; static; 

  end;
  
  Utils = class
    // Methods
    public constructor Create; 
    public function IdentListToString(list: List<ident>; separator: string): string; static; 

  end;

  access_modifer_node = class(syntax_tree_node)
    private _access_level: access_modifer;
    // Methods
    public constructor Create; 
    public constructor Create(_access_level: access_modifer); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property access_level: access_modifer read _access_level write _access_level;

    // Fields


  end;
  
  
  addressed_value_funcname = class(addressed_value)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

  end;
  
  array_const = class(expression)
    private _elements: expression_list;
    // Methods
    public constructor Create; 
    public constructor Create(_elements: expression_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property elements: expression_list read _elements write _elements;

    // Fields
  end;
  
  array_of_const_type_definition = class(type_definition)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

  end;
  
  array_of_named_type_definition = class(type_definition)
    private _type_name: named_type_reference;
    // Methods
    public constructor Create; 
    public constructor Create(_type_name: named_type_reference); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property type_name: named_type_reference read _type_name write _type_name;

    // Fields


  end;
  
  array_size = class(type_definition)
    private _max_value: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_max_value: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property max_value: expression read _max_value write _max_value;

    // Fields


  end;
  
  array_type = class(type_definition)
    private _elemets_types: type_definition;
    private _indexers: indexers_types;
    // Methods
    public constructor Create; 
    public constructor Create(_indexers: indexers_types; _elemets_types: type_definition); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property elemets_types: type_definition read _elemets_types write _elemets_types;
    public property indexers: indexers_types read _indexers write _indexers;

    // Fields


  end;
  
  assign = class(expression)
     private _from: expression;
     private _operator_type: Operators;
     private _to: addressed_value;
    // Methods
    public constructor Create; 
    public constructor Create(_to: addressed_value; _from: expression; _operator_type: Operators); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property from: expression read _from write _from;
    public property operator_type: Operators read _operator_type write _operator_type;
    public property &to: addressed_value read _to write _to;

    // Fields


end;

  bin_expr = class(addressed_value)
     private _left: expression;
     private _operation_type: Operators;
     private _right: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_left: expression; _right: expression; _operation_type: Operators); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property left: expression read _left write _left;
    public property operation_type: Operators read _operation_type write _operation_type;
    public property right: expression read _right write _right;

    // Fields


end;

   block = class(proc_block)
    // Fields
    private _defs: declarations;
    private _program_code: statement_list;
    
    // Methods
    public constructor Create; 
    public constructor Create(_defs: declarations; _program_code: statement_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property defs: declarations read _defs write _defs;
    public property program_code: statement_list read _program_code write _program_code;

end;

   bool_const = class(const_node)
    // Fields
    private _val: boolean;
    // Methods
    public constructor Create; 
    public constructor Create(_val: boolean); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property val: boolean read _val write _val;

end;

   c_for_cycle = class(statement)
     private _expr1: statement;
     private _expr2: expression;
     private _expr3: expression;
     private _stmt: statement;
    // Methods
    public constructor Create; 
    public constructor Create(_expr1: statement; _expr2: expression; _expr3: expression; _stmt: statement); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property expr1: statement read _expr1 write _expr1;
    public property expr2: expression read _expr2 write _expr2;
    public property expr3: expression read _expr3 write _expr3;
    public property stmt: statement read _stmt write _stmt;
     

end;

   c_module = class(compilation_unit)
    // Fields
     private _defs: declarations;
     private _used_units: uses_list;

    // Methods
    public constructor Create; 
    public constructor Create(_defs: declarations; _used_units: uses_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property defs: declarations read _defs write _defs;
    public property used_units: uses_list read _used_units write _used_units;

end;

c_scalar_type = class(type_definition)
    // Fields
     private _scalar_name: c_scalar_type_name;
     private _sign: c_scalar_sign;

    // Methods
    public constructor Create; 
    public constructor Create(_scalar_name: c_scalar_type_name; _sign: c_scalar_sign); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property scalar_name: c_scalar_type_name read _scalar_name write _scalar_name;
    public property sign: c_scalar_sign read _sign write _sign;

    
end;

case_node = class(statement)
        // Fields
     private _conditions: case_variants;
     private _else_statement: statement;
     private _param: expression;
     
    // Methods
    public constructor Create; 
    public constructor Create(_param: expression; _conditions: case_variants; _else_statement: statement); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property conditions: case_variants read _conditions write _conditions;
    public property else_statement: statement read _else_statement write _else_statement;
    public property param: expression read _param write _param;

end;

case_variant = class(statement)
       // Fields
     private _conditions: expression_list;
     private _exec_if_true: statement;
     
    // Methods
    public constructor Create; 
    public constructor Create(_conditions: expression_list; _exec_if_true: statement); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property conditions: expression_list read _conditions write _conditions;
    public property exec_if_true: statement read _exec_if_true write _exec_if_true;

 

end;

case_variants = class(syntax_tree_node)
     // Fields
     private _variants: List<case_variant>;
    // Methods
    public constructor Create; 
    public constructor Create(_variants: List<case_variant>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property variants: List<case_variant> read _variants write _variants;

end;

char_const = class(literal)
       // Fields
     private _cconst: Char;
    // Methods
    public constructor Create; 
    public constructor Create(_cconst: Char); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property cconst: Char read _cconst write _cconst;


end;

class_body = class(syntax_tree_node)
    private _class_def_blocks: List<class_members>;
    // Methods
    public constructor Create; 
    public constructor Create(_class_def_blocks: List<class_members>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property class_def_blocks: List<class_members> read _class_def_blocks write _class_def_blocks;

    // Fields
     

end;

class_definition = class(type_definition)
     private _attribute: class_attribute;
     private _body: class_body;
     private _class_parents: named_type_reference_list;
     private _keyword: class_keyword;
     private _template_args: ident_list;
     private _where_section: where_definition_list;
    // Methods
    public constructor Create; 
    public constructor Create(_class_parents: named_type_reference_list; _body: class_body; _keyword: class_keyword; _template_args: ident_list; _where_section: where_definition_list; _attribute: class_attribute); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property attribute: class_attribute read _attribute write _attribute;
    public property body: class_body read _body write _body;
    public property class_parents: named_type_reference_list read _class_parents write _class_parents;
    public property keyword: class_keyword read _keyword write _keyword;
    public property template_args: ident_list read _template_args write _template_args;
    public property where_section: where_definition_list read _where_section write _where_section;

    // Fields
end;

class_members = class(syntax_tree_node)
    private _access_mod: access_modifer_node;
    private _members: List<declaration>;
    // Methods
    public constructor Create; 
    public constructor Create(_members: List<declaration>; _access_mod: access_modifer_node); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property access_mod: access_modifer_node read _access_mod write _access_mod;
    public property members: List<declaration> read _members write _members;

end;

class_predefinition = class(type_declaration)
   private _class_name: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_class_name: ident); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property class_name: ident read _class_name write _class_name;

    // Fields
     

end;

 

 compiler_directive = class(syntax_tree_node)
    private _Directive: token_info;
     private _Name: token_info;
    // Methods
    public constructor Create; 
    public constructor Create(_Name: token_info; _Directive: token_info); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property Directive: token_info read _Directive write _Directive;
    public property Name: token_info read _Name write _Name;

    // Fields

end;

compiler_directive_if = class(compiler_directive)
   private _elseif_part: compiler_directive;
     private _if_part: compiler_directive;
    // Methods
    public constructor Create; 
    public constructor Create(_if_part: compiler_directive; _elseif_part: compiler_directive); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property elseif_part: compiler_directive read _elseif_part write _elseif_part;
    public property if_part: compiler_directive read _if_part write _if_part;

    // Fields
    

end;

 compiler_directive_list = class(compiler_directive)
    private _directives: List<compiler_directive>;
    // Methods
    public constructor Create; 
    public constructor Create(_directives: List<compiler_directive>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property directives: List<compiler_directive> read _directives write _directives;

    // Fields
     

end;

const_definition = class(declaration)
    private _const_name: ident;
     private _const_value: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_const_name: ident; _const_value: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property const_name: ident read _const_name write _const_name;
    public property const_value: expression read _const_value write _const_value;

    // Fields
     

end;


&constructor = class(procedure_header)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

end;

consts_definitions_list = class(declaration)
    private _const_defs: List<const_definition>;
    // Methods
    public constructor Create; 
    public constructor Create(_const_defs: List<const_definition>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property const_defs: List<const_definition> read _const_defs write _const_defs;

    // Fields
    

end;



 declarations = class(syntax_tree_node)
    private _defs: List<declaration>;
    // Methods
    public constructor Create; 
    public constructor Create(_defs: List<declaration>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property defs: List<declaration> read _defs write _defs;

    // Fields
     

end;

declarations_as_statement = class(statement)
    private _defs: declarations;
    // Methods
    public constructor Create; 
    public constructor Create(_defs: declarations); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property defs: declarations read _defs write _defs;

    // Fields
     

end;

default_indexer_property_node = class(syntax_tree_node)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

end;

dereference = class(addressed_value_funcname)
    private _dereferencing_value: addressed_value;
    // Methods
    public constructor Create; 
    public constructor Create(_dereferencing_value: addressed_value); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property dereferencing_value: addressed_value read _dereferencing_value write _dereferencing_value;

    // Fields
     

end;

&destructor = class(procedure_header)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

end;

diap_expr = class(expression)
    private _left: expression;
     private _right: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_left: expression; _right: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property left: expression read _left write _left;
    public property right: expression read _right write _right;

    // Fields
     

end;

 diapason = class(type_definition)
    private _left: expression;
     private _right: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_left: expression; _right: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property left: expression read _left write _left;
    public property right: expression read _right write _right;

    // Fields


end;

diapason_expr = class(expression)
    private _left: expression;
     private _right: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_left: expression; _right: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property left: expression read _left write _left;
    public property right: expression read _right write _right;

    // Fields
     

end;

documentation_comment_list = class(syntax_tree_node)
    private _sections: List<documentation_comment_section>;
    // Methods
    public constructor Create; 
    public constructor Create(_sections: List<documentation_comment_section>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property sections: List<documentation_comment_section> read _sections write _sections;

    // Fields
     

end;

 documentation_comment_section = class(syntax_tree_node)
    private _tags: List<documentation_comment_tag>;
     private _text: string;
    // Methods
    public constructor Create; 
    public constructor Create(_tags: List<documentation_comment_tag>; _text: string); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property tags: List<documentation_comment_tag> read _tags write _tags;
    public property text: string read _text write _text;

    // Fields
     

end;

documentation_comment_tag = class(syntax_tree_node)
    private _name: string;
     private _parameters: List<documentation_comment_tag_param>;
     private _text: string;
    // Methods
    public constructor Create; 
    public constructor Create(_name: string; _parameters: List<documentation_comment_tag_param>; _text: string); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property name: string read _name write _name;
    public property parameters: List<documentation_comment_tag_param> read _parameters write _parameters;
    public property text: string read _text write _text;

    // Fields
     

end;

documentation_comment_tag_param = class(syntax_tree_node)
    private _name: string;
     private _value: string;
    // Methods
    public constructor Create; 
    public constructor Create(_name: string; _value: string); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property name: string read _name write _name;
    public property value: string read _value write _value;

    // Fields
     

end;

dot_node = class(addressed_value_funcname)
    private _left: addressed_value;
     private _right: addressed_value;
    // Methods
    public constructor Create; 
    public constructor Create(_left: addressed_value; _right: addressed_value); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property left: addressed_value read _left write _left;
    public property right: addressed_value read _right write _right;

    // Fields
     

end;

double_const = class(const_node)
    // Fields
     private _val: Double;
    // Methods
    public constructor Create; 
    public constructor Create(_val: Double); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property val: Double read _val write _val;

    

end;

 empty_statement = class(statement)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

end;

enum_type_definition = class(type_definition)
    private _enumerators: enumerator_list;
    // Methods
    public constructor Create; 
    public constructor Create(_enumerators: enumerator_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property enumerators: enumerator_list read _enumerators write _enumerators;

    // Fields
     

end;

enumerator = class(syntax_tree_node)
    private _name: ident;
     private _value: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_name: ident; _value: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property name: ident read _name write _name;
    public property value: expression read _value write _value;

    // Fields
     

end;

enumerator_list = class(syntax_tree_node)
    private _enumerators: List<enumerator>;
    // Methods
    public constructor Create; 
    public constructor Create(_enumerators: List<enumerator>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property enumerators: List<enumerator> read _enumerators write _enumerators;

    // Fields
     

end;

exception_block = class(syntax_tree_node)
    private _else_stmt_list: statement_list;
     private _handlers: exception_handler_list;
     private _stmt_list: statement_list;
    // Methods
    public constructor Create; 
    public constructor Create(_stmt_list: statement_list; _handlers: exception_handler_list; _else_stmt_list: statement_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property else_stmt_list: statement_list read _else_stmt_list write _else_stmt_list;
    public property handlers: exception_handler_list read _handlers write _handlers;
    public property stmt_list: statement_list read _stmt_list write _stmt_list;

    // Fields
     

end;

exception_handler = class(syntax_tree_node)
    private _statements: statement;
     private _type_name: named_type_reference;
     private _variable: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_variable: ident; _type_name: named_type_reference; _statements: statement); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property statements: statement read _statements write _statements;
    public property type_name: named_type_reference read _type_name write _type_name;
    public property variable: ident read _variable write _variable;

    // Fields
     

end;

exception_handler_list = class(syntax_tree_node)
    private _handlers: List<exception_handler>;
    // Methods
    public constructor Create; 
    public constructor Create(_handlers: List<exception_handler>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property handlers: List<exception_handler> read _handlers write _handlers;

    // Fields
     

end;

exception_ident = class(syntax_tree_node)
    private _type_name: named_type_reference;
     private _variable: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_variable: ident; _type_name: named_type_reference); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property type_name: named_type_reference read _type_name write _type_name;
    public property variable: ident read _variable write _variable;

    // Fields
     

end;


expression_as_statement = class(statement)
    private _expr: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_expr: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property expr: expression read _expr write _expr;

    // Fields
     

end;

expression_list = class(expression)
    private _expressions: List<expression>;
    // Methods
    public constructor Create; 
    public constructor Create(_expressions: List<expression>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property expressions: List<expression> read _expressions write _expressions;

    // Fields
     

end;

external_directive = class(proc_block)
    private _modulename: expression;
     private _name: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_modulename: expression; _name: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property modulename: expression read _modulename write _modulename;
    public property name: expression read _name write _name;

    // Fields
     

end;

 file_type = class(type_definition)
    private _file_of_type: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_file_of_type: type_definition); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property file_of_type: type_definition read _file_of_type write _file_of_type;

    // Fields
     

end;

file_type_definition = class(type_definition)
    private _elem_type: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_elem_type: type_definition); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property elem_type: type_definition read _elem_type write _elem_type;

    // Fields
     

end;

for_node = class(statement)
    private _create_loop_variable: boolean;
     private _cycle_type: for_cycle_type;
     private _finish_value: expression;
     private _increment_value: expression;
     private _initial_value: expression;
     private _loop_variable: ident;
     private _statements: statement;
     private _type_name: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_loop_variable: ident; _initial_value: expression; _finish_value: expression; _statements: statement; _cycle_type: for_cycle_type; _increment_value: expression; _type_name: type_definition; _create_loop_variable: boolean); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property create_loop_variable: boolean read _create_loop_variable write _create_loop_variable;
    public property cycle_type: for_cycle_type read _cycle_type write _cycle_type;
    public property finish_value: expression read _finish_value write _finish_value;
    public property increment_value: expression read _increment_value write _increment_value;
    public property initial_value: expression read _initial_value write _initial_value;
    public property loop_variable: ident read _loop_variable write _loop_variable;
    public property statements: statement read _statements write _statements;
    public property type_name: type_definition read _type_name write _type_name;

    // Fields
     

end;

foreach_stmt = class(statement)
    private _identifier: ident;
     private _in_what: expression;
     private _stmt: statement;
     private _type_name: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_identifier: ident; _type_name: type_definition; _in_what: expression; _stmt: statement); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property identifier: ident read _identifier write _identifier;
    public property in_what: expression read _in_what write _in_what;
    public property stmt: statement read _stmt write _stmt;
    public property type_name: type_definition read _type_name write _type_name;

    // Fields
     

end;

 formal_parametres = class(syntax_tree_node)
    private _params_list: List<typed_parametres>;
    // Methods
    public constructor Create; 
    public constructor Create(_params_list: List<typed_parametres>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property params_list: List<typed_parametres> read _params_list write _params_list;

    // Fields
     

end;

format_expr = class(expression)
    private _expr: expression;
     private _format1: expression;
     private _format2: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_expr: expression; _format1: expression; _format2: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property expr: expression read _expr write _expr;
    public property format1: expression read _format1 write _format1;
    public property format2: expression read _format2 write _format2;

    // Fields
     

end;

 function_header = class(procedure_header)
    private _return_type: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_return_type: type_definition); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property return_type: type_definition read _return_type write _return_type;

    // Fields
     

end;

get_address = class(addressed_value_funcname)
    private _address_of: addressed_value;
    // Methods
    public constructor Create; 
    public constructor Create(_address_of: addressed_value); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property address_of: addressed_value read _address_of write _address_of;

    // Fields
     

end;

goto_statement = class(statement)
    private _label: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_label: ident); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property &label: ident read _label write _label;

    // Fields
     

end;

hex_constant = class(int64_const)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

end;

ident = class(addressed_value_funcname)
     private _name: string;
    // Methods
    public constructor Create; 
    public constructor Create(_name: string); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property name: string read _name write _name;

    // Fields
    

end;

ident_list = class(syntax_tree_node)
    private _idents: List<ident>;
    // Methods
    public constructor Create; 
    public constructor Create(_idents: List<ident>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property idents: List<ident> read _idents write _idents;

    // Fields
     

end;

if_node = class(statement)
    private _condition: expression;
    private _else_body: statement;
    private _then_body: statement;

    // Methods
    public constructor Create; 
    public constructor Create(_condition: expression; _then_body: statement; _else_body: statement); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property condition: expression read _condition write _condition;
    public property else_body: statement read _else_body write _else_body;
    public property then_body: statement read _then_body write _then_body;

    // Fields
     

end;

implementation_node = class(syntax_tree_node)
     private _implementation_definitions: declarations;
     private _uses_modules: uses_list;
     private _using_namespaces: using_list;
    // Methods
    public constructor Create; 
    public constructor Create(_uses_modules: uses_list; _implementation_definitions: declarations; _using_namespaces: using_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property implementation_definitions: declarations read _implementation_definitions write _implementation_definitions;
    public property uses_modules: uses_list read _uses_modules write _uses_modules;
    public property using_namespaces: using_list read _using_namespaces write _using_namespaces;

    // Fields


end;

index_property = class(simple_property)
    private _is_default: default_indexer_property_node;
     private _property_parametres: formal_parametres;
    // Methods
    public constructor Create; 
    public constructor Create(_property_parametres: formal_parametres; _is_default: default_indexer_property_node); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property is_default: default_indexer_property_node read _is_default write _is_default;
    public property property_parametres: formal_parametres read _property_parametres write _property_parametres;

    // Fields
     

end;

indexer = class(dereference)
    private _indexes: expression_list;
    // Methods
    public constructor Create; 
    public constructor Create(_indexes: expression_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property indexes: expression_list read _indexes write _indexes;

    // Fields
     

end;

 indexers_types = class(type_definition)
    private _indexers: List<type_definition>;
    // Methods
    public constructor Create; 
    public constructor Create(_indexers: List<type_definition>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property indexers: List<type_definition> read _indexers write _indexers;

    // Fields
     

end;

inherited_ident = class(ident)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

end;

inherited_message = class(statement)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

end;

inherited_method_call = class(statement)
    private _exprs: expression_list;
     private _method_name: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_method_name: ident; _exprs: expression_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property exprs: expression_list read _exprs write _exprs;
    public property method_name: ident read _method_name write _method_name;

    // Fields
     

end;

initfinal_part = class(syntax_tree_node)
    private _finalization_sect: statement_list;
     private _initialization_sect: statement_list;
    // Methods
    public constructor Create; 
    public constructor Create(_initialization_sect: statement_list; _finalization_sect: statement_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property finalization_sect: statement_list read _finalization_sect write _finalization_sect;
    public property initialization_sect: statement_list read _initialization_sect write _initialization_sect;

    // Fields
     

end;

int32_const = class(const_node)
    private _val: Integer;
    // Methods
    public constructor Create; 
    public constructor Create(_val: Integer); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property val: Integer read _val write _val;

    // Fields
     
end;



interface_node = class(syntax_tree_node)
    private _interface_definitions: declarations;
     private _uses_modules: uses_list;
     private _using_namespaces: using_list;
    // Methods
    public constructor Create; 
    public constructor Create(_interface_definitions: declarations; _uses_modules: uses_list; _using_namespaces: using_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property interface_definitions: declarations read _interface_definitions write _interface_definitions;
    public property uses_modules: uses_list read _uses_modules write _uses_modules;
    public property using_namespaces: using_list read _using_namespaces write _using_namespaces;

    // Fields
     

end;

 jump_stmt = class(statement)
    private _expr: expression;
     private _JumpType: JumpStmtType;
    // Methods
    public constructor Create; 
    public constructor Create(_expr: expression; _JumpType: JumpStmtType); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property expr: expression read _expr write _expr;
    public property JumpType: JumpStmtType read _JumpType write _JumpType;

    // Fields
     

end;

known_type_definition = class(type_definition)
    private _tp: known_type;
     private _unit_name: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_tp: known_type; _unit_name: ident); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property tp: known_type read _tp write _tp;
    public property unit_name: ident read _unit_name write _unit_name;

    // Fields
     

end;

known_type_ident = class(ident)
    private _type: known_type;
    // Methods
    public constructor Create; 
    public constructor Create(_type: known_type); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property &type: known_type read _type write _type;

    // Fields
     

end;

 label_definitions = class(declaration)
    private _labels: ident_list;
    // Methods
    public constructor Create; 
    public constructor Create(_labels: ident_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property labels: ident_list read _labels write _labels;

    // Fields
     

end;

 labeled_statement = class(statement)
    private _label_name: ident;
     private _to_statement: statement;
    // Methods
    public constructor Create; 
    public constructor Create(_label_name: ident; _to_statement: statement); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property label_name: ident read _label_name write _label_name;
    public property to_statement: statement read _to_statement write _to_statement;

    // Fields
     

end;

literal_const_line = class(literal)
    private _literals: List<literal>;
    // Methods
    public constructor Create; 
    public constructor Create(_literals: List<literal>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property literals: List<literal> read _literals write _literals;

    // Fields
     

end;

 lock_stmt = class(statement)
    private _lock_object: expression;
     private _stmt: statement;
    // Methods
    public constructor Create; 
    public constructor Create(_lock_object: expression; _stmt: statement); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property lock_object: expression read _lock_object write _lock_object;
    public property stmt: statement read _stmt write _stmt;

    // Fields
     

end;

loop_stmt = class(statement)
    private _stmt: statement;
    // Methods
    public constructor Create; 
    public constructor Create(_stmt: statement); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property stmt: statement read _stmt write _stmt;

    // Fields
     

end;

method_call = class(dereference)
    private _parametres: expression_list;
    // Methods
    public constructor Create; 
    public constructor Create(_parametres: expression_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property parametres: expression_list read _parametres write _parametres;

    // Fields
     

end;

method_name = class(syntax_tree_node)
    private _class_name: ident;
     private _meth_name: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_class_name: ident; _meth_name: ident); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property class_name: ident read _class_name write _class_name;
    public property meth_name: ident read _meth_name write _meth_name;

    // Fields
     

end;

named_type_reference = class(type_definition)
    private _names: List<ident>;
    // Methods
    public constructor Create; 
    public constructor Create(_names: List<ident>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property names: List<ident> read _names write _names;

    // Fields
     

end;

named_type_reference_list = class(syntax_tree_node)
    private _types: List<named_type_reference>;
    // Methods
    public constructor Create; 
    public constructor Create(_types: List<named_type_reference>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property types: List<named_type_reference> read _types write _types;

    // Fields
     

end;

new_expr = class(addressed_value)
    private _new_array: boolean;
     private _params_list: expression_list;
     private _type: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_type: type_definition; _params_list: expression_list; _new_array: boolean); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property new_array: boolean read _new_array write _new_array;
    public property params_list: expression_list read _params_list write _params_list;
    public property &type: type_definition read _type write _type;

    // Fields
     

end;

nil_const = class(const_node)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

end;

oberon_exit_stmt = class(statement)
    private _text: string;
    // Methods
    public constructor Create; 
    public constructor Create(_text: string); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property text: string read _text write _text;

    // Fields
     

end;

oberon_ident_with_export_marker = class(ident)
    private _marker: oberon_export_marker;
    // Methods
    public constructor Create; 
    public constructor Create(_marker: oberon_export_marker); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property marker: oberon_export_marker read _marker write _marker;

    // Fields
     

end;

oberon_import_module = class(unit_or_namespace)
    private _new_name: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_new_name: ident); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property new_name: ident read _new_name write _new_name;

    // Fields
     

end;

oberon_module = class(compilation_unit)
    private _definitions: declarations;
     private _first_name: ident;
     private _import_list: uses_list;
     private _module_code: statement_list;
     private _second_name: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_first_name: ident; _second_name: ident; _import_list: uses_list; _definitions: declarations; _module_code: statement_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property definitions: declarations read _definitions write _definitions;
    public property first_name: ident read _first_name write _first_name;
    public property import_list: uses_list read _import_list write _import_list;
    public property module_code: statement_list read _module_code write _module_code;
    public property second_name: ident read _second_name write _second_name;

    // Fields
     

end;

oberon_procedure_header = class(function_header)
    private _first_name: ident;
     private _receiver: oberon_procedure_receiver;
     private _second_name: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_receiver: oberon_procedure_receiver; _first_name: ident; _second_name: ident); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property first_name: ident read _first_name write _first_name;
    public property receiver: oberon_procedure_receiver read _receiver write _receiver;
    public property second_name: ident read _second_name write _second_name;

    // Fields
     

end;

oberon_procedure_receiver = class(syntax_tree_node)
    private _param_kind: parametr_kind;
     private _receiver_name: ident;
     private _receiver_typename: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_param_kind: parametr_kind; _receiver_name: ident; _receiver_typename: ident); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property param_kind: parametr_kind read _param_kind write _param_kind;
    public property receiver_name: ident read _receiver_name write _receiver_name;
    public property receiver_typename: ident read _receiver_typename write _receiver_typename;

    // Fields
     

end;

oberon_withstmt = class(statement)
    private _else_stmt: statement;
     private _quardstat_list: oberon_withstmt_guardstat_list;
    // Methods
    public constructor Create; 
    public constructor Create(_quardstat_list: oberon_withstmt_guardstat_list; _else_stmt: statement); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property else_stmt: statement read _else_stmt write _else_stmt;
    public property quardstat_list: oberon_withstmt_guardstat_list read _quardstat_list write _quardstat_list;

    // Fields
     

end;

oberon_withstmt_guardstat = class(syntax_tree_node)
    private _name: addressed_value;
     private _stmt: statement;
     private _type_name: type_definition;

    // Methods
    public constructor Create; 
    public constructor Create(_name: addressed_value; _type_name: type_definition; _stmt: statement); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property name: addressed_value read _name write _name;
    public property stmt: statement read _stmt write _stmt;
    public property type_name: type_definition read _type_name write _type_name;

    // Fields
     
end;

oberon_withstmt_guardstat_list = class(syntax_tree_node)
    private _guardstats: List<oberon_withstmt_guardstat>;
    // Methods
    public constructor Create; 
    public constructor Create(_guardstats: List<oberon_withstmt_guardstat>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property guardstats: List<oberon_withstmt_guardstat> read _guardstats write _guardstats;

    // Fields
     

end;

on_exception = class(syntax_tree_node)
    private _exception_type_name: ident;
     private _exception_var_name: ident;
     private _stat: statement;
    // Methods
    public constructor Create; 
    public constructor Create(_exception_var_name: ident; _exception_type_name: ident; _stat: statement); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property exception_type_name: ident read _exception_type_name write _exception_type_name;
    public property exception_var_name: ident read _exception_var_name write _exception_var_name;
    public property stat: statement read _stat write _stat;

    // Fields
     

end;

on_exception_list = class(syntax_tree_node)
    private _on_exceptions: List<on_exception>;
    // Methods
    public constructor Create; 
    public constructor Create(_on_exceptions: List<on_exception>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property on_exceptions: List<on_exception> read _on_exceptions write _on_exceptions;

    // Fields
     

end;

op_type_node = class(token_info)
    private _type: Operators;
    // Methods
    public constructor Create; 
    public constructor Create(_type: Operators); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property &type: Operators read _type write _type;

    // Fields
     

end;

operator_name_ident = class(ident)
    private _operator_type: Operators;
    // Methods
    public constructor Create; 
    public constructor Create(_operator_type: Operators); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property operator_type: Operators read _operator_type write _operator_type;

    // Fields
     

end;

pascal_set_constant = class(expression)
    private _values: expression_list;
    // Methods
    public constructor Create; 
    public constructor Create(_values: expression_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property values: expression_list read _values write _values;

    // Fields
     

end;



procedure_attribute = class(ident)
    private _attribute_type: proc_attribute;
    // Methods
    public constructor Create; 
    public constructor Create(_attribute_type: proc_attribute); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property attribute_type: proc_attribute read _attribute_type write _attribute_type;

    // Fields
     

end;

procedure_attributes_list = class(syntax_tree_node)
    private _proc_attributes: List<procedure_attribute>;
    // Methods
    public constructor Create; 
    public constructor Create(_proc_attributes: List<procedure_attribute>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property proc_attributes: List<procedure_attribute> read _proc_attributes write _proc_attributes;

    // Fields
     

end;

procedure_call = class(statement)
    private _func_name: addressed_value;
    // Methods
    public constructor Create; 
    public constructor Create(_func_name: addressed_value); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property func_name: addressed_value read _func_name write _func_name;

    // Fields
     

end;

procedure_definition = class(declaration)
    private _proc_body: proc_block;
     private _proc_header: procedure_header;
    // Methods
    public constructor Create; 
    public constructor Create(_proc_header: procedure_header; _proc_body: proc_block); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property proc_body: proc_block read _proc_body write _proc_body;
    public property proc_header: procedure_header read _proc_header write _proc_header;

    // Fields
     

end;



program_body = class(syntax_tree_node)
    private _program_code: statement_list;
     private _program_definitions: declarations;
     private _used_units: uses_list;
     private _using_list: using_list;
    // Methods
    public constructor Create; 
    public constructor Create(_used_units: uses_list; _program_definitions: declarations; _program_code: statement_list; _using_list: using_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property program_code: statement_list read _program_code write _program_code;
    public property program_definitions: declarations read _program_definitions write _program_definitions;
    public property used_units: uses_list read _used_units write _used_units;
    public property using_list: SyntaxTree.using_list read _using_list write _using_list;

    // Fields
     

end;

program_module = class(compilation_unit)
    private _program_block: block;
     private _program_name: program_name;
     private _used_units: uses_list;
     private _using_namespaces: using_list;
    // Methods
    public constructor Create; 
    public constructor Create(_program_name: program_name; _used_units: uses_list; _program_block: block; _using_namespaces: using_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property program_block: block read _program_block write _program_block;
    public property program_name: SyntaxTree.program_name read _program_name write _program_name;
    public property used_units: uses_list read _used_units write _used_units;
    public property using_namespaces: using_list read _using_namespaces write _using_namespaces;

    // Fields
     

end;

program_name = class(syntax_tree_node)
     private _prog_name: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_prog_name: ident); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property prog_name: ident read _prog_name write _prog_name;

    // Fields
    

end;

program_tree = class(syntax_tree_node)
    private _compilation_units: List<compilation_unit>;
    // Methods
    public constructor Create; 
    public constructor Create(_compilation_units: List<compilation_unit>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property compilation_units: List<compilation_unit> read _compilation_units write _compilation_units;

    // Fields
     

end;

property_accessors = class(syntax_tree_node)
    private _read_accessor: read_accessor_name;
    private _write_accessor: write_accessor_name;
    // Methods
    public constructor Create; 
    public constructor Create(_read_accessor: read_accessor_name; _write_accessor: write_accessor_name); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property read_accessor: read_accessor_name read _read_accessor write _read_accessor;
    public property write_accessor: write_accessor_name read _write_accessor write _write_accessor;

    // Fields
     

end;

property_array_default = class(syntax_tree_node)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

end;

 property_interface = class(syntax_tree_node)
    private _index_expression: expression;
     private _parameter_list: property_parameter_list;
     private _property_type: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_parameter_list: property_parameter_list; _property_type: type_definition; _index_expression: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property index_expression: expression read _index_expression write _index_expression;
    public property parameter_list: property_parameter_list read _parameter_list write _parameter_list;
    public property property_type: type_definition read _property_type write _property_type;

    // Fields
     

end;

property_parameter = class(syntax_tree_node)
    private _names: ident_list;
     private _type: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_names: ident_list; _type: type_definition); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property names: ident_list read _names write _names;
    public property &type: type_definition read _type write _type;

    // Fields
     

end;

property_parameter_list = class(syntax_tree_node)
    private _parameters: List<property_parameter>;
    // Methods
    public constructor Create; 
    public constructor Create(_parameters: List<property_parameter>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property parameters: List<property_parameter> read _parameters write _parameters;

    // Fields
     

end;

question_colon_expression = class(expression)
    private _condition: expression;
     private _ret_if_false: expression;
     private _ret_if_true: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_condition: expression; _ret_if_true: expression; _ret_if_false: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property condition: expression read _condition write _condition;
    public property ret_if_false: expression read _ret_if_false write _ret_if_false;
    public property ret_if_true: expression read _ret_if_true write _ret_if_true;

    // Fields
     

end;

 raise_statement = class(statement)
    private _excep: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_excep: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property excep: expression read _excep write _excep;

    // Fields
     

end;

raise_stmt = class(statement)
    private _address: expression;
     private _expr: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_expr: expression; _address: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property address: expression read _address write _address;
    public property expr: expression read _expr write _expr;

    // Fields
     

end;

read_accessor_name = class(syntax_tree_node)
    private _accessor_name: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_accessor_name: ident); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property accessor_name: ident read _accessor_name write _accessor_name;

    // Fields
     

end;

record_const = class(expression)
    private _rec_consts: List<record_const_definition>;
    // Methods
    public constructor Create; 
    public constructor Create(_rec_consts: List<record_const_definition>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property rec_consts: List<record_const_definition> read _rec_consts write _rec_consts;

    // Fields
     

end;

record_const_definition = class(statement)
    private _name: ident;
     private _val: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_name: ident; _val: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property name: ident read _name write _name;
    public property val: expression read _val write _val;

    // Fields
     

end;

record_type = class(type_definition)
    private _base_type: type_definition;
     private _parts: record_type_parts;
    // Methods
    public constructor Create; 
    public constructor Create(_parts: record_type_parts; _base_type: type_definition); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property base_type: type_definition read _base_type write _base_type;
    public property parts: record_type_parts read _parts write _parts;

    // Fields
     

end;

record_type_parts = class(syntax_tree_node)
    private _fixed_part: var_def_list;
     private _variant_part: variant_record_type;
    // Methods
    public constructor Create; 
    public constructor Create(_fixed_part: var_def_list; _variant_part: variant_record_type); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property fixed_part: var_def_list read _fixed_part write _fixed_part;
    public property variant_part: variant_record_type read _variant_part write _variant_part;

    // Fields
     

end;

ref_type = class(type_definition)
    private _pointed_to: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_pointed_to: type_definition); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property pointed_to: type_definition read _pointed_to write _pointed_to;

    // Fields
     

end;

repeat_node = class(statement)
    private _expr: expression;
     private _statements: statement;
    // Methods
    public constructor Create; 
    public constructor Create(_statements: statement; _expr: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property expr: expression read _expr write _expr;
    public property statements: statement read _statements write _statements;

    // Fields
     

end;

roof_dereference = class(dereference)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

end;

set_type_definition = class(type_definition)
    private _of_type: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_of_type: type_definition); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property of_type: type_definition read _of_type write _of_type;

    // Fields
     

end;

sharp_char_const = class(literal)
     private _char_num: Integer;
    // Methods
    public constructor Create; 
    public constructor Create(_char_num: Integer); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property char_num: Integer read _char_num write _char_num;

    // Fields
    

end;

simple_const_definition = class(const_definition)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

end;



sizeof_operator = class(addressed_value)
    private _expr: expression;
     private _type_def: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_type_def: type_definition; _expr: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property expr: expression read _expr write _expr;
    public property type_def: type_definition read _type_def write _type_def;

    // Fields
     

end;

 statement_list = class(statement)
    private _left_logical_bracket: syntax_tree_node;
     private _right_logical_bracket: syntax_tree_node;
     private _subnodes: List<statement>;
    // Methods
    public constructor Create; 
    public constructor Create(_subnodes: List<statement>; _left_logical_bracket: syntax_tree_node; _right_logical_bracket: syntax_tree_node); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property left_logical_bracket: syntax_tree_node read _left_logical_bracket write _left_logical_bracket;
    public property right_logical_bracket: syntax_tree_node read _right_logical_bracket write _right_logical_bracket;
    public property subnodes: List<statement> read _subnodes write _subnodes;

    // Fields
     

end;

string_const = class(literal)
    private _Value: string;
    // Methods
    public constructor Create; 
    public constructor Create(_Value: string); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property Value: string read _Value write _Value;

    // Fields
     

end;

string_num_definition = class(type_definition)
    private _name: ident;
     private _num_of_symbols: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_num_of_symbols: expression; _name: ident); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property name: ident read _name write _name;
    public property num_of_symbols: expression read _num_of_symbols write _num_of_symbols;

    // Fields
     

end;

subprogram_body = class(syntax_tree_node)
    private _subprogram_code: statement_list;
     private _subprogram_defs: declarations;
    // Methods
    public constructor Create; 
    public constructor Create(_subprogram_code: statement_list; _subprogram_defs: declarations); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property subprogram_code: statement_list read _subprogram_code write _subprogram_code;
    public property subprogram_defs: declarations read _subprogram_defs write _subprogram_defs;

    // Fields
     

end;

switch_stmt = class(statement)
    private _condition: expression;
     private _Part: SwitchPartType;
     private _stmt: statement;
    // Methods
    public constructor Create; 
    public constructor Create(_condition: expression; _stmt: statement; _Part: SwitchPartType); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property condition: expression read _condition write _condition;
    public property Part: SwitchPartType read _Part write _Part;
    public property stmt: statement read _stmt write _stmt;

    // Fields
     

end;

  
 
template_param_list = class(dereference)
    private _params_list: List<type_definition>;
    // Methods
    public constructor Create; 
    public constructor Create(_params_list: List<type_definition>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property params_list: List<type_definition> read _params_list write _params_list;

    // Fields
     

end;

template_type_reference = class(named_type_reference)
    private _name: named_type_reference;
     private _params_list: template_param_list;
    // Methods
    public constructor Create; 
    public constructor Create(_name: named_type_reference; _params_list: template_param_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property name: named_type_reference read _name write _name;
    public property params_list: template_param_list read _params_list write _params_list;

    // Fields
     

end;

token_taginfo = class(token_info)
    private _tag: object;
    // Methods
    public constructor Create; 
    public constructor Create(_tag: object); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property tag: object read _tag write _tag;

    // Fields
     

end;

try_except_statement = class(try_statement)
    private _else_statements: statement_list;
     private _on_except: on_exception_list;
    // Methods
    public constructor Create; 
    public constructor Create(_on_except: on_exception_list; _else_statements: statement_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property else_statements: statement_list read _else_statements write _else_statements;
    public property on_except: on_exception_list read _on_except write _on_except;

    // Fields
     

end;

try_finally_statement = class(try_statement)
    private _finally_statements: statement_list;
    // Methods
    public constructor Create; 
    public constructor Create(_finally_statements: statement_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property finally_statements: statement_list read _finally_statements write _finally_statements;

    // Fields
     

end;

try_handler = class(syntax_tree_node)
    // Methods
    public constructor Create; 
    public procedure visit(visitor: IVisitor); override; 

end;

try_handler_except = class(try_handler)
    private _except_block: exception_block;
    // Methods
    public constructor Create; 
    public constructor Create(_except_block: exception_block); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property except_block: exception_block read _except_block write _except_block;

    // Fields
     

end;

try_handler_finally = class(try_handler)
    private _stmt_list: statement_list;
    // Methods
    public constructor Create; 
    public constructor Create(_stmt_list: statement_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property stmt_list: statement_list read _stmt_list write _stmt_list;

    // Fields
     

end;

try_stmt = class(statement)
    private _handler: try_handler;
     private _stmt_list: statement_list;
    // Methods
    public constructor Create; 
    public constructor Create(_stmt_list: statement_list; _handler: try_handler); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property handler: try_handler read _handler write _handler;
    public property stmt_list: statement_list read _stmt_list write _stmt_list;

    // Fields
     

end;



type_declarations = class(declaration)
    private _types_decl: List<type_declaration>;
    // Methods
    public constructor Create; 
    public constructor Create(_types_decl: List<type_declaration>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property types_decl: List<type_declaration> read _types_decl write _types_decl;

    // Fields
     

end;



type_definition_attr = class(type_definition)
    private _attr: type_definition_attribute;
    // Methods
    public constructor Create; 
    public constructor Create(_attr: type_definition_attribute); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property attr: type_definition_attribute read _attr write _attr;

    // Fields
     

end;

type_definition_attr_list = class(syntax_tree_node)
    private _attributes: List<type_definition_attr>;
    // Methods
    public constructor Create; 
    public constructor Create(_attributes: List<type_definition_attr>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property attributes: List<type_definition_attr> read _attributes write _attributes;

    // Fields
     

end;

type_definition_list = class(syntax_tree_node)
    private _defs: List<type_definition>;
    // Methods
    public constructor Create; 
    public constructor Create(_defs: List<type_definition>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property defs: List<type_definition> read _defs write _defs;

    // Fields
     

end;

typecast_node = class(addressed_value)
     private _cast_op: op_typecast;
     private _expr: addressed_value;
     private _type_def: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_expr: addressed_value; _type_def: type_definition; _cast_op: op_typecast); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property cast_op: op_typecast read _cast_op write _cast_op;
    public property expr: addressed_value read _expr write _expr;
    public property type_def: type_definition read _type_def write _type_def;

    // Fields
    

end;

typed_const_definition = class(const_definition)
    private _const_type: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_const_type: type_definition); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property const_type: type_definition read _const_type write _const_type;

    // Fields
     

end;

typed_parametres = class(syntax_tree_node) 
    private _idents: ident_list;
     private _inital_value: expression;
     private _param_kind: parametr_kind;
     private _vars_type: type_definition;
     // Methods
    public constructor Create; 
    public constructor Create(_idents: ident_list; _vars_type: type_definition; _param_kind: parametr_kind; _inital_value: expression); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property idents: ident_list read _idents write _idents;
    public property inital_value: expression read _inital_value write _inital_value;
    public property param_kind: parametr_kind read _param_kind write _param_kind;
    public property vars_type: type_definition read _vars_type write _vars_type;

    // Fields
     

end;

typeof_operator = class(addressed_value)
    private _type_name: named_type_reference;
    // Methods
    public constructor Create; 
    public constructor Create(_type_name: named_type_reference); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property type_name: named_type_reference read _type_name write _type_name;

    // Fields
     

end;

uint64_const = class(const_node)
    private _val: UInt64;
    // Methods
    public constructor Create; 
    public constructor Create(_val: UInt64); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property val: UInt64 read _val write _val;

    // Fields
     

end;

un_expr = class(addressed_value)
    private _operation_type: Operators;
     private _subnode: expression;
    // Methods
    public constructor Create; 
    public constructor Create(_subnode: expression; _operation_type: Operators); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property operation_type: Operators read _operation_type write _operation_type;
    public property subnode: expression read _subnode write _subnode;

    // Fields
     

end;

unit_module = class(compilation_unit)
    private _finalization_part: statement_list;
     private _implementation_part: implementation_node;
     private _initialization_part: statement_list;
     private _interface_part: interface_node;
     private _unit_name: unit_name;
    // Methods
    public constructor Create; 
    public constructor Create(_unit_name: unit_name; _interface_part: interface_node; _implementation_part: implementation_node; _initialization_part: statement_list; _finalization_part: statement_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property finalization_part: statement_list read _finalization_part write _finalization_part;
    public property implementation_part: implementation_node read _implementation_part write _implementation_part;
    public property initialization_part: statement_list read _initialization_part write _initialization_part;
    public property interface_part: interface_node read _interface_part write _interface_part;
    public property unit_name: SyntaxTree.unit_name read _unit_name write _unit_name;

    // Fields
     

end;

unit_name = class(syntax_tree_node)
    private _HeaderKeyword: UnitHeaderKeyword;
     private _idunit_name: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_idunit_name: ident; _HeaderKeyword: UnitHeaderKeyword); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property HeaderKeyword: UnitHeaderKeyword read _HeaderKeyword write _HeaderKeyword;
    public property idunit_name: ident read _idunit_name write _idunit_name;

    // Fields
     

end;

uses_list = class(syntax_tree_node)
    private _units: List<unit_or_namespace>;
    // Methods
    public constructor Create; 
    public constructor Create(_units: List<unit_or_namespace>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property units: List<unit_or_namespace> read _units write _units;

    // Fields
     

end;

uses_unit_in = class(unit_or_namespace)
    private _in_file: string_const;
    // Methods
    public constructor Create; 
    public constructor Create(_in_file: string_const); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property in_file: string_const read _in_file write _in_file;

    // Fields
     

end;

using_list = class(syntax_tree_node)
    private _namespaces: List<unit_or_namespace>;
    // Methods
    public constructor Create; 
    public constructor Create(_namespaces: List<unit_or_namespace>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property namespaces: List<unit_or_namespace> read _namespaces write _namespaces;

    // Fields
     

end;

var_def_list = class(syntax_tree_node)
    private _vars: List<var_def_statement>;
    // Methods
    public constructor Create; 
    public constructor Create(_vars: List<var_def_statement>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property vars: List<var_def_statement> read _vars write _vars;

    // Fields
     

end;

var_def_statement = class(declaration)
    private _inital_value: expression;
     private _is_event: boolean;
     private _var_attr: type_definition_attribute;
     private _vars: ident_list;
     private _vars_type: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_vars: ident_list; _vars_type: type_definition; _inital_value: expression; _var_attr: type_definition_attribute; _is_event: boolean); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property inital_value: expression read _inital_value write _inital_value;
    public property is_event: boolean read _is_event write _is_event;
    public property var_attr: type_definition_attribute read _var_attr write _var_attr;
    public property vars: ident_list read _vars write _vars;
    public property vars_type: type_definition read _vars_type write _vars_type;

    // Fields
     

end;

var_statement = class(statement)
    private _var_def: var_def_statement;
    // Methods
    public constructor Create; 
    public constructor Create(_var_def: var_def_statement); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property var_def: var_def_statement read _var_def write _var_def;

    // Fields
     

end;

variable_definitions = class(declaration)
    private _var_definitions: List<var_def_statement>;
    // Methods
    public constructor Create; 
    public constructor Create(_var_definitions: List<var_def_statement>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property var_definitions: List<var_def_statement> read _var_definitions write _var_definitions;

    // Fields
     

end;

variant = class(syntax_tree_node)
    private _vars: ident_list;
     private _vars_type: type_definition;
    // Methods
    public constructor Create; 
    public constructor Create(_vars: ident_list; _vars_type: type_definition); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property vars: ident_list read _vars write _vars;
    public property vars_type: type_definition read _vars_type write _vars_type;

    // Fields
     

end;

variant_list = class(syntax_tree_node)
    private _vars: List<variant>;
    // Methods
    public constructor Create; 
    public constructor Create(_vars: List<variant>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property vars: List<variant> read _vars write _vars;

    // Fields
     

end;

variant_record_type = class(syntax_tree_node)
    private _var_name: ident;
     private _var_type: type_definition;
     private _vars: variant_types;
    // Methods
    public constructor Create; 
    public constructor Create(_var_name: ident; _var_type: type_definition; _vars: variant_types); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property var_name: ident read _var_name write _var_name;
    public property var_type: type_definition read _var_type write _var_type;
    public property vars: variant_types read _vars write _vars;

    // Fields
     

end;

variant_type = class(syntax_tree_node)
    private _case_exprs: expression_list;
     private _parts: record_type_parts;
    // Methods
    public constructor Create; 
    public constructor Create(_case_exprs: expression_list; _parts: record_type_parts); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property case_exprs: expression_list read _case_exprs write _case_exprs;
    public property parts: record_type_parts read _parts write _parts;

    // Fields
     

end;

variant_types = class(syntax_tree_node)
    private _vars: List<variant_type>;
    // Methods
    public constructor Create; 
    public constructor Create(_vars: List<variant_type>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property vars: List<variant_type> read _vars write _vars;

    // Fields
     

end;

where_definition = class(syntax_tree_node)
    private _constructor_specific_params: type_definition_list;
     private _names: ident_list;
     private _types: type_definition_list;
    // Methods
    public constructor Create; 
    public constructor Create(_names: ident_list; _types: type_definition_list; _constructor_specific_params: type_definition_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property constructor_specific_params: type_definition_list read _constructor_specific_params write _constructor_specific_params;
    public property names: ident_list read _names write _names;
    public property types: type_definition_list read _types write _types;

    // Fields
     

end;

where_definition_list = class(syntax_tree_node)
    private _defs: List<where_definition>;
    // Methods
    public constructor Create; 
    public constructor Create(_defs: List<where_definition>); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property defs: List<where_definition> read _defs write _defs;

    // Fields
     

end;

while_node = class(statement)
    private _CycleType: WhileCycleType;
     private _expr: expression;
     private _statements: statement;
    // Methods
    public constructor Create; 
    public constructor Create(_expr: expression; _statements: statement; _CycleType: WhileCycleType); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property CycleType: WhileCycleType read _CycleType write _CycleType;
    public property expr: expression read _expr write _expr;
    public property statements: statement read _statements write _statements;

    // Fields
     

end;

with_statement = class(statement)
    private _do_with: expression_list;
     private _what_do: statement;
    // Methods
    public constructor Create; 
    public constructor Create(_what_do: statement; _do_with: expression_list); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property do_with: expression_list read _do_with write _do_with;
    public property what_do: statement read _what_do write _what_do;

    // Fields
     

end;

write_accessor_name = class(syntax_tree_node)
    private _accessor_name: ident;
    // Methods
    public constructor Create; 
    public constructor Create(_accessor_name: ident); 
    public procedure visit(visitor: IVisitor); override; 

    // Properties
    public property accessor_name: ident read _accessor_name write _accessor_name;

    // Fields
     

end;

  
implementation

function file_position.get_column_num: Integer;
begin
  Result := self._column_num;
end;

function file_position.get_line_num: Integer;
begin
  Result := self._line_num;
end;

constructor file_position.Create(line_num: Integer; column_num: Integer);
begin
  self._line_num := line_num;
  self._column_num := column_num
end;


function SourceContext.get_begin_position: file_position;
begin
  Result := self._begin_position;
end;

function SourceContext.get_end_position: file_position;
begin
  Result := self._end_position;
end;

function SourceContext.get_FileName: string;
begin
  Result := self._file_name;
end;

procedure SourceContext.set_FileName(value: string);
begin
  self._file_name := value;
end;

function SourceContext.get_LeftSourceContext: SourceContext;
begin
  var sc := SourceContext.Create(self.begin_position.line_num, self.begin_position.column_num, self.begin_position.line_num, self.begin_position.column_num);
  sc.FileName := self.FileName;
  Result := sc
end;


function SourceContext.get_Length: Integer;
begin
  Result := self._end_symbol_position - self._begin_symbol_position;
end;

function SourceContext.get_Position: Integer;
begin
  Result := self._begin_symbol_position;
end;

function SourceContext.get_RightSourceContext: SourceContext;
begin
  var sc := SourceContext.Create(self.end_position.line_num, self.end_position.column_num, self.end_position.line_num, self.end_position.column_num);
  sc.FileName := self.FileName;
  Result := sc
end;

constructor SourceContext.Create(left: SourceContext; right: SourceContext);
begin
    self._file_name := nil;
    if (left <> nil) then
        self._begin_position := file_position.Create(left.begin_position.line_num, left.begin_position.column_num);
    if (right <> nil) then
        self._end_position := file_position.Create(right.end_position.line_num, right.end_position.column_num);
    if (left = nil) then
        self._begin_position := self._end_position;
    if (right = nil) then
        self._end_position := self._begin_position;
    self._begin_symbol_position := left._begin_symbol_position;
    self._end_symbol_position := right._end_symbol_position;
    self.FileName :=  (left.FileName = right.FileName)?left.FileName:nil;
end;

constructor SourceContext.Create(beg_line_num: Integer; beg_column_num: Integer; end_line_num: Integer; end_column_num: Integer);
begin
  self._file_name := nil;
  self._begin_position := file_position.Create(beg_line_num, beg_column_num);
  self._end_position := file_position.Create(end_line_num, end_column_num);
  self._begin_symbol_position := 0;
  self._end_symbol_position := 0
end;

constructor SourceContext.Create(beg_line_num: Integer; beg_column_num: Integer; end_line_num: Integer; end_column_num: Integer; _begin_symbol_position: Integer; _end_symbol_position: Integer);
begin
  self._file_name := nil;
  self._begin_position := file_position.Create(beg_line_num, beg_column_num);
  self._end_position := file_position.Create(end_line_num, end_column_num);
  self._begin_symbol_position := _begin_symbol_position;
  self._end_symbol_position := _end_symbol_position
end;

function SourceContext.&In(sc: SourceContext): boolean;
begin
  Result := ((((self.begin_position.line_num >= sc.begin_position.line_num) and (self.end_position.line_num <= sc.end_position.line_num)) and ((self.begin_position.line_num <> sc.begin_position.line_num) or (self.begin_position.column_num >= sc.begin_position.column_num))) and ((self.end_position.line_num <> sc.end_position.line_num) or (self.end_position.column_num <= sc.end_position.column_num)));
end;

function SourceContext.ToString: string;
begin
  //Result := string.Format('[({0},{1})-({2},{3})]', New(array[4] of TObject, ( ( self.begin_position.line_num, self.begin_position.column_num, self.end_position.line_num, self.end_position.column_num ) )))
end;

constructor syntax_tree_node.Create;
begin
  
end;

constructor syntax_tree_node.Create(_source_context: SourceContext);
begin
  self._source_context := _source_context;
end;

procedure syntax_tree_node.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor addressed_value.Create;
begin
  
end;

procedure addressed_value.visit(visitor: IVisitor);
begin
 visitor.visit(self); 
end;


constructor addressed_value_funcname.Create;
begin
  
end;

procedure addressed_value_funcname.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor array_const.Create;
begin
  
end;

constructor array_const.Create(_elements: expression_list);
begin
  self._elements := _elements;
end;

procedure array_const.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor array_of_const_type_definition.Create;
begin
  
end;

procedure array_of_const_type_definition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor array_of_named_type_definition.Create;
begin
  
end;

constructor array_of_named_type_definition.Create(_type_name: named_type_reference);
begin
  self._type_name := _type_name;
end;

procedure array_of_named_type_definition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor array_size.Create;
begin
  
end;

constructor array_size.Create(_max_value: expression);
begin
  self._max_value := _max_value;
end;

procedure array_size.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor array_type.Create;
begin
  
end;

constructor array_type.Create(_indexers: indexers_types; _elemets_types: type_definition);
begin
  self._indexers := _indexers;
  self._elemets_types := _elemets_types;
end;

procedure array_type.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor assign.Create;
begin
  
end;

constructor assign.Create(_to: addressed_value; _from: expression; _operator_type: Operators);
begin
  self._to := _to;
  self._from := _from;
  self._operator_type := _operator_type;
end;

procedure assign.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor bin_expr.Create;
begin
  
end;

constructor bin_expr.Create(_left: expression; _right: expression; _operation_type: Operators);
begin
  self._left := _left;
  self._right := _right;
end;

procedure bin_expr.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor block.Create;
begin
  
end;

constructor block.Create(_defs: declarations; _program_code: statement_list);
begin
  self._defs := _defs;
  self._program_code := _program_code;
end;

procedure block.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor bool_const.Create;
begin
  
end;

constructor bool_const.Create(_val: boolean);
begin
  self._val := _val;
end;

procedure bool_const.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor c_for_cycle.Create;
begin
  
end;

constructor c_for_cycle.Create(_expr1: statement; _expr2: expression; _expr3: expression; _stmt: statement);
begin
  self._expr1 := _expr1;
  self._expr2 := _expr2;
  self._expr3 := _expr3;
  self._stmt := _stmt;
end;

procedure c_for_cycle.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor c_module.Create;
begin
  
end;

constructor c_module.Create(_defs: declarations; _used_units: uses_list);
begin
  self._defs := _defs;
  self._used_units := _used_units;
end;

procedure c_module.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor c_scalar_type.Create;
begin
  
end;

constructor c_scalar_type.Create(_scalar_name: c_scalar_type_name; _sign: c_scalar_sign);
begin
  self._scalar_name := _scalar_name;
  self._sign := _sign
end;

procedure c_scalar_type.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor case_node.Create;
begin
  
end;

constructor case_node.Create(_param: expression; _conditions: case_variants; _else_statement: statement);
begin
  self._param := _param;
  self._conditions := _conditions;
  self._else_statement := _else_statement
end;

procedure case_node.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor case_variant.Create;
begin
  
end;

constructor case_variant.Create(_conditions: expression_list; _exec_if_true: statement);
begin
  self._conditions := _conditions;
  self._exec_if_true := _exec_if_true
end;

procedure case_variant.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor case_variants.Create;
begin
  self._variants := new List<case_variant>();
end;

constructor case_variants.Create(_variants: List<case_variant>);
begin
  self._variants := _variants
end;

procedure case_variants.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor char_const.Create;
begin
  
end;

constructor char_const.Create(_cconst: Char);
begin
  self._cconst := _cconst;
end;

procedure char_const.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor class_body.Create;
begin
  self._class_def_blocks := new List<class_members>();
end;

constructor class_body.Create(_class_def_blocks: List<class_members>);
begin
  self._class_def_blocks := _class_def_blocks
end;

procedure class_body.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor class_definition.Create;
begin
  
end;

constructor class_definition.Create(_class_parents: named_type_reference_list; _body: class_body; _keyword: class_keyword; _template_args: ident_list; _where_section: where_definition_list; _attribute: class_attribute);
begin
  self._class_parents := _class_parents;
  self._body := _body;
  self._keyword := _keyword;
  self._template_args := _template_args;
  self._where_section := _where_section;
  self._attribute := _attribute
end;

procedure class_definition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor class_members.Create;
begin
  self._members := new List<declaration>();
end;

constructor class_members.Create(_members: List<declaration>; _access_mod: access_modifer_node);
begin
  self._members := _members;
  self._access_mod := _access_mod
end;

procedure class_members.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor class_predefinition.Create;
begin
  
end;

constructor class_predefinition.Create(_class_name: ident);
begin
  self._class_name := _class_name;
end;

procedure class_predefinition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor compilation_unit.Create;
begin
  self._compiler_directives := new List<compiler_directive>();
end;

constructor compilation_unit.Create(_file_name: string; _compiler_directives: List<compiler_directive>; _Language: LanguageId);
begin
  self._file_name := _file_name;
  self._compiler_directives := _compiler_directives;
  self._Language := _Language
end;

procedure compilation_unit.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor compiler_directive.Create;
begin
  
end;

constructor compiler_directive.Create(_Name: token_info; _Directive: token_info);
begin
  self._Name := _Name;
  self._Directive := _Directive
end;

procedure compiler_directive.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor compiler_directive_if.Create;
begin
  
end;

constructor compiler_directive_if.Create(_if_part: compiler_directive; _elseif_part: compiler_directive);
begin
  self._if_part := _if_part;
  self._elseif_part := _elseif_part
end;

procedure compiler_directive_if.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor compiler_directive_list.Create;
begin
  
end;

constructor compiler_directive_list.Create(_directives: List<compiler_directive>);
begin
  self._directives := _directives;
end;

procedure compiler_directive_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor const_definition.Create;
begin
  
end;

constructor const_definition.Create(_const_name: ident; _const_value: expression);
begin
  self._const_name := _const_name;
  self._const_value := _const_value
end;

procedure const_definition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor const_node.Create;
begin
  
end;

procedure const_node.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor &constructor.Create;
begin
  
end;

procedure &constructor.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor consts_definitions_list.Create;
begin
  self._const_defs := new List<const_definition>();
end;

constructor consts_definitions_list.Create(_const_defs: List<const_definition>);
begin
  self._const_defs := _const_defs;
end;

procedure consts_definitions_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor declaration.Create;
begin
  
end;

procedure declaration.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor declarations.Create;
begin
  self._defs := new List<declaration>();
end;

constructor declarations.Create(_defs: List<declaration>);
begin
  self._defs := _defs;
end;

procedure declarations.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor declarations_as_statement.Create;
begin
  
end;

constructor declarations_as_statement.Create(_defs: declarations);
begin
  self._defs := _defs;
end;

procedure declarations_as_statement.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor default_indexer_property_node.Create;
begin
  
end;

procedure default_indexer_property_node.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor dereference.Create;
begin
  
end;

constructor dereference.Create(_dereferencing_value: addressed_value);
begin
  self._dereferencing_value := _dereferencing_value;
end;

procedure dereference.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor &destructor.Create;
begin
  
end;

procedure &destructor.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor diap_expr.Create;
begin
  
end;

constructor diap_expr.Create(_left: expression; _right: expression);
begin
  self._left := _left;
  self._right := _right;
end;

procedure diap_expr.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor diapason.Create;
begin
  
end;

constructor diapason.Create(_left: expression; _right: expression);
begin
  self._left := _left;
  self._right := _right;
end;

procedure diapason.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor diapason_expr.Create;
begin
  
end;

constructor diapason_expr.Create(_left: expression; _right: expression);
begin
  self._left := _left;
  self._right := _right;  
end;

procedure diapason_expr.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor documentation_comment_list.Create;
begin
  self._sections := new List<documentation_comment_section>();
end;

constructor documentation_comment_list.Create(_sections: List<documentation_comment_section>);
begin
  self._sections := _sections;
end;

procedure documentation_comment_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor documentation_comment_section.Create;
begin
  self._tags := new List<documentation_comment_tag>();
end;

constructor documentation_comment_section.Create(_tags: List<documentation_comment_tag>; _text: string);
begin
  self._tags := _tags;
  self._text := _text;
end;

procedure documentation_comment_section.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor documentation_comment_tag.Create;
begin
  self._parameters := new List<documentation_comment_tag_param>()
end;

constructor documentation_comment_tag.Create(_name: string; _parameters: List<documentation_comment_tag_param>; _text: string);
begin
  self._name := _name;
  self._parameters := _parameters;
  self._text := _text
end;

procedure documentation_comment_tag.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor documentation_comment_tag_param.Create;
begin
  
end;

constructor documentation_comment_tag_param.Create(_name: string; _value: string);
begin
  self._name := _name;
  self._value := _value;
end;

procedure documentation_comment_tag_param.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor dot_node.Create;
begin
  
end;

constructor dot_node.Create(_left: addressed_value; _right: addressed_value);
begin
  self._left := _left;
  self._right := _right;
end;

procedure dot_node.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor double_const.Create;
begin
  
end;

constructor double_const.Create(_val: Double);
begin
  self._val := _val;
end;

procedure double_const.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor empty_statement.Create;
begin
  
end;

procedure empty_statement.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor enum_type_definition.Create;
begin
  
end;

constructor enum_type_definition.Create(_enumerators: enumerator_list);
begin
  self._enumerators := _enumerators;
end;

procedure enum_type_definition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor enumerator.Create;
begin
  
end;

constructor enumerator.Create(_name: ident; _value: expression);
begin
  self._name := _name;
  self._value := _value;
end;

procedure enumerator.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor enumerator_list.Create;
begin
  self._enumerators := new List<enumerator>();
end;

constructor enumerator_list.Create(_enumerators: List<enumerator>);
begin
  self._enumerators := _enumerators;
end;

procedure enumerator_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor exception_block.Create;
begin
  
end;

constructor exception_block.Create(_stmt_list: statement_list; _handlers: exception_handler_list; _else_stmt_list: statement_list);
begin
  self._stmt_list := _stmt_list;
  self._handlers := _handlers;
  self._else_stmt_list := _else_stmt_list
end;

procedure exception_block.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor exception_handler.Create;
begin
  
end;

constructor exception_handler.Create(_variable: ident; _type_name: named_type_reference; _statements: statement);
begin
  self._variable := _variable;
  self._type_name := _type_name;
  self._statements := _statements
end;

procedure exception_handler.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor exception_handler_list.Create;
begin
  self._handlers := new List<exception_handler>();
end;

constructor exception_handler_list.Create(_handlers: List<exception_handler>);
begin
  self._handlers := _handlers;
end;

procedure exception_handler_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor exception_ident.Create;
begin
  
end;

constructor exception_ident.Create(_variable: ident; _type_name: named_type_reference);
begin
  self._variable := _variable;
  self._type_name := _type_name;
end;

procedure exception_ident.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor expression.Create;
begin
  
end;

procedure expression.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor expression_as_statement.Create;
begin
  
end;

constructor expression_as_statement.Create(_expr: expression);
begin
  self._expr := _expr;
end;

procedure expression_as_statement.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor expression_list.Create;
begin
  self._expressions := new List<expression>();
end;

constructor expression_list.Create(_expressions: List<expression>);
begin
  self._expressions := _expressions;
end;

procedure expression_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor external_directive.Create;
begin
  
end;

constructor external_directive.Create(_modulename: expression; _name: expression);
begin
  self._modulename := _modulename;
  self._name := _name
end;

procedure external_directive.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor file_type.Create;
begin
  
end;

constructor file_type.Create(_file_of_type: type_definition);
begin
  self._file_of_type := _file_of_type
end;

procedure file_type.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor file_type_definition.Create;
begin
  
end;

constructor file_type_definition.Create(_elem_type: type_definition);
begin
  self._elem_type := _elem_type;
end;

procedure file_type_definition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor for_node.Create;
begin
  
end;

constructor for_node.Create(_loop_variable: ident; _initial_value: expression; _finish_value: expression; _statements: statement; _cycle_type: for_cycle_type; _increment_value: expression; _type_name: type_definition; _create_loop_variable: boolean);
begin
  self._loop_variable := _loop_variable;
  self._initial_value := _initial_value;
  self._finish_value := _finish_value;
  self._statements := _statements;
  self._cycle_type := _cycle_type;
  self._increment_value := _increment_value;
  self._type_name := _type_name;
  self._create_loop_variable := _create_loop_variable
end;

procedure for_node.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor foreach_stmt.Create;
begin
  
end;

constructor foreach_stmt.Create(_identifier: ident; _type_name: type_definition; _in_what: expression; _stmt: statement);
begin
  self._identifier := _identifier;
  self._type_name := _type_name;
  self._in_what := _in_what;
  self._stmt := _stmt
end;

procedure foreach_stmt.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor formal_parametres.Create;
begin
  self._params_list := new List<typed_parametres>();
end;

constructor formal_parametres.Create(_params_list: List<typed_parametres>);
begin
  self._params_list := _params_list;
end;

procedure formal_parametres.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor format_expr.Create;
begin
  
end;

constructor format_expr.Create(_expr: expression; _format1: expression; _format2: expression);
begin
  self._expr := _expr;
  self._format1 := _format1;
  self._format2 := _format2
end;

procedure format_expr.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor function_header.Create;
begin
  
end;

constructor function_header.Create(_return_type: type_definition);
begin
  self._return_type := _return_type
end;

procedure function_header.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor get_address.Create;
begin
  
end;

constructor get_address.Create(_address_of: addressed_value);
begin
  self._address_of := _address_of
end;

procedure get_address.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor goto_statement.Create;
begin
  
end;

constructor goto_statement.Create(_label: ident);
begin
  self._label := _label;
end;

procedure goto_statement.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor hex_constant.Create;
begin
  
end;

procedure hex_constant.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor ident.Create;
begin
  
end;

constructor ident.Create(_name: string);
begin
  self._name := _name
end;

procedure ident.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor ident_list.Create;
begin
  self._idents := new List<ident>();
end;

constructor ident_list.Create(_idents: List<ident>);
begin
  self._idents := _idents;
end;

procedure ident_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor if_node.Create;
begin
  
end;

constructor if_node.Create(_condition: expression; _then_body: statement; _else_body: statement);
begin
  self._condition := _condition;
  self._then_body := _then_body;
  self._else_body := _else_body
end;

procedure if_node.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor implementation_node.Create;
begin
  
end;

constructor implementation_node.Create(_uses_modules: uses_list; _implementation_definitions: declarations; _using_namespaces: using_list);
begin
  self._uses_modules := _uses_modules;
  self._implementation_definitions := _implementation_definitions;
  self._using_namespaces := _using_namespaces
end;

procedure implementation_node.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor index_property.Create;
begin
  
end;

constructor index_property.Create(_property_parametres: formal_parametres; _is_default: default_indexer_property_node);
begin
  self._property_parametres := _property_parametres;
  self._is_default := _is_default
end;

procedure index_property.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor indexer.Create;
begin
  
end;

constructor indexer.Create(_indexes: expression_list);
begin
  self._indexes := _indexes
end;

procedure indexer.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor indexers_types.Create;
begin
  self._indexers := new List<type_definition>()
end;

constructor indexers_types.Create(_indexers: List<type_definition>);
begin
  self._indexers := _indexers
end;

procedure indexers_types.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor inherited_ident.Create;
begin
  
end;

procedure inherited_ident.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor inherited_message.Create;
begin
  
end;

procedure inherited_message.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor inherited_method_call.Create;
begin
  
end;

constructor inherited_method_call.Create(_method_name: ident; _exprs: expression_list);
begin
  self._method_name := _method_name;
  self._exprs := _exprs
end;

procedure inherited_method_call.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor initfinal_part.Create;
begin
  
end;

constructor initfinal_part.Create(_initialization_sect: statement_list; _finalization_sect: statement_list);
begin
  self._initialization_sect := _initialization_sect;
  self._finalization_sect := _finalization_sect
end;

procedure initfinal_part.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor int32_const.Create;
begin
  
end;

constructor int32_const.Create(_val: Integer);
begin
  self._val := _val;
end;

procedure int32_const.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor int64_const.Create;
begin
  
end;

constructor int64_const.Create(_val: Int64);
begin
  self._val := _val;
end;

procedure int64_const.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor interface_node.Create;
begin
  
end;

constructor interface_node.Create(_interface_definitions: declarations; _uses_modules: uses_list; _using_namespaces: using_list);
begin
  self._interface_definitions := _interface_definitions;
  self._uses_modules := _uses_modules;
  self._using_namespaces := _using_namespaces
end;

procedure interface_node.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor jump_stmt.Create;
begin
  
end;

constructor jump_stmt.Create(_expr: expression; _JumpType: JumpStmtType);
begin
  self._expr := _expr;
  self._JumpType := _JumpType
end;

procedure jump_stmt.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor known_type_definition.Create;
begin
  
end;

constructor known_type_definition.Create(_tp: known_type; _unit_name: ident);
begin
  self._tp := _tp;
  self._unit_name := _unit_name
end;

procedure known_type_definition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor known_type_ident.Create;
begin
  
end;

constructor known_type_ident.Create(_type: known_type);
begin
  self._type := _type
end;

procedure known_type_ident.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor label_definitions.Create;
begin
  
end;

constructor label_definitions.Create(_labels: ident_list);
begin
  self._labels := _labels;
end;

procedure label_definitions.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor labeled_statement.Create;
begin
  
end;

constructor labeled_statement.Create(_label_name: ident; _to_statement: statement);
begin
  self._label_name := _label_name;
  self._to_statement := _to_statement
end;

procedure labeled_statement.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor literal.Create;
begin
  
end;

procedure literal.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor literal_const_line.Create;
begin
  self._literals := new List<literal>();
end;

constructor literal_const_line.Create(_literals: List<literal>);
begin
  self._literals := _literals;
end;

procedure literal_const_line.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor lock_stmt.Create;
begin
  
end;

constructor lock_stmt.Create(_lock_object: expression; _stmt: statement);
begin
  self._lock_object := _lock_object;
  self._stmt := _stmt
end;

procedure lock_stmt.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor loop_stmt.Create;
begin
  
end;

constructor loop_stmt.Create(_stmt: statement);
begin
  self._stmt := _stmt;
end;

procedure loop_stmt.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor method_call.Create;
begin
  
end;

constructor method_call.Create(_parametres: expression_list);
begin
  self._parametres := _parametres;
end;

procedure method_call.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor method_name.Create;
begin
  
end;

constructor method_name.Create(_class_name: ident; _meth_name: ident);
begin
  self._class_name := _class_name;
  self._meth_name := _meth_name
end;

procedure method_name.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor named_type_reference.Create;
begin
  self._names := new List<ident>();
end;

constructor named_type_reference.Create(_names: List<ident>);
begin
  self._names := _names;
end;

procedure named_type_reference.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor named_type_reference_list.Create;
begin
  self._types := new List<named_type_reference>();  
end;

constructor named_type_reference_list.Create(_types: List<named_type_reference>);
begin
  self._types := _types
end;

procedure named_type_reference_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor new_expr.Create;
begin
  
end;

constructor new_expr.Create(_type: type_definition; _params_list: expression_list; _new_array: boolean);
begin
  self._type := _type;
  self._params_list := _params_list;
  self._new_array := _new_array
end;

procedure new_expr.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor nil_const.Create;
begin
  
end;

procedure nil_const.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor oberon_exit_stmt.Create;
begin
  
end;

constructor oberon_exit_stmt.Create(_text: string);
begin
  self._text := _text;
end;

procedure oberon_exit_stmt.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor oberon_ident_with_export_marker.Create;
begin
  
end;

constructor oberon_ident_with_export_marker.Create(_marker: oberon_export_marker);
begin
  self._marker := _marker;
end;

procedure oberon_ident_with_export_marker.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor oberon_import_module.Create;
begin
  
end;

constructor oberon_import_module.Create(_new_name: ident);
begin
  self._new_name := _new_name;
end;

procedure oberon_import_module.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor oberon_module.Create;
begin
  
end;

constructor oberon_module.Create(_first_name: ident; _second_name: ident; _import_list: uses_list; _definitions: declarations; _module_code: statement_list);
begin
  self._first_name := _first_name;
  self._second_name := _second_name;
  self._import_list := _import_list;
  self._definitions := _definitions;
  self._module_code := _module_code
end;

procedure oberon_module.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor oberon_procedure_header.Create;
begin
  
end;

constructor oberon_procedure_header.Create(_receiver: oberon_procedure_receiver; _first_name: ident; _second_name: ident);
begin
  self._receiver := _receiver;
  self._first_name := _first_name;
  self._second_name := _second_name
end;

procedure oberon_procedure_header.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor oberon_procedure_receiver.Create;
begin
  
end;

constructor oberon_procedure_receiver.Create(_param_kind: parametr_kind; _receiver_name: ident; _receiver_typename: ident);
begin
  self._param_kind := _param_kind;
  self._receiver_name := _receiver_name;
  self._receiver_typename := _receiver_typename
end;

procedure oberon_procedure_receiver.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor oberon_withstmt.Create;
begin
  
end;

constructor oberon_withstmt.Create(_quardstat_list: oberon_withstmt_guardstat_list; _else_stmt: statement);
begin
  self._quardstat_list := _quardstat_list;
  self._else_stmt := _else_stmt
end;

procedure oberon_withstmt.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor oberon_withstmt_guardstat.Create;
begin
  
end;

constructor oberon_withstmt_guardstat.Create(_name: addressed_value; _type_name: type_definition; _stmt: statement);
begin
  self._name := _name;
  self._type_name := _type_name;
  self._stmt := _stmt
end;

procedure oberon_withstmt_guardstat.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor oberon_withstmt_guardstat_list.Create;
begin
  self._guardstats := new List<oberon_withstmt_guardstat>();  
end;

constructor oberon_withstmt_guardstat_list.Create(_guardstats: List<oberon_withstmt_guardstat>);
begin
  self._guardstats := _guardstats
end;

procedure oberon_withstmt_guardstat_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor on_exception.Create;
begin
  
end;

constructor on_exception.Create(_exception_var_name: ident; _exception_type_name: ident; _stat: statement);
begin
  self._exception_var_name := _exception_var_name;
  self._exception_type_name := _exception_type_name;
  self._stat := _stat
end;

procedure on_exception.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor on_exception_list.Create;
begin
  self._on_exceptions := new List<on_exception>();  
end;

constructor on_exception_list.Create(_on_exceptions: List<on_exception>);
begin
  self._on_exceptions := _on_exceptions
end;

procedure on_exception_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor op_type_node.Create;
begin
  
end;

constructor op_type_node.Create(_type: Operators);
begin
  self._type := _type;
end;

procedure op_type_node.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor operator_name_ident.Create;
begin
  
end;

constructor operator_name_ident.Create(_operator_type: Operators);
begin
  self._operator_type := _operator_type;
end;

procedure operator_name_ident.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor pascal_set_constant.Create;
begin
  
end;

constructor pascal_set_constant.Create(_values: expression_list);
begin
  self._values := _values;
end;

procedure pascal_set_constant.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor proc_block.Create;
begin
  
end;

procedure proc_block.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor procedure_attribute.Create;
begin
  
end;

constructor procedure_attribute.Create(_attribute_type: proc_attribute);
begin
  self._attribute_type := _attribute_type;
end;

procedure procedure_attribute.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor procedure_attributes_list.Create;
begin
  self._proc_attributes := new List<procedure_attribute>();  
end;

constructor procedure_attributes_list.Create(_proc_attributes: List<procedure_attribute>);
begin
  self._proc_attributes := _proc_attributes
end;

procedure procedure_attributes_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor procedure_call.Create;
begin
  
end;

constructor procedure_call.Create(_func_name: addressed_value);
begin
  self._func_name := _func_name;
end;

procedure procedure_call.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor procedure_definition.Create;
begin
  
end;

constructor procedure_definition.Create(_proc_header: procedure_header; _proc_body: proc_block);
begin
  self._proc_header := _proc_header;
  self._proc_body := _proc_body
end;

procedure procedure_definition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor procedure_header.Create;
begin
  
end;

constructor procedure_header.Create(_parametres: formal_parametres; _proc_attributes: procedure_attributes_list; _name: method_name; _of_object: boolean; _class_keyword: boolean);
begin
  self._parametres := _parametres;
  self._proc_attributes := _proc_attributes;
  self._name := _name;
  self._of_object := _of_object;
  self._class_keyword := _class_keyword
end;

procedure procedure_header.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor program_body.Create;
begin
  
end;

constructor program_body.Create(_used_units: uses_list; _program_definitions: declarations; _program_code: statement_list; _using_list: SyntaxTree.using_list);
begin
  self._used_units := _used_units;
  self._program_definitions := _program_definitions;
  self._program_code := _program_code;
  self._using_list := _using_list
end;

procedure program_body.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor program_module.Create;
begin
  
end;

constructor program_module.Create(_program_name: SyntaxTree.program_name; _used_units: uses_list; _program_block: block; _using_namespaces: using_list);
begin
  self._program_name := _program_name;
  self._used_units := _used_units;
  self._program_block := _program_block;
  self._using_namespaces := _using_namespaces
end;

procedure program_module.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor program_name.Create;
begin
  
end;

constructor program_name.Create(_prog_name: ident);
begin
  self._prog_name := _prog_name;
end;

procedure program_name.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor program_tree.Create;
begin
  self._compilation_units := new List<compilation_unit>();  
end;

constructor program_tree.Create(_compilation_units: List<compilation_unit>);
begin
  self._compilation_units := _compilation_units
end;

procedure program_tree.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor property_accessors.Create;
begin
  
end;

constructor property_accessors.Create(_read_accessor: read_accessor_name; _write_accessor: write_accessor_name);
begin
  self._read_accessor := _read_accessor;
  self._write_accessor := _write_accessor
end;

procedure property_accessors.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor property_array_default.Create;
begin
  
end;

procedure property_array_default.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor property_interface.Create;
begin
  
end;

constructor property_interface.Create(_parameter_list: property_parameter_list; _property_type: type_definition; _index_expression: expression);
begin
  self._parameter_list := _parameter_list;
  self._property_type := _property_type;
  self._index_expression := _index_expression
end;

procedure property_interface.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor property_parameter.Create;
begin
  
end;

constructor property_parameter.Create(_names: ident_list; _type: type_definition);
begin
  self._names := _names;
  self._type := _type
end;

procedure property_parameter.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor property_parameter_list.Create;
begin
  self._parameters := new List<property_parameter>()
end;

constructor property_parameter_list.Create(_parameters: List<property_parameter>);
begin
  self._parameters := _parameters;
end;

procedure property_parameter_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor question_colon_expression.Create;
begin
  
end;

constructor question_colon_expression.Create(_condition: expression; _ret_if_true: expression; _ret_if_false: expression);
begin
  self._condition := _condition;
  self._ret_if_true := _ret_if_true;
  self._ret_if_false := _ret_if_false
end;

procedure question_colon_expression.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor raise_statement.Create;
begin
  
end;

constructor raise_statement.Create(_excep: expression);
begin
  self._excep := _excep;
end;

procedure raise_statement.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor raise_stmt.Create;
begin
  
end;

constructor raise_stmt.Create(_expr: expression; _address: expression);
begin
  self._expr := _expr;
  self._address := _address
end;

procedure raise_stmt.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor read_accessor_name.Create;
begin
  
end;

constructor read_accessor_name.Create(_accessor_name: ident);
begin
  self._accessor_name := _accessor_name;
end;

procedure read_accessor_name.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor record_const.Create;
begin
  self._rec_consts := new List<record_const_definition>();  
end;

constructor record_const.Create(_rec_consts: List<record_const_definition>);
begin
  self._rec_consts := _rec_consts
end;

procedure record_const.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor record_const_definition.Create;
begin
  
end;

constructor record_const_definition.Create(_name: ident; _val: expression);
begin
  self._name := _name;
  self._val := _val
end;

procedure record_const_definition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor record_type.Create;
begin
  
end;

constructor record_type.Create(_parts: record_type_parts; _base_type: type_definition);
begin
  self._parts := _parts;
  self._base_type := _base_type
end;

procedure record_type.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor record_type_parts.Create;
begin
  
end;

constructor record_type_parts.Create(_fixed_part: var_def_list; _variant_part: variant_record_type);
begin
  self._fixed_part := _fixed_part;
  self._variant_part := _variant_part
end;

procedure record_type_parts.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor ref_type.Create;
begin
  
end;

constructor ref_type.Create(_pointed_to: type_definition);
begin
  self._pointed_to := _pointed_to;
end;

procedure ref_type.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor repeat_node.Create;
begin
  
end;

constructor repeat_node.Create(_statements: statement; _expr: expression);
begin
  self._statements := _statements;
  self._expr := _expr
end;

procedure repeat_node.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor roof_dereference.Create;
begin
  
end;

procedure roof_dereference.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor set_type_definition.Create;
begin
  
end;

constructor set_type_definition.Create(_of_type: type_definition);
begin
  self._of_type := _of_type;
end;

procedure set_type_definition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor sharp_char_const.Create;
begin
  
end;

constructor sharp_char_const.Create(_char_num: Integer);
begin
  self._char_num := _char_num;
end;

procedure sharp_char_const.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor simple_const_definition.Create;
begin
  
end;

procedure simple_const_definition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor simple_property.Create;
begin
  
end;

constructor simple_property.Create(_property_name: ident; _property_type: type_definition; _index_expression: expression; _accessors: property_accessors; _array_default: property_array_default; _parameter_list: property_parameter_list);
begin
  self._property_name := _property_name;
  self._property_type := _property_type;
  self._index_expression := _index_expression;
  self._accessors := _accessors;
  self._array_default := _array_default;
  self._parameter_list := _parameter_list
end;

procedure simple_property.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor sizeof_operator.Create;
begin
  
end;

constructor sizeof_operator.Create(_type_def: type_definition; _expr: expression);
begin
  self._type_def := _type_def;
  self._expr := _expr
end;

procedure sizeof_operator.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor statement.Create;
begin
  
end;

procedure statement.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor statement_list.Create;
begin
  self._subnodes := new List<statement>();  
end;

constructor statement_list.Create(_subnodes: List<statement>; _left_logical_bracket: syntax_tree_node; _right_logical_bracket: syntax_tree_node);
begin
  self._subnodes := _subnodes;
  self._left_logical_bracket := _left_logical_bracket;
  self._right_logical_bracket := _right_logical_bracket
end;

procedure statement_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor string_const.Create;
begin
  
end;

constructor string_const.Create(_Value: string);
begin
  self._Value := _Value;
end;

procedure string_const.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor string_num_definition.Create;
begin
  
end;

constructor string_num_definition.Create(_num_of_symbols: expression; _name: ident);
begin
  self._num_of_symbols := _num_of_symbols;
  self._name := _name
end;

procedure string_num_definition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor subprogram_body.Create;
begin
  
end;

constructor subprogram_body.Create(_subprogram_code: statement_list; _subprogram_defs: declarations);
begin
  self._subprogram_code := _subprogram_code;
  self._subprogram_defs := _subprogram_defs
end;

procedure subprogram_body.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor switch_stmt.Create;
begin
  
end;

constructor switch_stmt.Create(_condition: expression; _stmt: statement; _Part: SwitchPartType);
begin
  self._condition := _condition;
  self._stmt := _stmt;
  self._Part := _Part
end;

procedure switch_stmt.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor template_param_list.Create;
begin
  self._params_list := new List<type_definition>();  
end;

constructor template_param_list.Create(_params_list: List<type_definition>);
begin
  self._params_list := _params_list
end;

procedure template_param_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor template_type_reference.Create;
begin
  
end;

constructor template_type_reference.Create(_name: named_type_reference; _params_list: template_param_list);
begin
  self._name := _name;
  self._params_list := _params_list
end;

procedure template_type_reference.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor token_info.Create;
begin
  
end;

constructor token_info.Create(_text: string);
begin
  self._text := _text;
end;

procedure token_info.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor token_taginfo.Create;
begin
  
end;

constructor token_taginfo.Create(_tag: object);
begin
  self._tag := _tag;
end;

procedure token_taginfo.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor try_except_statement.Create;
begin
  
end;

constructor try_except_statement.Create(_on_except: on_exception_list; _else_statements: statement_list);
begin
  self._on_except := _on_except;
  self._else_statements := _else_statements
end;

procedure try_except_statement.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor try_finally_statement.Create;
begin
  
end;

constructor try_finally_statement.Create(_finally_statements: statement_list);
begin
  self._finally_statements := _finally_statements
end;

procedure try_finally_statement.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor try_handler.Create;
begin
  
end;

procedure try_handler.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor try_handler_except.Create;
begin
  
end;

constructor try_handler_except.Create(_except_block: exception_block);
begin
  self._except_block := _except_block
end;

procedure try_handler_except.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor try_handler_finally.Create;
begin
  
end;

constructor try_handler_finally.Create(_stmt_list: statement_list);
begin
  self._stmt_list := _stmt_list;
end;

procedure try_handler_finally.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor try_statement.Create;
begin
  
end;

constructor try_statement.Create(_statements: statement_list);
begin
  self._statements := _statements;
end;

procedure try_statement.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor try_stmt.Create;
begin
  
end;

constructor try_stmt.Create(_stmt_list: statement_list; _handler: try_handler);
begin
  self._stmt_list := _stmt_list;
  self._handler := _handler
end;

procedure try_stmt.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor type_declaration.Create;
begin
  
end;

constructor type_declaration.Create(_type_name: ident; _type_def: type_definition);
begin
  self._type_name := _type_name;
  self._type_def := _type_def
end;

procedure type_declaration.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor type_declarations.Create;
begin
  self._types_decl := new List<type_declaration>();  
end;

constructor type_declarations.Create(_types_decl: List<type_declaration>);
begin
  self._types_decl := _types_decl
end;

procedure type_declarations.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor type_definition.Create;
begin
  
end;

constructor type_definition.Create(_attr_list: type_definition_attr_list);
begin
  self._attr_list := _attr_list;
end;

procedure type_definition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor type_definition_attr.Create;
begin
  
end;

constructor type_definition_attr.Create(_attr: type_definition_attribute);
begin
  self._attr := _attr;
end;

procedure type_definition_attr.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor type_definition_attr_list.Create;
begin
  self._attributes := new List<type_definition_attr>();  
end;

constructor type_definition_attr_list.Create(_attributes: List<type_definition_attr>);
begin
  self._attributes := _attributes
end;

procedure type_definition_attr_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor type_definition_list.Create;
begin
  self._defs := new List<type_definition>();  
end;

constructor type_definition_list.Create(_defs: List<type_definition>);
begin
  self._defs := _defs
end;

procedure type_definition_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor typecast_node.Create;
begin
  
end;

constructor typecast_node.Create(_expr: addressed_value; _type_def: type_definition; _cast_op: op_typecast);
begin
  self._expr := _expr;
  self._type_def := _type_def;
  self._cast_op := _cast_op
end;

procedure typecast_node.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor typed_const_definition.Create;
begin
  
end;

constructor typed_const_definition.Create(_const_type: type_definition);
begin
  self._const_type := _const_type
end;

procedure typed_const_definition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor typed_parametres.Create;
begin
  
end;

constructor typed_parametres.Create(_idents: ident_list; _vars_type: type_definition; _param_kind: parametr_kind; _inital_value: expression);
begin
  self._idents := _idents;
  self._vars_type := _vars_type;
  self._param_kind := _param_kind;
  self._inital_value := _inital_value
end;

procedure typed_parametres.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor typeof_operator.Create;
begin
  
end;

constructor typeof_operator.Create(_type_name: named_type_reference);
begin
  self._type_name := _type_name;
end;

procedure typeof_operator.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor uint64_const.Create;
begin
  
end;

constructor uint64_const.Create(_val: UInt64);
begin
  self._val := _val;
end;

procedure uint64_const.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor un_expr.Create;
begin
  
end;

constructor un_expr.Create(_subnode: expression; _operation_type: Operators);
begin
  self._subnode := _subnode;
  self._operation_type := _operation_type
end;

procedure un_expr.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor unit_module.Create;
begin
  
end;

constructor unit_module.Create(_unit_name: SyntaxTree.unit_name; _interface_part: interface_node; _implementation_part: implementation_node; _initialization_part: statement_list; _finalization_part: statement_list);
begin
  self._unit_name := _unit_name;
  self._interface_part := _interface_part;
  self._implementation_part := _implementation_part;
  self._initialization_part := _initialization_part;
  self._finalization_part := _finalization_part
end;

procedure unit_module.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor unit_name.Create;
begin
  
end;

constructor unit_name.Create(_idunit_name: ident; _HeaderKeyword: UnitHeaderKeyword);
begin
  self._idunit_name := _idunit_name;
  self._HeaderKeyword := _HeaderKeyword
end;

procedure unit_name.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor unit_or_namespace.Create;
begin
  
end;

constructor unit_or_namespace.Create(_name: ident_list);
begin
  self._name := _name
end;

procedure unit_or_namespace.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor uses_list.Create;
begin
  self._units := new List<unit_or_namespace>();
end;

constructor uses_list.Create(_units: List<unit_or_namespace>);
begin
  self._units := _units;
end;

procedure uses_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor uses_unit_in.Create;
begin
  
end;

constructor uses_unit_in.Create(_in_file: string_const);
begin
  self._in_file := _in_file;
end;

procedure uses_unit_in.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor using_list.Create;
begin
  self._namespaces := new List<unit_or_namespace>();  
end;

constructor using_list.Create(_namespaces: List<unit_or_namespace>);
begin
  self._namespaces := _namespaces
end;

procedure using_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor var_def_list.Create;
begin
  self._vars := new List<var_def_statement>();  
end;

constructor var_def_list.Create(_vars: List<var_def_statement>);
begin
  self._vars := _vars
end;

procedure var_def_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor var_def_statement.Create;
begin
  
end;

constructor var_def_statement.Create(_vars: ident_list; _vars_type: type_definition; _inital_value: expression; _var_attr: type_definition_attribute; _is_event: boolean);
begin
  self._vars := _vars;
  self._vars_type := _vars_type;
  self._inital_value := _inital_value;
  self._var_attr := _var_attr;
  self._is_event := _is_event
end;

procedure var_def_statement.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor var_statement.Create;
begin
  
end;

constructor var_statement.Create(_var_def: var_def_statement);
begin
  self._var_def := _var_def;
end;

procedure var_statement.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor variable_definitions.Create;
begin
  self._var_definitions := new List<var_def_statement>();  
end;

constructor variable_definitions.Create(_var_definitions: List<var_def_statement>);
begin
  self._var_definitions := _var_definitions
end;

procedure variable_definitions.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor variant.Create;
begin
  
end;

constructor variant.Create(_vars: ident_list; _vars_type: type_definition);
begin
  self._vars := _vars;
  self._vars_type := _vars_type
end;

procedure variant.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor variant_list.Create;
begin
  self._vars := new List<variant>();  
end;

constructor variant_list.Create(_vars: List<variant>);
begin
  self._vars := _vars
end;

procedure variant_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor variant_record_type.Create;
begin
  
end;

constructor variant_record_type.Create(_var_name: ident; _var_type: type_definition; _vars: variant_types);
begin
  self._var_name := _var_name;
  self._var_type := _var_type;
  self._vars := _vars
end;

procedure variant_record_type.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor variant_type.Create;
begin
  
end;

constructor variant_type.Create(_case_exprs: expression_list; _parts: record_type_parts);
begin
  self._case_exprs := _case_exprs;
  self._parts := _parts
end;

procedure variant_type.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor variant_types.Create;
begin
   self._vars := new List<variant_type>();  
end;

constructor variant_types.Create(_vars: List<variant_type>);
begin
  self._vars := _vars
end;

procedure variant_types.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor where_definition.Create;
begin
  
end;

constructor where_definition.Create(_names: ident_list; _types: type_definition_list; _constructor_specific_params: type_definition_list);
begin
  self._names := _names;
  self._types := _types;
  self._constructor_specific_params := _constructor_specific_params
end;

procedure where_definition.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor where_definition_list.Create;
begin
  self._defs := new List<where_definition>();  
end;

constructor where_definition_list.Create(_defs: List<where_definition>);
begin
  self._defs := _defs
end;

procedure where_definition_list.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor while_node.Create;
begin
  
end;

constructor while_node.Create(_expr: expression; _statements: statement; _CycleType: WhileCycleType);
begin
  self._expr := _expr;
  self._statements := _statements;
  self._CycleType := _CycleType
end;

procedure while_node.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor with_statement.Create;
begin
  
end;

constructor with_statement.Create(_what_do: statement; _do_with: expression_list);
begin
  self._what_do := _what_do;
  self._do_with := _do_with
end;

procedure with_statement.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor write_accessor_name.Create;
begin
  
end;

constructor write_accessor_name.Create(_accessor_name: ident);
begin
  self._accessor_name := _accessor_name
end;

procedure write_accessor_name.visit(visitor: IVisitor);
begin
  visitor.visit(self);
end;


constructor OperatorServices.Create;
begin
  
end;

function OperatorServices.IsAssigmentOperator(&Operator: Operators): boolean;
begin
  
end;

function OperatorServices.ToString(&Operator: Operators; Language: LanguageId): string;
begin
  
end;


constructor Utils.Create;
begin
  
end;

function Utils.IdentListToString(list: List<ident>; separator: string): string;
begin
  
end;


procedure IVisitor.visit(_access_modifer_node: access_modifer_node);
begin

end;

procedure IVisitor.visit(_addressed_value: addressed_value);
begin

end;

procedure IVisitor.visit(_addressed_value_funcname: addressed_value_funcname);
begin
  
end;

procedure IVisitor.visit(_array_const: array_const);
begin
  
end;

procedure IVisitor.visit(_array_of_const_type_definition: array_of_const_type_definition);
begin
  
end;

procedure IVisitor.visit(_array_of_named_type_definition: array_of_named_type_definition);
begin
  
end;

procedure IVisitor.visit(_array_size: array_size);
begin
  
end;

procedure IVisitor.visit(_array_type: array_type);
begin
  
end;

procedure IVisitor.visit(_assign: assign);
begin
  
end;

procedure IVisitor.visit(_bin_expr: bin_expr);
begin
  
end;

procedure IVisitor.visit(_block: block);
begin
  
end;

procedure IVisitor.visit(_bool_const: bool_const);
begin
  
end;

procedure IVisitor.visit(_c_for_cycle: c_for_cycle);
begin
  
end;

procedure IVisitor.visit(_c_module: c_module);
begin
  
end;

procedure IVisitor.visit(_c_scalar_type: c_scalar_type);
begin
  
end;

procedure IVisitor.visit(_case_node: case_node);
begin
  
end;

procedure IVisitor.visit(_case_variant: case_variant);
begin
  
end;

procedure IVisitor.visit(_case_variants: case_variants);
begin
  
end;

procedure IVisitor.visit(_char_const: char_const);
begin
  
end;

procedure IVisitor.visit(_class_body: class_body);
begin
  
end;

procedure IVisitor.visit(_class_definition: class_definition);
begin
  
end;

procedure IVisitor.visit(_class_members: class_members);
begin
  
end;

procedure IVisitor.visit(_class_predefinition: class_predefinition);
begin
  
end;

procedure IVisitor.visit(_compilation_unit: compilation_unit);
begin
  
end;

procedure IVisitor.visit(_compiler_directive: compiler_directive);
begin
  
end;

procedure IVisitor.visit(_compiler_directive_if: compiler_directive_if);
begin
  
end;

procedure IVisitor.visit(_compiler_directive_list: compiler_directive_list);
begin
  
end;

procedure IVisitor.visit(_const_definition: const_definition);
begin
  
end;

procedure IVisitor.visit(_const_node: const_node);
begin
  
end;

procedure IVisitor.visit(_constructor: &constructor);
begin
  
end;

procedure IVisitor.visit(_consts_definitions_list: consts_definitions_list);
begin
  
end;

procedure IVisitor.visit(_declaration: declaration);
begin
  
end;

procedure IVisitor.visit(_declarations: declarations);
begin
  
end;

procedure IVisitor.visit(_declarations_as_statement: declarations_as_statement);
begin
  
end;

procedure IVisitor.visit(_default_indexer_property_node: default_indexer_property_node);
begin
  
end;

procedure IVisitor.visit(_dereference: dereference);
begin
  
end;

procedure IVisitor.visit(_destructor: &destructor);
begin
  
end;

procedure IVisitor.visit(_diap_expr: diap_expr);
begin
  
end;

procedure IVisitor.visit(_diapason: diapason);
begin
  
end;

procedure IVisitor.visit(_diapason_expr: diapason_expr);
begin
  
end;

procedure IVisitor.visit(_documentation_comment_list: documentation_comment_list);
begin
  
end;

procedure IVisitor.visit(_documentation_comment_section: documentation_comment_section);
begin
  
end;

procedure IVisitor.visit(_documentation_comment_tag: documentation_comment_tag);
begin
  
end;

procedure IVisitor.visit(_documentation_comment_tag_param: documentation_comment_tag_param);
begin
  
end;

procedure IVisitor.visit(_dot_node: dot_node);
begin
  
end;

procedure IVisitor.visit(_double_const: double_const);
begin
  
end;

procedure IVisitor.visit(_empty_statement: empty_statement);
begin
  
end;

procedure IVisitor.visit(_enum_type_definition: enum_type_definition);
begin
  
end;

procedure IVisitor.visit(_enumerator: enumerator);
begin
  
end;

procedure IVisitor.visit(_enumerator_list: enumerator_list);
begin
  
end;

procedure IVisitor.visit(_exception_block: exception_block);
begin
  
end;

procedure IVisitor.visit(_exception_handler: exception_handler);
begin
  
end;

procedure IVisitor.visit(_exception_handler_list: exception_handler_list);
begin
  
end;

procedure IVisitor.visit(_exception_ident: exception_ident);
begin
  
end;

procedure IVisitor.visit(_expression: expression);
begin
  
end;

procedure IVisitor.visit(_expression_as_statement: expression_as_statement);
begin
  
end;

procedure IVisitor.visit(_expression_list: expression_list);
begin
  
end;

procedure IVisitor.visit(_external_directive: external_directive);
begin
  
end;

procedure IVisitor.visit(_file_type: file_type);
begin
  
end;

procedure IVisitor.visit(_file_type_definition: file_type_definition);
begin
  
end;

procedure IVisitor.visit(_for_node: for_node);
begin
  
end;

procedure IVisitor.visit(_foreach_stmt: foreach_stmt);
begin
  
end;

procedure IVisitor.visit(_formal_parametres: formal_parametres);
begin
  
end;

procedure IVisitor.visit(_format_expr: format_expr);
begin

end;

procedure IVisitor.visit(_function_header: function_header);
begin
  
end;

procedure IVisitor.visit(_get_address: get_address);
begin
  
end;

procedure IVisitor.visit(_goto_statement: goto_statement);
begin
  
end;

procedure IVisitor.visit(_hex_constant: hex_constant);
begin
  
end;

procedure IVisitor.visit(_ident: ident);
begin
  
end;

procedure IVisitor.visit(_ident_list: ident_list);
begin
  
end;

procedure IVisitor.visit(_if_node: if_node);
begin
  
end;

procedure IVisitor.visit(_implementation_node: implementation_node);
begin
  
end;

procedure IVisitor.visit(_index_property: index_property);
begin
  
end;

procedure IVisitor.visit(_indexer: indexer);
begin
  
end;

procedure IVisitor.visit(_indexers_types: indexers_types);
begin
  
end;

procedure IVisitor.visit(_inherited_ident: inherited_ident);
begin
  
end;

procedure IVisitor.visit(_inherited_message: inherited_message);
begin
  
end;

procedure IVisitor.visit(_inherited_method_call: inherited_method_call);
begin
  
end;

procedure IVisitor.visit(_initfinal_part: initfinal_part);
begin
  
end;

procedure IVisitor.visit(_int32_const: int32_const);
begin
  
end;

procedure IVisitor.visit(_int64_const: int64_const);
begin
  
end;

procedure IVisitor.visit(_interface_node: interface_node);
begin
  
end;

procedure IVisitor.visit(_jump_stmt: jump_stmt);
begin
  
end;

procedure IVisitor.visit(_known_type_definition: known_type_definition);
begin
  
end;

procedure IVisitor.visit(_known_type_ident: known_type_ident);
begin
  
end;

procedure IVisitor.visit(_label_definitions: label_definitions);
begin
  
end;

procedure IVisitor.visit(_labeled_statement: labeled_statement);
begin
  
end;

procedure IVisitor.visit(_literal: literal);
begin
  
end;

procedure IVisitor.visit(_literal_const_line: literal_const_line);
begin
  
end;

procedure IVisitor.visit(_lock_stmt: lock_stmt);
begin
  
end;

procedure IVisitor.visit(_loop_stmt: loop_stmt);
begin
  
end;

procedure IVisitor.visit(_method_call: method_call);
begin
  
end;

procedure IVisitor.visit(_method_name: method_name);
begin
  
end;

procedure IVisitor.visit(_named_type_reference: named_type_reference);
begin
  
end;

procedure IVisitor.visit(_named_type_reference_list: named_type_reference_list);
begin
  
end;

procedure IVisitor.visit(_new_expr: new_expr);
begin
  
end;

procedure IVisitor.visit(_nil_const: nil_const);
begin
  
end;

procedure IVisitor.visit(_oberon_exit_stmt: oberon_exit_stmt);
begin
  
end;

procedure IVisitor.visit(_oberon_ident_with_export_marker: oberon_ident_with_export_marker);
begin
  
end;

procedure IVisitor.visit(_oberon_import_module: oberon_import_module);
begin
  
end;

procedure IVisitor.visit(_oberon_module: oberon_module);
begin
  
end;

procedure IVisitor.visit(_oberon_procedure_header: oberon_procedure_header);
begin
  
end;

procedure IVisitor.visit(_oberon_procedure_receiver: oberon_procedure_receiver);
begin
  
end;

procedure IVisitor.visit(_oberon_withstmt: oberon_withstmt);
begin
  
end;

procedure IVisitor.visit(_oberon_withstmt_guardstat: oberon_withstmt_guardstat);
begin
  
end;

procedure IVisitor.visit(_oberon_withstmt_guardstat_list: oberon_withstmt_guardstat_list);
begin
  
end;

procedure IVisitor.visit(_on_exception: on_exception);
begin
  
end;

procedure IVisitor.visit(_on_exception_list: on_exception_list);
begin
  
end;

procedure IVisitor.visit(_op_type_node: op_type_node);
begin
  
end;

procedure IVisitor.visit(_operator_name_ident: operator_name_ident);
begin
  
end;

procedure IVisitor.visit(_pascal_set_constant: pascal_set_constant);
begin
  
end;

procedure IVisitor.visit(_proc_block: proc_block);
begin
  
end;

procedure IVisitor.visit(_procedure_attribute: procedure_attribute);
begin
  
end;

procedure IVisitor.visit(_procedure_attributes_list: procedure_attributes_list);
begin
  
end;

procedure IVisitor.visit(_procedure_call: procedure_call);
begin
  
end;

procedure IVisitor.visit(_procedure_definition: procedure_definition);
begin
  
end;

procedure IVisitor.visit(_procedure_header: procedure_header);
begin
  
end;

procedure IVisitor.visit(_program_body: program_body);
begin
  
end;

procedure IVisitor.visit(_program_module: program_module);
begin
  
end;

procedure IVisitor.visit(_program_name: program_name);
begin
  
end;

procedure IVisitor.visit(_program_tree: program_tree);
begin
  
end;

procedure IVisitor.visit(_property_accessors: property_accessors);
begin
  
end;

procedure IVisitor.visit(_property_array_default: property_array_default);
begin
  
end;

procedure IVisitor.visit(_property_interface: property_interface);
begin
  
end;

procedure IVisitor.visit(_property_parameter: property_parameter);
begin
  
end;

procedure IVisitor.visit(_property_parameter_list: property_parameter_list);
begin
  
end;

procedure IVisitor.visit(_question_colon_expression: question_colon_expression);
begin
  
end;

procedure IVisitor.visit(_raise_statement: raise_statement);
begin
  
end;

procedure IVisitor.visit(_raise_stmt: raise_stmt);
begin
  
end;

procedure IVisitor.visit(_read_accessor_name: read_accessor_name);
begin
  
end;

procedure IVisitor.visit(_record_const: record_const);
begin
  
end;

procedure IVisitor.visit(_record_const_definition: record_const_definition);
begin
  
end;

procedure IVisitor.visit(_record_type: record_type);
begin
  
end;

procedure IVisitor.visit(_record_type_parts: record_type_parts);
begin
  
end;

procedure IVisitor.visit(_ref_type: ref_type);
begin
  
end;

procedure IVisitor.visit(_repeat_node: repeat_node);
begin
  
end;

procedure IVisitor.visit(_roof_dereference: roof_dereference);
begin
  
end;

procedure IVisitor.visit(_set_type_definition: set_type_definition);
begin
  
end;

procedure IVisitor.visit(_sharp_char_const: sharp_char_const);
begin
  
end;

procedure IVisitor.visit(_simple_const_definition: simple_const_definition);
begin
  
end;

procedure IVisitor.visit(_simple_property: simple_property);
begin
  
end;

procedure IVisitor.visit(_sizeof_operator: sizeof_operator);
begin
  
end;

procedure IVisitor.visit(_statement: statement);
begin
  
end;

procedure IVisitor.visit(_statement_list: statement_list);
begin
  
end;

procedure IVisitor.visit(_string_const: string_const);
begin
  
end;

procedure IVisitor.visit(_string_num_definition: string_num_definition);
begin
  
end;

procedure IVisitor.visit(_subprogram_body: subprogram_body);
begin
  
end;

procedure IVisitor.visit(_switch_stmt: switch_stmt);
begin
  
end;

procedure IVisitor.visit(_syntax_tree_node: syntax_tree_node);
begin
  
end;

procedure IVisitor.visit(_template_param_list: template_param_list);
begin
  
end;

procedure IVisitor.visit(_template_type_reference: template_type_reference);
begin
  
end;

procedure IVisitor.visit(_token_info: token_info);
begin
  
end;

procedure IVisitor.visit(_token_taginfo: token_taginfo);
begin
  
end;

procedure IVisitor.visit(_try_except_statement: try_except_statement);
begin
  
end;

procedure IVisitor.visit(_try_finally_statement: try_finally_statement);
begin
  
end;

procedure IVisitor.visit(_try_handler: try_handler);
begin
  
end;

procedure IVisitor.visit(_try_handler_except: try_handler_except);
begin
  
end;

procedure IVisitor.visit(_try_handler_finally: try_handler_finally);
begin
  
end;

procedure IVisitor.visit(_try_statement: try_statement);
begin
  
end;

procedure IVisitor.visit(_try_stmt: try_stmt);
begin
  
end;

procedure IVisitor.visit(_type_declaration: type_declaration);
begin
  
end;

procedure IVisitor.visit(_type_declarations: type_declarations);
begin
  
end;

procedure IVisitor.visit(_type_definition: type_definition);
begin
  
end;

procedure IVisitor.visit(_type_definition_attr: type_definition_attr);
begin
  
end;

procedure IVisitor.visit(_type_definition_attr_list: type_definition_attr_list);
begin
  
end;

procedure IVisitor.visit(_type_definition_list: type_definition_list);
begin
  
end;

procedure IVisitor.visit(_typecast_node: typecast_node);
begin
  
end;

procedure IVisitor.visit(_typed_const_definition: typed_const_definition);
begin
  
end;

procedure IVisitor.visit(_typed_parametres: typed_parametres);
begin
  
end;

procedure IVisitor.visit(_typeof_operator: typeof_operator);
begin
  
end;

procedure IVisitor.visit(_uint64_const: uint64_const);
begin
  
end;

procedure IVisitor.visit(_un_expr: un_expr);
begin
  
end;

procedure IVisitor.visit(_unit_module: unit_module);
begin
  
end;

procedure IVisitor.visit(_unit_name: unit_name);
begin
  
end;

procedure IVisitor.visit(_unit_or_namespace: unit_or_namespace);
begin
  
end;

procedure IVisitor.visit(_uses_list: uses_list);
begin
  
end;

procedure IVisitor.visit(_uses_unit_in: uses_unit_in);
begin
  
end;

procedure IVisitor.visit(_using_list: using_list);
begin
  
end;

procedure IVisitor.visit(_var_def_list: var_def_list);
begin
  
end;

procedure IVisitor.visit(_var_def_statement: var_def_statement);
begin
  
end;

procedure IVisitor.visit(_var_statement: var_statement);
begin
  
end;

procedure IVisitor.visit(_variable_definitions: variable_definitions);
begin
  
end;

procedure IVisitor.visit(_variant: variant);
begin
  
end;

procedure IVisitor.visit(_variant_list: variant_list);
begin
  
end;

procedure IVisitor.visit(_variant_record_type: variant_record_type);
begin
  
end;

procedure IVisitor.visit(_variant_type: variant_type);
begin
  
end;

procedure IVisitor.visit(_variant_types: variant_types);
begin
  
end;

procedure IVisitor.visit(_where_definition: where_definition);
begin
  
end;

procedure IVisitor.visit(_where_definition_list: where_definition_list);
begin
  
end;

procedure IVisitor.visit(_while_node: while_node);
begin
  
end;

procedure IVisitor.visit(_with_statement: with_statement);
begin
  
end;

procedure IVisitor.visit(_write_accessor_name: write_accessor_name);
begin
  
end;


constructor access_modifer_node.Create;
begin
  
end;

constructor access_modifer_node.Create(_access_level: access_modifer);
begin
  
end;

procedure access_modifer_node.visit(visitor: IVisitor);
begin
  
end;

end.