parser.c

Go to the documentation of this file.

/*
 * A n t l r  T r a n s l a t i o n  H e a d e r
 *
 * Terence Parr, Will Cohen, and Hank Dietz: 1989-2001
 * Purdue University Electrical Engineering
 * With AHPCRC, University of Minnesota
 * ANTLR Version 1.33MR33
 *
 *   ./pccts/bin/antlr -o ../ -gh parser.h -gt -mrhoist off -k 2 parser.g
 *
 */

#define ANTLR_VERSION 13333
#include "pcctscfg.h"
#include "pccts_stdio.h"

#include "charbuf.h"
#include "stringbuffer.h"
#include "libicl.h"
#include "libicl_private.h"
#include "glib.h"
#include <stdio.h>
#ifdef _WINDOWS
#include "oaa-windows.h"
#endif

/* Abstract Syntax Tree fields */
#define AST_FIELDS int isDefined; int type; char* tokenData; size_t tokenLen;
/* Remember column numbers */
#define ZZCOL
/* We define syntax error function */
#define USER_ZZSYN
/* Token buffer size */
/* #define ZZLEXBUFSIZE 10485760*/
#define ZZLEXBUFSIZE 10485760

extern GByteArray* parser_dblQuoteBuf;
extern char* parser_tmpStrIn;
#ifdef NORMAL_GC
extern void* GC_debug_malloc(size_t, const char*, int);
extern char* gc_strdup(char*);
#endif

#ifdef NORMAL_GC
#define zzcr_ast(ast, attr, ttype, text) { \
  if(((ttype) == ICLDATAQ) || \
  ((ttype) == DBLQUOTED)) { \
    char* buf = parser_dblQuoteBuf->data; \
    g_byte_array_free(parser_dblQuoteBuf, FALSE); \
    /* \
    char* buf = (char*)malloc(parser_dblQuoteLen + 1); \
    memcpy(buf, text, parser_dblQuoteLen); \
    buf[parser_dblQuoteLen] = '\0'; \
    */ \
    ast->tokenData = buf; \
    ast->tokenLen = parser_dblQuoteLen; \
  } \
  else { \
    if(zzbufovf) { \
      ast->tokenLen = ZZLEXBUFSIZE; \
      ast->tokenData = (char*)GC_debug_malloc(ZZLEXBUFSIZE + 1, __FILE__, __LINE__); \
      strncpy(ast->tokenData, text, ZZLEXBUFSIZE); \
      fprintf(stderr, "ZZLEXBUFSIZE overflowed (%i)\n", ZZLEXBUFSIZE); \
    } \
    else { \
      ast->tokenData = gc_strdup(text); \
      ast->tokenLen = strlen(text); \
    } \
  } \
  ast->type = (ttype); \
  ast->isDefined = 1; \
  ast->right = NULL; \
  ast->down = NULL; \
  /* printf("zzcr_ast at pointer %p\n", ast); */ \
};

/*
#define zzd_ast(t) { \
  GC_debug_free(t->tokenData); \
  fprintf(stderr, "freed token data at pointer %p\n", t); \
  t->isDefined = 0; \
} \
*/
#undef zzd_ast

#else
#define zzcr_ast(ast, attr, ttype, text) { \
  if(((ttype) == ICLDATAQ) || \
  ((ttype) == DBLQUOTED)) { \
    char* buf = parser_dblQuoteBuf->data; \
    g_byte_array_free(parser_dblQuoteBuf, FALSE); \
    /* \
    char* buf = (char*)malloc(parser_dblQuoteLen + 1); \
    memcpy(buf, text, parser_dblQuoteLen); \
    buf[parser_dblQuoteLen] = '\0'; \
    */ \
    ast->tokenData = buf; \
    ast->tokenLen = parser_dblQuoteLen; \
  } \
  else { \
    if(zzbufovf) { \
      ast->tokenLen = ZZLEXBUFSIZE; \
      ast->tokenData = (char*)malloc(ZZLEXBUFSIZE + 1); \
      strncpy(ast->tokenData, text, ZZLEXBUFSIZE); \
      fprintf(stderr, "ZZLEXBUFSIZE overflowed (%i)\n", ZZLEXBUFSIZE); \
    } \
    else { \
      ast->tokenData = strdup(text); \
      ast->tokenLen = strlen(text); \
    } \
  } \
  ast->type = (ttype); \
  ast->isDefined = 1; \
  ast->right = NULL; \
  ast->down = NULL; \
  /* printf("zzcr_ast at pointer %p\n", ast); */ \
};

/*
#define zzd_ast(t) { \
  free(t->tokenData); \
  t->isDefined = 0; \
} \
*/
#undef zzd_ast

#endif

extern int parser_dblQuoteLen;
extern ICLTerm* parser_getTermFromString(char* str, size_t len);
extern ICLTerm* parser_getTermFromStringDebug(char* str, size_t len);
extern int parser_getTermFromBuf(ICLTerm** result, stringbuffer_t* buf, int* lookedAhead);
extern int parser_getNetTermFromBuf(ICLTerm** result, stringbuffer_t* buf);
/*extern void zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok, int k, char *bad_text);*/
extern int parser_error;
extern int parser_setDebug(int b);
extern void handleDblQuotedData();
#define LL_K 2
#define GENAST

#include "ast.h"

#define zzSET_SIZE 8
#include "antlr.h"
#include "tokens.h"
#include "dlgdef.h"
#include "mode.h"

/* MR23 In order to remove calls to PURIFY use the antlr -nopurify option */

#ifndef PCCTS_PURIFY
#define PCCTS_PURIFY(r,s) memset((char *) &(r),'\0',(s));
#endif

#include "ast.c"
zzASTgvars

ANTLR_INFO


extern int zzSyntaxErrCount; /* defined in err.h */
extern void (*zzerr)(const char*); /* defined in dlgauto.h */
int parser_error = FALSE;
int parser_DEBUG = FALSE;
int parser_dblQuoteLen;
GByteArray* parser_dblQuoteBuf = NULL;
char* parser_tmpStrIn = NULL;
ICLTerm* parser_getTermFromStringReal(char* str, size_t len, int debug);
static stringbuffer_t* currentBuf = NULL;
enum parser_state_vals {parser_dblquote_CONTINUE, parser_dblquote_FOUNDQUOTE};
static int parser_dblquote_state = 0;
static size_t parser_savedIndex = 0;
static int parser_savedIndexSet = FALSE;

void handleDblQuotedData() {
struct zzdlg_state dlgState;
int done = FALSE;
int nextChar = 0;
char toAppend[1];

    /* we save the dlg automaton state each time--could do it just once, but it's */
/* not that expensive */
zzsave_dlg_state(&dlgState);

    /* if we've been here before without finishing the data, continue where we left off */
if(parser_savedIndexSet) {
stringbuffer_setIndex(currentBuf, parser_savedIndex);
}
else {
parser_dblQuoteBuf = g_byte_array_new();
}

    /* A tiny state machine of two states--CONTINUE or FOUNDQUOTE; we enter FOUNDQUOTE */
/* when we find a double quote, so that we can check if it is the ending double quote */
/* or just a quadruple quote (a quoted double quote: "").  If we ever hit EOF, we */
/* save the index in the currentBuf object and return so that the pccts automaton */
/* can fail to find the token correctly */
while(!done) {
nextChar = (*(dlgState.func_ptr))();
if(nextChar == EOF) {
done = TRUE;
//g_byte_array_free(parser_dblQuoteBuf, TRUE);
parser_dblQuoteLen = 0;
zzrestore_dlg_state(&dlgState);
parser_savedIndex = stringbuffer_getIndex(currentBuf);
parser_savedIndexSet = TRUE;
return;
}
switch(parser_dblquote_state) {
case 0:
if(nextChar == '"') {
parser_dblquote_state = parser_dblquote_FOUNDQUOTE;
break;
}
else {
toAppend[0] = nextChar;
/* printf("Adding char %o\n", nextChar); */
g_byte_array_append(parser_dblQuoteBuf, (guint8*)toAppend, 1);
}
break;
case 1:
parser_dblquote_state = parser_dblquote_CONTINUE;
if(nextChar == '"') {
/* printf("Adding char %o\n", '"'); */
g_byte_array_append(parser_dblQuoteBuf, (guint8*)"\"", 1);
}
else {
/* done */
stringbuffer_rewind(currentBuf, 2);
done = TRUE;
parser_dblQuoteLen = parser_dblQuoteBuf->len;
zzrestore_dlg_state(&dlgState);
parser_savedIndex = 0;
parser_savedIndexSet = FALSE;
return;
}
break;
}
}
}

void parser_errorWriter(const char* s) {
int i = 0;
if(parser_DEBUG) {
fprintf(stderr, "Error with text: [");
for(i = 0; s[i] != '\0'; ++i) {
fprintf(stderr, " %o ", s[i]);
}
fprintf(stderr, "\n");
zzerrstd(s);
}
}

int parser_setDebug(int b) {
int ret = parser_DEBUG;
parser_DEBUG = b;
return ret;
}

void zzsynstd(char *text, int tok, char *egroup, SetWordType *eset, int etok, int k, char *bad_text) {
zzSyntaxErrCount++;                             /* MR11 */
fprintf(stderr, "line %d: syntax error at \"%s\"", zzline, (tok==zzEOF_TOKEN)?"EOF":bad_text);
if ( !etok && !eset ) {fprintf(stderr, "\n"); return;}
if ( k==1 ) fprintf(stderr, " missing");
else
{
fprintf(stderr, "; \"%s\" not", bad_text);
if ( zzset_deg(eset)>1 ) fprintf(stderr, " in");
}
if ( zzset_deg(eset)>0 ) zzedecode(eset);
else fprintf(stderr, " %s", zztokens[etok]);
if ( strlen(egroup) > 0 ) fprintf(stderr, " in %s", egroup);
fprintf(stderr, "\n");

}

void zzsyn(char *text, int tok, char *egroup, SetWordType *eset, int etok, int k, char *bad_text) {
if(parser_DEBUG) {
fprintf(stderr, "standard error text:\n");
zzsynstd(text, tok, egroup, eset, etok, k, bad_text);
fprintf(stderr, "end standard error text\n");
}
parser_error = TRUE;
}

void printAst(AST* a) {
if(a == NULL) {
return;
}
if(a->isDefined != 1) {
return;
}
printf(" [type %i][text %s] ", a->type, a->tokenData);
}

void before(AST* a) {
(void)a;
printf(" (");
}

void after(AST* a) {
(void)a;
printf(")");
}

int currentBuf_read() {
return stringbuffer_read(currentBuf);
}

void traverse(AST* tree, 
void (*func)(AST*, void*),
void (*pre)(AST*, void*), 
void (*post)(AST*, void*),
void* data) {
while(tree != NULL) {
if(tree->down != NULL) {
if(pre != NULL) {
(*pre)(tree, data);
}
}
if(func != NULL) {
(*func)(tree, data);
}
traverse(tree->down, func, pre, post, data);
if(tree->down != NULL) {
if(post != NULL) {
(*post)(tree, data);
}
}
tree = tree->right;
}
}

void parser_freeASTData(AST* a, void* dummy) {
(void)dummy;
if(a->isDefined == 1) {
#ifdef NORMAL_GC
GC_debug_free(a->tokenData);
#else
free(a->tokenData);
#endif
}
}

void parser_freeTree(AST* root) {
traverse(root, parser_freeASTData, NULL, NULL, NULL);
}

int astToTerm(AST* root, ICLTerm** result, int debug) {
int done = FALSE;
GPtrArray* parentsList = g_ptr_array_new();
GPtrArray* termList = g_ptr_array_new();
AST* currentAST = NULL;
ICLTerm* currentTerm = NULL;
gint64* intp;
double* dblp;
char* endp;
ICLStructType* st;
ICLGroupType* gt;
int parentIndex = 0;

    if(debug || parser_DEBUG) {
debug = TRUE;
}

    g_ptr_array_add(parentsList, root);
while(parentsList->len != 0) {
currentAST = (AST*)g_ptr_array_index(parentsList, parentsList->len - 1);
if(currentAST->isDefined != 1) {
(void)g_ptr_array_remove_index(parentsList, parentIndex);
continue;
}
#ifdef NORMAL_GC
currentTerm = (ICLTerm*)GC_debug_malloc(sizeof(ICLTerm), __FILE__, __LINE__);
printf("Allocated new term at %p\n", currentTerm);
#else
currentTerm = (ICLTerm*)malloc(sizeof(ICLTerm));
#endif
currentTerm->magic_cookie = ICL_MAGIC_COOKIE;
currentTerm->refCount = 1;
currentTerm->glibAlloc = 0;
currentTerm->needsQuotes = 0;
g_ptr_array_add(termList, currentTerm);
switch(currentAST->type) {
case STR:
currentTerm->iclType = icl_str_type;
if(currentAST->tokenData[0] == '\'') {
icl_setStrFromProperlyQuoted(currentAST->tokenData, currentTerm);
}
else {
currentTerm->p = currentAST->tokenData;
}
currentTerm->len = strlen(currentTerm->p);
if(debug) {
printf("Found str: %s\n", currentTerm->p);
}
break;
case VAR:
currentTerm->iclType = icl_var_type;
currentTerm->p = currentAST->tokenData;
currentTerm->len = currentAST->tokenLen;
if(debug) {
printf("Found var: %s\n", currentTerm->p);
}
break;
case INT:
currentTerm->iclType = icl_int_type;
#ifdef NORMAL_GC
intp = (gint64*)GC_debug_malloc(sizeof(gint64), __FILE__, __LINE__);
#else
intp = (gint64*)malloc(sizeof(gint64));
#endif
*intp = strtoll(currentAST->tokenData, &endp, 10);
if(*endp != '\0') {
if(debug) {
printf("Bad int\n");
}
parser_error = TRUE;
g_ptr_array_free(termList, TRUE);
g_ptr_array_free(parentsList, TRUE);
return FALSE;
}
free(currentAST->tokenData);
currentAST->tokenData = NULL;
currentAST->tokenLen = 0;
currentTerm->p = intp;
currentTerm->len = sizeof(gint64);
if(debug) {
printf("Found int: %lld\n", *((gint64*)currentTerm->p));
}
break;
case FLOAT:
currentTerm->iclType = icl_float_type;
#ifdef NORMAL_GC
dblp = (double*)GC_debug_malloc(sizeof(double), __FILE__, __LINE__);
#else
dblp = (double*)malloc(sizeof(double));
#endif
*dblp = strtod(currentAST->tokenData, &endp);
if(*endp != '\0') {
if(debug) {
printf("Bad float\n");
}
parser_error = TRUE;
g_ptr_array_free(termList, TRUE);
g_ptr_array_free(parentsList, TRUE);                
return FALSE;
}
free(currentAST->tokenData);
currentAST->tokenData = NULL;
currentAST->tokenLen = 0;
currentTerm->p = dblp;
currentTerm->len = sizeof(double);
if(debug) {
printf("Found float: %lf\n", *((double*)currentTerm->p));
}
break;
case STRUCT:
currentTerm->iclType = icl_struct_type;
#ifdef NORMAL_GC
st = (ICLStructType*)GC_debug_malloc(sizeof(ICLStructType), __FILE__, __LINE__);
#else
st = (ICLStructType*)malloc(sizeof(ICLStructType));
#endif
st->functor = icl_NewStrNoCopy(currentAST->tokenData);
st->args = NULL;
st->numArgs = 0;
currentTerm->p = st;
currentTerm->len = sizeof(st);
if(debug) {
printf("Found struct: name at %p: %s\n", st->functor->p, st->functor->p);
}
break;
case LIST:
free(currentAST->tokenData);
currentTerm->iclType = icl_list_type;
currentTerm->p = NULL;
currentTerm->len = sizeof(ICLListType*);
if(debug) {
printf("Found list\n");
}
break;
case GROUP:
currentTerm->iclType = icl_group_type;
#ifdef NORMAL_GC
gt = (ICLGroupType*)GC_debug_malloc(sizeof(ICLGroupType), __FILE__, __LINE__);
#else
gt = (ICLGroupType*)malloc(sizeof(ICLGroupType));
#endif
gt->list = NULL;
gt->startChar = currentAST->tokenData[0];
free(currentAST->tokenData);
gt->separator = strdup(",");
currentTerm->p = gt;
currentTerm->len = sizeof(gt);
if(debug) {
printf("Found group\n");
}
break;
case ICLDATAQ:
currentTerm->iclType = icl_dataq_type;
currentTerm->p = currentAST->tokenData;
currentTerm->len = currentAST->tokenLen;
currentTerm->glibAlloc = 1;
if(debug) {
printf("Found icldataq of len %i\n", currentTerm->len);
}
break;
default:
fprintf(stderr, "Parser attempted to make ICLTerm from type %i\n", currentAST->type);
parser_error = TRUE;
g_ptr_array_free(termList, TRUE);
g_ptr_array_free(parentsList, TRUE);
return FALSE;
}
if(debug) {
printf("Created term at %p with type %i\n", currentTerm, currentTerm->iclType);
}
if(currentAST != root) {
if(debug) {
printf("Attempting to add term at %p to parent %p\n", (ICLTerm*)g_ptr_array_index(termList, parentIndex), (ICLTerm*)g_ptr_array_index(termList, parentIndex - 1));
}
icl_addChild((ICLTerm*)g_ptr_array_index(termList, parentIndex - 1), (ICLTerm*)g_ptr_array_index(termList, parentIndex));
}
/* Check if we go down or right or up */
if(currentAST->down != NULL) {
g_ptr_array_add(parentsList, currentAST->down);
++parentIndex;
continue;
}
else if(currentAST->right != NULL) {
(void)g_ptr_array_remove_index(parentsList, parentIndex);
(void)g_ptr_array_remove_index(termList, parentIndex);
g_ptr_array_add(parentsList, currentAST->right);
/* parentIndex stays the same, since we removed and added one */
}
else {
/* both down  and right are NULL--we're at a leaf */
/* Keep going up the tree until we get to a non-NULL
* right, or we hit the root of the tree
*/
int foundSibling = FALSE;
while(parentIndex > 0){
(void)g_ptr_array_remove_index(parentsList, parentIndex);
(void)g_ptr_array_remove_index(termList, parentIndex);
--parentIndex;
currentAST = g_ptr_array_index(parentsList, parentIndex);
if(currentAST->right == NULL) {
continue;
}
else {
foundSibling = TRUE;
break;
}
}
if(parentIndex == 0) {
/* done */
*result = (ICLTerm*)g_ptr_array_remove_index(termList, 0);
g_ptr_array_free(termList, TRUE);
g_ptr_array_free(parentsList, TRUE);
termList = NULL;
parentsList = NULL;
if(debug) {
printf("found ICLTerm\n");
}
parser_error = FALSE;
return TRUE;
}
else if(foundSibling == TRUE) {
/* keep making ICLTerm tree */
/* remove the current sibling and replace with the new one */
(void)g_ptr_array_remove_index(parentsList, parentIndex);
(void)g_ptr_array_remove_index(termList, parentIndex);
g_ptr_array_add(parentsList, currentAST->right);
continue;
}
else {
fprintf(stderr, "Bad parse: at leaf, could not find suitable parent to continue or return");
parser_error = TRUE;
g_ptr_array_free(termList, TRUE);
g_ptr_array_free(parentsList, TRUE);
return FALSE;
/* error */
}
}
}
}

AST* getASTFromString(char* str, size_t len, int debug) {
int oldDebug = parser_DEBUG;
#ifdef NORMAL_GC
AST* root = (AST*)GC_debug_malloc(sizeof(AST), __FILE__, __LINE__);
#else
AST* root = (AST*)malloc(sizeof(AST));
#endif
memset(root, 0, sizeof(AST));
currentBuf = stringbuffer_new(str, len);
parser_DEBUG = debug;
parser_error = FALSE;
zzerr = parser_errorWriter;
zzmode(START);
ANTLRf(startOneOnly(&root), currentBuf_read);
stringbuffer_delete(currentBuf);
parser_DEBUG = oldDebug;
return root;
}

ICLTerm* parser_getTermFromString(char* str, size_t len) {
return parser_getTermFromStringReal(str, len, FALSE);
}

ICLTerm* parser_getTermFromStringDebug(char* str, size_t len) {
return parser_getTermFromStringReal(str, len, TRUE);
}

ICLTerm* parser_getTermFromStringReal(char* str, size_t len, int debug) {
AST* root = getASTFromString(str, len, debug);
AST* treeTerm = zzchild(root);
ICLTerm* result = NULL;
int parsedOkay = FALSE;

    if(parser_savedIndexSet) {
parser_savedIndexSet = FALSE;
g_byte_array_free(parser_dblQuoteBuf, TRUE);
}

    if(parser_error) {
parser_error = FALSE;
parser_freeTree(root);
zzfree_ast(root);
icl_Free(result);
return NULL;
}
parsedOkay = astToTerm(treeTerm, &result, debug);
if(parser_error) {
parser_error = FALSE;
parser_freeTree(root);
zzfree_ast(root);
icl_Free(result);
return NULL;
}
if(parsedOkay == TRUE) {
zzfree_ast(root);
return result;
}
else {
parser_freeTree(root);
zzfree_ast(root);
return NULL;
}
}

int parser_getTermFromBuf(ICLTerm** result, stringbuffer_t* buf, int* lookedAhead) {
#ifdef NORMAL_GC
AST* root = (AST*)GC_debug_malloc(sizeof(AST), __FILE__, __LINE__);
#else
AST* root = (AST*)malloc(sizeof(AST));
#endif
int parsedOkay = FALSE;
int lookaheadIndex;
*result = NULL;
memset(root, 0, sizeof(AST));
currentBuf = buf;
parser_error = FALSE;
zzerr = parser_errorWriter;
zzmode(START);
ANTLRf(startOneOnly(&root), currentBuf_read);
if(parser_savedIndexSet) {
parser_savedIndexSet = FALSE;
g_byte_array_free(parser_dblQuoteBuf, TRUE);
}

    *lookedAhead = LL_K;
for(lookaheadIndex = LL_K - 1; lookaheadIndex >= 0; --lookaheadIndex) {
if(zztextLA[lookaheadIndex] && zztextLA[lookaheadIndex][0] == -1) {
*lookedAhead = LL_K - lookaheadIndex - 1;
break;
}
}
//printf("zztextLA = [%s:%i,%s:%i]\n", zztextLA[0], zztextLA[0][0], zztextLA[1], zztextLA[1][0]);
if(parser_error) {
parser_freeTree(root);
zzfree_ast(root);
icl_Free(*result);
*result = NULL;
if(parser_DEBUG) {
printf("parser_getTermFromBuf parser_error\n");
}
return FALSE;
}
parsedOkay = astToTerm(zzchild(root), result, FALSE);
if(parser_error) {
parser_freeTree(root);
zzfree_ast(root);
icl_Free(*result);
*result = NULL;
if(parser_DEBUG) {
printf("parser_getTermFromBuf parser_error\n");
}
return FALSE;
}
if(parsedOkay == TRUE) {
zzfree_ast(root);
return TRUE;
}
else {
parser_freeTree(root);
zzfree_ast(root);
if(parser_DEBUG) {
printf("parser_getTermFromBuf didn't parse okay\n");
}
return FALSE;
}
}

int parser_getNetTermFromBuf(ICLTerm** result, stringbuffer_t* buf) {
#ifdef NORMAL_GC
AST* root = (AST*)GC_debug_malloc(sizeof(AST), __FILE__, __LINE__);
#else
AST* root = (AST*)malloc(sizeof(AST));
#endif
int parsedOkay = FALSE;
*result = NULL;
memset(root, 0, sizeof(AST));
currentBuf = buf;
parser_error = FALSE;
zzerr = parser_errorWriter;
zzmode(START);
ANTLRf(startNet(&root), currentBuf_read);
if(parser_savedIndexSet) {
parser_savedIndexSet = FALSE;
g_byte_array_free(parser_dblQuoteBuf, TRUE);
}

    if(parser_error) {
parser_freeTree(root);
zzfree_ast(root);
icl_Free(*result);
*result = NULL;
if(parser_DEBUG) {
printf("parser_getNetTermFromBuf parser_error\n");
}
return FALSE;
}
parsedOkay = astToTerm(zzchild(root), result, FALSE);
if(parser_error) {
parser_freeTree(root);
zzfree_ast(root);
icl_Free(*result);
*result = NULL;
if(parser_DEBUG) {
printf("parser_getNetTermFromBuf parser_error\n");
}
return FALSE;
}
if(parsedOkay == TRUE) {
zzfree_ast(root);
return TRUE;
}
else {
parser_freeTree(root);
zzfree_ast(root);
if(parser_DEBUG) {
printf("parser_getNetTermFromBuf didn't parse okay\n");
}
return FALSE;
}
}

/*
int main(int argc, char* argv[]) {
AST* root;
while(1) {
zzmode(START);
ANTLR(startNet(&root), stdin);
printf("Printing AST: \n");
zzpre_ast(zzchild(root), printAst, before, after);
}
}
*/

void
#ifdef __USE_PROTOS
startOneOnly(AST**_root)
#else
startOneOnly(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  structure(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    if ( (LA(1)==DOT) ) {
      zzmatch(DOT);  zzCONSUME;
    }
    else {
      if ( (LA(1)==1) ) {
      }
      else {zzFAIL(1,zzerr1,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
    zzEXIT(zztasp2);
    }
  }
  if(parser_DEBUG) printf("completed structure for startOneOnly\n");
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd1, 0x1);
  }
}

void
#ifdef __USE_PROTOS
startNet(AST**_root)
#else
startNet(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    if ( (LA(1)==DOT) ) {
      zzmatch(DOT);  zzCONSUME;
    }
    else {
      if ( (LA(1)==TERM_LITERAL) ) {
      }
      else {zzFAIL(1,zzerr2,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
    zzEXIT(zztasp2);
    }
  }
  netstruct(zzSTR); zzlink(_root, &_sibling, &_tail);
  if(parser_DEBUG) printf("completed netstruct for startNet\n");
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd1, 0x2);
  }
}

void
#ifdef __USE_PROTOS
netstruct(AST**_root)
#else
netstruct(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  zzmatch(TERM_LITERAL); zzsubroot(_root, &_sibling, &_tail);
  (*_root)->type = STRUCT; if(parser_DEBUG) printf("netstruct\n");
 zzCONSUME;

  zzmatch(LPAREN);  zzCONSUME;
  nonEmptyExpressionList(zzSTR); zzlink(_root, &_sibling, &_tail);
  zzmatch(RPAREN); 
  zzEXIT(zztasp1); return;
 zzCONSUME;

  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd1, 0x4);
  }
}

void
#ifdef __USE_PROTOS
structure(AST**_root)
#else
structure(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  semiExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (LA(1)==TURNSTILE)
 ) {
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        zzmatch(TURNSTILE); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
        zzEXIT(zztasp3);
        }
      }
      (*_root)->type = STRUCT; if(parser_DEBUG) printf("struct\n");
      semiExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd1, 0x8);
  }
}

void
#ifdef __USE_PROTOS
semiExpression(AST**_root)
#else
semiExpression(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  backslashExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (LA(1)==SEMI) ) {
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        zzmatch(SEMI); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
        zzEXIT(zztasp3);
        }
      }
      (*_root)->type = STRUCT; if(parser_DEBUG) printf("semiExpression\n");
      backslashExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd1, 0x10);
  }
}

void
#ifdef __USE_PROTOS
backslashExpression(AST**_root)
#else
backslashExpression(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  equalsExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (LA(1)==BACKSLASH) ) {
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        zzmatch(BACKSLASH); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
        zzEXIT(zztasp3);
        }
      }
      (*_root)->type = STRUCT; if(parser_DEBUG) printf("backslashExpression\n");
      equalsExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd1, 0x20);
  }
}

void
#ifdef __USE_PROTOS
equalsExpression(AST**_root)
#else
equalsExpression(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  colonExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (LA(1)==EQUAL) ) {
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        zzmatch(EQUAL); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
        zzEXIT(zztasp3);
        }
      }
      (*_root)->type = STRUCT; if(parser_DEBUG) printf("equalsExpression\n");
      colonExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd1, 0x40);
  }
}

void
#ifdef __USE_PROTOS
colonExpression(AST**_root)
#else
colonExpression(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  plusMinusExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (setwd1[LA(1)]&0x80) ) {
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        if ( (LA(1)==COLON)
 ) {
          zzmatch(COLON); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
        }
        else {
          if ( (LA(1)==DBL_COLON) ) {
            zzmatch(DBL_COLON); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
          }
          else {zzFAIL(1,zzerr3,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
        }
        zzEXIT(zztasp3);
        }
      }
      (*_root)->type = STRUCT; if(parser_DEBUG) printf("colonExpr\n");
      plusMinusExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd2, 0x1);
  }
}

void
#ifdef __USE_PROTOS
plusMinusExpression(AST**_root)
#else
plusMinusExpression(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  multiplicativeExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (setwd2[LA(1)]&0x2) ) {
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        if ( (LA(1)==PLUS) ) {
          zzmatch(PLUS); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
        }
        else {
          if ( (LA(1)==MINUS) ) {
            zzmatch(MINUS); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
          }
          else {zzFAIL(1,zzerr4,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
        }
        zzEXIT(zztasp3);
        }
      }
      (*_root)->type = STRUCT; if(parser_DEBUG) printf("plusMinusExpression\n");
      multiplicativeExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd2, 0x4);
  }
}

void
#ifdef __USE_PROTOS
multiplicativeExpression(AST**_root)
#else
multiplicativeExpression(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  unaryExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (setwd2[LA(1)]&0x8)
 ) {
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        if ( (LA(1)==STAR) ) {
          zzmatch(STAR); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
        }
        else {
          if ( (LA(1)==DIV) ) {
            zzmatch(DIV); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
          }
          else {zzFAIL(1,zzerr5,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
        }
        zzEXIT(zztasp3);
        }
      }
      (*_root)->type = STRUCT; if(parser_DEBUG) printf("multiplicativeExpr\n");
      unaryExpression(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd2, 0x10);
  }
}

void
#ifdef __USE_PROTOS
unaryExpression(AST**_root)
#else
unaryExpression(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  if ( (setwd2[LA(1)]&0x20) && (LA(2)==LPAREN) && !(
 LA(1)==BANG && LA(2)==1
|| LA(1)==SEMI && LA(2)==1
|| LA(1)==STRING_LITERAL && LA(2)==1
|| LA(1)==STAR && LA(2)==1
|| LA(1)==PLUS && LA(2)==1
|| LA(1)==MINUS && LA(2)==1
|| LA(1)==DIV && LA(2)==1
|| LA(1)==EQUAL && LA(2)==1
|| LA(1)==TURNSTILE && LA(2)==1
|| LA(1)==IDENT && LA(2)==1
|| LA(1)==SPECIAL_CHAR_LITERAL && LA(2)==1
) ) {
    normalStruct(zzSTR); zzlink(_root, &_sibling, &_tail);
  }
  else {
    if ( (LA(1)==ICLDATAQ_LITERAL) && (LA(2)==LPAREN) && !( LA(1)==ICLDATAQ_LITERAL && LA(2)==1) ) {
      icldataqStruct(zzSTR); zzlink(_root, &_sibling, &_tail);
    }
    else {
      if ( (setwd2[LA(1)]&0x40) && 
(setwd2[LA(2)]&0x80) ) {
        unaryExpressionNotPlusMinus(zzSTR); zzlink(_root, &_sibling, &_tail);
      }
      else {zzFAIL(2,zzerr6,zzerr7,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd3, 0x1);
  }
}

void
#ifdef __USE_PROTOS
normalStruct(AST**_root)
#else
normalStruct(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    if ( (LA(1)==BANG) ) {
      zzmatch(BANG); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
    }
    else {
      if ( (LA(1)==SEMI) ) {
        zzmatch(SEMI); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
      }
      else {
        if ( (LA(1)==STRING_LITERAL) ) {
          zzmatch(STRING_LITERAL); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
        }
        else {
          if ( (LA(1)==IDENT) ) {
            zzmatch(IDENT); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
          }
          else {
            if ( (LA(1)==PLUS)
 ) {
              zzmatch(PLUS); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
            }
            else {
              if ( (LA(1)==MINUS) ) {
                zzmatch(MINUS); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
              }
              else {
                if ( (LA(1)==STAR) ) {
                  zzmatch(STAR); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
                }
                else {
                  if ( (LA(1)==DIV) ) {
                    zzmatch(DIV); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
                  }
                  else {
                    if ( (LA(1)==EQUAL) ) {
                      zzmatch(EQUAL); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
                    }
                    else {
                      if ( (LA(1)==TURNSTILE)
 ) {
                        zzmatch(TURNSTILE); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
                      }
                      else {
                        if ( (LA(1)==COLON) ) {
                          zzmatch(COLON); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
                        }
                        else {
                          if ( (LA(1)==DBL_COLON) ) {
                            zzmatch(DBL_COLON); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
                          }
                          else {
                            if ( (LA(1)==SPECIAL_CHAR_LITERAL) ) {
                              zzmatch(SPECIAL_CHAR_LITERAL); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
                            }
                            else {
                              if ( (LA(1)==BACKSLASH) ) {
                                zzmatch(BACKSLASH); zzsubroot(_root, &_sibling, &_tail); zzCONSUME;
                              }
                              else {zzFAIL(1,zzerr8,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
    zzEXIT(zztasp2);
    }
  }
  (*_root)->type = STRUCT; if(parser_DEBUG) printf("normalStruct\n");
  zzmatch(LPAREN);  zzCONSUME;
  nonEmptyExpressionList(zzSTR); zzlink(_root, &_sibling, &_tail);
  zzmatch(RPAREN);  zzCONSUME;
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd3, 0x2);
  }
}

void
#ifdef __USE_PROTOS
nonEmptyExpressionList(AST**_root)
#else
nonEmptyExpressionList(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  structure(zzSTR); zzlink(_root, &_sibling, &_tail);
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    while ( (LA(1)==COMMA)
 ) {
      zzmatch(COMMA);  zzCONSUME;
      structure(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzLOOP(zztasp2);
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd3, 0x4);
  }
}

void
#ifdef __USE_PROTOS
expressionList(AST**_root)
#else
expressionList(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    if ( (setwd3[LA(1)]&0x8) ) {
      structure(zzSTR); zzlink(_root, &_sibling, &_tail);
      {
        zzBLOCK(zztasp3);
        zzMake0;
        {
        while ( (LA(1)==COMMA) ) {
          zzmatch(COMMA);  zzCONSUME;
          structure(zzSTR); zzlink(_root, &_sibling, &_tail);
          zzLOOP(zztasp3);
        }
        zzEXIT(zztasp3);
        }
      }
    }
    else {
      if ( (setwd3[LA(1)]&0x10) ) {
      }
      else {zzFAIL(1,zzerr9,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
    zzEXIT(zztasp2);
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd3, 0x20);
  }
}

void
#ifdef __USE_PROTOS
icldataqStruct(AST**_root)
#else
icldataqStruct(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  zzmatch(ICLDATAQ_LITERAL);  zzCONSUME;
  zzmatch(LPAREN);  zzCONSUME;
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    if ( (LA(1)==DBLQUOTED) ) {
      icldataqShortStruct(zzSTR); zzlink(_root, &_sibling, &_tail);
    }
    else {
      if ( (setwd3[LA(1)]&0x40)
 ) {
        icldataqLongStruct(zzSTR); zzlink(_root, &_sibling, &_tail);
      }
      else {zzFAIL(1,zzerr10,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
    zzEXIT(zztasp2);
    }
  }
  zzmatch(RPAREN);  zzCONSUME;
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd3, 0x80);
  }
}

void
#ifdef __USE_PROTOS
icldataqShortStruct(AST**_root)
#else
icldataqShortStruct(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  zzmatch(DBLQUOTED); zzsubroot(_root, &_sibling, &_tail);
  (*_root)->type = ICLDATAQ; if(parser_DEBUG) printf("icldataqShort\n");
 zzCONSUME;

  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd4, 0x1);
  }
}

void
#ifdef __USE_PROTOS
icldataqLongStruct(AST**_root)
#else
icldataqLongStruct(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    if ( (LA(1)==NUM_INTONE) ) {
      zzmatch(NUM_INTONE);  zzCONSUME;
    }
    else {
      if ( (LA(1)==NUM_INTTWO) ) {
        zzmatch(NUM_INTTWO);  zzCONSUME;
      }
      else {zzFAIL(1,zzerr11,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
    zzEXIT(zztasp2);
    }
  }
  zzmatch(COMMA);  zzCONSUME;
  {
    zzBLOCK(zztasp2);
    zzMake0;
    {
    if ( (LA(1)==NUM_INTONE) ) {
      zzmatch(NUM_INTONE);  zzCONSUME;
    }
    else {
      if ( (LA(1)==NUM_INTTWO) ) {
        zzmatch(NUM_INTTWO);  zzCONSUME;
      }
      else {zzFAIL(1,zzerr12,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
    }
    zzEXIT(zztasp2);
    }
  }
  zzmatch(COMMA);  zzCONSUME;
  zzmatch(DBLQUOTED); zzsubroot(_root, &_sibling, &_tail);
  (*_root)->type = ICLDATAQ; if(parser_DEBUG) printf("icldataqLong\n");
 zzCONSUME;

  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd4, 0x2);
  }
}

void
#ifdef __USE_PROTOS
unaryExpressionNotPlusMinus(AST**_root)
#else
unaryExpressionNotPlusMinus(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  if ( (LA(1)==NUM_INTONE)
 ) {
    zzmatch(NUM_INTONE); zzsubchild(_root, &_sibling, &_tail);
    (*_root)->type = INT; if(parser_DEBUG) printf("intone\n");
 zzCONSUME;

  }
  else {
    if ( (LA(1)==NUM_INTTWO) ) {
      zzmatch(NUM_INTTWO); zzsubchild(_root, &_sibling, &_tail);
      (*_root)->type = INT; if(parser_DEBUG) printf("inttwo\n");
 zzCONSUME;

    }
    else {
      if ( (LA(1)==NUM_FLOATONE) ) {
        zzmatch(NUM_FLOATONE); zzsubchild(_root, &_sibling, &_tail);
        (*_root)->type = FLOAT; if(parser_DEBUG) printf("floatone\n");
 zzCONSUME;

      }
      else {
        if ( (LA(1)==NUM_FLOATTWO) ) {
          zzmatch(NUM_FLOATTWO); zzsubchild(_root, &_sibling, &_tail);
          (*_root)->type = FLOAT; if(parser_DEBUG) printf("floattwo\n");
 zzCONSUME;

        }
        else {
          if ( (setwd4[LA(1)]&0x4) ) {
            str(zzSTR); zzlink(_root, &_sibling, &_tail);
          }
          else {
            if ( (LA(1)==VARIABLE)
 ) {
              var(zzSTR); zzlink(_root, &_sibling, &_tail);
            }
            else {
              if ( (LA(1)==LBRACK) ) {
                list(zzSTR); zzlink(_root, &_sibling, &_tail);
              }
              else {
                if ( (setwd4[LA(1)]&0x8) ) {
                  group(zzSTR); zzlink(_root, &_sibling, &_tail);
                }
                else {zzFAIL(1,zzerr13,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
              }
            }
          }
        }
      }
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd4, 0x10);
  }
}

void
#ifdef __USE_PROTOS
str(AST**_root)
#else
str(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  if ( (LA(1)==BANG) ) {
    zzmatch(BANG); zzsubchild(_root, &_sibling, &_tail);
    (*_root)->type = STR; if(parser_DEBUG) printf("str\n");
 zzCONSUME;

  }
  else {
    if ( (LA(1)==SEMI) ) {
      zzmatch(SEMI); zzsubchild(_root, &_sibling, &_tail);
      (*_root)->type = STR; if(parser_DEBUG) printf("str\n");
 zzCONSUME;

    }
    else {
      if ( (LA(1)==STRING_LITERAL)
 ) {
        zzmatch(STRING_LITERAL); zzsubchild(_root, &_sibling, &_tail);
        (*_root)->type = STR; if(parser_DEBUG) printf("str\n");
 zzCONSUME;

      }
      else {
        if ( (LA(1)==STAR) ) {
          zzmatch(STAR); zzsubchild(_root, &_sibling, &_tail);
          (*_root)->type = STR; if(parser_DEBUG) printf("str\n");
 zzCONSUME;

        }
        else {
          if ( (LA(1)==PLUS) ) {
            zzmatch(PLUS); zzsubchild(_root, &_sibling, &_tail);
            (*_root)->type = STR; if(parser_DEBUG) printf("str\n");
 zzCONSUME;

          }
          else {
            if ( (LA(1)==MINUS) ) {
              zzmatch(MINUS); zzsubchild(_root, &_sibling, &_tail);
              (*_root)->type = STR; if(parser_DEBUG) printf("str\n");
 zzCONSUME;

            }
            else {
              if ( (LA(1)==DIV) ) {
                zzmatch(DIV); zzsubchild(_root, &_sibling, &_tail);
                (*_root)->type = STR; if(parser_DEBUG) printf("str\n");
 zzCONSUME;

              }
              else {
                if ( (LA(1)==EQUAL)
 ) {
                  zzmatch(EQUAL); zzsubchild(_root, &_sibling, &_tail);
                  (*_root)->type = STR; if(parser_DEBUG) printf("str\n");
 zzCONSUME;

                }
                else {
                  if ( (LA(1)==TURNSTILE) ) {
                    zzmatch(TURNSTILE); zzsubchild(_root, &_sibling, &_tail);
                    (*_root)->type = STR; if(parser_DEBUG) printf("str\n");
 zzCONSUME;

                  }
                  else {
                    if ( (LA(1)==IDENT) ) {
                      zzmatch(IDENT); zzsubchild(_root, &_sibling, &_tail);
                      (*_root)->type = STR; if(parser_DEBUG) printf("str\n");
 zzCONSUME;

                    }
                    else {
                      if ( (LA(1)==SPECIAL_CHAR_LITERAL) ) {
                        zzmatch(SPECIAL_CHAR_LITERAL); zzsubchild(_root, &_sibling, &_tail);
                        (*_root)->type = STR; if(parser_DEBUG) { printf("SPECIAL_CHAR_LITERAL str\n"); printf("%s\n", (*_root)->tokenData); }
 zzCONSUME;

                      }
                      else {
                        if ( (LA(1)==TERM_LITERAL) ) {
                          zzmatch(TERM_LITERAL); zzsubchild(_root, &_sibling, &_tail);
                          (*_root)->type = STR; if(parser_DEBUG) printf("str\n");
 zzCONSUME;

                        }
                        else {
                          if ( (LA(1)==ICLDATAQ_LITERAL)
 ) {
                            zzmatch(ICLDATAQ_LITERAL); zzsubchild(_root, &_sibling, &_tail);
                            (*_root)->type = STR; if(parser_DEBUG) printf("str\n");
 zzCONSUME;

                          }
                          else {zzFAIL(1,zzerr14,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd4, 0x20);
  }
}

void
#ifdef __USE_PROTOS
var(AST**_root)
#else
var(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  zzmatch(VARIABLE); zzsubchild(_root, &_sibling, &_tail);
  (*_root)->type = VAR; if(parser_DEBUG) printf("var\n");
 zzCONSUME;

  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd4, 0x40);
  }
}

void
#ifdef __USE_PROTOS
list(AST**_root)
#else
list(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  zzmatch(LBRACK); zzsubroot(_root, &_sibling, &_tail);
  (*_root)->type = LIST; if(parser_DEBUG) printf("list\n");
 zzCONSUME;

  expressionList(zzSTR); zzlink(_root, &_sibling, &_tail);
  zzmatch(RBRACK);  zzCONSUME;
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd4, 0x80);
  }
}

void
#ifdef __USE_PROTOS
group(AST**_root)
#else
group(_root)
AST **_root;
#endif
{
  zzRULE;
  zzBLOCK(zztasp1);
  zzMake0;
  {
  if ( (LA(1)==LBRACE) ) {
    zzmatch(LBRACE); zzsubroot(_root, &_sibling, &_tail);
    (*_root)->type = GROUP; if(parser_DEBUG) printf("group\n");
 zzCONSUME;

    expressionList(zzSTR); zzlink(_root, &_sibling, &_tail);
    zzmatch(RBRACE);  zzCONSUME;
  }
  else {
    if ( (LA(1)==LPAREN) ) {
      zzmatch(LPAREN); zzsubroot(_root, &_sibling, &_tail);
      (*_root)->type = GROUP; if(parser_DEBUG) printf("group\n");
 zzCONSUME;

      expressionList(zzSTR); zzlink(_root, &_sibling, &_tail);
      zzmatch(RPAREN);  zzCONSUME;
    }
    else {zzFAIL(1,zzerr15,&zzMissSet,&zzMissText,&zzBadTok,&zzBadText,&zzErrk); goto fail;}
  }
  zzEXIT(zztasp1);
  return;
fail:
  zzEXIT(zztasp1);
  zzsyn(zzMissText, zzBadTok, (ANTLRChar *)"", zzMissSet, zzMissTok, zzErrk, zzBadText);
  zzresynch(setwd5, 0x1);
  }
}

---