LGParser.cpp.skl

#ifdef DFASTAR

		#include "ComGlobal.h"
      #include "LGParser.h"
		#include "LGActions.h"

		#define STKSIZE        1000 // Parser stack size.
		#define ACCEPT_STATE	@accp_sta.6d; // Final state.
      #define LOOKAHEADS        2

/*--- Parser Table Constants. -----------------------------------------------*/
                                                                                          
      static int n_terms	= @numb_term.5d;; // No. of terminals.                               
      static int n_heads   = @numb_head.5d;; // No. of non-terminals.     
      static int n_prods   = @numb_prod.5d;; // No. of productions.       
      static int n_states  = @numb_sta. 5d;; // No. of states.
      static int eol_symb  = @eol_numb. 5d;; // EOL symbol number            
      static int eof_symb  = @eof_numb. 5d;; // EOF symbol number            
      static int err_used  = @err_used. 5d;; // <error> used in grammar      

/*--- Terminal and Nonterminal Symbols of the Grammar. ----------------------*/

   // Terminal symbols of the grammar. 
      char* term_symb[@term_symb.d;] = 
      {
         @term_symb.1|"%s"|,|,\n         |;
      };                                                 

   // Head symbols of the grammar. 
      char* head_symb[@head_symb.d;] = 
      {
         @head_symb.1|"%s"|,|,\n         |;
      };

/*--- Production Information. -----------------------------------------------*/

   // Production length - 1 
      @prod_leng.t; PL[@prod_leng.d;] = 
      {
         @prod_leng.10|%6d|,|,\n         |;
      };

   // Head symbol for a production 
      @prod_head.t; head_numb[@prod_head.d;] = 
      {
         @prod_head.10|%6d|,|,\n         |;
      };

   // Index to first tail symbol for a production 
      @prod_tail.t; f_tail[@prod_tail.d;] = 
      {
         @prod_tail.10|%6d|,|,\n         |;
      };

   // Tail symbol numbers (T: >= 0, NT: < 0)
      @tail_numb.t; tail[@tail_numb.d;] = 
      {
         @tail_numb.10|%6d|,|,\n         |;
      };

/*--- token Action Variables ------------------------------------------------*/

   // token Action number. 
      @tact_numb.t; tact_numb[@tact_numb.d;] = 
      {
         @tact_numb.10|%6d|,|,\n         |;
      };

   // token Action Addresses.
      int (*tact_func[@tact_func.d;]) (int, int) = 
      {
         @tact_func.1|LGActions::%s|,|,\n         |;
      };

   // token Action argument index. 
      @tact_arg.t; tact_arg[@tact_arg.d;] = 
      {
         @tact_arg.10|%6d|,|,\n         |;
      };

/*--- Bit Matrix and Access Vectors. -----------------------------------------*/

   // B_matrix.
      @bmat_numb.t; Bm [@bmat_numb.d;] =
      {
      @bmat_numb.20|%5d|,|,\n      |;
      };

   // B_matrix row.
      @bmat_row.t; Br [@bmat_row.d;] =
      {
      @bmat_row.20|%5d|,|,\n      |;
      };

   // B_matrix column.
      @bmat_col.t; Bc [@bmat_col.d;] =
      {
      @bmat_col.20|%5d|,|,\n      |;
      };

   // B_matrix mask.
      @bmat_mask.t; Bmask [@bmat_mask.d;] =
      {
      @bmat_mask.20|%5d|,|,\n      |;
      };

/*--- Terminal Transition Matrix and Access Vectors. ------------------------*/

   // T_matrix.
      @tmat_numb.t; Tm [@tmat_numb.d;] =
      {
      @tmat_numb.20|%5d|,|,\n      |;
      };

   // T_matrix row.
      @tmat_row.t; Tr [@tmat_row.d;] =
      {
      @tmat_row.20|%5d|,|,\n      |;
      };

   // T_matrix column.
      @tmat_col.t; Tc [@tmat_col.d;] =
      {
      @tmat_col.20|%5d|,|,\n      |;
      };

/*--- Nonterminal Transition Matrix and Access Vectors. ---------------------*/

   // N_matrix.
      @nmat_numb.t; Nm [@nmat_numb.d;] =
      {
      @nmat_numb.20|%5d|,|,\n      |;
      };

   // N_matrix row.
      @nmat_row.t; Nr [@nmat_row.d;] =
      {
      @nmat_row.20|%5d|,|,\n      |;
      };

   // N_matrix column.
      @nmat_col.t; Nc [@nmat_col.d;] =
      {
      @nmat_col.20|%5d|,|,\n      |;
      };

/*--- Reduction Matrix and Access Vectors. ----------------------------------*/

   // R_matrix.
      @rmat_numb.t; Rm [@rmat_numb.d;] =
      {
      @rmat_numb.20|%5d|,|,\n      |;
      };

   // R_matrix row.
      @rmat_row.t; Rr [@rmat_row.d;] =
      {
      @rmat_row.20|%5d|,|,\n      |;
      };

   // R_matrix column.
      @rmat_col.t; Rc [@rmat_col.d;] =
      {
      @rmat_col.20|%5d|,|,\n      |;
      };

/*--- Production Action Variables. ------------------------------------------*/

/* // Reverse production.
      char Reverse[@prod_revs.d;] = 
      {
         @prod_revs.10|%6d|,|,\n         |;
      }; */

   // First action for a production
      @pact_numb.t; pact_numb[@pact_numb.d;] = 
      {
         @pact_numb.10|%6d|,|,\n         |;
      };

   // Production Action Addresses.
      int (*pact_func[@pact_func.d;]) (int, int) = 
      {
         @pact_func.1|LGActions::%s|,|,\n         |;
      };

   // Production Action argument index. 
      @pact_arg.t; LGParser::pact_arg[@pact_arg.d;] = 
      {
         @pact_arg.10|%6d|,|,\n         |;
      };

/*--- Argument Variables. ---------------------------------------------------*/

   // Action argument numbers 
		@arg_numb.t; LGParser::arg_numb[@arg_numb.d;] = 
      {
         @arg_numb.10|%6d|,|,\n         |;
      };

@arg_text?;...
   // Text for string arguments 
      char* arg_text[@arg_text.d;] = 
      {
         @arg_text.1|"%s"|,|,\n         |;
      };

@@
/*--- End of Parser Tables. ----------------------------------------------------*/

  		int      top_state;
  		PStack*  top_ptr;

      PStack*  LGParser::PS;                  
      PStack   LGParser::P_stack[STKSIZE]; 

      RStack*	LGParser::RS; 
      RStack	LGParser::R_stack[STKSIZE]; 

		char*    LGParser::T_list;
		char*    LGParser::H_list;
		int*     LGParser::P_list;

		char*    LGParser::T_start;
		char*    LGParser::T_end; 
		int      LGParser::T_line;        

		static char*	prt_line   (char* ls, int ln); 

///////////////////////////////////////////////////////////////////////////////
//                                                                           // 
//    LGParse                                                                  //

int   LGParser::Parse ()                            
{
		init_lexer ();										// Initialize lexer.
		if (LGActions::CheckOptions() == 0) return 0;
		LGActions::init();								// Initialize everything else.

      if (LGParser::parse() == 0) return 0;
		LGActions::term ();
		if (n_errors) return 0;
      return (1);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           // 
//    term                                                                   //
/*
int   LGParser::term ()
{
		delete [] node;
      LGLexer::term();
      return (0);
}
*/
///////////////////////////////////////////////////////////////////////////////
//                                                                           // 
//    parse                                                                  //

int   LGParser::parse ()                        // LR Parser.               
{
      int t;												// Terminal. 
      int p;												// Production.  
      int x;												// State.  

      PS = P_stack;										// Set parse stack pointer.   
      n_errors = 0;										// Set number of errors.    
      x = 0;												// Set state to zero.

      RS = R_stack;										// Reset reduction stack pointer.
		top_ptr = PS;										// Save parse stack top pointer.
		top_state = x;										// Save current state.
		t = get_token ();									// Get token. 
		if (t == 0) goto Err;							// Bad token!
		goto Cont;

Read: RS = R_stack;										// Reset reduction stack pointer.
		top_ptr = PS;										// Save parse stack top pointer.
		top_state = x;										// Save current state.
		t = get_token ();									// Get next token. 
Cont:	if (tact_numb[t] >= 0)							// If input action ...         
      {
			int t1 = t;
      // T_start = token.start;						// Set token start.
      // T_end   = token.end;							// Set token end.
         t = (*tact_func[tact_numb [t]]) (t, tact_arg[t]);	// Call token action.  
      }
    	/*	For debugging ...
			char ch = *token.end;
  			*token.end = 0;
			printf ("       %-20s %3d, %s\n", token.start, t, term_symb[t]);
  			*token.end = ch; 
		*/

Shft: if (Bm [Br[x] + Bc[t]] & Bmask[t])			// Accept this terminal symbol?
      {
         (++PS)->state = x;                     // Stack state.   
         PS->start = token.start;					// Stack token start pointer.
         PS->end   = token.end;						// Stack token end pointer.
         PS->line  = token.line;						// Stack token line number.
         p = -Tm [Tr[x] + Tc[t]];					// Get reduction or next state.
         while (p >= 0)							      // While shift-reduce action.
         {
            PS -= PL[p];                        // Reduce parse stack pointer. 
				if (apply (p) != 0) return (0);		// Apply reduction, quit parsing?
            p = -Nm [Nr[PS->state] + Nc[p]];		// Get reduction or next state.
         }
			x = -p;											// Set next state.
         goto Read;										// Go read next token.
      }
      if ((p = Rr[x]) > 0 || (p = Rm [Rc[t] - p]) > 0) // Get reduction?
      {
         if (PL[p] == -1)                       // Null production?
         {
     		   (++RS)->state = (++PS)->state;		// Save state before destroying it.
            PS->state  = x;							// Stack state.
				RS->ptr = PS;						   // Save parse-stack pointer.
            PS->start  = NULL;					   // Clear start.
            PS->end    = NULL;					   // Clear end.
				goto Apply;
         }
         do 
         {
            PS -= PL[p];                        // Reduce parse stack ptr by production length. 
Apply:		if (apply (p) != 0) return (0);		// Apply reduction, quit parsing?
            p = -Nm [Nr[PS->state] + Nc[p]];		// Get reduction or next state.
         }
         while (p > 0);	
         x = -p;											// Set new state.
         goto Shft;										// Try to shift from this new state.
      }

      if (x == ACCEPT_STATE) 
      {
         PS -= PL[0];                             
         line_numb--;
			if (n_errors > 0) return (0);
         return (1);
      }

//		Error ...
Err:  syntax_error (t); 
		expecting ();
      return (0);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           // 
//    apply                                                                  //

int   LGParser::apply (int p)
{
      int i, n, r, a;
      if (pact_numb[p] >= 0)				      // Call function?  
      {
			a = pact_arg[p];							// Get first arg index.
         i = arg_numb [a] - 1;					// Get parse stack position.
			if (i >= 0)									// Valid parse stack position?	
			{
				T_start = PS[i].start;           // Define T_start working pointer.
				T_end   = PS[i].end;             // Define T_end working pointer.
				T_line  = PS[i].line;            // Define T_line.
			}
			else											// Use last token accepted.
			{
				T_start = token.start;           // Define T_start working pointer.
				T_end   = token.end;             // Define T_end working pointer.
				T_line  = token.line;            // Define T_line.
			}
         r = (*pact_func [pact_numb[p]]) (p, a);   // Call production action.               
			if (r != 0) return (r);
      }  
      return (0);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           // 

void  LGParser::syntax_error (int t)
{
      ushort ln, i, j;																																 
      char *ls, *le, *p, c;

		if (++n_errors == 1) prt_log ("\n");

		ls = line_start;
		ln = line_numb;
		if (*token.start == 26 || *ls == 26)  // At <eof> ?
		{
			do // Backup to last line start.
			{
				for (ls -= 2; *ls != '\n'; ls--);
				ls++;
				ln--;
			}
			while (token.start < ls);
		}
		else if (token.start < ls) // If token starts before current line start.
		{
			do 
			{
				for (ls--; *ls != '\n'; ls--);
			}
			while (token.start < ls);
			ls++;
		}
		le = prt_line (ls, ln);
		prt_pointer (ls, ln, token.start);
      if (*token.start <= 32) 
      {
         short x = *token.start;
         if (x < 0) x += 256;
         prt_log ("at (%d) %s\n", x,  term_symb[t]);
      }
      else
      {
         if (token.end == token.start) token.end++;
         if (token.end > le) 
         {
            if (*token.end == 26) line_numb--;
            prt_log ("starts here\n");
				prt_line (line_start, line_numb);
				prt_pointer (line_start, line_numb, token.end);
				prt_log ("ends here.\n");
         }
         else
         {
            c = *token.end; 
            *token.end = 0;
				int x = *(token.start+1);
				if (x < 0) x += 256;
            prt_log ("at %s (%d) %s\n", token.start, x, term_symb[t]);
            *token.end = c;
         }
      }	
      prt_log ("%s(%04d) : Syntax error.\n\n", grmfid, line_numb);
}

char* LGParser::prt_line (char* ls, int ln) 
{
		char *p;
	// Replace tabs with spaces. 
      for (p = ls; *p != '\n'; p++)
      {
         if (*p == '\t') *p = ' ';
      }
	// Remove ending spaces.
      while (*(--p) == ' '); 
      *(++p) = 0;
	// Print the line.
      prt_log ("%s(%04d) : %s\n", grmfid, ln, ls);
		*p = '\n';
		return (p);
}

void	LGParser::prt_pointer (char* ls, int ln, char* token) 
{
      int  i = 0;
		char *p, string[10000];
      for (p = ls; p < token; p++)   
      {
			string[i++] = '-';
			if (i == 9999) break;
      }
      string[i++] = 0;
      prt_log ("%s(%04d) : %s^ ", grmfid, ln, string);
}

////////////////////////////////////////////////////////////////////////////////
//

void  LGParser::expecting ()
{
		int t;

		T_list = (char*)malloc (sizeof(*T_list)*n_terms);
		H_list = (char*)malloc (sizeof(*H_list)*n_heads);
		P_list = (int* )malloc (sizeof(*P_list)*n_prods);

		for (t = 0; t < n_terms; t++) T_list[t] = 0;

		prt_log ("Expecting one of the following:\n\n");

		restore ();
	  	collect (top_state);	

		prt_log ("\n");

		free (P_list);
		free (H_list);
		free (T_list);
}

////////////////////////////////////////////////////////////////////////////////
//

void  LGParser::restore () // Restore parse stack.    
{
		while (RS > R_stack) // For all null reductions.                   
		{  
			(RS->ptr)->state = RS->state;	// Replace state with the saved one.
			RS--;
		}
		PS = top_ptr;
}

////////////////////////////////////////////////////////////////////////////////
//

void	LGParser::collect (int x) // Collect terminals that cause a transition or reduction. 
{
		int t, y, p, h, i, la, offset, n_red;
	//	printf ("Collecting terminals in state %d\n", x);
		for (h = 0; h < n_heads; h++) H_list[h] = -1;
     	for (t = 0; t < n_terms; t++)							// For all terminals.
		{
  			if (Bm [Br[x] + Bc[t]] & Bmask[t])				// Accept this terminal?
			{
				if (T_list[t] == 0 && t != T_PERCENT)
				{
					T_list[t] = 1;										// Mark it done, in case of SR conflict.
					y = Tm [Tr[x] + Tc[t]];							// Get action?
					if (y > 0)											// Shift & goto y action?
					{
			    		if ((p = Rr[y]) > 0)							// Default reduction in state y?
						{
							if (PL[p] == 0) H_list [head_numb[p]] = t;				
						}
						else 
						{
							offset = -p;	
     						for (la = 0; la < n_terms; la++)			// For all lookaheads.
							{
								if ((p = Rm [Rc[la] + offset]) > 0)	// Got a reduction on this terminal?
								{
									if (PL[p] == 0) H_list [head_numb[p]] = t; // Yes t and not la.				
								}
							}
						}
					}
					else 													// Shift & reduce action!
					{
						p = -y;											// Get production.
						if (PL[p] == 0) H_list [head_numb[p]] = t;				
					}
					prt_log ("\t%-32s", term_symb[t]);
					char first = 1;
					char blank[21] = "                    ";
					for (h = 0; h < n_heads; h++)
					{
						if (H_list[h] == t)
						{
							if (first)
							{
								prt_log (" => %s\n", head_symb[h]);	
								first = 0;
							}
							else
							{
								prt_log ("\t%-32s => %s\n", blank, head_symb[h]);
							}
						}
					}
					if (first)
					{
						prt_log ("\n");
					}
				}
			}
		}
    	if ((p = Rr[x]) > 0)										// Default reduction?
		{
			reduce (p, x);
		}
		else															// Reductions based on lookaheads!    		
		{
			n_red  = 0;
			offset = -p;	
			for (la = 0; la < n_terms; la++)			
			{
				if ((p = Rm [Rc[la] + offset]) > 0)			// Got a reduction on this terminal?
				{	
			  		for (i = 0; i < n_red; i++)				// For all reductions in the list.
					{
						if (P_list[i] == p) break;				// Already in this list?
					}
					if (i == n_red) P_list [n_red++] = p;	// Add this production to list.
				}
			}
		  	for (i = 0; i < n_red; i++)
			{
				reduce (P_list[i], x);
			}	  
		}
}

////////////////////////////////////////////////////////////////////////////////
//

void	LGParser::reduce (int p, int x)			// Reduce production. 
{
      if (PL[p] == -1)                       // Null production?
      {
			PS++;											// Increment stack pointer.
         PS->state = x;								// Stack state.
			goto Cont;
      }
		do
		{
			PS -= PL[p];								// Reduce parse stack pointer. 
Cont:		p = -Nm [Nr[PS->state] + Nc[p]];		// Get reduction or next state.
		}
		while (p > 0);
		x = -p;											// Set new state.
		collect (x);									// Go collect terminals.	
}

#endif

///// End of Parser ////////////////////////////////////////////////////////////