/*
$echo file: rule8.dat
$echo  test: premature closing of rules by extra } 
$echo Error
*/

fsm	
(fsm-id "rule_def_phrase.lex"
,fsm-filename rule_def_phrase
,fsm-namespace NS_rule_def_phrase
,fsm-class Crule_def_phrase{
  user-prefix-declaration
    using namespace NS_yacco2_terminals;
    #include "c:/yacco2/compiler/grammars/ws.h"
    #include "c:/yacco2/compiler/grammars/c_comments.h"
    #include "c:/yacco2/compiler/grammars/identifier.h"
    #include "c:/yacco2/compiler/grammars/c_string.h"
    #include "c:/yacco2/compiler/grammars/terminal_def_directives.h"
    #include "c:/yacco2/compiler/grammars/terminal_def_delabort_tags.h"
    #include "c:/yacco2/compiler/grammars/subrules_phrase.h"
    #include "c:/yacco2/compiler/grammars/rule_lhs_phrase.h"
    #include "c:/yacco2/compiler/cweb/symbol table/yacco2_ste.h"
    #include "c:/yacco2/compiler/grammars/parallel_monitor_phrase.h"
  ***
  user-declaration
    public:
    T_rule_def* rule_def_;
  ***
  constructor
    rule_def_ = 0;
  ***
  destructor
    delete rule_def_; // stop_parse: clean up software dodos
  ***
  op
    if(rule_def_ != 0){
      delete rule_def_;
      rule_def_ = 0;
    }
    rule_def_ = new T_rule_def;
    // due to a compiler bug in the whos who of pc processing
    // which is not linux but win...
    //rule_def_->rc(abs_parser()->start_token(),abs_parser());
///*
    CAbs_lr1_sym* Rc = abs_parser()->start_token();
    rule_def_->tok_co_ords__.external_file_id__ = Rc->external_file_id();
    rule_def_->tok_co_ords__.rc_pos__ = Rc->rc_pos();
    rule_def_->tok_co_ords__.line_no__ = Rc->line_no();
    rule_def_->tok_co_ords__.pos_in_line__ = Rc->pos_in_line();
//*/
  ***
}
,fsm-version "1.0",fsm-date "24 mar 2004",fsm-debug "true"
,fsm-comments "into the valley of ...")
parallel-parser	
(	
  parallel-thread-function
    TH_rule_def_phrase
  ***
  parallel-la-boundary
    eolr
  ***
)
@"/yacco2/compiler/grammars/yacco2_T_includes.T"

rules{
Rrule_def_phrase AD AB(){
  -> Rid Rlint Rad_ab_tags  
         Ropen_par Rlint
             Rrule_parameters
         Rclose_par Rlint 
         Rrule_body
         {
      op
      Crule_def_phrase* fsm = (Crule_def_phrase*)abs_parser()->fsm_tbl();
      // add to global symbol table
      const char* skey = fsm->rule_def_->rule_name()->c_str();
      T_sym_tbl_report_card report_card;
      using namespace yacco2_ste;
      find_sym_in_stbl(&report_card,skey);
      if(report_card.action_ == T_sym_tbl_report_card::fnd){
        if(report_card.sym_entry_->type_ != T_table_entry::rule){
          CAbs_lr1_sym* sym = new LR1_err_stble_has_entry_but_not_a_rule;
          sym->rc(abs_parser()->start_token(),abs_parser());
          RSVP(sym)
          abs_parser()->stop_parse(true); 
          return; 
        }
        if(report_card.sym_entry_->defined_ == true){
          CAbs_lr1_sym* sym = new LR1_err_dup_entry_in_sym_table;
          sym->rc(abs_parser()->start_token(),abs_parser());
          RSVP(sym)
          abs_parser()->stop_parse(true); 
          return; 
        }
        report_card.sym_entry_->defined_ = true;
        RSVP(fsm->rule_def_)
        fsm->rule_def_ = 0;
        return; 
      }

      add_sym_to_stbl
          (&report_card
          ,skey
          ,fsm->rule_def_
          ,T_table_entry::defed
          ,T_table_entry::rule);
      RSVP(fsm->rule_def_)
      fsm->rule_def_ = 0;
    ***
    }	
}

Rid AD AB(
lhs
,parallel-control-monitor{
  arbitrator-code
  ***
  }
){
  ->  ||| identifier NS_identifier::TH_identifier {
      op
        Crule_def_phrase* fsm = (Crule_def_phrase*)abs_parser()->fsm_tbl();
        const char* skey = Sub_rule_1.p2__->identifier()->c_str();
        fsm->rule_def_->rule_name(skey);
        Sub_rule_1.p2__->auto_delete(true);
      ***
      } 
  ->  |.| {
      op
        CAbs_lr1_sym* sym = new LR1_err_no_rule_name_present;
        sym->rc(abs_parser()->current_token(),abs_parser());
        RSVP(sym)
        abs_parser()->stop_parse(true);
      ***
      }
}

Rad_ab_tags AD AB(){
  ->  Rad_ab_tag Rlint  
  ->  Rad_ab_tags Rad_ab_tag Rlint
  ->  |.|  
}

Rad_ab_tag AD AB(
lhs
,parallel-control-monitor{
  arbitrator-code
  ***
  }
){
  ->  ||| "#AD" NS_terminal_def_delabort_tags::TH_terminal_def_delabort_tags {
      op 
        Crule_def_phrase* fsm = (Crule_def_phrase*)abs_parser()->fsm_tbl();
        if(fsm->rule_def_->autodelete() == true){
			CAbs_lr1_sym* sym = new LR1_err_already_defined_AD;
			sym->rc(Sub_rule_1.p2__,abs_parser());
			RSVP(sym)
			abs_parser()->stop_parse(true);
			return;
        }
        fsm->rule_def_->autodelete(true);
      ***
      }
  ->  ||| "#AB" NULL {
      op
        Crule_def_phrase* fsm = (Crule_def_phrase*)abs_parser()->fsm_tbl();
        if(fsm->rule_def_->autoabort() == true){
			CAbs_lr1_sym* sym = new LR1_err_already_defined_AB;
			sym->rc(Sub_rule_2.p2__,abs_parser());
			RSVP(sym)
			abs_parser()->stop_parse(true);
			return;
        }
        fsm->rule_def_->autoabort(true);
      ***
      }
}

Rrule_parameters AD AB(){
  -> 
  -> Rrule_parameter
  -> Rrule_parameters "," Rrule_parameter
}

Rrule_parameter AD AB(){
  -> ||| |+| NULL{
      op
        RSVP(Sub_rule_1.p2__)
        abs_parser()->stop_parse(true);
    ***
  }
  -> Rlhs_phrase Rlint
  -> Rparallel_monitor_phrase Rlint
}

Rlhs_phrase AD AB(
lhs
,parallel-control-monitor{
  arbitrator-code
  ***
  }
){
  -> ||| "rule-lhs-phrase" NS_rule_lhs_phrase::TH_rule_lhs_phrase {
      op
      Crule_def_phrase* fsm = (Crule_def_phrase*)abs_parser()->fsm_tbl();
      fsm->rule_def_->rule_lhs(Sub_rule_1.p2__);
    ***
    }
}

Rparallel_monitor_phrase AD AB(
lhs
,parallel-control-monitor{
  arbitrator-code
  ***
  }
){
  -> ||| "parallel-monitor-phrase" NS_parallel_monitor_phrase::TH_parallel_monitor_phrase {
      op
      Crule_def_phrase* fsm = (Crule_def_phrase*)abs_parser()->fsm_tbl();
      fsm->rule_def_->parallel_mntr(Sub_rule_1.p2__);
    ***
    }
}

Rrule_body AD AB(){
  ->  Ropen_brace Rlint 
        Rsubrules 
      Rclose_brace Rlint
}

Rsubrules AD AB(
lhs
,parallel-control-monitor{
  arbitrator-code
  ***
  }
){
  ->  ||| "subrules-phrase" NS_subrules_phrase::TH_subrules_phrase{
      op
      Crule_def_phrase* fsm = (Crule_def_phrase*)abs_parser()->fsm_tbl();
      fsm->rule_def_->subrules(Sub_rule_1.p2__);
    ***
    }
  -> ||| |+| NULL{
      op
        RSVP(Sub_rule_2.p2__)
        abs_parser()->stop_parse(true);
    ***
  }
  ->  |.| { 
      op
        CAbs_lr1_sym* sym = new LR1_err_no_sub_rule_present;
        sym->rc(abs_parser()->current_token(),abs_parser());
        RSVP(sym)
        abs_parser()->stop_parse(true);
      ***
      }
}

Ropen_par AD AB(){
  ->  |.| { 
      op
        CAbs_lr1_sym* sym = new LR1_err_no_open_parenthesis;
        sym->rc(abs_parser()->current_token(),abs_parser());
        RSVP(sym)
        abs_parser()->stop_parse(true);
      ***
      }
  ->  "("
}

Rclose_par AD AB(){
  ->  |.| {
      op
        CAbs_lr1_sym* sym = new LR1_err_no_close_parenthesis;
        sym->rc(abs_parser()->current_token(),abs_parser());
        RSVP(sym)
        abs_parser()->stop_parse(true);
      ***
      }
  ->  ")"
}

Ropen_brace AD AB(){
  ->  |.| { 
      op
        CAbs_lr1_sym* sym = new LR1_err_no_open_brace;
        sym->rc(abs_parser()->current_token(),abs_parser());
        RSVP(sym)
        abs_parser()->stop_parse(true);
      ***
      }
  ->  "{"
}

Rclose_brace AD AB(){
  ->  |.| { 
      op
        CAbs_lr1_sym* sym = new LR1_err_no_closing_brace;
        sym->rc(abs_parser()->current_token(),abs_parser());
        RSVP(sym)
        abs_parser()->stop_parse(true);
      ***
      }
  }//extra

}//this stops the rules process

Rlint AD AB(){
  -> |.|
  -> Rfluffs |.| 
}

Rfluffs AD AB(){
  ->  Rfluff
  ->  Rfluffs Rfluff
}

Rfluff AD AB(
lhs
,parallel-control-monitor{
  arbitrator-code
  ***
  }
){
  ->  ||| ws NS_ws::TH_ws {
      op
        Sub_rule_1.p2__->auto_delete(true);
      ***
      }
  ->  ||| comment NS_c_comments::TH_c_comments {
      op

        Sub_rule_2.p2__->auto_delete(true);
      ***
      }
  ->  ||| |+| NULL {
      op
        RSVP(Sub_rule_3.p2__)
        abs_parser()->stop_parse(true);
      ***
      }
}
}// end of rules