ParseUtility Class Reference

#include <cccc_utl.h>

Collaboration diagram for ParseUtility:

Public Member Functions
	ParseUtility (ANTLRParser *parser)
	~ParseUtility ()
void	tracein (const char *rulename, int guessing, ANTLRAbstractToken *tok)
void	traceout (const char *rulename, int guessing, ANTLRAbstractToken *tok)
void	syn (_ANTLRTokenPtr tok, ANTLRChar *egroup, SetWordType *eset, ANTLRTokenType etok, int k)
string	lookahead_text (int n)
void	resynchronize (int initial_nesting, SetWordType *resync_token_class, ANTLRTokenPtr &resync_token)
string	scopeCombine (const string &baseScope, const string &name)

Static Public Member Functions
static ParseUtility *	currentInstance ()

Private Member Functions
	ParseUtility (const ParseUtility &)
const ParseUtility &	operator= (const ParseUtility &)

Private Attributes
ANTLR_Assisted_Parser *	parser
int	trace_depth

Static Private Attributes
static ParseUtility *	theCurrentInstance =NULL
static int	stack_depth
static string	stack_tokentext [MAX_STACK_DEPTH]
static int	stack_tokenline [MAX_STACK_DEPTH]
static string	stack_rules [MAX_STACK_DEPTH]

Detailed Description

Definition at line 139 of file cccc_utl.h.

Constructor & Destructor Documentation

ParseUtility::ParseUtility

(

ANTLRParser *

parser

)

Definition at line 183 of file cccc_utl.cc.

{
  // This is designed as a serial-singleton class (e.g. many 
  // instances may exist over time but no more than one at a
  // time).
  // For the lifetime of an instance, the static member theCurrentInstance
  // points to it. When no instance exists, this pointer is null.
  assert(theCurrentInstance==NULL);
  theCurrentInstance=this;

  trace_depth=0;
  stack_depth=0;
  this->parser=(ANTLR_Assisted_Parser*)parser;

}

ParseUtility::~ParseUtility

(

)

Definition at line 199 of file cccc_utl.cc.

{
  theCurrentInstance=NULL;
}

ParseUtility::ParseUtility ( const ParseUtility &  )

private

Member Function Documentation

static ParseUtility* ParseUtility::currentInstance ( )

inlinestatic

Definition at line 169 of file cccc_utl.h.

{ return theCurrentInstance; }

string ParseUtility::lookahead_text

(

int

n

)

Definition at line 99 of file cccc_utl.cc.

{
  static string retval;
  retval="";
  int i;
  for(i=1; i<=n; i++)
    {
      if(parser->LT(i) != NULL)
    {
      retval=retval+parser->LT(i)->getText();
      retval=retval+" ";
    }
    }
  return retval;
}

const ParseUtility& ParseUtility::operator= ( const ParseUtility &  )

private

void ParseUtility::resynchronize	(	int	initial_nesting,
		SetWordType *	resync_token_class,
		ANTLRTokenPtr &	resync_token
	)

Definition at line 115 of file cccc_utl.cc.

{
  // the interface for resynchronisation is as follows:
  // the caller supplies a nesting level at which the resynchronisation must 
  // occur, and a token class containing all of the tokens which can 
  // be accepted to delimit the resynchronisation
  // this function will scan until it finds that it is at the correct level and
  // the next token of lookahead is in the resynchronisation set
  // it will then accept as many tokens from the resynchronisation set as
  // are available, consolidating the text of the tokens accepted
  // as the text associated with the last token
  string resync_text="...";

  string string1=parser->LT(1)->getText();
  int line1=parser->LT(1)->getLine();
  string string2;
  int line2=0;

  int resynchronising=1;
  while(resynchronising)
    {
      parser->consumeUntil(resync_token_class);
      if( 
     (MY_TOK(parser->LT(1))->getNestingLevel() > initial_nesting) &&
     (parser->LT(2) != NULL)
     )
    {
      parser->consume();
    }
      else
    {
      // we are ready to resynchronise
      resynchronising=0;
      string2=parser->LT(1)->getText();
      line2=parser->LT(1)->getLine();
    }
    }

  // we now consume a succession of tokens from the resynchronisation token
  // class until we come across a token which is not in the set, or the
  // nesting level changes
  resync_token=parser->LT(1);
  while(
    parser->set_el(parser->LT(1)->getType(),resync_token_class) &&
    ( MY_TOK(parser->LT(1))->getNestingLevel() == initial_nesting) 
    )
    {
      string2=parser->LT(1)->getText();
      line2=parser->LT(1)->getLine();
 
      resync_text+=parser->LT(1)->getText();
      resync_text+=" ";
      resync_token=parser->LT(1);
      resync_token->setText(resync_text.c_str());
      parser->consume();
    }

  cerr << "Unrecognized section from " 
       << string1.c_str() << " on line " << line1 << " to " 
       << string2.c_str() << " on line " << line2 << endl
       << "=====ignored section begins=====" << endl
       << resync_text.c_str() << endl
       << "===== ignored section ends =====" << endl;
}

string ParseUtility::scopeCombine	(	const string &	baseScope,
		const string &	name
	)

Definition at line 207 of file cccc_utl.cc.

{
    // I am presently (as at 3.pre44) experimenting with
    // how I handle scopes.  The present code has a policy
    // of discarding scope information altogether and defining
    // modules based solely on the final component of the 
    // fully qualified name.
    // This variable may become a parameter to control policy in this
    // area.
    bool bIgnoreScope=true;
    string retval;
    if(bIgnoreScope)
    {
        retval=name;
    }
    else if(baseScope.size()>0 && name.size()>0)
    {
        retval=baseScope+"::"+name;
    }
    else
    {
        retval=baseScope+name;
    }
    
  return retval;
}

Here is the call graph for this function:

void ParseUtility::syn	(	_ANTLRTokenPtr	tok,
		ANTLRChar *	egroup,
		SetWordType *	eset,
		ANTLRTokenType	etok,
		int	k
	)

Definition at line 549 of file cccc_utl.cc.

{
  string filename=ParseStore::currentInstance()->filename();
  if(tok != NULL)
    {
      cerr << filename << '(' << tok->getLine() << "):" 
       << " syntax error at token " << tok->getText() << endl;
    }
  else
    {
      cerr << filename << "(0): syntax error at null token" << endl;
    }

#if 1
      // The logic in the other half of this #if section
      // generated too much noise for some people's taste.
      // It's only really useful to myself (TJL) or anyone
      // else with a taste for debugging cccc.g/java.g etc.
      int i=stack_depth-1;
      cerr << filename << '(' << stack_tokenline[i] 
       << "): trying to match " << stack_rules[i]
       << " at '" << stack_tokentext[i] << "'"
       << endl;
#else
  cerr << "Parser context:" << endl;
  for(int i=stack_depth-1; i>=0; i--)
    {
      cerr << filename << '(' << stack_tokenline[i] 
       << "): trying to match " << stack_rules[i]
       << " at '" << stack_tokentext[i] << "'"
       << endl;
    }   
  cerr << endl;
#endif
}   

Here is the call graph for this function:

void ParseUtility::tracein	(	const char *	rulename,
		int	guessing,
		ANTLRAbstractToken *	tok
	)

Definition at line 501 of file cccc_utl.cc.

{
  if(guessing == 0)
    {
      stack_tokentext[stack_depth]=tok->getText();
      stack_tokenline[stack_depth]=tok->getLine();
      stack_rules[stack_depth]=rulename;
      stack_depth++;
    }

  // first put out the token details
  toktrace(tok);
  
  // then the indented recognition trace
  rectrace(rulename,"-> ",guessing,tok);
}

Here is the call graph for this function:

void ParseUtility::traceout	(	const char *	rulename,
		int	guessing,
		ANTLRAbstractToken *	tok
	)

Definition at line 520 of file cccc_utl.cc.

{
  if(guessing == 0)
    {
      stack_depth--;
      // some error checking...
      if(stack_depth<0)
    {
      cerr << "ParseUtility::traceout negative stack depth - "
           << "exiting from rule " << rulename 
           << " at " << tok->getText() << " on line " << tok->getLine() 
           << endl;
    }
      else if(rulename!=stack_rules[stack_depth])
    {
      cerr << "ParseStore::traceout rule name mismatch - "
           << rulename << "!=" << stack_rules[stack_depth] << endl;
    }
      stack_tokentext[stack_depth]="";
      stack_tokenline[stack_depth]=0;
      stack_rules[stack_depth]="";
    }
  // first put out the token details
  toktrace(tok);
  rectrace(rulename,"<- ",guessing,tok);
}

Here is the call graph for this function:

Member Data Documentation

ANTLR_Assisted_Parser* ParseUtility::parser

private

Definition at line 174 of file cccc_utl.h.

int ParseUtility::stack_depth

staticprivate

Definition at line 176 of file cccc_utl.h.

string ParseUtility::stack_rules

staticprivate

Definition at line 179 of file cccc_utl.h.

int ParseUtility::stack_tokenline

staticprivate

Definition at line 178 of file cccc_utl.h.

string ParseUtility::stack_tokentext

staticprivate

Definition at line 177 of file cccc_utl.h.

ParseUtility * ParseUtility::theCurrentInstance =NULL

staticprivate

Definition at line 172 of file cccc_utl.h.

int ParseUtility::trace_depth

private

Definition at line 175 of file cccc_utl.h.

---

The documentation for this class was generated from the following files:

• cccc_utl.h
• cccc_utl.cc