<< | |
/* parser.dlg -- DLG Description of scanner | |
* | |
* Generated from: antlr.g | |
* | |
* Terence Parr, Will Cohen, and Hank Dietz: 1989-2001 | |
* Purdue University Electrical Engineering | |
* With AHPCRC, University of Minnesota | |
* ANTLR Version 1.33MR33 | |
*/ | |
#define ANTLR_VERSION 13333 | |
#include "pcctscfg.h" | |
#include "pccts_stdio.h" | |
#include "pcctscfg.h" | |
#include "set.h" | |
#include <ctype.h> | |
#include "syn.h" | |
#include "hash.h" | |
#include "generic.h" | |
#define zzcr_attr(attr,tok,t) | |
#include "antlr.h" | |
#include "tokens.h" | |
#include "dlgdef.h" | |
LOOKAHEAD | |
void | |
#ifdef __USE_PROTOS | |
zzerraction(void) | |
#else | |
zzerraction() | |
#endif | |
{ | |
(*zzerr)("invalid token"); | |
zzadvance(); | |
zzskip(); | |
} | |
>> | |
<<%%lexaction | |
/* maintained, but not used for now */ | |
set AST_nodes_refd_in_actions = set_init; | |
int inAlt = 0; | |
set attribsRefdFromAction = set_init; /* MR20 */ | |
int UsedOldStyleAttrib = 0; | |
int UsedNewStyleLabel = 0; | |
#ifdef __USE_PROTOS | |
char *inline_set(char *); | |
#else | |
char *inline_set(); | |
#endif | |
/* MR1 10-Apr-97 MR1 Previously unable to put right shift operator */ | |
/* MR1 in DLG action */ | |
int tokenActionActive=0; /* MR1 */ | |
>> | |
<<%%lexaction | |
static char * | |
#ifdef __USE_PROTOS | |
getFileNameFromTheLineInfo(char *toStr, char *fromStr) | |
#else | |
getFileNameFromTheLineInfo(toStr, fromStr) | |
char *toStr, *fromStr; | |
#endif | |
{ | |
int i, j, k; | |
if (!fromStr || !toStr) return toStr; | |
/* find the first " */ | |
for (i=0; | |
(i<MaxFileName) && | |
(fromStr[i] != '\n') && | |
(fromStr[i] != '\r') && | |
(fromStr[i] != '\"'); | |
i++) /* nothing */ ; | |
if ( (i == MaxFileName) || | |
(fromStr[i] == '\n') || | |
(fromStr[i] == '\r') ) { | |
return toStr; | |
} | |
/* find the second " */ | |
for (j=i+1; | |
(j<MaxFileName) && | |
(fromStr[j] != '\n') && | |
(fromStr[j] != '\r') && | |
(fromStr[j] != '\"'); | |
j++) /* nothing */ ; | |
if ((j == MaxFileName) || | |
(fromStr[j] == '\n') || | |
(fromStr[j] == '\r') ) { | |
return toStr; | |
} | |
/* go back until the last / or \ */ | |
for (k=j-1; | |
(fromStr[k] != '\"') && | |
(fromStr[k] != '/') && | |
(fromStr[k] != '\\'); | |
k--) /* nothing */ ; | |
/* copy the string after " / or \ into toStr */ | |
for (i=k+1; fromStr[i] != '\"'; i++) { | |
toStr[i-k-1] = fromStr[i]; | |
} | |
toStr[i-k-1] = '\0'; | |
return toStr; | |
} | |
/* MR14 end of a block to support #line in antlr source code */ | |
>> | |
<<%%lexaction | |
#ifdef __USE_PROTOS | |
void mark_label_used_in_sem_pred(LabelEntry *le) /* MR10 */ | |
#else | |
void mark_label_used_in_sem_pred(le) /* MR10 */ | |
LabelEntry *le; | |
#endif | |
{ | |
TokNode *tn; | |
require (le->elem->ntype == nToken,"mark_label_used... ntype != nToken"); | |
tn=(TokNode *)le->elem; | |
require (tn->label != 0,"mark_label_used... TokNode has no label"); | |
tn->label_used_in_semantic_pred=1; | |
} | |
>> | |
%%START | |
@ | |
<< | |
NLA = Eof; | |
/* L o o k F o r A n o t h e r F i l e */ | |
{ | |
FILE *new_input; | |
new_input = NextFile(); | |
if ( new_input == NULL ) { NLA=Eof; return; } | |
fclose( input ); | |
input = new_input; | |
zzrdstream( input ); | |
zzskip(); /* Skip the Eof (@) char i.e continue */ | |
} | |
>> | |
[\t\ ]+ | |
<< | |
NLA = 76; | |
zzskip(); | |
>> | |
\n|\r|\r\n | |
<< | |
NLA = 77; | |
zzline++; zzskip(); | |
>> | |
\[ | |
<< | |
NLA = 78; | |
zzmode(ACTIONS); zzmore(); | |
istackreset(); | |
pushint(']'); | |
>> | |
\<\< | |
<< | |
NLA = 79; | |
action_file=CurFile; action_line=zzline; | |
zzmode(ACTIONS); zzmore(); | |
list_free(&CurActionLabels,0); /* MR10 */ | |
numericActionLabel=0; /* MR10 */ | |
istackreset(); | |
pushint('>'); | |
>> | |
\" | |
<< | |
NLA = 80; | |
zzmode(STRINGS); zzmore(); | |
>> | |
/\* | |
<< | |
NLA = 81; | |
zzmode(COMMENTS); zzskip(); | |
>> | |
\*/ | |
<< | |
NLA = 82; | |
warn("Missing /*; found dangling */"); zzskip(); | |
>> | |
// | |
<< | |
NLA = 83; | |
zzmode(CPP_COMMENTS); zzskip(); | |
>> | |
#line[\ \t]* [0-9]+ {[\ \t]* \"~[\"]+\" ([\ \t]* [0-9]*)* } (\n|\r|\r\n) | |
<< | |
NLA = 84; | |
zzline = atoi(zzbegexpr+5) - 1; zzline++; zzmore(); | |
getFileNameFromTheLineInfo(FileStr[CurFile], zzbegexpr); | |
>> | |
#line ~[\n\r]* (\n|\r|\r\n) | |
<< | |
NLA = 85; | |
zzline++; zzmore(); | |
>> | |
\>\> | |
<< | |
NLA = 86; | |
warn("Missing <<; found dangling \>\>"); zzskip(); | |
>> | |
. | |
<< | |
NLA = WildCard; | |
>> | |
\@ | |
<< | |
NLA = 88; | |
FoundException = 1; /* MR6 */ | |
FoundAtOperator = 1; | |
>> | |
{\\}#pragma | |
<< | |
NLA = Pragma; | |
>> | |
{\\}#FirstSetSymbol | |
<< | |
NLA = FirstSetSymbol; | |
>> | |
{\\}#header | |
<< | |
NLA = 94; | |
>> | |
{\\}#first | |
<< | |
NLA = 95; | |
>> | |
{\\}#parser | |
<< | |
NLA = 96; | |
>> | |
{\\}#tokdefs | |
<< | |
NLA = 97; | |
>> | |
\} | |
<< | |
NLA = 98; | |
>> | |
class | |
<< | |
NLA = 99; | |
>> | |
\{ | |
<< | |
NLA = 102; | |
>> | |
! | |
<< | |
NLA = 103; | |
>> | |
\< | |
<< | |
NLA = 104; | |
>> | |
\> | |
<< | |
NLA = 105; | |
>> | |
: | |
<< | |
NLA = 106; | |
>> | |
; | |
<< | |
NLA = 107; | |
>> | |
{\\}#lexaction | |
<< | |
NLA = 108; | |
>> | |
{\\}#lexmember | |
<< | |
NLA = 109; | |
>> | |
{\\}#lexprefix | |
<< | |
NLA = 110; | |
>> | |
{\\}#pred | |
<< | |
NLA = 111; | |
>> | |
\|\| | |
<< | |
NLA = 112; | |
>> | |
&& | |
<< | |
NLA = 113; | |
>> | |
\( | |
<< | |
NLA = 114; | |
>> | |
\) | |
<< | |
NLA = 115; | |
>> | |
{\\}#lexclass | |
<< | |
NLA = 116; | |
>> | |
{\\}#errclass | |
<< | |
NLA = 117; | |
>> | |
{\\}#tokclass | |
<< | |
NLA = 118; | |
>> | |
.. | |
<< | |
NLA = 119; | |
>> | |
{\\}#token | |
<< | |
NLA = 120; | |
>> | |
= | |
<< | |
NLA = 121; | |
>> | |
[0-9]+ | |
<< | |
NLA = 122; | |
>> | |
\| | |
<< | |
NLA = 123; | |
>> | |
\~ | |
<< | |
NLA = 124; | |
>> | |
^ | |
<< | |
NLA = 125; | |
>> | |
approx | |
<< | |
NLA = 126; | |
>> | |
LL\(1\) | |
<< | |
NLA = 127; | |
>> | |
LL\(2\) | |
<< | |
NLA = 128; | |
>> | |
\* | |
<< | |
NLA = 129; | |
>> | |
\+ | |
<< | |
NLA = 130; | |
>> | |
? | |
<< | |
NLA = 131; | |
>> | |
=> | |
<< | |
NLA = 132; | |
>> | |
exception | |
<< | |
NLA = 133; | |
>> | |
default | |
<< | |
NLA = 134; | |
>> | |
catch | |
<< | |
NLA = 135; | |
>> | |
[a-z] [A-Za-z0-9_]* | |
<< | |
NLA = NonTerminal; | |
while ( zzchar==' ' || zzchar=='\t' ) { | |
zzadvance(); | |
} | |
if ( zzchar == ':' && inAlt ) NLA = LABEL; | |
>> | |
[A-Z] [A-Za-z0-9_]* | |
<< | |
NLA = TokenTerm; | |
while ( zzchar==' ' || zzchar=='\t' ) { | |
zzadvance(); | |
} | |
if ( zzchar == ':' && inAlt ) NLA = LABEL; | |
>> | |
{\\}#[A-Za-z0-9_]* | |
<< | |
NLA = 136; | |
warn(eMsg1("unknown meta-op: %s",LATEXT(1))); zzskip(); | |
>> | |
%%STRINGS | |
@ | |
<< | |
NLA = Eof; | |
>> | |
\" | |
<< | |
NLA = QuotedTerm; | |
zzmode(START); | |
>> | |
\n|\r|\r\n | |
<< | |
NLA = 3; | |
zzline++; | |
warn("eoln found in string"); | |
zzskip(); | |
>> | |
\\(\n|\r|\r\n) | |
<< | |
NLA = 4; | |
zzline++; zzmore(); | |
>> | |
\\~[] | |
<< | |
NLA = 5; | |
zzmore(); | |
>> | |
~[\n\r\"\\]+ | |
<< | |
NLA = 6; | |
zzmore(); | |
>> | |
%%ACTION_STRINGS | |
@ | |
<< | |
NLA = Eof; | |
>> | |
\" | |
<< | |
NLA = 7; | |
zzmode(ACTIONS); zzmore(); | |
>> | |
\n|\r|\r\n | |
<< | |
NLA = 8; | |
zzline++; | |
warn("eoln found in string (in user action)"); | |
zzskip(); | |
>> | |
\\(\n|\r|\r\n) | |
<< | |
NLA = 9; | |
zzline++; zzmore(); | |
>> | |
\\~[] | |
<< | |
NLA = 10; | |
zzmore(); | |
>> | |
~[\n\r\"\\]+ | |
<< | |
NLA = 11; | |
zzmore(); | |
>> | |
%%ACTION_CHARS | |
@ | |
<< | |
NLA = Eof; | |
>> | |
' | |
<< | |
NLA = 12; | |
zzmode(ACTIONS); zzmore(); | |
>> | |
\n|\r|\r\n | |
<< | |
NLA = 13; | |
zzline++; | |
warn("eoln found in char literal (in user action)"); | |
zzskip(); | |
>> | |
\\~[] | |
<< | |
NLA = 14; | |
zzmore(); | |
>> | |
~[\n\r'\\]+ | |
<< | |
NLA = 15; | |
zzmore(); | |
>> | |
%%ACTION_COMMENTS | |
@ | |
<< | |
NLA = Eof; | |
>> | |
\*/ | |
<< | |
NLA = 16; | |
zzmode(ACTIONS); zzmore(); | |
>> | |
\* | |
<< | |
NLA = 17; | |
zzmore(); | |
>> | |
\n|\r|\r\n | |
<< | |
NLA = 18; | |
zzline++; zzmore(); DAWDLE; | |
>> | |
~[\n\r\*]+ | |
<< | |
NLA = 19; | |
zzmore(); | |
>> | |
%%TOK_DEF_COMMENTS | |
@ | |
<< | |
NLA = Eof; | |
>> | |
\*/ | |
<< | |
NLA = 20; | |
zzmode(PARSE_ENUM_FILE); | |
zzmore(); | |
>> | |
\* | |
<< | |
NLA = 21; | |
zzmore(); | |
>> | |
\n|\r|\r\n | |
<< | |
NLA = 22; | |
zzline++; zzmore(); DAWDLE; | |
>> | |
~[\n\r\*]+ | |
<< | |
NLA = 23; | |
zzmore(); | |
>> | |
%%TOK_DEF_CPP_COMMENTS | |
@ | |
<< | |
NLA = Eof; | |
>> | |
\n|\r|\r\n | |
<< | |
NLA = 24; | |
zzline++; zzmode(PARSE_ENUM_FILE); zzskip(); DAWDLE; | |
>> | |
~[\n\r]+ | |
<< | |
NLA = 25; | |
zzskip(); | |
>> | |
%%ACTION_CPP_COMMENTS | |
@ | |
<< | |
NLA = Eof; | |
>> | |
\n|\r|\r\n | |
<< | |
NLA = 26; | |
zzline++; zzmode(ACTIONS); zzmore(); DAWDLE; | |
>> | |
~[\n\r]+ | |
<< | |
NLA = 27; | |
zzmore(); | |
>> | |
%%CPP_COMMENTS | |
@ | |
<< | |
NLA = Eof; | |
>> | |
\n|\r|\r\n | |
<< | |
NLA = 28; | |
zzline++; zzmode(START); zzskip(); DAWDLE; | |
>> | |
~[\n\r]+ | |
<< | |
NLA = 29; | |
zzskip(); | |
>> | |
%%COMMENTS | |
@ | |
<< | |
NLA = Eof; | |
>> | |
\*/ | |
<< | |
NLA = 30; | |
zzmode(START); zzskip(); | |
>> | |
\* | |
<< | |
NLA = 31; | |
zzskip(); | |
>> | |
\n|\r|\r\n | |
<< | |
NLA = 32; | |
zzline++; zzskip(); DAWDLE; | |
>> | |
~[\n\r\*]+ | |
<< | |
NLA = 33; | |
zzskip(); | |
>> | |
%%ACTIONS | |
@ | |
<< | |
NLA = Eof; | |
>> | |
\>\> | |
<< | |
NLA = Action; | |
/* these do not nest */ | |
zzmode(START); | |
NLATEXT[0] = ' '; | |
NLATEXT[1] = ' '; | |
zzbegexpr[0] = ' '; | |
zzbegexpr[1] = ' '; | |
if ( zzbufovf ) { | |
err( eMsgd("action buffer overflow; size %d",ZZLEXBUFSIZE)); | |
} | |
/* MR1 10-Apr-97 MR1 Previously unable to put right shift operator */ | |
/* MR1 in DLG action */ | |
/* MR1 Doesn't matter what kind of action it is - reset*/ | |
tokenActionActive=0; /* MR1 */ | |
>> | |
\>\>? | |
<< | |
NLA = Pred; | |
/* these do not nest */ | |
zzmode(START); | |
NLATEXT[0] = ' '; | |
NLATEXT[1] = ' '; | |
zzbegexpr[0] = '\0'; | |
if ( zzbufovf ) { | |
err( eMsgd("predicate buffer overflow; size %d",ZZLEXBUFSIZE)); | |
}; | |
#ifdef __cplusplus__ | |
/* MR10 */ list_apply(CurActionLabels, (void (*)(void *))mark_label_used_in_sem_pred); | |
#else | |
#ifdef __STDC__ | |
/* MR10 */ list_apply(CurActionLabels, (void (*)(void *))mark_label_used_in_sem_pred); | |
#else | |
#ifdef __USE_PROTOS | |
/* MRxx */ list_apply(CurActionLabels, (void (*)(void *))mark_label_used_in_sem_pred); | |
#else | |
/* MR10 */ list_apply(CurActionLabels,mark_label_used_in_sem_pred); | |
#endif | |
#endif | |
#endif | |
>> | |
\] | |
<< | |
NLA = PassAction; | |
if ( topint() == ']' ) { | |
popint(); | |
if ( istackempty() ) /* terminate action */ | |
{ | |
zzmode(START); | |
NLATEXT[0] = ' '; | |
zzbegexpr[0] = ' '; | |
if ( zzbufovf ) { | |
err( eMsgd("parameter buffer overflow; size %d",ZZLEXBUFSIZE)); | |
} | |
} | |
else { | |
/* terminate $[..] and #[..] */ | |
if ( GenCC ) zzreplstr("))"); | |
else zzreplstr(")"); | |
zzmore(); | |
} | |
} | |
else if ( topint() == '|' ) { /* end of simple [...] */ | |
popint(); | |
zzmore(); | |
} | |
else zzmore(); | |
>> | |
consumeUntil\( [\ \t]* \{~[\}]+\} [\ \t]* \) | |
<< | |
NLA = 37; | |
zzmore(); | |
zzreplstr(inline_set(zzbegexpr+ | |
strlen("consumeUntil("))); | |
>> | |
consumeUntil\( ~[\)]+ \) | |
<< | |
NLA = 38; | |
zzmore(); | |
>> | |
\n|\r|\r\n | |
<< | |
NLA = 39; | |
zzline++; zzmore(); DAWDLE; | |
>> | |
\> | |
<< | |
NLA = 40; | |
zzmore(); | |
>> | |
$ | |
<< | |
NLA = 41; | |
zzmore(); | |
>> | |
$$ | |
<< | |
NLA = 42; | |
if ( !GenCC ) {zzreplstr("zzaRet"); zzmore();} | |
else err("$$ use invalid in C++ mode"); | |
>> | |
$\[\] | |
<< | |
NLA = 43; | |
if ( !GenCC ) {zzreplstr("zzempty_attr"); zzmore();} | |
else err("$[] use invalid in C++ mode"); | |
>> | |
$\[ | |
<< | |
NLA = 44; | |
pushint(']'); | |
if ( !GenCC ) zzreplstr("zzconstr_attr("); | |
else err("$[..] use invalid in C++ mode"); | |
zzmore(); | |
>> | |
$[0-9]+ | |
<< | |
NLA = 45; | |
{ | |
static char buf[100]; | |
numericActionLabel=1; /* MR10 */ | |
if ( strlen(zzbegexpr)>(size_t)85 ) | |
fatal("$i attrib ref too big"); | |
set_orel(atoi(zzbegexpr+1), &attribsRefdFromAction); | |
if ( !GenCC ) sprintf(buf,"zzaArg(zztasp%d,%s)", | |
BlkLevel-1,zzbegexpr+1); | |
else sprintf(buf,"_t%d%s", | |
BlkLevel-1,zzbegexpr+1); | |
zzreplstr(buf); | |
zzmore(); | |
UsedOldStyleAttrib = 1; | |
if ( UsedNewStyleLabel ) | |
err("cannot mix old-style $i with new-style labels"); | |
} | |
>> | |
$[0-9]+. | |
<< | |
NLA = 46; | |
{ | |
static char buf[100]; | |
numericActionLabel=1; /* MR10 */ | |
if ( strlen(zzbegexpr)>(size_t)85 ) | |
fatal("$i.field attrib ref too big"); | |
zzbegexpr[strlen(zzbegexpr)-1] = ' '; | |
set_orel(atoi(zzbegexpr+1), &attribsRefdFromAction); | |
if ( !GenCC ) sprintf(buf,"zzaArg(zztasp%d,%s).", | |
BlkLevel-1,zzbegexpr+1); | |
else sprintf(buf,"_t%d%s.", | |
BlkLevel-1,zzbegexpr+1); | |
zzreplstr(buf); | |
zzmore(); | |
UsedOldStyleAttrib = 1; | |
if ( UsedNewStyleLabel ) | |
err("cannot mix old-style $i with new-style labels"); | |
} | |
>> | |
$[0-9]+.[0-9]+ | |
<< | |
NLA = 47; | |
{ | |
static char buf[100]; | |
static char i[20], j[20]; | |
char *p,*q; | |
numericActionLabel=1; /* MR10 */ | |
if (strlen(zzbegexpr)>(size_t)85) fatal("$i.j attrib ref too big"); | |
for (p=zzbegexpr+1,q= &i[0]; *p!='.'; p++) { | |
if ( q == &i[20] ) | |
fatalFL("i of $i.j attrib ref too big", | |
FileStr[CurFile], zzline ); | |
*q++ = *p; | |
} | |
*q = '\0'; | |
for (p++, q= &j[0]; *p!='\0'; p++) { | |
if ( q == &j[20] ) | |
fatalFL("j of $i.j attrib ref too big", | |
FileStr[CurFile], zzline ); | |
*q++ = *p; | |
} | |
*q = '\0'; | |
if ( !GenCC ) sprintf(buf,"zzaArg(zztasp%s,%s)",i,j); | |
else sprintf(buf,"_t%s%s",i,j); | |
zzreplstr(buf); | |
zzmore(); | |
UsedOldStyleAttrib = 1; | |
if ( UsedNewStyleLabel ) | |
err("cannot mix old-style $i with new-style labels"); | |
} | |
>> | |
$[_a-zA-Z][_a-zA-Z0-9]* | |
<< | |
NLA = 48; | |
{ static char buf[300]; LabelEntry *el; | |
zzbegexpr[0] = ' '; | |
if ( CurRule != NULL && | |
strcmp(CurRule, &zzbegexpr[1])==0 ) { | |
if ( !GenCC ) zzreplstr("zzaRet"); | |
} | |
else if ( CurRetDef != NULL && | |
strmember(CurRetDef, &zzbegexpr[1])) { | |
if ( hasMultipleOperands( CurRetDef ) ) { | |
require (strlen(zzbegexpr)<=(size_t)285, | |
"$retval attrib ref too big"); | |
sprintf(buf,"_retv.%s",&zzbegexpr[1]); | |
zzreplstr(buf); | |
} | |
else zzreplstr("_retv"); | |
} | |
else if ( CurParmDef != NULL && | |
strmember(CurParmDef, &zzbegexpr[1])) { | |
; | |
} | |
else if ( Elabel==NULL ) { | |
{ err("$-variables in actions outside of rules are not allowed"); } | |
} else if ( (el=(LabelEntry *)hash_get(Elabel, &zzbegexpr[1]))!=NULL ) { | |
/* MR10 */ | |
/* MR10 */ /* element labels might exist without an elem when */ | |
/* MR10 */ /* it is a forward reference (to a rule) */ | |
/* MR10 */ | |
/* MR10 */ if ( GenCC && (el->elem == NULL || el->elem->ntype==nRuleRef) ) | |
/* MR10 */ { err(eMsg1("There are no token ptrs for rule references: '$%s'",&zzbegexpr[1])); } | |
/* MR10 */ | |
/* MR10 */ if ( !GenCC && (el->elem == NULL || el->elem->ntype==nRuleRef) && GenAST) { | |
/* MR10 */ err("You can no longer use attributes returned by rules when also using ASTs"); | |
/* MR10 */ err(" Use upward inheritance (\"rule >[Attrib a] : ... <<$a=...\>\>\")"); | |
/* MR10 */ }; | |
/* MR10 */ | |
/* MR10 */ /* keep track of <<... $label ...>> for semantic predicates in guess mode */ | |
/* MR10 */ /* element labels contain pointer to the owners node */ | |
/* MR10 */ | |
/* MR10 */ if (el->elem != NULL && el->elem->ntype == nToken) { | |
/* MR10 */ list_add(&CurActionLabels,el); | |
/* MR10 */ }; | |
} | |
else | |
warn(eMsg1("$%s not parameter, return value, (defined) element label",&zzbegexpr[1])); | |
} | |
zzmore(); | |
>> | |
#0 | |
<< | |
NLA = 49; | |
zzreplstr("(*_root)"); zzmore(); chkGTFlag(); | |
>> | |
#\[\] | |
<< | |
NLA = 50; | |
if ( GenCC ) { | |
if (NewAST) zzreplstr("(newAST)"); | |
else zzreplstr("(new AST)");} | |
else {zzreplstr("zzastnew()");} zzmore(); | |
chkGTFlag(); | |
>> | |
#\(\) | |
<< | |
NLA = 51; | |
zzreplstr("NULL"); zzmore(); chkGTFlag(); | |
>> | |
#[0-9]+ | |
<< | |
NLA = 52; | |
{ | |
static char buf[100]; | |
if ( strlen(zzbegexpr)>(size_t)85 ) | |
fatal("#i AST ref too big"); | |
if ( GenCC ) sprintf(buf,"_ast%d%s",BlkLevel-1,zzbegexpr+1); | |
else sprintf(buf,"zzastArg(%s)",zzbegexpr+1); | |
zzreplstr(buf); | |
zzmore(); | |
set_orel(atoi(zzbegexpr+1), &AST_nodes_refd_in_actions); | |
chkGTFlag(); | |
} | |
>> | |
#line[\ \t]* [0-9]+ {[\ \t]* \"~[\"]+\" ([\ \t]* [0-9]*)* } (\n|\r|\r\n) | |
<< | |
NLA = 53; | |
zzline = atoi(zzbegexpr+5) - 1; zzline++; zzmore(); | |
getFileNameFromTheLineInfo(FileStr[CurFile], zzbegexpr); | |
>> | |
#line ~[\n\r]* (\n|\r|\r\n) | |
<< | |
NLA = 54; | |
zzline++; zzmore(); | |
>> | |
#[_a-zA-Z][_a-zA-Z0-9]* | |
<< | |
NLA = 55; | |
if ( !(strcmp(zzbegexpr, "#ifdef")==0 || | |
strcmp(zzbegexpr, "#if")==0 || | |
strcmp(zzbegexpr, "#else")==0 || | |
strcmp(zzbegexpr, "#endif")==0 || | |
strcmp(zzbegexpr, "#ifndef")==0 || | |
strcmp(zzbegexpr, "#define")==0 || | |
strcmp(zzbegexpr, "#pragma")==0 || | |
strcmp(zzbegexpr, "#undef")==0 || | |
strcmp(zzbegexpr, "#import")==0 || | |
strcmp(zzbegexpr, "#line")==0 || | |
strcmp(zzbegexpr, "#include")==0 || | |
strcmp(zzbegexpr, "#error")==0) ) | |
{ | |
static char buf[100]; | |
sprintf(buf, "%s_ast", zzbegexpr+1); | |
/* MR27 */ list_add(&CurAstLabelsInActions, mystrdup(zzbegexpr+1)); | |
zzreplstr(buf); | |
chkGTFlag(); | |
} | |
zzmore(); | |
>> | |
#\[ | |
<< | |
NLA = 56; | |
pushint(']'); | |
if ( GenCC ) { | |
if (NewAST) zzreplstr("(newAST("); | |
else zzreplstr("(new AST("); } | |
else zzreplstr("zzmk_ast(zzastnew(),"); | |
zzmore(); | |
chkGTFlag(); | |
>> | |
#\( | |
<< | |
NLA = 57; | |
pushint('}'); | |
if ( GenCC ) { | |
if (tmakeInParser) { | |
zzreplstr("tmake("); | |
} | |
else { | |
zzreplstr("ASTBase::tmake("); | |
} | |
} | |
else { | |
zzreplstr("zztmake("); | |
} | |
zzmore(); | |
chkGTFlag(); | |
>> | |
# | |
<< | |
NLA = 58; | |
zzmore(); | |
>> | |
\) | |
<< | |
NLA = 59; | |
if ( istackempty() ) | |
zzmore(); | |
else if ( topint()==')' ) { | |
popint(); | |
} | |
else if ( topint()=='}' ) { | |
popint(); | |
/* terminate #(..) */ | |
zzreplstr(", NULL)"); | |
} | |
zzmore(); | |
>> | |
\[ | |
<< | |
NLA = 60; | |
pushint('|'); /* look for '|' to terminate simple [...] */ | |
zzmore(); | |
>> | |
\( | |
<< | |
NLA = 61; | |
pushint(')'); | |
zzmore(); | |
>> | |
\\\] | |
<< | |
NLA = 62; | |
zzreplstr("]"); zzmore(); | |
>> | |
\\\) | |
<< | |
NLA = 63; | |
zzreplstr(")"); zzmore(); | |
>> | |
\\> | |
<< | |
NLA = 64; | |
if (! tokenActionActive) zzreplstr(">"); /* MR1 */ | |
zzmore(); /* MR1 */ | |
>> | |
' | |
<< | |
NLA = 65; | |
zzmode(ACTION_CHARS); zzmore(); | |
>> | |
\" | |
<< | |
NLA = 66; | |
zzmode(ACTION_STRINGS); zzmore(); | |
>> | |
\\$ | |
<< | |
NLA = 67; | |
zzreplstr("$"); zzmore(); | |
>> | |
\\# | |
<< | |
NLA = 68; | |
zzreplstr("#"); zzmore(); | |
>> | |
\\(\n|\r|\r\n) | |
<< | |
NLA = 69; | |
zzline++; zzmore(); | |
>> | |
\\~[\]\)>$#] | |
<< | |
NLA = 70; | |
zzmore(); | |
>> | |
/ | |
<< | |
NLA = 71; | |
zzmore(); | |
>> | |
/\* | |
<< | |
NLA = 72; | |
zzmode(ACTION_COMMENTS); zzmore(); | |
>> | |
\*/ | |
<< | |
NLA = 73; | |
warn("Missing /*; found dangling */ in action"); zzmore(); | |
>> | |
// | |
<< | |
NLA = 74; | |
zzmode(ACTION_CPP_COMMENTS); zzmore(); | |
>> | |
~[\n\r\)\(\\$#\>\]\[\"'/]+ | |
<< | |
NLA = 75; | |
zzmore(); | |
>> | |
%%PARSE_ENUM_FILE | |
@ | |
<< | |
NLA = Eof; | |
; | |
>> | |
[\t\ ]+ | |
<< | |
NLA = 137; | |
zzskip(); | |
>> | |
\n|\r|\r\n | |
<< | |
NLA = 138; | |
zzline++; zzskip(); | |
>> | |
// | |
<< | |
NLA = 139; | |
zzmode(TOK_DEF_CPP_COMMENTS); zzmore(); | |
>> | |
/\* | |
<< | |
NLA = 140; | |
zzmode(TOK_DEF_COMMENTS); zzskip(); | |
>> | |
#ifdef | |
<< | |
NLA = 141; | |
zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); | |
>> | |
#if | |
<< | |
NLA = 142; | |
zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); | |
>> | |
#ifndef | |
<< | |
NLA = 143; | |
; | |
>> | |
#else | |
<< | |
NLA = 144; | |
zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); | |
>> | |
#endif | |
<< | |
NLA = 145; | |
zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); | |
>> | |
#undef | |
<< | |
NLA = 146; | |
zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); | |
>> | |
#import | |
<< | |
NLA = 147; | |
zzmode(TOK_DEF_CPP_COMMENTS); zzskip(); | |
>> | |
#define | |
<< | |
NLA = 149; | |
>> | |
enum | |
<< | |
NLA = 151; | |
>> | |
\{ | |
<< | |
NLA = 152; | |
>> | |
= | |
<< | |
NLA = 153; | |
>> | |
, | |
<< | |
NLA = 154; | |
>> | |
\} | |
<< | |
NLA = 155; | |
>> | |
; | |
<< | |
NLA = 156; | |
>> | |
[0-9]+ | |
<< | |
NLA = INT; | |
>> | |
[a-zA-Z_][_a-zA-Z0-9]* | |
<< | |
NLA = ID; | |
>> | |
%% |