/*
 File: yacco2_terminals.cpp
 Date and Time: Sun Apr 20 13:54:30 2014 
*/
#include "yacco2_terminals.h"
  using namespace NS_yacco2_terminals;
  using namespace NS_yacco2_T_enum;
T_option_t::
T_option_t()
 T_CTOR("option-t",T_Enum::T_T_option_t_,0,true,false){}
T_option_p::
T_option_p()
 T_CTOR("option-p",T_Enum::T_T_option_p_,0,true,false){}
T_option_err::
T_option_err()
 T_CTOR("option-err",T_Enum::T_T_option_err_,0,true,false){}

    T_esc_seq::
    T_esc_seq(const char* Esc_data)
      T_CTOR("esc-seq",T_Enum::T_T_esc_seq_,0,true,false)
      {
        esc_data_ += Esc_data;
      }
     std::string* T_esc_seq::esc_data(){return &esc_data_;};
  
    T_eol::
    T_eol() 
      T_CTOR("eol",T_Enum::T_T_eol_,0,false,false)
     {}
    T_eol eol__;
    yacco2::CAbs_lr1_sym* NS_yacco2_terminals::PTR_eol__ = &eol__;
  
    T_basic_char::
    T_basic_char(CAbs_lr1_sym* Basic_char)
      T_CTOR("basic-char",T_Enum::T_T_basic_char_,&dtor_T_basic_char,false,false)
     {basic_char_ = Basic_char;}
    void T_basic_char::zero_out_basic_char(){basic_char_ = 0;}
    CAbs_lr1_sym* T_basic_char::basic_char()const{return basic_char_;}
  void T_basic_char::dtor_T_basic_char(yacco2::VOIDP This,yacco2::VOIDP P){
 T_basic_char* R = (T_basic_char*)(This);
 
	  if(R->basic_char_!=0)
    delete R->basic_char();
  
}

    T_raw_char::
    T_raw_char(CAbs_lr1_sym* Raw_char)
     T_CTOR("raw-char",T_Enum::T_T_raw_char_,0,false,false)
     {raw_char_ = Raw_char;}
    void T_raw_char::zero_out_raw_char(){raw_char_ = 0;}
    CAbs_lr1_sym* T_raw_char::raw_char()const{return raw_char_;}
  void T_raw_char::dtor_T_raw_char(yacco2::VOIDP This,yacco2::VOIDP P){
 T_raw_char* R = (T_raw_char*)(This);
 
	  if(R->raw_char_!=0)
    delete R->raw_char();
  
}

    T_comment::
    T_comment(const std::string& Comment_data) 
      T_CTOR("comment",T_Enum::T_T_comment_,0,false,false)
      {comment_data_ = Comment_data;}
    std::string* T_comment::comment_data(){return &comment_data_;}
	
    T_ws::
    T_ws(const std::string& Ws_data) 
      T_CTOR("ws",T_Enum::T_T_ws_,0,false,false)
      {ws_data_+= Ws_data;}
    T_ws::
    T_ws() 
      T_CTOR("ws",T_Enum::T_T_ws_,0,false,false)
     {}
    std::string* T_ws::ws_data(){return &ws_data_;}
    T_ws ws__;
    yacco2::CAbs_lr1_sym* NS_yacco2_terminals::PTR_ws__ = &ws__;
  
    T_angled_string::T_angled_string(const string& Angled_string) 
      T_CTOR("angled-string",T_Enum::T_T_angled_string_,0,false,false)
      {angled_string_ = Angled_string;}
    std::string* T_angled_string::angled_string(){return &angled_string_;}
  
    T_c_literal::T_c_literal(const string& C_literal) 
      T_CTOR("c-literal",T_Enum::T_T_c_literal_,0,false,false)
      {c_literal_ = C_literal;}
    std::string* T_c_literal::c_literal(){return &c_literal_;}
  
    T_c_string::T_c_string(const std::string& C_string) 
      T_CTOR("c-string",T_Enum::T_T_c_string_,0,false,false)
      {c_string_ = C_string;}
    std::string* T_c_string::c_string(){return &c_string_;}
  
    T_xc_str::T_xc_str(const std::string& C_string) 
      T_CTOR("xc-str",T_Enum::T_T_xc_str_,0,false,false)
      {c_string_ = C_string;}
    std::string* T_xc_str::c_string(){return &c_string_;}
  
    T_unquoted_string::T_unquoted_string(const std::string& String) 
      T_CTOR("unquoted-string",T_Enum::T_T_unquoted_string_,0,false,false)
      {unquoted_string_ = String;}
    std::string* T_unquoted_string::unquoted_string(){return &unquoted_string_;}
  
    T_file_inclusion::T_file_inclusion
      (T_c_string* File_name,CAbs_lr1_sym* Error)
      T_CTOR("file-inclusion",T_Enum::T_T_file_inclusion_,0,false,false)
      {file_name_ = File_name;
      error_sym_ = Error;}
    CAbs_lr1_sym* T_file_inclusion::error_sym(){
      return error_sym_;
    }
    void T_file_inclusion::error_sym(CAbs_lr1_sym* Error){
      error_sym_ = Error;
    }
    T_c_string* T_file_inclusion::file_name(){return file_name_;}
    T_file_inclusion::~T_file_inclusion(){delete file_name_;delete error_sym_;}
  
    T_identifier::T_identifier(yacco2::KCHARP Identifier) 
      T_CTOR("identifier",T_Enum::T_T_identifier_,0,false,false)
      {identifier_ = Identifier;}
    std::string* T_identifier::identifier(){return &identifier_;}
  
    T_int_no::
    T_int_no(long S_no) 
       T_CTOR("int-no",T_Enum::T_T_int_no_,0,false,false)
      {no_ = S_no;}
    long T_int_no::no(){return no_;};
  
    T_raw_characters::T_raw_characters() 
      T_CTOR("#raw-characters",T_Enum::T_T_raw_characters_,&dtor_T_raw_characters,false,false)
      {rc_phrase_ = 0;}
    T_rc_phrase* T_raw_characters::rc_phrase(){return rc_phrase_;}
    void T_raw_characters::rc_phrase(T_rc_phrase* Phrase){rc_phrase_ = Phrase;}
  void T_raw_characters::dtor_T_raw_characters(yacco2::VOIDP This,yacco2::VOIDP P){
 T_raw_characters* R = (T_raw_characters*)(This);
 
	  if(R->rc_phrase_!=0)
    delete R->rc_phrase_;
  
}

    T_lr1_constant_symbols::T_lr1_constant_symbols() 
T_CTOR("#lr1-constant-symbols",T_Enum::T_T_lr1_constant_symbols_,&dtor_T_lr1_constant_symbols,false,false)
      {lr1_k_phrase_ = 0;}
    T_lr1_k_phrase* T_lr1_constant_symbols::lr1_k_phrase(){return lr1_k_phrase_;}
    void T_lr1_constant_symbols::lr1_k_phrase(T_lr1_k_phrase* Phrase){lr1_k_phrase_ = Phrase;}
  void T_lr1_constant_symbols::dtor_T_lr1_constant_symbols(yacco2::VOIDP This,yacco2::VOIDP P){
 T_lr1_constant_symbols* R = (T_lr1_constant_symbols*)(This);
 
    if(R->lr1_k_phrase_ != 0)
    delete R->lr1_k_phrase_;
  
}

    T_error_symbols::T_error_symbols() 
T_CTOR("#error-symbols",T_Enum::T_T_error_symbols_,&dtor_T_error_symbols,false,false)
      {error_symbols_phrase_ = 0;}
    T_error_symbols_phrase* 
    T_error_symbols::error_symbols_phrase(){return error_symbols_phrase_;}
    void T_error_symbols::
    error_symbols_phrase(T_error_symbols_phrase* Phrase){error_symbols_phrase_ = Phrase;}
  void T_error_symbols::dtor_T_error_symbols(yacco2::VOIDP This,yacco2::VOIDP P){
 T_error_symbols* R = (T_error_symbols*)(This);
 
    if(R->error_symbols_phrase_ != 0)
    delete R->error_symbols_phrase_;
  
}
T_eocode::
T_eocode()
 T_CTOR("#***",T_Enum::T_T_eocode_,0,false,false){}
T_AD::
T_AD()
 T_CTOR("#AD",T_Enum::T_T_AD_,0,false,false){}
T_AB::
T_AB()
 T_CTOR("#AB",T_Enum::T_T_AB_,0,false,false){}

    T_parallel_la_boundary::T_parallel_la_boundary() 
      T_CTOR("#parallel-la-boundary",T_Enum::T_T_parallel_la_boundary_,0,false,false)
      {la_supplier_ = 0;
      cweb_marker_=0;
      }
    void T_parallel_la_boundary::cweb_la_srce_expr(const char* Srce_expr){
      cweb_la_srce_expr_.append(Srce_expr);
    }
    std::string* T_parallel_la_boundary::cweb_la_srce_expr(){
      return &cweb_la_srce_expr_;
    }
      
    yacco2::TOKEN_GAGGLE* T_parallel_la_boundary::la_supplier(){return la_supplier_;}
    void T_parallel_la_boundary::la_supplier(yacco2::TOKEN_GAGGLE* Supplier)
        {la_supplier_ = Supplier;}
    
    void T_parallel_la_boundary::add_cweb_marker(AST* Cweb){
      cweb_marker_ = Cweb;
    }
    
    AST* T_parallel_la_boundary::cweb_marker(){
      return cweb_marker_;
    }
    
    std::set<T_in_stbl*>* T_parallel_la_boundary::la_first_set()
    {return &la_first_set_;}
    void T_parallel_la_boundary::la_first_set(std::set<T_in_stbl*>& Supplier)
    {
		la_first_set_.insert(Supplier.begin(),Supplier.end());
    }
  
    T_arbitrator_code::T_arbitrator_code() 
      T_CTOR("#arbitrator-code",T_Enum::T_T_arbitrator_code_,0,false,false)
      {syntax_code_ = 0;cweb_marker_=0;}
    T_syntax_code* T_arbitrator_code::syntax_code(){return syntax_code_;}
    void T_arbitrator_code::syntax_code(T_syntax_code* Stc){syntax_code_ = Stc;}
    void T_arbitrator_code::add_cweb_marker(AST* Cweb){
      cweb_marker_ = Cweb;
    }
    AST* T_arbitrator_code::cweb_marker(){
      return cweb_marker_;
    }
  
    T_parallel_parser::T_parallel_parser() 
 T_CTOR("#parallel-parser",T_Enum::T_T_parallel_parser_,&dtor_T_parallel_parser,false,false)
      {parallel_parser_phrase_ = 0;}
    T_parallel_parser_phrase* 
    T_parallel_parser::parallel_parser_phrase(){return parallel_parser_phrase_;}
    void T_parallel_parser::parallel_parser_phrase
    (T_parallel_parser_phrase* Phrase){parallel_parser_phrase_ = Phrase;}
  void T_parallel_parser::dtor_T_parallel_parser(yacco2::VOIDP This,yacco2::VOIDP P){
 T_parallel_parser* R = (T_parallel_parser*)(This);
 
    if(R->parallel_parser_phrase_ != 0)
    delete R->parallel_parser_phrase_;
  
}

    T_parallel_thread_function::T_parallel_thread_function() 
 T_CTOR("#parallel-thread-function",T_Enum::T_T_parallel_thread_function_,0,false,false)
      {id_ = 0;cweb_marker_=0;}
    T_identifier* T_parallel_thread_function::identifier(){return id_;}
    void T_parallel_thread_function::identifier(T_identifier* Id){id_ = Id;}
    void T_parallel_thread_function::add_cweb_marker(AST* Cweb){
      cweb_marker_ = Cweb;
    }
    AST* T_parallel_thread_function::cweb_marker(){
      return cweb_marker_;
    }
  T_parallel_control_monitor::
T_parallel_control_monitor()
 T_CTOR("#parallel-control-monitor",T_Enum::T_T_parallel_control_monitor_,0,false,false){}

    T_fsm::T_fsm() 
     T_CTOR("#fsm",T_Enum::T_T_fsm_,&dtor_T_fsm,false,false)
      {fsm_phrase_ = 0;}
    T_fsm_phrase* T_fsm::fsm_phrase(){return fsm_phrase_;}
    void T_fsm::fsm_phrase(T_fsm_phrase* Phrase){fsm_phrase_ = Phrase;}
  void T_fsm::dtor_T_fsm(yacco2::VOIDP This,yacco2::VOIDP P){
 T_fsm* R = (T_fsm*)(This);
 
    if(R->fsm_phrase_ != 0)
    delete R->fsm_phrase_;
  
}
T_fsm_id::
T_fsm_id()
 T_CTOR("#fsm-id",T_Enum::T_T_fsm_id_,0,false,false){}
T_fsm_filename::
T_fsm_filename()
 T_CTOR("#fsm-filename",T_Enum::T_T_fsm_filename_,0,false,false){}
T_fsm_namespace::
T_fsm_namespace()
 T_CTOR("#fsm-namespace",T_Enum::T_T_fsm_namespace_,0,false,false){}
T_fsm_class::
T_fsm_class()
 T_CTOR("#fsm-class",T_Enum::T_T_fsm_class_,0,false,false){}
T_fsm_version::
T_fsm_version()
 T_CTOR("#fsm-version",T_Enum::T_T_fsm_version_,0,false,false){}
T_fsm_date::
T_fsm_date()
 T_CTOR("#fsm-date",T_Enum::T_T_fsm_date_,0,false,false){}
T_fsm_debug::
T_fsm_debug()
 T_CTOR("#fsm-debug",T_Enum::T_T_fsm_debug_,0,false,false){}
T_fsm_comments::
T_fsm_comments()
 T_CTOR("#fsm-comments",T_Enum::T_T_fsm_comments_,0,false,false){}

    T_terminals::T_terminals() 
      T_CTOR("#terminals",T_Enum::T_T_terminals_,&dtor_T_terminals,false,true)
      {terminals_phrase_ = 0;}
    T_terminals_phrase* T_terminals::terminals_phrase(){return terminals_phrase_;}
    void T_terminals::terminals_phrase(T_terminals_phrase* Phrase)
        {terminals_phrase_ = Phrase;}
  void T_terminals::dtor_T_terminals(yacco2::VOIDP This,yacco2::VOIDP P){
 T_terminals* R = (T_terminals*)(This);
 
    if(R->terminals_phrase_ != 0)
    delete R->terminals_phrase_;
  
}

    T_enumeration::T_enumeration() 
      T_CTOR("#T-enumeration",T_Enum::T_T_enumeration_,&dtor_T_enumeration,false,true)
      {enum_phrase_ = 0;}
    T_enum_phrase* T_enumeration::enum_phrase(){return enum_phrase_;}
    void T_enumeration::enum_phrase(T_enum_phrase* Phrase){enum_phrase_ = Phrase;}
  void T_enumeration::dtor_T_enumeration(yacco2::VOIDP This,yacco2::VOIDP P){
 T_enumeration* R = (T_enumeration*)(This);
 
    if(R->enum_phrase_ != 0)
    delete R->enum_phrase_;
  
}
T_file_name::
T_file_name()
 T_CTOR("#file-name",T_Enum::T_T_file_name_,0,false,false){}
T_name_space::
T_name_space()
 T_CTOR("#name-space",T_Enum::T_T_name_space_,0,false,false){}
T_sym_class::
T_sym_class()
 T_CTOR("#sym-class",T_Enum::T_T_sym_class_,0,false,false){}

    T_rules::T_rules() 
     T_CTOR("#rules",T_Enum::T_T_rules_,&dtor_T_rules,false,true)
      {rules_phrase_ = 0;}
    T_rules_phrase* T_rules::rules_phrase(){return rules_phrase_;}
    void T_rules::rules_phrase(T_rules_phrase* Phrase){rules_phrase_ = Phrase;}
  void T_rules::dtor_T_rules(yacco2::VOIDP This,yacco2::VOIDP P){
 T_rules* R = (T_rules*)(This);
 
    if(R->rules_phrase_ != 0)
    delete R->rules_phrase_;
  
}
T_lhs::
T_lhs()
 T_CTOR("#lhs",T_Enum::T_T_lhs_,0,false,false){}

    T_user_declaration::T_user_declaration() 
      T_CTOR("#user-declaration",T_Enum::T_T_user_declaration_,0,false,false)
      {syntax_code_ = 0;}
    T_syntax_code* T_user_declaration::syntax_code(){return syntax_code_;}
    void T_user_declaration::syntax_code(T_syntax_code* Stc){syntax_code_ = Stc;}
  
    T_user_prefix_declaration::T_user_prefix_declaration() 
  T_CTOR("#user-prefix-declaration",T_Enum::T_T_user_prefix_declaration_,0,false,false)
      {syntax_code_ = 0;}
    T_syntax_code* T_user_prefix_declaration::syntax_code(){return syntax_code_;}
    void T_user_prefix_declaration::syntax_code(T_syntax_code* Stc){syntax_code_ = Stc;}
  
    T_user_suffix_declaration::T_user_suffix_declaration() 
      T_CTOR("#user-suffix-declaration",T_Enum::T_T_user_suffix_declaration_,0,false,false)
      {syntax_code_ = 0;}
    T_syntax_code* T_user_suffix_declaration::syntax_code(){return syntax_code_;}
    void T_user_suffix_declaration::syntax_code(T_syntax_code* Stc){syntax_code_ = Stc;}
  
    T_constructor::T_constructor() 
      T_CTOR("#constructor",T_Enum::T_T_constructor_,0,false,false)
      {syntax_code_ = 0;}
    T_syntax_code* T_constructor::syntax_code(){return syntax_code_;}
    void T_constructor::syntax_code(T_syntax_code* Stc){syntax_code_ = Stc;}
  
    T_destructor::T_destructor() 
      T_CTOR("#destructor",T_Enum::T_T_destructor_,0,false,false)
      {syntax_code_ = 0;}
    T_syntax_code* T_destructor::syntax_code(){return syntax_code_;}
    void T_destructor::syntax_code(T_syntax_code* Stc){syntax_code_ = Stc;}
  
    T_op::T_op() 
      T_CTOR("#op",T_Enum::T_T_op_,0,false,false)
      {syntax_code_ = 0;}
    T_syntax_code* T_op::syntax_code(){return syntax_code_;}
    void T_op::syntax_code(T_syntax_code* Stc){syntax_code_ = Stc;}
  
    T_failed::T_failed() 
      T_CTOR("#failed",T_Enum::T_T_failed_,0,false,false)
      {syntax_code_ = 0;}
    T_syntax_code* T_failed::syntax_code(){return syntax_code_;}
    void T_failed::syntax_code(T_syntax_code* Stc){syntax_code_ = Stc;}
  
    T_user_implementation::T_user_implementation() 
 T_CTOR("#user-implementation",T_Enum::T_T_user_implementation_,0,false,false)
      {syntax_code_ = 0;}
    T_syntax_code* T_user_implementation::syntax_code(){return syntax_code_;}
    void T_user_implementation::syntax_code(T_syntax_code* Stc){syntax_code_ = Stc;}
  
    T_user_imp_tbl::T_user_imp_tbl() 
      T_CTOR("#user-imp-tbl",T_Enum::T_T_user_imp_tbl_,0,false,false)
      {syntax_code_ = 0;}
    T_syntax_code* T_user_imp_tbl::syntax_code(){return syntax_code_;}
    void T_user_imp_tbl::syntax_code(T_syntax_code* Stc){syntax_code_ = Stc;}
  
    T_user_imp_sym::T_user_imp_sym() 
      T_CTOR("#user-imp-sym",T_Enum::T_T_user_imp_sym_,0,false,false)
      {syntax_code_ = 0;}
    T_syntax_code* T_user_imp_sym::syntax_code(){return syntax_code_;}
    void T_user_imp_sym::syntax_code(T_syntax_code* Stc){syntax_code_ = Stc;}
  T_constant_defs::
T_constant_defs()
 T_CTOR("#constant-defs",T_Enum::T_T_constant_defs_,0,false,false){}
T_terminals_refs::
T_terminals_refs()
 T_CTOR("#terminals-refs",T_Enum::T_T_terminals_refs_,0,false,false){}
T_terminals_sufx::
T_terminals_sufx()
 T_CTOR("#terminals-sufx",T_Enum::T_T_terminals_sufx_,0,false,false){}
T_lrk_sufx::
T_lrk_sufx()
 T_CTOR("#lrk-sufx",T_Enum::T_T_lrk_sufx_,0,false,false){}
T_selector::
T_selector()
 T_CTOR("->",T_Enum::T_T_selector_,0,false,false){}
T_NULL::
T_NULL()
 T_CTOR("#NULL",T_Enum::T_T_NULL_,0,false,false){}
T_2colon::
T_2colon()
 T_CTOR("::",T_Enum::T_T_2colon_,0,false,false){}

    T_block::
    T_block(yacco2::AST* Ast)
     T_CTOR("block",T_Enum::T_T_block_,&dtor_T_block,false,true)
      {ast_ = Ast;}
    yacco2::AST* T_block::ast(){return ast_;}
  void T_block::dtor_T_block(yacco2::VOIDP This,yacco2::VOIDP P){
 bool ABORT_STATUS = ((yacco2::Parser*)P)->top_stack_record()->aborted__;
 T_block* R = (T_block*)(This);
 
    if(ABORT_STATUS == true){
      yacco2::AST::zero_content(*R->ast());// break dbl delete of self
      yacco2::AST::ast_delete(*R->ast(),ABORT_STATUS);
    }
  
}

    T_syntax_code::T_syntax_code(const char* Syntax_code)
      T_CTOR("syntax-code",T_Enum::T_T_syntax_code_,0,false,false)
    {syntax_code_ += Syntax_code;
    cweb_marker_=0;}
    std::string* T_syntax_code::syntax_code(){return &syntax_code_;}
    void T_syntax_code::add_cweb_marker(AST* Cweb){
      cweb_marker_ = Cweb;
    }
    AST* T_syntax_code::cweb_marker(){
      return cweb_marker_;
    }
  
    T_fsm_class_phrase::T_fsm_class_phrase() 
T_CTOR("fsm-class-phrase",T_Enum::T_T_fsm_class_phrase_,&dtor_T_fsm_class_phrase,false,false)
      {identifier_ = 0;phrase_tree_=0;}

    void T_fsm_class_phrase::phrase_tree(AST* Tree){phrase_tree_=Tree;}
    AST* T_fsm_class_phrase::phrase_tree(){return phrase_tree_;}
    
    T_identifier* T_fsm_class_phrase::identifier(){return identifier_;}
    void T_fsm_class_phrase::identifier(T_identifier* Id){identifier_ = Id;}

    std::map<string,CAbs_lr1_sym*>*
    T_fsm_class_phrase::directives_map(){
      return &directives_map_;
    }

    void T_fsm_class_phrase::remove_directives_from_map(){
      std::map<std::string,CAbs_lr1_sym*>::iterator i = directives_map_.begin();
      std::map<std::string,CAbs_lr1_sym*>::iterator ie = directives_map_.end();
      for(;i != ie;++i){
        CAbs_lr1_sym* sym = i->second;
        delete sym;
      }
    }

    CAbs_lr1_sym* // 0 - ok, or error 
    T_fsm_class_phrase::
    add_directive_to_map(CAbs_lr1_sym* Directive,yacco2::Parser* P){
      std::map<std::string,CAbs_lr1_sym*>::iterator i;
      string key(Directive->id__);
      i = directives_map_.find(key);
      if(i == directives_map_.end()){
        directives_map_[key] = Directive;
        return 0;
      }
      CAbs_lr1_sym* sym = new Err_duplicate_directive;
      sym->set_rc(*Directive,__FILE__,__LINE__);
      remove_directives_from_map();
      return sym; 
    }
    void T_fsm_class_phrase::dtor_T_fsm_class_phrase(yacco2::VOIDP This,yacco2::VOIDP P){
 T_fsm_class_phrase* R = (T_fsm_class_phrase*)(This);
 
      if(R->identifier_ != 0)
      delete R->identifier_;
      R->remove_directives_from_map();
  
}

    T_fsm_phrase::T_fsm_phrase() 
      T_CTOR("fsm-phrase",T_Enum::T_T_fsm_phrase_,&dtor_T_fsm_phrase,false,false)
      {fsm_id_ = 0;
      filename_id_ = 0;
      namespace_id_ = 0;
      fsm_class_phrase_ = 0;
      version_ = 0;
      date_ = 0;
      debug_ = 0;
      comment_ = 0;
      phrase_tree_=0;
      cweb_marker_=0;
    }
    
    void T_fsm_phrase::add_cweb_marker(AST* Cweb){
      cweb_marker_ = Cweb;
    }
    AST* T_fsm_phrase::cweb_marker(){
      return cweb_marker_;
    }

    void T_fsm_phrase::phrase_tree(AST* Tree){phrase_tree_=Tree;}
    AST* T_fsm_phrase::phrase_tree(){return phrase_tree_;}

    T_c_string* T_fsm_phrase::fsm_id(){return fsm_id_;}
    void T_fsm_phrase::fsm_id(T_c_string* Id){fsm_id_ = Id;}
    T_identifier* T_fsm_phrase::filename_id(){return filename_id_;}
    void T_fsm_phrase::filename_id(T_identifier* Id){filename_id_ = Id;}
    T_identifier* T_fsm_phrase::namespace_id(){return namespace_id_;}
    void T_fsm_phrase::namespace_id(T_identifier* Id){namespace_id_ = Id;}
    
    T_fsm_class_phrase* T_fsm_phrase::fsm_class_phrase(){return fsm_class_phrase_;}
    void T_fsm_phrase::fsm_class_phrase(T_fsm_class_phrase* Id)
        {fsm_class_phrase_ = Id;}


    T_c_string* T_fsm_phrase::version(){return version_;}
    void T_fsm_phrase::version(T_c_string* Id){version_ = Id;}
    T_c_string* T_fsm_phrase::date(){return date_;}
    void T_fsm_phrase::date(T_c_string* Id){date_ = Id;}
    T_c_string* T_fsm_phrase::debug(){return debug_;}
    void T_fsm_phrase::debug(T_c_string* Id){debug_ = Id;}
    T_c_string* T_fsm_phrase::comment(){return comment_;}
    void T_fsm_phrase::comment(T_c_string* Id){comment_ = Id;}
    void T_fsm_phrase::dtor_T_fsm_phrase(yacco2::VOIDP This,yacco2::VOIDP P){
 T_fsm_phrase* R = (T_fsm_phrase*)(This);
 
      delete R->fsm_id_;
      delete R->filename_id_;
      delete R->namespace_id_;
      delete R->fsm_class_phrase_;
      delete R->version_;
      delete R->date_;
      delete R->debug_;
      delete R->comment_;
  
}

    T_parallel_parser_phrase::T_parallel_parser_phrase() 
 T_CTOR("parallel-parser-phrase",T_Enum::T_T_parallel_parser_phrase_,&dtor_T_parallel_parser_phrase,false,false)
    {phrase_tree_=0;cweb_marker_=0;}
    
    void T_parallel_parser_phrase::add_cweb_marker(AST* Cweb){
      cweb_marker_ = Cweb;
    }
    
    AST* T_parallel_parser_phrase::cweb_marker(){
      return cweb_marker_;
    }
    
    void T_parallel_parser_phrase::phrase_tree(AST* Tree){phrase_tree_=Tree;}
    AST* T_parallel_parser_phrase::phrase_tree(){return phrase_tree_;}

    T_parallel_thread_function* T_parallel_parser_phrase::pp_funct(){
      return pp_funct_;
    }
    void T_parallel_parser_phrase::pp_funct(T_parallel_thread_function* PP_fnct){
      pp_funct_ = PP_fnct;
    }
    T_parallel_la_boundary* T_parallel_parser_phrase::la_bndry(){
      return la_bndry_;
    }
    void T_parallel_parser_phrase::la_bndry(T_parallel_la_boundary* La_bndry){
      la_bndry_ = La_bndry;
    }
    void T_parallel_parser_phrase::dtor_T_parallel_parser_phrase(yacco2::VOIDP This,yacco2::VOIDP P){
 T_parallel_parser_phrase* R = (T_parallel_parser_phrase*)(This);
 
      delete R->la_bndry_;
      delete R->pp_funct_;
  
}

    T_enum_phrase::T_enum_phrase() 
 T_CTOR("T-enum-phrase",T_Enum::T_T_enum_phrase_,&dtor_T_enum_phrase,false,false)
      {kdefs_ = 0;phrase_tree_=0;cweb_marker_=0;}
    
    void T_enum_phrase::add_cweb_marker(AST* Cweb){
      cweb_marker_ = Cweb;
    }
    
    AST* T_enum_phrase::cweb_marker(){
      return cweb_marker_;
    }
    
    void T_enum_phrase::phrase_tree(AST* Tree){phrase_tree_=Tree;}
    AST* T_enum_phrase::phrase_tree(){return phrase_tree_;}

   T_identifier* T_enum_phrase::filename_id(){return filename_id_;}
    void T_enum_phrase::filename_id(T_identifier* Id){filename_id_ = Id;}
    T_identifier* T_enum_phrase::namespace_id(){return namespace_id_;}
    void T_enum_phrase::namespace_id(T_identifier* Id){namespace_id_ = Id;}
    
    T_syntax_code* 
    T_enum_phrase::kdefs(){return kdefs_;}
    
    void T_enum_phrase::kdefs(T_syntax_code* Kdefs){
      kdefs_ = Kdefs;
    }
    void T_enum_phrase::start_lrk_enumerate(int Enum){start_lrk_enumerate_ = Enum;}
    void T_enum_phrase::stop_lrk_enumerate(int Enum){stop_lrk_enumerate_ = Enum;}
    int T_enum_phrase::start_lrk_enumerate(){return start_lrk_enumerate_;}
    int T_enum_phrase::stop_lrk_enumerate(){return stop_lrk_enumerate_;}
    void T_enum_phrase::start_err_enumerate(int Enum){start_err_enumerate_ = Enum;}
    void T_enum_phrase::stop_err_enumerate(int Enum){stop_err_enumerate_ = Enum;}
    int T_enum_phrase::start_err_enumerate(){return start_err_enumerate_;}
    int T_enum_phrase::stop_err_enumerate(){return stop_err_enumerate_;}
    void T_enum_phrase::start_rc_enumerate(int Enum){start_rc_enumerate_ = Enum;}
    void T_enum_phrase::stop_rc_enumerate(int Enum){stop_rc_enumerate_ = Enum;}
    int T_enum_phrase::start_rc_enumerate(){return start_rc_enumerate_;}
    int T_enum_phrase::stop_rc_enumerate(){return stop_rc_enumerate_;}
    void T_enum_phrase::start_T_enumerate(int Enum){start_T_enumerate_ = Enum;}
    void T_enum_phrase::stop_T_enumerate(int Enum){stop_T_enumerate_ = Enum;}
    int T_enum_phrase::start_T_enumerate(){return start_T_enumerate_;}
    int T_enum_phrase::stop_T_enumerate(){return stop_T_enumerate_;}
    void T_enum_phrase::total_enumerate(int Enum){total_enumerate_ = Enum;}
    int T_enum_phrase::total_enumerate(){return total_enumerate_;}
    
    void T_enum_phrase::total_T_enumerate(int Enum){total_T_enumerate_ = Enum;}
    int T_enum_phrase::total_T_enumerate(){return total_T_enumerate_;}
    void T_enum_phrase::total_rc_enumerate(int Enum){total_rc_enumerate_ = Enum;}
    int T_enum_phrase::total_rc_enumerate(){return total_rc_enumerate_;}
    void T_enum_phrase::total_err_enumerate(int Enum){total_err_enumerate_ = Enum;}
    int T_enum_phrase::total_err_enumerate(){return total_err_enumerate_;}
    void T_enum_phrase::total_lrk_enumerate(int Enum){total_lrk_enumerate_ = Enum;}
    int T_enum_phrase::total_lrk_enumerate(){return total_lrk_enumerate_;}
    int T_enum_phrase::total_no_subrules(){return total_no_subrules_;}
    void T_enum_phrase::total_no_subrules(int Total_subrules){
        total_no_subrules_ = Total_subrules;
    }
    void T_enum_phrase::dtor_T_enum_phrase(yacco2::VOIDP This,yacco2::VOIDP P){
 T_enum_phrase* R = (T_enum_phrase*)(This);
 
      delete R->filename_id_;
      delete R->namespace_id_;
      delete R->kdefs_;
  
}

    T_terminal_def::T_terminal_def() 
T_CTOR("terminal-def",T_Enum::T_T_terminal_def_,&dtor_T_terminal_def,false,false)
      {auto_delete_ = false;
      auto_abort_ = false;
      classification_ = T_terminal_def::not_classed;
      cweb_marker_ = 0;
      enum_id_ = -1;
    }
    void T_terminal_def::enum_id(int Id){enum_id_=Id;}
    int T_terminal_def::enum_id(){return enum_id_;}
     void T_terminal_def::add_cweb_marker(AST* Cweb){
       cweb_marker_ = Cweb;
     }
     
    AST* T_terminal_def::cweb_marker(){
       return cweb_marker_;
    }
   
    map<std::string,CAbs_lr1_sym*>*
    T_terminal_def::directives_map(){
      return &directives_map_;
    }

    void T_terminal_def::remove_directives_from_map(){
      std::map<std::string,CAbs_lr1_sym*>::iterator i = directives_map_.begin();
      std::map<std::string,CAbs_lr1_sym*>::iterator ie = directives_map_.end();
      for(;i != ie;++i){
        CAbs_lr1_sym* sym = i->second;
        delete sym;
      }
    }

    CAbs_lr1_sym* // 0 - ok, or error 
    T_terminal_def::
    add_directive_to_map(CAbs_lr1_sym* Directive,yacco2::Parser* P){
      map<std::string,CAbs_lr1_sym*>::iterator i;
      std::string key(Directive->id__);
      i = directives_map_.find(key);
      if(i == directives_map_.end()){
        directives_map_[key] = Directive;
        return 0;
      }
      CAbs_lr1_sym* sym = new Err_duplicate_directive;
      sym->set_rc(*Directive,__FILE__,__LINE__);
      remove_directives_from_map();
      return sym; 
    }

    std::string* T_terminal_def::t_name(){return &t_name_;}
    void T_terminal_def::t_name(const char* Id){t_name_ += Id;}
    
    std::string* T_terminal_def::classsym(){return &class_sym_;}
    void T_terminal_def::classsym(const char* Id){class_sym_ += Id;}
    
    bool T_terminal_def::autodelete(){return auto_delete_;}
    void T_terminal_def::autodelete(bool Ton){auto_delete_ = Ton;} 
    
    bool T_terminal_def::autoabort(){return auto_abort_;}
    void T_terminal_def::autoabort(bool Ton){auto_abort_ = Ton;} 
    
    T_terminal_def::classification_typ 
      T_terminal_def::classification(){return classification_;}      
    void 
      T_terminal_def::classification(T_terminal_def::classification_typ C)
        {classification_ = C;}      
    void T_terminal_def::dtor_T_terminal_def(yacco2::VOIDP This,yacco2::VOIDP P){
 T_terminal_def* R = (T_terminal_def*)(This);
 
      R->remove_directives_from_map();
  
}

    table_entry::    
    table_entry()
      T_CTOR("symbol-table",T_Enum::T_table_entry_,0,false,false)
		{vacant_ = true;
		defined_ = false;
		used_ = false;
		type_ = table_entry::unknown;
		symbol_ = 0;
		key_ = 0;
		pos_ = -1;
        key_len_ = 0;
    }
  
    T_sym_tbl_report_card::    
    T_sym_tbl_report_card()
      T_CTOR("sym-tbl-report-card",T_Enum::T_T_sym_tbl_report_card_,0,false,false)
      {status_ = okay;
      action_ = unknown;
      tbl_entry_ = 0;
      pos_ = 0;
      key_len_ = 0;
    }
  
    T_terminals_phrase::T_terminals_phrase() 
T_CTOR("terminals-phrase",T_Enum::T_T_terminals_phrase_,&dtor_T_terminals_phrase,false,false)
      {terminals_refs_code_ = 0;
      terminals_sufx_code_ = 0;
      phrase_tree_=0;
      cweb_marker_=0;
    }
    
    void T_terminals_phrase::add_cweb_marker(AST* Cweb){
      cweb_marker_ = Cweb;
    }
    
    AST* T_terminals_phrase::cweb_marker(){
      return cweb_marker_;
    }
    
    void T_terminals_phrase::phrase_tree(AST* Tree){phrase_tree_=Tree;}
    AST* T_terminals_phrase::phrase_tree(){return phrase_tree_;}

    T_identifier* T_terminals_phrase::filename_id(){return filename_id_;}
    void T_terminals_phrase::filename_id(T_identifier* Id){filename_id_ = Id;}
    T_identifier* T_terminals_phrase::namespace_id(){return namespace_id_;}
    void T_terminals_phrase::namespace_id(T_identifier* Id){namespace_id_ = Id;}

    std::map<std::string,NS_yacco2_terminals::T_terminal_def*>*
    T_terminals_phrase::alphabet(){
      return &alphabet_;
    }
    std::vector<T_terminal_def*>* 
    T_terminals_phrase::
    crt_order(){return &crt_order_;}

    void T_terminals_phrase::destroy_alphabet(){
      std::vector<T_terminal_def*>::iterator i = crt_order_.begin();
      std::vector<T_terminal_def*>::iterator ie = crt_order_.end();
      for(;i != ie;++i){
        CAbs_lr1_sym* sym = *i;
        delete sym;
      }
      alphabet_.clear();
    }

    CAbs_lr1_sym* 
    T_terminals_phrase::
    add_t_to_alphabet(T_terminal_def* T,yacco2::Parser* P){
      string key(T->t_name()->c_str());
      std::map<std::string,NS_yacco2_terminals::T_terminal_def*>::iterator i = alphabet_.find(key);
      if(i != alphabet_.end()){
        CAbs_lr1_sym* sym = new Err_dup_entry_in_alphabet;
        sym->set_rc(*T,__FILE__,__LINE__);
        return sym;      
      }
      alphabet_[key] = T;
      crt_order_.push_back(T);
      return 0;
    }
    
    T_syntax_code*     
    T_terminals_phrase::
    terminals_refs_code(){return terminals_refs_code_;}
    
    void     
    T_terminals_phrase::
    terminals_refs_code(T_syntax_code* Code){
      terminals_refs_code_ = Code;
    }
    
    T_syntax_code*     
    T_terminals_phrase::
    terminals_sufx_code(){return terminals_sufx_code_;}
    
    void     
    T_terminals_phrase::
    terminals_sufx_code(T_syntax_code* Code){
      terminals_sufx_code_ = Code;
    }
  void T_terminals_phrase::dtor_T_terminals_phrase(yacco2::VOIDP This,yacco2::VOIDP P){
 T_terminals_phrase* R = (T_terminals_phrase*)(This);
 
      R->destroy_alphabet();
      delete R->filename_id_;
      delete R->namespace_id_;
      delete R->terminals_refs_code_;
      delete R->terminals_sufx_code_;
  
}

    T_error_symbols_phrase::T_error_symbols_phrase() 
T_CTOR("error-symbols-phrase",T_Enum::T_T_error_symbols_phrase_,&dtor_T_error_symbols_phrase,false,false)
    {phrase_tree_=0;cweb_marker_=0;}
    
    void T_error_symbols_phrase::add_cweb_marker(AST* Cweb){
      cweb_marker_ = Cweb;
    }
    
    AST* T_error_symbols_phrase::cweb_marker(){
      return cweb_marker_;
    }
    
    void T_error_symbols_phrase::phrase_tree(AST* Tree){phrase_tree_=Tree;}
    AST* T_error_symbols_phrase::phrase_tree(){return phrase_tree_;}

    T_identifier* T_error_symbols_phrase::filename_id(){return filename_id_;}
    void T_error_symbols_phrase::filename_id(T_identifier* Id){filename_id_ = Id;}
    T_identifier* T_error_symbols_phrase::namespace_id(){return namespace_id_;}
    void T_error_symbols_phrase::namespace_id(T_identifier* Id){namespace_id_ = Id;}

    std::map<std::string,NS_yacco2_terminals::T_terminal_def*>*
    T_error_symbols_phrase::alphabet(){
      return &alphabet_;
    }
    
    std::vector<T_terminal_def*>* 
    T_error_symbols_phrase::
    crt_order(){return &crt_order_;}

    void T_error_symbols_phrase::destroy_alphabet(){
      std::vector<T_terminal_def*>::iterator i = crt_order_.begin();
      std::vector<T_terminal_def*>::iterator ie = crt_order_.end();
      for(;i != ie;++i){
        CAbs_lr1_sym* sym = *i;
        delete sym;
      }
      alphabet_.clear();
    }

    CAbs_lr1_sym* 
    T_error_symbols_phrase::
    add_t_to_alphabet(T_terminal_def* T,yacco2::Parser* P){
      std::string key(T->t_name()->c_str());
      std::map<std::string,NS_yacco2_terminals::T_terminal_def*>::iterator i = alphabet_.find(key);
      if(i != alphabet_.end()){
        CAbs_lr1_sym* sym = new Err_dup_entry_in_alphabet;
        sym->set_rc(*T,__FILE__,__LINE__);
        return sym;      
      }
      alphabet_[key] = T;
      crt_order_.push_back(T);
      return 0;
    }
    void T_error_symbols_phrase::dtor_T_error_symbols_phrase(yacco2::VOIDP This,yacco2::VOIDP P){
 T_error_symbols_phrase* R = (T_error_symbols_phrase*)(This);
 
      R->destroy_alphabet();
      delete R->filename_id_;
      delete R->namespace_id_;
  
}

    T_lr1_k_phrase::T_lr1_k_phrase() 
      T_CTOR("lr1-k-phrase",T_Enum::T_T_lr1_k_phrase_,&dtor_T_lr1_k_phrase,false,false)
      {lrk_sufx_code_ = 0;phrase_tree_=0;cweb_marker_=0;}
    
    void T_lr1_k_phrase::add_cweb_marker(AST* Cweb){
      cweb_marker_ = Cweb;
    }
    
    AST* T_lr1_k_phrase::cweb_marker(){
      return cweb_marker_;
    }
    
    void T_lr1_k_phrase::phrase_tree(AST* Tree){phrase_tree_=Tree;}
    AST* T_lr1_k_phrase::phrase_tree(){return phrase_tree_;}

    T_identifier* T_lr1_k_phrase::filename_id(){return filename_id_;}
    void T_lr1_k_phrase::filename_id(T_identifier* Id){filename_id_ = Id;}
    T_identifier* T_lr1_k_phrase::namespace_id(){return namespace_id_;}
    void T_lr1_k_phrase::namespace_id(T_identifier* Id){namespace_id_ = Id;}

    std::map<std::string,NS_yacco2_terminals::T_terminal_def*>*
    T_lr1_k_phrase::alphabet(){
      return &alphabet_;
    }
 
    std::vector<T_terminal_def*>* 
    T_lr1_k_phrase::
    crt_order(){return &crt_order_;}

    void T_lr1_k_phrase::destroy_alphabet(){
      std::vector<T_terminal_def*>::iterator i = crt_order_.begin();
      std::vector<T_terminal_def*>::iterator ie = crt_order_.end();
      for(;i != ie;++i){
        CAbs_lr1_sym* sym = *i;
        delete sym;
      }
      alphabet_.clear();
    }

    CAbs_lr1_sym* 
    T_lr1_k_phrase::
    add_t_to_alphabet(T_terminal_def* T,yacco2::Parser* P){
      std::string key(T->t_name()->c_str());
      std::map<std::string,NS_yacco2_terminals::T_terminal_def*>::iterator i = alphabet_.find(key);
      if(i != alphabet_.end()){
        CAbs_lr1_sym* sym = new Err_dup_entry_in_alphabet;
        sym->set_rc(*T,__FILE__,__LINE__);
        return sym;      
      }
      alphabet_[key] = T;
      crt_order_.push_back(T);
      return 0;
    }
    T_syntax_code*     
    T_lr1_k_phrase::
    lrk_sufx_code(){return lrk_sufx_code_;}
    
    void     
    T_lr1_k_phrase::
    lrk_sufx_code(T_syntax_code* Code){
      lrk_sufx_code_ = Code;
    }
    void T_lr1_k_phrase::dtor_T_lr1_k_phrase(yacco2::VOIDP This,yacco2::VOIDP P){
 T_lr1_k_phrase* R = (T_lr1_k_phrase*)(This);
 
      R->destroy_alphabet();
      delete R->filename_id_;
      delete R->namespace_id_;
      delete R->lrk_sufx_code_;
  
}

    T_rc_phrase::T_rc_phrase() 
      T_CTOR("rc-phrase",T_Enum::T_T_rc_phrase_,&dtor_T_rc_phrase,false,false)
    {phrase_tree_=0;cweb_marker_=0;}
    
    void T_rc_phrase::add_cweb_marker(AST* Cweb){
      cweb_marker_ = Cweb;
    }
    
    AST* T_rc_phrase::cweb_marker(){
      return cweb_marker_;
    }
    
    void T_rc_phrase::phrase_tree(AST* Tree){phrase_tree_=Tree;}
    AST* T_rc_phrase::phrase_tree(){return phrase_tree_;}

    T_identifier* T_rc_phrase::filename_id(){return filename_id_;}
    void T_rc_phrase::filename_id(T_identifier* Id){filename_id_ = Id;}
    T_identifier* T_rc_phrase::namespace_id(){return namespace_id_;}
    void T_rc_phrase::namespace_id(T_identifier* Id){namespace_id_ = Id;}

    std::map<std::string,NS_yacco2_terminals::T_terminal_def*>*
    T_rc_phrase::alphabet(){
      return &alphabet_;
    }
 
    std::vector<T_terminal_def*>* 
    T_rc_phrase::
    crt_order(){return &crt_order_;}

    void T_rc_phrase::destroy_alphabet(){
      std::vector<T_terminal_def*>::iterator i = crt_order_.begin();
      std::vector<T_terminal_def*>::iterator ie = crt_order_.end();
      for(;i != ie;++i){
        CAbs_lr1_sym* sym = *i;
        delete sym;
      }
      alphabet_.clear();
    }

    CAbs_lr1_sym* 
    T_rc_phrase::
    add_t_to_alphabet(T_terminal_def* T,yacco2::Parser* P){
      std::string key(T->t_name()->c_str());
      std::map<std::string,NS_yacco2_terminals::T_terminal_def*>::iterator i = alphabet_.find(key);
      if(i != alphabet_.end()){
        CAbs_lr1_sym* sym = new Err_dup_entry_in_alphabet;
        sym->set_rc(*T,__FILE__,__LINE__);
        return sym;      
      }
      alphabet_[key] = T;
      crt_order_.push_back(T);
      return 0;
    }
    void T_rc_phrase::dtor_T_rc_phrase(yacco2::VOIDP This,yacco2::VOIDP P){
 T_rc_phrase* R = (T_rc_phrase*)(This);
 
      R->destroy_alphabet();
      delete R->filename_id_;
      delete R->namespace_id_;
  
}

    T_rule_lhs_phrase::T_rule_lhs_phrase() 
T_CTOR("rule-lhs-phrase",T_Enum::T_T_rule_lhs_phrase_,&dtor_T_rule_lhs_phrase,false,false)
    {phrase_tree_=0;cweb_marker_=0;}
    
    
    void T_rule_lhs_phrase::add_cweb_marker(AST* Cweb){
      cweb_marker_ = Cweb;
    }
    
    AST* T_rule_lhs_phrase::cweb_marker(){
      return cweb_marker_;
    }
    
    void T_rule_lhs_phrase::phrase_tree(AST* Tree){phrase_tree_=Tree;}
    AST* T_rule_lhs_phrase::phrase_tree(){return phrase_tree_;}

   map<std::string,CAbs_lr1_sym*>*
    T_rule_lhs_phrase::lhs_directives_map(){
      return &lhs_directives_map_;
    }

    void T_rule_lhs_phrase::remove_lhs_directives(){
      std::map<std::string,CAbs_lr1_sym*>::iterator i = lhs_directives_map_.begin();
      std::map<std::string,CAbs_lr1_sym*>::iterator ie = lhs_directives_map_.end();
      for(;i != ie;++i){
        CAbs_lr1_sym* sym = i->second;
        delete sym;
      }
    }

    CAbs_lr1_sym* // 0 - ok, or error 
    T_rule_lhs_phrase::
    add_directive_to_lhs(CAbs_lr1_sym* Directive,yacco2::Parser* P){
      map<std::string,CAbs_lr1_sym*>::iterator i;
      string key(Directive->id__);
      i = lhs_directives_map_.find(key);
      if(i == lhs_directives_map_.end()){
        lhs_directives_map_[key] = Directive;
        return 0;
      }
      CAbs_lr1_sym* sym = new Err_duplicate_directive;
      sym->set_rc(*Directive,__FILE__,__LINE__);
      remove_lhs_directives();
      return sym; 
    }
    void T_rule_lhs_phrase::dtor_T_rule_lhs_phrase(yacco2::VOIDP This,yacco2::VOIDP P){
 T_rule_lhs_phrase* R = (T_rule_lhs_phrase*)(This);
 
      R->remove_lhs_directives();
  
}

    T_parallel_monitor_phrase::T_parallel_monitor_phrase() 
T_CTOR("parallel-monitor-phrase",T_Enum::T_T_parallel_monitor_phrase_,&dtor_T_parallel_monitor_phrase,false,false)
    {phrase_tree_=0;}
    
    void T_parallel_monitor_phrase::phrase_tree(AST* Tree){phrase_tree_=Tree;}
    AST* T_parallel_monitor_phrase::phrase_tree(){return phrase_tree_;}

    map<string,CAbs_lr1_sym*>*
    T_parallel_monitor_phrase::mntr_directives_map(){
      return &mntr_directives_map_;
    }

    void T_parallel_monitor_phrase::remove_mntr_directives(){
      std::map<std::string,CAbs_lr1_sym*>::iterator i = mntr_directives_map_.begin();
      std::map<std::string,CAbs_lr1_sym*>::iterator ie = mntr_directives_map_.end();
      for(;i != ie;++i){
        CAbs_lr1_sym* sym = i->second;
        delete sym;
      }
    }

    CAbs_lr1_sym* // 0 - ok, or error 
    T_parallel_monitor_phrase::
    add_directive_to_mntr(CAbs_lr1_sym* Directive,yacco2::Parser* P){
      map<std::string,CAbs_lr1_sym*>::iterator i;
      std::string key(Directive->id__);
      i = mntr_directives_map_.find(key);
      if(i == mntr_directives_map_.end()){
        mntr_directives_map_[key] = Directive;
        return 0;
      }
      CAbs_lr1_sym* sym = new Err_duplicate_directive;
      sym->set_rc(*Directive,__FILE__,__LINE__);
      remove_mntr_directives();
      return sym; 
    }
    void T_parallel_monitor_phrase::dtor_T_parallel_monitor_phrase(yacco2::VOIDP This,yacco2::VOIDP P){
 T_parallel_monitor_phrase* R = (T_parallel_monitor_phrase*)(This);
 
      R->remove_mntr_directives();
  
}

    rule_def::rule_def(const char* Key) 
      T_CTOR("rule-def",T_Enum::T_rule_def_,&dtor_rule_def,false,false)
      {auto_delete_ = false;
      auto_abort_ = false;
	  rule_no_ = 0;//starts cnt at 1
	  recursive_ = NO;
	  lhs_use_cnt_ = 0;
	  rhs_use_cnt_ = 0;
      rule_use_skeleton_ = 0;
      parallel_mntr_ = 0;
      subrules_ = 0;
      rule_lhs_ = 0;
      rule_name_ += Key;
      epsilon_ = false;      
      derive_t_ = false;
      cweb_marker_ = 0;
      its_tree_ = 0;
      enum_id_ = -1;
      first_set_.clear();
    }
    std::set<rule_in_stbl*>* rule_def::closure_rules_making_up_first_set(){
      return &closure_rules_making_up_first_set_;
    }
    AST* rule_def::rule_use_skeleton(){return rule_use_skeleton_;} 
    void rule_def::rule_use_skeleton(AST* Tree){rule_use_skeleton_ = Tree;} 
    
    std::map<T_in_stbl*,std::set<std::string*> >* 
    rule_def::rule_adding_T_in_first_set(){
      return &rules_adding_T_in_first_set_;
    }
	int rule_def::rule_no(){return rule_no_;}
	void rule_def::rule_no(int Rule_no){rule_no_ = Rule_no;}
	bool rule_def::recursive(){return recursive_;}
	void rule_def::recursive(bool Recursive){recursive_ = Recursive;}
	int rule_def::lhs_use_cnt(){return lhs_use_cnt_;};
	void rule_def::lhs_use_cnt(int Use_cnt){lhs_use_cnt_ = Use_cnt;}
	int rule_def::rhs_use_cnt(){return rhs_use_cnt_;}
	void rule_def::rhs_use_cnt(int Use_cnt){rhs_use_cnt_ = Use_cnt;}
    
    void rule_def::add_closure_rule_making_up_first_set(rule_in_stbl* Rule){
      if(closure_rules_making_up_first_set_.find(Rule) 
						!= 
        closure_rules_making_up_first_set_ .end()) return;
      closure_rules_making_up_first_set_.insert(Rule);   
    }
    void rule_def::add_rule_adding_T_in_first_set
		(T_in_stbl* T,std::string* Rule_enumerate){
          std::map<T_in_stbl*,std::set<std::string*> >::iterator i;		
          std::map<T_in_stbl*,std::set<std::string*> >::iterator ie;
          ie = rules_adding_T_in_first_set_.end();		
          i = rules_adding_T_in_first_set_.find(T); 
          if(i == ie){
			rules_adding_T_in_first_set_[T] = std::set<std::string*>();
			i = rules_adding_T_in_first_set_.find(T);
            i->second.insert(Rule_enumerate);
            return;
          }		
          i->second.insert(Rule_enumerate);
		}

    std::string* rule_def::grammar_s_enumerate(){
      return &grammar_s_enumerate_;
    }
    void rule_def::grammar_s_enumerate(const char* Enumerate){
      grammar_s_enumerate_+=Enumerate;
    }
    
    std::set<T_in_stbl*>* rule_def::first_set(){
      return &first_set_;
    }
    std::set<T_called_thread_eosubrule*>* rule_def::called_thread_first_set(){
      return &called_thread_first_set_;
    }

    void rule_def::add_to_first_set(T_in_stbl& T){
      T_in_stbl* t = &T;
      std::set<T_in_stbl*>::iterator i;
      i = first_set_.find(t);
      if(i == first_set_.end()){
        first_set_.insert(t);
      }
    }
    void rule_def::add_to_called_thread_first_set(T_called_thread_eosubrule* T){
      std::set<T_called_thread_eosubrule*>::iterator i;
      i = called_thread_first_set_.find(T);
      if(i == called_thread_first_set_.end()){
        called_thread_first_set_.insert(T);
      }
    }

    void rule_def::enum_id(int Id){enum_id_=Id;}
    int rule_def::enum_id(){return enum_id_;}
    void rule_def::bld_its_tree(){
      its_tree_ = new AST(*this);
	  T_subrules_phrase* subrules_ph = subrules();
	  std::vector<T_subrule_def*>* subrule_list = subrules_ph->subrules();
	  std::vector<T_subrule_def*>::iterator sri = subrule_list->begin();
	  std::vector<T_subrule_def*>::iterator srie = subrule_list->end();
	  AST* subrule_lvl = 0;
	  for(;sri!=srie;++sri){// walk subrules
		T_subrule_def* srdef = *sri;
		AST* srt = srdef->subrule_s_tree();
		if(subrule_lvl == 0){
			AST::crt_tree_of_1son(*its_tree_,*srt);
			subrule_lvl = srt;  
		}else{ // subrule brothers
			AST::join_sts(*subrule_lvl,*srt);  
			subrule_lvl = srt;  
		}
	  }
    }
    
    AST* rule_def::rule_s_tree(){
      return its_tree_;
    }
    
    void rule_def::add_cweb_marker(AST* Cweb){
      cweb_marker_ = Cweb;
    }
    
    AST* rule_def::cweb_marker(){
      return cweb_marker_;
    }
    
    T_rule_lhs_phrase* rule_def::rule_lhs(){
      return rule_lhs_;
    }
    
    void rule_def::rule_lhs(T_rule_lhs_phrase* Lhs){
      rule_lhs_ = Lhs;
    }

    void rule_def::parallel_mntr(T_parallel_monitor_phrase* Mntr){
      parallel_mntr_ = Mntr;
    }
    
    T_parallel_monitor_phrase* rule_def::parallel_mntr(){
      return parallel_mntr_;
    }
    
    T_subrules_phrase* rule_def::subrules(){
      return subrules_;
    }
    
    void rule_def::subrules(T_subrules_phrase* Subrules){
      subrules_ = Subrules;
    }
    
    std::string* rule_def::rule_name(){return &rule_name_;}
        
    bool rule_def::autodelete(){return auto_delete_;}
    void rule_def::autodelete(bool Ton){auto_delete_ = Ton;} 
    
    bool rule_def::autoabort(){return auto_abort_;}
    void rule_def::autoabort(bool Ton){auto_abort_ = Ton;} 
        
    bool rule_def::epsilon(){return epsilon_;}
    void rule_def::epsilon(bool Ton){epsilon_ = Ton;} 

    bool rule_def::derive_t(){return derive_t_;}
    void rule_def::derive_t(bool Ton){derive_t_ = Ton;} 
        
    void rule_def::dtor_rule_def(yacco2::VOIDP This,yacco2::VOIDP P){
 rule_def* R = (rule_def*)(This);
 
      delete R->parallel_mntr_;
      delete R->rule_lhs_;
      delete R->subrules_;
  
}

    T_rules_phrase::T_rules_phrase() 
T_CTOR("rules-phrase",T_Enum::T_T_rules_phrase_,&dtor_T_rules_phrase,false,false)
    {phrase_tree_=0;cweb_marker_=0;}
    
    void T_rules_phrase::add_cweb_marker(AST* Cweb){
      cweb_marker_ = Cweb;
    }
    
    AST* T_rules_phrase::cweb_marker(){
      return cweb_marker_;
    }
    

    void T_rules_phrase::phrase_tree(AST* Tree){phrase_tree_=Tree;}
    AST* T_rules_phrase::phrase_tree(){return phrase_tree_;}

    std::map<string,rule_def*>*
    T_rules_phrase::rules_alphabet(){
      return &rules_alphabet_;
    }

    void T_rules_phrase::destroy_rules_alphabet(){
      std::vector<rule_def*>::iterator i = crt_order_.begin();
      std::vector<rule_def*>::iterator ie = crt_order_.end();
      for(;i != ie;++i){
        CAbs_lr1_sym* sym = *i;
        delete sym;
      }
      rules_alphabet_.clear();
    }

    CAbs_lr1_sym* 
    T_rules_phrase::
    add_r_to_alphabet(rule_def* R,yacco2::Parser* P){
      std::string key(R->rule_name()->c_str());
      std::map<std::string,rule_def*>::iterator i = rules_alphabet_.find(key);
      if(i != rules_alphabet_.end()){
        CAbs_lr1_sym* sym = new Err_dup_entry_in_alphabet;
        sym->set_rc(*R,__FILE__,__LINE__);
        return sym;      
      }
      rules_alphabet_[key] = R;
      crt_order_.push_back(R);
      return 0;
    }
    std::vector<rule_def*>*
    T_rules_phrase::
	crt_order(){return &crt_order_;}
    void T_rules_phrase::dtor_T_rules_phrase(yacco2::VOIDP This,yacco2::VOIDP P){
 T_rules_phrase* R = (T_rules_phrase*)(This);
 
      R->destroy_rules_alphabet();
  
}

    T_subrule_def::T_subrule_def() 
T_CTOR("subrule-def",T_Enum::T_T_subrule_def_,&dtor_T_subrule_def,false,false)
      {subrule_no_of_rule_ = 0;
      no_of_elems_ = 0;
      epsilon_ = false;
      derive_t_ = false;
      its_rule_def_ = 0;
      cweb_marker_ = 0;
	  its_tree_ = 0;
      its_grammar_s_pos_ = 0; 
      }
    int T_subrule_def::its_grammar_s_pos(){return its_grammar_s_pos_;} 
    void T_subrule_def::its_grammar_s_pos(int Pos){its_grammar_s_pos_ = Pos;}   
    int T_subrule_def::subrule_no_of_rule(){
      return subrule_no_of_rule_;
    }
    void T_subrule_def::subrule_no_of_rule(int Subrule_no){
      subrule_no_of_rule_ = Subrule_no;
    }
    
    std::string* T_subrule_def::grammar_s_enumerate(){
      return &grammar_s_enumerate_;
    }
    void T_subrule_def::grammar_s_enumerate(const char* Enumerate){
      grammar_s_enumerate_+=Enumerate;
    }
    
    void T_subrule_def::bld_its_tree(){
      its_tree_ = new AST(*this);
	  std::vector<CAbs_lr1_sym*>* element_list = subrule_elems();
	  std::vector<CAbs_lr1_sym*>::iterator ei = element_list->begin();
	  std::vector<CAbs_lr1_sym*>::iterator eie = element_list->end();
	  AST* element_lvl = 0;
	  for(;ei!=eie;++ei){// walk elements of subrule
		CAbs_lr1_sym* elem_def = *ei;
		AST* elemtt = new AST(*elem_def);
		int id = elem_def->enumerated_id__;
		using namespace NS_yacco2_terminals;
		switch (id){
		case T_Enum::T_refered_rule_: {
		  refered_rule* rrule = (refered_rule*)elem_def;
		  rrule->tree_node(elemtt);
		  break;
		}
		case T_Enum::T_T_eosubrule_: {
		  T_eosubrule* eos = (T_eosubrule*)elem_def;
		  eos->tree_node(elemtt);
		  break;
		}
		case T_Enum::T_refered_T_: {
		  refered_T* rt = (refered_T*)elem_def;
		  rt->tree_node(elemtt);
		  break;
		}
      }
		if(element_lvl == 0){
			AST::crt_tree_of_1son(*its_tree_,*elemtt);
			element_lvl = elemtt;  
		}else{ // element brothers
			AST::join_sts(*element_lvl,*elemtt);  
			element_lvl = elemtt;  
		}
	  }
    }
    
    AST* T_subrule_def::subrule_s_tree(){
      return its_tree_;
    }
    
    void T_subrule_def::add_cweb_marker(AST* Cweb){
      cweb_marker_ = Cweb;
    }
    
    AST* T_subrule_def::cweb_marker(){
      return cweb_marker_;
    }
    
    rule_def* T_subrule_def::its_rule_def(){
      return its_rule_def_;
    }
    
    void T_subrule_def::its_rule_def(rule_def* Its_rule_def){
      its_rule_def_ = Its_rule_def;
    }
    
	std::vector<CAbs_lr1_sym*>* T_subrule_def::subrule_elems(){
		return &subrule_elems_;	
	}
	
    bool T_subrule_def::epsilon(){
      return epsilon_;
    }
    
    void T_subrule_def::epsilon(bool Epsilon){
      epsilon_ = Epsilon;
    }

    bool T_subrule_def::derive_t(){
      return derive_t_;
    }
    
    void T_subrule_def::derive_t(bool Ton){
      derive_t_ = Ton;
    }
    
	void T_subrule_def::
	add_elem_to_subrule_vector(CAbs_lr1_sym* Elem){
	  ++no_of_elems_;
	  subrule_elems_.push_back(Elem);		
	}
	int T_subrule_def::no_of_elems(){
	  return no_of_elems_;
	}
    
    map<std::string,CAbs_lr1_sym*>*
    T_subrule_def::subrule_directives(){
      return &subrule_directives_;
    }

    void T_subrule_def::remove_subrule_directives(){
      std::map<std::string,CAbs_lr1_sym*>::iterator i = subrule_directives_.begin();
      std::map<std::string,CAbs_lr1_sym*>::iterator ie = subrule_directives_.end();
      for(;i != ie;++i){
        CAbs_lr1_sym* sym = i->second;
        delete sym;
      }
    }

    CAbs_lr1_sym* // 0 - ok, or error 
    T_subrule_def::
    add_directive_to_subrule(CAbs_lr1_sym* Directive,yacco2::Parser* P){
      std::map<std::string,CAbs_lr1_sym*>::iterator i;
      std::string key(Directive->id__);
      i = subrule_directives_.find(key);
      if(i == subrule_directives_.end()){
        subrule_directives_[key] = Directive;
        return 0;
      }
      CAbs_lr1_sym* sym = new Err_duplicate_directive;
      sym->set_rc(*Directive,__FILE__,__LINE__);
      remove_subrule_directives();
      return sym; 
    }
    void T_subrule_def::remove_subrule_elems_from_vector(){
      std::vector<CAbs_lr1_sym*>::iterator i = subrule_elems_.begin();
      std::vector<CAbs_lr1_sym*>::iterator ie = subrule_elems_.end();
      for(;i != ie;++i){
        delete *i;
      }
    }
  void T_subrule_def::dtor_T_subrule_def(yacco2::VOIDP This,yacco2::VOIDP P){
 T_subrule_def* R = (T_subrule_def*)(This);
 
      R->remove_subrule_directives();
      R->remove_subrule_elems_from_vector();
  
}

    T_subrules_phrase::T_subrules_phrase() 
T_CTOR("subrules-phrase",T_Enum::T_T_subrules_phrase_,&dtor_T_subrules_phrase,false,false)
      {no_subrules_ = 0;phrase_tree_=0;}
    void T_subrules_phrase::phrase_tree(AST* Tree){phrase_tree_=Tree;}
    AST* T_subrules_phrase::phrase_tree(){return phrase_tree_;}

    int T_subrules_phrase::no_subrules(){
      return no_subrules_;
    }
    std::vector<T_subrule_def*>*
    T_subrules_phrase::subrules(){
      return &subrules_;
    }

    void T_subrules_phrase::destroy_subrules(){
      std::vector<T_subrule_def*>::iterator i = subrules_.begin();
      std::vector<T_subrule_def*>::iterator ie = subrules_.end();
      for(;i != ie;++i){
        CAbs_lr1_sym* sym = *i;
        delete sym;
      }
    }

    void 
    T_subrules_phrase::
    add_sr_to_subrules(T_subrule_def* R){
      ++no_subrules_;
      subrules_.push_back(R);
    }
    void T_subrules_phrase::dtor_T_subrules_phrase(yacco2::VOIDP This,yacco2::VOIDP P){
 T_subrules_phrase* R = (T_subrules_phrase*)(This);
 
      R->destroy_subrules();
  
}

T_in_stbl::T_in_stbl(T_terminal_def* Fnd_T_in_stbl,CAbs_lr1_sym* Rc,yacco2::Parser* P)
      T_CTOR("T-in-stbl",T_Enum::T_T_in_stbl_,0,false,false)
      {t_def_ = Fnd_T_in_stbl;
      set_rc(*Rc,__FILE__,__LINE__);// set its source co-ordinates
      stbl_idx_ = -1;
    }
    T_terminal_def* T_in_stbl::t_def(){
      return t_def_;
    }
    std::list<refered_T*>* T_in_stbl::xref_t(){
		return  &xref_t_;;   
    }
    void T_in_stbl::add_T_into_xref(refered_T& T){
      xref_t_.push_back(&T);
    }
    void T_in_stbl::stbl_idx(yacco2::UINT Idx){stbl_idx_ = Idx;}
    int T_in_stbl::stbl_idx(){return stbl_idx_;}
  
    refered_T::refered_T(T_in_stbl& Term_in_stbl)
      T_CTOR("refered-T",T_Enum::T_refered_T_,0,false,false)
      {t_in_stbl_ = &Term_in_stbl;
      its_subrule_def_ = 0;
      tree_node_ = 0;
      element_pos_ = 0;
    }
    int refered_T::element_pos(){return element_pos_;}
    void refered_T::element_pos(int Pos){element_pos_ = Pos;}

    T_terminal_def* refered_T::its_t_def(){
      return t_in_stbl_->t_def();
    }
    rule_def* refered_T::its_rule_def(){
      return its_subrule_def_->its_rule_def();
    }
    AST* refered_T::tree_node(){
      return tree_node_;
    }
    void refered_T::tree_node(AST* Tree_node){
      tree_node_ = Tree_node;
    }
    std::string* refered_T::grammar_s_enumerate(){
      return &grammar_s_enumerate_;
    }
    void refered_T::grammar_s_enumerate(const char* Enumerate){
      grammar_s_enumerate_+=Enumerate;
    }

   T_in_stbl* refered_T::t_in_stbl(){
      return t_in_stbl_;
    }
    
    T_subrule_def* refered_T::its_subrule_def(){
      return its_subrule_def_;
    }
    
    void refered_T::its_subrule_def(T_subrule_def* Its_subrule){
      its_subrule_def_ = Its_subrule;
    }
  
    rule_in_stbl::rule_in_stbl(rule_def& Rule_def)
      T_CTOR("rule-in-stbl",T_Enum::T_rule_in_stbl_,0,false,false)
      {r_def_ = &Rule_def;
      stbl_idx_ = -1;
    }
    rule_def* rule_in_stbl::r_def(){
      return r_def_;
    }
    std::list<refered_rule*>* rule_in_stbl::xref_r(){
		return  &xref_r_;;   
    }
    void rule_in_stbl::add_R_into_xref(refered_rule& R){
      xref_r_.push_back(&R);
    }
    void rule_in_stbl::stbl_idx(yacco2::UINT Idx){stbl_idx_ = Idx;}
    int rule_in_stbl::stbl_idx(){return stbl_idx_;}
  
    refered_rule::refered_rule(rule_in_stbl& Rule_in_stbl)
      T_CTOR("refered-rule",T_Enum::T_refered_rule_,0,false,false)
      {rule_in_stbl_ = &Rule_in_stbl;
      its_subrule_def_ = 0;
      tree_node_ = 0;
      element_pos_ = 0;
    }
    int refered_rule::element_pos(){return element_pos_;}
    void refered_rule::element_pos(int Pos){element_pos_ = Pos;}
    rule_def* refered_rule::its_rule_def(){
      return rule_in_stbl_->r_def();
    }
    AST* refered_rule::tree_node(){
      return tree_node_;
    }
    void refered_rule::tree_node(AST* Tree_node){
      tree_node_ = Tree_node;
    }
      std::string* refered_rule::grammar_s_enumerate(){
      return &grammar_s_enumerate_;
    }
    void refered_rule::grammar_s_enumerate(const char* Enumerate){
      grammar_s_enumerate_+=Enumerate;
    }
   
    T_subrule_def* refered_rule::its_subrule_def(){
      return its_subrule_def_;
    }
    
    void refered_rule::its_subrule_def(T_subrule_def* Its_subrule){
      its_subrule_def_ = Its_subrule;
    }
    
    rule_in_stbl* refered_rule::Rule_in_stbl(){
      return rule_in_stbl_;
    }
  T_transitive::
T_transitive()
 T_CTOR("transitive",T_Enum::T_T_transitive_,0,false,false){}
T_grammar_name::
T_grammar_name()
 T_CTOR("grammar-name",T_Enum::T_T_grammar_name_,0,false,false){}
T_thread_name::
T_thread_name()
 T_CTOR("thread-name",T_Enum::T_T_thread_name_,0,false,false){}
T_monolithic::
T_monolithic()
 T_CTOR("monolithic",T_Enum::T_T_monolithic_,0,false,false){}
T_no_of_T::
T_no_of_T()
 T_CTOR("no-of-T",T_Enum::T_T_no_of_T_,0,false,false){}
T_list_of_native_first_set_terminals::
T_list_of_native_first_set_terminals()
 T_CTOR("list-of-native-first-set-terminals",T_Enum::T_T_list_of_native_first_set_terminals_,0,false,false){}
T_end_list_of_native_first_set_terminals::
T_end_list_of_native_first_set_terminals()
 T_CTOR("end-list-of-native-first-set-terminals",T_Enum::T_T_end_list_of_native_first_set_terminals_,0,false,false){}
T_list_of_transitive_threads::
T_list_of_transitive_threads()
 T_CTOR("list-of-transitive-threads",T_Enum::T_T_list_of_transitive_threads_,0,false,false){}
T_end_list_of_transitive_threads::
T_end_list_of_transitive_threads()
 T_CTOR("end-list-of-transitive-threads",T_Enum::T_T_end_list_of_transitive_threads_,0,false,false){}
T_emitfile::
T_emitfile()
 T_CTOR("emitfile",T_Enum::T_T_emitfile_,0,false,false){}
T_preamble::
T_preamble()
 T_CTOR("preamble",T_Enum::T_T_preamble_,0,false,false){}
T_end_preamble::
T_end_preamble()
 T_CTOR("end-preamble",T_Enum::T_T_end_preamble_,0,false,false){}
T_T_alphabet::
T_T_alphabet()
 T_CTOR("T-alphabet",T_Enum::T_T_T_alphabet_,0,false,false){}
T_end_T_alphabet::
T_end_T_alphabet()
 T_CTOR("end-T-alphabet",T_Enum::T_T_end_T_alphabet_,0,false,false){}
T_file_of_T_alphabet::
T_file_of_T_alphabet()
 T_CTOR("file-of-T-alphabet",T_Enum::T_T_file_of_T_alphabet_,0,false,false){}

  T_attributes::T_attributes(const char* Fully_qualified_T_name,int Enum)
	T_CTOR("T-attributes",T_Enum::T_T_attributes_,0,false,false)
	{fully_qualified_T_name_ += Fully_qualified_T_name;
		T_enum_ = Enum;		
	  }
  
    tth_in_stbl::tth_in_stbl
        (T_attributes* Fnd_T_in_stbl,CAbs_lr1_sym* Rc,yacco2::Parser* P)
      T_CTOR("tth-in-stbl",T_Enum::T_tth_in_stbl_,0,false,false)
      {t_in_stbl_ = Fnd_T_in_stbl;
      set_rc(*Rc,__FILE__,__LINE__);// set its source co-ordinates
      stbl_idx_ = -1;
    }
    T_attributes* tth_in_stbl::t_in_stbl(){
      return t_in_stbl_;
    }
    void tth_in_stbl::stbl_idx(yacco2::UINT Idx){stbl_idx_ = Idx;}
    int tth_in_stbl::stbl_idx(){return stbl_idx_;}
  
  thread_attributes::thread_attributes(const char* Fully_qualified_th_name)
T_CTOR("thread-attributes",T_Enum::T_thread_attributes_,0,false,false)
		{fully_qualified_th_name_ += Fully_qualified_th_name;
		transitive_ = ' ';
		grammar_file_name_ = 0;
		name_space_name_ = 0;
		thread_name_ = 0;
		monolithic_ = ' ';
		file_name_ = 0;
		th_enum_ = -1;
                fsm_comments_ = 0;		
		called_thread_graph_ = 0;
	  }
 	  thread_attributes::thread_attributes
		(const char* Fully_qualified_th_name
		,char Transitive
		,T_c_string* Grammar_name
		,T_c_string* Name_space_name
		,T_c_string* Thread_name
		,char Monolithic
		,T_c_string* File_name
		,std::vector<int>& List_of_Ts
		,std::vector<thread_attributes*>& List_of_transitive_thds
                ,T_c_string* Fsm_comments)
	T_CTOR("thread-attributes",T_Enum::T_thread_attributes_,0,false,false)
		{fully_qualified_th_name_ += Fully_qualified_th_name;
		transitive_ = Transitive;
		grammar_file_name_ = Grammar_name;
		name_space_name_ = Name_space_name;
		thread_name_ = Thread_name;
		monolithic_ = Monolithic;
		file_name_ = File_name;
		if(!List_of_Ts.empty()){
		  copy(List_of_Ts.begin()
		      ,List_of_Ts.end()
		      ,back_inserter(list_of_Ts_));
                  std::vector<int>::iterator i = List_of_Ts.begin();
                  std::vector<int>::iterator ie = List_of_Ts.end();
                  for(;i!=ie;++i){
                    fs_.insert(*i);
                  }
                }
		if(!List_of_transitive_thds.empty())
		  copy(List_of_transitive_thds.begin()
		      ,List_of_transitive_thds.end()
		      ,back_inserter(list_of_transitive_threads_));
		th_enum_ = -1;	
                fsm_comments_ = Fsm_comments;		
		called_thread_graph_ = 0;	
	}
  
    th_in_stbl::th_in_stbl(thread_attributes* Fnd_th_in_stbl)
      T_CTOR("th-in-stbl",T_Enum::T_th_in_stbl_,0,false,false)
      {th_in_stbl_ = Fnd_th_in_stbl;
      stbl_idx_ = -1;
    }
    thread_attributes* th_in_stbl::thread_in_stbl(){
      return th_in_stbl_;
    }
    void th_in_stbl::stbl_idx(yacco2::UINT Idx){stbl_idx_ = Idx;}
    int th_in_stbl::stbl_idx(){return stbl_idx_;}
  
    kw_in_stbl::kw_in_stbl(CAbs_lr1_sym* Fnd_kw_in_stbl)
      T_CTOR("kw-in-stbl",T_Enum::T_kw_in_stbl_,0,false,false)
      {kw_in_stbl_ = Fnd_kw_in_stbl;
      stbl_idx_ = -1;
    }
    CAbs_lr1_sym* kw_in_stbl::keyword_in_stbl(){
      return kw_in_stbl_;
    }
    void kw_in_stbl::stbl_idx(yacco2::UINT Idx){stbl_idx_ = Idx;}
    int kw_in_stbl::stbl_idx(){return stbl_idx_;}
  
    T_la_expr_src::T_la_expr_src()
T_CTOR("la-express-source",T_Enum::T_T_la_expr_src_,0,false,false)
      {la_tok_can_ = new yacco2::TOKEN_GAGGLE;
    }
    void T_la_expr_src::zero_la_tok_can(){
      la_tok_can_ = 0;
    }
    yacco2::TOKEN_GAGGLE* T_la_expr_src::la_tok_can(){
      return la_tok_can_;
    }
  
    T_eosubrule::T_eosubrule()
      T_CTOR("eosubrule",T_Enum::T_T_eosubrule_,0,false,false){
      its_subrule_def_ = 0;
      tree_node_ = 0;
      element_pos_ = 0;
   }
    int T_eosubrule::element_pos(){return element_pos_;}
    void T_eosubrule::element_pos(int Pos){element_pos_ = Pos;}

    rule_def* T_eosubrule::its_rule_def(){
      return its_subrule_def_->its_rule_def();
    }
    AST* T_eosubrule::tree_node(){
      return tree_node_;
    }
    void T_eosubrule::tree_node(AST* Tree_node){
      tree_node_ = Tree_node;
    }
    
    std::string* T_eosubrule::grammar_s_enumerate(){
      return &grammar_s_enumerate_;
    }
    void T_eosubrule::grammar_s_enumerate(const char* Enumerate){
      grammar_s_enumerate_+=Enumerate;
    }
    T_subrule_def* T_eosubrule::its_subrule_def(){
      return its_subrule_def_;
    }
    
    void T_eosubrule::its_subrule_def(T_subrule_def* Its_subrule){
      its_subrule_def_ = Its_subrule;
    }
  
T_called_thread_eosubrule::T_called_thread_eosubrule
        (T_identifier* Ns,T_identifier* Thd_name)
T_CTOR("called thread eosubrule",T_Enum::T_T_called_thread_eosubrule_,0,false,false){
      its_subrule_def_ = 0;
      tree_node_ = 0;
      ns_ = Ns;
      called_thread_name_ = Thd_name;
      element_pos_ = 0;
    }
    int T_called_thread_eosubrule::element_pos(){return element_pos_;}
    void T_called_thread_eosubrule::element_pos(int Pos){element_pos_ = Pos;}
      T_identifier* T_called_thread_eosubrule::ns(){
      return ns_;
    }
      T_identifier* T_called_thread_eosubrule::called_thread_name(){
      return called_thread_name_;
    }
    rule_def* T_called_thread_eosubrule::its_rule_def(){
      return its_subrule_def_->its_rule_def();
    }
    AST* T_called_thread_eosubrule::tree_node(){
      return tree_node_;
    }
    void T_called_thread_eosubrule::tree_node(AST* Tree_node){
      tree_node_ = Tree_node;
    }
    
    std::string* T_called_thread_eosubrule::grammar_s_enumerate(){
      return &grammar_s_enumerate_;
    }
    void T_called_thread_eosubrule::grammar_s_enumerate(const char* Enumerate){
      grammar_s_enumerate_+=Enumerate;
    }
    T_subrule_def* T_called_thread_eosubrule::its_subrule_def(){
      return its_subrule_def_;
    }
    
    void T_called_thread_eosubrule::its_subrule_def(T_subrule_def* Its_subrule){
      its_subrule_def_ = Its_subrule;
    }
  
    T_null_call_thread_eosubrule::T_null_call_thread_eosubrule()
T_CTOR("null call thread eosubrule",T_Enum::T_T_null_call_thread_eosubrule_,0,false,false){
      its_subrule_def_ = 0;
      tree_node_ = 0;
      element_pos_ = 0;
    }
    int T_null_call_thread_eosubrule::element_pos(){return element_pos_;}
    void T_null_call_thread_eosubrule::element_pos(int Pos){element_pos_ = Pos;}
    rule_def* T_null_call_thread_eosubrule::its_rule_def(){
      return its_subrule_def_->its_rule_def();
    }
    AST* T_null_call_thread_eosubrule::tree_node(){
      return tree_node_;
    }
    void T_null_call_thread_eosubrule::tree_node(AST* Tree_node){
      tree_node_ = Tree_node;
    }
    
    std::string* T_null_call_thread_eosubrule::grammar_s_enumerate(){
      return &grammar_s_enumerate_;
    }
    void T_null_call_thread_eosubrule::grammar_s_enumerate(const char* Enumerate){
      grammar_s_enumerate_+=Enumerate;
    }
    T_subrule_def* T_null_call_thread_eosubrule::its_subrule_def(){
      return its_subrule_def_;
    }
    
    void T_null_call_thread_eosubrule::its_subrule_def(T_subrule_def* Its_subrule){
      its_subrule_def_ = Its_subrule;
    }
  
    T_cweb_comment::
    T_cweb_comment(const std::string& Comment_data) 
      T_CTOR("cweb-comment",T_Enum::T_T_cweb_comment_,0,false,false)
      {comment_data_ = Comment_data;}
    std::string* T_cweb_comment::comment_data(){return &comment_data_;}
	T_grammar_phrase::
T_grammar_phrase()
 T_CTOR("grammar-phrase",T_Enum::T_T_grammar_phrase_,0,false,false){}

    T_cweb_marker::
    T_cweb_marker(AST* Node) 
      T_CTOR("cweb-marker",T_Enum::T_T_cweb_marker_,0,false,false)
      {ast_ = Node;}
    T_cweb_marker::
    T_cweb_marker() 
      T_CTOR("cweb-marker",T_Enum::T_T_cweb_marker_,0,false,false)
      {ast_ = 0;}
      AST* T_cweb_marker::ast(){return ast_;}
	
    T_lint::T_lint()
    T_CTOR("lint",T_Enum::T_T_lint_,0,false,false)
    {}
    T_lint lint__;
    yacco2::CAbs_lr1_sym* NS_yacco2_terminals::PTR_lint__ = &lint__;
  T_list_of_used_threads::
T_list_of_used_threads()
 T_CTOR("list-of-used-threads",T_Enum::T_T_list_of_used_threads_,0,false,false){}
T_end_list_of_used_threads::
T_end_list_of_used_threads()
 T_CTOR("end-list-of-used-threads",T_Enum::T_T_end_list_of_used_threads_,0,false,false){}
