/*
 * gen.c
 *
 * Generate C code (ANSI, K&R, C++)
 *
 * SOFTWARE RIGHTS
 *
 * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
 * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
 * company may do whatever they wish with source code distributed with
 * PCCTS or the code generated by PCCTS, including the incorporation of
 * PCCTS, or its output, into commerical software.
 *
 * We encourage users to develop software with PCCTS.  However, we do ask
 * that credit is given to us for developing PCCTS.  By "credit",
 * we mean that if you incorporate our source code into one of your
 * programs (commercial product, research project, or otherwise) that you
 * acknowledge this fact somewhere in the documentation, research report,
 * etc...  If you like PCCTS and have developed a nice tool with the
 * output, please mention that you developed it using PCCTS.  In
 * addition, we ask that this header remain intact in our source code.
 * As long as these guidelines are kept, we expect to continue enhancing
 * this system and expect to make other tools available as they are
 * completed.
 *
 * ANTLR 1.33
 * Terence Parr
 * Parr Research Corporation
 * with Purdue University and AHPCRC, University of Minnesota
 * 1989-2001
 */

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include "pcctscfg.h"
#include "set.h"
#include "syn.h"
#include "hash.h"
#include "generic.h"
#include "dlgdef.h"

#define NumExprPerLine	4
static int on1line=0;
static set tokensRefdInBlock;

					/* T r a n s l a t i o n  T a b l e s */

/* C_Trans[node type] == pointer to function that knows how to translate that node. */
#ifdef __cplusplus
void (*C_Trans[NumNodeTypes+1])(...) = {
	NULL,
	NULL,					/* See next table.
Junctions have many types */
	(void (*)(...)) genRuleRef,
	(void (*)(...)) genToken,
	(void (*)(...)) genAction
 };
#else
void (*C_Trans[NumNodeTypes+1])() = {
	NULL,
	NULL,					/* See next table.
Junctions have many types */
	genRuleRef,
	genToken,
	genAction
 };
#endif

/* C_JTrans[Junction type] == pointer to function that knows how to translate that
 * kind of junction node.
 */
#ifdef __cplusplus
void (*C_JTrans[NumJuncTypes+1])(...) = {
	NULL,
	(void (*)(...)) genSubBlk,
	(void (*)(...)) genOptBlk,
	(void (*)(...)) genLoopBlk,
	(void (*)(...)) genEndBlk,
	(void (*)(...)) genRule,
	(void (*)(...)) genJunction,
	(void (*)(...)) genEndRule,
	(void (*)(...)) genPlusBlk,
	(void (*)(...)) genLoopBegin
 };
#else
void (*C_JTrans[NumJuncTypes+1])() = {
	NULL,
	genSubBlk,
	genOptBlk,
	genLoopBlk,
	genEndBlk,
	genRule,
	genJunction,
	genEndRule,
	genPlusBlk,
	genLoopBegin
 };
#endif

#define PastWhiteSpace(s)	while (*(s) == ' ' || *(s) == '\t') {s++;}

static int tabs = 0;

/* MR6	Got tired of text running off page when using standard tab stops */

#define TAB { int i; 					                		\
	      if (TabWidth==0) { 					                \
	         for (i=0; i<tabs; i++) fputc('\t', output);		                \
	      } else {           							\
		 for (i=0; i<tabs*TabWidth; i++) fputc(' ',output);     	        \
	      };	                						\
	    }

static void
#ifdef __USE_PROTOS
tab( void )
#else
tab( )
#endif
TAB

#ifdef __USE_PROTOS
static char *tokenFollowSet(TokNode *);
static ActionNode *findImmedAction( Node * );
static void dumpRetValAssign(char *, char *, RuleRefNode *);		/* MR30 */
static void dumpAfterActions(FILE *output);
static set ComputeErrorSet(Junction *, int, int);
static void makeErrorClause(Junction *, set, int, int);
static void DumpFuncHeader( Junction *, RuleEntry * );
static int has_guess_block_as_first_item(Junction *);
static int genExprSets(set *, int);
static void genExprTree( Tree *t, int k );
static void genExprTreeOriginal( Tree *t, int k );                  /* MR10 */
static char * findOuterHandlerLabel(ExceptionGroup *eg);            /* MR7 */
static void OutLineInfo(FILE *file,int line,char *fileName);        /* MR14 */
#else
static char *tokenFollowSet();
static ActionNode *findImmedAction();
static void dumpRetValAssign();
static void dumpAfterActions();
static set ComputeErrorSet();
static void makeErrorClause();
static void DumpFuncHeader();
static int has_guess_block_as_first_item();
static int genExprSets();
static void genExprTree();
static void genExprTreeOriginal();                                  /* MR10 */
static char * findOuterHandlerLabel();                              /* MR7 */
static void OutLineInfo();                                          /* MR14 */
#endif

#define gen(s)			{tab(); fprintf(output, s);}
#define gen1(s,a)		{tab(); fprintf(output, s,a);}
#define gen2(s,a,b)		{tab(); fprintf(output, s,a,b);}
#define gen3(s,a,b,c)	{tab(); fprintf(output, s,a,b,c);}
#define gen4(s,a,b,c,d)	{tab(); fprintf(output, s,a,b,c,d);}
#define gen5(s,a,b,c,d,e)	{tab(); fprintf(output, s,a,b,c,d,e);}
#define gen6(s,a,b,c,d,e,f)	{tab(); fprintf(output, s,a,b,c,d,e,f);}
#define gen7(s,a,b,c,d,e,f,g)	{tab(); fprintf(output, s,a,b,c,d,e,f,g);}

#define _gen(s)			{fprintf(output, s);}
#define _gen1(s,a)		{fprintf(output, s,a);}
#define _gen2(s,a,b)	{fprintf(output, s,a,b);}
#define _gen3(s,a,b,c)	{fprintf(output, s,a,b,c);}
#define _gen4(s,a,b,c,d){fprintf(output, s,a,b,c,d);}
#define _gen5(s,a,b,c,d,e){fprintf(output, s,a,b,c,d,e);}
#define _gen6(s,a,b,c,d,e,f){fprintf(output, s,a,b,c,d,e,f);}
#define _gen7(s,a,b,c,d,e,f,g){fprintf(output, s,a,b,c,d,e,f,g);}


/* MR11 a convenient place to set a break point */

#ifdef __USE_PROTOS
void MR_break(void) 
#else
void MR_break() 
#endif
{
  return;
}

/* MR10 genTraceOut(Junction *)      */

#ifdef __USE_PROTOS
static void genTraceOut(Junction *q)
#else
static void genTraceOut(q)
  Junction  *q;
#endif
{
  if ( TraceGen ) {
		if ( GenCC ) {gen1("zzTRACEOUT(\"%s\");\n", q->rname);}
    		else gen1("zzTRACEOUT((ANTLRChar *)\"%s\");\n", q->rname);
  }
}

static void
#ifdef __USE_PROTOS
warn_about_using_gk_option(void)
#else
warn_about_using_gk_option()
#endif
{
	static int warned_already=0;

	if ( !DemandLookahead || warned_already ) return;
	warned_already = 1;
	warnNoFL("-gk option could cause trouble for <<...>>? predicates");
}

void
#ifdef __USE_PROTOS
freeBlkFsets( Junction *q )
#else
freeBlkFsets( q )
Junction *q;
#endif
{
	int i;
	Junction *alt;
	require(q!=NULL, "freeBlkFsets: invalid node");

	for (alt=q; alt != NULL; alt= (Junction *) alt->p2 )
	{
		for (i=1; i<=CLL_k; i++) set_free(alt->fset[i]);
	}
}

/*
 * Generate a local variable allocation for each token references
 * in this block.
 */
static void
#ifdef __USE_PROTOS
genTokenPointers( Junction *q )
#else
genTokenPointers( q )
Junction *q;
#endif
{
	/* Rule refs are counted and can be referenced, but their
	 * value is not set to anything useful ever.
	 *
     * The ptrs are to be named _tij where i is the current level
	 * and j is the element number within an alternative.
	 */
	int first=1, t=0;
	set a;
	tokensRefdInBlock = q->tokrefs;

	if ( set_deg(q->tokrefs) == 0 ) return;
	a = set_dup(q->tokrefs);
	gen("ANTLRTokenPtr ");
	for (; !set_nil(a); set_rm(t, a))
	{
		t = set_int(a);
		if ( first ) first = 0;
		else _gen(",");
		if ( !DontCopyTokens ) _gen2("_tv%d%d,", BlkLevel, t);
		_gen2("_t%d%d", BlkLevel, t);
		if ( !DontCopyTokens ) {_gen2("= &_tv%d%d", BlkLevel, t);}
		else _gen("=NULL");
	}
	_gen(";\n");
	set_free(a);
}

static int
#ifdef __USE_PROTOS
hasDefaultException(ExceptionGroup *eg)
#else
hasDefaultException(eg)
ExceptionGroup *eg;
#endif
{
    ListNode *q;

    for (q = eg->handlers->next; q!=NULL; q=q->next)
    {
        ExceptionHandler *eh = (ExceptionHandler *)q->elem;
        if ( strcmp("default", eh->signalname)==0 ) {
            return 1;
        }
    }
    return 0;
}
static void
#ifdef __USE_PROTOS
dumpException(ExceptionGroup *eg, int no_default_case)
#else
dumpException(eg, no_default_case)
ExceptionGroup *eg;
int no_default_case;
#endif
{
    char    *outerLabel;                                             /* MR7 */
    int     altHandler=0;                                            /* MR7 */
    int     namedHandler=0;                                          /* MR7 */

    outerLabel=findOuterHandlerLabel(eg);                            /* MR7 */

    if (eg->label != NULL) {                                         /* MR7 */
      namedHandler=1;                                                /* MR7 */
    } else if (eg->forRule) {                                        /* MR7 */
      /* nothing */                                                  /* MR20 */
    } else {                                                         /* MR7 */
      altHandler=1;                                                  /* MR7 */
    };                                                               /* MR7 */

#if 0
**     if (! eg->used) {                                             /* MR7 */
**     	warnFL("exception group never used",                         /* MR7 */
**             FileStr[eg->altstart->file],eg->altstart->line);      /* MR7 */
**     };                                                            /* MR7 */
#endif

    if (namedHandler) {                                              /* MR7 */
	  gen1("switch ( _signal ) {  /* [%s] */\n",eg->label);          /* MR7 */
    } else {                                                         /* MR7 */
	  gen("switch ( _signal ) {\n");                                 /* MR7 */
      gen("case NoSignal: break;  /* MR7 */\n");                     /* MR7 */
    };                                                               /* MR7 */
	{
		ListNode *q;
		for (q = eg->handlers->next; q!=NULL; q=q->next)
		{
			ExceptionHandler *eh = (ExceptionHandler *)q->elem;
			if ( strcmp("default", eh->signalname)==0 ) {
				gen("default :\n");
				tabs++;
				dumpAction(eh->action, output, tabs, -1, 1, 1);
                gen("_signal=NoSignal;  /* MR7 */\n");                  /* MR7 */
                gen("break;  /* MR7 */\n");                             /* MR7 */
				tabs--;
				gen("}\n");

                /* copied from later code in dumpException */        /* MR7 */

                if (namedHandler) {                                  /* MR7 */
                  gen("if (_signal != NoSignal)");                   /* MR7 */
                  _gen1(" goto %s_handler;  /* MR7 */\n",outerLabel);/* MR7 */
                } else if (altHandler) {                             /* MR7 */
                  gen1("goto %s_handler;  /* MR7 */\n",outerLabel);  /* MR7 */
                };
				return;
			}
			gen1("case %s :\n", eh->signalname);
			tabs++;
			if ( eh->action != NULL )
			{
				dumpAction(eh->action, output, tabs, -1, 1, 1);
                gen("break;  /* MR7 */\n");                          /* MR7 */
			}
			tabs--;
		}
	}
	if ( no_default_case ) return;

	gen("default :\n");
    tabs++;                                                         /* MR7 */
    gen("break;  /* MR7 */\n");                                     /* MR7 */
    tabs--;                                                         /* MR7 */

	tabs++;
/*****	gen("*_retsignal = _signal;\n"); *****/

	tabs--;
	gen("}\n");

    if (namedHandler) {                                             /* MR7 */
      gen("if (_signal != NoSignal)");                              /* MR7 */
      _gen1(" goto %s_handler;  /* MR7 */\n",outerLabel);           /* MR7 */
    } else if (altHandler) {                                        /* MR7 */
      gen1("goto %s_handler;  /* MR7 */\n",outerLabel);             /* MR7 */
    };

}

static void
#ifdef __USE_PROTOS
dumpExceptions(ListNode *list)
#else
dumpExceptions(list)
ListNode *list;
#endif
{
	ListNode *p;

	for (p = list->next; p!=NULL; p=p->next)
	{
		ExceptionGroup *eg = (ExceptionGroup *) p->elem;
		_gen2("%s%s_handler:\n",
			  eg->label==NULL?"":eg->label,
			  eg->altID==NULL?"":eg->altID);
		if ( eg->altID!=NULL ) dumpException(eg, 0);
		else {
			/* This must be the rule exception handler */
			dumpException(eg, 1);
			if ( !hasDefaultException(eg) )
            {
                gen("default :\n");
                tabs++;
                gen("zzdflthandlers(_signal,_retsignal);\n");
                tabs--;
                gen("}\n");
            }
		}
	}
}

/* For each element label that is found in a rule, generate a unique
 * Attribute (and AST pointer if GenAST) variable.
 */
void
#ifdef __USE_PROTOS
genElementLabels(ListNode *list)
#else
genElementLabels(list)
ListNode *list;
#endif
{
	int first=1;
	ListNode *p;

	if ( GenCC ) {gen("ANTLRTokenPtr");}
	else {gen("Attrib");}
	for (p = list->next; p!=NULL; p=p->next)
	{
		char *ep = (char *)p->elem;
		if ( first ) first = 0;
		else _gen(",");
		if ( GenCC ) {_gen1(" %s=NULL",ep);}
		else {_gen1(" %s",ep);}
	}
	_gen(";\n");

	if ( !GenAST ) return;

	first = 1;
	gen("AST");
	for (p = list->next; p!=NULL; p=p->next)
	{
		char *ep = (char *)p->elem;
		if ( first ) first = 0;
		else _gen(",");
		_gen1(" *%s_ast=NULL",ep);
	}
	_gen(";\n");
}

/*
 * Generate a local variable allocation for each token or rule reference
 * in this block.
 */
static void
#ifdef __USE_PROTOS
genASTPointers( Junction *q )
#else
genASTPointers( q )
Junction *q;
#endif
{
	int first=1, t;
	set a;

	a = set_or(q->tokrefs, q->rulerefs);
	if ( set_deg(a) > 0 )
	{
		gen("AST ");
		for (; !set_nil(a); set_rm(t, a))
		{
			t = set_int(a);
			if ( first ) first = 0;
			else _gen(",");
			_gen2("*_ast%d%d=NULL", BlkLevel, t);
		}
		set_free(a);
	}
	_gen(";\n");
}

static void
#ifdef __USE_PROTOS
BLOCK_Head( void )
#else
BLOCK_Head( )
#endif
{
	gen("{\n");
	tabs++;
	if ( !GenCC ) gen1("zzBLOCK(zztasp%d);\n", BlkLevel);
}

static void
#ifdef __USE_PROTOS
BLOCK_Tail( void )
#else
BLOCK_Tail( )
#endif
{
	if ( !GenCC ) gen1("zzEXIT(zztasp%d);\n", BlkLevel);
	if ( !GenCC ) gen("}\n");
	tabs--;
	gen("}\n");
}

static void
#ifdef __USE_PROTOS
BLOCK_Preamble( Junction *q )
#else
BLOCK_Preamble( q )
Junction *q;
#endif
{
	ActionNode *a;
	Junction *begin;

	BLOCK_Head();
	if ( GenCC ) genTokenPointers(q);
	if ( GenCC&&GenAST ) genASTPointers(q);
	if ( q->jtype == aPlusBlk ) gen("int zzcnt=1;\n");
	if ( q->parm != NULL && !q->predparm ) gen1("zzaPush(%s);\n", q->parm)
	else if ( !GenCC ) gen("zzMake0;\n");
	if ( !GenCC ) gen("{\n");
	if ( q->jtype == aLoopBegin ) begin = (Junction *) ((Junction *)q->p1);
	else begin = q;
	if ( has_guess_block_as_first_item(begin) )
	{
		gen("zzGUESS_BLOCK\n");
	}
	if ( q->jtype == aLoopBegin )
		a = findImmedAction( ((Junction *)q->p1)->p1 );	/* look at aLoopBlk */
	else
		a = findImmedAction( q->p1 );
	if ( a!=NULL && !a->is_predicate) {
/* MR21 */ if (!a->noHoist) dumpActionPlus(a, a->action, output, tabs, a->file, a->line, 1);
		   a->done = 1;	/* remove action. We have already handled it */
	}
}

void
#ifdef __USE_PROTOS
genCombinedPredTreeContextOrig( Predicate *p )
#else
genCombinedPredTreeContextOrig( p )
Predicate *p;
#endif
{
	static set *ctx=NULL;		/* genExprSets() is destructive, make copy*/
	require(p!=NULL, "can't make context tree for NULL pred tree");

#ifdef DBG_PRED
	fprintf(stderr, "enter genCombinedPredTreeContextOrig(%s,0x%x) with sets:\n", p->expr, p);
	s_fprT(stderr, p->scontext[1]);
	fprintf(stderr, "\n");
#endif
	if ( p->down == NULL )
	{
/***	if ( p->k>1 && p->tcontext!=NULL ) ***/
		if ( p->tcontext!=NULL )
		{
			_gen("(");
			genExprTree(p->tcontext, 1);
			_gen(")");
		}
/***	else if ( p->k==1 && set_deg(p->scontext[1])>0 ) ***/
		else if ( set_deg(p->scontext[1])>0 )
		{
			if ( ctx==NULL ) ctx = (set *)calloc(CLL_k+1, sizeof(set));
			require(ctx!=NULL, "ctx cannot allocate");
			ctx[0]=empty;
			ctx[1]=set_dup(p->scontext[1]);
			_gen("(");
			genExprSets(&(ctx[0]), p->k);
			_gen(")");
			set_free(ctx[1]);
		}
		else if ( p->expr==PRED_AND_LIST || p->expr==PRED_OR_LIST ) {
			fatal_internal("pred tree is orphan OR or AND list");
		}
		else {
            if (! HoistPredicateContext) {
              _gen(" 1 /* no context: prc is off */ ");
            } else {
              fatal_internal("pred tree context is empty");
            };
		}
		return;
	}

/* MR10 - make AND just like OR */

	if ( p->expr == PRED_AND_LIST )
	{
        Predicate *list = p->down;
        for (; list!=NULL; list=list->right)
        {
     	     genCombinedPredTreeContextOrig(list);
       		 if ( list->right!=NULL ) _gen("|| /* MR10 was wrong */ ");
        };
		return;
	}

	if ( p->expr == PRED_OR_LIST )
	{
        Predicate *list = p->down;
        for (; list!=NULL; list=list->right)
        {
           genCombinedPredTreeContextOrig(list);
           if ( list->right!=NULL ) _gen("||");
        };
        return;
     };

	fatal("pred tree is really wacked");
}

/* [genCombinedPredTreeContext] */

void
#ifdef __USE_PROTOS
genCombinedPredTreeContext( Predicate *p )
#else
genCombinedPredTreeContext( p )
Predicate *p;
#endif
{
  Tree  *t;
  int   predDepth=0;

  if (0 && ! MR_usingPredNames && ! MRhoisting) {
    genCombinedPredTreeContextOrig(p);
  } else {
/* MR13 */    MR_pred_depth(p,&predDepth);
/* MR13 */    if (predDepth == 1) {
/* MR13 */
/* MR13 */      set   scontext[2];
/* MR13 */      scontext[0]=empty;
/* MR13 */      scontext[1]=MR_compute_pred_set(p);
/* MR13 */      if (set_nil(scontext[1])) {
/* MR13 */        _gen(" 1 /* MR12 no context (-prc off) */ ");
/* MR13 */      } else {
/* MR13 */        _gen("(");
/* MR13 */        genExprSets(&scontext[0], 1);
/* MR13 */        set_free(scontext[1]);
/* MR13 */        _gen(")");
/* MR13 */      };

    } else {
      t=MR_compute_pred_tree_context(p);
      if (t == NULL) {
        _gen(" 1 /* MR12 no context (-prc off) */ ");
      } else {
        _gen("(");
        genExprTree(t, 1);
        Tfree(t);   /* MR10 */
        _gen(")");
      };
    };
  };
}

/* [genPredTreeGate] */

void
#ifdef __USE_PROTOS
genPredTreeGate( Predicate *p, int in_and_expr )
#else
genPredTreeGate( p, in_and_expr )
Predicate *p;
int in_and_expr;
#endif
{
	if ( in_and_expr )
	{
		_gen("!(");
		genCombinedPredTreeContext(p);
		_gen(")||");
		if ( p->down!=NULL ) _gen("\n");
	}
	else
	{
		_gen("(");
		genCombinedPredTreeContext(p);
		_gen(")&&");
		if ( p->down!=NULL ) _gen("\n");
	}
}

#ifdef __USE_PROTOS
void genPredEntry(Predicate *p,int outer)
#else
void genPredEntry(p,outer)
  Predicate     *p;
  int           outer;
#endif
{
    int         inverted=0;
    Predicate   *q;
    int         localOuter=outer;
    int         needRP=0;

    if (p == NULL) return;

    if (p->predEntry != NULL && p->predEntry->predLiteral != NULL) {
      if (p->inverted != p->predEntry->pred->inverted) {
        _gen("! /* inverted pred */ (");
        needRP=1;
      } else {
        if (!localOuter) _gen("(");
        needRP=1;
      };
      dumpAction(p->predEntry->predLiteral,output,0,p->source->file,p->source->line,0);
      if (needRP) _gen(")");
      return;
    };

    inverted=p->inverted;

    if (inverted) {
      _gen(" ! /* inverted pred */ (");
      localOuter=1;
    };

    if (p->expr == PRED_OR_LIST) {
      if (!localOuter) _gen("(");
      for (q=p->down; q != NULL ; q=q->right) {
        genPredEntry(q,0);
        if (q->right != NULL) _gen(" || ");
      };
      if (!localOuter) _gen(")");
    } else if (p->expr == PRED_AND_LIST) {
      if (!localOuter) _gen("(");
      for (q=p->down; q != NULL ; q=q->right) {
        genPredEntry(q,0);
        if (q->right != NULL) _gen(" && ");
      };
      if (!localOuter) _gen(")");
    } else {
      if (!localOuter) _gen("(");
      require (p->source != NULL,"predEntry->source == NULL");
      require (p->source->inverted == 0,"dumpPredEntry p->source->inverted != 0");
      dumpAction(p->source->action,output,0,p->source->file,p->source->line,0);
      if (!localOuter) _gen(")");
    };

    if (inverted) {
        _gen(")");
    }
}

void
#ifdef __USE_PROTOS
dumpPredAction(ActionNode *anode,
                    char *s,FILE *output,int tabs,int file,int line,int final_newline)
#else
dumpPredAction(anode,
                    s,output,tabs,file,line,final_newline)

    ActionNode  *anode;
    char        *s;
    FILE        *output;
    int         tabs;
    int         file;
    int         line;
    int         final_newline;
#endif
{
    PredEntry   *predEntry=anode->predEntry;
    int         inverted=anode->inverted;
    Predicate   *workPred;

    if (predEntry == NULL) {

      /* inline predicate literal */

      require(inverted == 0,"dumpPredAction action->inverted");
  	  dumpAction(s,output,tabs,file,line,final_newline);

    } else {

      /* a reference to a predicate - possibly with an inverted source */

      if (predEntry->predLiteral != NULL) {
        if (inverted) _gen("! /* inverted pred */ (");
        dumpAction(predEntry->predLiteral,output,0,anode->file,anode->line,0);
        if (inverted) _gen(")");
      } else {
        workPred=predicate_dup(predEntry->pred);
        if (inverted) workPred->inverted=!workPred->inverted;
        genPredEntry(workPred,1);
        predicate_free(workPred);
      };
    };
}

/* [genPred] */

void
#ifdef __USE_PROTOS
genPred(Predicate *p, Node *j,int suppress_sva)
#else
genPred(p,j,suppress_sva)
    Predicate   *p;
    Node        *j;
    int         suppress_sva;
#endif
{
	if ( FoundException && !suppress_sva) {_gen("(_sva=(");}    /* MR11 suppress_sva */
	else {_gen("(");}
	if ( GenLineInfo && j->file != -1 ) _gen("\n");
    if (p->source != NULL && p->source->ampersandPred != NULL) {
      if (p->source->ampersandPred->k == 1) {

            set     ctx[2];

			ctx[0]=empty;
			ctx[1]=set_dup(p->source->ampersandPred->scontext[1]);

			_gen("(");
			genExprSets(&(ctx[0]), p->k);
			_gen(") && ");
			set_free(ctx[1]);
      } else {
        _gen("( ");
        genExprTree(p->source->ampersandPred->tcontext,1);
		_gen(" ) && ");
      };
    };

    dumpPredAction((ActionNode *)p->source,
                p->expr, output, 0, -1 /*indicates no line info*/, j->line, 0);

	if ( FoundException && !suppress_sva)   /* MR11 suppress_sva */
         {_gen("),_sva)");}    /* MR10 - get red of "meant ==" messages */
	else {_gen(")");}
}

void
#ifdef __USE_PROTOS
MR_distinctORcontextOpt(Predicate *p,Node *j,int in_and_expr)
#else
MR_distinctORcontextOpt(p,j,in_and_expr)
    Predicate   *p;
    Node        *j;
    int         in_and_expr;
#endif
{
    Predicate   *q;

    _gen(" /* MR10 Distinct OR context optimization */ \n");

    if (in_and_expr) {
      gen("zzpf=0,\n");
      for (q=p->down; q != NULL; q=q->right) {
        gen("(  ");
        genCombinedPredTreeContext(q);
        _gen(" && (zzpf=1, ");
        genPred(q,j,0);
        _gen("  )) ||\n");
      };
      gen("!zzpf)");
    } else {
      require (0,
            "MR_distinctORcontextOpt: can't get here when using MR_predSimplify");
#if 0
**      for (q=p->down; q != NULL; q=q->right) {
**        gen("(  ");
**        genCombinedPredTreeContext(q);
**        _gen(" && ");
**        genPred(q,j);
**        if (q->right != NULL) {
**          _gen("  ) ||\n");
**        };
**      };
**      gen(")");
#endif
   };
}

void
#ifdef __USE_PROTOS
genPredTreeOrig( Predicate *p, Node *j, int in_and_expr )
#else
genPredTreeOrig( p, j, in_and_expr )
Predicate *p;
Node *j;
int in_and_expr;
#endif
{

/* MR10 */  int     allHaveContext=1;
/* MR10 */  int     noneHaveContext=1;

/* MR10 */  MR_predContextPresent(p,&allHaveContext,&noneHaveContext);

	if ( ! noneHaveContext )                  /* MR10 context guards ignored when -prc off */
	{
		_gen("(");
		genPredTreeGate(p, in_and_expr);
	}

	/* if leaf node, just gen predicate */

	if ( p->down==NULL )
	{
		genPred(p,j,0);
		if ( ! noneHaveContext ) _gen(")");   /* MR10 context guards ignored when -prc off */
		return;
	}

	/* if AND list, do both preds (only two possible) */
	if ( p->expr == PRED_AND_LIST )
	{
#if 0
**		_gen("(");
**		genPredTreeOrig(p->down, j, 1);
**		_gen("&&");
**		genPredTreeOrig(p->down->right, j, 1);
**		_gen(")");
**		if ( ! noneHaveContext ) _gen(")");    /* MR10 context guards ignored when -prc off */
**		return;
#endif
        /* MR11 - make it work with AND with more than two children - like OR */

		Predicate *list;
		_gen("(");
		list = p->down;
		for (; list!=NULL; list=list->right)
		{
			genPredTreeOrig(list, j, 1);
			if ( list->right!=NULL ) _gen("&&");
		}
		_gen(")");
		if ( ! noneHaveContext ) _gen(")");    /* MR10 context guards ignored when -prc off */
		return;
    };

	if ( p->expr == PRED_OR_LIST )
	{
		Predicate *list;
		_gen("(");
		list = p->down;
		for (; list!=NULL; list=list->right)
		{
			genPredTreeOrig(list, j, 0);
			if ( list->right!=NULL ) _gen("||");
		}
		_gen(")");
		if ( ! noneHaveContext ) _gen(")");    /* MR10 context guards ignored when -prc off */
		return;
	}

	fatal_internal("genPredTreeOrig: predicate tree is wacked");
}

#if 0
**   Predicate member dummyPredDepth is no longer used in MR10
**     but we might need it again in the future
**
**   if (MRhoisting) {
**     if ( !noneHaveContext &&
**          ! in_and_expr &&
**          p->source != NULL &&
**          p->source->dummyPredicateDepth > 0 &&
**          p->down == NULL) {
** 		_gen("(");
** 		genCombinedPredTreeContext(p);
** 		_gen("  )\n");
** 		return;
**     };
**   };
#endif

/* [genPredTree] */

/* in_and_expr

   what to do if the context is wrong
   what to do if the context is correct but the predicate is false

   remember: if the context is wrong it's the same as if the
             predicate is true as far as enabling an alternative

        Consider (AND p q r)

        if in an ... && ... expression then you don't want
        the entire predicate chain to fail just because the
        context for one component is wrong: so return true

        Consider (OR p q r)

        if in an ... || ... expression then you don't want
        the entire predicate chain to succeed just because
        the context for one component is correct when the
        corresponding test is false: so return false when
        the context is correct but the test is false.
*/

void
#ifdef __USE_PROTOS
genPredTree( Predicate *p, Node *j, int in_and_expr, int suppress_sva )
#else
genPredTree( p, j, in_and_expr, suppress_sva)
  Predicate     *p;
  Node          *j;
  int           in_and_expr;
  int           suppress_sva;
#endif
{

    int         allHaveContext=1;
    int         noneHaveContext=1;
    Tree        *groupTree;
    Tree        *oneTree;
    Predicate   *q;
    int         identicalORcontextOptimization=0;
    int         identicalANDcontextOptimization=0;

    if (0 && !MR_usingPredNames && !MRhoisting) {
      genPredTreeOrig(p,j,in_and_expr);
      return;
    };

    MR_predContextPresent(p,&allHaveContext,&noneHaveContext);

	if ( ! noneHaveContext ) {                 /* MR10 context guards ignored when -prc off */

      _gen("(");

            /* MR10 optimize OR predicates which are all leaves */

      if (p->expr == PRED_OR_LIST && MR_allPredLeaves(p->down)) {
        groupTree=MR_compute_pred_tree_context(p);
        for (q=p->down ; q != NULL ; q=q->right) {
          oneTree=MR_compute_pred_tree_context(q);
          if (! MR_tree_equ(groupTree,oneTree)) {
            Tfree(oneTree);
            break;
          };
          Tfree(oneTree);
        };
        Tfree(groupTree);
        if (q == NULL) {
          _gen("/* MR10 individual OR gates suppressed when all predicates are leaves");
          _gen(" with identical context */\n");
          genPredTreeGate(p,in_and_expr);   /* use the parent's in_and_expr for this gate */
          identicalORcontextOptimization=1;
        } else {
          MR_distinctORcontextOpt(p,j,in_and_expr);
          return;
        };
      } else if (p->expr == PRED_AND_LIST && MR_allPredLeaves(p->down)) {

            /* MR12 optimize AND predicates which are all leaves */

        groupTree=MR_compute_pred_tree_context(p);
        for (q=p->down ; q != NULL ; q=q->right) {
          oneTree=MR_compute_pred_tree_context(q);
          if (! MR_tree_equ(groupTree,oneTree)) {
            Tfree(oneTree);
            break;
          };
          Tfree(oneTree);
        };
        Tfree(groupTree);
        if (q == NULL) {
          _gen("/* MR12 individual AND gates suppressed when all predicates are leaves");
          _gen(" with identical context */\n");
          genPredTreeGate(p,in_and_expr);   /* use the parent's in_and_expr for this gate */
          identicalANDcontextOptimization=1;
        } else {
          genPredTreeGate(p, in_and_expr);
        };
      } else {
  	    genPredTreeGate(p, in_and_expr);
      };
	}

	/* if leaf node, just gen predicate */

	if ( p->down==NULL )
	{
		genPred(p,j,suppress_sva);
		if ( ! noneHaveContext ) _gen(")");   /* MR10 context guards ignored when -prc off */
		return;
	}

	/* if AND list, do both preds (only two possible) */
    /* MR10    not any more ! */

	if ( p->expr == PRED_AND_LIST )
	{
		Predicate *list;
		_gen("(");
		list = p->down;
        for (; list != NULL; list=list->right) {
          if (identicalANDcontextOptimization) {
            genPred(list, j,suppress_sva);
          } else {
	   	    genPredTree(list, j, 1, suppress_sva);  /* in and context */
          };
          if ( list->right!=NULL ) _gen("&&");
        };
		_gen(")");
		if ( ! noneHaveContext ) _gen(")");    /* MR10 context guards ignored when -prc off */
		return;
	}

	if ( p->expr == PRED_OR_LIST )
	{
		Predicate *list;
		_gen("(");
		list = p->down;
		for (; list!=NULL; list=list->right)
		{
            if (identicalORcontextOptimization) {
	          genPred(list, j,suppress_sva);
            } else {
	   	      genPredTree(list, j, 0, suppress_sva);
            };
			if ( list->right!=NULL ) _gen("||");
		}
		_gen(")");
		if ( ! noneHaveContext ) _gen(")");    /* MR10 context guards ignored when -prc off */
		return;
	}

	fatal_internal("predicate tree is wacked");
}

/* [genPredTreeMainXX] */

Predicate *     /* MR10 */
#ifdef __USE_PROTOS
genPredTreeMainXX( Predicate *p, Node *j ,int in_and_expr)
#else
genPredTreeMainXX( p, j ,in_and_expr)
    Predicate   *p;
    Node        *j;
    int         in_and_expr;
#endif
{

    int     allHaveContext=1;
    int     noneHaveContext=1;

#if 0
    fprintf(stderr,"Pred before\n");
    dumppred(p);
    fprintf(stderr,"\n");
    fprintf(stderr,"Pred after\n");
    dumppred(p);
    fprintf(stderr,"\n");
#endif

    p=MR_predSimplifyALL(p);    /* MR10 */

    require (MR_predicate_context_completed(p),"predicate context is not complete");

    MR_cleanup_pred_trees(p);   /* MR10 */

    MR_predContextPresent(p,&allHaveContext,&noneHaveContext);
    if (!noneHaveContext & !allHaveContext) {
      warnFL("predicate contains elements both with and without context",
                FileStr[j->file],j->line);
    };

    if (InfoP) {
       _gen("\n#if 0\n\n");
       MR_dumpPred(p,1);
       _gen("#endif\n");
    };
	genPredTree(p,j,in_and_expr,0);
    return p;
}

Predicate *     /* MR10 */
#ifdef __USE_PROTOS
genPredTreeMain( Predicate *p, Node *j)
#else
genPredTreeMain( p, j)
    Predicate   *p;
    Node        *j;
#endif
{
  return genPredTreeMainXX(p,j,1);
}

static void
#ifdef __USE_PROTOS
genExprTreeOriginal( Tree *t, int k )
#else
genExprTreeOriginal( t, k )
Tree *t;
int k;
#endif
{
	require(t!=NULL, "genExprTreeOriginal: NULL tree");
	
	if ( t->token == ALT )
	{
		_gen("("); genExprTreeOriginal(t->down, k); _gen(")");
		if ( t->right!=NULL )
		{
			_gen("||");
			on1line++;
			if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
			_gen("("); genExprTreeOriginal(t->right, k); _gen(")");
		}
		return;
	}
	if ( t->down!=NULL ) _gen("(");
	_gen1("LA(%d)==",k);
	if ( TokenString(t->token) == NULL ) _gen1("%d", t->token)
	else _gen1("%s", TokenString(t->token));
	if ( t->down!=NULL )
	{
		_gen("&&");
		on1line++;
		if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
		_gen("("); genExprTreeOriginal(t->down, k+1); _gen(")");
	}
	if ( t->down!=NULL ) _gen(")");
	if ( t->right!=NULL )
	{
		_gen("||");
		on1line++;
		if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
		_gen("("); genExprTreeOriginal(t->right, k); _gen(")");
	}
}

#ifdef __USE_PROTOS
static void MR_LAtokenString(int k,int token)
#else
static void MR_LAtokenString(k,token)
  int   k;
  int   token;
#endif
{
    char    *ts;

    ts=TokenString(token);
    if (ts == NULL) {
      _gen2(" LA(%d)==%d",k,token);
    } else {
      _gen2(" LA(%d)==%s",k,ts);
    };
}


#ifdef __USE_PROTOS
static int MR_countLeaves(Tree *t)
#else
static int MR_countLeaves(t)
  Tree  *t;
#endif
{
  if (t == NULL) return 0;
  if (t->token == ALT) {
    return MR_countLeaves(t->down)+MR_countLeaves(t->right);
  } else {
    return 1+MR_countLeaves(t->down)+MR_countLeaves(t->right);
  };
}

#ifdef __USE_PROTOS
static void MR_genOneLine(Tree *tree,int k)
#else
static void MR_genOneLine(tree,k)
  Tree      *tree;
  int       k;
#endif
{
    if (tree == NULL) return;
    if (tree->token == ALT) {
       MR_genOneLine(tree->down,k);
    } else {
       MR_LAtokenString(k,tree->token);
       if (tree->down != NULL &&
           tree->down->right == NULL) {
          _gen(" &&");
          MR_genOneLine(tree->down,k+1);
       } else if (tree->down != NULL) {
         _gen(" && (");
         MR_genOneLine(tree->down,k+1);
         _gen(")");
       };
    };
    if (tree->right != NULL) {
      _gen(" ||");
      MR_genOneLine(tree->right,k);
    };
}

static int across;
static int depth;
static int lastkonline;

#ifdef __USE_PROTOS
static void MR_genMultiLine(Tree *tree,int k)
#else
static void MR_genMultiLine(tree,k)
  Tree  *tree;
  int   k;
#endif
{
    int     i;

    if (tree == NULL) return;
    if (tree->token == ALT) {
      MR_genMultiLine(tree,k);
    } else {
      MR_LAtokenString(k,tree->token);
      lastkonline=k;
      across++;
      if (tree->down != NULL && tree->down->right == NULL) {
        if (across > 3) {
          _gen("\n");
          across=0;
          lastkonline=0;
          for (i=0 ; i < depth+k ; i++) _gen("   ");
          _gen("&&");
        } else {
          _gen(" &&");
        };
        MR_genMultiLine(tree->down,k+1);
      } else if (tree->down != NULL) {
        _gen("\n");
        lastkonline=0;
        across=0;
        for (i=0 ; i < depth+k ; i++) _gen("   ");
        _gen("&& (");
        MR_genMultiLine(tree->down,k+1);
        _gen(")");
      };
    };
    if (tree->right != NULL) {
      if (k < lastkonline) {
        _gen("\n");
        across=0;
        lastkonline=0;
        for (i=0; i < depth+k-1 ; i++) _gen("   ");
        _gen("||");
      } else if (across > 3 ) {
        _gen("\n");
        across=0;
        lastkonline=0;
        for (i=0; i < depth+k ; i++) _gen("   ");
        _gen("||");
      } else {
        _gen(" ||");
      };
      MR_genMultiLine(tree->right,k);
    };
}

#ifdef __USE_PROTOS
static void genExprTree(Tree *tree,int k)
#else
static void genExprTree(tree,k)
  Tree  *tree;
  int   k;
#endif
{
    int     count;

#if 0
    /* MR20 THM This was probably an error.
            The routine should probably reference that static 
            "across" and this declaration hides it.
    */

    int     across;
#endif
  
    require (tree != NULL,"genExprTree: tree is NULL");
    require (k > 0,"genExprTree: k <= 0");

    if (0 && !MRhoisting) {   /* MR11 make new version standard */
      genExprTreeOriginal(tree,k);
    } else {
      count=MR_countLeaves(tree);
      if (count < 5) {
        MR_genOneLine(tree,k);
      } else {
        _gen("\n");
        across=0;
        depth=0;
        lastkonline=0;
        MR_genMultiLine(tree,k);
        _gen("\n");
      };
    };
}


/*
 * Generate LL(k) type expressions of the form:
 *
 *		 (LA(1) == T1 || LA(1) == T2 || ... || LA(1) == Tn) &&
 *		 (LA(2) == T1 || LA(2) == T2 || ... || LA(2) == Tn) &&
 *			.....
 *		 (LA(k) == T1 || LA(k) == T2 || ... || LA(k) == Tn)
 *
 * If GenExprSetsOpt generate:
 *
 *		(setwdi[LA(1)]&(1<<j)) && (setwdi[LA(2)]&(1<<j)) ...
 *
 * where n is set_deg(expr) and Ti is some random token and k is the last nonempty
 * set in fset <=CLL_k.
 * k=1..CLL_k where CLL_k >= 1.
 *
 * This routine is visible only to this file and cannot answer a TRANS message.
 *
 */

/*  [genExpr] */

static int
#ifdef __USE_PROTOS
genExpr( Junction *j )
#else
genExpr( j )
Junction *j;
#endif
{
	int max_k;

	/* if full LL(k) is sufficient, then don't use approximate (-ck) lookahead
	 * from CLL_k..LL_k
	 */
	{
		int limit;
		if ( j->ftree!=NULL ) limit = LL_k;
		else limit = CLL_k;
		max_k = genExprSets(j->fset, limit);
	}

	/* Do tests for real tuples from other productions that conflict with
	 * artificial tuples generated by compression (using sets of tokens
	 * rather than k-trees).
	 */
	if ( j->ftree != NULL )
	{
		_gen(" && !("); genExprTree(j->ftree, 1); _gen(")");
	}

	if ( ParseWithPredicates && j->predicate!=NULL )
	{
		Predicate *p = j->predicate;
		warn_about_using_gk_option();
		_gen("&&");
		j->predicate=genPredTreeMain(p, (Node *)j);     /* MR10 */
	}

	return max_k;
}

static int
#ifdef __USE_PROTOS
genExprSets( set *fset, int limit )
#else
genExprSets( fset, limit )
set *fset;
int limit;
#endif
{
	int k = 1;
	int max_k = 0;
	unsigned *e, *g, firstTime=1;

    if (set_nil(fset[1])) {
      _gen(" 0 /* MR13 empty set expression  - undefined rule ? infinite left recursion ? */ ");
      MR_BadExprSets++;
    };

	if ( GenExprSetsOpt )
	{
		while ( k <= limit && !set_nil(fset[k]) )   /* MR11 */
		{
			if ( set_deg(fset[k])==1 )	/* too simple for a set? */
			{
				int e;
				_gen1("(LA(%d)==",k);
				e = set_int(fset[k]);
				if ( TokenString(e) == NULL ) _gen1("%d)", e)
				else _gen1("%s)", TokenString(e));
			}
			else
			{
				NewSet();
				FillSet( fset[k] );
				_gen3("(setwd%d[LA(%d)]&0x%x)", wordnum, k, 1<<setnum);
			}
			if ( k>max_k ) max_k = k;
			if ( k == CLL_k ) break;
			k++;
			if ( k<=limit && !set_nil(fset[k]) ) _gen(" && ");  /* MR11 */
			on1line++;
			if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
		}
		return max_k;
	}

	while ( k<= limit &&  !set_nil(fset[k]) )       /* MR11 */
	{
		if ( (e=g=set_pdq(fset[k])) == NULL ) fatal_internal("genExpr: cannot allocate IF expr pdq set");
		for (; *e!=nil; e++)
		{
			if ( !firstTime ) _gen(" || ") else { _gen("("); firstTime = 0; }
			on1line++;
			if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
			_gen1("LA(%d)==",k);
			if ( TokenString(*e) == NULL ) _gen1("%d", *e)
			else _gen1("%s", TokenString(*e));
		}
		free( (char *)g );
		_gen(")");
		if ( k>max_k ) max_k = k;
		if ( k == CLL_k ) break;
		k++;
		if ( k <= limit && !set_nil(fset[k]) ) { firstTime=1; _gen(" && "); }   /* MR11 */
		on1line++;
		if ( on1line > NumExprPerLine ) { on1line=0; _gen("\n"); }
	}
	return max_k;
}

/*
 * Generate code for any type of block.  If the last alternative in the block is
 * empty (not even an action) don't bother doing it.  This permits us to handle
 * optional and loop blocks as well.
 *
 * Only do this block, return after completing the block.
 * This routine is visible only to this file and cannot answer a TRANS message.
 */
static set
#ifdef __USE_PROTOS
genBlk( Junction *q, int jtype, int *max_k, int *need_right_curly, int * lastAltEmpty /* MR23 */)
#else
genBlk( q, jtype, max_k, need_right_curly, lastAltEmpty /* MR23 */)
Junction *q;
int jtype;
int *max_k;
int *need_right_curly;
int *lastAltEmpty; /* MR23 */
#endif
{
	set f;
	Junction *alt;
	int a_guess_in_block = 0;
	require(q!=NULL,				"genBlk: invalid node");
	require(q->ntype == nJunction,	"genBlk: not junction");
	*need_right_curly=0;
	*lastAltEmpty = 0;		/* MR23 */
	if ( q->p2 == NULL )	/* only one alternative?  Then don't need if */
	{	
		if (first_item_is_guess_block((Junction *)q->p1)!=NULL )
		{
            if (jtype != aLoopBlk && jtype != aOptBlk && jtype != aPlusBlk) {
  			  warnFL("(...)? as only alternative of block is unnecessary", FileStr[q->file], q->line);
            };
   	   	    gen("zzGUESS\n");	/* guess anyway to make output code consistent */
/* MR10 disable */  /**** gen("if ( !zzrv )\n"); ****/
/* MR10 */          gen("if ( !zzrv ) {\n"); tabs++; (*need_right_curly)++;
        };
		TRANS(q->p1);
		return empty;		/* no decision to be made-->no error set */
	}

	f = First(q, 1, jtype, max_k);
	for (alt=q; alt != NULL; alt= (Junction *) alt->p2 )
	{
		if ( alt->p2 == NULL )					/* chk for empty alt */
		{	
			Node *p = alt->p1;
			if ( p->ntype == nJunction )
			{
				/* we have empty alt */
/* MR23
   There is a conflict between giving good error information for non-exceptions
   and making life easy for those using parser exception handling.  Consider:

         r: { A } b;
		 b: B;
		 
		   with input "C"

   Before MR21 the error message would be "expecting B - found C".  After MR21
   the error message would be "expcect A, B - found C".  This was good, but it
   caused problems for those using parser exceptions because the reference to
   B was generated inside the {...} where B really wasn't part of the block.

   In MR23 this has been changed for the case where exceptions are in use to
   not generate the extra check in the tail of the {A} block.
*/


/* MR23 */	if (isEmptyAlt( ((Junction *)p)->p1, (Node *)q->end)) {
/* MR23 */      *lastAltEmpty = 1;
/* MR23 */		if (FoundException) {
/* MR23 */			/* code to restore state if a prev alt didn't follow guess */
/* MR23 */			if ( a_guess_in_block && jtype != aPlusBlk) {
/* MR23 */				gen("if ( !zzrv ) zzGUESS_DONE; /* MR28 */\n");
/* MR23 */			}
/* MR23 */			break;
/* MR23 */		};
/* MR28 */      if (jtype == aPlusBlk) {
/* MR28 */          break;
/* MR28 */      }
/* MR23 */	}
		}
	} /* end of for loop on alt */

/* MR10 */        if (alt->p2 == NULL &&
/* MR10 */               ( q->jtype == aSubBlk || q->jtype == RuleBlk) ) {
/* MR10 */          if (first_item_is_guess_block(alt)) {
/* MR10 */               warnFL("(...)? as last alternative of block is unnecessary",
/* MR10 */                                FileStr[alt->file],alt->line);
/* MR10 */          };
/* MR10 */        };

		if ( alt != q ) gen("else ")
		else
		{
			if ( DemandLookahead ) {
				if ( !GenCC ) {gen1("LOOK(%d);\n", *max_k);}
				else gen1("look(%d);\n", *max_k);
			}
		}

		if ( alt!=q )
		{
			_gen("{\n");
			tabs++;
			(*need_right_curly)++;
			/* code to restore state if a prev alt didn't follow guess */
			if ( a_guess_in_block )
				gen("if ( !zzrv ) zzGUESS_DONE;\n");
		}
		if ( first_item_is_guess_block((Junction *)alt->p1)!=NULL )
		{
			a_guess_in_block = 1;
			gen("zzGUESS\n");
		}
		gen("if ( ");
		if ( first_item_is_guess_block((Junction *)alt->p1)!=NULL ) _gen("!zzrv && ");
		genExpr(alt);
		_gen(" ) ");
		_gen("{\n");
		tabs++;
		TRANS(alt->p1);
		--tabs;
		gen("}\n");
/* MR10 */        if (alt->p2 == NULL) {
/* MR10 */          if (first_item_is_guess_block(alt)) {
/* MR10 */            gen("/* MR10 */ else {\n");
/* MR10 */            tabs++;
/* MR10 */  		  (*need_right_curly)++;
/* MR10 */  		  /* code to restore state if a prev alt didn't follow guess */
/* MR10 */            gen("/* MR10 */ if ( !zzrv ) zzGUESS_DONE;\n");
/* MR10 */            gen("/* MR10 */ if (0) {}     /* last alternative of block is guess block */\n");
/* MR10 */          };
/* MR10 */        };
	}
	return f;
}

static int
#ifdef __USE_PROTOS
has_guess_block_as_first_item( Junction *q )
#else
has_guess_block_as_first_item( q )
Junction *q;
#endif
{
	Junction *alt;

	for (alt=q; alt != NULL; alt= (Junction *) alt->p2 )
	{
		if ( first_item_is_guess_block((Junction *)alt->p1)!=NULL ) return 1;
	}
	return 0;
}

static int
#ifdef __USE_PROTOS
has_guess_block_as_last_item( Junction *q )
#else
has_guess_block_as_last_item( q )
Junction *q;
#endif
{
	Junction *alt;

    if (q == NULL) return 0;
	for (alt=q; alt->p2 != NULL && !( (Junction *) alt->p2)->ignore; alt= (Junction *) alt->p2 ) {};
    return first_item_is_guess_block( (Junction *) alt->p1) != NULL;
}

/* MR30 See description of first_item_is_guess_block for background */

Junction *
#ifdef __USE_PROTOS
first_item_is_guess_block_extra(Junction *q )
#else
first_item_is_guess_block_extra(q)
Junction *q;
#endif
{
	while ( q!=NULL &&
            (  ( q->ntype==nAction ) ||
               ( q->ntype==nJunction &&
                    (q->jtype==Generic || q->jtype == aLoopBlk) 
               )
            )
          )
	{
		if ( q->ntype==nJunction ) q = (Junction *)q->p1;
		else q = (Junction *) ((ActionNode *)q)->next;
	}

	if ( q==NULL ) return NULL;
	if ( q->ntype!=nJunction ) return NULL;
	if ( q->jtype!=aSubBlk ) return NULL;
	if ( !q->guess ) return NULL;

	return q;
}

/* return NULL if 1st item of alt is NOT (...)? block; else return ptr to aSubBlk node
 * of (...)?;  This function ignores actions and predicates.
 */

Junction *
#ifdef __USE_PROTOS
first_item_is_guess_block( Junction *q )
#else
first_item_is_guess_block( q )
Junction *q;
#endif
{
	Junction * qOriginal = q;	/* DEBUG */

    /* MR14  Couldn't find aSubBlock which was a guess block when it lay
             behind aLoopBlk.  The aLoopBlk only appear in conjunction with
             aLoopBegin, but the routine didn't know that.  I think.

       MR14a Added extra parentheses to clarify precedence

	   MR30  This appears to have been a mistake.  The First set was then
	         computed incorrectly for:

					r : ( (A)? B
					    | C
						)*
			 
			 The routine analysis_point was seeing the guess block when
			 it was still analyzing the loopBegin block.  As a consequence,
			 when it looked for the analysis_point it was processing the B, but
			 skipping over the C alternative altogether because it thought
			 it was looking at a guess block, not realizing there was a loop
			 block in front of the loopBegin.

             loopBegin  loopBlk  subBlk/guess  A  G  EB  G  B EB EB  EB  ER
			    |          |          |                     ^   ^
				|		   |                                |   |
                |          +-> G  C G ----------------------+   |
                |                                               |
				+--- G G G -------------------------------------+
    
			 Reported by Arpad Beszedes (beszedes@inf.u-szeged.hu).

		MR30  This is still more complicated.  This fix caused ambiguity messages
		to be reported for "( (A B)? )* A B" but not for "( (A B)? )+".  Why is
		there a difference when these are outwardly identical ?  It is because the
		start of a (...)* block is represented by two nodes: a loopBegin block
		followed by a loopBlock whereas the start of a (...)+ block is
		represented as a single node: a plusBlock.  So if first_item_is_guess_block
		is called when the current node is a loopBegin it starts with the
		loop block rather than the the sub block which follows the loop block.
		However, we can't just skip past the loop block because some routines
		depend on the old implementation.  So, we provide a new implementation
		which does skip the loopBlock.  However, which should be called when ?
		I'm not sure, but my guess is that first_item_is_guess_block_extra (the
		new one) should only be called for the ambiguity routines.

    */

	while ( q!=NULL &&
            (  ( q->ntype==nAction ) ||
               ( q->ntype==nJunction &&
                    (q->jtype==Generic /*** || q->jtype == aLoopBlk ***/ ) /*** MR30 Undo MR14 change ***/
               )
            )
          )
	{
		if ( q->ntype==nJunction ) q = (Junction *)q->p1;
		else q = (Junction *) ((ActionNode *)q)->next;
	}

	if ( q==NULL ) return NULL;
	if ( q->ntype!=nJunction ) return NULL;
	if ( q->jtype!=aSubBlk ) return NULL;
	if ( !q->guess ) return NULL;

	return q;
}

/* MR1				                 					    */
/* MR1  10-Apr-97 MR1 Routine to stringize failed semantic predicates msgs  */
/* MR1				                                                        */

#define STRINGIZEBUFSIZE 1024

static char stringizeBuf[STRINGIZEBUFSIZE];
char *
#ifdef __USE_PROTOS
stringize(char * s)
#else
stringize(s)
char *s;
#endif

{
  char		*p;
  char		*stop;

  p=stringizeBuf;
  stop=&stringizeBuf[1015];

  if (s != 0) {
    while (*s != 0) {
      if (p >= stop) {
	goto stringizeStop;
      } else if (*s == '\n') {
        *p++='\\';
        *p++='n';
        *p++='\\';
	*p++=*s++;
      } else if (*s == '\\') {
	*p++=*s;
	*p++=*s++;
      } else if (*s == '\"') {
        *p++='\\';
	*p++=*s++;
        while (*s != 0) {
          if (p >= stop) {
	     goto stringizeStop;
	  } else if (*s == '\n') {
	    *p++='\\';
	    *p++=*s++;
	  } else if (*s == '\\') {
	    *p++=*s++;
	    *p++=*s++;
	  } else if (*s == '\"') {
	    *p++='\\';
	    *p++=*s++;
	    break;
	  } else {
	    *p++=*s++;
          };
        };
      } else if (*s == '\'') {
	*p++=*s++;
        while (*s != 0) {
          if (p >= stop) {
	     goto stringizeStop;
	  } else if (*s == '\'') {
	    *p++=*s++;
	    break;
	  } else if (*s == '\\') {
	    *p++=*s++;
	    *p++=*s++;
	  } else if (*s == '\"') {
	    *p++='\\';
	    *p++=*s++;
	    break;
	  } else {
	    *p++=*s++;
          };
        };
      } else {
        *p++=*s++;
      };
    };
  };
  goto stringizeExit;
stringizeStop:
  *p++='.';        	
  *p++='.';        	
  *p++='.';        	
stringizeExit:
  *p=0;
  return stringizeBuf;
}

#ifdef __USE_PROTOS
int isNullAction(char *s)
#else
int isNullAction(s)
  char  *s;
#endif
{
  char  *p;
  for (p=s; *p != '\0' ; p++) {
    if (*p != ';' && *p !=' ') return 0;
  };
  return 1;
}
/* MR1									                                    */
/* MR1	End of Routine to stringize code for failed predicates msgs         */
/* MR1				                                                        */

/* Generate an action.  Don't if action is NULL which means that it was already
 * handled as an init action.
 */
void
#ifdef __USE_PROTOS
genAction( ActionNode *p )
#else
genAction( p )
ActionNode *p;
#endif
{
	require(p!=NULL,			"genAction: invalid node and/or rule");
	require(p->ntype==nAction,	"genAction: not action");

	if ( !p->done )  /* MR10 */ /* MR11 */
	{
		if ( p->is_predicate)
		{
			if ( p->guardpred != NULL )
			{
                Predicate *guardDup=predicate_dup(p->guardpred); /* MR10 */
                gen("if (!");
       			guardDup=genPredTreeMain(guardDup, (Node *)p);
                predicate_free(guardDup);
			}
/* MR10 */  else if (p->ampersandPred != NULL) {
/* MR10 */      gen("if (!");
/* MR10 */      p->ampersandPred=genPredTreeMain(p->ampersandPred, (Node *)p);
/* MR10 */  }
			else
			{
				gen("if (!(");
				/* make sure that '#line n' is on front of line */
				if ( GenLineInfo && p->file != -1 ) _gen("\n");
				dumpPredAction(p,p->action, output, 0, p->file, p->line, 0);
				_gen(")");
			}

/* MR23 Change failed predicate macro to have three arguments:

        macro arg 1: The stringized predicate itself
        macro arg 2: 0 => no user-defined error action
                     1 => user-defined error action
        macro arg 3: The user-defined error action

   This gives the user more control of the error action.
*/
			tabs++;
			gen3(") {zzfailed_pred(\"%s\",%s, { %s } );}\n",         /* MR23 */
					stringize(p->action),	                         /* MR23 */
                    (p->pred_fail == NULL ?                          /* MR23/MR27 */
                       	"0 /* report */" : "1 /* user action */"),   /* MR23/MR27 */
                    (p->pred_fail == NULL ?                          /* MR23 */
                        "0; /* no user action */" : p->pred_fail));  /* MR23 */
			tabs--;
		}
		else    /* not a predicate */
		{
            if (! isNullAction(p->action) && !p->noHoist) {
  	  		  if ( FoundGuessBlk ) {
				if ( GenCC ) {
                  gen("if ( !guessing ) {\n");
                } else {
				  gen("zzNON_GUESS_MODE {\n");
                };
              };
			  dumpActionPlus(p, p->action, output, tabs, p->file, p->line, 1); /* MR21 */
			  if ( FoundGuessBlk ) gen("}\n");
            };
		}
	}
	TRANS(p->next)
}

/*
 *		if invoking rule has !noAST pass zzSTR to rule ref and zzlink it in
 *		else pass addr of temp root ptr (&_ast) (don't zzlink it in).
 *
 *		if ! modifies rule-ref, then never link it in and never pass zzSTR.
 *		Always pass address of temp root ptr.
 */
void
#ifdef __USE_PROTOS
genRuleRef( RuleRefNode *p )
#else
genRuleRef( p )
RuleRefNode *p;
#endif
{
	Junction *q;
	char *handler_id = "";
	RuleEntry *r, *r2;
	char *parm = "", *exsig = "";

    int     genRuleRef_emittedGuessGuard=0;     /* MR10 */

	require(p!=NULL,			"genRuleRef: invalid node and/or rule");
	require(p->ntype==nRuleRef, "genRuleRef: not rule reference");
	
	if ( p->altstart!=NULL && p->altstart->exception_label!=NULL )
		handler_id = p->altstart->exception_label;

	r = (RuleEntry *) hash_get(Rname, p->text);
	if ( r == NULL )
	{
		warnFL( eMsg1("rule %s not defined",
					  p->text), FileStr[p->file], p->line );
		return;
	}

/* MR8 5-Aug-97     Reported by S.Bochnak@microtool.com.pl                  */
/*                  Don't do assign when no return values declared          */
/*                  Move definition of q up and use it to guard p->assign   */

	q = RulePtr[r->rulenum];	/* find definition of ref'd rule */  /* MR8 */

	r2 = (RuleEntry *) hash_get(Rname, p->rname);
	if ( r2 == NULL ) {warnNoFL("Rule hash table is screwed up beyond belief"); return;}

    OutLineInfo(output,p->line,FileStr[p->file]);

	if ( GenCC && GenAST ) {
		gen("_ast = NULL;\n");
	}

	if ( FoundGuessBlk && p->assign!=NULL && q->ret != NULL ) {      /* MR8 */
		if ( GenCC ) {
          gen("if ( !guessing ) {\n");
        } else {
          gen("zzNON_GUESS_MODE {\n");
        };
        tabs++;                                                      /* MR11 */
        genRuleRef_emittedGuessGuard=1;                              /* MR11 */
    };

	if ( FoundException ) exsig = "&_signal";

	tab();
	if ( GenAST )
	{
		if ( GenCC ) {
/****			if ( r2->noAST || p->astnode==ASTexclude )
****/
			{
/****				_gen("_ast = NULL;\n");
****/
				parm = "&_ast";
			}
/*** we always want to set just a pointer now, then set correct
pointer after

			else {
				_gen("_astp =
(_tail==NULL)?(&_sibling):(&(_tail->_right));\n");
				parm = "_astp";
			}
****/
		}
		else {
			if ( r2->noAST || p->astnode==ASTexclude )
			{
				_gen("_ast = NULL; ");
				parm = "&_ast";
			}
			else parm = "zzSTR";
		}
		if ( p->assign!=NULL && q->ret!=NULL )                       /* MR8 */
		{
			if ( !hasMultipleOperands(p->assign) ) {_gen1("%s = ",p->assign);} /* MR23 */
			else _gen1("{ struct _rv%d _trv; _trv = ", r->rulenum);
		}
		if ( FoundException ) {
			_gen5("%s%s(%s,&_signal%s%s); ",
				  RulePrefix,
				  p->text,
				  parm,
				  (p->parms!=NULL)?",":"",
				  (p->parms!=NULL)?p->parms:"");
			if ( p->ex_group!=NULL ) {
				_gen("\n");
				gen("if (_signal) {\n");
				tabs++;
				dumpException(p->ex_group, 0);
				tabs--;
				gen("}");
			}
			else {
				_gen1("if (_signal) goto %s_handler;", handler_id);
			}
		}
		else {
			_gen5("%s%s(%s%s%s);",
				  RulePrefix,
				  p->text,
				  parm,
				  (p->parms!=NULL)?",":"",
				  (p->parms!=NULL)?p->parms:"");
		}
		if ( GenCC && (r2->noAST || p->astnode==ASTexclude) )
		{
			/* rule has a ! or element does */
			/* still need to assign to #i so we can play with it */
			_gen("\n");
			gen2("_ast%d%d = (AST *)_ast;", BlkLevel-1, p->elnum);
		}
		else if ( !r2->noAST && p->astnode == ASTinclude )
		{
			/* rule doesn't have a ! and neither does element */
/* MR10 */  if (FoundGuessBlk && !genRuleRef_emittedGuessGuard) {
/* MR10 */    _gen("\n");
/* MR10 */    if (GenCC) gen ("if (!guessing) {    /* MR10 */")
/* MR10 */          else gen ("if (!zzguessing) {    /* MR10 */\n");
/* MR10 */    tabs++;
/* MR10 */  };
			if ( GenCC ) {
				_gen("\n");
				gen("if ( _tail==NULL ) _sibling = _ast; else _tail->setRight(_ast);\n");
				gen2("_ast%d%d = (AST *)_ast;\n", BlkLevel-1, p->elnum);
				tab();
			}
			else _gen(" ");
            if ( GenCC ) {
                _gen("ASTBase::"); }
                else _gen("zz");
			_gen("link(_root, &_sibling, &_tail);");

/* MR10 */  if (FoundGuessBlk && !genRuleRef_emittedGuessGuard) {     /* MR10 */
/* MR10 */    _gen("\n");
/* MR10 */    tabs--;
/* MR10 */    if (GenCC) gen ("};    /* MR10 */")
/* MR10 */          else gen ("};    /* MR10 */");
/* MR10 */  };
		}
	}
	else
	{
		if ( p->assign!=NULL && q->ret!=NULL )                       /* MR8 */
		{
			if ( !hasMultipleOperands(p->assign) ) {_gen1("%s = ",p->assign);} /* MR23 */
			else _gen1("{ struct _rv%d _trv; _trv = ", r->rulenum);
		}
		if ( FoundException ) {
			_gen4("%s%s(&_signal%s%s); ",
				  RulePrefix,
				  p->text,
				  (p->parms!=NULL)?",":"",
				  (p->parms!=NULL)?p->parms:"");
			if ( p->ex_group!=NULL ) {
				_gen("\n");
				gen("if (_signal) {\n");
				tabs++;
				dumpException(p->ex_group, 0);
				tabs--;
				gen("}");
			}
			else {
				_gen1("if (_signal) goto %s_handler;", handler_id);
			}
		}
		else {
			_gen3("%s%s(%s);",
				  RulePrefix,
				  p->text,
				  (p->parms!=NULL)?p->parms:"");
		}
		if ( p->assign!=NULL && q->ret!=NULL ) _gen("\n");           /* MR8 */
	}

	if ( p->assign!=NULL && q->ret!=NULL) {                          /* MR8 */
		if ( hasMultipleOperands(p->assign) )                        /* MR23 */
		{
			_gen("\n");
			dumpRetValAssign(p->assign, q->ret, p);                  /* MR30 */
			_gen("}");
		}
	}
	_gen("\n");

	/* Handle element labels now */
	if ( p->el_label!=NULL )
	{
		if ( GenAST )
		{
			if ( GenCC ) {
				gen3("%s_ast = _ast%d%d;\n", p->el_label, BlkLevel-1, p->elnum);
			}
			else {gen1("%s_ast = zzastCur;\n", p->el_label);}
		}
       	else if (!GenCC ) {
			gen1("%s = zzaCur;\n", p->el_label);
        }
	}

	if ( FoundGuessBlk && p->assign!=NULL && q->ret!=NULL ) {       /* MR8 */
		/* in guessing mode, don't branch to handler upon error */
        tabs--;                                                     /* MR11 */
		gen("} else {\n");
        tabs++;                                                     /* MR11 */
		if ( FoundException ) {
			gen6("%s%s(%s%s&_signal%s%s);\n",
				 RulePrefix,
				 p->text,
				 parm,
                 (*parm!='\0')?",":"",
                 (p->parms!=NULL)?",":"",
				 (p->parms!=NULL)?p->parms:"");
		}
		else {
			gen5("%s%s(%s%s%s);\n",
				 RulePrefix,
				 p->text,
				 parm,
				 (p->parms!=NULL && *parm!='\0')?",":"",
				 (p->parms!=NULL)?p->parms:"");
		}
        tabs--;                                                     /* MR11 */
		gen("}\n");
	}
	TRANS(p->next)
}

/*
 * Generate code to match a token.
 *
 * Getting the next token is tricky.  We want to ensure that any action
 * following a token is executed before the next GetToken();
 */
void
#ifdef __USE_PROTOS
genToken( TokNode *p )
#else
genToken( p )
TokNode *p;
#endif
{
	RuleEntry *r;
	char *handler_id = "";
	ActionNode *a;
	char *set_name;
	char *set_nameErrSet;
	int complement;
	int ast_label_in_action = 0;	/* MR27 */
	int pushedCmodeAST = 0;			/* MR27 */

	require(p!=NULL,			"genToken: invalid node and/or rule");
	require(p->ntype==nToken,	"genToken: not token");
	if ( p->altstart!=NULL && p->altstart->exception_label!=NULL )
		handler_id = p->altstart->exception_label;

	r = (RuleEntry *) hash_get(Rname, p->rname);
	if ( r == NULL ) {warnNoFL("Rule hash table is screwed up beyond belief"); return;}

/*
 * MR27 Has the element label been referenced as an AST (with the # operator) ?
 *      If so, then we'll want to build the AST even though the user has used
 *      the ! operator.
 */
/* MR27 */	if (GenAST && p->el_label != NULL) {
/* MR27 */		ast_label_in_action = list_search_cstring(r->ast_labels_in_actions,
/* MR27 */		                                          p->el_label);
/* MR27 */	}
	
    OutLineInfo(output,p->line,FileStr[p->file]);

	if ( !set_nil(p->tset) )	/* implies '.', ~Tok, or tokenclass */
	{
		unsigned e;
		unsigned eErrSet = 0;
		set b;
		set bErrSet;					/* MR23 */
		b = set_dup(p->tset);
		bErrSet = set_dup(p->tset);	    /* MR23 */
		complement = p->complement; /* MR23 */
		if ( p->tclass!=NULL  && complement == 0 /* MR23 */) { /* token class not complemented*/
			static char buf[MaxRuleName+20];	    /* MR23 */
			static char bufErrSet[MaxRuleName+20];	/* MR23 */
			if ( p->tclass->dumped ) {
				e = p->tclass->setnum;
				eErrSet = p->tclass->setnumErrSet;
			}
			else {
				e = DefErrSet(&b, 0, TokenString(p->token));
				eErrSet = DefErrSetWithSuffix(0, &bErrSet, 1, TokenString(p->token), "_errset");
				p->tclass->dumped = 1;	/* indicate set has been created */
				p->tclass->setnum = e;
				p->tclass->setnumErrSet = eErrSet;					/* MR23 */
			}
			sprintf(buf, "%s_set", TokenString(p->token));
			sprintf(bufErrSet, "%s_errset", TokenString(p->token));	/* MR23 */
			set_name = buf;
			set_nameErrSet = bufErrSet;								/* MR23 */
		}

		/* MR23 - Forgot about the case of ~TOKCLASS. */

		else if ( p->tclass!=NULL  && complement != 0 /* MR23 */)
		{
			static char buf[MaxRuleName+20];	    /* MR23 */
			static char bufErrSet[MaxRuleName+20];	/* MR23 */
			if ( p->tclass->dumpedComplement ) {
				e = p->tclass->setnumComplement;
				eErrSet = p->tclass->setnumErrSetComplement;
			}
			else {
				e = DefErrSetWithSuffix(0, &b, 0, TokenString(p->token), "_setbar");
				eErrSet = DefErrSetWithSuffix(0, &bErrSet, 1, TokenString(p->token), "_errsetbar");
				p->tclass->dumpedComplement = 1;	/* indicate set has been created */
				p->tclass->setnumComplement = e;
				p->tclass->setnumErrSetComplement = eErrSet;					/* MR23 */
			}
			sprintf(buf, "%s_setbar", TokenString(p->token));
			sprintf(bufErrSet, "%s_errsetbar", TokenString(p->token));	/* MR23 */
			set_name = buf;
			set_nameErrSet = bufErrSet;								/* MR23 */
		}
		else {					/* wild card */
			static char buf[sizeof("zzerr")+10];
			static char bufErrSet[sizeof("zzerr")+10];
			int n = DefErrSet( &b, 0, NULL );
			int nErrSet = DefErrSetWithSuffix(0, &bErrSet, 1, NULL, "_set");
			if ( GenCC ) sprintf(buf, "err%d", n);
			else sprintf(buf, "zzerr%d", n);
			if ( GenCC ) sprintf(bufErrSet, "err%d", nErrSet);
			else sprintf(bufErrSet, "zzerr%d", nErrSet);
			set_name = buf;
			set_nameErrSet = bufErrSet;
		}

		if ( !FoundException ) {
/* MR23 */		gen2("zzsetmatch(%s, %s);", set_name, set_nameErrSet);
		}
		else if ( p->ex_group==NULL ) {
            if ( p->use_def_MT_handler )
                gen3("zzsetmatch_wdfltsig(%s,(ANTLRTokenType)%d,%s);",
                     set_name,
                     p->token,
                     tokenFollowSet(p))
            else
                gen2("zzsetmatch_wsig(%s, %s_handler);",
                     set_name,
                     handler_id);
		}
		else
		{
			gen1("if ( !_setmatch_wsig(%s) ) {\n", set_name);
			tabs++;
/* MR6 */	if (FoundGuessBlk) {
/* MR6 */	  if ( GenCC ) {gen("if ( guessing ) goto fail;\n");}
/* MR6 */	  else gen("if ( zzguessing ) goto fail;\n");
/* MR6 */	};
			gen("_signal=MismatchedToken;\n");
			dumpException(p->ex_group, 0);
			tabs--;
			gen("}\n");
		}
		set_free(b);
		set_free(bErrSet);
	}
	else if ( TokenString(p->token)!=NULL )
	{
		if ( FoundException ) {
			if ( p->use_def_MT_handler )
				gen2("zzmatch_wdfltsig(%s,%s);",TokenString(p->token),tokenFollowSet(p))
			else if ( p->ex_group==NULL )
			{
				gen2("zzmatch_wsig(%s, %s_handler);",
					 TokenString(p->token),
					 handler_id);
			}
			else
			{
/* MR6 */		if (GenCC) {
/* MR6 */		  gen1("if ( !_match_wsig(%s) ) {\n", TokenString(p->token));
/* MR6 */		} else {
/* MR6 */		  gen1("if ( !_zzmatch_wsig(%s) ) {\n", TokenString(p->token));
/* MR6 */		};
				tabs++;
/* MR6 */		if (FoundGuessBlk) {
/* MR6 */	  	  if ( GenCC ) {gen("if ( guessing ) goto fail;\n");}
/* MR6 */		  else gen("if ( zzguessing ) goto fail;\n");
/* MR6 */		};
				gen("_signal=MismatchedToken;\n");
				dumpException(p->ex_group, 0);
				tabs--;
				gen("}\n");
			}
		}
		else gen1("zzmatch(%s);", TokenString(p->token));
	}
	else {
        if ( FoundException ) {
            if ( p->use_def_MT_handler )
				gen2("zzmatch_wdfltsig((ANTLRTokenType)%d,%s);",
					 p->token,tokenFollowSet(p))
            else
                gen2("zzmatch_wsig(%d,%s_handler);",p->token,handler_id);
        }
		else {gen1("zzmatch(%d);", p->token);}
	}

	a = findImmedAction( p->next );
	/* generate the token labels */
	if ( GenCC && p->elnum>0 )
	{
		/* If building trees in C++, always gen the LT() assigns */
		if ( set_el(p->elnum, tokensRefdInBlock) || GenAST )
		{
/* MR10 */	if ( FoundGuessBlk ) {
/* MR10 */    gen("\n");
/* MR10 */    if (p->label_used_in_semantic_pred) {
/* MR10 */		gen2(" _t%d%d = (ANTLRTokenPtr)LT(1);  /* MR10 */\n", BlkLevel-1, p->elnum);
/* MR10 */    } else {
/* MR10 */		gen("if ( !guessing ) {\n"); tab();
/* MR10 */		_gen2(" _t%d%d = (ANTLRTokenPtr)LT(1);\n", BlkLevel-1, p->elnum);
/* MR10 */      gen("}\n");
/* MR10 */    };
/* MR10 */  } else {
/* MR10 */	  _gen2(" _t%d%d = (ANTLRTokenPtr)LT(1);", BlkLevel-1, p->elnum);
/* MR10 */  };
/* MR10 */
		}

/*
 *  MR23 labase is never used in the C++ runtime library.
 *       and this code is generated only in C++ mode
 */

/***		if ( LL_k>1 )                                    / * MR23 disabled */
/***			if ( !DemandLookahead ) _gen(" labase++;");  / * MR23 disabled */
/***		_gen("\n");                                      / * MR23 disabled */
/***		tab();                                           / * MR23 disabled */
	}
	if ( GenAST )
	{
		if ( FoundGuessBlk &&
				(ast_label_in_action || !(p->astnode == ASTexclude || r->noAST)) )
		{
			if ( GenCC ) {_gen("if ( !guessing ) {\n"); tab();}
			else {_gen("zzNON_GUESS_MODE {\n"); tab();}
		}

/* MR27 addition when labels referenced when operator ! used */

		pushedCmodeAST = 0; /* MR27 */
		if (ast_label_in_action && (p->astnode == ASTexclude || r->noAST)) {
			_gen("\n");
			if (GenCC) {
/* MR13 */      if (NewAST) {
/* MR13 */    	    gen4("_ast%d%d = newAST(_t%d%d); /* MR27 */\n", BlkLevel-1, p->elnum, BlkLevel-1, p->elnum);
/* MR13 */      } else {
/* MR13 */    	    gen4("_ast%d%d = new AST(_t%d%d); /* MR27 */\n", BlkLevel-1, p->elnum, BlkLevel-1, p->elnum);
/* MR13 */      }
			}
			else {
				pushedCmodeAST = 1;
				gen("zzastPush(zzmk_ast(zzastnew(),zzaCur)); /* MR27 */");
			}
		}

/* end MR27 addition for labels referenced when operator ! used */

		if (!r->noAST )
		{
			if (GenCC && !(p->astnode == ASTexclude) ) {
				_gen("\n");
/* MR13 */      if (NewAST) {
/* MR13 */    	    gen4("_ast%d%d = newAST(_t%d%d);\n", BlkLevel-1, p->elnum, BlkLevel-1, p->elnum);
/* MR13 */      } else {
/* MR13 */    	    gen4("_ast%d%d = new AST(_t%d%d);\n", BlkLevel-1, p->elnum, BlkLevel-1, p->elnum);
/* MR13 */      }
				tab();
			}
			if ( GenCC && !(p->astnode == ASTexclude) )
				{_gen2("_ast%d%d->", BlkLevel-1, p->elnum);}
			else _gen(" ");
			if ( p->astnode==ASTchild ) {
				if ( !GenCC ) _gen("zz");
				_gen("subchild(_root, &_sibling, &_tail);");
			}
			else if ( p->astnode==ASTroot ) {
				if ( !GenCC ) _gen("zz");
				_gen("subroot(_root, &_sibling, &_tail);");
			}
			if ( GenCC && !(p->astnode == ASTexclude) ) {
				_gen("\n");
				tab();
			}
		}
		else if ( !GenCC ) {
			if (! pushedCmodeAST) _gen(" zzastDPush;");
		}
		if ( FoundGuessBlk &&
				(ast_label_in_action || !(p->astnode == ASTexclude || r->noAST)) )
			{gen("}\n"); tab();}
	}

	/* Handle element labels now */
	if ( p->el_label!=NULL )
	{
        int     done_NON_GUESSMODE=0;

		_gen("\n");

/* MR10 */    /* do Attrib / Token ptr for token label used in semantic pred */
/* MR10 */    /* for these cases do assign even in guess mode                */
/* MR10 */
/* MR10 */    if (p->label_used_in_semantic_pred) {
/* MR10 */      if ( GenCC ) {
/* MR10 */        if ( set_el(p->elnum, tokensRefdInBlock) || GenAST ) {
/* MR10 */          gen3("%s = _t%d%d;", p->el_label, BlkLevel-1, p->elnum);
/* MR10 */        } else {
/* MR10 */          gen1("%s = (ANTLRTokenPtr)LT(1);\n", p->el_label);
/* MR10 */        };
/* MR10 */      } else {
/* MR10 */		  gen1("%s = zzaCur;", p->el_label);
/* MR10 */      };
/* MR10 */      if (FoundGuessBlk) _gen("  /* MR10 */");
/* MR10 */      _gen("\n");
/* MR10 */    };

		/* Do Attrib / Token ptr */

/* MR10 */  if (! p->label_used_in_semantic_pred) {
/* MR10 */
/* MR10 */      if ( FoundGuessBlk ) {
/* MR10 */        if (! done_NON_GUESSMODE) {
/* MR10 */          done_NON_GUESSMODE=1;
/* MR10 */          if ( GenCC ) {gen("if ( !guessing ) {\n"); tab();}
/* MR10 */          else {gen("zzNON_GUESS_MODE {\n"); tab();}
/* MR10 */        };
/* MR10 */      };
/* MR10 */
/* MR10 */      if ( GenCC ) {
/* MR10 */        if ( set_el(p->elnum, tokensRefdInBlock) || GenAST ) {
/* MR10 */          gen3("%s = _t%d%d;\n", p->el_label, BlkLevel-1, p->elnum);
/* MR10 */        } else {
/* MR10 */          gen1("%s = (ANTLRTokenPtr)LT(1);\n", p->el_label);
/* MR10 */        };
/* MR10 */      } else {
/* MR10 */        gen1("%s = zzaCur;\n", p->el_label);
/* MR10 */      };
/* MR10 */  };

		/* Do AST ptr */

		if (GenAST && (ast_label_in_action || !(p->astnode == ASTexclude || r->noAST) )) /* MR27 */
		{

/* MR10 */      if ( FoundGuessBlk ) {
/* MR10 */        if (! done_NON_GUESSMODE) {
/* MR10 */          done_NON_GUESSMODE=1;
/* MR10 */          if ( GenCC ) {gen("if ( !guessing ) {\n"); tab();}
/* MR10 */          else {gen("zzNON_GUESS_MODE {\n"); tab();}
/* MR10 */        };
/* MR10 */      };

			if ( GenCC ) {
				gen3("%s_ast = _ast%d%d;\n", p->el_label, BlkLevel-1, p->elnum);
			}
			else {gen1("%s_ast = zzastCur;\n", p->el_label);}
		}

/* MR10 */  if (done_NON_GUESSMODE) {
/* MR10 */    gen("}\n"); tab();
/* MR10 */  };

	}

	/* Handle any actions immediately following action */
	if ( a != NULL )  /* MR10 */ /* MR11 */
    {
    	/* delay next token fetch until after action */
		_gen("\n");
		if ( a->is_predicate)
		{
#if 0
/* Disabled in MR30 ************************************************************
   And moved into genAction
   *****************************************************************************
*/
 
    	    gen("if (!(");

			/* make sure that '#line n' is on front of line */  /* MR14 */
			if ( GenLineInfo && p->file != -1 ) _gen("\n");     /* MR14 */
			dumpPredAction(a,a->action, output, 0, a->file, a->line, 0);

/* MR23 Change failed predicate macro to have three arguments:

        macro arg 1: The stringized predicate itself
        macro arg 2: 0 => no user-defined error action
                     1 => user-defined error action
        macro arg 3: The user-defined error action

   This gives the user more control of the error action.
*/
			_gen(")) \n");
			tabs++;
			gen3(" {zzfailed_pred(\"%s\",%s,{ %s } );}\n",           /* MR23 */
					stringize(a->action),	                         /* MR23 */
                    (a->pred_fail == NULL ?                          /* MR23/MR27 */
                       	"0 /* report */" : "1 /* user action */"),   /* MR23/MR27 */
                    (a->pred_fail == NULL ?                          /* MR23 */
                        "0; /* no user action */" : a->pred_fail));  /* MR23 */
			tabs--;
/* Disabled in MR30 ************************************************************
   And moved into genAction
   *****************************************************************************
*/
#endif
		}
		else    /* MR9 a regular action - not a predicate action */
		{

/* MR23: Search an action which is not a predicate for LT(i),
         LA(i), or LATEXT(i) in order to warn novice users that
         it refers to the previous matched token, not the next
         one.  This is different than the case for semantic
         predicates.
*/
                                 
/* MR23 */    if (GenCC) {
/* MR23 */	    if (strstr(a->action, "LT(") != NULL) LTinTokenAction = 1;
/* MR23 */    }
/* MR23 */    else {
/* MR23 */      if (strstr(a->action, "LA(") != NULL) LTinTokenAction = 1;            
/* MR23 */      if (strstr(a->action, "LATEXT(") != NULL) LTinTokenAction = 1;
/* MR23 */    }

			if ( FoundGuessBlk ) {
   				if ( GenCC ) {gen("if ( !guessing ) {\n");}
   				else gen("zzNON_GUESS_MODE {\n");
			}
   			dumpActionPlus(a, a->action, output, tabs, a->file, a->line, 1); /* MR21 */
       		if ( FoundGuessBlk ) gen("}\n");
			a->done = 1; /* MR30 */
 		}
/***    a->done = 1;  MR30 Moved up into then branch for true actions, but not predicates ***/
		if ( !DemandLookahead ) {
			if ( GenCC ) {
				if ( FoundException && p->use_def_MT_handler ) gen("if (!_signal)");
				_gen(" consume();")
                if ( FoundException && p->use_def_MT_handler )
                    _gen(" _signal=NoSignal;");
                _gen("\n");
			}
            else
            {
                if ( FoundException && p->use_def_MT_handler ) _gen("if (!_signal)");
					_gen(" zzCONSUME;\n");
                if ( FoundException && p->use_def_MT_handler ) _gen(" _signal=NoSignal;");
                _gen("\n");
            }
		}
		else gen("\n");
		if (a->done) {			/* MR30 */
			TRANS( a->next );   /* MR30 */
		}						/* MR30 */
		else {					/* MR30 */
			TRANS( p->next );	/* MR30 */
		}						/* MR30 */
	}
	else
	{
        if ( !DemandLookahead ) {
			if ( GenCC ) {
				if (FoundException && p->use_def_MT_handler) _gen("if (!_signal)");
				_gen(" consume();")
				if (FoundException&&p->use_def_MT_handler) _gen(" _signal=NoSignal;");
				_gen("\n");
			}
			else {
				if (FoundException && p->use_def_MT_handler) _gen("if (!_signal)");
				_gen(" zzCONSUME;");
				if ( FoundException && p->use_def_MT_handler ) _gen(" _signal=NoSignal;");
				_gen("\n");
			}
		}
		else _gen("\n");
		TRANS(p->next);
	}
}

/*  MR21
 *
 *  There was a bug in the code generation for {...} which causes it
 *  to omit the optional tokens from the error messages.  The easiest
 *  way to fix this was to make the opt block look like a sub block:
 *
 *          { a | b | c }
 *
 *  becomes (internally):
 *
 *          ( a | b | c | )
 *
 *  The code for genOptBlk is now identical to genSubBlk except for
 *  cosmetic changes.
 */

void
#ifdef __USE_PROTOS
genOptBlk( Junction *q )
#else
genOptBlk( q )
Junction *q;
#endif
{
	int max_k;
	set f;
	int need_right_curly;
	set savetkref;
	int lastAltEmpty;			/* MR23 */
	savetkref = tokensRefdInBlock;
	require(q->ntype == nJunction,	"genOptBlk: not junction");
	require(q->jtype == aOptBlk,	"genOptBlk: not opt block");

    OutLineInfo(output,q->line,FileStr[q->file]);
	BLOCK_Preamble(q);
	BlkLevel++;
    BlockPreambleOption(q,q->pFirstSetSymbol); /* MR21 */
	f = genBlk(q, aOptBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);
/* MR23
   Bypass error clause generation when exceptions are used in {...} block 
   See multi-line note in genBlk near call to isEmptyAlt.
*/
	if (! FoundException) {
	    if ( q->p2 != NULL ) {tab(); makeErrorClause(q,f,max_k,0 /* use plus block bypass ? */ );}
	}
	else {
		gen("/* MR23 skip error clause for {...} when exceptions in use */\n");
	}
	{ int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
	freeBlkFsets(q);
	--BlkLevel;
	BLOCK_Tail();

	if ( q->guess )
	{
		gen("zzGUESS_DONE\n");
	}

	/* must duplicate if (alpha)?; one guesses (validates), the
	 * second pass matches */
	if ( q->guess && analysis_point(q)==q )
	{
        OutLineInfo(output,q->line,FileStr[q->file]);
		BLOCK_Preamble(q);
		BlkLevel++;
		f = genBlk(q, aSubBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);
		if ( q->p2 != NULL ) {tab(); makeErrorClause(q,f,max_k,0 /* use plus block bypass ? */ );}
		{ int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
		freeBlkFsets(q);
		--BlkLevel;
		BLOCK_Tail();
	}

	tokensRefdInBlock = savetkref;
	if (q->end->p1 != NULL) TRANS(q->end->p1);
}

/*
 * Generate code for a loop blk of form:
 *
 *				 |---|
 *				 v   |
 *			   --o-G-o-->o--
 */
void
#ifdef __USE_PROTOS
genLoopBlk( Junction *begin, Junction *q, Junction *start, int max_k )
#else
genLoopBlk( begin, q, start, max_k )
Junction *begin;
Junction *q;
Junction *start;	/* where to start generating code from */
int max_k;
#endif
{
	set         f;
	int         need_right_curly;
	set         savetkref;
    Junction    *guessBlock;    /* MR10 */
    int         singleAlt;      /* MR10 */
	int			lastAltEmpty;	/* MR23 */

	savetkref = tokensRefdInBlock;
	require(q->ntype == nJunction,	"genLoopBlk: not junction");
	require(q->jtype == aLoopBlk,	"genLoopBlk: not loop block");

	if ( q->visited ) return;
	q->visited = TRUE;

    /* first_item_is_guess_block doesn't care what kind of node it is */

    guessBlock=first_item_is_guess_block( (Junction *) q->p1);  /* MR10 */
    singleAlt=q->p2==NULL;                                      /* MR10 */

	if (singleAlt && !guessBlock)	    /* MR10 */ /* only one alternative? */
	{
		if ( DemandLookahead ) {
			if ( !GenCC ) {gen1("LOOK(%d);\n", max_k);}
			else gen1("look(%d);\n", max_k);
		}
		gen("while ( ");
		if ( begin!=NULL ) genExpr(begin);
		else genExpr(q);
		/* if no predicates have been hoisted for this single alt (..)*
		 * do so now
		 */
        require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
		if ( ParseWithPredicates && begin->predicate==NULL )
		{
			Predicate *a = MR_find_predicates_and_supp((Node *)q->p1);
            require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");

			if ( a!=NULL )
			{
				_gen("&&");
				a=genPredTreeMain(a, (Node *)q);    /* MR10 */
			}
/* MR10 */  if (MRhoisting) {
/* MR10 */    predicate_free(a);
/* MR10 */  };
		}
		_gen(" ) {\n");
		tabs++;
		TRANS(q->p1);
		if ( !GenCC ) gen1("zzLOOP(zztasp%d);\n", BlkLevel-1);
		if ( DemandLookahead ) {
			if ( !GenCC ) {gen1("LOOK(%d);\n", max_k);}
			else gen1("look(%d);\n", max_k);
		}
		--tabs;
		gen("}\n");
		freeBlkFsets(q);
		q->visited = FALSE;
		tokensRefdInBlock = savetkref;
		return;
	}
	gen("for (;;) {\n");        /* MR20 G. Hobbelt */
	tabs++;
/* MR6				                					*/
/* MR6 	   "begin" can never be null when called from genLoopBegin	*/
/* MR6     because q==(Junction *)begin->p1 and we know q is valid	*/
/* MR6								                            	*/
/* MR6	   from genLoopBegin:						                */
/* MR6			                						            */
/* MR6		 if ( LL_k>1 && !set_nil(q->fset[2]) )			        */
/* MR6	 	   genLoopBlk( q, (Junction *)q->p1, q, max_k );	    */
/* MR6		else genLoopBlk( q, (Junction *)q->p1, NULL, max_k );	*/
/* MR6				                				            	*/
	if ( begin!=NULL )
	{
		if ( DemandLookahead )
		{
			if ( !GenCC ) {gen1("LOOK(%d);\n", max_k);}
			else gen1("look(%d);\n", max_k);
		}
		/* The bypass arc of the (...)* predicts what to do when you fail, but
		 * ONLY after having tested the loop start expression.  To avoid this,
		 * we simply break out of the (...)* loop when we find something that
		 * is not in the prediction of the loop (all alts thereof).
		 */
		gen("if ( !(");

/***	TJP says: It used to use the prediction expression for the bypass arc
     	of the (...)*.  HOWEVER, if a non LL^1(k) decision was found, this
    	thing would miss the ftree stored in the aLoopBegin node and generate
    	an LL^1(k) decision anyway.

 ***		genExpr((Junction *)begin->p2);
 ***/

            genExpr((Junction *)begin);
            _gen(")) break;\n");

	}

	/* generate code for terminating loop (this is optional branch) */

	f = genBlk(q, aLoopBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);
	set_free(f);
	freeBlkFsets(q);

	/* generate code for terminating loop (this is optional branch) */

/* MR6 						                    			            */
/* MR6  30-May-97 Bug reported by Manuel Ornato				            */
/* MR6            A definite bug involving the exit from a loop block   */
/* MR6 		  In 1.23 and later versions (including 1.33) Instead       */
/* MR6              exiting the block and reporting a syntax error the  */
/* MR6		    code loops forever.     				                */
/* MR6	          Looking at 1.20 which generates proper code it is not */
/* MR6		    clear which of two changes should be undone.            */
/* MR6		  This is my best guess.                                    */
/* MR6		  From earlier MR6 note we know that begin can never be     */
/* MR6		    null when genLoopBlk called from genLoopBegin           */
/* MR6 */
/* MR6 */ if ( begin==NULL) {
/* MR6 */   /* code for exiting loop "for sure" */
/* MR6 */   gen("/* Suppressed by MR6 */ /*** else break; ***/\n");
/* MR6 */ };

/* MR10 */if (singleAlt && guessBlock) {
/* MR10 */  tabs--;
/* MR6 */   gen("} else break; /* MR6 code for exiting loop \"for sure\" */\n");
/* MR10 */  need_right_curly--;
/* MR10 */ } else {
/* MR6 */   gen("else break; /* MR6 code for exiting loop \"for sure\" */\n");
/* MR10 */ };

	{ int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
	if ( !GenCC ) gen1("zzLOOP(zztasp%d);\n", BlkLevel-1);
	--tabs;
	gen("}\n");
	q->visited = FALSE;
	tokensRefdInBlock = savetkref;
}

/*
 * Generate code for a loop blk of form:
 *
 * 				         |---|
 *					     v   |
 *			   --o-->o-->o-G-o-->o--
 *                   |           ^
 *                   v           |
 *					 o-----------o
 *
 * q->end points to the last node (far right) in the blk.
 *
 * Note that q->end->jtype must be 'EndBlk'.
 *
 * Generate code roughly of the following form:
 *
 *	do {
 *		... code for alternatives ...
 *  } while ( First Set of aLoopBlk );
 *
 *	OR if > 1 alternative
 *
 *	do {
 *		... code for alternatives ...
 *		else break;
 *  } while ( 1 );
 */
void
#ifdef __USE_PROTOS
genLoopBegin( Junction *q )
#else
genLoopBegin( q )
Junction *q;
#endif
{
	set f;
	int i;
	int max_k;
	set savetkref;
	savetkref = tokensRefdInBlock;
	require(q!=NULL,				"genLoopBegin: invalid node and/or rule");
	require(q->ntype == nJunction,	"genLoopBegin: not junction");
	require(q->jtype == aLoopBegin,	"genLoopBegin: not loop block");
	require(q->p2!=NULL,			"genLoopBegin: invalid Loop Graph");

    OutLineInfo(output,q->line,FileStr[q->file]);

	BLOCK_Preamble(q);
	BlkLevel++;
    BlockPreambleOption(q,q->pFirstSetSymbol);       /* MR21 */
	f = First(q, 1, aLoopBegin, &max_k);
	/* If not simple LL(1), must specify to start at LoopBegin, not LoopBlk */
	if ( LL_k>1 && !set_nil(q->fset[2]) )
		genLoopBlk( q, (Junction *)q->p1, q, max_k );
	else genLoopBlk( q, (Junction *)q->p1, NULL, max_k );

	for (i=1; i<=CLL_k; i++) set_free(q->fset[i]);
	for (i=1; i<=CLL_k; i++) set_free(((Junction *)q->p2)->fset[i]);
	--BlkLevel;
	BLOCK_Tail();
	set_free(f);
	tokensRefdInBlock = savetkref;
/* MR21 */	if (MR_BlkErr) {
/* MR21 */		set f, fArray[2];
/* MR21 */		f = ComputeErrorSet(q,1,0 /* use plus block bypass ? */ );
/* MR21 */      fArray[0]= empty;
/* MR21 */		fArray[1]= set_dup(f);
/* MR21 */      gen("if (");
/* MR21 */      genExprSets(fArray,1);  /* note: destroys set arguments */
/* MR21 */      _gen(") { /* MR21 option -mrblksynerr */\n");
/* MR21 */      tabs++;
/* MR21 */      tab();
/* MR21 */      _gen("/* nothing */ }\n");
/* MR21 */      tab();
/* MR21 */      makeErrorClause(q,f,1,0 /* use plus block bypass ? */ );  /* frees set */
/* MR21 */      tabs--;
/* MR21 */	};
	if (q->end->p1 != NULL) TRANS(q->end->p1);
}

/*
 * Generate code for a loop blk of form:
 *
 * 					 |---|
 *					 v   |
 *			       --o-G-o-->o--
 *
 * q->end points to the last node (far right) in the blk.
 * Note that q->end->jtype must be 'EndBlk'.
 *
 * Generate code roughly of the following form:
 *
 *	do {
 *		... code for alternatives ...
 *  } while ( First Set of aPlusBlk );
 *
 *	OR if > 1 alternative
 *
 *	do {
 *		... code for alternatives ...
 *		else if not 1st time through, break;
 *  } while ( 1 );
 */
void
#ifdef __USE_PROTOS
genPlusBlk( Junction *q )
#else
genPlusBlk( q )
Junction *q;
#endif
{
	int         max_k;
	set         f;
	int         need_right_curly;
	int			lastAltEmpty;	/* MR23 */
	set         savetkref;
    Junction    *guessBlock;    /* MR10 */
    int         singleAlt;      /* MR10 */

	savetkref = tokensRefdInBlock;
	require(q!=NULL,				"genPlusBlk: invalid node and/or rule");
	require(q->ntype == nJunction,	"genPlusBlk: not junction");
	require(q->jtype == aPlusBlk,	"genPlusBlk: not Plus block");
	require(q->p2 != NULL,			"genPlusBlk: not a valid Plus block");

	if ( q->visited ) return;
	q->visited = TRUE;
    OutLineInfo(output,q->line,FileStr[q->file]);
	BLOCK_Preamble(q);
	BlkLevel++;

    BlockPreambleOption((Junction *)q, q->pFirstSetSymbol);       /* MR21 */
    
    /* first_item_is_guess_block  doesn't care what kind of node it is */

    guessBlock=first_item_is_guess_block( (Junction *)q->p1);   /* MR10 */

	/* if the ignore flag is set on the 2nd alt and that alt is empty,
	 * then it is the implied optional alternative that we added for (...)+
	 * and, hence, only 1 alt.
	 */

/* MR10  Reported by Pulkkinen Esa (esap@cs.tut.fi)
 *       Outer code for guess blocks ignored when there is only one alt
 *         for a (...)+ block.
 *       Force use of regular code rather than "optimized" code for that case
 */

    singleAlt=( ( (Junction *) q->p2)->p2 == NULL) &&
        	  ( ( (Junction *) q->p2)->ignore );			/* only one alternative? */

    if (singleAlt && !guessBlock)   /* MR10 */
	{

		Predicate *a=NULL;
		/* if the only alt has a semantic predicate, hoist it; must test before
		 * entering loop.
		 */
		if ( ParseWithPredicates )
		{
            require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");
			a = MR_find_predicates_and_supp((Node *)q);
            require(MR_PredRuleRefStack.count == 0,"PredRuleRef stack not empty");

			if ( a!=NULL ) {
				gen("if (");
				a=genPredTreeMain(a, (Node *)q);    /* MR10 */
				_gen(") {\n");
			}
		}
		gen("do {\n");
		tabs++;
		TRANS(q->p1);
		if ( !GenCC ) gen1("zzLOOP(zztasp%d);\n", BlkLevel-1);
		f = First(q, 1, aPlusBlk, &max_k);
		if ( DemandLookahead ) {
			if ( !GenCC ) {gen1("LOOK(%d);\n", max_k);}
			else gen1("look(%d);\n", max_k);
		}
		--tabs;
		gen("} while ( ");
		if ( q->parm!=NULL && q->predparm ) _gen1("(%s) && ", q->parm);
		genExpr(q);
		if ( ParseWithPredicates && a!=NULL )
		{
            if (! MR_comparePredicates(q->predicate,a)) {
    			_gen("&&");
    			a=genPredTreeMain(a, (Node *)q);    /* MR10 */
            };
		}
		_gen(" );\n");
		if ( ParseWithPredicates && a!=NULL ) gen("}\n");
		--BlkLevel;
		BLOCK_Tail();
		q->visited = FALSE;
		freeBlkFsets(q);
		set_free(f);
		tokensRefdInBlock = savetkref;
/* MR21 */	if (MR_BlkErr) {
/* MR21 */		set f, fArray[2];
/* MR21 */		f = ComputeErrorSet(q,1,1 /* use plus block bypass ? */ );
/* MR21 */      fArray[0]= empty;
/* MR21 */		fArray[1]= set_dup(f);
/* MR21 */      gen("if (");
/* MR21 */      genExprSets(fArray,1);  /* note: destroys set arguments */
/* MR21 */      _gen(") { /* MR21 option -mrblksynerr */\n");
/* MR21 */      tabs++;
/* MR21 */      tab();
/* MR21 */      _gen("/* nothing */ }\n");
/* MR21 */      tab();
/* MR21 */      makeErrorClause(q,f,1,1 /* use plus block bypass ? */ );  /* frees set */
/* MR21 */      tabs--;
/* MR21 */	};
		if (q->end->p1 != NULL) TRANS(q->end->p1);
/* MR10 */  if (MRhoisting) {
/* MR10 */    predicate_free(a);
/* MR10 */  };
		return;
	}
	gen("do {\n");
	tabs++;
	f = genBlk(q, aPlusBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);
/* MR6              									        */
/* MR6	Sinan Karasu	(sinan@tardis.ds.boeing.com)			*/
/* MR6    Failed to turn off guess mode when leaving block		*/
/* MR6				                           					*/
/* MR6  */ if ( has_guess_block_as_last_item(q) ) {
/* MR10 */   gen("/* MR10 ()+ */ else {\n");
/* MR10 */   tabs++;
/* MR10 */   need_right_curly++;
/* MR10 */   gen("/* MR10 ()+ */ if ( !zzrv ) zzGUESS_DONE;\n");
/* MR6  */   gen("/* MR10 ()+ */ if ( zzcnt > 1 ) break;\n");
/* MR10 */ } else {
/* MR10 */   gen("/* MR10 ()+ */ else {\n");
/* MR10 */   tabs++;
/* MR10 */   need_right_curly++;
/* MR10 */   gen("if ( zzcnt > 1 ) break;\n");
/* MR10 */ };

/* MR21 */	if (MR_BlkErr && 1 >= max_k) {
/* MR21 */		set f;
/* MR21 */		f = ComputeErrorSet(q,1,0 /* use plus block bypass ? */ );
/* MR21 */      tabs++;
/* MR21 */      tab();
/* MR21 */      makeErrorClause(q,f,1,0 /* use plus block bypass ? */ );  /* frees set */
/* MR21 */      tabs--;
/* MR21 */	}
/* MR21 */  else {
				tab();
                makeErrorClause(q,f,max_k,1 /* use plus block bypass ? */);
										    /* MR21 I think this generates the wrong set ? */
                                            /* MR21 because it includes the plus block bypass ? */
										    /* MR21 but I'm afraid to change it without additional checking */
            }

	{ int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
	freeBlkFsets(q);
	gen("zzcnt++;");
	if ( !GenCC ) _gen1(" zzLOOP(zztasp%d);", BlkLevel-1);
	_gen("\n");
	if ( DemandLookahead ) {
		if ( !GenCC ) {gen1("LOOK(%d);\n", max_k);}
		else gen1("look(%d);\n", max_k);
	}
	--tabs;
	if ( q->parm!=NULL && q->predparm ) {gen1("} while (%s);\n", q->parm);}
	else gen("} while ( 1 );\n");
	--BlkLevel;
	BLOCK_Tail();
	q->visited = FALSE;
	tokensRefdInBlock = savetkref;
/* MR21 */	if (MR_BlkErr) {
/* MR21 */		set f, fArray[2];
/* MR21 */		f = ComputeErrorSet(q,1,1 /* use plus block bypass ? */ );
/* MR21 */      fArray[0]= empty;
/* MR21 */		fArray[1]= set_dup(f);
/* MR21 */      gen("if (");
/* MR21 */      genExprSets(fArray,1);  /* note: destroys set arguments */
/* MR21 */      _gen(") { /* MR21 option -mrblksynerr */\n");
/* MR21 */      tabs++;
/* MR21 */      tab();
/* MR21 */      _gen("/* nothing */ }\n");
/* MR21 */      tab();
/* MR21 */      makeErrorClause(q,f,1,1 /* use plus block bypass ? */ );  /* frees set */
/* MR21 */      tabs--;
/* MR21 */	};
	if (q->end->p1 != NULL) TRANS(q->end->p1);
}

/*
 * Generate code for a sub blk of alternatives of form:
 *
 *			       --o-G1--o--
 *					 |     ^
 *					 v    /|
 *			         o-G2-o|
 *					 |     ^
 *					 v     |
 *				   ..........
 *					 |     ^
 *					 v    /
 *			         o-Gn-o
 *
 * q points to the 1st junction of blk (upper-left).
 * q->end points to the last node (far right) in the blk.
 * Note that q->end->jtype must be 'EndBlk'.
 * The last node in every alt points to q->end.
 *
 * Generate code of the following form:
 *	if ( First(G1) ) {
 *		...code for G1...
 *	}
 *	else if ( First(G2) ) {
 *		...code for G2...
 *	}
 *	...
 *	else {
 *		...code for Gn...
 *	}
 */

void
#ifdef __USE_PROTOS
genSubBlk( Junction *q )
#else
genSubBlk( q )
Junction *q;
#endif
{
	int max_k;
	set f;
	int need_right_curly;
	int lastAltEmpty;		/* MR23 */
	set savetkref;
	savetkref = tokensRefdInBlock;
	require(q->ntype == nJunction,	"genSubBlk: not junction");
	require(q->jtype == aSubBlk,	"genSubBlk: not subblock");

    OutLineInfo(output,q->line,FileStr[q->file]);
	BLOCK_Preamble(q);
	BlkLevel++;
    BlockPreambleOption(q,q->pFirstSetSymbol);       /* MR21 */
	f = genBlk(q, aSubBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);

/* MR23
   Bypass error clause generation when exceptions are used in a sub block
   in which the last alternative is epsilon.  Example: "(A | B | )". 
   See multi-line note in genBlk near call to isEmptyAlt.
*/
	if (FoundException && lastAltEmpty) {
		gen("/* MR23 skip error clause for (...| epsilon) when exceptions in use */\n");
	}
	else {
		if ( q->p2 != NULL ) {tab(); makeErrorClause(q,f,max_k,0 /* use plus block bypass ? */ );}
	}
    
	{ int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
	freeBlkFsets(q);
	--BlkLevel;
	BLOCK_Tail();

	if ( q->guess )
	{
		gen("zzGUESS_DONE\n");
	}

	/* must duplicate if (alpha)?; one guesses (validates), the
	 * second pass matches */
	if ( q->guess && analysis_point(q)==q )
	{
        OutLineInfo(output,q->line,FileStr[q->file]);
		BLOCK_Preamble(q);
		BlkLevel++;
		f = genBlk(q, aSubBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);
		if ( q->p2 != NULL ) {tab(); makeErrorClause(q,f,max_k,0 /* use plus block bypass ? */);}
		{ int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
		freeBlkFsets(q);
		--BlkLevel;
		BLOCK_Tail();
	}

	tokensRefdInBlock = savetkref;
	if (q->end->p1 != NULL) TRANS(q->end->p1);
}

static int TnodesAllocatedPrevRule=0;

/*
 * Generate code for a rule.
 *
 *		rule--> o-->o-Alternatives-o-->o
 * Or,
 *		rule--> o-->o-Alternative-o-->o
 *
 * The 1st junction is a RuleBlk.  The second can be a SubBlk or just a junction
 * (one alternative--no block), the last is EndRule.
 * The second to last is EndBlk if more than one alternative exists in the rule.
 *
 * To get to the init-action for a rule, we must bypass the RuleBlk,
 * and possible SubBlk.
 * Mark any init-action as generated so genBlk() does not regenerate it.
 */
void
#ifdef __USE_PROTOS
genRule( Junction *q )
#else
genRule( q )
Junction *q;
#endif
{

	const char * returnValueInitializer;

do {    /* MR10     Change recursion into iteration         */

	int max_k;
	set follow, rk, f;
	ActionNode *a;
	RuleEntry *r;
	int lastAltEmpty;		/* MR23 */
	static int file = -1;
	int need_right_curly;
	require(q->ntype == nJunction,	"genRule: not junction");
	require(q->jtype == RuleBlk,	"genRule: not rule");

/* MR14 */    require (MR_BackTraceStack.count == 0,"-alpha MR_BackTraceStack.count != 0");
/* MR14 */    MR_pointerStackReset(&MR_BackTraceStack);
/* MR14 */    if (AlphaBetaTrace) MR_MaintainBackTrace=1;

    CurRule=q->rname;                               /* MR11 */

	r = (RuleEntry *) hash_get(Rname, q->rname);
	if ( r == NULL ) warnNoFL("Rule hash table is screwed up beyond belief");
	if ( q->file != file )		/* open new output file if need to */
	{
/* MR6              									*/
/* MR6  Simpler to debug when output goes to stdout rather than a file 	*/
/* MR6				                					*/
/* MR6 */	if (UseStdout) {
/* MR6 */	  output = stdout;
/* MR6 */	} else {
/* MR6 */  	  if ( output != NULL) fclose( output );
/* MR6 */	  output = fopen(OutMetaName(outname(FileStr[q->file])), "w");
/* MR6 */	};
		require(output != NULL, "genRule: can't open output file");

#ifdef SPECIAL_FOPEN
       special_fopen_actions(OutMetaName(outname(FileStr[q->file]))); /* MR1 */
#endif
		if ( file == -1 ) genHdr1(q->file);
		else genHdr(q->file);
		file = q->file;
	}

    if (InfoM) {
      fprintf(stderr,"    rule %s\n",q->rname);
      fflush(output);
    };

#if 0
    if (strcmp(q->rname,"***debug***") == 0) {
      fprintf(stderr,"***debug*** %s reached\n",q->rname);
      MR_break();
    };
#endif

	DumpFuncHeader(q,r);
	tabs++;

	/* MR23 
	   
	   If there is a single return value then it can be initialized in 
	   the declaration using assignment syntax.  If there are multiple
	   return values then antlr creates a struct and initialization takes
	   place element by element for each element of the struct.  For
       multiple elements the initialization is by assignment so we have
       to wait until all declarations are done before emitting that code -
       because of restrictions in C which don't exist in C++.

       In the past (before MR23) the only kind of initialization was
	   the PURIFY macro which was just a memset() of 0.  Now we allow
	   the user to specify an initial value.  PURIFY is still used in C
	   mode because C does not have constructors.  However, PURIFY is
	   not used in C++ mode because it might overwrite information created
	   by elements which have their own ctor.
       
	*/

	if ( q->ret!=NULL )
	{
		if ( hasMultipleOperands(q->ret) )                         /* MR23 */
		{

            /* Emit initialization code later. */

			gen1("struct _rv%d _retv;\n",r->rulenum);
		}
		else
		{
            /* Emit initialization code now. */

			tab();
			DumpType(q->ret, output);
            returnValueInitializer = getInitializer(q->ret);
            if (returnValueInitializer == NULL) {                  /* MR23 */
      			gen(" _retv;\n");                     		    /* MR1 MR3 */
            }                                                      /* MR23 */
            else {                                                 /* MR23 */
                gen1(" _retv = %s;\n", returnValueInitializer);    /* MR23 */
            }                                                      /* MR23 */
		}
	}

    OutLineInfo(output,q->line,FileStr[q->file]);

    if (InfoM) {
      fflush(output);
    };

	gen("zzRULE;\n");
	if ( FoundException )
	{
		gen("int _sva=1;\n");
	}
	if ( GenCC && GenAST )
		gen("ASTBase *_ast = NULL, *_sibling = NULL, *_tail = NULL;\n");
	if ( GenCC ) genTokenPointers(q);
	if ( GenCC&&GenAST ) genASTPointers(q);
	if ( q->el_labels!=NULL ) genElementLabels(q->el_labels);
	if ( FoundException ) gen("int _signal=NoSignal;\n");

	if ( !GenCC ) gen1("zzBLOCK(zztasp%d);\n", BlkLevel);

/* MR10 */  /* move zzTRACEIN to before init action */

/* MR10 */	if ( TraceGen ) {
/* MR10 */		if ( GenCC ) {gen1("zzTRACEIN(\"%s\");\n", q->rname);}
/* MR10 */		else gen1("zzTRACEIN((ANTLRChar *)\"%s\");\n", q->rname);
/* MR10 */	}

/* MR7      Moved PURIFY() to after all local variables have been declared */
/* MR7      so that the generated code is valid C as well as C++           */
/* MR7        Jan Mikkelsen 10-June-1997                                   */


     /*
       MR23    Do the PURIFY macro only for C mode.
               C++ users should use constructors or initialization expressions.
     */

	if ( q->ret != NULL )                                            /* MR7 */
	{                                                                /* MR7 */
		if (hasMultipleOperands(q->ret)) {                           /* MR23 */
			if (PURIFY == TRUE) {
                gen1("PCCTS_PURIFY(_retv,sizeof(struct _rv%d))\n",r->rulenum); /* MR23 */
            }
        }                                                            /* MR7 */
		else {                                                       /* MR7 */

			/* MR23
			   If there were only one return value operand and
			   it had an initializer then it would have been
			   initiailized in the declaration.
			*/

			returnValueInitializer = getInitializer(q->ret);         /* MR23 */
			if (returnValueInitializer == NULL) {                    /* MR23 */
    			if (PURIFY == TRUE) {
        			gen("PCCTS_PURIFY(_retv,sizeof(");               /* MR23 */
	    			DumpType(q->ret, output);                        /* MR7 */
					gen("))\n");                                     /* MR7 */
				}
			}                                                        /* MR23 */
		}                                                            /* MR7 */

        if (hasMultipleOperands(q->ret)) {                           /* MR23 */
          DumpInitializers(output, r, q->ret);                       /* MR23 */
        }

	}
	if ( !GenCC ) gen("zzMake0;\n");
	if ( FoundException ) gen("*_retsignal = NoSignal;\n");

	if ( !GenCC ) gen("{\n");

	if ( has_guess_block_as_first_item((Junction *)q->p1) )
	{
		gen("zzGUESS_BLOCK\n");
	}

	/* L o o k  F o r  I n i t  A c t i o n */
	if ( ((Junction *)q->p1)->jtype == aSubBlk )
		a = findImmedAction( ((Junction *)q->p1)->p1 );
	else
		a = findImmedAction( q->p1 );	/* only one alternative in rule */
	if ( a!=NULL && !a->is_predicate)
	{
 /* MR21 */ if (!a->noHoist) dumpActionPlus(a, a->action, output, tabs, a->file, a->line, 1);
  		    a->done = 1;	/* ignore action. We have already handled it */
	}

	BlkLevel++;
	q->visited = TRUE;				/* mark RULE as visited for FIRST/FOLLOW */
    BlockPreambleOption((Junction *)q->p1, NULL);   /* MR21 */
	f = genBlk((Junction *)q->p1, RuleBlk, &max_k, &need_right_curly, &lastAltEmpty /* MR23 */);
	if ( q->p1 != NULL )
		if ( ((Junction *)q->p1)->p2 != NULL )
			{tab(); makeErrorClause((Junction *)q->p1,f,max_k,0 /* use plus block bypass ? */);}
	{ int i; for (i=1; i<=need_right_curly; i++) {tabs--; gen("}\n");} }
	freeBlkFsets((Junction *)q->p1);
	q->visited = FALSE;
	--BlkLevel;
	if ( !GenCC ) gen1("zzEXIT(zztasp%d);\n", BlkLevel);

    genTraceOut(q);

	if ( q->ret!=NULL ) gen("return _retv;\n") else gen("return;\n");
	/* E r r o r  R e c o v e r y */
	NewSet();
	rk = empty;

/* MR14 */    if (r->dontComputeErrorSet) {
/* MR14 */      follow=empty;
              } else {
                MR_pointerStackReset(&MR_BackTraceStack);   /* MR14 */
                MR_ErrorSetComputationActive=1;
                REACH(q->end, 1, &rk, follow);
                MR_ErrorSetComputationActive=0;
                require (MR_BackTraceStack.count == 0,"K: MR_BackTraceStack.count != 0");
              }

  FillSet( follow );
	set_free( follow );

  /* MR20 G. Hobbelt 
     Isn't it so that "fail:" is ONLY referenced when:

      	 !FoundException || FoundGuessBlk ?

     Therefore add the "if" around this piece of code generation...

     Should guessing mode also use _handler label instead of "fail"
     when exception handling is active? gen can automatically put 
     "if (guessing)" there so as to skip all kinds of user code.

   */

	if ( !FoundException || FoundGuessBlk )  /* MR20 G. Hobbelt */
  {                                          /* MR20 G. Hobbelt */
	_gen("fail:\n");
	if ( !GenCC ) gen("zzEXIT(zztasp1);\n");
	if ( FoundGuessBlk ) {
	   	if ( !GenCC ) {gen("if ( zzguessing ) zzGUESS_FAIL;\n");}
		else gen("if ( guessing ) zzGUESS_FAIL;\n");
	}
	if ( q->erraction!=NULL )
		dumpAction(q->erraction, output, tabs, q->file, q->line, 1);
	if ( GenCC )
	{
		gen1("syn(zzBadTok, %s, zzMissSet, zzMissTok, zzErrk);\n",
			 r->egroup==NULL?"(ANTLRChar *)\"\"":r->egroup);
	}
	else
	{
		gen1("zzsyn(zzMissText, zzBadTok, %s, zzMissSet, zzMissTok, zzErrk, zzBadText);\n",
			 r->egroup==NULL?"(ANTLRChar *)\"\"":r->egroup);
	}
	gen3("%sresynch(setwd%d, 0x%x);\n", GenCC?"":"zz", wordnum, 1<<setnum);

	if ( q->ret!=NULL ) {
      genTraceOut(q);
      gen("return _retv;\n");
    } else if ( q->exceptions!=NULL ) {
      genTraceOut(q);
      gen("return;\n");
    } else if (!FoundException) {       /* MR10 */
      genTraceOut(q);                   /* MR10 */
    };

  }                                        /* MR20 G. Hobbelt */

	if ( !GenCC ) gen("}\n");

	/* Gen code for exception handlers */
    /* make sure each path out contains genTraceOut() */

	if ( q->exceptions!=NULL )
	{

		gen("/* exception handlers */\n");

		dumpExceptions(q->exceptions);

        if ( !r->has_rule_exception )
        {
            _gen("_handler:\n");
            gen("zzdflthandlers(_signal,_retsignal);\n");
        }
/*  MR20 G. Gobbelt   The label "adios" is never referenced */

#if 0
	_gen("_adios:\n");
#endif
    if ( q->ret!=NULL ) {
            genTraceOut(q);
            gen("return _retv;\n");
        }
		else {
            genTraceOut(q);
            gen("return;\n");
        }
	}
	else if ( FoundException )
	{
      _gen("_handler:\n");
      gen("zzdflthandlers(_signal,_retsignal);\n");

/* MR1                                                                      */
/* MR1	 7-Apr-97 Fix suggested by: John Bair (jbair@iftime.com)            */
/* MR1							                                            */

   	  if ( q->ret != NULL) {			                             /* MR1 */
            genTraceOut(q);                                          /* MR10 */
            gen("return _retv;\n");			                         /* MR1 */
      } else {					                                     /* MR1 */
            genTraceOut(q);                                          /* MR10 */
            gen("return;\n")    ;				                     /* MR1 */
      };						                                     /* MR1 */
	}

	tabs--;
	gen("}\n");

/* MR10     Tired of looking at stacks that are as deep as the number of    */
/* MR10       rules.  Changes recursion to iteration.                       */

    MR_releaseResourcesUsedInRule( (Node *) q );      /* MR10 */

    if (InfoT) {
      fprintf(output,"\n/* tnodes created for rule %s:  %d */\n",
                q->rname, (TnodesAllocated-TnodesAllocatedPrevRule) );
    };

    TnodesAllocatedPrevRule=TnodesAllocated;

    if (q->p2 == NULL) dumpAfterActions( output );
    q=(Junction *)q->p2;
    require(q==NULL || q->jtype==RuleBlk,"RuleBlk p2 does not point to another RuleBlk");

} while (q != NULL);

/**** The old code                           ****/
/****	if ( q->p2 != NULL ) {TRANS(q->p2);} ****/ /* generate code for next rule too */
/****	else dumpAfterActions( output );     ****/

}


/* This is for the function definition, not the declaration. */

static void
#ifdef __USE_PROTOS
DumpFuncHeader( Junction *q, RuleEntry *r )
#else
DumpFuncHeader( q, r )
Junction *q;
RuleEntry *r;
#endif
{
/*								                                            */
/*  MR1 10-Apr-97  MR1  Simplify insertion of commas in function header     */
/*								                                            */
	int	needComma;					                                 /* MR1 */


	/* A N S I */
	_gen("\n");
	if ( q->ret!=NULL )
	{
		if ( hasMultipleOperands(q->ret) )                            /* MR23 */
		{
			if (GenCC) gen2("%s::_rv%d\n", CurrentClassName, r->rulenum)
			else gen1("struct _rv%d\n",r->rulenum);
		}
		else
		{
			DumpType(q->ret, output);
			gen("\n");
		}
	}
	else
	{
		_gen("void\n");
	}
/*  MR1			                                                            */
/*  MR1	10-Apr-97  133MR1	Replace __STDC__ with __USE_PROTOS              */
/*  MR1								                                        */
	if ( !GenCC ) _gen("#ifdef __USE_PROTOS\n");		     /* MR1 */
	if ( !GenCC ) gen2("%s%s(", RulePrefix, q->rname)
	else gen3("%s::%s%s(", CurrentClassName, RulePrefix,q->rname);

    	/* If we generate C++ method names, we must hide default arguments */
        /* which can appear in the parameter declaration list.             */
        /* NOTICE: this is done only here, for the method definition, but  */
        /*         not for the method declaration inside the class         */
        /*         definition. This is exactly the behaviour defined in    */
        /*         C++ standard for default paramters.                     */

	DumpANSIFunctionArgDef(output,q, 0 /* emit initializers ? */);
	_gen("\n");

	if ( GenCC ) {
      gen("{\n");
      return;
    }

	/* K & R */
	gen("#else\n");
	gen2("%s%s(", RulePrefix, q->rname);
	needComma=0;						                             /* MR1 */
	if ( GenAST )						                             /* MR1 */
	{							                                     /* MR1 */
		_gen("_root");					                             /* MR1 */
		needComma=1;					                             /* MR1 */
	}							                                     /* MR1 */
	if ( FoundException )					                         /* MR1 */
	{							                                     /* MR1 */
		if (needComma) {_gen(",");needComma=0;};	                 /* MR1 */
		_gen("_retsignal");				                             /* MR1 */
		needComma=1;					                             /* MR1 */
	}							                                     /* MR1 */
/* MR5	Change below by Jan Mikkelsen (janm@zeta.org.au) 26-May-97      MR5 */
	DumpListOfParmNames( q->pdecl, output, needComma );	             /* MR5 */
	gen(")\n");
	if ( GenAST ) gen("AST **_root;\n");
	if ( FoundException ) gen("int *_retsignal;\n");
	DumpOldStyleParms( q->pdecl, output );
	gen("#endif\n");
    gen("{\n");
}

void
#ifdef __USE_PROTOS
DumpANSIFunctionArgDef(FILE *f, Junction *q, int bInitializer)
#else
DumpANSIFunctionArgDef(f,q,bInitializer)
FILE *f;
Junction *q;
int bInitializer;
#endif
{
	if ( GenAST )
	{
		if ( GenCC ) {fprintf(f,"ASTBase **_root");}
		else fprintf(f,"AST**_root");
		if ( !FoundException && q->pdecl!=NULL ) fprintf(f,",");
	}
	if ( FoundException )
	{
		if ( GenAST ) fprintf(f,",");
		fprintf(f,"int *_retsignal");
		if ( q->pdecl!=NULL ) {
            fprintf(f,",");
        }
	}
	if ( q->pdecl!=NULL ) {
        DumpFormals(f, q->pdecl, bInitializer);     /* MR23 */
    }
	else {
        if ( !GenAST && !FoundException ) {
            fprintf(f,"void");
        }
    }
	fprintf(f,")");
}

void
#ifdef __USE_PROTOS
genJunction( Junction *q )
#else
genJunction( q )
Junction *q;
#endif
{
	require(q->ntype == nJunction,	"genJunction: not junction");
	require(q->jtype == Generic,	"genJunction: not generic junction");

	if ( q->p1 != NULL ) TRANS(q->p1);
	if ( q->p2 != NULL ) TRANS(q->p2);
}

void
#ifdef __USE_PROTOS
genEndBlk( Junction *q )
#else
genEndBlk( q )
Junction *q;
#endif
{
}

void
#ifdef __USE_PROTOS
genEndRule( Junction *q )
#else
genEndRule( q )
Junction *q;
#endif
{
}

void
#ifdef __USE_PROTOS
genHdr( int file )
#else
genHdr( file )
int file;
#endif
{
    int     i;

	_gen("/*\n");
	_gen(" * A n t l r  T r a n s l a t i o n  H e a d e r\n");
	_gen(" *\n");
	_gen(" * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001\n");
	_gen(" * Purdue University Electrical Engineering\n");
	_gen(" * With AHPCRC, University of Minnesota\n");
	_gen1(" * ANTLR Version %s\n", Version);
	_gen(" *\n");
/* MR10 */    _gen(" *  ");
/* MR10 */    for (i=0 ; i < Save_argc ; i++) {
/* MR10 */      _gen(" ");
/* MR10 */      _gen(Save_argv[i]);
/* MR10 */    };
	_gen("\n");
	_gen(" *\n");
    _gen(" */\n\n");
	if (FirstAction != NULL ) dumpAction( FirstAction, output, 0, -1, 0, 1);    /* MR11 MR15b */
	_gen1("#define ANTLR_VERSION	%s\n", VersionDef);
	_gen("#include \"pcctscfg.h\"\n");
	_gen("#include \"pccts_stdio.h\"\n");
	if ( strcmp(ParserName, DefaultParserName)!=0 )
		_gen2("#define %s %s\n", DefaultParserName, ParserName);
   	if ( strcmp(ParserName, DefaultParserName)!=0 )
		{_gen1("#include \"%s\"\n", RemapFileName);}
    OutLineInfo(output,1,FileStr[file]);
	if ( GenCC ) {
		if ( UserTokenDefsFile != NULL )
			fprintf(output, "#include %s\n", UserTokenDefsFile);
		else
			fprintf(output, "#include \"%s\"\n", DefFileName);
	}

	if ( HdrAction != NULL ) dumpAction( HdrAction, output, 0, -1, 0, 1);
	if ( !GenCC && FoundGuessBlk )
	{
		_gen("#define ZZCAN_GUESS\n");
		_gen("#include \"pccts_setjmp.h\"\n");  /* MR15 K.J. Cummings (cummings@peritus.com) */
	}
	if ( FoundException )
	{
		_gen("#define EXCEPTION_HANDLING\n");
		_gen1("#define NUM_SIGNALS %d\n", NumSignals);
	}
	if ( !GenCC && OutputLL_k > 1 ) _gen1("#define LL_K %d\n", OutputLL_k);
	if ( GenAST&&!GenCC ) _gen("#define GENAST\n\n");
	if ( GenAST ) {
		if ( GenCC ) {_gen1("#include \"%s\"\n\n", ASTBASE_H);}
		else _gen("#include \"ast.h\"\n\n");
	}
	if ( !GenCC && DemandLookahead ) _gen("#define DEMAND_LOOK\n\n");
#ifdef DUM
	if ( !GenCC && LexGen ) {
		_gen1("#define zzEOF_TOKEN %d\n", (TokenInd!=NULL?TokenInd[EofToken]:EofToken));
	}
#endif
	/* ###WARNING: This will have to change when SetWordSize changes */
	if ( !GenCC ) _gen1("#define zzSET_SIZE %d\n", NumWords(TokenNum-1)*sizeof(unsigned));
    if (TraceGen) {
      _gen("#ifndef zzTRACE_RULES\n");  /* MR20 */
      _gen("#define zzTRACE_RULES\n");  /* MR20 */
      _gen("#endif\n");                 /* MR22 */
    };
	if ( !GenCC ) {_gen("#include \"antlr.h\"\n");}
	else {
		_gen1("#include \"%s\"\n", APARSER_H);
		_gen1("#include \"%s.h\"\n", CurrentClassName);
	}
	if ( !GenCC ) {
		if ( UserDefdTokens )
			{_gen1("#include %s\n", UserTokenDefsFile);}
		/* still need this one as it has the func prototypes */
		_gen1("#include \"%s\"\n", DefFileName);
	}
	/* still need this one as it defines the DLG interface */
	if ( !GenCC ) _gen("#include \"dlgdef.h\"\n");
	if ( LexGen && GenCC ) _gen1("#include \"%s\"\n", DLEXERBASE_H);
	if ( GenCC ) _gen1("#include \"%s\"\n", ATOKPTR_H);
	if ( !GenCC && LexGen ) _gen1("#include \"%s\"\n", ModeFileName);

/* MR10  Ofer Ben-Ami (gremlin@cs.huji.ac.il)           */
/* MR10    Finally, a definition of the Purify macro    */

    if (PURIFY == TRUE) {                                                   /* MR23 */
        _gen("\n/* MR23 In order to remove calls to PURIFY use the antlr"); /* MR23 */
        _gen(" -nopurify option */\n\n");                                   /* MR23 */
    	_gen("#ifndef PCCTS_PURIFY\n");
        _gen("#define PCCTS_PURIFY(r,s) memset((char *) &(r),'\\0',(s));\n");
        _gen("#endif\n\n");
    }                                                                       /* MR23 */
}

void
#ifdef __USE_PROTOS
genHdr1( int file )
#else
genHdr1( file )
int file;
#endif
{
	ListNode *p;

	genHdr(file);
	if ( GenAST )
	{
		if ( !GenCC ) {
			_gen("#include \"ast.c\"\n");
			_gen("zzASTgvars\n\n");
		}
	}
	if ( !GenCC ) _gen("ANTLR_INFO\n");
	if ( BeforeActions != NULL )
	{
		for (p = BeforeActions->next; p!=NULL; p=p->next)
		{
			UserAction *ua = (UserAction *)p->elem;
			dumpAction( ua->action, output, 0, ua->file, ua->line, 1);
		}
	}

	if ( !FoundException ) return;

	if ( GenCC )
	{
		_gen1("\nvoid %s::\n", CurrentClassName);
		_gen("zzdflthandlers( int _signal, int *_retsignal )\n");
		_gen("{\n");
	}
	else
	{
		_gen("\nvoid\n");
/*  MR1				                                                        */
/*  MR1	10-Apr-97  133MR1	Replace __STDC__ with __USE_PROTOS              */
/*  MR1	                                                                    */
	    _gen("#ifdef __USE_PROTOS\n");                               /* MR1 */
		_gen("zzdflthandlers( int _signal, int *_retsignal )\n");
		_gen("#else\n");
		_gen("zzdflthandlers( _signal, _retsignal )\n");
		_gen("int _signal;\n");
		_gen("int *_retsignal;\n");
		_gen("#endif\n");
		_gen("{\n");
	}
	tabs++;
	if ( DefaultExGroup!=NULL )
	{
		dumpException(DefaultExGroup, 1);
		if ( !hasDefaultException(DefaultExGroup) )
		{
			gen("default :\n");
			tabs++;
			gen("*_retsignal = _signal;\n");
			tabs--;
			gen("}\n");
		}
	}
	else {
		gen("*_retsignal = _signal;\n");
	}

	tabs--;
	_gen("}\n\n");
}

void
#ifdef __USE_PROTOS
genStdPCCTSIncludeFile( FILE *f,char *gate )    /* MR10 */
#else
genStdPCCTSIncludeFile( f , gate)               /* MR10 */
FILE *f;
char * gate;                                    /* MR10 */
#endif
{
/* MR10 Ramanathan Santhanam (ps@kumaran.com)           */
/* MR10 Same preprocessor symbol use to gate stdpccts.h */
/* MR10   even when two grammars are in use.            */
/* MR10 Derive gate symbol from -fh filename            */

    if (gate == NULL) {
      fprintf(f,"#ifndef STDPCCTS_H\n");          /* MR10 */
      fprintf(f,"#define STDPCCTS_H\n");          /* MR10 */
    } else {
      fprintf(f,"#ifndef STDPCCTS_%s_H\n",gate);  /* MR10 */
      fprintf(f,"#define STDPCCTS_%s_H\n",gate);  /* MR10 */
    };
	fprintf(f,"/*\n");
    if (gate == NULL) {
	  fprintf(f," * %s -- P C C T S  I n c l u d e\n", stdpccts);
    } else {
	  fprintf(f," * Standard PCCTS include file with -fh %s -- P C C T S  I n c l u d e\n", stdpccts);
    }
	fprintf(f," *\n");
	fprintf(f," * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001\n");
	fprintf(f," * Purdue University Electrical Engineering\n");
	fprintf(f," * With AHPCRC, University of Minnesota\n");
	fprintf(f," * ANTLR Version %s\n", Version);
	fprintf(f," */\n\n");

    fprintf(f,"#ifndef ANTLR_VERSION\n");
	fprintf(f,"#define ANTLR_VERSION	%s\n", VersionDef);
    fprintf(f,"#endif\n\n");

    if (FirstAction != NULL ) dumpAction(FirstAction, f, 0, -1, 0, 1);  /* MR11 */

	fprintf(f,"#include \"pcctscfg.h\"\n");
	fprintf(f,"#include \"pccts_stdio.h\"\n");
	if ( GenCC )
	{
		if ( UserDefdTokens )
			fprintf(f, "#include %s\n", UserTokenDefsFile);
		else {
			fprintf(f, "#include \"%s\"\n", DefFileName);
		}

		fprintf(f, "#include \"%s\"\n", ATOKEN_H);

		if ( HdrAction != NULL ) dumpAction( HdrAction, f, 0, -1, 0, 1);

		fprintf(f, "#include \"%s\"\n", ATOKENBUFFER_H);

		if ( OutputLL_k > 1 ) fprintf(f,"static const unsigned LL_K=%d;\n", OutputLL_k);
		if ( GenAST ) {
			fprintf(f, "#include \"%s\"\n", ASTBASE_H);
		}

        if (TraceGen) {
          fprintf(f,"#ifndef zzTRACE_RULES\n");  /* MR20 */
          fprintf(f,"#define zzTRACE_RULES\n");  /* MR20 */
          fprintf(f,"#endif\n");                 /* MR22 */
        };

		fprintf(f,"#include \"%s\"\n", APARSER_H);
		fprintf(f,"#include \"%s.h\"\n", CurrentClassName);
		if ( LexGen ) fprintf(f,"#include \"%s\"\n", DLEXERBASE_H);
		fprintf(f, "#endif\n");
		return;
	}

	if ( strcmp(ParserName, DefaultParserName)!=0 )
		fprintf(f, "#define %s %s\n", DefaultParserName, ParserName);
	if ( strcmp(ParserName, DefaultParserName)!=0 )
		fprintf(f, "#include \"%s\"\n", RemapFileName);
	if ( UserTokenDefsFile != NULL )
	   fprintf(f, "#include %s\n", UserTokenDefsFile);
	if ( HdrAction != NULL ) dumpAction( HdrAction, f, 0, -1, 0, 1);
	if ( FoundGuessBlk )
	{
		fprintf(f,"#define ZZCAN_GUESS\n");
		fprintf(f,"#include \"pccts_setjmp.h\"\n");
	}
    if (TraceGen) {
      fprintf(f,"#ifndef zzTRACE_RULES\n");  /* MR20 */
      fprintf(f,"#define zzTRACE_RULES\n");  /* MR20 */
      fprintf(f,"#endif\n");                 /* MR22 */
    };
	if ( OutputLL_k > 1 ) fprintf(f,"#define LL_K %d\n", OutputLL_k);
	if ( GenAST ) fprintf(f,"#define GENAST\n");
	if ( FoundException )
	{
/* MR1	 7-Apr-97  1.33MR1					                           */
/* MR1	 	   Fix suggested by:				                   */
/* MR1		   Francois-Xavier Fontaine (fontaine_f@istvax.ist.lu)         */

		fprintf(f,"#define EXCEPTION_HANDLING\n");	            /* MR1 */
		fprintf(f,"#define NUM_SIGNALS %d\n", NumSignals);          /* MR1 */
	}
	if ( DemandLookahead ) fprintf(f,"#define DEMAND_LOOK\n");
#ifdef DUM
	if ( LexGen ) fprintf(f, "#define zzEOF_TOKEN %d\n", (TokenInd!=NULL?TokenInd[EofToken]:EofToken));
#endif
	/* ###WARNING: This will have to change when SetWordSize changes */
	fprintf(f, "#define zzSET_SIZE %d\n", NumWords(TokenNum-1)*sizeof(unsigned));
    if (TraceGen) {
      fprintf(f,"#ifndef zzTRACE_RULES\n");  /* MR20 */
      fprintf(f,"#define zzTRACE_RULES\n");  /* MR20 */
      fprintf(f,"#endif\n");                 /* MR22 */
    };
	fprintf(f,"#include \"antlr.h\"\n");
	if ( GenAST ) fprintf(f,"#include \"ast.h\"\n");
	if ( UserDefdTokens )
		fprintf(f, "#include %s\n", UserTokenDefsFile);
	/* still need this one as it has the func prototypes */
	fprintf(f, "#include \"%s\"\n", DefFileName);
	/* still need this one as it defines the DLG interface */
	fprintf(f,"#include \"dlgdef.h\"\n");
	/* don't need this one unless DLG is used */
	if ( LexGen ) fprintf(f,"#include \"%s\"\n", ModeFileName);
	fprintf(f,"#endif\n");
}

/* dump action 's' to file 'output' starting at "local" tab 'tabs'
   Dump line information in front of action if GenLineInfo is set
   If file == -1 then GenLineInfo is ignored.
   The user may redefine the LineInfoFormatStr to his/her liking
   most compilers will like the default, however.

   June '93; changed so that empty lines are left alone so that
   line information is correct for the compiler/debuggers.
*/
void
#ifdef __USE_PROTOS
dumpAction( char *s, FILE *output, int tabs, int file, int line,
int final_newline )
#else
dumpAction( s, output, tabs, file, line, final_newline )
char *s;
FILE *output;
int tabs;
int file;
int line;
int final_newline;
#endif
{
    int inDQuote, inSQuote;
    require(s!=NULL, 		"dumpAction: NULL action");
    require(output!=NULL,	eMsg1("dumpAction: output FILE is NULL for %s",s));

	if ( GenLineInfo && file != -1 )
	{
        OutLineInfo(output,line,FileStr[file]);
	}
    PastWhiteSpace( s );
	/* don't print a tab if first non-white char is a # (preprocessor command) */
	if ( *s!='#' ) {TAB;}
    inDQuote = inSQuote = FALSE;
    while ( *s != '\0' )
    {
        if ( *s == '\\' )
        {
            fputc( *s++, output ); /* Avoid '"' Case */
            if ( *s == '\0' ) return;
            if ( *s == '\'' ) fputc( *s++, output );
            if ( *s == '\"' ) fputc( *s++, output );
        }
        if ( *s == '\'' )
        {
            if ( !inDQuote ) inSQuote = !inSQuote;
        }
        if ( *s == '"' )
        {
            if ( !inSQuote ) inDQuote = !inDQuote;
        }
        if ( *s == '\n' )
        {
            fputc('\n', output);
			s++;
            PastWhiteSpace( s );
            if ( *s == '}' )
            {
                --tabs;
				TAB;
                fputc( *s++, output );
                continue;
            }
            if ( *s == '\0' ) return;
			if ( *s != '#' )	/* #define, #endif etc.. start at col 1 */
            {
				TAB;
			}
        }
        if ( *s == '}' && !(inSQuote || inDQuote) )
        {
            --tabs;            /* Indent one fewer */
        }
        if ( *s == '{' && !(inSQuote || inDQuote) )
        {
            tabs++;            /* Indent one more */
        }
        fputc( *s, output );
        s++;
    }
    if ( final_newline ) fputc('\n', output);
}

static void
#ifdef __USE_PROTOS
dumpAfterActions( FILE *output )
#else
dumpAfterActions( output )
FILE *output;
#endif
{
	ListNode *p;
	require(output!=NULL, "dumpAfterActions: output file was NULL for some reason");
	if ( AfterActions != NULL )
	{
		for (p = AfterActions->next; p!=NULL; p=p->next)
		{
			UserAction *ua = (UserAction *)p->elem;
			dumpAction( ua->action, output, 0, ua->file, ua->line, 1);
		}
	}
	fclose( output );
}

/*
 * Find the next action in the stream of execution.  Do not pass
 * junctions with more than one path leaving them.
 * Only pass generic junctions.
 *
 *	Scan forward while (generic junction with p2==NULL)
 *	If we stop on an action, return ptr to the action
 *	else return NULL;
 */
static ActionNode *
#ifdef __USE_PROTOS
findImmedAction( Node *q )
#else
findImmedAction( q )
Node *q;
#endif
{
	Junction *j;
	require(q!=NULL, "findImmedAction: NULL node");
	require(q->ntype>=1 && q->ntype<=NumNodeTypes, "findImmedAction: invalid node");
	
	while ( q->ntype == nJunction )
	{
		j = (Junction *)q;
		if ( j->jtype != Generic || j->p2 != NULL ) return NULL;
		q = j->p1;
		if ( q == NULL ) return NULL;
	}
	if ( q->ntype == nAction ) return (ActionNode *)q;
	return NULL;
}

static void
#ifdef __USE_PROTOS
dumpRetValAssign( char *retval, char *ret_def, RuleRefNode * ruleRef /* MR30 */)
#else
dumpRetValAssign( retval, ret_def, ruleRef /* MR30 */)
char *retval;
char *ret_def;
RuleRefNode *ruleRefNode;
#endif
{
	char *q = ret_def;
	
	tab();
	while ( *retval != '\0' && *q != '\0')
	{
		while ( isspace((*retval)) ) retval++;
		while ( *retval!=',' && *retval!='\0' ) fputc(*retval++, output);
		fprintf(output, " = _trv.");
		
		DumpNextNameInDef(&q, output);
		while ( isspace(*q) ) q++;
		fputc(';', output); fputc(' ', output);
		if ( *retval == ',' ) retval++;
	}
	if (*retval == '\0' && *q != '\0') {
/* MR30 */    errFL("Fewer output values than output formals for rule reference",
/* MR30 */                 FileStr[ruleRef->file],ruleRef->line);
	}
	if (*retval != '\0' && *q == '\0') {
/* MR30 */    errFL("More output actuals than output formals for rule reference",
/* MR30 */                 FileStr[ruleRef->file],ruleRef->line);
	}
}

/* This function computes the set of tokens that can possibly be seen k
 * tokens in the future from point j
 */

static set
#ifdef __USE_PROTOS
ComputeErrorSet( Junction *j, int k, int usePlusBlockBypass)
#else
ComputeErrorSet( j, k, usePlusBlockBypass )
Junction *j;
int k;
int usePlusBlockBypass;
#endif
{
	Junction *alt1;
	set a, rk, f;
	require(j->ntype==nJunction, "ComputeErrorSet: non junction passed");

	f = rk = empty;
	for (alt1=j; alt1!=NULL; alt1 = (Junction *)alt1->p2)
	{
        if (alt1->ignore && ! usePlusBlockBypass) continue;     /* MR21 - Ignore aPlusBlk forward p2 */
		REACH(alt1->p1, k, &rk, a);
		require(set_nil(rk), "ComputeErrorSet: rk != nil");
		set_free(rk);
		set_orin(&f, a);
		set_free(a);
	}
	return f;
}

static char *
#ifdef __USE_PROTOS
tokenFollowSet(TokNode *p)
#else
tokenFollowSet(p)
TokNode *p;
#endif
{
    static char buf[100];
    set rk, a;
    int n;
    rk = empty;

    REACH(p->next, 1, &rk, a);
    require(set_nil(rk), "rk != nil");
    set_free(rk);
    n = DefErrSet( &a, 0, NULL );
    set_free(a);
    if ( GenCC )
        sprintf(buf, "err%d", n);
    else
        sprintf(buf, "zzerr%d", n);
    return buf;
}

static void
#ifdef __USE_PROTOS
makeErrorClause( Junction *q, set f, int max_k, int usePlusBlockBypass )
#else
makeErrorClause( q, f, max_k, usePlusBlockBypass )
Junction *q;
set f;
int max_k;
int usePlusBlockBypass;
#endif
{
    char *  handler_id="";                                           /* MR7 */
    int     nilf=0;                                                  /* MR13 */
    RuleEntry *ruleEntry;                                            /* MR14 */

	if ( FoundException )
	{
		_gen("else {\n");
		tabs++;
		if ( FoundGuessBlk )
		{
			if ( GenCC ) {gen("if ( guessing ) goto fail;\n");}
			else gen("if ( zzguessing ) goto fail;\n");
		}
		gen("if (_sva) _signal=NoViableAlt;\n");
		gen("else _signal=NoSemViableAlt;\n");
        if (q->outerEG != NULL) {
          handler_id=q->outerEG->altID;
#if 0
        } else {
          printf("q->curAltNum=%d q->exception_label=%s\n",q->curAltNum,q->exception_label);
          gen("*** DEBUG *** outerEG==NULL\n");
#endif
        };
		gen1("goto %s_handler;  /* MR7 */\n",handler_id);    /* MR7 */
		tabs--;
		gen("}\n");
		return;
	}

	if ( max_k == 1 )
	{
/* MR13 */  nilf=set_nil(f);
    	  	if ( GenCC ) {
              _gen1("else {FAIL(1,err%d", DefErrSet1(1,&f,1,NULL));
            } else {
               _gen1("else {zzFAIL(1,zzerr%d", DefErrSet1(1,&f,1,NULL));
            };
    		set_free(f);
	}
	else
	{
		int i;
		set_free(f);
		if ( GenCC ) {_gen1("else {FAIL(%d", max_k);}
		else _gen1("else {zzFAIL(%d", max_k);

    ruleEntry = (RuleEntry *) hash_get(Rname,q->rname);

		for (i=1; i<=max_k; i++)
		{
/* MR14 */  if (ruleEntry->dontComputeErrorSet) {
/* MR14 */    f=empty;
            } else {
      	      f = ComputeErrorSet(q, i, usePlusBlockBypass /* use plus block bypass ? */ );
            }

      if ( GenCC ) {_gen1(",err%d", DefErrSet( &f, 1, NULL ));}
			else _gen1(",zzerr%d", DefErrSet( &f, 1, NULL ));
			
			set_free(f);
		}
	}
	_gen(",&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}\n");
/* MR13 */  if (nilf) {
/* MR13 */    errFL("empty error set for alt - probably because of undefined rule or infinite left recursion",
/* MR13 */                 FileStr[q->file],q->line);
/* MR13 */    gen(" /* MR13 empty error set for this alt - undef rule ? infinite left recursion ? */");
/* MR13 */  };
}

static                                                               /* MR7 */
#ifdef __USE_PROTOS
char * findOuterHandlerLabel(ExceptionGroup *eg)                     /* MR7 */
#else
char * findOuterHandlerLabel(eg)                                     /* MR7 */
ExceptionGroup *eg;                                                  /* MR7 */
#endif
{
  char              *label=NULL;                                     /* MR7 */
  ExceptionGroup    *outerEG;                                        /* MR7 */

  if (eg->forRule == 0) {                                            /* MR7 */
    if (eg->labelEntry != NULL) {                                    /* MR7 */
      outerEG=eg->labelEntry->outerEG;                               /* MR7 */
      if (outerEG != NULL) {                                         /* MR7 */
        label=outerEG->altID;                                        /* MR7 */
        outerEG->used=1;                                             /* MR7 */
      };                                                             /* MR7 */
    } else if (eg->outerEG != NULL) {                                /* MR7 */
      outerEG=eg->outerEG;                                           /* MR7 */
      label=outerEG->altID;                                          /* MR7 */
      outerEG->used=1;                                               /* MR7 */
    };                                                               /* MR7 */
  };                                                                 /* MR7 */
  return (label==NULL ? "" : label);                                 /* MR7 */
}                                                                    /* MR7 */

/*** debug ***/
#if 0
** static                                                               /* MR7 */
** #ifdef __USE_PROTOS
** char * findOuterAltHandlerLabel(Junction *startJ)                    /* MR7 */
** #else
** char * findOuterAltHandlerLabel(startJ)                              /* MR7 */
** Junction *startJ;                                                    /* MR7 */
** #endif
** {                                                                    /* MR7 */
**   char      *label=NULL;                                             /* MR7 */
**   Junction  *alt;                                                    /* MR7 */
**                                                                      /* MR7 */
**   for (alt=startJ; alt != NULL; alt=alt->outerAltstart) {            /* MR7 */
**     label=alt->exception_label;                                      /* MR7 */
**     if (label != NULL) break;                                        /* MR7 */
**   };                                                                 /* MR7 */
**   return (label==NULL ? "" : label);                                 /* MR7 */
** }                                                                    /* MR7 */
#endif

#ifdef __USE_PROTOS
static void OutLineInfo(FILE *file,int line,char *fileName)
#else
static void OutLineInfo(file,line,fileName)
  FILE *    file;
  int       line;
  char *    fileName;
#endif
{
    static  char * prevFileName=NULL;
    static  char * prevFileNameMS=NULL;

    char *  p;
    char *  q;

    if (! GenLineInfo) return;

    if (!GenLineInfoMS) {
	    fprintf(file, LineInfoFormatStr,line,fileName);
    } else {
      if (fileName == prevFileName) {
	    fprintf(file, LineInfoFormatStr,line,prevFileNameMS);
      } else {
        if (prevFileNameMS != NULL) free (prevFileNameMS);
        prevFileNameMS=(char *)calloc(1,strlen(fileName)+1);
        require(prevFileNameMS != NULL,"why not do this in calloc wrapper");
        q=prevFileNameMS;
        for (p=fileName; *p != 0; p++) {
            *q=*p;
            if (*q == '\\') *q='/';
            q++;
        }
      }
      prevFileName=fileName;
    };
}

#if 0

/* MR21 */

#ifdef __USE_PROTOS
void OutFirstSetSymbol(Junction *q, char * pSymbol)
#else
void OutFirstSetSymbol(q, pSymbol)
    Junction* q;
	char * pSymbol
#endif
{

	set f;
    if (pSymbol == NULL) return;
	gen1("/** #FirstSetSymbol(%s) **/\n",pSymbol);
    f = ComputeErrorSet(q, 1, 0 /* use plus block bypass ? */);
    DefErrSetWithSuffix (0 /* nil ok */, &f,0 /* no substitute */, pSymbol, "");
    set_free(f);
}
#endif

/* MR21 */

#ifdef __USE_PROTOS
void BlockPreambleOption(Junction *q, char * pSymbol)
#else
void BlockPreambleOption(q, pSymbol)
    Junction* q;
	char * pSymbol;
#endif
{
	set f = empty;
    if (pSymbol != NULL) {
        f = ComputeErrorSet(q, 1, 0 /* use plus block bypass ? */);
    	gen1("/** #FirstSetSymbol(%s) **/\n",pSymbol);
        DefErrSetWithSuffix (0 /* nil ok */, &f,0 /* no substitute */, pSymbol, "");
    }
    set_free(f);
}

/* MR21 */

void
#ifdef __USE_PROTOS
dumpActionPlus(ActionNode *a, char *s, FILE *output, int tabs, int file, int line,
int final_newline )
#else
dumpActionPlus(a, s, output, tabs, file, line, final_newline )
ActionNode *a;
char *s;
FILE *output;
int tabs;
int file;
int line;
int final_newline;
#endif
{
    dumpAction(s,output,tabs,file,line,final_newline);
}


#if 0
** #ifdef __USE_PROTOS
** void MR_ErrorSets(Junction *q, int max_k, int usePlusBlockBypass)
** #else
** void MR_ErrorSets(q, max_k, usePlusBlockBypass)
** Junction *q;
** int max_k;
** int usePlusBlockBypass;
** #endif
** {
**     int k;
**     set setResult;
** 	Junction* alt1;
** 	Junction* p;
** 	set rk;
** 
**     require (max_k <= CLL_k, "k > CLL_k");
** 
** 
**     for (k = 1; k <= CLL_k; k++) {set_clr(q->fset[k]); }
** 
**     for (k = 1; k <= max_k; k++) {
**         for (alt1=q; alt1 != NULL; alt1 = (Junction *)alt1->p2)
**     	{
**             if (alt1->ignore && ! usePlusBlockBypass) continue;
**         	p = analysis_point((Junction *)alt1->p1);
**     		REACH(p, k, &rk, setResult);
**     		require(set_nil(rk), "rk != nil");
**             set_orin(&q->fset[k], setResult);
**     	}
**     }
** }
#endif


#ifdef __USE_PROTOS
void DumpInitializers(FILE* output, RuleEntry *r, char * pReturn)
#else
void DumpInitializers(output, r, pReturn)
FILE* output;
RuleEntry *r;
char * pReturn;
#endif
{
	char *p = pReturn;
	char *pDataType;
	char *pSymbol;
	char *pEqualSign;
	char *pValue;
	char *pSeparator;
	int nest = 0;
    char *q;

	require(pReturn!=NULL, "DumpInitializer: invalid string"); 

    while (*p != 0) {
    	p = endFormal(p,
    			      &pDataType,
    				  &pSymbol,
    				  &pEqualSign,
    				  &pValue,
    				  &pSeparator,
    				  &nest);
        if (nest != 0) return;
        if (pValue != NULL) {
			tab();
            q = strBetween(pSymbol, pEqualSign, pSeparator);
            fprintf(output, "_retv.%s", q);
            q = strBetween(pValue, NULL, pSeparator);
            fprintf(output, " = %s;\n", q);
        }
    }
}

#ifdef __USE_PROTOS
void DumpFormals(FILE* output, char * pReturn, int bInitializer)
#else
void DumpFormals(output, pReturn, bInitializer)
FILE* output;
char * pReturn;
int bInitializer;
#endif
{
	char *p = pReturn;
	char *pDataType;
	char *pSymbol;
	char *pEqualSign;
	char *pValue;
	char *pSeparator;
	int nest = 0;
    char *q;
    int count = 0;

	require(pReturn!=NULL, "DumpFormals: invalid string"); 

    while (*p != 0) {
    	p = endFormal(p,
    			      &pDataType,
    				  &pSymbol,
    				  &pEqualSign,
    				  &pValue,
    				  &pSeparator,
    				  &nest);
        if (nest != 0) return;
        if (count > 0) fprintf(output,",");
        if (pDataType != NULL && pSymbol != NULL) {
            q = strBetween(pDataType, pSymbol, pSeparator);
            fprintf(output, "%s", q);
            q = strBetween(pSymbol, pEqualSign, pSeparator);
            fprintf(output," %s",q);
            if (pValue != NULL) {
                q = strBetween(pValue, NULL, pSeparator);
                if (bInitializer != 0) {
                    fprintf(output, " = %s", q);
                }
            }
        }
        count++;
    }
}

/* MR23 Check for empty alt in a more intelligent way.
        Previously, an empty alt for genBlk had to point directly
		to the endBlock.  This did not work once I changed {...}
		blocks to look like (...|...| epsilon) since there were
		intervening generics.  This fixes the problem for this
		particular case.  Things like actions or empty blocks of
		various kinds will still cause problems, but I wasnt't
		prepared to handle pathological cases like (A|()*). It
		does handle (A | ()), which is a recommended idiom for
		epsilon.

        Actually, this isn't quite correct since it doesn't handle
		the case of the ignore bit in the plus block bypass, but
		I'm too tired to figure out the correct fix, and will just
		work around it.
*/

#ifdef __USE_PROTOS
int isEmptyAlt(Node * alt, Node * endBlock)
#else
int isEmptyAlt(alt, endBlock)
Node * alt;
Node * endBlock;
#endif
{
	Node * n = alt;
	Junction * j;
	while (n != endBlock) {
		switch (n->ntype) {

			case nRuleRef:
				return 0;

			case nToken:
				return 0;

			case nAction:
				return 0;

			case nJunction:
				goto JUNCTION;

			default:
				fatal_internal("Invalid node type");
				return 0;
		}
JUNCTION:
		j = (Junction *) n;

		switch (j->jtype) {
			case Generic:
				{
					n = j->p1;
					goto NEXT;
				}

			case aSubBlk:
				{
					n = j->p1;	/* MR26 */
					goto NEXT;	/* MR26 */
				}

			case EndBlk:
					return 0;

			case EndRule:
					return 1;

			default:
					return 0;
		}
NEXT: continue;
	}
	return 1;
}