/*
 File: yacco2_err_symbols.cpp
 Date and Time: Sun Apr 20 13:54:30 2014 
*/
#include "yacco2_err_symbols.h"
  using namespace NS_yacco2_err_symbols;
  using namespace NS_yacco2_T_enum;

		Err_nested_files_exceeded::
		Err_nested_files_exceeded(yacco2::INT Nested_cnt,std::string& File_name)
	      T_CTOR("nested files exceeded",T_Enum::T_Err_nested_files_exceeded_,0,false,false)
		  {nested_cnt_ = Nested_cnt;file_exceeded_ += File_name.c_str();}
	Err_no_end_of_code::
Err_no_end_of_code()
 T_CTOR("no end-of-code",T_Enum::T_Err_no_end_of_code_,0,false,false){}
Err_no_cmd_lne_data::
Err_no_cmd_lne_data()
 T_CTOR("no cmd-lne-data",T_Enum::T_Err_no_cmd_lne_data_,0,false,false){}
Err_no_filename::
Err_no_filename()
 T_CTOR("no filename",T_Enum::T_Err_no_filename_,0,false,false){}

		Err_bad_filename::
		Err_bad_filename(std::string& File_name)
      T_CTOR("bad filename",T_Enum::T_Err_bad_filename_,0,false,false)
		  {file_name_ += File_name.c_str();}
		Err_bad_filename::
		Err_bad_filename(const char* File_name)
      T_CTOR("bad filename",T_Enum::T_Err_bad_filename_,0,false,false)
		  {file_name_ += File_name;}
		std::string* Err_bad_filename::file_name(){return &file_name_;}
	
		Err_bad_fsmheader_filename::
		Err_bad_fsmheader_filename(std::string& File_name)
T_CTOR("bad filename to output grammar header",T_Enum::T_Err_bad_fsmheader_filename_,0,false,false)
		  {file_name_ += File_name.c_str();}
		Err_bad_fsmheader_filename::
		Err_bad_fsmheader_filename(const char* File_name)
T_CTOR("bad filename to output grammar header",T_Enum::T_Err_bad_fsmheader_filename_,0,false,false)
		  {file_name_ += File_name;}
		std::string* Err_bad_fsmheader_filename::file_name(){return &file_name_;}
	
		Err_bad_fsmcpp_filename::
		Err_bad_fsmcpp_filename(std::string& File_name)
T_CTOR("bad filename to output cpp",T_Enum::T_Err_bad_fsmcpp_filename_,0,false,false)
		  {file_name_ += File_name.c_str();}
		Err_bad_fsmcpp_filename::
		Err_bad_fsmcpp_filename(const char* File_name)
T_CTOR("bad filename to output cpp",T_Enum::T_Err_bad_fsmcpp_filename_,0,false,false)
		  {file_name_ += File_name;}
		std::string* Err_bad_fsmcpp_filename::file_name(){return &file_name_;}
	
		Err_bad_fsmsym_filename::
		Err_bad_fsmsym_filename(std::string& File_name)
T_CTOR("bad filename to output sym",T_Enum::T_Err_bad_fsmsym_filename_,0,false,false)
		  {file_name_ += File_name.c_str();}
		Err_bad_fsmsym_filename::
		Err_bad_fsmsym_filename(const char* File_name)
T_CTOR("bad filename to output sym",T_Enum::T_Err_bad_fsmsym_filename_,0,false,false)
		  {file_name_ += File_name;}
		std::string* Err_bad_fsmsym_filename::file_name(){return &file_name_;}
	
	Err_bad_fsmtbl_filename::
	Err_bad_fsmtbl_filename(std::string& File_name)
T_CTOR("bad filename to output tbl",T_Enum::T_Err_bad_fsmtbl_filename_,0,false,false)
	  {file_name_ += File_name.c_str();}
	Err_bad_fsmtbl_filename::
	Err_bad_fsmtbl_filename(const char* File_name)
T_CTOR("bad filename to output tbl",T_Enum::T_Err_bad_fsmtbl_filename_,0,false,false)
	  {file_name_ += File_name;}
	std::string* Err_bad_fsmtbl_filename::file_name(){return &file_name_;}
	
		Err_bad_enum_filename::
		Err_bad_enum_filename(std::string& File_name)
T_CTOR("bad filename to output enumeration header",T_Enum::T_Err_bad_enum_filename_,0,false,false)
		  {file_name_ += File_name.c_str();}
		Err_bad_enum_filename::
		Err_bad_enum_filename(const char* File_name)
T_CTOR("bad filename to output enumeration header",T_Enum::T_Err_bad_enum_filename_,0,false,false)
		  {file_name_ += File_name;}
		std::string* Err_bad_enum_filename::file_name(){return &file_name_;}
	
		Err_bad_errors_hdrfilename::
		Err_bad_errors_hdrfilename(std::string& File_name)
T_CTOR("bad filename for Errors vocabulary header",T_Enum::T_Err_bad_errors_hdrfilename_,0,false,false)
		  {file_name_ += File_name.c_str();}
		Err_bad_errors_hdrfilename::
		Err_bad_errors_hdrfilename(const char* File_name)
T_CTOR("bad filename for Errors vocabulary header",T_Enum::T_Err_bad_errors_hdrfilename_,0,false,false)
		  {file_name_ += File_name;}
		std::string* Err_bad_errors_hdrfilename::file_name(){return &file_name_;}
	
		Err_bad_errors_impfilename::
		Err_bad_errors_impfilename(std::string& File_name)
T_CTOR("bad filename for Errors vocabulary implementation",T_Enum::T_Err_bad_errors_impfilename_,0,false,false)
		  {file_name_ += File_name.c_str();}
		Err_bad_errors_impfilename::
		Err_bad_errors_impfilename(const char* File_name)
T_CTOR("bad filename for Errors vocabulary implementation",T_Enum::T_Err_bad_errors_impfilename_,0,false,false)
		  {file_name_ += File_name;}
		std::string* Err_bad_errors_impfilename::file_name(){return &file_name_;}
	Err_bad_cmd_lne_opt::
Err_bad_cmd_lne_opt()
 T_CTOR("bad cmd-opt",T_Enum::T_Err_bad_cmd_lne_opt_,0,false,false){}
Err_bad_int_no::
Err_bad_int_no()
 T_CTOR("bad int-no",T_Enum::T_Err_bad_int_no_,0,false,false){}
Err_bad_int_no_range::
Err_bad_int_no_range()
 T_CTOR("bad int-no range",T_Enum::T_Err_bad_int_no_range_,0,false,false){}
Err_no_int_present::
Err_no_int_present()
 T_CTOR("no int present",T_Enum::T_Err_no_int_present_,0,false,false){}
Err_bad_eos::
Err_bad_eos()
 T_CTOR("bad eos",T_Enum::T_Err_bad_eos_,0,false,false){}
Err_bad_esc::
Err_bad_esc()
 T_CTOR("bad esc",T_Enum::T_Err_bad_esc_,0,false,false){}
Err_comment_overrun::
Err_comment_overrun()
 T_CTOR("comment-overrun",T_Enum::T_Err_comment_overrun_,0,false,false){}

		Err_bad_char::
		Err_bad_char(CAbs_lr1_sym* Bad_char)
T_CTOR("bad char",T_Enum::T_Err_bad_char_,&dtor_Err_bad_char,false,false)
		  {bad_char_ = Bad_char;}
		yacco2::CAbs_lr1_sym* Err_bad_char::bad_char()const{return bad_char_;}
		void Err_bad_char::zero_out_bad_char(){bad_char_ = 0;}
	void Err_bad_char::dtor_Err_bad_char(yacco2::VOIDP This,yacco2::VOIDP P){
 Err_bad_char* R = (Err_bad_char*)(This);
 
	  if(R->bad_char_!=0)
		delete R->bad_char();
	
}

		Err_bad_univ_seq::
		Err_bad_univ_seq(unsigned long Bad_univ_seq)
	    T_CTOR("bad univ seq",T_Enum::T_Err_bad_univ_seq_,0,false,false)
	    {bad_univ_seq_ = Bad_univ_seq;
	    }
		unsigned long 
		Err_bad_univ_seq::bad_univ_seq()const{return bad_univ_seq_;}
	Err_improper_closing_of_rules::
Err_improper_closing_of_rules()
 T_CTOR("improper closing of rules construct",T_Enum::T_Err_improper_closing_of_rules_,0,false,false){}
Err_no_identifier_present::
Err_no_identifier_present()
 T_CTOR("no identifier present",T_Enum::T_Err_no_identifier_present_,0,false,false){}
Err_no_directive_present::
Err_no_directive_present()
 T_CTOR("no directive present",T_Enum::T_Err_no_directive_present_,0,false,false){}
Err_duplicate_directive::
Err_duplicate_directive()
 T_CTOR("duplicate directive",T_Enum::T_Err_duplicate_directive_,0,false,false){}
Err_no_syntax_code_present::
Err_no_syntax_code_present()
 T_CTOR("no syntax-code present",T_Enum::T_Err_no_syntax_code_present_,0,false,false){}
Err_no_open_parenthesis::
Err_no_open_parenthesis()
 T_CTOR("no open-parenthesis",T_Enum::T_Err_no_open_parenthesis_,0,false,false){}
Err_no_close_parenthesis::
Err_no_close_parenthesis()
 T_CTOR("no close-parenthesis",T_Enum::T_Err_no_close_parenthesis_,0,false,false){}
Err_no_fsm_id_present::
Err_no_fsm_id_present()
 T_CTOR("no fsm-id-present",T_Enum::T_Err_no_fsm_id_present_,0,false,false){}
Err_no_fsm_id_string::
Err_no_fsm_id_string()
 T_CTOR("no fsm-id-string present",T_Enum::T_Err_no_fsm_id_string_,0,false,false){}
Err_no_fsm_filename_present::
Err_no_fsm_filename_present()
 T_CTOR("no fsm-filename present",T_Enum::T_Err_no_fsm_filename_present_,0,false,false){}
Err_no_fsm_filename_id_present::
Err_no_fsm_filename_id_present()
 T_CTOR("no fsm-filename id present",T_Enum::T_Err_no_fsm_filename_id_present_,0,false,false){}
Err_no_comma_present::
Err_no_comma_present()
 T_CTOR("no comma present",T_Enum::T_Err_no_comma_present_,0,false,false){}
Err_no_fsm_namespace_present::
Err_no_fsm_namespace_present()
 T_CTOR("no fsm-namespace present",T_Enum::T_Err_no_fsm_namespace_present_,0,false,false){}
Err_no_fsm_namespace_id_present::
Err_no_fsm_namespace_id_present()
 T_CTOR("no fsm-namespace id present",T_Enum::T_Err_no_fsm_namespace_id_present_,0,false,false){}
Err_no_fsm_class_present::
Err_no_fsm_class_present()
 T_CTOR("no fsm-class present",T_Enum::T_Err_no_fsm_class_present_,0,false,false){}
Err_no_fsm_version_present::
Err_no_fsm_version_present()
 T_CTOR("no fsm-version present",T_Enum::T_Err_no_fsm_version_present_,0,false,false){}
Err_no_fsm_version_string::
Err_no_fsm_version_string()
 T_CTOR("no fsm-version string present",T_Enum::T_Err_no_fsm_version_string_,0,false,false){}
Err_no_fsm_date_present::
Err_no_fsm_date_present()
 T_CTOR("no fsm-date present",T_Enum::T_Err_no_fsm_date_present_,0,false,false){}
Err_no_fsm_date_string::
Err_no_fsm_date_string()
 T_CTOR("no fsm-date string present",T_Enum::T_Err_no_fsm_date_string_,0,false,false){}
Err_no_fsm_debug_present::
Err_no_fsm_debug_present()
 T_CTOR("no fsm-debug present",T_Enum::T_Err_no_fsm_debug_present_,0,false,false){}
Err_no_fsm_debug_string::
Err_no_fsm_debug_string()
 T_CTOR("no fsm-debug string present",T_Enum::T_Err_no_fsm_debug_string_,0,false,false){}
Err_no_fsm_comments_present::
Err_no_fsm_comments_present()
 T_CTOR("no fsm-comments present",T_Enum::T_Err_no_fsm_comments_present_,0,false,false){}
Err_no_fsm_comments_string::
Err_no_fsm_comments_string()
 T_CTOR("no fsm-comments string present",T_Enum::T_Err_no_fsm_comments_string_,0,false,false){}
Err_fsm_debug_string_not_true_or_false::
Err_fsm_debug_string_not_true_or_false()
 T_CTOR("invalid fsm-debug value",T_Enum::T_Err_fsm_debug_string_not_true_or_false_,0,false,false){}
Err_no_pp_thread_function_present::
Err_no_pp_thread_function_present()
 T_CTOR("no parallel-thread-function",T_Enum::T_Err_no_pp_thread_function_present_,0,false,false){}
Err_no_pp_ctrl_mntor_kw_present::
Err_no_pp_ctrl_mntor_kw_present()
 T_CTOR("no parallel-control-monitor",T_Enum::T_Err_no_pp_ctrl_mntor_kw_present_,0,false,false){}
Err_no_pp_fnct_id_present::
Err_no_pp_fnct_id_present()
 T_CTOR("no parallel thread function",T_Enum::T_Err_no_pp_fnct_id_present_,0,false,false){}
Err_no_pp_bndry_present::
Err_no_pp_bndry_present()
 T_CTOR("no parallel-la-boundary",T_Enum::T_Err_no_pp_bndry_present_,0,false,false){}
Err_no_pp_la_bndary_expr_present::
Err_no_pp_la_bndary_expr_present()
 T_CTOR("no parallel-la-boundary-expr",T_Enum::T_Err_no_pp_la_bndary_expr_present_,0,false,false){}
Err_no_syntax_code_end_present::
Err_no_syntax_code_end_present()
 T_CTOR("no ***",T_Enum::T_Err_no_syntax_code_end_present_,0,false,false){}
Err_no_pp_code_present::
Err_no_pp_code_present()
 T_CTOR("no parallel-code",T_Enum::T_Err_no_pp_code_present_,0,false,false){}
Err_no_pp_code_stc_present::
Err_no_pp_code_stc_present()
 T_CTOR("no parallel-code-syntax-code",T_Enum::T_Err_no_pp_code_stc_present_,0,false,false){}
Err_not_arbitration_code_kw::
Err_not_arbitration_code_kw()
 T_CTOR("not an arbitration-code keyword",T_Enum::T_Err_not_arbitration_code_kw_,0,false,false){}
Err_no_open_brace::
Err_no_open_brace()
 T_CTOR("no open-brace",T_Enum::T_Err_no_open_brace_,0,false,false){}
Err_no_close_brace::
Err_no_close_brace()
 T_CTOR("no close-brace",T_Enum::T_Err_no_close_brace_,0,false,false){}
Err_no_constant_defs_present::
Err_no_constant_defs_present()
 T_CTOR("no constant-defs-directive present",T_Enum::T_Err_no_constant_defs_present_,0,false,false){}
Err_no_filename_present::
Err_no_filename_present()
 T_CTOR("no file-name present",T_Enum::T_Err_no_filename_present_,0,false,false){}
Err_no_filename_id_present::
Err_no_filename_id_present()
 T_CTOR("no file-name-id present",T_Enum::T_Err_no_filename_id_present_,0,false,false){}
Err_no_namespace_present::
Err_no_namespace_present()
 T_CTOR("no name-space present",T_Enum::T_Err_no_namespace_present_,0,false,false){}
Err_no_namespace_id_present::
Err_no_namespace_id_present()
 T_CTOR("no name-space-id present",T_Enum::T_Err_no_namespace_id_present_,0,false,false){}
Err_no_kdefs_code_present::
Err_no_kdefs_code_present()
 T_CTOR("no constant-defs-code present",T_Enum::T_Err_no_kdefs_code_present_,0,false,false){}
Err_no_kdefs_kw_present::
Err_no_kdefs_kw_present()
 T_CTOR("no constant-defs keyword present",T_Enum::T_Err_no_kdefs_kw_present_,0,false,false){}
Err_no_tdef_code_present::
Err_no_tdef_code_present()
 T_CTOR("no terminal-def-code present",T_Enum::T_Err_no_tdef_code_present_,0,false,false){}
Err_no_sym_defs_present::
Err_no_sym_defs_present()
 T_CTOR("no symbol definition present",T_Enum::T_Err_no_sym_defs_present_,0,false,false){}
Err_no_terminal_key_present::
Err_no_terminal_key_present()
 T_CTOR("no key-value present in definition",T_Enum::T_Err_no_terminal_key_present_,0,false,false){}
Err_dup_entry_in_alphabet::
Err_dup_entry_in_alphabet()
 T_CTOR("duplicate-entry in alphabet",T_Enum::T_Err_dup_entry_in_alphabet_,0,false,false){}
Err_already_defined_AB::
Err_already_defined_AB()
 T_CTOR("already defined AB tag",T_Enum::T_Err_already_defined_AB_,0,false,false){}
Err_already_defined_AD::
Err_already_defined_AD()
 T_CTOR("already defined AD tag",T_Enum::T_Err_already_defined_AD_,0,false,false){}
Err_improper_directive::
Err_improper_directive()
 T_CTOR("improper directive",T_Enum::T_Err_improper_directive_,0,false,false){}
Err_no_sym_class_present::
Err_no_sym_class_present()
 T_CTOR("no sym-class present",T_Enum::T_Err_no_sym_class_present_,0,false,false){}
Err_no_sym_class_id_present::
Err_no_sym_class_id_present()
 T_CTOR("no sym-class id present",T_Enum::T_Err_no_sym_class_id_present_,0,false,false){}
Err_zero_len_sym::
Err_zero_len_sym()
 T_CTOR("zero len symbol",T_Enum::T_Err_zero_len_sym_,0,false,false){}
Err_sym_tbl_full::
Err_sym_tbl_full()
 T_CTOR("stbl full",T_Enum::T_Err_sym_tbl_full_,0,false,false){}
Err_sym_tbl_char_pool_full::
Err_sym_tbl_char_pool_full()
 T_CTOR("stbl char-pool full",T_Enum::T_Err_sym_tbl_char_pool_full_,0,false,false){}
Err_dup_entry_in_sym_table::
Err_dup_entry_in_sym_table()
 T_CTOR("dup-entry in sym-table",T_Enum::T_Err_dup_entry_in_sym_table_,0,false,false){}
Err_subscript_out_of_range::
Err_subscript_out_of_range()
 T_CTOR("subscript out-of-range",T_Enum::T_Err_subscript_out_of_range_,0,false,false){}
Err_sym_tbl_nested_scope_stk_overflow::
Err_sym_tbl_nested_scope_stk_overflow()
 T_CTOR("stbl scope-stk overflow",T_Enum::T_Err_sym_tbl_nested_scope_stk_overflow_,0,false,false){}
Err_sym_tbl_nested_scope_stk_underflow::
Err_sym_tbl_nested_scope_stk_underflow()
 T_CTOR("stbl scope-stk underflow",T_Enum::T_Err_sym_tbl_nested_scope_stk_underflow_,0,false,false){}
Err_sym_tbl_context_buf_overflow::
Err_sym_tbl_context_buf_overflow()
 T_CTOR("stbl context-buf-overflow",T_Enum::T_Err_sym_tbl_context_buf_overflow_,0,false,false){}
Err_report_card_ptr_0::
Err_report_card_ptr_0()
 T_CTOR("report-card-ptr-0",T_Enum::T_Err_report_card_ptr_0_,0,false,false){}
Err_cannot_define_term_after_sufx_dir::
Err_cannot_define_term_after_sufx_dir()
 T_CTOR("bad pos of t def",T_Enum::T_Err_cannot_define_term_after_sufx_dir_,0,false,false){}
Err_dup_sufx_directive::
Err_dup_sufx_directive()
 T_CTOR("dup ? sufx directive",T_Enum::T_Err_dup_sufx_directive_,0,false,false){}
Err_terminals_refs_def_after_terminals::
Err_terminals_refs_def_after_terminals()
 T_CTOR("bad pos of terminals-refs",T_Enum::T_Err_terminals_refs_def_after_terminals_,0,false,false){}
Err_terminals_refs_dup_def::
Err_terminals_refs_dup_def()
 T_CTOR("terminals-refs duplicate",T_Enum::T_Err_terminals_refs_dup_def_,0,false,false){}
Err_no_rule_name_present::
Err_no_rule_name_present()
 T_CTOR("no rule name present",T_Enum::T_Err_no_rule_name_present_,0,false,false){}
Err_no_sub_rule_present::
Err_no_sub_rule_present()
 T_CTOR("no sub rule present",T_Enum::T_Err_no_sub_rule_present_,0,false,false){}
Err_subrule_use_undefined_T::
Err_subrule_use_undefined_T()
 T_CTOR("undefined terminal in subrule",T_Enum::T_Err_subrule_use_undefined_T_,0,false,false){}
Err_stbl_entry_unknown::
Err_stbl_entry_unknown()
 T_CTOR("unknown symbol type in stbl",T_Enum::T_Err_stbl_entry_unknown_,0,false,false){}
Err_subrule_overrun::
Err_subrule_overrun()
 T_CTOR("subrule overrun",T_Enum::T_Err_subrule_overrun_,0,false,false){}
Err_stble_has_entry_but_not_a_rule::
Err_stble_has_entry_but_not_a_rule()
 T_CTOR("stbl has entry but not a rule",T_Enum::T_Err_stble_has_entry_but_not_a_rule_,0,false,false){}
Err_file_of_T_alphabet_kw_not_present::
Err_file_of_T_alphabet_kw_not_present()
 T_CTOR("no file-of-T-alphabet",T_Enum::T_Err_file_of_T_alphabet_kw_not_present_,0,false,false){}
Err_emitfile_kw_not_present::
Err_emitfile_kw_not_present()
 T_CTOR("emitfile kw not present",T_Enum::T_Err_emitfile_kw_not_present_,0,false,false){}
Err_preamble_kw_not_present::
Err_preamble_kw_not_present()
 T_CTOR("preamble kw not present",T_Enum::T_Err_preamble_kw_not_present_,0,false,false){}
Err_preamble_srce_code_not_present::
Err_preamble_srce_code_not_present()
 T_CTOR("no preamble source code",T_Enum::T_Err_preamble_srce_code_not_present_,0,false,false){}
Err_end_preamble_kw_not_present::
Err_end_preamble_kw_not_present()
 T_CTOR("no end-preamble present",T_Enum::T_Err_end_preamble_kw_not_present_,0,false,false){}
Err_cmd_line_chaffe::
Err_cmd_line_chaffe()
 T_CTOR("command line chaffe",T_Enum::T_Err_cmd_line_chaffe_,0,false,false){}
Err_T_alphabet_kw_not_present::
Err_T_alphabet_kw_not_present()
 T_CTOR("T-alphabet kw not present",T_Enum::T_Err_T_alphabet_kw_not_present_,0,false,false){}
Err_T_alphabet_file_not_present::
Err_T_alphabet_file_not_present()
 T_CTOR("T-alphabet file not present",T_Enum::T_Err_T_alphabet_file_not_present_,0,false,false){}
Err_end_T_alphabet_kw_not_present::
Err_end_T_alphabet_kw_not_present()
 T_CTOR("no end-T-alphabet present",T_Enum::T_Err_end_T_alphabet_kw_not_present_,0,false,false){}
Err_no_terminals_in_T_alphabet_list::
Err_no_terminals_in_T_alphabet_list()
 T_CTOR("no T in T-alphabet list",T_Enum::T_Err_no_terminals_in_T_alphabet_list_,0,false,false){}
Err_rotten_chr_in_T_alphabet::
Err_rotten_chr_in_T_alphabet()
 T_CTOR("rotten chr in T-alphabet",T_Enum::T_Err_rotten_chr_in_T_alphabet_,0,false,false){}
Err_transitive_kw_not_present::
Err_transitive_kw_not_present()
 T_CTOR("no transitive present",T_Enum::T_Err_transitive_kw_not_present_,0,false,false){}
Err_grammar_name_kw_not_present::
Err_grammar_name_kw_not_present()
 T_CTOR("no grammar-name present",T_Enum::T_Err_grammar_name_kw_not_present_,0,false,false){}
Err_namespace_kw_not_present::
Err_namespace_kw_not_present()
 T_CTOR("no name-space",T_Enum::T_Err_namespace_kw_not_present_,0,false,false){}
Err_filename_kw_not_present::
Err_filename_kw_not_present()
 T_CTOR("no file-name kw present",T_Enum::T_Err_filename_kw_not_present_,0,false,false){}
Err_threadname_kw_not_present::
Err_threadname_kw_not_present()
 T_CTOR("no thread-name present",T_Enum::T_Err_threadname_kw_not_present_,0,false,false){}
Err_monolithic_kw_not_present::
Err_monolithic_kw_not_present()
 T_CTOR("no monolithic present",T_Enum::T_Err_monolithic_kw_not_present_,0,false,false){}
Err_no_of_T_kw_not_present::
Err_no_of_T_kw_not_present()
 T_CTOR("no no-of-T present",T_Enum::T_Err_no_of_T_kw_not_present_,0,false,false){}
Err_list_of_terminals_kw_not_present::
Err_list_of_terminals_kw_not_present()
 T_CTOR("no list-of-native-terminals",T_Enum::T_Err_list_of_terminals_kw_not_present_,0,false,false){}
Err_no_list_of_trans_threads_kw::
Err_no_list_of_trans_threads_kw()
 T_CTOR("no list-of-transit...",T_Enum::T_Err_no_list_of_trans_threads_kw_,0,false,false){}
Err_no_terminals_present_in_T_alphabet::
Err_no_terminals_present_in_T_alphabet()
 T_CTOR("no Ts in T-alphabet",T_Enum::T_Err_no_terminals_present_in_T_alphabet_,0,false,false){}
Err_transitive_value_bad::
Err_transitive_value_bad()
 T_CTOR("linker's transitive value not n or y",T_Enum::T_Err_transitive_value_bad_,0,false,false){}
Err_monolithic_value_bad::
Err_monolithic_value_bad()
 T_CTOR("linker's monolithic value not n or y",T_Enum::T_Err_monolithic_value_bad_,0,false,false){}
Err_grammar_name_value_not_present::
Err_grammar_name_value_not_present()
 T_CTOR("no grammar-name value",T_Enum::T_Err_grammar_name_value_not_present_,0,false,false){}
Err_namespace_value_not_present::
Err_namespace_value_not_present()
 T_CTOR("no name-space value",T_Enum::T_Err_namespace_value_not_present_,0,false,false){}
Err_threadname_value_not_present::
Err_threadname_value_not_present()
 T_CTOR("no thread-name value",T_Enum::T_Err_threadname_value_not_present_,0,false,false){}
Err_filename_value_not_present::
Err_filename_value_not_present()
 T_CTOR("no file-name value",T_Enum::T_Err_filename_value_not_present_,0,false,false){}
Err_no_of_T_value_not_present::
Err_no_of_T_value_not_present()
 T_CTOR("no-of-T value not present",T_Enum::T_Err_no_of_T_value_not_present_,0,false,false){}
Err_no_of_terminals_not_present::
Err_no_of_terminals_not_present()
 T_CTOR("no# in list-of-native-term...",T_Enum::T_Err_no_of_terminals_not_present_,0,false,false){}
Err_end_list_native_T_kw_not_present::
Err_end_list_native_T_kw_not_present()
 T_CTOR("no end-list-of-native...",T_Enum::T_Err_end_list_native_T_kw_not_present_,0,false,false){}
Err_end_list_of_transitive_threads_kw_not_present::
Err_end_list_of_transitive_threads_kw_not_present()
 T_CTOR("no end-list-of-trans...",T_Enum::T_Err_end_list_of_transitive_threads_kw_not_present_,0,false,false){}

		Err_no_of_native_Ts_in_list_not_equal::
		Err_no_of_native_Ts_in_list_not_equal(unsigned long No)
T_CTOR("no terminals in list not equal, chk items in list",T_Enum::T_Err_no_of_native_Ts_in_list_not_equal_,0,false,false)
	    {  no_ = No;}
		unsigned long 
		Err_no_of_native_Ts_in_list_not_equal::no()const{return no_;}
	
		Err_no_of_threads_in_list_not_equal::
		Err_no_of_threads_in_list_not_equal(unsigned long No)
T_CTOR("no threads in list not equal, chk list",T_Enum::T_Err_no_of_threads_in_list_not_equal_,0,false,false)
	    {  no_ = No;}
		unsigned long 
		Err_no_of_threads_in_list_not_equal::no()const{return no_;}
	
		Err_thread_refed_but_not_defined::
		Err_thread_refed_but_not_defined(CAbs_lr1_sym* Th_id)
T_CTOR("thread xrefed, but not defed",T_Enum::T_Err_thread_refed_but_not_defined_,0,false,false)
	    {  th_id_ = Th_id;}
yacco2::CAbs_lr1_sym* Err_thread_refed_but_not_defined::th_id(){return th_id_;};
	Err_bad_T_in_list::
Err_bad_T_in_list()
 T_CTOR("T in list not defined in T-alphabet",T_Enum::T_Err_bad_T_in_list_,0,false,false){}
Err_bad_th_in_list::
Err_bad_th_in_list()
 T_CTOR("transitive list thread not defined by fsc files",T_Enum::T_Err_bad_th_in_list_,0,false,false){}
Err_already_defined_in_fsc_file::
Err_already_defined_in_fsc_file()
 T_CTOR("thread defined by another fsc file",T_Enum::T_Err_already_defined_in_fsc_file_,0,false,false){}
Err_bad_thread_subscript::
Err_bad_thread_subscript()
 T_CTOR("thread in stbl but subscript badly set",T_Enum::T_Err_bad_thread_subscript_,0,false,false){}
Err_not_a_keyword::
Err_not_a_keyword()
 T_CTOR("token found in stbl but not a kw",T_Enum::T_Err_not_a_keyword_,0,false,false){}
Err_no_of_threads_not_present::
Err_no_of_threads_not_present()
 T_CTOR("no# in list-of-trans...",T_Enum::T_Err_no_of_threads_not_present_,0,false,false){}
Err_bad_T_alphabet::
Err_bad_T_alphabet()
 T_CTOR("re-compile grammar: bad T-alphabet",T_Enum::T_Err_bad_T_alphabet_,0,false,false){}
Err_fsc_file_does_not_exist::
Err_fsc_file_does_not_exist()
 T_CTOR("fsc file does not exist",T_Enum::T_Err_fsc_file_does_not_exist_,0,false,false){}
Err_filename_file_does_not_exist::
Err_filename_file_does_not_exist()
 T_CTOR("file-name file does not exist",T_Enum::T_Err_filename_file_does_not_exist_,0,false,false){}
Err_T_alphabet_file_does_not_exist::
Err_T_alphabet_file_does_not_exist()
 T_CTOR("T-alphabet file does not exist",T_Enum::T_Err_T_alphabet_file_does_not_exist_,0,false,false){}
Err_emitfile_file_does_not_exist::
Err_emitfile_file_does_not_exist()
 T_CTOR("emitfile file does not exist",T_Enum::T_Err_emitfile_file_does_not_exist_,0,false,false){}
Err_emitfile_file_not_present::
Err_emitfile_file_not_present()
 T_CTOR("emitfile file not present",T_Enum::T_Err_emitfile_file_not_present_,0,false,false){}
Err_fsc_cntl_file_not_present::
Err_fsc_cntl_file_not_present()
 T_CTOR("fsc file not present",T_Enum::T_Err_fsc_cntl_file_not_present_,0,false,false){}
Err_file_of_T_alphabet_not_present::
Err_file_of_T_alphabet_not_present()
 T_CTOR("file of T-alphabet not present",T_Enum::T_Err_file_of_T_alphabet_not_present_,0,false,false){}
Err_epsilon_pass_thru::
Err_epsilon_pass_thru()
 T_CTOR("O2 epsilon badly gened: 0 items in fsc lists",T_Enum::T_Err_epsilon_pass_thru_,0,false,false){}
Err_epsilon_pass_thru_no_Ts::
Err_epsilon_pass_thru_no_Ts()
 T_CTOR("O2 epsilon: T present, but no T list",T_Enum::T_Err_epsilon_pass_thru_no_Ts_,0,false,false){}
Err_rule_not_in_stbl::
Err_rule_not_in_stbl()
 T_CTOR("rule not found in stbl",T_Enum::T_Err_rule_not_in_stbl_,0,false,false){}
Err_T_not_in_stbl::
Err_T_not_in_stbl()
 T_CTOR("T not found in stbl",T_Enum::T_Err_T_not_in_stbl_,0,false,false){}
Err_bad_directive::
Err_bad_directive()
 T_CTOR("bad directive",T_Enum::T_Err_bad_directive_,0,false,false){}
Err_bad_term_in_la_expr::
Err_bad_term_in_la_expr()
 T_CTOR("bad term in la expr",T_Enum::T_Err_bad_term_in_la_expr_,0,false,false){}
Err_empty_set_removal_in_la_expr::
Err_empty_set_removal_in_la_expr()
 T_CTOR("removal of term against empty set in la expr",T_Enum::T_Err_empty_set_removal_in_la_expr_,0,false,false){}
Err_bad_operator_in_la_expr::
Err_bad_operator_in_la_expr()
 T_CTOR("bad operator la expr: not a + or -",T_Enum::T_Err_bad_operator_in_la_expr_,0,false,false){}
Err_not_a_lhs_kw::
Err_not_a_lhs_kw()
 T_CTOR("not a lhs kw",T_Enum::T_Err_not_a_lhs_kw_,0,false,false){}
Err_pp_la_boundary_attribute_not_fnd::
Err_pp_la_boundary_attribute_not_fnd()
 T_CTOR("no parallel-la-bndary expr",T_Enum::T_Err_pp_la_boundary_attribute_not_fnd_,0,false,false){}
Err_already_processed_fsm_phase::
Err_already_processed_fsm_phase()
 T_CTOR("duplicate fsm phrase",T_Enum::T_Err_already_processed_fsm_phase_,0,false,false){}
Err_already_processed_pp_phase::
Err_already_processed_pp_phase()
 T_CTOR("duplicate parallel-parse phrase",T_Enum::T_Err_already_processed_pp_phase_,0,false,false){}
Err_already_processed_T_enum_phase::
Err_already_processed_T_enum_phase()
 T_CTOR("duplicate T_enum phrase",T_Enum::T_Err_already_processed_T_enum_phase_,0,false,false){}
Err_already_processed_error_phase::
Err_already_processed_error_phase()
 T_CTOR("duplicate error phrase",T_Enum::T_Err_already_processed_error_phase_,0,false,false){}
Err_already_processed_rc_phase::
Err_already_processed_rc_phase()
 T_CTOR("duplicate raw character phrase",T_Enum::T_Err_already_processed_rc_phase_,0,false,false){}
Err_already_processed_lrk_phase::
Err_already_processed_lrk_phase()
 T_CTOR("duplicate lrk phrase",T_Enum::T_Err_already_processed_lrk_phase_,0,false,false){}
Err_already_processed_T_phase::
Err_already_processed_T_phase()
 T_CTOR("duplicate terminal phrase",T_Enum::T_Err_already_processed_T_phase_,0,false,false){}
Err_already_processed_rule_phase::
Err_already_processed_rule_phase()
 T_CTOR("duplicate rule phrase",T_Enum::T_Err_already_processed_rule_phase_,0,false,false){}
Err_not_T_for_rtned_token_from_th::
Err_not_T_for_rtned_token_from_th()
 T_CTOR("T not returned from a thread",T_Enum::T_Err_not_T_for_rtned_token_from_th_,0,false,false){}
Err_not_id_for_ns_in_th_stmt::
Err_not_id_for_ns_in_th_stmt()
 T_CTOR("not a namespace id in thread expr",T_Enum::T_Err_not_id_for_ns_in_th_stmt_,0,false,false){}
Err_not_id_for_th_name_in_th_stmt::
Err_not_id_for_th_name_in_th_stmt()
 T_CTOR("not a thread name id in expr",T_Enum::T_Err_not_id_for_th_name_in_th_stmt_,0,false,false){}
Err_bad_th_qualifier::
Err_bad_th_qualifier()
 T_CTOR("bad thread expr",T_Enum::T_Err_bad_th_qualifier_,0,false,false){}
Err_not_dbl_colon_in_th_stmt::
Err_not_dbl_colon_in_th_stmt()
 T_CTOR("not :: in thread expr",T_Enum::T_Err_not_dbl_colon_in_th_stmt_,0,false,false){}
Err_not_T_or_R_in_subrule_expr::
Err_not_T_or_R_in_subrule_expr()
 T_CTOR("bad term in subrule expr",T_Enum::T_Err_not_T_or_R_in_subrule_expr_,0,false,false){}
Err_not_T_or_R_or_eos_in_subrule_expr::
Err_not_T_or_R_or_eos_in_subrule_expr()
 T_CTOR("? ended subrule expr",T_Enum::T_Err_not_T_or_R_or_eos_in_subrule_expr_,0,false,false){}
Err_not_eos_in_subrule_expr::
Err_not_eos_in_subrule_expr()
 T_CTOR("not an eosr in subrule expr",T_Enum::T_Err_not_eos_in_subrule_expr_,0,false,false){}
Err_invalid_logical_name::
Err_invalid_logical_name()
 T_CTOR("invalid logical name",T_Enum::T_Err_invalid_logical_name_,0,false,false){}
Err_invalid_logical_value::
Err_invalid_logical_value()
 T_CTOR("invalid logical value",T_Enum::T_Err_invalid_logical_value_,0,false,false){}
Err_duplicate_logical_name::
Err_duplicate_logical_name()
 T_CTOR("duplicate logical name",T_Enum::T_Err_duplicate_logical_name_,0,false,false){}
Err_missing_terminals_refs_kw::
Err_missing_terminals_refs_kw()
 T_CTOR("missing terminals-refs kw",T_Enum::T_Err_missing_terminals_refs_kw_,0,false,false){}
Err_missing_terminals_sufx_kw::
Err_missing_terminals_sufx_kw()
 T_CTOR("missing terminals-sufx kw",T_Enum::T_Err_missing_terminals_sufx_kw_,0,false,false){}
Err_not_a_terminal_definition::
Err_not_a_terminal_definition()
 T_CTOR("not a terminal definition",T_Enum::T_Err_not_a_terminal_definition_,0,false,false){}
Err_missing_lrk_sufx_kw::
Err_missing_lrk_sufx_kw()
 T_CTOR("missing lrk-sufx kw",T_Enum::T_Err_missing_lrk_sufx_kw_,0,false,false){}
ERR_sick_grammar::
ERR_sick_grammar()
 T_CTOR("rule does not gen T strings - sick grammar",T_Enum::T_ERR_sick_grammar_,0,false,false){}
ERR_no_fsm_phrase::
ERR_no_fsm_phrase()
 T_CTOR("misplaced or missing fsm phrase",T_Enum::T_ERR_no_fsm_phrase_,0,false,false){}
ERR_no_T_enum_phrase::
ERR_no_T_enum_phrase()
 T_CTOR("misplaced or missing T enumeration phrase",T_Enum::T_ERR_no_T_enum_phrase_,0,false,false){}
ERR_no_lrk_phrase::
ERR_no_lrk_phrase()
 T_CTOR("misplaced or missing lrk phrase",T_Enum::T_ERR_no_lrk_phrase_,0,false,false){}
ERR_no_rc_phrase::
ERR_no_rc_phrase()
 T_CTOR("misplaced or missing rc phrase",T_Enum::T_ERR_no_rc_phrase_,0,false,false){}
ERR_no_errors_phrase::
ERR_no_errors_phrase()
 T_CTOR("misplaced or missing errors phrase",T_Enum::T_ERR_no_errors_phrase_,0,false,false){}
ERR_no_terminals_phrase::
ERR_no_terminals_phrase()
 T_CTOR("misplaced or missing terminals phrase",T_Enum::T_ERR_no_terminals_phrase_,0,false,false){}
ERR_no_rules_phrase::
ERR_no_rules_phrase()
 T_CTOR("misplaced or missing rules phrase",T_Enum::T_ERR_no_rules_phrase_,0,false,false){}
Err_used_rule_but_undefined::
Err_used_rule_but_undefined()
 T_CTOR("rule used but undefined",T_Enum::T_Err_used_rule_but_undefined_,0,false,false){}
Err_rule_already_defined::
Err_rule_already_defined()
 T_CTOR("rule already defined",T_Enum::T_Err_rule_already_defined_,0,false,false){}
Err_la_expr_calc_empty_set::
Err_la_expr_calc_empty_set()
 T_CTOR("la expression calculates an empty set",T_Enum::T_Err_la_expr_calc_empty_set_,0,false,false){}
Err_no_close_brace_ending_rules_defs::
Err_no_close_brace_ending_rules_defs()
 T_CTOR("no closing brace ending rules defs",T_Enum::T_Err_no_close_brace_ending_rules_defs_,0,false,false){}
Err_use_of_T_outside_Rules_construct::
Err_use_of_T_outside_Rules_construct()
 T_CTOR("use of T outside Rules's construct",T_Enum::T_Err_use_of_T_outside_Rules_construct_,0,false,false){}
Err_not_kw_defining_grammar_construct::
Err_not_kw_defining_grammar_construct()
 T_CTOR("not a kw to start the top/down parse construct",T_Enum::T_Err_not_kw_defining_grammar_construct_,0,false,false){}
Err_use_of_N_outside_Rules_construct::
Err_use_of_N_outside_Rules_construct()
 T_CTOR("use of Non-terminal (rule) outside Rules's construct",T_Enum::T_Err_use_of_N_outside_Rules_construct_,0,false,false){}
Err_misplaced_or_misspelt_Rule_or_T::
Err_misplaced_or_misspelt_Rule_or_T()
 T_CTOR("misplaced or misspelt Rule or T outside of Rules defs",T_Enum::T_Err_misplaced_or_misspelt_Rule_or_T_,0,false,false){}
Err_not_a_Rule::
Err_not_a_Rule()
 T_CTOR("not a Rule in chained dispatcher expr",T_Enum::T_Err_not_a_Rule_,0,false,false){}
Err_empty_file::
Err_empty_file()
 T_CTOR("Empty file no grammar constructs present",T_Enum::T_Err_empty_file_,0,false,false){}
Err_not_lhs_pcnrl_mntr::
Err_not_lhs_pcnrl_mntr()
 T_CTOR("term not a lhs or parallel-control-monitor kw",T_Enum::T_Err_not_lhs_pcnrl_mntr_,0,false,false){}
