/* File: fsm_class_phrase_th.cpp Date and Time: Fri Jan 30 18:55:12 2015 */ #include "fsm_class_phrase_th.h" using namespace NS_yacco2_T_enum;// enumerate using namespace NS_yacco2_err_symbols;// error symbols using namespace NS_yacco2_k_symbols;// lrk using namespace NS_yacco2_terminals;// terminals using namespace NS_yacco2_characters;// rc using namespace yacco2;// yacco2 library using namespace NS_fsm_class_phrase_th;// grammar's ns // first set terminals fsm_rules_reuse_table_type::fsm_rules_reuse_table_type(){ no_rules_entries_ = 15; per_rule_s_table_[0] = new Per_rule_s_reuse_table(); per_rule_s_table_[1] = new Per_rule_s_reuse_table(); per_rule_s_table_[2] = new Per_rule_s_reuse_table(); per_rule_s_table_[3] = new Per_rule_s_reuse_table(); per_rule_s_table_[4] = new Per_rule_s_reuse_table(); per_rule_s_table_[5] = new Per_rule_s_reuse_table(); per_rule_s_table_[6] = new Per_rule_s_reuse_table(); per_rule_s_table_[7] = new Per_rule_s_reuse_table(); per_rule_s_table_[8] = new Per_rule_s_reuse_table(); per_rule_s_table_[9] = new Per_rule_s_reuse_table(); per_rule_s_table_[10] = new Per_rule_s_reuse_table(); per_rule_s_table_[11] = new Per_rule_s_reuse_table(); per_rule_s_table_[12] = new Per_rule_s_reuse_table(); per_rule_s_table_[13] = new Per_rule_s_reuse_table(); per_rule_s_table_[14] = new Per_rule_s_reuse_table(); } Cfsm_class_phrase_th:: Cfsm_class_phrase_th() :yacco2::CAbs_fsm ("fsm_class_phrase_th.lex" ,"1.0" ,"2 mar 2004" ,false ,"Parse the fsm-class grammar construct." ,"Fri Jan 30 18:55:12 2015 " ,S1_Cfsm_class_phrase_th){ fsm_class_phrase_ = 0; } Cfsm_class_phrase_th::~Cfsm_class_phrase_th(){ for(int x = 0;x < 15;++x){ ///delete fsm_rules_reuse_table.per_rule_s_table_[x]; } } bool Cfsm_class_phrase_th::failed(){ return false; } void Cfsm_class_phrase_th::op(){ if(fsm_class_phrase_ != 0){ delete fsm_class_phrase_; fsm_class_phrase_ = 0; } fsm_class_phrase_ = new T_fsm_class_phrase; fsm_class_phrase_->set_rc(*parser__->start_token__,__FILE__,__LINE__); AST* t = new AST(*fsm_class_phrase_); fsm_class_phrase_->phrase_tree(t); } int Cfsm_class_phrase_th::rhs_to_rules_mapping_[49] = { -1 ,0 // subrule 1 for rule 1 ,1 // subrule 2 for rule 2 ,1 // subrule 3 for rule 2 ,1 // subrule 4 for rule 2 ,2 // subrule 5 for rule 3 ,3 // subrule 6 for rule 4 ,3 // subrule 7 for rule 4 ,4 // subrule 8 for rule 5 ,5 // subrule 9 for rule 6 ,5 // subrule 10 for rule 6 ,5 // subrule 11 for rule 6 ,5 // subrule 12 for rule 6 ,5 // subrule 13 for rule 6 ,5 // subrule 14 for rule 6 ,5 // subrule 15 for rule 6 ,5 // subrule 16 for rule 6 ,5 // subrule 17 for rule 6 ,5 // subrule 18 for rule 6 ,5 // subrule 19 for rule 6 ,5 // subrule 20 for rule 6 ,6 // subrule 21 for rule 7 ,6 // subrule 22 for rule 7 ,7 // subrule 23 for rule 8 ,7 // subrule 24 for rule 8 ,8 // subrule 25 for rule 9 ,8 // subrule 26 for rule 9 ,9 // subrule 27 for rule 10 ,9 // subrule 28 for rule 10 ,9 // subrule 29 for rule 10 ,9 // subrule 30 for rule 10 ,9 // subrule 31 for rule 10 ,9 // subrule 32 for rule 10 ,9 // subrule 33 for rule 10 ,9 // subrule 34 for rule 10 ,9 // subrule 35 for rule 10 ,9 // subrule 36 for rule 10 ,9 // subrule 37 for rule 10 ,10 // subrule 38 for rule 11 ,10 // subrule 39 for rule 11 ,11 // subrule 40 for rule 12 ,11 // subrule 41 for rule 12 ,12 // subrule 42 for rule 13 ,12 // subrule 43 for rule 13 ,13 // subrule 44 for rule 14 ,13 // subrule 45 for rule 14 ,13 // subrule 46 for rule 14 ,14 // subrule 47 for rule 15 ,14 // subrule 48 for rule 15 }; void Cfsm_class_phrase_th::remove_directives_from_map(){ delete fsm_class_phrase_; fsm_class_phrase_ = 0; } yacco2::CAbs_lr1_sym* // 0 - ok, or error Cfsm_class_phrase_th:: add_directive_to_map(yacco2::CAbs_lr1_sym* Directive){ CAbs_lr1_sym* sym = fsm_class_phrase_->add_directive_to_map(Directive,parser__); return sym; } void Cfsm_class_phrase_th:: add_sdc_to_directive(yacco2::CAbs_lr1_sym* Dr,T_syntax_code* Sdc){ using namespace NS_yacco2_T_enum; int eid = Dr->enumerated_id__; switch (eid){ case T_Enum::T_T_user_declaration_: { T_user_declaration* k = (T_user_declaration*)Dr; k->syntax_code(Sdc); break; } case T_Enum::T_T_user_prefix_declaration_: { T_user_prefix_declaration* k = (T_user_prefix_declaration*)Dr; k->syntax_code(Sdc); break; } case T_Enum::T_T_user_suffix_declaration_: { T_user_suffix_declaration* k = (T_user_suffix_declaration*)Dr; k->syntax_code(Sdc); break; } case T_Enum::T_T_constructor_: { T_constructor* k = (T_constructor*)Dr; k->syntax_code(Sdc); break; } case T_Enum::T_T_destructor_: { T_destructor* k = (T_destructor*)Dr; k->syntax_code(Sdc); break; } case T_Enum::T_T_op_: { T_op* k = (T_op*)Dr; k->syntax_code(Sdc); break; } case T_Enum::T_T_failed_: { T_failed* k = (T_failed*)Dr; k->syntax_code(Sdc); break; } case T_Enum::T_T_user_implementation_: { T_user_implementation* k = (T_user_implementation*)Dr; k->syntax_code(Sdc); break; } case T_Enum::T_T_user_imp_tbl_: { T_user_imp_tbl* k = (T_user_imp_tbl*)Dr; k->syntax_code(Sdc); break; } case T_Enum::T_T_user_imp_sym_: { T_user_imp_sym* k = (T_user_imp_sym*)Dr; k->syntax_code(Sdc); break; } default: { CAbs_lr1_sym* sym = new Err_improper_directive; sym->set_rc(*Dr,__FILE__,__LINE__); RSVP_FSM(sym); parser__->set_stop_parse(true); } } } Rfsm_class_phrase_th::Rfsm_class_phrase_th(yacco2::Parser* P) :CAbs_lr1_sym ("Rfsm_class_phrase_th",0,Cfsm_class_phrase_th::R_Rfsm_class_phrase_th_,P,false,false){ } void Rfsm_class_phrase_th::sr1(){ Cfsm_class_phrase_th* fsm = (Cfsm_class_phrase_th*)rule_info__.parser__->fsm_tbl__; RSVP(fsm->fsm_class_phrase_); fsm->fsm_class_phrase_ = 0; } Rid::Rid(yacco2::Parser* P) :CAbs_lr1_sym ("Rid",0,Cfsm_class_phrase_th::R_Rid_,P,false,false){ } void Rid::sr1(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_identifier* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); Cfsm_class_phrase_th* fsm = (Cfsm_class_phrase_th*)rule_info__.parser__->fsm_tbl__; fsm->fsm_class_phrase_->identifier(sf->p2__); } void Rid::sr2(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; CAbs_lr1_sym* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); sf->p2__->set_auto_delete(true); CAbs_lr1_sym* sym = new Err_no_identifier_present; sym->set_rc(*sf->p2__,__FILE__,__LINE__); RSVP(sym); rule_info__.parser__->set_stop_parse(true); } void Rid::sr3(){ CAbs_lr1_sym* sym = new Err_no_identifier_present; sym->set_rc(*rule_info__.parser__->current_token(),__FILE__,__LINE__); RSVP(sym); rule_info__.parser__->set_stop_parse(true); } Rpotential_code_blk::Rpotential_code_blk(yacco2::Parser* P) :CAbs_lr1_sym ("Rpotential_code_blk",0,Cfsm_class_phrase_th::R_Rpotential_code_blk_,P,false,false){ } Rpotential_directives::Rpotential_directives(yacco2::Parser* P) :CAbs_lr1_sym ("Rpotential_directives",0,Cfsm_class_phrase_th::R_Rpotential_directives_,P,false,false){ } Rmust_directive_phrase::Rmust_directive_phrase(yacco2::Parser* P) :CAbs_lr1_sym ("Rmust_directive_phrase",0,Cfsm_class_phrase_th::R_Rmust_directive_phrase_,P,false,false){ } void Rmust_directive_phrase::sr1(){ struct SF{ Rdirective_cweb_k* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; Rlint* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; Rmust_directive* p3__; State* s3__; bool abort3__; Rule_s_reuse_entry* rule_s_reuse_entry3__; Rsyntax_code* p4__; State* s4__; bool abort4__; Rule_s_reuse_entry* rule_s_reuse_entry4__; Rlint* p5__; State* s5__; bool abort5__; Rule_s_reuse_entry* rule_s_reuse_entry5__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(5); AST* cwebt = sf->p1__->cweb_t_; Rmust_directive* dir = sf->p3__; Rsyntax_code* sdc = sf->p4__; if(cwebt != 0) sdc->syntax_code_->add_cweb_marker(cwebt); Cfsm_class_phrase_th* fsm = (Cfsm_class_phrase_th*)rule_info__.parser__->fsm_tbl__; fsm->add_sdc_to_directive(dir->directive_,sdc->syntax_code_); } Rmust_directive::Rmust_directive(yacco2::Parser* P) :CAbs_lr1_sym ("Rmust_directive",0,Cfsm_class_phrase_th::R_Rmust_directive_,P,false,false){ } void Rmust_directive::op(){ sstrace_rulesss if(directive_ == 0) return; Cfsm_class_phrase_th* fsm = ( Cfsm_class_phrase_th*)rule_info__.parser__->fsm_tbl__; CAbs_lr1_sym* result = fsm->add_directive_to_map(directive_); if(result == 0) return;// ok added directive_->set_auto_delete(true);//dup: delete when popped from stack RSVP(result); rule_info__.parser__->set_stop_parse(true); } void Rmust_directive::sr1(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_user_declaration* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rmust_directive::sr2(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_user_implementation* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rmust_directive::sr3(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_user_prefix_declaration* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rmust_directive::sr4(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_user_suffix_declaration* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rmust_directive::sr5(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_constructor* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rmust_directive::sr6(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_destructor* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rmust_directive::sr7(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_op* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rmust_directive::sr8(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_failed* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rmust_directive::sr9(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_user_imp_tbl* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rmust_directive::sr10(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_user_imp_sym* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rmust_directive::sr11(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; CAbs_lr1_sym* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = 0; sf->p2__->set_auto_delete(true); CAbs_lr1_sym* sym = new Err_improper_directive; sym->set_rc(*sf->p2__,__FILE__,__LINE__); RSVP(sym); rule_info__.parser__->set_stop_parse(true); } void Rmust_directive::sr12(){ struct SF{ CAbs_lr1_sym* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(1); directive_ = 0; CAbs_lr1_sym* sym = new Err_no_directive_present; sym->set_rc(*sf->p1__,__FILE__,__LINE__); RSVP(sym); rule_info__.parser__->set_stop_parse(true); } Rmaybe_more_directives::Rmaybe_more_directives(yacco2::Parser* P) :CAbs_lr1_sym ("Rmaybe_more_directives",0,Cfsm_class_phrase_th::R_Rmaybe_more_directives_,P,false,false){ } Rmaybe_directive_phrases::Rmaybe_directive_phrases(yacco2::Parser* P) :CAbs_lr1_sym ("Rmaybe_directive_phrases",0,Cfsm_class_phrase_th::R_Rmaybe_directive_phrases_,P,false,false){ } Rmaybe_directive_phrase::Rmaybe_directive_phrase(yacco2::Parser* P) :CAbs_lr1_sym ("Rmaybe_directive_phrase",0,Cfsm_class_phrase_th::R_Rmaybe_directive_phrase_,P,false,false){ } void Rmaybe_directive_phrase::sr1(){ struct SF{ Rcweb_k* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; Rlint* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; Rdirective* p3__; State* s3__; bool abort3__; Rule_s_reuse_entry* rule_s_reuse_entry3__; Rsyntax_code* p4__; State* s4__; bool abort4__; Rule_s_reuse_entry* rule_s_reuse_entry4__; Rlint* p5__; State* s5__; bool abort5__; Rule_s_reuse_entry* rule_s_reuse_entry5__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(5); AST* cwebt = sf->p1__->cweb_t_; Rdirective* dir = sf->p3__; Rsyntax_code* sdc = sf->p4__; if(cwebt != 0) sdc->syntax_code_->add_cweb_marker(cwebt); Cfsm_class_phrase_th* fsm = (Cfsm_class_phrase_th*)rule_info__.parser__->fsm_tbl__; fsm->add_sdc_to_directive(dir->directive_,sdc->syntax_code_); } void Rmaybe_directive_phrase::sr2(){ struct SF{ Rdirective* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; Rsyntax_code* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; Rlint* p3__; State* s3__; bool abort3__; Rule_s_reuse_entry* rule_s_reuse_entry3__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(3); Rdirective* dir = sf->p1__; Rsyntax_code* sdc = sf->p2__; Cfsm_class_phrase_th* fsm = (Cfsm_class_phrase_th*)rule_info__.parser__->fsm_tbl__; fsm->add_sdc_to_directive(dir->directive_,sdc->syntax_code_); } Rdirective::Rdirective(yacco2::Parser* P) :CAbs_lr1_sym ("Rdirective",0,Cfsm_class_phrase_th::R_Rdirective_,P,false,false){ } void Rdirective::op(){ sstrace_rulesss if(directive_ == 0) return; Cfsm_class_phrase_th* fsm = ( Cfsm_class_phrase_th*)rule_info__.parser__->fsm_tbl__; CAbs_lr1_sym* result = fsm->add_directive_to_map(directive_); if(result == 0) return;// ok added directive_->set_auto_delete(true);//dup: delete when popped from stack RSVP(result); rule_info__.parser__->set_stop_parse(true); } void Rdirective::sr1(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_user_declaration* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rdirective::sr2(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_user_implementation* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rdirective::sr3(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_user_prefix_declaration* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rdirective::sr4(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_user_suffix_declaration* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rdirective::sr5(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_constructor* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rdirective::sr6(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_destructor* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rdirective::sr7(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_op* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rdirective::sr8(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_failed* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rdirective::sr9(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_user_imp_tbl* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rdirective::sr10(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_user_imp_sym* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = sf->p2__; } void Rdirective::sr11(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; CAbs_lr1_sym* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); directive_ = 0; sf->p2__->set_auto_delete(true); CAbs_lr1_sym* sym = new Err_improper_directive; sym->set_rc(*sf->p2__,__FILE__,__LINE__); RSVP(sym); rule_info__.parser__->set_stop_parse(true); } Rclosing_brace::Rclosing_brace(yacco2::Parser* P) :CAbs_lr1_sym ("Rclosing_brace",0,Cfsm_class_phrase_th::R_Rclosing_brace_,P,false,false){ } void Rclosing_brace::sr1(){ CAbs_lr1_sym* sym = new Err_no_close_brace; sym->set_rc(*rule_info__.parser__->current_token(),__FILE__,__LINE__); RSVP(sym); rule_info__.parser__->set_stop_parse(true); } Rsyntax_code::Rsyntax_code(yacco2::Parser* P) :CAbs_lr1_sym ("Rsyntax_code",0,Cfsm_class_phrase_th::R_Rsyntax_code_,P,false,false){ } void Rsyntax_code::sr1(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_syntax_code* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); syntax_code_ = sf->p2__; } void Rsyntax_code::sr2(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; CAbs_lr1_sym* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); syntax_code_ = 0; RSVP(sf->p2__); rule_info__.parser__->set_stop_parse(true); } Rlint::Rlint(yacco2::Parser* P) :CAbs_lr1_sym ("Rlint",0,Cfsm_class_phrase_th::R_Rlint_,P,false,false){ } Rdirective_cweb_k::Rdirective_cweb_k(yacco2::Parser* P) :CAbs_lr1_sym ("Rdirective_cweb_k",0,Cfsm_class_phrase_th::R_Rdirective_cweb_k_,P,false,false){ } void Rdirective_cweb_k::ctor(){ cweb_t_ = 0; } void Rdirective_cweb_k::sr2(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_cweb_comment* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); T_cweb_comment* k = sf->p2__; AST* cwebk_t_ = new AST(*k); cweb_t_ = new AST(); T_cweb_marker* cw = new T_cweb_marker(cweb_t_); AST::set_content(*cweb_t_,*cw); cw->set_rc(*k,__FILE__,__LINE__); AST::join_pts(*cweb_t_,*cwebk_t_); } void Rdirective_cweb_k::sr3(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; Err_comment_overrun* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); RSVP(sf->p2__); rule_info__.parser__->set_stop_parse(true); } Rcweb_k::Rcweb_k(yacco2::Parser* P) :CAbs_lr1_sym ("Rcweb_k",0,Cfsm_class_phrase_th::R_Rcweb_k_,P,false,false){ } void Rcweb_k::ctor(){ cweb_t_ = 0; } void Rcweb_k::sr1(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; T_cweb_comment* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); T_cweb_comment* k = sf->p2__; AST* cwebk_t_ = new AST(*k); cweb_t_ = new AST(); T_cweb_marker* cw = new T_cweb_marker(cweb_t_); AST::set_content(*cweb_t_,*cw); cw->set_rc(*k,__FILE__,__LINE__); AST::join_pts(*cweb_t_,*cwebk_t_); } void Rcweb_k::sr2(){ struct SF{ LR1_parallel_operator* p1__; State* s1__; bool abort1__; Rule_s_reuse_entry* rule_s_reuse_entry1__; Err_comment_overrun* p2__; State* s2__; bool abort2__; Rule_s_reuse_entry* rule_s_reuse_entry2__; }; SF* sf = (SF*)rule_info__.parser__->parse_stack__.sf_by_top(2); RSVP(sf->p2__); rule_info__.parser__->set_stop_parse(true); }