/* | |
* 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; | |
} |