/*
 File: fsc_file.cpp
 Date and Time: Fri Jan 30 18:55:11 2015 
*/
#include "fsc_file.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_fsc_file;// grammar's ns
// first set terminals
fsm_rules_reuse_table_type::fsm_rules_reuse_table_type(){
 no_rules_entries_ = 46;
 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();
 per_rule_s_table_[15] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[16] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[17] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[18] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[19] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[20] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[21] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[22] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[23] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[24] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[25] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[26] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[27] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[28] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[29] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[30] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[31] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[32] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[33] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[34] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[35] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[36] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[37] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[38] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[39] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[40] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[41] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[42] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[43] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[44] =  new Per_rule_s_reuse_table();
 per_rule_s_table_[45] =  new Per_rule_s_reuse_table();
}
  Cfsc_file::
  Cfsc_file()
    :yacco2::CAbs_fsm
      ("fsc_file.lex"
      ,"1.0"
      ,"11 Mar 2005"
      ,false
      ,"\\Olinker's ``fsc'' control file parser."
      ,"Fri Jan 30 18:55:11 2015 "
      ,S1_Cfsc_file){
    
  }
 
Cfsc_file::~Cfsc_file(){

  for(int x = 0;x < 46;++x){
   ///delete fsm_rules_reuse_table.per_rule_s_table_[x];
  }
} 

  bool Cfsc_file::failed(){
      return false;
  }
  void Cfsc_file::op(){
}
int Cfsc_file::rhs_to_rules_mapping_[79] = {
 -1
 ,0 // subrule 1 for rule 1
 ,1 // subrule 2 for rule 2
 ,2 // subrule 3 for rule 3
 ,2 // subrule 4 for rule 3
 ,3 // subrule 5 for rule 4
 ,3 // subrule 6 for rule 4
 ,4 // subrule 7 for rule 5
 ,5 // subrule 8 for rule 6
 ,5 // subrule 9 for rule 6
 ,6 // subrule 10 for rule 7
 ,6 // subrule 11 for rule 7
 ,7 // subrule 12 for rule 8
 ,8 // subrule 13 for rule 9
 ,8 // subrule 14 for rule 9
 ,9 // subrule 15 for rule 10
 ,9 // subrule 16 for rule 10
 ,10 // subrule 17 for rule 11
 ,11 // subrule 18 for rule 12
 ,11 // subrule 19 for rule 12
 ,12 // subrule 20 for rule 13
 ,12 // subrule 21 for rule 13
 ,13 // subrule 22 for rule 14
 ,14 // subrule 23 for rule 15
 ,14 // subrule 24 for rule 15
 ,15 // subrule 25 for rule 16
 ,15 // subrule 26 for rule 16
 ,16 // subrule 27 for rule 17
 ,17 // subrule 28 for rule 18
 ,17 // subrule 29 for rule 18
 ,18 // subrule 30 for rule 19
 ,18 // subrule 31 for rule 19
 ,19 // subrule 32 for rule 20
 ,20 // subrule 33 for rule 21
 ,20 // subrule 34 for rule 21
 ,21 // subrule 35 for rule 22
 ,21 // subrule 36 for rule 22
 ,22 // subrule 37 for rule 23
 ,23 // subrule 38 for rule 24
 ,23 // subrule 39 for rule 24
 ,24 // subrule 40 for rule 25
 ,24 // subrule 41 for rule 25
 ,25 // subrule 42 for rule 26
 ,25 // subrule 43 for rule 26
 ,26 // subrule 44 for rule 27
 ,26 // subrule 45 for rule 27
 ,27 // subrule 46 for rule 28
 ,27 // subrule 47 for rule 28
 ,28 // subrule 48 for rule 29
 ,28 // subrule 49 for rule 29
 ,29 // subrule 50 for rule 30
 ,30 // subrule 51 for rule 31
 ,30 // subrule 52 for rule 31
 ,31 // subrule 53 for rule 32
 ,31 // subrule 54 for rule 32
 ,32 // subrule 55 for rule 33
 ,32 // subrule 56 for rule 33
 ,33 // subrule 57 for rule 34
 ,33 // subrule 58 for rule 34
 ,34 // subrule 59 for rule 35
 ,34 // subrule 60 for rule 35
 ,35 // subrule 61 for rule 36
 ,35 // subrule 62 for rule 36
 ,36 // subrule 63 for rule 37
 ,37 // subrule 64 for rule 38
 ,37 // subrule 65 for rule 38
 ,38 // subrule 66 for rule 39
 ,38 // subrule 67 for rule 39
 ,39 // subrule 68 for rule 40
 ,39 // subrule 69 for rule 40
 ,40 // subrule 70 for rule 41
 ,40 // subrule 71 for rule 41
 ,41 // subrule 72 for rule 42
 ,41 // subrule 73 for rule 42
 ,42 // subrule 74 for rule 43
 ,42 // subrule 75 for rule 43
 ,43 // subrule 76 for rule 44
 ,44 // subrule 77 for rule 45
 ,45 // subrule 78 for rule 46
}; 
Rfsc_file::Rfsc_file(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rfsc_file",0,Cfsc_file::R_Rfsc_file_,P,false,false){
}

void Rfsc_file::op(){
  sstrace_rulesss
 
   Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
   using namespace NS_yacco2_k_symbols;
   int no_T = fsm->no_native_T_->no();
   int sze_T = fsm->list_of_Ts_.size();
	if(sze_T !=no_T){
		CAbs_lr1_sym* sym = new Err_no_of_native_Ts_in_list_not_equal(sze_T);
		sym->set_rc(*fsm->no_native_T_,__FILE__,__LINE__);
		ADD_TOKEN_TO_ERROR_QUEUE(*sym);
		return;
	}
	int no_th = fsm->no_threads_->no();
    int sze_th = fsm->list_of_transitive_threads_.size();
	if(sze_th != no_th){
		CAbs_lr1_sym* sym = new Err_no_of_threads_in_list_not_equal(sze_th);
		sym->set_rc(*fsm->no_threads_,__FILE__,__LINE__);
		ADD_TOKEN_TO_ERROR_QUEUE(*sym);
		return;
	}
   if(fsm->monolithic_ == 'n'){// pass epsilon pass thru: thread grammar only
     if((no_T == 0) && (no_th == 0)){
		    CAbs_lr1_sym* sym = new Err_epsilon_pass_thru;
            sym->set_rc(*fsm->no_native_T_,__FILE__,__LINE__);
            ADD_TOKEN_TO_ERROR_QUEUE(*sym);
            rule_info__.parser__->set_stop_parse(true);
            return;     
     }
     if((no_T == 1) && (no_th == 0)){
       int transience = fsm->list_of_Ts_[0];
       if(transience == 7){// \transienceoperator operator
		    CAbs_lr1_sym* sym = new Err_epsilon_pass_thru_no_Ts;
            sym->set_rc(*fsm->no_native_T_,__FILE__,__LINE__);
            ADD_TOKEN_TO_ERROR_QUEUE(*sym);
            rule_info__.parser__->set_stop_parse(true);
            return;
       }     
     }
   }
      
    using namespace yacco2_stbl;
	T_sym_tbl_report_card report_card;
	find_sym_in_stbl(report_card,*fsm->fully_qualified_th_name_.c_str());
	if(report_card.action_ == T_sym_tbl_report_card::fnd){// crted by another fsc file
	  if(report_card.tbl_entry_->defined_ == true){// probably dup fsc file
		    CAbs_lr1_sym* sym = new Err_already_defined_in_fsc_file;
            sym->set_rc(*fsm->thread_name_,__FILE__,__LINE__);
            ADD_TOKEN_TO_ERROR_QUEUE(*sym);
            rule_info__.parser__->set_stop_parse(true);
            return;
	  }
	  report_card.tbl_entry_->defined_ = true;
	  th_in_stbl* th_in_tbl = (th_in_stbl*)report_card.tbl_entry_->symbol_;
	  thread_attributes* th_entry = th_in_tbl->thread_in_stbl();
	  th_entry->transitive_ = fsm->transitive_;
	  th_entry->grammar_file_name_ = fsm->grammar_file_name_;
	  th_entry->name_space_name_ = fsm->name_space_name_;
	  th_entry->thread_name_ = fsm->thread_name_;
	  th_entry->monolithic_ = fsm->monolithic_;
	  th_entry->file_name_ = fsm->file_name_;
	  th_entry->fsm_comments_ = fsm->fsm_comments_;
	  if(!fsm->list_of_Ts_.empty())
		 copy(fsm->list_of_Ts_.begin()
		        ,fsm->list_of_Ts_.end()
		        ,back_inserter(th_entry->list_of_Ts_));
	  if(!fsm->list_of_transitive_threads_.empty())
		  copy(fsm->list_of_transitive_threads_.begin()
		      ,fsm->list_of_transitive_threads_.end()
		      ,back_inserter(th_entry->list_of_transitive_threads_));
	  return;
	}
	  thread_attributes* th_id = 
		  new thread_attributes(fsm->fully_qualified_th_name_.c_str()
		  ,fsm->transitive_
		  ,fsm->grammar_file_name_
		  ,fsm->name_space_name_
		  ,fsm->thread_name_
		  ,fsm->monolithic_
		  ,fsm->file_name_
		  ,fsm->list_of_Ts_
		  ,fsm->list_of_transitive_threads_
                  ,fsm->fsm_comments_);
	  th_in_stbl* t = new th_in_stbl(th_id);
	  add_sym_to_stbl(report_card
		             ,*fsm->fully_qualified_th_name_.c_str()
		             ,*t
		             ,table_entry::defed
		             ,table_entry::thread);
	  	if(report_card.status_ != T_sym_tbl_report_card::okay){
	  	  t->stbl_idx(report_card.pos_);
          report_card.err_entry_->set_rc(*th_id,__FILE__,__LINE__);
          ADD_TOKEN_TO_ERROR_QUEUE(*report_card.err_entry_);
          rule_info__.parser__->set_stop_parse(true);
          return;
	  }
      GRAMMAR_DICTIONARY.push_back(report_card.tbl_entry_);
      th_id->th_enum_ = GRAMMAR_DICTIONARY.size()-1;

      ADD_TOKEN_TO_PRODUCER_QUEUE(*yacco2::PTR_LR1_eog__);   
      ADD_TOKEN_TO_PRODUCER_QUEUE(*yacco2::PTR_LR1_eog__);  
  
}
Rtransitive_phrase::Rtransitive_phrase(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rtransitive_phrase",0,Cfsc_file::R_Rtransitive_phrase_,P,false,false){
}

Rtransitive::Rtransitive(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rtransitive",0,Cfsc_file::R_Rtransitive_,P,false,false){
}

void Rtransitive::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_transitive_kw_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rtransitive_value::Rtransitive_value(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rtransitive_value",0,Cfsc_file::R_Rtransitive_value_,P,false,false){
}

void Rtransitive_value::sr1(){
  struct SF{
   T_identifier* 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);
  
      Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      T_identifier* k = sf->p1__;
      if(k->identifier()->size() != 1){
        CAbs_lr1_sym* sym = new Err_transitive_value_bad;
        sym->set_rc(*sf->p1__,__FILE__,__LINE__);
        ADD_TOKEN_TO_ERROR_QUEUE(*sym);
        rule_info__.parser__->set_stop_parse(true);
        return;
      }
	  char c = (*k->identifier())[0];
      if(c == 'n' || c == 'y'){
		fsm->transitive_ = c;
		return;      
      }
        CAbs_lr1_sym* sym = new Err_transitive_value_bad;
        sym->set_rc(*sf->p1__,__FILE__,__LINE__);
        ADD_TOKEN_TO_ERROR_QUEUE(*sym);
        rule_info__.parser__->set_stop_parse(true);
    
}

void Rtransitive_value::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_transitive_value_bad;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rgrammar_name_phrase::Rgrammar_name_phrase(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rgrammar_name_phrase",0,Cfsc_file::R_Rgrammar_name_phrase_,P,false,false){
}

Rgrammar_name::Rgrammar_name(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rgrammar_name",0,Cfsc_file::R_Rgrammar_name_,P,false,false){
}

void Rgrammar_name::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_grammar_name_kw_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rgrammar_name_value::Rgrammar_name_value(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rgrammar_name_value",0,Cfsc_file::R_Rgrammar_name_value_,P,false,false){
}

void Rgrammar_name_value::sr1(){
  struct SF{
   T_c_string* 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);
  
      Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      fsm->grammar_file_name_ = sf->p1__; 
    
}

void Rgrammar_name_value::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_grammar_name_value_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rnamespace_phrase::Rnamespace_phrase(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rnamespace_phrase",0,Cfsc_file::R_Rnamespace_phrase_,P,false,false){
}

Rnamespace::Rnamespace(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rnamespace",0,Cfsc_file::R_Rnamespace_,P,false,false){
}

void Rnamespace::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_namespace_kw_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rnamespace_value::Rnamespace_value(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rnamespace_value",0,Cfsc_file::R_Rnamespace_value_,P,false,false){
}

void Rnamespace_value::sr1(){
  struct SF{
   T_c_string* 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);
  
      Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      fsm->name_space_name_ = sf->p1__; 
    
}

void Rnamespace_value::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_namespace_value_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rthreadname_phrase::Rthreadname_phrase(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rthreadname_phrase",0,Cfsc_file::R_Rthreadname_phrase_,P,false,false){
}

Rthreadname::Rthreadname(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rthreadname",0,Cfsc_file::R_Rthreadname_,P,false,false){
}

void Rthreadname::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_threadname_kw_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rthreadname_value::Rthreadname_value(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rthreadname_value",0,Cfsc_file::R_Rthreadname_value_,P,false,false){
}

void Rthreadname_value::sr1(){
  struct SF{
   T_c_string* 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);
  
      Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      fsm->thread_name_ = sf->p1__;
      fsm->fully_qualified_th_name_+= fsm->name_space_name_->c_string()->c_str(); 
      fsm->fully_qualified_th_name_ += "::"; 
      fsm->fully_qualified_th_name_ += fsm->thread_name_->c_string()->c_str();
      T_identifier* th_id = new T_identifier(fsm->fully_qualified_th_name_.c_str()); 
      th_id->set_rc(*fsm->thread_name_,__FILE__,__LINE__);
     string gnm(sf->p1__->c_string()->c_str());
        USED_THREADS_LIST[gnm] = std::vector<string>();
     std::map<std::string, std::vector<std::string> >::iterator i = USED_THREADS_LIST.find(gnm);   
     fsm->used_threads_ = &i->second;
    
}

void Rthreadname_value::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_threadname_value_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
     ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rmonolithic_phrase::Rmonolithic_phrase(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rmonolithic_phrase",0,Cfsc_file::R_Rmonolithic_phrase_,P,false,false){
}

Rmonolithic::Rmonolithic(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rmonolithic",0,Cfsc_file::R_Rmonolithic_,P,false,false){
}

void Rmonolithic::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_monolithic_kw_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rmonolithic_value::Rmonolithic_value(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rmonolithic_value",0,Cfsc_file::R_Rmonolithic_value_,P,false,false){
}

void Rmonolithic_value::sr1(){
  struct SF{
   T_identifier* 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);
  
      Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      T_identifier* k = sf->p1__;
      if(k->identifier()->size() != 1){
        CAbs_lr1_sym* sym = new Err_monolithic_value_bad;
        sym->set_rc(*sf->p1__,__FILE__,__LINE__);
       ADD_TOKEN_TO_ERROR_QUEUE(*sym);
        rule_info__.parser__->set_stop_parse(true);
        return;
      }  
	  char c = (*k->identifier())[0];
	  if(c == 'n' || c == 'y'){
			fsm->monolithic_ = c;
			return;      
	  }
      CAbs_lr1_sym* sym = new Err_monolithic_value_bad;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
     ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

void Rmonolithic_value::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_monolithic_value_bad;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rfilename_phrase::Rfilename_phrase(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rfilename_phrase",0,Cfsc_file::R_Rfilename_phrase_,P,false,false){
}

Rfilename::Rfilename(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rfilename",0,Cfsc_file::R_Rfilename_,P,false,false){
}

void Rfilename::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_filename_kw_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rfilename_value::Rfilename_value(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rfilename_value",0,Cfsc_file::R_Rfilename_value_,P,false,false){
}

void Rfilename_value::sr1(){
  struct SF{
   T_c_string* 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);
  
      Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      fsm->file_name_ = sf->p1__; 
    
}

void Rfilename_value::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_filename_value_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rno_of_T_phrase::Rno_of_T_phrase(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rno_of_T_phrase",0,Cfsc_file::R_Rno_of_T_phrase_,P,false,false){
}

Rno_of_T::Rno_of_T(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rno_of_T",0,Cfsc_file::R_Rno_of_T_,P,false,false){
}

void Rno_of_T::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_no_of_T_kw_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rno_of_T_value::Rno_of_T_value(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rno_of_T_value",0,Cfsc_file::R_Rno_of_T_value_,P,false,false){
}

void Rno_of_T_value::sr1(){
  struct SF{
   T_int_no* 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);
  
      Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      fsm->no_of_T_ = sf->p1__;
      // not eq make as a warning but continue parsing
      if(T_DICTIONARY.size() != sf->p1__->no()){
		CAbs_lr1_sym* sym = new Err_bad_T_alphabet;
		sym->set_rc(*sf->p1__,__FILE__,__LINE__);
		ADD_TOKEN_TO_ERROR_QUEUE(*sym);
		rule_info__.parser__->set_stop_parse(true);
      } 
    
}

void Rno_of_T_value::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_no_of_T_value_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rlist_of_native_terminals_phrase::Rlist_of_native_terminals_phrase(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rlist_of_native_terminals_phrase",0,Cfsc_file::R_Rlist_of_native_terminals_phrase_,P,false,false){
}

Rlist_of_native_fset_terminals::Rlist_of_native_fset_terminals(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rlist_of_native_fset_terminals",0,Cfsc_file::R_Rlist_of_native_fset_terminals_,P,false,false){
}

void Rlist_of_native_fset_terminals::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_list_of_terminals_kw_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rno_of_native_fset_terminals::Rno_of_native_fset_terminals(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rno_of_native_fset_terminals",0,Cfsc_file::R_Rno_of_native_fset_terminals_,P,false,false){
}

void Rno_of_native_fset_terminals::sr1(){
  struct SF{
   T_int_no* 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);
  
      Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      fsm->no_native_T_ = sf->p1__; 
    
}

void Rno_of_native_fset_terminals::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_no_of_terminals_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rfset_terminals_epi::Rfset_terminals_epi(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rfset_terminals_epi",0,Cfsc_file::R_Rfset_terminals_epi_,P,false,false){
}

Rfset_terminals::Rfset_terminals(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rfset_terminals",0,Cfsc_file::R_Rfset_terminals_,P,false,false){
}

Ra_T::Ra_T(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Ra_T",0,Cfsc_file::R_Ra_T_,P,false,false){
}

void Ra_T::sr1(){
  struct SF{
   T_identifier* 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);
  
      T_identifier* k = sf->p1__;
      CAbs_lr1_sym* sym = new Err_bad_T_in_list;
      sym->set_rc(*k,__FILE__,__LINE__);
     ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

void Ra_T::sr2(){
  struct SF{
   tth_in_stbl* 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);
  
      Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      tth_in_stbl* k = sf->p1__;
      T_attributes* T_att = k->t_in_stbl();
      fsm->list_of_Ts_.push_back(T_att->T_enum_);
    
}

Rend_list_of_native_fset_terminals::Rend_list_of_native_fset_terminals(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rend_list_of_native_fset_terminals",0,Cfsc_file::R_Rend_list_of_native_fset_terminals_,P,false,false){
}

void Rend_list_of_native_fset_terminals::sr2(){
  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);
  
       CAbs_lr1_sym* sym = new Err_end_list_native_T_kw_not_present;
       sym->set_rc(*sf->p1__,__FILE__,__LINE__); 
       ADD_TOKEN_TO_ERROR_QUEUE(*sym);
       rule_info__.parser__->set_stop_parse(true);
    
}

Rlist_of_transitive_threads_phrase::Rlist_of_transitive_threads_phrase(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rlist_of_transitive_threads_phrase",0,Cfsc_file::R_Rlist_of_transitive_threads_phrase_,P,false,false){
}

Rlist_of_transitive_threads::Rlist_of_transitive_threads(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rlist_of_transitive_threads",0,Cfsc_file::R_Rlist_of_transitive_threads_,P,false,false){
}

void Rlist_of_transitive_threads::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_no_list_of_trans_threads_kw;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rno_of_transitive_threads::Rno_of_transitive_threads(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rno_of_transitive_threads",0,Cfsc_file::R_Rno_of_transitive_threads_,P,false,false){
}

void Rno_of_transitive_threads::sr1(){
  struct SF{
   T_int_no* 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);
  
      Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      fsm->no_threads_ = sf->p1__; 
    
}

void Rno_of_transitive_threads::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_no_of_threads_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rtransitive_threads_epi::Rtransitive_threads_epi(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rtransitive_threads_epi",0,Cfsc_file::R_Rtransitive_threads_epi_,P,false,false){
}

Rtransitive_threads::Rtransitive_threads(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rtransitive_threads",0,Cfsc_file::R_Rtransitive_threads_,P,false,false){
}

Ra_th::Ra_th(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Ra_th",0,Cfsc_file::R_Ra_th_,P,false,false){
}

void Ra_th::sr1(){
  struct SF{
   T_identifier* 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);
  
 	  Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      T_identifier* k = sf->p1__;

      	using namespace yacco2_stbl;
		T_sym_tbl_report_card report_card;
		thread_attributes* th = new thread_attributes(k->identifier()->c_str());
		th->set_rc(*k,__FILE__,__LINE__);
        fsm->list_of_transitive_threads_.push_back(th);
		th_in_stbl* t = new th_in_stbl(th);
		add_sym_to_stbl(report_card
		               ,*k->identifier()->c_str()
		               ,*t
		               ,table_entry::used
		               ,table_entry::thread);
	  	if(report_card.status_ != T_sym_tbl_report_card::okay){
	  	  t->stbl_idx(report_card.pos_);
          report_card.err_entry_->set_rc(*k,__FILE__,__LINE__);
          ADD_TOKEN_TO_ERROR_QUEUE(*report_card.err_entry_);
          rule_info__.parser__->set_stop_parse(true);
          return;
		}
        GRAMMAR_DICTIONARY.push_back(report_card.tbl_entry_);
        th->th_enum_ = GRAMMAR_DICTIONARY.size()-1;

    
}

void Ra_th::sr2(){
  struct SF{
   th_in_stbl* 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);
  
 	  Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      th_in_stbl* k = sf->p1__;
      thread_attributes* th = k->thread_in_stbl();
      fsm->list_of_transitive_threads_.push_back(th);

      	using namespace yacco2_stbl;
		T_sym_tbl_report_card report_card;
		find_sym_in_stbl(report_card,*th->fully_qualified_th_name_.c_str());
	  	if(report_card.status_ != T_sym_tbl_report_card::okay){
          report_card.err_entry_->set_rc(*k,__FILE__,__LINE__);
          ADD_TOKEN_TO_ERROR_QUEUE(*report_card.err_entry_);
          rule_info__.parser__->set_stop_parse(true);
          return;
		}
		if(report_card.action_ == T_sym_tbl_report_card::fnd){// crted by another fsc file
		  report_card.tbl_entry_->used_ = true;
		  return;
		}
		if(report_card.action_ == T_sym_tbl_report_card::not_fnd){
		  CAbs_lr1_sym* sym = new Err_no_sym_defs_present;
          sym->set_rc(*k,__FILE__,__LINE__);
          ADD_TOKEN_TO_ERROR_QUEUE(*sym);
          rule_info__.parser__->set_stop_parse(true);
          return;
		}
    
}

Rend_list_of_transitive_threads::Rend_list_of_transitive_threads(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rend_list_of_transitive_threads",0,Cfsc_file::R_Rend_list_of_transitive_threads_,P,false,false){
}

void Rend_list_of_transitive_threads::sr2(){
  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);
  
       CAbs_lr1_sym* sym = new Err_end_list_of_transitive_threads_kw_not_present;
       sym->set_rc(*sf->p1__,__FILE__,__LINE__); 
       ADD_TOKEN_TO_ERROR_QUEUE(*sym);
       rule_info__.parser__->set_stop_parse(true);
    
}

Rlist_of_used_threads_phrase::Rlist_of_used_threads_phrase(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rlist_of_used_threads_phrase",0,Cfsc_file::R_Rlist_of_used_threads_phrase_,P,false,false){
}

Rlist_of_used_threads::Rlist_of_used_threads(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rlist_of_used_threads",0,Cfsc_file::R_Rlist_of_used_threads_,P,false,false){
}

void Rlist_of_used_threads::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_no_list_of_trans_threads_kw;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rno_of_used_threads::Rno_of_used_threads(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rno_of_used_threads",0,Cfsc_file::R_Rno_of_used_threads_,P,false,false){
}

void Rno_of_used_threads::sr1(){
  struct SF{
   T_int_no* 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);
  
      Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      fsm->used_no_threads_ = sf->p1__; 
    
}

void Rno_of_used_threads::sr2(){
  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);
  
      CAbs_lr1_sym* sym = new Err_no_of_threads_not_present;
      sym->set_rc(*sf->p1__,__FILE__,__LINE__);
      ADD_TOKEN_TO_ERROR_QUEUE(*sym);
      rule_info__.parser__->set_stop_parse(true);
    
}

Rused_threads_epi::Rused_threads_epi(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rused_threads_epi",0,Cfsc_file::R_Rused_threads_epi_,P,false,false){
}

Rused_threads::Rused_threads(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rused_threads",0,Cfsc_file::R_Rused_threads_,P,false,false){
}

Rb_th::Rb_th(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rb_th",0,Cfsc_file::R_Rb_th_,P,false,false){
}

void Rb_th::sr1(){
  struct SF{
   T_identifier* 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);
  
      Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      T_identifier* k = sf->p1__;

      	using namespace yacco2_stbl;
	T_sym_tbl_report_card report_card;
	thread_attributes* th = new thread_attributes(k->identifier()->c_str());
	th->set_rc(*k,__FILE__,__LINE__);
        fsm->list_of_used_threads_.push_back(th);
        std::string::size_type x = th->fully_qualified_th_name_.find("::");
        string tnm;
        string& fqn = th->fully_qualified_th_name_;
        for(int xx=x+2;xx< fqn.size();++xx){
          tnm += fqn[xx];
        }
        fsm->used_threads_->push_back(tnm);
    
}

void Rb_th::sr2(){
  struct SF{
   th_in_stbl* 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);
  
      Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      th_in_stbl* k = sf->p1__;
      thread_attributes* th = k->thread_in_stbl();
      fsm->list_of_used_threads_.push_back(th);
        std::string::size_type x = th->fully_qualified_th_name_.find("::");
        string tnm;
        string& fqn = th->fully_qualified_th_name_;
        for(int xx=x+2;xx< fqn.size();++xx){
          tnm += fqn[xx];
        }
        fsm->used_threads_->push_back(tnm);
    
}

Rend_list_of_used_threads::Rend_list_of_used_threads(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rend_list_of_used_threads",0,Cfsc_file::R_Rend_list_of_used_threads_,P,false,false){
}

void Rend_list_of_used_threads::sr2(){
  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);
  
       CAbs_lr1_sym* sym = new Err_end_list_of_transitive_threads_kw_not_present;
       sym->set_rc(*sf->p1__,__FILE__,__LINE__); 
       ADD_TOKEN_TO_ERROR_QUEUE(*sym);
       rule_info__.parser__->set_stop_parse(true);
    
}

Rfsm_comments_phrase::Rfsm_comments_phrase(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rfsm_comments_phrase",0,Cfsc_file::R_Rfsm_comments_phrase_,P,false,false){
}

Rfsm_comments::Rfsm_comments(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rfsm_comments",0,Cfsc_file::R_Rfsm_comments_,P,false,false){
}

Rfsm_comments_value::Rfsm_comments_value(yacco2::Parser* P)
 :CAbs_lr1_sym
  ("Rfsm_comments_value",0,Cfsc_file::R_Rfsm_comments_value_,P,false,false){
}

void Rfsm_comments_value::sr1(){
  struct SF{
   T_c_string* 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);
  
      Cfsc_file* fsm = (Cfsc_file*) rule_info__.parser__->fsm_tbl__;
      fsm->fsm_comments_ = sf->p1__; 
    
}

