\input  "supp-pdf"
\input "/usr/local/yacco2/diagrams/o2mac.tex"
\DOCtitle{Error Vocabulary}{yacco2\_err\_symbols}
{NS\_yacco2\_err\_symbols}{191}

@i "/usr/local/yacco2/copyright.w"
@** Error symbols vocabulary.\fbreak
Error symbols for the telling.\fbreak
Due to my verbosity and |cweb|'s (\TeX) black slug output 
some of my symbol keys are
more cryptic in description as i wanted to title them with
their enumeration symbol.
Now, the enumeration symbol is removed from the index so there is
no blob of ...
If the truth be told, these descriptions should
be indirect key values that allow for 
multilingual translation.
One step at a time...

Upon experimentation with error keys 
having a suffixed Exxx indicator in the key itself
whereby
the xxx is a number: 001 and 
associating a translation file with the error construct, i nixed the ideas.
It is simply a post error evaluation on the given
error keys to translate them using some form of associated map. 
The error enumeration key with a language indicator would suffice.
A simple database could be used.
For example T\_Enum::T\_LR1\_err\_nested\_files\_exceeded\_ with
 a country code of ``DE'' for
German would translate ``nested files exceeded''.
Not finding a translation should default to the error token's
literal key.
See grammar ``o2\_err\_hdr.lex'' for a context sensitive approach to error reporting.


Ahh... grandeur. Now what about unicode?

@*2 {\bf \NOsign  T in list not eq}.\fbreak
Enum: T\_Err\_no\_of\_native\_Ts\_in\_list\_not\_equal\_
\fbreak
\line{Class: Err\_no\_of\_native\_Ts\_in\_list\_not\_equal \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*3 \NOsign  T in list not eq user-declaration directive.
@<\NOsign  T in list not eq user-declaration directive@>=

		public:
		Err_no_of_native_Ts_in_list_not_equal(unsigned long Value);
		unsigned long no()const;
		private:unsigned long no_;
	
@*3 \NOsign  T in list not eq user-implementation directive.
@<\NOsign  T in list not eq user-implementation directive@>=

		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_;}
	
@*2 {\bf \NOsign  threads in list not eq}.\fbreak
Enum: T\_Err\_no\_of\_threads\_in\_list\_not\_equal\_
\fbreak
\line{Class: Err\_no\_of\_threads\_in\_list\_not\_equal \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*3 \NOsign  threads in list not eq user-declaration directive.
@<\NOsign  threads in list not eq user-declaration directive@>=

		public:
		Err_no_of_threads_in_list_not_equal(unsigned long No);
		unsigned long no()const;
		private:unsigned long no_;
	
@*3 \NOsign  threads in list not eq user-implementation directive.
@<\NOsign  threads in list not eq user-implementation directive@>=

		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_;}
	
@*2 {\bf ? ended subrule expr}.\fbreak
Enum: T\_Err\_not\_T\_or\_R\_or\_eos\_in\_subrule\_expr\_
\fbreak
\line{Class: Err\_not\_T\_or\_R\_or\_eos\_in\_subrule\_expr \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf Empty file no grammar constructs present}.\fbreak
Enum: T\_Err\_empty\_file\_
\fbreak
\line{Class: Err\_empty\_file \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf O2 epsilon badly gened: 0 items in fsc lists}.\fbreak
Enum: T\_Err\_epsilon\_pass\_thru\_
\fbreak
\line{Class: Err\_epsilon\_pass\_thru \hfil AB: N \hfil AD: N}


\O2 states that a thread has epsilon pass thru of thread calling.
Example the called thread start state has an epsilon subrule.
Sanity check or paranoia on my work.

\fbreak 
\hrule
@*2 {\bf O2 epsilon: T present, but no T list}.\fbreak
Enum: T\_Err\_epsilon\_pass\_thru\_no\_Ts\_
\fbreak
\line{Class: Err\_epsilon\_pass\_thru\_no\_Ts \hfil AB: N \hfil AD: N}

 
\O2 states that a thread has epsilon pass thru of thread calling.
Example the called thread start state has an epsilon subrule.
Sanity check or paranoia on my work.

\fbreak 
\hrule
@*2 {\bf T in list not defined in T-alphabet}.\fbreak
Enum: T\_Err\_bad\_T\_in\_list\_
\fbreak
\line{Class: Err\_bad\_T\_in\_list \hfil AB: N \hfil AD: N}


\Olinker message. It indicates that the terminal
is not defined in ``T-alphabet'' construct.
This is the T vocabulary.
If the terminal is not defined, it means that the 
grammar writer has not generated the vocabulary.
So turn on the /t option and re-compile a grammar thus
creating the updated list.

\fbreak 
\hrule
@*2 {\bf T not found in stbl}.\fbreak
Enum: T\_Err\_T\_not\_in\_stbl\_
\fbreak
\line{Class: Err\_T\_not\_in\_stbl \hfil AB: N \hfil AD: N}


Either the grammmar writer forgot to add a new T definition or
its a mistype.

\fbreak 
\hrule
@*2 {\bf T not returned from a thread}.\fbreak
Enum: T\_Err\_not\_T\_for\_rtned\_token\_from\_th\_
\fbreak
\line{Class: Err\_not\_T\_for\_rtned\_token\_from\_th \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf T-alphabet file does not exist}.\fbreak
Enum: T\_Err\_T\_alphabet\_file\_does\_not\_exist\_
\fbreak
\line{Class: Err\_T\_alphabet\_file\_does\_not\_exist \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf T-alphabet file not present}.\fbreak
Enum: T\_Err\_T\_alphabet\_file\_not\_present\_
\fbreak
\line{Class: Err\_T\_alphabet\_file\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf T-alphabet kw not present}.\fbreak
Enum: T\_Err\_T\_alphabet\_kw\_not\_present\_
\fbreak
\line{Class: Err\_T\_alphabet\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf already defined AB tag}.\fbreak
Enum: T\_Err\_already\_defined\_AB\_
\fbreak
\line{Class: Err\_already\_defined\_AB \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf already defined AD tag}.\fbreak
Enum: T\_Err\_already\_defined\_AD\_
\fbreak
\line{Class: Err\_already\_defined\_AD \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf bad char}.\fbreak
Enum: T\_Err\_bad\_char\_
\fbreak
\line{Class: Err\_bad\_char \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*3 bad char destructor directive.
@<bad char destructor directive@>=

	  if(R->bad_char_!=0)
		delete R->bad_char();
	
@*3 bad char user-declaration directive.
@<bad char user-declaration directive@>=

		public:
		Err_bad_char(CAbs_lr1_sym* Err_char);
		yacco2::CAbs_lr1_sym* bad_char()const;
		void zero_out_bad_char();
		private:
		yacco2::CAbs_lr1_sym* bad_char_;
	
@*3 bad char user-implementation directive.
@<bad char user-implementation directive@>=

		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;}
	
@*2 {\bf bad cmd-opt}.\fbreak
Enum: T\_Err\_bad\_cmd\_lne\_opt\_
\fbreak
\line{Class: Err\_bad\_cmd\_lne\_opt \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf bad directive}.\fbreak
Enum: T\_Err\_bad\_directive\_
\fbreak
\line{Class: Err\_bad\_directive \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf bad eos}.\fbreak
Enum: T\_Err\_bad\_eos\_
\fbreak
\line{Class: Err\_bad\_eos \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf bad esc}.\fbreak
Enum: T\_Err\_bad\_esc\_
\fbreak
\line{Class: Err\_bad\_esc \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf bad filename}.\fbreak
Enum: T\_Err\_bad\_filename\_
\fbreak
\line{Class: Err\_bad\_filename \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*3 bad filename user-declaration directive.
@<bad filename user-declaration directive@>=

		public:
		Err_bad_filename(std::string& File_name);
		Err_bad_filename(const char* File_name);
		std::string* file_name();
		private:
			std::string file_name_;
	
@*3 bad filename user-implementation directive.
@<bad filename user-implementation directive@>=

		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_;}
	
@*2 {\bf bad filename for Errors vocabulary header}.\fbreak
Enum: T\_Err\_bad\_errors\_hdrfilename\_
\fbreak
\line{Class: Err\_bad\_errors\_hdrfilename \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*3 bad filename for Errors vocabulary header user-declaration directive.
@<bad filename for Errors vocabulary header user-declaration directive@>=

		public:
		Err_bad_errors_hdrfilename(std::string& File_name);
		Err_bad_errors_hdrfilename(const char* File_name);
		std::string* file_name();
		private:
		std::string file_name_;
	
@*3 bad filename for Errors vocabulary header user-implementation directive.
@<bad filename for Errors vocabulary header user-implementation directive@>=

		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_;}
	
@*2 {\bf bad filename for Errors vocabulary implementation}.\fbreak
Enum: T\_Err\_bad\_errors\_impfilename\_
\fbreak
\line{Class: Err\_bad\_errors\_impfilename \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*3 bad filename for Errors vocabulary implementation user-declaration directive.
@<bad filename for Errors vocabulary implementation user-declaration directive@>=

		public:
		Err_bad_errors_impfilename(std::string& File_name);
		Err_bad_errors_impfilename(const char* File_name);
		std::string* file_name();
		private:
		std::string file_name_;
	
@*3 bad filename for Errors vocabulary implementation user-implementation directive.
@<bad filename for Errors vocabulary implementation user-implementation directive@>=

		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_;}
	
@*2 {\bf bad filename to output cpp}.\fbreak
Enum: T\_Err\_bad\_fsmcpp\_filename\_
\fbreak
\line{Class: Err\_bad\_fsmcpp\_filename \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*3 bad filename to output cpp user-declaration directive.
@<bad filename to output cpp user-declaration directive@>=

		public:
		Err_bad_fsmcpp_filename(std::string& File_name);
		Err_bad_fsmcpp_filename(const char* File_name);
		std::string* file_name();
		private:
			std::string file_name_;
	
@*3 bad filename to output cpp user-implementation directive.
@<bad filename to output cpp user-implementation directive@>=

		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_;}
	
@*2 {\bf bad filename to output enumeration header}.\fbreak
Enum: T\_Err\_bad\_enum\_filename\_
\fbreak
\line{Class: Err\_bad\_enum\_filename \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*3 bad filename to output enumeration header user-declaration directive.
@<bad filename to output enumeration header user-declaration directive@>=

		public:
		Err_bad_enum_filename(std::string& File_name);
		Err_bad_enum_filename(const char* File_name);
		std::string* file_name();
		private:
			std::string file_name_;
	
@*3 bad filename to output enumeration header user-implementation directive.
@<bad filename to output enumeration header user-implementation directive@>=

		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_;}
	
@*2 {\bf bad filename to output grammar header}.\fbreak
Enum: T\_Err\_bad\_fsmheader\_filename\_
\fbreak
\line{Class: Err\_bad\_fsmheader\_filename \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*3 bad filename to output grammar header user-declaration directive.
@<bad filename to output grammar header user-declaration directive@>=

		public:
		Err_bad_fsmheader_filename(std::string& File_name);
		Err_bad_fsmheader_filename(const char* File_name);
		std::string* file_name();
		private:
			std::string file_name_;
	
@*3 bad filename to output grammar header user-implementation directive.
@<bad filename to output grammar header user-implementation directive@>=

		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_;}
	
@*2 {\bf bad filename to output sym}.\fbreak
Enum: T\_Err\_bad\_fsmsym\_filename\_
\fbreak
\line{Class: Err\_bad\_fsmsym\_filename \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*3 bad filename to output sym user-declaration directive.
@<bad filename to output sym user-declaration directive@>=

		public:
		Err_bad_fsmsym_filename(std::string& File_name);
		Err_bad_fsmsym_filename(const char* File_name);
		std::string* file_name();
		private:
			std::string file_name_;
	
@*3 bad filename to output sym user-implementation directive.
@<bad filename to output sym user-implementation directive@>=

		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_;}
	
@*2 {\bf bad filename to output tbl}.\fbreak
Enum: T\_Err\_bad\_fsmtbl\_filename\_
\fbreak
\line{Class: Err\_bad\_fsmtbl\_filename \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*3 bad filename to output tbl user-declaration directive.
@<bad filename to output tbl user-declaration directive@>=

		public:
		Err_bad_fsmtbl_filename(std::string& File_name);
		Err_bad_fsmtbl_filename(const char* File_name);
		std::string* file_name();
		private:
			std::string file_name_;
	
@*3 bad filename to output tbl user-implementation directive.
@<bad filename to output tbl user-implementation directive@>=

	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_;}
	
@*2 {\bf bad int-no}.\fbreak
Enum: T\_Err\_bad\_int\_no\_
\fbreak
\line{Class: Err\_bad\_int\_no \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf bad int-no range}.\fbreak
Enum: T\_Err\_bad\_int\_no\_range\_
\fbreak
\line{Class: Err\_bad\_int\_no\_range \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf bad operator la expr: not a + or -}.\fbreak
Enum: T\_Err\_bad\_operator\_in\_la\_expr\_
\fbreak
\line{Class: Err\_bad\_operator\_in\_la\_expr \hfil AB: N \hfil AD: N}


Thread's lookahead expression malformed.

\fbreak 
\hrule
@*2 {\bf bad pos of t def}.\fbreak
Enum: T\_Err\_cannot\_define\_term\_after\_sufx\_dir\_
\fbreak
\line{Class: Err\_cannot\_define\_term\_after\_sufx\_dir \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf bad pos of terminals-refs}.\fbreak
Enum: T\_Err\_terminals\_refs\_def\_after\_terminals\_
\fbreak
\line{Class: Err\_terminals\_refs\_def\_after\_terminals \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf bad term in la expr}.\fbreak
Enum: T\_Err\_bad\_term\_in\_la\_expr\_
\fbreak
\line{Class: Err\_bad\_term\_in\_la\_expr \hfil AB: N \hfil AD: N}


Must be a Rule or a T term within the subrule expression.

\fbreak 
\hrule
@*2 {\bf bad term in subrule expr}.\fbreak
Enum: T\_Err\_not\_T\_or\_R\_in\_subrule\_expr\_
\fbreak
\line{Class: Err\_not\_T\_or\_R\_in\_subrule\_expr \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf bad thread expr}.\fbreak
Enum: T\_Err\_bad\_th\_qualifier\_
\fbreak
\line{Class: Err\_bad\_th\_qualifier \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf bad univ-seq}.\fbreak
Enum: T\_Err\_bad\_univ\_seq\_
\fbreak
\line{Class: Err\_bad\_univ\_seq \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*3 bad univ-seq user-declaration directive.
@<bad univ-seq user-declaration directive@>=

		public:
		Err_bad_univ_seq(unsigned long Value);
		unsigned long bad_univ_seq()const;
		private:unsigned long bad_univ_seq_;
	
@*3 bad univ-seq user-implementation directive.
@<bad univ-seq user-implementation directive@>=

		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_;}
	
@*2 {\bf command line chaffe}.\fbreak
Enum: T\_Err\_cmd\_line\_chaffe\_
\fbreak
\line{Class: Err\_cmd\_line\_chaffe \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf comment-overrun}.\fbreak
Enum: T\_Err\_comment\_overrun\_
\fbreak
\line{Class: Err\_comment\_overrun \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf dup ? sufx directive}.\fbreak
Enum: T\_Err\_dup\_sufx\_directive\_
\fbreak
\line{Class: Err\_dup\_sufx\_directive \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf dup-entry in sym-table}.\fbreak
Enum: T\_Err\_dup\_entry\_in\_sym\_table\_
\fbreak
\line{Class: Err\_dup\_entry\_in\_sym\_table \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf duplicate T\_enum phrase}.\fbreak
Enum: T\_Err\_already\_processed\_T\_enum\_phase\_
\fbreak
\line{Class: Err\_already\_processed\_T\_enum\_phase \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf duplicate directive}.\fbreak
Enum: T\_Err\_duplicate\_directive\_
\fbreak
\line{Class: Err\_duplicate\_directive \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf duplicate error phrase}.\fbreak
Enum: T\_Err\_already\_processed\_error\_phase\_
\fbreak
\line{Class: Err\_already\_processed\_error\_phase \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf duplicate fsm phrase}.\fbreak
Enum: T\_Err\_already\_processed\_fsm\_phase\_
\fbreak
\line{Class: Err\_already\_processed\_fsm\_phase \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf duplicate logical name}.\fbreak
Enum: T\_Err\_duplicate\_logical\_name\_
\fbreak
\line{Class: Err\_duplicate\_logical\_name \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf duplicate lrk phrase}.\fbreak
Enum: T\_Err\_already\_processed\_lrk\_phase\_
\fbreak
\line{Class: Err\_already\_processed\_lrk\_phase \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf duplicate parallel-parse phrase}.\fbreak
Enum: T\_Err\_already\_processed\_pp\_phase\_
\fbreak
\line{Class: Err\_already\_processed\_pp\_phase \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf duplicate raw character phrase}.\fbreak
Enum: T\_Err\_already\_processed\_rc\_phase\_
\fbreak
\line{Class: Err\_already\_processed\_rc\_phase \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf duplicate rule phrase}.\fbreak
Enum: T\_Err\_already\_processed\_rule\_phase\_
\fbreak
\line{Class: Err\_already\_processed\_rule\_phase \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf duplicate terminal phrase}.\fbreak
Enum: T\_Err\_already\_processed\_T\_phase\_
\fbreak
\line{Class: Err\_already\_processed\_T\_phase \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf duplicate-entry in alphabet}.\fbreak
Enum: T\_Err\_dup\_entry\_in\_alphabet\_
\fbreak
\line{Class: Err\_dup\_entry\_in\_alphabet \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf emitfile file does not exist}.\fbreak
Enum: T\_Err\_emitfile\_file\_does\_not\_exist\_
\fbreak
\line{Class: Err\_emitfile\_file\_does\_not\_exist \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf emitfile file not present}.\fbreak
Enum: T\_Err\_emitfile\_file\_not\_present\_
\fbreak
\line{Class: Err\_emitfile\_file\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf emitfile kw not present}.\fbreak
Enum: T\_Err\_emitfile\_kw\_not\_present\_
\fbreak
\line{Class: Err\_emitfile\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf file of T-alphabet not present}.\fbreak
Enum: T\_Err\_file\_of\_T\_alphabet\_not\_present\_
\fbreak
\line{Class: Err\_file\_of\_T\_alphabet\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf file-name file does not exist}.\fbreak
Enum: T\_Err\_filename\_file\_does\_not\_exist\_
\fbreak
\line{Class: Err\_filename\_file\_does\_not\_exist \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf fsc file does not exist}.\fbreak
Enum: T\_Err\_fsc\_file\_does\_not\_exist\_
\fbreak
\line{Class: Err\_fsc\_file\_does\_not\_exist \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf fsc file not present}.\fbreak
Enum: T\_Err\_fsc\_cntl\_file\_not\_present\_
\fbreak
\line{Class: Err\_fsc\_cntl\_file\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf improper closing of rules construct}.\fbreak
Enum: T\_Err\_improper\_closing\_of\_rules\_
\fbreak
\line{Class: Err\_improper\_closing\_of\_rules \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf improper directive}.\fbreak
Enum: T\_Err\_improper\_directive\_
\fbreak
\line{Class: Err\_improper\_directive \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf invalid fsm-debug value}.\fbreak
Enum: T\_Err\_fsm\_debug\_string\_not\_true\_or\_false\_
\fbreak
\line{Class: Err\_fsm\_debug\_string\_not\_true\_or\_false \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf invalid logical name}.\fbreak
Enum: T\_Err\_invalid\_logical\_name\_
\fbreak
\line{Class: Err\_invalid\_logical\_name \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf invalid logical value}.\fbreak
Enum: T\_Err\_invalid\_logical\_value\_
\fbreak
\line{Class: Err\_invalid\_logical\_value \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf la expression calculates an empty set}.\fbreak
Enum: T\_Err\_la\_expr\_calc\_empty\_set\_
\fbreak
\line{Class: Err\_la\_expr\_calc\_empty\_set \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf linker's monolithic value not n or y}.\fbreak
Enum: T\_Err\_monolithic\_value\_bad\_
\fbreak
\line{Class: Err\_monolithic\_value\_bad \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf linker's transitive value not n or y}.\fbreak
Enum: T\_Err\_transitive\_value\_bad\_
\fbreak
\line{Class: Err\_transitive\_value\_bad \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf misplaced or missing T enumeration phrase}.\fbreak
Enum: T\_ERR\_no\_T\_enum\_phrase\_
\fbreak
\line{Class: ERR\_no\_T\_enum\_phrase \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf misplaced or missing errors phrase}.\fbreak
Enum: T\_ERR\_no\_errors\_phrase\_
\fbreak
\line{Class: ERR\_no\_errors\_phrase \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf misplaced or missing fsm phrase}.\fbreak
Enum: T\_ERR\_no\_fsm\_phrase\_
\fbreak
\line{Class: ERR\_no\_fsm\_phrase \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf misplaced or missing lrk phrase}.\fbreak
Enum: T\_ERR\_no\_lrk\_phrase\_
\fbreak
\line{Class: ERR\_no\_lrk\_phrase \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf misplaced or missing rc phrase}.\fbreak
Enum: T\_ERR\_no\_rc\_phrase\_
\fbreak
\line{Class: ERR\_no\_rc\_phrase \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf misplaced or missing rules phrase}.\fbreak
Enum: T\_ERR\_no\_rules\_phrase\_
\fbreak
\line{Class: ERR\_no\_rules\_phrase \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf misplaced or missing terminals phrase}.\fbreak
Enum: T\_ERR\_no\_terminals\_phrase\_
\fbreak
\line{Class: ERR\_no\_terminals\_phrase \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf misplaced or misspelt Rule or T outside of Rules defs}.\fbreak
Enum: T\_Err\_misplaced\_or\_misspelt\_Rule\_or\_T\_
\fbreak
\line{Class: Err\_misplaced\_or\_misspelt\_Rule\_or\_T \hfil AB: N \hfil AD: N}


Thrown by |pass3.lex| grammar.
It is outside of a proper grammar's construct and 
does not have a symbol table entry.
So it could be a misspelt T or an orphanned rule outside of its
defining Rules construct.

\fbreak 
\hrule
@*2 {\bf missing lrk-sufx kw}.\fbreak
Enum: T\_Err\_missing\_lrk\_sufx\_kw\_
\fbreak
\line{Class: Err\_missing\_lrk\_sufx\_kw \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf missing terminals-refs kw}.\fbreak
Enum: T\_Err\_missing\_terminals\_refs\_kw\_
\fbreak
\line{Class: Err\_missing\_terminals\_refs\_kw \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf missing terminals-sufx kw}.\fbreak
Enum: T\_Err\_missing\_terminals\_sufx\_kw\_
\fbreak
\line{Class: Err\_missing\_terminals\_sufx\_kw \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf nested files exceeded}.\fbreak
Enum: T\_Err\_nested\_files\_exceeded\_
\fbreak
\line{Class: Err\_nested\_files\_exceeded \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*3 nested files exceeded user-declaration directive.
@<nested files exceeded user-declaration directive@>=

		public:
	Err_nested_files_exceeded(yacco2::INT Nested_file_cnt,std::string& File_name);
		yacco2::INT nested_cnt(){return nested_cnt_;};
		std::string* file_exceeded(){return &file_exceeded_;};
		private:
			yacco2::INT nested_cnt_;
			std::string file_exceeded_;
	
@*3 nested files exceeded user-implementation directive.
@<nested files exceeded user-implementation directive@>=

		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();}
	
@*2 {\bf no \ASTERICsign{}\ASTERICsign{}\ASTERICsign{}}.\fbreak
Enum: T\_Err\_no\_syntax\_code\_end\_present\_
\fbreak
\line{Class: Err\_no\_syntax\_code\_end\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no T in T-alphabet list}.\fbreak
Enum: T\_Err\_no\_terminals\_in\_T\_alphabet\_list\_
\fbreak
\line{Class: Err\_no\_terminals\_in\_T\_alphabet\_list \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no Ts in T-alphabet}.\fbreak
Enum: T\_Err\_no\_terminals\_present\_in\_T\_alphabet\_
\fbreak
\line{Class: Err\_no\_terminals\_present\_in\_T\_alphabet \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no close-brace}.\fbreak
Enum: T\_Err\_no\_close\_brace\_
\fbreak
\line{Class: Err\_no\_close\_brace \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no close-parenthesis}.\fbreak
Enum: T\_Err\_no\_close\_parenthesis\_
\fbreak
\line{Class: Err\_no\_close\_parenthesis \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no closing brace ending rules defs}.\fbreak
Enum: T\_Err\_no\_close\_brace\_ending\_rules\_defs\_
\fbreak
\line{Class: Err\_no\_close\_brace\_ending\_rules\_defs \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no cmd-lne-data}.\fbreak
Enum: T\_Err\_no\_cmd\_lne\_data\_
\fbreak
\line{Class: Err\_no\_cmd\_lne\_data \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no comma present}.\fbreak
Enum: T\_Err\_no\_comma\_present\_
\fbreak
\line{Class: Err\_no\_comma\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no constant-defs keyword present}.\fbreak
Enum: T\_Err\_no\_kdefs\_kw\_present\_
\fbreak
\line{Class: Err\_no\_kdefs\_kw\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no constant-defs-code present}.\fbreak
Enum: T\_Err\_no\_kdefs\_code\_present\_
\fbreak
\line{Class: Err\_no\_kdefs\_code\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no constant-defs-directive present}.\fbreak
Enum: T\_Err\_no\_constant\_defs\_present\_
\fbreak
\line{Class: Err\_no\_constant\_defs\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no directive present}.\fbreak
Enum: T\_Err\_no\_directive\_present\_
\fbreak
\line{Class: Err\_no\_directive\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no end-T-alphabet present}.\fbreak
Enum: T\_Err\_end\_T\_alphabet\_kw\_not\_present\_
\fbreak
\line{Class: Err\_end\_T\_alphabet\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no end-list-of-native...}.\fbreak
Enum: T\_Err\_end\_list\_native\_T\_kw\_not\_present\_
\fbreak
\line{Class: Err\_end\_list\_native\_T\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no end-list-of-trans...}.\fbreak
Enum: T\_Err\_end\_list\_of\_transitive\_threads\_kw\_not\_present\_
\fbreak
\line{Class: Err\_end\_list\_of\_transitive\_threads\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no end-of-code}.\fbreak
Enum: T\_Err\_no\_end\_of\_code\_
\fbreak
\line{Class: Err\_no\_end\_of\_code \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no end-preamble present}.\fbreak
Enum: T\_Err\_end\_preamble\_kw\_not\_present\_
\fbreak
\line{Class: Err\_end\_preamble\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no file-name kw present}.\fbreak
Enum: T\_Err\_filename\_kw\_not\_present\_
\fbreak
\line{Class: Err\_filename\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no file-name present}.\fbreak
Enum: T\_Err\_no\_filename\_present\_
\fbreak
\line{Class: Err\_no\_filename\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no file-name value}.\fbreak
Enum: T\_Err\_filename\_value\_not\_present\_
\fbreak
\line{Class: Err\_filename\_value\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no file-name-id present}.\fbreak
Enum: T\_Err\_no\_filename\_id\_present\_
\fbreak
\line{Class: Err\_no\_filename\_id\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no file-of-T-alphabet}.\fbreak
Enum: T\_Err\_file\_of\_T\_alphabet\_kw\_not\_present\_
\fbreak
\line{Class: Err\_file\_of\_T\_alphabet\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no filename}.\fbreak
Enum: T\_Err\_no\_filename\_
\fbreak
\line{Class: Err\_no\_filename \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no fsm-class present}.\fbreak
Enum: T\_Err\_no\_fsm\_class\_present\_
\fbreak
\line{Class: Err\_no\_fsm\_class\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no fsm-comments present}.\fbreak
Enum: T\_Err\_no\_fsm\_comments\_present\_
\fbreak
\line{Class: Err\_no\_fsm\_comments\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no fsm-comments string present}.\fbreak
Enum: T\_Err\_no\_fsm\_comments\_string\_
\fbreak
\line{Class: Err\_no\_fsm\_comments\_string \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no fsm-date present}.\fbreak
Enum: T\_Err\_no\_fsm\_date\_present\_
\fbreak
\line{Class: Err\_no\_fsm\_date\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no fsm-date string present}.\fbreak
Enum: T\_Err\_no\_fsm\_date\_string\_
\fbreak
\line{Class: Err\_no\_fsm\_date\_string \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no fsm-debug present}.\fbreak
Enum: T\_Err\_no\_fsm\_debug\_present\_
\fbreak
\line{Class: Err\_no\_fsm\_debug\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no fsm-debug string present}.\fbreak
Enum: T\_Err\_no\_fsm\_debug\_string\_
\fbreak
\line{Class: Err\_no\_fsm\_debug\_string \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no fsm-filename id present}.\fbreak
Enum: T\_Err\_no\_fsm\_filename\_id\_present\_
\fbreak
\line{Class: Err\_no\_fsm\_filename\_id\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no fsm-filename present}.\fbreak
Enum: T\_Err\_no\_fsm\_filename\_present\_
\fbreak
\line{Class: Err\_no\_fsm\_filename\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no fsm-id-present}.\fbreak
Enum: T\_Err\_no\_fsm\_id\_present\_
\fbreak
\line{Class: Err\_no\_fsm\_id\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no fsm-id-string present}.\fbreak
Enum: T\_Err\_no\_fsm\_id\_string\_
\fbreak
\line{Class: Err\_no\_fsm\_id\_string \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no fsm-namespace id present}.\fbreak
Enum: T\_Err\_no\_fsm\_namespace\_id\_present\_
\fbreak
\line{Class: Err\_no\_fsm\_namespace\_id\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no fsm-namespace present}.\fbreak
Enum: T\_Err\_no\_fsm\_namespace\_present\_
\fbreak
\line{Class: Err\_no\_fsm\_namespace\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no fsm-version present}.\fbreak
Enum: T\_Err\_no\_fsm\_version\_present\_
\fbreak
\line{Class: Err\_no\_fsm\_version\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no fsm-version string present}.\fbreak
Enum: T\_Err\_no\_fsm\_version\_string\_
\fbreak
\line{Class: Err\_no\_fsm\_version\_string \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no grammar-name present}.\fbreak
Enum: T\_Err\_grammar\_name\_kw\_not\_present\_
\fbreak
\line{Class: Err\_grammar\_name\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no grammar-name value}.\fbreak
Enum: T\_Err\_grammar\_name\_value\_not\_present\_
\fbreak
\line{Class: Err\_grammar\_name\_value\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no identifier present}.\fbreak
Enum: T\_Err\_no\_identifier\_present\_
\fbreak
\line{Class: Err\_no\_identifier\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no int present}.\fbreak
Enum: T\_Err\_no\_int\_present\_
\fbreak
\line{Class: Err\_no\_int\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no key-value present in definition}.\fbreak
Enum: T\_Err\_no\_terminal\_key\_present\_
\fbreak
\line{Class: Err\_no\_terminal\_key\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no list-of-native-terminals}.\fbreak
Enum: T\_Err\_list\_of\_terminals\_kw\_not\_present\_
\fbreak
\line{Class: Err\_list\_of\_terminals\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no list-of-transit...}.\fbreak
Enum: T\_Err\_no\_list\_of\_trans\_threads\_kw\_
\fbreak
\line{Class: Err\_no\_list\_of\_trans\_threads\_kw \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no monolithic present}.\fbreak
Enum: T\_Err\_monolithic\_kw\_not\_present\_
\fbreak
\line{Class: Err\_monolithic\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no name-space}.\fbreak
Enum: T\_Err\_namespace\_kw\_not\_present\_
\fbreak
\line{Class: Err\_namespace\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no name-space present}.\fbreak
Enum: T\_Err\_no\_namespace\_present\_
\fbreak
\line{Class: Err\_no\_namespace\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no name-space value}.\fbreak
Enum: T\_Err\_namespace\_value\_not\_present\_
\fbreak
\line{Class: Err\_namespace\_value\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no name-space-id present}.\fbreak
Enum: T\_Err\_no\_namespace\_id\_present\_
\fbreak
\line{Class: Err\_no\_namespace\_id\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no no-of-T present}.\fbreak
Enum: T\_Err\_no\_of\_T\_kw\_not\_present\_
\fbreak
\line{Class: Err\_no\_of\_T\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no open-brace}.\fbreak
Enum: T\_Err\_no\_open\_brace\_
\fbreak
\line{Class: Err\_no\_open\_brace \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no open-parenthesis}.\fbreak
Enum: T\_Err\_no\_open\_parenthesis\_
\fbreak
\line{Class: Err\_no\_open\_parenthesis \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no parallel thread function}.\fbreak
Enum: T\_Err\_no\_pp\_fnct\_id\_present\_
\fbreak
\line{Class: Err\_no\_pp\_fnct\_id\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no parallel-code}.\fbreak
Enum: T\_Err\_no\_pp\_code\_present\_
\fbreak
\line{Class: Err\_no\_pp\_code\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no parallel-code-syntax-code}.\fbreak
Enum: T\_Err\_no\_pp\_code\_stc\_present\_
\fbreak
\line{Class: Err\_no\_pp\_code\_stc\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no parallel-control-monitor}.\fbreak
Enum: T\_Err\_no\_pp\_ctrl\_mntor\_kw\_present\_
\fbreak
\line{Class: Err\_no\_pp\_ctrl\_mntor\_kw\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no parallel-la-bndary expr}.\fbreak
Enum: T\_Err\_pp\_la\_boundary\_attribute\_not\_fnd\_
\fbreak
\line{Class: Err\_pp\_la\_boundary\_attribute\_not\_fnd \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no parallel-la-boundary}.\fbreak
Enum: T\_Err\_no\_pp\_bndry\_present\_
\fbreak
\line{Class: Err\_no\_pp\_bndry\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no parallel-la-boundary-expr}.\fbreak
Enum: T\_Err\_no\_pp\_la\_bndary\_expr\_present\_
\fbreak
\line{Class: Err\_no\_pp\_la\_bndary\_expr\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no parallel-thread-function}.\fbreak
Enum: T\_Err\_no\_pp\_thread\_function\_present\_
\fbreak
\line{Class: Err\_no\_pp\_thread\_function\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no preamble source code}.\fbreak
Enum: T\_Err\_preamble\_srce\_code\_not\_present\_
\fbreak
\line{Class: Err\_preamble\_srce\_code\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no rule name present}.\fbreak
Enum: T\_Err\_no\_rule\_name\_present\_
\fbreak
\line{Class: Err\_no\_rule\_name\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no sub rule present}.\fbreak
Enum: T\_Err\_no\_sub\_rule\_present\_
\fbreak
\line{Class: Err\_no\_sub\_rule\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no sym-class id present}.\fbreak
Enum: T\_Err\_no\_sym\_class\_id\_present\_
\fbreak
\line{Class: Err\_no\_sym\_class\_id\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no sym-class present}.\fbreak
Enum: T\_Err\_no\_sym\_class\_present\_
\fbreak
\line{Class: Err\_no\_sym\_class\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no symbol definition present}.\fbreak
Enum: T\_Err\_no\_sym\_defs\_present\_
\fbreak
\line{Class: Err\_no\_sym\_defs\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no syntax-code present}.\fbreak
Enum: T\_Err\_no\_syntax\_code\_present\_
\fbreak
\line{Class: Err\_no\_syntax\_code\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no terminal-def-code present}.\fbreak
Enum: T\_Err\_no\_tdef\_code\_present\_
\fbreak
\line{Class: Err\_no\_tdef\_code\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no thread-name present}.\fbreak
Enum: T\_Err\_threadname\_kw\_not\_present\_
\fbreak
\line{Class: Err\_threadname\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no thread-name value}.\fbreak
Enum: T\_Err\_threadname\_value\_not\_present\_
\fbreak
\line{Class: Err\_threadname\_value\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no transitive present}.\fbreak
Enum: T\_Err\_transitive\_kw\_not\_present\_
\fbreak
\line{Class: Err\_transitive\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no\NOsign  in list-of-native-term...}.\fbreak
Enum: T\_Err\_no\_of\_terminals\_not\_present\_
\fbreak
\line{Class: Err\_no\_of\_terminals\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf no\NOsign  in list-of-trans...}.\fbreak
Enum: T\_Err\_no\_of\_threads\_not\_present\_
\fbreak
\line{Class: Err\_no\_of\_threads\_not\_present \hfil AB: N \hfil AD: N}


Cross check against the \O2 linker ``fsc'' info.
The ``list-of-transitive-threads'' construct also
states the number of entries in its list.
Some how they don't jive.
i think thar's something rotten in the fingers and 
diletants playing with the file?

\fbreak 
\hrule
@*2 {\bf no-of-T value not present}.\fbreak
Enum: T\_Err\_no\_of\_T\_value\_not\_present\_
\fbreak
\line{Class: Err\_no\_of\_T\_value\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf not :: in thread expr}.\fbreak
Enum: T\_Err\_not\_dbl\_colon\_in\_th\_stmt\_
\fbreak
\line{Class: Err\_not\_dbl\_colon\_in\_th\_stmt \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf not a Rule in chained dispatcher expr}.\fbreak
Enum: T\_Err\_not\_a\_Rule\_
\fbreak
\line{Class: Err\_not\_a\_Rule \hfil AB: N \hfil AD: N}


Thrown by |subrule_def.lex| grammar supporting the
new back-to-back thread call construct whereby the following procedure call is chained to
the pushed ``return T'' of the 1st thread call.
The term following the 1st thread call expression must be a rule whose
contents use the \\TRAshift operator.

\fbreak 
\hrule
@*2 {\bf not a kw to start the top/down parse construct}.\fbreak
Enum: T\_Err\_not\_kw\_defining\_grammar\_construct\_
\fbreak
\line{Class: Err\_not\_kw\_defining\_grammar\_construct \hfil AB: N \hfil AD: N}


Thrown by |pass3.lex| grammar.
Caused by an identifier that has been misplaced.
Could be a typo
where the item should be within the
defining Rules Vocabulary or 
a premature ending of the Rules construct by an extra close brace
whereby it is trying to define a rule.

\fbreak 
\hrule
@*2 {\bf not a lhs kw}.\fbreak
Enum: T\_Err\_not\_a\_lhs\_kw\_
\fbreak
\line{Class: Err\_not\_a\_lhs\_kw \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf not a namespace id in thread expr}.\fbreak
Enum: T\_Err\_not\_id\_for\_ns\_in\_th\_stmt\_
\fbreak
\line{Class: Err\_not\_id\_for\_ns\_in\_th\_stmt \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf not a terminal definition}.\fbreak
Enum: T\_Err\_not\_a\_terminal\_definition\_
\fbreak
\line{Class: Err\_not\_a\_terminal\_definition \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf not a thread name id in expr}.\fbreak
Enum: T\_Err\_not\_id\_for\_th\_name\_in\_th\_stmt\_
\fbreak
\line{Class: Err\_not\_id\_for\_th\_name\_in\_th\_stmt \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf not an arbitration-code keyword}.\fbreak
Enum: T\_Err\_not\_arbitration\_code\_kw\_
\fbreak
\line{Class: Err\_not\_arbitration\_code\_kw \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf not an eosr in subrule expr}.\fbreak
Enum: T\_Err\_not\_eos\_in\_subrule\_expr\_
\fbreak
\line{Class: Err\_not\_eos\_in\_subrule\_expr \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf preamble kw not present}.\fbreak
Enum: T\_Err\_preamble\_kw\_not\_present\_
\fbreak
\line{Class: Err\_preamble\_kw\_not\_present \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf re-compile grammar: bad T-alphabet}.\fbreak
Enum: T\_Err\_bad\_T\_alphabet\_
\fbreak
\line{Class: Err\_bad\_T\_alphabet \hfil AB: N \hfil AD: N}


Mismatch with the contents of the ``T-alphabet'' construct and the 
number of terminals stated in each individual grammar ``fsc'' file.
Usually means that terminals of some ilk have changed the
population and requires a recompilation per grammar
to match the vocabulary numbers.
That is regen grammars with the ``-t'' and ``-err'' switches.
This gens the eumeration file that ``o2linker'' depends on.

\fbreak 
\hrule
@*2 {\bf removal of term against empty set in la expr}.\fbreak
Enum: T\_Err\_empty\_set\_removal\_in\_la\_expr\_
\fbreak
\line{Class: Err\_empty\_set\_removal\_in\_la\_expr \hfil AB: N \hfil AD: N}


Bad expression where a removal expression is against an empty set.
For example, a - eolr - b is invalid. The eolr empties the set.
a - eolr + b is a round about way of having just b in the set.

\fbreak 
\hrule
@*2 {\bf report-card-ptr-0}.\fbreak
Enum: T\_Err\_report\_card\_ptr\_0\_
\fbreak
\line{Class: Err\_report\_card\_ptr\_0 \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf rotten chr in T-alphabet}.\fbreak
Enum: T\_Err\_rotten\_chr\_in\_T\_alphabet\_
\fbreak
\line{Class: Err\_rotten\_chr\_in\_T\_alphabet \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf rule already defined}.\fbreak
Enum: T\_Err\_rule\_already\_defined\_
\fbreak
\line{Class: Err\_rule\_already\_defined \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf rule does not gen T strings - sick grammar}.\fbreak
Enum: T\_ERR\_sick\_grammar\_
\fbreak
\line{Class: ERR\_sick\_grammar \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf rule not found in stbl}.\fbreak
Enum: T\_Err\_rule\_not\_in\_stbl\_
\fbreak
\line{Class: Err\_rule\_not\_in\_stbl \hfil AB: N \hfil AD: N}


Post process the grammar's vocabulary. 
A rule can be referenced before
its definition.
Just help the grammar writer of misselling or forgetfulness.

\fbreak 
\hrule
@*2 {\bf rule used but undefined}.\fbreak
Enum: T\_Err\_used\_rule\_but\_undefined\_
\fbreak
\line{Class: Err\_used\_rule\_but\_undefined \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf stbl char-pool full}.\fbreak
Enum: T\_Err\_sym\_tbl\_char\_pool\_full\_
\fbreak
\line{Class: Err\_sym\_tbl\_char\_pool\_full \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf stbl context-buf-overflow}.\fbreak
Enum: T\_Err\_sym\_tbl\_context\_buf\_overflow\_
\fbreak
\line{Class: Err\_sym\_tbl\_context\_buf\_overflow \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf stbl full}.\fbreak
Enum: T\_Err\_sym\_tbl\_full\_
\fbreak
\line{Class: Err\_sym\_tbl\_full \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf stbl has entry but not a rule}.\fbreak
Enum: T\_Err\_stble\_has\_entry\_but\_not\_a\_rule\_
\fbreak
\line{Class: Err\_stble\_has\_entry\_but\_not\_a\_rule \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf stbl scope-stk overflow}.\fbreak
Enum: T\_Err\_sym\_tbl\_nested\_scope\_stk\_overflow\_
\fbreak
\line{Class: Err\_sym\_tbl\_nested\_scope\_stk\_overflow \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf stbl scope-stk underflow}.\fbreak
Enum: T\_Err\_sym\_tbl\_nested\_scope\_stk\_underflow\_
\fbreak
\line{Class: Err\_sym\_tbl\_nested\_scope\_stk\_underflow \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf subrule overrun}.\fbreak
Enum: T\_Err\_subrule\_overrun\_
\fbreak
\line{Class: Err\_subrule\_overrun \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf subscript out-of-range}.\fbreak
Enum: T\_Err\_subscript\_out\_of\_range\_
\fbreak
\line{Class: Err\_subscript\_out\_of\_range \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf term not a lhs or parallel-control-monitor kw}.\fbreak
Enum: T\_Err\_not\_lhs\_pcnrl\_mntr\_
\fbreak
\line{Class: Err\_not\_lhs\_pcnrl\_mntr \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf terminals-refs duplicate}.\fbreak
Enum: T\_Err\_terminals\_refs\_dup\_def\_
\fbreak
\line{Class: Err\_terminals\_refs\_dup\_def \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf thread defined by another fsc file}.\fbreak
Enum: T\_Err\_already\_defined\_in\_fsc\_file\_
\fbreak
\line{Class: Err\_already\_defined\_in\_fsc\_file \hfil AB: N \hfil AD: N}


Each individual thread's fsc file contains its bio.
This error indicates that the grammar writer probably
cloned off a grammar but did not
edit properly the vital statistics.
So go edit the erroneous grammar and correct
its thread name, namespace etc.

\fbreak 
\hrule
@*2 {\bf thread in stbl but subscript badly set}.\fbreak
Enum: T\_Err\_bad\_thread\_subscript\_
\fbreak
\line{Class: Err\_bad\_thread\_subscript \hfil AB: N \hfil AD: N}


More of a sanity check in the symbol table.
If this occurs i'm really in trouble.

\fbreak 
\hrule
@*2 {\bf thread xrefed, but not defed}.\fbreak
Enum: T\_Err\_thread\_refed\_but\_not\_defined\_
\fbreak
\line{Class: Err\_thread\_refed\_but\_not\_defined \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*3 thread xrefed, but not defed user-declaration directive.
@<thread xrefed, but not defed user-declaration directive@>=

		public:
		Err_thread_refed_but_not_defined(CAbs_lr1_sym* Th_id);
		CAbs_lr1_sym* th_id();
		private:CAbs_lr1_sym* th_id_;
	
@*3 thread xrefed, but not defed user-implementation directive.
@<thread xrefed, but not defed user-implementation directive@>=

		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_;};
	
@*2 {\bf token found in stbl but not a kw}.\fbreak
Enum: T\_Err\_not\_a\_keyword\_
\fbreak
\line{Class: Err\_not\_a\_keyword \hfil AB: N \hfil AD: N}


The symbol is not a keyword. Could be an initialization
problem with my \O2 setup.

\fbreak 
\hrule
@*2 {\bf transitive list thread not defined by fsc files}.\fbreak
Enum: T\_Err\_bad\_th\_in\_list\_
\fbreak
\line{Class: Err\_bad\_th\_in\_list \hfil AB: N \hfil AD: N}


The hand coded ``???.fsc'' control file provides
all the threads' ``fsc'' files has thread entries missing.
Typically the grammar writer created a new thread but forgot the 
include it in the global ``fsc'' file.
So go add the missing thread entries in the global ``fsc'' file.

\fbreak 
\hrule
@*2 {\bf undefined terminal in subrule}.\fbreak
Enum: T\_Err\_subrule\_use\_undefined\_T\_
\fbreak
\line{Class: Err\_subrule\_use\_undefined\_T \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf unknown symbol type in stbl}.\fbreak
Enum: T\_Err\_stbl\_entry\_unknown\_
\fbreak
\line{Class: Err\_stbl\_entry\_unknown \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@*2 {\bf use of Non-terminal (rule) outside Rules's construct}.\fbreak
Enum: T\_Err\_use\_of\_N\_outside\_Rules\_construct\_
\fbreak
\line{Class: Err\_use\_of\_N\_outside\_Rules\_construct \hfil AB: N \hfil AD: N}


Thrown by |pass3.lex| grammar.
The rule reference has already been 
seen by the parsed Rules construct and
stored in the symbol table.
The symbol table returns the found item as a rule.
Cause is a reference to the rule outside of the Rules construct.
Probably a typo by the grammar writer caused by the premature
parsing of the Rules Vocabulary.

\fbreak 
\hrule
@*2 {\bf use of T outside Rules's construct}.\fbreak
Enum: T\_Err\_use\_of\_T\_outside\_Rules\_construct\_
\fbreak
\line{Class: Err\_use\_of\_T\_outside\_Rules\_construct \hfil AB: N \hfil AD: N}


Thrown by |pass3.lex| grammar.
The terminal definitions have already been parsed and
stored in the symbol table.
The symbol table returns the found item as a terminal rather than
the unfound identifier.
Cause is reference of a terminal outside of the Rules construct.
Probably a typo by the grammar writer.

\fbreak 
\hrule
@*2 {\bf zero len symbol}.\fbreak
Enum: T\_Err\_zero\_len\_sym\_
\fbreak
\line{Class: Err\_zero\_len\_sym \hfil AB: N \hfil AD: N}

\fbreak 
\hrule
@** Index.