/*
 File: subrule_def.h
 Date and Time: Fri Jan 30 18:55:24 2015 
*/
#ifndef __subrule_def_h__
#define __subrule_def_h__ 1
#include "yacco2.h"
#include "yacco2_T_enumeration.h"
#include "yacco2_k_symbols.h"
#include "yacco2_err_symbols.h"
#include "yacco2_terminals.h"
#include "yacco2_characters.h"

using namespace NS_yacco2_terminals;
#include "lint_balls.h"
#include "cweb_or_c_k.h"

#include "subrule_vector.h"
#include "o2_sdc.h"
#include "identifier.h"
#include "dbl_colon.h"
#include "rhs_component.h"
#include "rtn_component.h"
#include "rhs_bnd.h"
#include "parallel_oper.h"
  
extern yacco2::Thread_entry ITH_subrule_def;

extern yacco2::State S1_Csubrule_def;
namespace NS_subrule_def {
yacco2::THR _YACCO2_CALL_TYPE
TH_subrule_def(yacco2::Parser* Caller);// called thread
yacco2::THR_result _YACCO2_CALL_TYPE
PROC_TH_subrule_def(yacco2::Parser* Caller);// called thread's twin the procedure
using namespace NS_yacco2_T_enum;// enumerate
using namespace yacco2;
struct fsm_rules_reuse_table_type{
 fsm_rules_reuse_table_type();
 int no_rules_entries_;
 Per_rule_s_reuse_table* per_rule_s_table_[36];
};
class Csubrule_def: public yacco2::CAbs_fsm {
 public:
  enum rules_and_subrules{
   start_of_rule_list = NS_yacco2_T_enum::T_Enum::sum_total_T
   ,R_Rsubrule_def_ = 569//start_of_rule_list + 0
    ,rhs1_Rsubrule_def_ = 1
   ,R_Rvector_ = 570//start_of_rule_list + 2
    ,rhs1_Rvector_ = 2
   ,R_Rcommon_comments_ = 571//start_of_rule_list + 4
    ,rhs1_Rcommon_comments_ = 3
   ,R_Rrhs_expr_ = 572//start_of_rule_list + 6
    ,rhs1_Rrhs_expr_ = 4
    ,rhs2_Rrhs_expr_ = 5
    ,rhs3_Rrhs_expr_ = 6
    ,rhs4_Rrhs_expr_ = 7
    ,rhs5_Rrhs_expr_ = 8
   ,R_Rstart_thread_ = 573//start_of_rule_list + 8
    ,rhs1_Rstart_thread_ = 9
   ,R_Rbal_thread_expr_ = 574//start_of_rule_list + 10
    ,rhs1_Rbal_thread_expr_ = 10
   ,R_Rrtned_T_ = 575//start_of_rule_list + 12
    ,rhs1_Rrtned_T_ = 11
    ,rhs2_Rrtned_T_ = 12
    ,rhs3_Rrtned_T_ = 13
    ,rhs4_Rrtned_T_ = 14
   ,R_Rcalled_thread_ = 576//start_of_rule_list + 14
    ,rhs1_Rcalled_thread_ = 15
    ,rhs2_Rcalled_thread_ = 16
   ,R_RNULL_ = 577//start_of_rule_list + 16
    ,rhs1_RNULL_ = 17
   ,R_Rns_ = 578//start_of_rule_list + 18
    ,rhs1_Rns_ = 18
    ,rhs2_Rns_ = 19
    ,rhs3_Rns_ = 20
   ,R_Rdbl_colon_ = 579//start_of_rule_list + 20
    ,rhs1_Rdbl_colon_ = 21
    ,rhs2_Rdbl_colon_ = 22
    ,rhs3_Rdbl_colon_ = 23
   ,R_Rth_name_ = 580//start_of_rule_list + 22
    ,rhs1_Rth_name_ = 24
    ,rhs2_Rth_name_ = 25
    ,rhs3_Rth_name_ = 26
   ,R_Rcalled_proc_op_ = 581//start_of_rule_list + 24
    ,rhs1_Rcalled_proc_op_ = 27
   ,R_Rbal_called_proc_expr_ = 582//start_of_rule_list + 26
    ,rhs1_Rbal_called_proc_expr_ = 28
   ,R_Rcalled_proc_name_ = 583//start_of_rule_list + 28
    ,rhs1_Rcalled_proc_name_ = 29
    ,rhs2_Rcalled_proc_name_ = 30
   ,R_RTorRcomponents_epi_ = 584//start_of_rule_list + 30
    ,rhs1_RTorRcomponents_epi_ = 31
    ,rhs2_RTorRcomponents_epi_ = 32
   ,R_RTorRcomponents_ = 585//start_of_rule_list + 32
    ,rhs1_RTorRcomponents_ = 33
    ,rhs2_RTorRcomponents_ = 34
   ,R_RTorRcomponent_ = 586//start_of_rule_list + 34
    ,rhs1_RTorRcomponent_ = 35
    ,rhs2_RTorRcomponent_ = 36
    ,rhs3_RTorRcomponent_ = 37
   ,R_Rchained_dispatcher_ = 587//start_of_rule_list + 36
    ,rhs1_Rchained_dispatcher_ = 38
    ,rhs2_Rchained_dispatcher_ = 39
    ,rhs3_Rchained_dispatcher_ = 40
   ,R_Rmust_eos_ = 588//start_of_rule_list + 38
    ,rhs1_Rmust_eos_ = 41
    ,rhs2_Rmust_eos_ = 42
    ,rhs3_Rmust_eos_ = 43
   ,R_Rcalled_thd_eos_ = 589//start_of_rule_list + 40
    ,rhs1_Rcalled_thd_eos_ = 44
    ,rhs2_Rcalled_thd_eos_ = 45
   ,R_Rcalled_proc_eos_ = 590//start_of_rule_list + 42
    ,rhs1_Rcalled_proc_eos_ = 46
    ,rhs2_Rcalled_proc_eos_ = 47
   ,R_Rpotential_codeblk_ = 591//start_of_rule_list + 44
    ,rhs1_Rpotential_codeblk_ = 48
   ,R_Rpotential_directives_ = 592//start_of_rule_list + 46
    ,rhs1_Rpotential_directives_ = 49
    ,rhs2_Rpotential_directives_ = 50
   ,R_Rmust_directive_phrase_ = 593//start_of_rule_list + 48
    ,rhs1_Rmust_directive_phrase_ = 51
   ,R_Rmust_directive_ = 594//start_of_rule_list + 50
    ,rhs1_Rmust_directive_ = 52
    ,rhs2_Rmust_directive_ = 53
    ,rhs3_Rmust_directive_ = 54
   ,R_Rclose_brace_ = 595//start_of_rule_list + 52
    ,rhs1_Rclose_brace_ = 55
    ,rhs2_Rclose_brace_ = 56
   ,R_Rmaybe_more_directives_ = 596//start_of_rule_list + 54
    ,rhs1_Rmaybe_more_directives_ = 57
    ,rhs2_Rmaybe_more_directives_ = 58
   ,R_Rmaybe_directive_phrases_ = 597//start_of_rule_list + 56
    ,rhs1_Rmaybe_directive_phrases_ = 59
    ,rhs2_Rmaybe_directive_phrases_ = 60
   ,R_Rmaybe_directive_phrase_ = 598//start_of_rule_list + 58
    ,rhs1_Rmaybe_directive_phrase_ = 61
    ,rhs2_Rmaybe_directive_phrase_ = 62
   ,R_Rdirective_phrase_ = 599//start_of_rule_list + 60
    ,rhs1_Rdirective_phrase_ = 63
   ,R_Rdirective_ = 600//start_of_rule_list + 62
    ,rhs1_Rdirective_ = 64
    ,rhs2_Rdirective_ = 65
   ,R_Rsyntax_code_ = 601//start_of_rule_list + 64
    ,rhs1_Rsyntax_code_ = 66
    ,rhs2_Rsyntax_code_ = 67
   ,R_Rlint_epi_ = 602//start_of_rule_list + 66
    ,rhs1_Rlint_epi_ = 68
    ,rhs2_Rlint_epi_ = 69
   ,R_Rdirective_cweb_k_epi_ = 603//start_of_rule_list + 68
    ,rhs1_Rdirective_cweb_k_epi_ = 70
    ,rhs2_Rdirective_cweb_k_epi_ = 71
    ,rhs3_Rdirective_cweb_k_epi_ = 72
    ,rhs4_Rdirective_cweb_k_epi_ = 73
   ,R_Rcweb_k_epi_ = 604//start_of_rule_list + 70
    ,rhs1_Rcweb_k_epi_ = 74
    ,rhs2_Rcweb_k_epi_ = 75
    ,rhs3_Rcweb_k_epi_ = 76
    ,rhs4_Rcweb_k_epi_ = 77
  };
  //no of la sets = 9
  //no of states = 151
  Csubrule_def();
  ~Csubrule_def();
  void op();
  bool failed();
  void reduce_rhs_of_rule
      (yacco2::UINT Sub_rule_no,yacco2::Rule_s_reuse_entry** Recycled_rule);
  fsm_rules_reuse_table_type fsm_rules_reuse_table;
  static int rhs_to_rules_mapping_[78];
  
    public:
    void add_sdc_to_directive(yacco2::CAbs_lr1_sym* Dir,T_syntax_code* Sdc);
    T_subrule_def* subrule_def_;
  
 };
struct Rsubrule_def;
struct Rvector;
struct Rcommon_comments;
struct Rrhs_expr;
struct Rstart_thread;
struct Rbal_thread_expr;
struct Rrtned_T;
struct Rcalled_thread;
struct RNULL;
struct Rns;
struct Rdbl_colon;
struct Rth_name;
struct Rcalled_proc_op;
struct Rbal_called_proc_expr;
struct Rcalled_proc_name;
struct RTorRcomponents_epi;
struct RTorRcomponents;
struct RTorRcomponent;
struct Rchained_dispatcher;
struct Rmust_eos;
struct Rcalled_thd_eos;
struct Rcalled_proc_eos;
struct Rpotential_codeblk;
struct Rpotential_directives;
struct Rmust_directive_phrase;
struct Rmust_directive;
struct Rclose_brace;
struct Rmaybe_more_directives;
struct Rmaybe_directive_phrases;
struct Rmaybe_directive_phrase;
struct Rdirective_phrase;
struct Rdirective;
struct Rsyntax_code;
struct Rlint_epi;
struct Rdirective_cweb_k_epi;
struct Rcweb_k_epi;
struct Rsubrule_def:public yacco2::CAbs_lr1_sym {
  Rsubrule_def(yacco2::Parser* P);
  public:
  void sr1();
};

struct Rvector:public yacco2::CAbs_lr1_sym {
  Rvector(yacco2::Parser* P);
  public:
};

struct Rcommon_comments:public yacco2::CAbs_lr1_sym {
  Rcommon_comments(yacco2::Parser* P);
  public:
};

yacco2::THR _YACCO2_CALL_TYPE
AR_Rrhs_expr(yacco2::Parser* Caller_pp);// rule's arbitrator
struct Rrhs_expr:public yacco2::CAbs_lr1_sym {
  Rrhs_expr(yacco2::Parser* P);
  public:
};

yacco2::THR _YACCO2_CALL_TYPE
AR_Rstart_thread(yacco2::Parser* Caller_pp);// rule's arbitrator
struct Rstart_thread:public yacco2::CAbs_lr1_sym {
  Rstart_thread(yacco2::Parser* P);
  public:
  void sr1();
};

struct Rbal_thread_expr:public yacco2::CAbs_lr1_sym {
  Rbal_thread_expr(yacco2::Parser* P);
  public:
};

struct Rrtned_T:public yacco2::CAbs_lr1_sym {
  Rrtned_T(yacco2::Parser* P);
  public:
  void sr1();
  void sr2();
  void sr3();
  void sr4();
};

struct Rcalled_thread:public yacco2::CAbs_lr1_sym {
  Rcalled_thread(yacco2::Parser* P);
  public:
  void sr1();
};

struct RNULL:public yacco2::CAbs_lr1_sym {
  RNULL(yacco2::Parser* P);
  public:
  void sr1();
};

struct Rns:public yacco2::CAbs_lr1_sym {
  Rns(yacco2::Parser* P);

  public:
  T_identifier* ns_;
  
  public:
  void sr1();
  void sr2();
  void sr3();
};

struct Rdbl_colon:public yacco2::CAbs_lr1_sym {
  Rdbl_colon(yacco2::Parser* P);
  public:
  void sr1();
  void sr2();
  void sr3();
};

struct Rth_name:public yacco2::CAbs_lr1_sym {
  Rth_name(yacco2::Parser* P);

  public:
  T_identifier* thd_nm_;
  
  public:
  void sr1();
  void sr2();
  void sr3();
};

yacco2::THR _YACCO2_CALL_TYPE
AR_Rcalled_proc_op(yacco2::Parser* Caller_pp);// rule's arbitrator
struct Rcalled_proc_op:public yacco2::CAbs_lr1_sym {
  Rcalled_proc_op(yacco2::Parser* P);
  public:
  void sr1();
};

struct Rbal_called_proc_expr:public yacco2::CAbs_lr1_sym {
  Rbal_called_proc_expr(yacco2::Parser* P);
  public:
};

struct Rcalled_proc_name:public yacco2::CAbs_lr1_sym {
  Rcalled_proc_name(yacco2::Parser* P);
  public:
  void sr1();
};

struct RTorRcomponents_epi:public yacco2::CAbs_lr1_sym {
  RTorRcomponents_epi(yacco2::Parser* P);
  public:
};

struct RTorRcomponents:public yacco2::CAbs_lr1_sym {
  RTorRcomponents(yacco2::Parser* P);
  public:
};

struct RTorRcomponent:public yacco2::CAbs_lr1_sym {
  RTorRcomponent(yacco2::Parser* P);
  public:
  void sr1();
  void sr2();
  void sr3();
};

struct Rchained_dispatcher:public yacco2::CAbs_lr1_sym {
  Rchained_dispatcher(yacco2::Parser* P);
  public:
  void sr1();
  void sr2();
  void sr3();
};

struct Rmust_eos:public yacco2::CAbs_lr1_sym {
  Rmust_eos(yacco2::Parser* P);
  public:
  void sr1();
  void sr2();
  void sr3();
};

struct Rcalled_thd_eos:public yacco2::CAbs_lr1_sym {
  Rcalled_thd_eos(yacco2::Parser* P);
  public:
  void sr1();
  void sr2();
};

struct Rcalled_proc_eos:public yacco2::CAbs_lr1_sym {
  Rcalled_proc_eos(yacco2::Parser* P);
  public:
  void sr1();
  void sr2();
};

struct Rpotential_codeblk:public yacco2::CAbs_lr1_sym {
  Rpotential_codeblk(yacco2::Parser* P);
  public:
};

struct Rpotential_directives:public yacco2::CAbs_lr1_sym {
  Rpotential_directives(yacco2::Parser* P);
  public:
};

struct Rmust_directive_phrase:public yacco2::CAbs_lr1_sym {
  Rmust_directive_phrase(yacco2::Parser* P);
  public:
  void sr1();
};

struct Rmust_directive:public yacco2::CAbs_lr1_sym {
  Rmust_directive(yacco2::Parser* P);
  void op();
  void ctor();

    CAbs_lr1_sym* directive_;
  
  public:
  void sr1();
  void sr2();
  void sr3();
};

struct Rclose_brace:public yacco2::CAbs_lr1_sym {
  Rclose_brace(yacco2::Parser* P);
  public:
  void sr1();
};

struct Rmaybe_more_directives:public yacco2::CAbs_lr1_sym {
  Rmaybe_more_directives(yacco2::Parser* P);
  public:
};

struct Rmaybe_directive_phrases:public yacco2::CAbs_lr1_sym {
  Rmaybe_directive_phrases(yacco2::Parser* P);
  public:
};

struct Rmaybe_directive_phrase:public yacco2::CAbs_lr1_sym {
  Rmaybe_directive_phrase(yacco2::Parser* P);
  public:
  void sr1();
  void sr2();
};

struct Rdirective_phrase:public yacco2::CAbs_lr1_sym {
  Rdirective_phrase(yacco2::Parser* P);
  public:
  void sr1();
};

struct Rdirective:public yacco2::CAbs_lr1_sym {
  Rdirective(yacco2::Parser* P);
  void op();
  void ctor();

    CAbs_lr1_sym* directive_;
  
  public:
  void sr1();
  void sr2();
};

struct Rsyntax_code:public yacco2::CAbs_lr1_sym {
  Rsyntax_code(yacco2::Parser* P);
  void ctor();

    T_syntax_code* syntax_code_;
  
  public:
  void sr1();
  void sr2();
};

struct Rlint_epi:public yacco2::CAbs_lr1_sym {
  Rlint_epi(yacco2::Parser* P);
  public:
};

struct Rdirective_cweb_k_epi:public yacco2::CAbs_lr1_sym {
  Rdirective_cweb_k_epi(yacco2::Parser* P);
  void ctor();

	  AST* cweb_t_;
	
  public:
  void sr2();
  void sr3();
  void sr4();
};

struct Rcweb_k_epi:public yacco2::CAbs_lr1_sym {
  Rcweb_k_epi(yacco2::Parser* P);
  public:
  void sr1();
  void sr2();
  void sr3();
};

} // end of namespace

#endif
