/* Copyright (C) Boris Nikolaus, Germany, 1996-1997. All rights reserved. */

#line 4 "parser.ll"
#include <stdio.h>
#include <string.h>
#include "defs.h"

#define MAXTAGS 16

extern char *find_tag(char *);
extern item_t *find_symbol(char *);
extern item_t *get_symbol(char *);
extern char *convert(char *);
extern item_t *create_symbol(int isnonterm, int isexternal, char *tag, char *identifier, char *altidentifier, char **args);
extern char *conststr;
extern char *ll;
extern char *LL;
extern char *usetypes;
extern char *USETYPES;

void output(char *fmt, ...);
void output_line();
void output_rhs(char *identifier, struct rhs_s *rhs);
void incput(char *fmt, ...);
void create_vardefs();
void set_start(char *startstr);
void set_prefix(char *prefixstr);
void set_module(char *modulestr);
void add_rules(item_t *item, struct rhs_s *rhs);

#line 30 "parser.c"


#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <limits.h>
#include "parser.h"

int llcpos;
int *llstk;
unsigned llstksize;
unsigned llcstp = 1;
LLTERM *lltokens;
int llntokens;
char llerrormsg[256];
LLPOS llerrorpos;
int llepos;
LLSTYPE lllval;

int llterm(int token, LLSTYPE *lval, LLSTATE *llin, LLSTATE *llout);
void llfailed(LLPOS *pos, char *fmt, ...);
void llresizestk();
#define LLCHECKSTK do{if (llcstp + 1 >= llstksize) llresizestk();}while(/*CONSTCOND*/0)
#define LLFAILED(_err) do{llfailed _err; goto failed;}while(/*CONSTCOND*/0)
#define LLCUTOFF do{unsigned i; for (i = llstp; i < llcstp; i++) if (llstk[i] > 0) llstk[i] = -llstk[i];}while(/*CONSTCOND*/0)
#define LLCUTTHIS do{if (llstk[llstp] > 0) llstk[llstp] = -llstk[llstp];}while(/*CONSTCOND*/0)
#define LLCUTALL do{unsigned i; for (i = 0; i < llcstp; i++) if (llstk[i] > 0) llstk[i] = -llstk[i];}while(/*CONSTCOND*/0)

#if LLDEBUG > 0
int lldebug;
int last_linenr;
char *last_file = "";
#define LLDEBUG_ENTER(_ident) lldebug_enter(_ident)
#define LLDEBUG_LEAVE(_ident,_succ) lldebug_leave(_ident,_succ)
#define LLDEBUG_ALTERNATIVE(_ident,_alt) lldebug_alternative(_ident,_alt)
#define LLDEBUG_ITERATION(_ident,_num) lldebug_iteration(_ident,_num)
#define LLDEBUG_TOKEN(_exp,_pos) lldebug_token(_exp,_pos)
#define LLDEBUG_ANYTOKEN(_pos) lldebug_anytoken(_pos)
#define LLDEBUG_BACKTRACKING(_ident) lldebug_backtracking(_ident)
void lldebug_init();
void lldebug_enter(char *ident);
void lldebug_leave(char *ident, int succ);
void lldebug_alternative(char *ident, int alt);
void lldebug_token(int expected, unsigned pos);
void lldebug_anytoken(unsigned pos);
void lldebug_backtracking(char *ident);
void llprinttoken(LLTERM *token, char *identifier, FILE *f);
#else
#define LLDEBUG_ENTER(_ident)
#define LLDEBUG_LEAVE(_ident,_succ)
#define LLDEBUG_ALTERNATIVE(_ident,_alt)
#define LLDEBUG_ITERATION(_ident,_num)
#define LLDEBUG_TOKEN(_exp,_pos)
#define LLDEBUG_ANYTOKEN(_pos)
#define LLDEBUG_BACKTRACKING(_ident)
#endif

int ll_main(LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("main");

llstate_0 = *llin;
#undef failed
#define failed failed1
{LLSTATE llstate_1;
if (!ll_declsect(&llstate_0, &llstate_1)) goto failed1;
{LLSTATE llstate_2;
if (!llterm(PERCENT_PERCENT, (LLSTYPE *)0, &llstate_1, &llstate_2)) goto failed1;
{LLSTATE llstate_3;
if (!ll_rulesect(&llstate_2, &llstate_3)) goto failed1;
{LLSTATE llstate_4;
if (!llterm(PERCENT_PERCENT, (LLSTYPE *)0, &llstate_3, &llstate_4)) goto failed1;
{LLSTATE llstate_5;
if (!ll_csect(&llstate_4, &llstate_5)) goto failed1;
*llout = llstate_5;
}}}}}
LLDEBUG_LEAVE("main", 1);
return 1;
failed1: LLDEBUG_LEAVE("main", 0);
return 0;
}

int ll_declsect(LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("declsect");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("declsect", 1);
{LLSTATE llstate_1;
if (!ll_decl(&llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;
if (!ll_declsect(&llstate_1, &llstate_2)) goto failed2;
*llout = llstate_2;
break;
}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("declsect", 2);
*llout = llstate_0;
#line 94 "parser.ll"
{create_vardefs(); 
#line 144 "parser.c"
break;
}
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("declsect");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("declsect", 1);
return 1;
failed1: LLDEBUG_LEAVE("declsect", 0);
return 0;
}

int ll_decl(LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("decl");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("decl", 1);
{LLSTATE llstate_1;
if (!llterm(PERCENT_TOKEN, (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;
if (!ll_tokens(&llstate_1, &llstate_2, NULL)) goto failed2;
*llout = llstate_2;
break;
}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("decl", 2);
{LLSTATE llstate_1;
if (!llterm(PERCENT_TOKEN, (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;string llatt_2;
if (!ll_tag(&llatt_2, &llstate_1, &llstate_2)) goto failed2;
{LLSTATE llstate_3;
if (!ll_tokens(&llstate_2, &llstate_3, llatt_2)) goto failed2;
*llout = llstate_3;
break;
}}}
case 3: case -3:
LLDEBUG_ALTERNATIVE("decl", 3);
{LLSTATE llstate_1;
if (!llterm(PERCENT_TYPE, (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;
if (!ll_nterms(&llstate_1, &llstate_2, NULL, 0)) goto failed2;
*llout = llstate_2;
break;
}}
case 4: case -4:
LLDEBUG_ALTERNATIVE("decl", 4);
{LLSTATE llstate_1;
if (!llterm(PERCENT_TYPE, (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;string llatt_2;
if (!ll_tag(&llatt_2, &llstate_1, &llstate_2)) goto failed2;
{LLSTATE llstate_3;
if (!ll_nterms(&llstate_2, &llstate_3, llatt_2, 0)) goto failed2;
*llout = llstate_3;
break;
}}}
case 5: case -5:
LLDEBUG_ALTERNATIVE("decl", 5);
{LLSTATE llstate_1;
if (!llterm(PERCENT_EXTERNAL, (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;
if (!ll_nterms(&llstate_1, &llstate_2, NULL, 1)) goto failed2;
*llout = llstate_2;
break;
}}
case 6: case -6:
LLDEBUG_ALTERNATIVE("decl", 6);
{LLSTATE llstate_1;
if (!llterm(PERCENT_EXTERNAL, (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;string llatt_2;
if (!ll_tag(&llatt_2, &llstate_1, &llstate_2)) goto failed2;
{LLSTATE llstate_3;
if (!ll_nterms(&llstate_2, &llstate_3, llatt_2, 1)) goto failed2;
*llout = llstate_3;
break;
}}}
case 7: case -7:
LLDEBUG_ALTERNATIVE("decl", 7);
{LLSTATE llstate_1;
if (!llterm(PERCENT_UNION, (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;
if (!llterm('{', (LLSTYPE *)0, &llstate_1, &llstate_2)) goto failed2;
{LLSTATE llstate_3;
if (!ll_union(&llstate_2, &llstate_3)) goto failed2;
{LLSTATE llstate_4;
if (!llterm('}', (LLSTYPE *)0, &llstate_3, &llstate_4)) goto failed2;
*llout = llstate_4;
#line 104 "parser.ll"
{output("\n"); 
#line 251 "parser.c"
break;
}}}}}
case 8: case -8:
LLDEBUG_ALTERNATIVE("decl", 8);
{LLSTATE llstate_1;
if (!llterm(PERCENT_STATE, (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;
if (!llterm('{', (LLSTYPE *)0, &llstate_1, &llstate_2)) goto failed2;
{LLSTATE llstate_3;
if (!ll_state(&llstate_2, &llstate_3)) goto failed2;
{LLSTATE llstate_4;
if (!llterm('}', (LLSTYPE *)0, &llstate_3, &llstate_4)) goto failed2;
*llout = llstate_4;
#line 106 "parser.ll"
{output("\n"); 
#line 267 "parser.c"
break;
}}}}}
case 9: case -9:
LLDEBUG_ALTERNATIVE("decl", 9);
{LLSTATE llstate_1;
if (!llterm(PERCENT_PREFIX, (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;string llatt_2;
if (!llterm(IDENTIFIER, &lllval, &llstate_1, &llstate_2)) goto failed2;
llatt_2 = lllval._string;
*llout = llstate_2;
#line 108 "parser.ll"
{set_prefix(llatt_2); 
#line 280 "parser.c"
break;
}}}
case 10: case -10:
LLDEBUG_ALTERNATIVE("decl", 10);
{LLSTATE llstate_1;
if (!llterm(PERCENT_MODULE, (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;string llatt_2;
if (!llterm(IDENTIFIER, &lllval, &llstate_1, &llstate_2)) goto failed2;
llatt_2 = lllval._string;
*llout = llstate_2;
#line 110 "parser.ll"
{set_module(llatt_2); 
#line 293 "parser.c"
break;
}}}
case 11: case -11:
LLDEBUG_ALTERNATIVE("decl", 11);
{LLSTATE llstate_1;
if (!llterm(PERCENT_LBRACE, (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;ccode llatt_2;
if (!llterm(CCODE, &lllval, &llstate_1, &llstate_2)) goto failed2;
llatt_2 = lllval._ccode;
{LLSTATE llstate_3;
if (!llterm(PERCENT_RBRACE, (LLSTYPE *)0, &llstate_2, &llstate_3)) goto failed2;
*llout = llstate_3;
#line 112 "parser.ll"
{if (linedirective)
			output("#line %d \"%s\"\n", llstate_2.pos.line, llstate_2.pos.file);
		    output("%s", llatt_2);
		    if (linedirective)
			output_line();
		
#line 313 "parser.c"
break;
}}}}
case 12: case -12:
LLDEBUG_ALTERNATIVE("decl", 12);
{LLSTATE llstate_1;
if (!llterm(PERCENT_START, (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;string llatt_2;
if (!llterm(IDENTIFIER, &lllval, &llstate_1, &llstate_2)) goto failed2;
llatt_2 = lllval._string;
*llout = llstate_2;
#line 119 "parser.ll"
{set_start(llatt_2); 
#line 326 "parser.c"
break;
}}}
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("decl");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("decl", 1);
return 1;
failed1: LLDEBUG_LEAVE("decl", 0);
return 0;
}

int ll_tokens(LLSTATE *llin, LLSTATE *llout, string llarg_tag)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("tokens");

llstate_0 = *llin;
#undef failed
#define failed failed1
{LLSTATE llstate_1;token llatt_1;
if (!ll_token(&llatt_1, &llstate_0, &llstate_1, llarg_tag)) goto failed1;
{LLSTATE llstate_2;
if (!ll_tokens2(&llstate_1, &llstate_2, llarg_tag)) goto failed1;
*llout = llstate_2;
#line 123 "parser.ll"
{create_symbol(0, 0, llarg_tag, llatt_1.identifier, llatt_1.altidentifier,
			NULL);
		
#line 363 "parser.c"
}}}
LLDEBUG_LEAVE("tokens", 1);
return 1;
failed1: LLDEBUG_LEAVE("tokens", 0);
return 0;
}

int ll_tokens2(LLSTATE *llin, LLSTATE *llout, string llarg_tag)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("tokens2");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("tokens2", 1);
{LLSTATE llstate_1;token llatt_1;
if (!ll_token(&llatt_1, &llstate_0, &llstate_1, llarg_tag)) goto failed2;
{LLSTATE llstate_2;
if (!ll_tokens2(&llstate_1, &llstate_2, llarg_tag)) goto failed2;
*llout = llstate_2;
#line 129 "parser.ll"
{create_symbol(0, 0, llarg_tag, llatt_1.identifier, llatt_1.altidentifier,
			NULL);
		
#line 397 "parser.c"
break;
}}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("tokens2", 2);
*llout = llstate_0;
break;
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("tokens2");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("tokens2", 1);
return 1;
failed1: LLDEBUG_LEAVE("tokens2", 0);
return 0;
}

int ll_token(token *llret, LLSTATE *llin, LLSTATE *llout, string llarg_tag)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("token");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("token", 1);
{LLSTATE llstate_1;string llatt_1;
if (!llterm(IDENTIFIER, &lllval, &llstate_0, &llstate_1)) goto failed2;
llatt_1 = lllval._string;
{LLSTATE llstate_2;
if (!llterm('=', (LLSTYPE *)0, &llstate_1, &llstate_2)) goto failed2;
{LLSTATE llstate_3;string llatt_3;
if (!llterm(IDENTIFIER, &lllval, &llstate_2, &llstate_3)) goto failed2;
llatt_3 = lllval._string;
*llout = llstate_3;
#line 136 "parser.ll"
{(*llret).identifier = llatt_1; (*llret).altidentifier = llatt_3; 
#line 448 "parser.c"
break;
}}}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("token", 2);
{LLSTATE llstate_1;string llatt_1;
if (!llterm(IDENTIFIER, &lllval, &llstate_0, &llstate_1)) goto failed2;
llatt_1 = lllval._string;
*llout = llstate_1;
#line 138 "parser.ll"
{(*llret).identifier = llatt_1; (*llret).altidentifier = NULL; 
#line 459 "parser.c"
break;
}}
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("token");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("token", 1);
return 1;
failed1: LLDEBUG_LEAVE("token", 0);
return 0;
}

int ll_nterms(LLSTATE *llin, LLSTATE *llout, string llarg_tag, integer llarg_ext)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("nterms");

llstate_0 = *llin;
#undef failed
#define failed failed1
{LLSTATE llstate_1;nterm llatt_1;
if (!ll_nterm(&llatt_1, &llstate_0, &llstate_1, llarg_tag)) goto failed1;
{LLSTATE llstate_2;
if (!ll_nterms2(&llstate_1, &llstate_2, llarg_tag, llarg_ext)) goto failed1;
*llout = llstate_2;
#line 142 "parser.ll"
{create_symbol(1, llarg_ext, llarg_tag, llatt_1.identifier, NULL, llatt_1.tags);
#line 494 "parser.c"
}}}
LLDEBUG_LEAVE("nterms", 1);
return 1;
failed1: LLDEBUG_LEAVE("nterms", 0);
return 0;
}

int ll_nterms2(LLSTATE *llin, LLSTATE *llout, string llarg_tag, integer llarg_ext)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("nterms2");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("nterms2", 1);
{LLSTATE llstate_1;nterm llatt_1;
if (!ll_nterm(&llatt_1, &llstate_0, &llstate_1, llarg_tag)) goto failed2;
{LLSTATE llstate_2;
if (!ll_nterms2(&llstate_1, &llstate_2, llarg_tag, llarg_ext)) goto failed2;
*llout = llstate_2;
#line 146 "parser.ll"
{create_symbol(1, llarg_ext, llarg_tag, llatt_1.identifier, NULL, llatt_1.tags);
#line 526 "parser.c"
break;
}}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("nterms2", 2);
*llout = llstate_0;
break;
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("nterms2");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("nterms2", 1);
return 1;
failed1: LLDEBUG_LEAVE("nterms2", 0);
return 0;
}

int ll_nterm(nterm *llret, LLSTATE *llin, LLSTATE *llout, string llarg_tag)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("nterm");

llstate_0 = *llin;
#undef failed
#define failed failed1
{LLSTATE llstate_1;string llatt_1;
if (!llterm(IDENTIFIER, &lllval, &llstate_0, &llstate_1)) goto failed1;
llatt_1 = lllval._string;
{LLSTATE llstate_2;strings llatt_2;
if (!ll_tags(&llatt_2, &llstate_1, &llstate_2)) goto failed1;
*llout = llstate_2;
#line 151 "parser.ll"
{(*llret).identifier = llatt_1; (*llret).tags = llatt_2; 
#line 566 "parser.c"
}}}
LLDEBUG_LEAVE("nterm", 1);
return 1;
failed1: LLDEBUG_LEAVE("nterm", 0);
return 0;
}

int ll_tags(strings *llret, LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("tags");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("tags", 1);
{LLSTATE llstate_1;string llatt_1;
if (!ll_tag(&llatt_1, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;strings llatt_2;
if (!ll_tags(&llatt_2, &llstate_1, &llstate_2)) goto failed2;
*llout = llstate_2;
#line 155 "parser.ll"
{(*llret) = llatt_2;
		    memmove((*llret) + 1, (*llret),
			(MAXTAGS - 1) * sizeof(char *));
		    (*llret)[0] = llatt_1;
		
#line 602 "parser.c"
break;
}}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("tags", 2);
*llout = llstate_0;
#line 161 "parser.ll"
{(*llret) = (char **)malloc(MAXTAGS * sizeof(char *));
		    memset((*llret), 0, MAXTAGS * sizeof(char *));
		
#line 612 "parser.c"
break;
}
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("tags");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("tags", 1);
return 1;
failed1: LLDEBUG_LEAVE("tags", 0);
return 0;
}

int ll_tag(string *llret, LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("tag");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("tag", 1);
{LLSTATE llstate_1;
if (!llterm('<', (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;string llatt_2;
if (!llterm(IDENTIFIER, &lllval, &llstate_1, &llstate_2)) goto failed2;
llatt_2 = lllval._string;
{LLSTATE llstate_3;
if (!llterm('>', (LLSTYPE *)0, &llstate_2, &llstate_3)) goto failed2;
*llout = llstate_3;
#line 167 "parser.ll"
{(*llret) = find_tag(llatt_2); 
#line 658 "parser.c"
break;
}}}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("tag", 2);
{LLSTATE llstate_1;
if (!llterm('<', (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;
if (!llterm('>', (LLSTYPE *)0, &llstate_1, &llstate_2)) goto failed2;
*llout = llstate_2;
#line 169 "parser.ll"
{(*llret) = (char *)malloc(strlen(LL) + 6);
		    sprintf((*llret), "%sSTYPE", LL);
		
#line 672 "parser.c"
break;
}}}
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("tag");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("tag", 1);
return 1;
failed1: LLDEBUG_LEAVE("tag", 0);
return 0;
}

int ll_union(LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("union");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("union", 1);
{LLSTATE llstate_1;string llatt_1;
if (!llterm(TAGDEF, &lllval, &llstate_0, &llstate_1)) goto failed2;
llatt_1 = lllval._string;
{LLSTATE llstate_2;
if (!llterm(';', (LLSTYPE *)0, &llstate_1, &llstate_2)) goto failed2;
#line 175 "parser.ll"
{if (!usetypes) incput("typedef %s;\n", llatt_1); 
#line 715 "parser.c"
{LLSTATE llstate_3;
if (!ll_union(&llstate_2, &llstate_3)) goto failed2;
*llout = llstate_3;
break;
}}}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("union", 2);
*llout = llstate_0;
break;
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("union");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("union", 1);
return 1;
failed1: LLDEBUG_LEAVE("union", 0);
return 0;
}

int ll_state(LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("state");

llstate_0 = *llin;
#undef failed
#define failed failed1
#line 181 "parser.ll"
{if (usetypes) {
			incput("typedef %sPOS %sPOS;\n", USETYPES, LL);
			incput("typedef %sSTATE %sSTATE;\n", USETYPES, LL);
		    } else {
			incput("typedef struct %sPOS {\n", LL);
			incput("\tint line;\n");
			incput("\tint column;\n");
			incput("\tchar *file;\n");
			incput("} %sPOS;\n", LL);
			incput("typedef struct %sSTATE {\n", LL);
			incput("\t%sPOS pos;\n", LL);
		    }
		
#line 764 "parser.c"
{LLSTATE llstate_1;
if (!ll_state1(&llstate_0, &llstate_1)) goto failed1;
*llout = llstate_1;
#line 195 "parser.ll"
{if (!usetypes) incput("} %sSTATE;\n", LL); 
#line 770 "parser.c"
}}}
LLDEBUG_LEAVE("state", 1);
return 1;
failed1: LLDEBUG_LEAVE("state", 0);
return 0;
}

int ll_state1(LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("state1");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("state1", 1);
{LLSTATE llstate_1;string llatt_1;
if (!llterm(TAGDEF, &lllval, &llstate_0, &llstate_1)) goto failed2;
llatt_1 = lllval._string;
{LLSTATE llstate_2;
if (!llterm(';', (LLSTYPE *)0, &llstate_1, &llstate_2)) goto failed2;
#line 199 "parser.ll"
{if (!usetypes) incput("\t%s;\n", llatt_1); 
#line 802 "parser.c"
{LLSTATE llstate_3;
if (!ll_state1(&llstate_2, &llstate_3)) goto failed2;
*llout = llstate_3;
break;
}}}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("state1", 2);
*llout = llstate_0;
break;
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("state1");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("state1", 1);
return 1;
failed1: LLDEBUG_LEAVE("state1", 0);
return 0;
}

int ll_rulesect(LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("rulesect");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("rulesect", 1);
{LLSTATE llstate_1;
if (!ll_rule(&llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;
if (!ll_rulesect(&llstate_1, &llstate_2)) goto failed2;
*llout = llstate_2;
break;
}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("rulesect", 2);
*llout = llstate_0;
break;
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("rulesect");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("rulesect", 1);
return 1;
failed1: LLDEBUG_LEAVE("rulesect", 0);
return 0;
}

int ll_rule(LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("rule");

llstate_0 = *llin;
#undef failed
#define failed failed1
{LLSTATE llstate_1;lhs llatt_1;
if (!ll_lhs(&llatt_1, &llstate_0, &llstate_1)) goto failed1;
{LLSTATE llstate_2;rhs llatt_2;
if (!ll_rhss(&llatt_2, &llstate_1, &llstate_2)) goto failed1;
{LLSTATE llstate_3;
if (!llterm(';', (LLSTYPE *)0, &llstate_2, &llstate_3)) goto failed1;
*llout = llstate_3;
#line 211 "parser.ll"
{item_t *item = find_symbol(llatt_1.identifier);
		    /* XXX check llatt_1.args against item */
		    if (!item)
			item = create_symbol(1, 0, NULL, llatt_1.identifier,
			    NULL, NULL);
		    if (item->tag) {
			if (llatt_1.args) {
			    output("int %s_%s(%s *%sret, %s%sSTATE *%sin, %sSTATE *%sout, %s)\n",
			    	ll, llatt_1.identifier, item->tag, ll, conststr, LL,
				ll, LL, ll, llatt_1.args);
			    incput("int %s_%s(%s *%sret, %s%sSTATE *%sin, %sSTATE *%sout, %s);\n",
			    	ll, llatt_1.identifier, item->tag, ll, conststr, LL,
				ll, LL, ll, llatt_1.args);
			} else {
			    output("int %s_%s(%s *%sret, %s%sSTATE *%sin, %sSTATE *%sout)\n",
			    	ll, llatt_1.identifier, item->tag, ll, conststr, LL,
				ll, LL, ll);
			    incput("int %s_%s(%s *%sret, %s%sSTATE *%sin, %sSTATE *%sout);\n",
			    	ll, llatt_1.identifier, item->tag, ll, conststr, LL,
				ll, LL, ll);
			}
		    } else {
			if (llatt_1.args) {
			    output("int %s_%s(%s%sSTATE *%sin, %sSTATE *%sout, %s)\n",
			    	ll, llatt_1.identifier, conststr, LL,
				ll, LL, ll, llatt_1.args);
			    incput("int %s_%s(%s%sSTATE *%sin, %sSTATE *%sout, %s);\n",
			    	ll, llatt_1.identifier, conststr, LL,
				ll, LL, ll, llatt_1.args);
			} else {
			    output("int %s_%s(%s%sSTATE *%sin, %sSTATE *%sout)\n",
			    	ll, llatt_1.identifier, conststr, LL,
				ll, LL, ll);
			    incput("int %s_%s(%s%sSTATE *%sin, %sSTATE *%sout);\n",
			    	ll, llatt_1.identifier, conststr, LL,
				ll, LL, ll);
			}
		    }
		    output("{\n");
		    output("unsigned %sstp = %scstp;\n", ll, ll);
		    output_rhs(llatt_1.identifier, llatt_2);
		    output("}\n");
		    output("\n");
		    add_rules(item, llatt_2);
		
#line 934 "parser.c"
}}}}
LLDEBUG_LEAVE("rule", 1);
return 1;
failed1: LLDEBUG_LEAVE("rule", 0);
return 0;
}

int ll_lhs(lhs *llret, LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("lhs");

llstate_0 = *llin;
#undef failed
#define failed failed1
{LLSTATE llstate_1;string llatt_1;
if (!llterm(IDENTIFIER, &lllval, &llstate_0, &llstate_1)) goto failed1;
llatt_1 = lllval._string;
{LLSTATE llstate_2;string llatt_2;
if (!ll_lhsargs(&llatt_2, &llstate_1, &llstate_2, llatt_1)) goto failed1;
{LLSTATE llstate_3;
if (!llterm(':', (LLSTYPE *)0, &llstate_2, &llstate_3)) goto failed1;
*llout = llstate_3;
#line 259 "parser.ll"
{(*llret).identifier = llatt_1; (*llret).args = llatt_2; 
#line 961 "parser.c"
}}}}
LLDEBUG_LEAVE("lhs", 1);
return 1;
failed1: LLDEBUG_LEAVE("lhs", 0);
return 0;
}

int ll_rhss(rhs *llret, LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("rhss");

llstate_0 = *llin;
#undef failed
#define failed failed1
{LLSTATE llstate_1;rhs llatt_1;
if (!ll_items(&llatt_1, &llstate_0, &llstate_1)) goto failed1;
{LLSTATE llstate_2;rhs llatt_2;
if (!ll_rhss2(&llatt_2, &llstate_1, &llstate_2)) goto failed1;
*llout = llstate_2;
#line 263 "parser.ll"
{(*llret) = (struct rhs_s *)malloc(sizeof(struct rhs_s));
		    (*llret)->type = eAlternative;
		    (*llret)->u.alternative.element = llatt_1;
		    (*llret)->u.alternative.next = llatt_2;
		
#line 989 "parser.c"
}}}
LLDEBUG_LEAVE("rhss", 1);
return 1;
failed1: LLDEBUG_LEAVE("rhss", 0);
return 0;
}

int ll_rhss2(rhs *llret, LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("rhss2");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("rhss2", 1);
{LLSTATE llstate_1;
if (!llterm('|', (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;rhs llatt_2;
if (!ll_items(&llatt_2, &llstate_1, &llstate_2)) goto failed2;
{LLSTATE llstate_3;rhs llatt_3;
if (!ll_rhss2(&llatt_3, &llstate_2, &llstate_3)) goto failed2;
*llout = llstate_3;
#line 271 "parser.ll"
{(*llret) = (struct rhs_s *)malloc(sizeof(struct rhs_s));
		    (*llret)->type = eAlternative;
		    (*llret)->u.alternative.element = llatt_2;
		    (*llret)->u.alternative.next = llatt_3;
		
#line 1027 "parser.c"
break;
}}}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("rhss2", 2);
*llout = llstate_0;
#line 277 "parser.ll"
{(*llret) = NULL; 
#line 1035 "parser.c"
break;
}
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("rhss2");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("rhss2", 1);
return 1;
failed1: LLDEBUG_LEAVE("rhss2", 0);
return 0;
}

int ll_items(rhs *llret, LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("items");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("items", 1);
{LLSTATE llstate_1;rhs llatt_1;
if (!ll_item(&llatt_1, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;bounds llatt_2;
if (!ll_extension(&llatt_2, &llstate_1, &llstate_2)) goto failed2;
{LLSTATE llstate_3;rhs llatt_3;
if (!ll_items(&llatt_3, &llstate_2, &llstate_3)) goto failed2;
*llout = llstate_3;
#line 281 "parser.ll"
{(*llret) = (struct rhs_s *)malloc(sizeof(struct rhs_s));
		    (*llret)->type = eSequence;
		    if (llatt_2.lower != 1 || llatt_2.upper != 1) {
			(*llret)->u.sequence.element =
			    (struct rhs_s *)malloc(sizeof(struct rhs_s));
			(*llret)->u.sequence.element->type = eBounded;
			(*llret)->u.sequence.element->u.bounded.items = llatt_1;
			(*llret)->u.sequence.element->u.bounded.bounds = llatt_2;
		    } else {
			(*llret)->u.sequence.element = llatt_1;
		    }
		    (*llret)->u.sequence.next = llatt_3;
		
#line 1092 "parser.c"
break;
}}}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("items", 2);
*llout = llstate_0;
#line 295 "parser.ll"
{(*llret) = NULL; 
#line 1100 "parser.c"
break;
}
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("items");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("items", 1);
return 1;
failed1: LLDEBUG_LEAVE("items", 0);
return 0;
}

int ll_item(rhs *llret, LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("item");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("item", 1);
{LLSTATE llstate_1;string llatt_1;
if (!llterm(IDENTIFIER, &lllval, &llstate_0, &llstate_1)) goto failed2;
llatt_1 = lllval._string;
{LLSTATE llstate_2;string llatt_2;
if (!ll_args(&llatt_2, &llstate_1, &llstate_2)) goto failed2;
*llout = llstate_2;
#line 299 "parser.ll"
{(*llret) = (struct rhs_s *)malloc(sizeof(struct rhs_s));
		    (*llret)->type = eItem;
		    (*llret)->u.item.identifier = llatt_1;
		    (*llret)->u.item.args = llatt_2;
		
#line 1148 "parser.c"
break;
}}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("item", 2);
{LLSTATE llstate_1;
if (!llterm('[', (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;rhs llatt_2;
if (!ll_rhss(&llatt_2, &llstate_1, &llstate_2)) goto failed2;
{LLSTATE llstate_3;
if (!llterm(']', (LLSTYPE *)0, &llstate_2, &llstate_3)) goto failed2;
*llout = llstate_3;
#line 305 "parser.ll"
{(*llret) = llatt_2;
		
#line 1163 "parser.c"
break;
}}}}
case 3: case -3:
LLDEBUG_ALTERNATIVE("item", 3);
{LLSTATE llstate_1;
if (!llterm('[', (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;rhs llatt_2;
if (!ll_rhss(&llatt_2, &llstate_1, &llstate_2)) goto failed2;
{LLSTATE llstate_3;
if (!llterm(':', (LLSTYPE *)0, &llstate_2, &llstate_3)) goto failed2;
{LLSTATE llstate_4;rhs llatt_4;
if (!ll_rhss(&llatt_4, &llstate_3, &llstate_4)) goto failed2;
{LLSTATE llstate_5;
if (!llterm(']', (LLSTYPE *)0, &llstate_4, &llstate_5)) goto failed2;
*llout = llstate_5;
#line 308 "parser.ll"
{(*llret) = (struct rhs_s *)malloc(sizeof(struct rhs_s));
		    (*llret)->type = eNode;
		    (*llret)->u.node.left = llatt_2;
		    (*llret)->u.node.right = llatt_4;
		
#line 1185 "parser.c"
break;
}}}}}}
case 4: case -4:
LLDEBUG_ALTERNATIVE("item", 4);
{LLSTATE llstate_1;
if (!llterm('{', (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;ccode llatt_2;
if (!llterm(CCODE, &lllval, &llstate_1, &llstate_2)) goto failed2;
llatt_2 = lllval._ccode;
{LLSTATE llstate_3;
if (!llterm('}', (LLSTYPE *)0, &llstate_2, &llstate_3)) goto failed2;
*llout = llstate_3;
#line 314 "parser.ll"
{(*llret) = (struct rhs_s *)malloc(sizeof(struct rhs_s));
		    (*llret)->type = eCCode;
		    (*llret)->u.ccode.ccode = llatt_2;
		    (*llret)->u.ccode.line = llstate_2.pos.line;
		    (*llret)->u.ccode.column = llstate_2.pos.column;
		    (*llret)->u.ccode.file = llstate_2.pos.file;
		
#line 1206 "parser.c"
break;
}}}}
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("item");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("item", 1);
return 1;
failed1: LLDEBUG_LEAVE("item", 0);
return 0;
}

int ll_extension(bounds *llret, LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("extension");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("extension", 1);
{LLSTATE llstate_1;
if (!llterm('+', (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
*llout = llstate_1;
#line 324 "parser.ll"
{(*llret).lower = 1;
		    (*llret).upper = 0;
		
#line 1249 "parser.c"
break;
}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("extension", 2);
{LLSTATE llstate_1;
if (!llterm('*', (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
*llout = llstate_1;
#line 328 "parser.ll"
{(*llret).lower = 0;
		    (*llret).upper = 0;
		
#line 1261 "parser.c"
break;
}}
case 3: case -3:
LLDEBUG_ALTERNATIVE("extension", 3);
{LLSTATE llstate_1;
if (!llterm('?', (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
*llout = llstate_1;
#line 332 "parser.ll"
{(*llret).lower = 0;
		    (*llret).upper = 1;
		
#line 1273 "parser.c"
break;
}}
case 4: case -4:
LLDEBUG_ALTERNATIVE("extension", 4);
*llout = llstate_0;
#line 336 "parser.ll"
{(*llret).lower = 1;
		    (*llret).upper = 1;
		
#line 1283 "parser.c"
break;
}
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("extension");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("extension", 1);
return 1;
failed1: LLDEBUG_LEAVE("extension", 0);
return 0;
}

int ll_lhsargs(string *llret, LLSTATE *llin, LLSTATE *llout, string llarg_ide)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("lhsargs");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("lhsargs", 1);
{LLSTATE llstate_1;
if (!llterm('(', (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
#line 342 "parser.ll"
{item_t *item;
		    item = find_symbol(llarg_ide);
		    if (!item || !item->args || !*item->args) {
			fprintf(stderr,
			    "%s has not been declared to have arguments\n",
			    llarg_ide);
			exit(1);
		    }
		
#line 1331 "parser.c"
{LLSTATE llstate_2;string llatt_2;
if (!ll_lhsarglist(&llatt_2, &llstate_1, &llstate_2, item->args, llarg_ide)) goto failed2;
{LLSTATE llstate_3;
if (!llterm(')', (LLSTYPE *)0, &llstate_2, &llstate_3)) goto failed2;
*llout = llstate_3;
#line 352 "parser.ll"
{(*llret) = llatt_2; 
#line 1339 "parser.c"
break;
}}}}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("lhsargs", 2);
*llout = llstate_0;
#line 354 "parser.ll"
{item_t *item;
		    item = find_symbol(llarg_ide);
		    if (item && item->args && *item->args) {
			fprintf(stderr,
			    "%s has not been declared to have no arguments\n",
			    llarg_ide);
			exit(1);
		    }
		    (*llret) = NULL;
		
#line 1356 "parser.c"
break;
}
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("lhsargs");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("lhsargs", 1);
return 1;
failed1: LLDEBUG_LEAVE("lhsargs", 0);
return 0;
}

int ll_lhsarglist(string *llret, LLSTATE *llin, LLSTATE *llout, strings llarg_tags, string llarg_ide)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("lhsarglist");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("lhsarglist", 1);
{LLSTATE llstate_1;string llatt_1;
if (!llterm(ARG, &lllval, &llstate_0, &llstate_1)) goto failed2;
llatt_1 = lllval._string;
{LLSTATE llstate_2;
if (!llterm(',', (LLSTYPE *)0, &llstate_1, &llstate_2)) goto failed2;
{LLSTATE llstate_3;string llatt_3;
if (!ll_lhsarglist(&llatt_3, &llstate_2, &llstate_3, llarg_tags+1, llarg_ide)) goto failed2;
*llout = llstate_3;
#line 367 "parser.ll"
{if (!*llarg_tags) {
			fprintf(stderr,
			    "%s has not been declared to have so much arguments\n",
			    llarg_ide);
			exit(1);
		    }
		    (*llret) = (char *)malloc(strlen(llatt_1) + strlen(llatt_3) +
			strlen(*llarg_tags) + strlen(conststr) + 10);
		    sprintf((*llret), "%s%s %sarg_%s, %s",
			conststr, *llarg_tags, ll, llatt_1, llatt_3);
		
#line 1412 "parser.c"
break;
}}}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("lhsarglist", 2);
{LLSTATE llstate_1;string llatt_1;
if (!llterm(ARG, &lllval, &llstate_0, &llstate_1)) goto failed2;
llatt_1 = lllval._string;
*llout = llstate_1;
#line 379 "parser.ll"
{if (!*llarg_tags) {
			fprintf(stderr,
			    "%s has not been declared to have so much arguments\n",
			    llarg_ide);
			exit(1);
		    }
		    if (llarg_tags[1]) {
			fprintf(stderr,
			    "%s has not been declared to have so less arguments\n",
			    llarg_ide);
			exit(1);
		    }
		    (*llret) = (char *)malloc(strlen(llatt_1) + strlen(*llarg_tags) +
		    	strlen(conststr) + 8);
		    sprintf((*llret), "%s%s %sarg_%s", conststr, *llarg_tags, ll, llatt_1);
		
#line 1438 "parser.c"
break;
}}
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("lhsarglist");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("lhsarglist", 1);
return 1;
failed1: LLDEBUG_LEAVE("lhsarglist", 0);
return 0;
}

int ll_args(string *llret, LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("args");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("args", 1);
{LLSTATE llstate_1;
if (!llterm('(', (LLSTYPE *)0, &llstate_0, &llstate_1)) goto failed2;
{LLSTATE llstate_2;string llatt_2;
if (!ll_arglist(&llatt_2, &llstate_1, &llstate_2)) goto failed2;
{LLSTATE llstate_3;
if (!llterm(')', (LLSTYPE *)0, &llstate_2, &llstate_3)) goto failed2;
*llout = llstate_3;
#line 398 "parser.ll"
{(*llret) = llatt_2; 
#line 1483 "parser.c"
break;
}}}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("args", 2);
*llout = llstate_0;
#line 400 "parser.ll"
{(*llret) = ""; 
#line 1491 "parser.c"
break;
}
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("args");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("args", 1);
return 1;
failed1: LLDEBUG_LEAVE("args", 0);
return 0;
}

int ll_arglist(string *llret, LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("arglist");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("arglist", 1);
{LLSTATE llstate_1;string llatt_1;
if (!llterm(ARG, &lllval, &llstate_0, &llstate_1)) goto failed2;
llatt_1 = lllval._string;
{LLSTATE llstate_2;
if (!llterm(',', (LLSTYPE *)0, &llstate_1, &llstate_2)) goto failed2;
{LLSTATE llstate_3;string llatt_3;
if (!ll_arglist(&llatt_3, &llstate_2, &llstate_3)) goto failed2;
*llout = llstate_3;
#line 404 "parser.ll"
{char *p = convert(llatt_1);
		    (*llret) = (char *)malloc(strlen(p) + strlen(llatt_3) + 3);
		    strcpy((*llret), p);
		    strcat((*llret), ", ");
		    strcat((*llret), llatt_3);
		
#line 1542 "parser.c"
break;
}}}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("arglist", 2);
{LLSTATE llstate_1;string llatt_1;
if (!llterm(ARG, &lllval, &llstate_0, &llstate_1)) goto failed2;
llatt_1 = lllval._string;
*llout = llstate_1;
#line 411 "parser.ll"
{(*llret) = convert(llatt_1); 
#line 1553 "parser.c"
break;
}}
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("arglist");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("arglist", 1);
return 1;
failed1: LLDEBUG_LEAVE("arglist", 0);
return 0;
}

int ll_csect(LLSTATE *llin, LLSTATE *llout)
{
unsigned llstp = llcstp;
LLSTATE llstate_0;
LLDEBUG_ENTER("csect");

llstate_0 = *llin;
#undef failed
#define failed failed1
#undef failed
#define failed failed2
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
LLDEBUG_ALTERNATIVE("csect", 1);
{LLSTATE llstate_1;ccode llatt_1;
if (!llterm(CCODE, &lllval, &llstate_0, &llstate_1)) goto failed2;
llatt_1 = lllval._ccode;
*llout = llstate_1;
#line 417 "parser.ll"
{if (linedirective)
			output("#line %d \"%s\"\n", llstate_1.pos.line, llstate_1.pos.file);
		    output("%s\n", llatt_1);
		    if (linedirective)
			output_line();
		
#line 1600 "parser.c"
break;
}}
case 2: case -2:
LLDEBUG_ALTERNATIVE("csect", 2);
*llout = llstate_0;
break;
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("csect");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("csect", 1);
return 1;
failed1: LLDEBUG_LEAVE("csect", 0);
return 0;
}

#line 426 "parser.ll"

#line 1625 "parser.c"
int
llparser(LLTERM *tokens, unsigned ntokens, LLSTATE *llin, LLSTATE *llout)
{
unsigned i;
LLDEBUG_ENTER("llparser");
lltokens = tokens; llntokens = ntokens;
for (i = 0; i < llstksize; i++) llstk[i] = 1;
llcstp = 1; llcpos = 0; llepos = 0; *llerrormsg = 0;
#if LLDEBUG > 0
last_linenr = 0; last_file = "";
#endif
{unsigned llpos1 = llcpos, llstp1 = llcstp;
LLCHECKSTK;
for (;;) {
switch (llstk[llcstp++]) {
case 1: case -1:
if (!ll_main(llin, llout)) goto failed2;
if (llcpos != llntokens) goto failed2;
break;
default:
llstk[--llcstp] = 1;
goto failed1;
failed2:
LLDEBUG_BACKTRACKING("llparser");
if (llstk[--llcstp] < 0) llstk[llcstp] = 0; else llstk[llcstp]++;
llcpos = llpos1; llcstp = llstp1;
continue;
} break;
}}
LLDEBUG_LEAVE("llparser", 1);
return 1;
failed1:
LLDEBUG_LEAVE("llparser", 0);
return 0;
}

int
llterm(int token, LLSTYPE *lval, LLSTATE *llin, LLSTATE *llout)
{
#if LLDEBUG > 0
	if (lldebug > 0 && (lltokens[llcpos].pos.line > last_linenr || strcmp(lltokens[llcpos].pos.file, last_file))) {
	fprintf(stderr, "File \"%s\", Line %5d                    \r",
		lltokens[llcpos].pos.file, lltokens[llcpos].pos.line);
	last_linenr = lltokens[llcpos].pos.line / 10 * 10 + 9;
	last_file = lltokens[llcpos].pos.file;
	}
#endif
	if (llstk[llcstp] != 1 && llstk[llcstp] != -1) {
		LLDEBUG_BACKTRACKING("llterm");
		llstk[llcstp] = 1;
		return 0;
	}
	LLDEBUG_TOKEN(token, llcpos);
	if (llcpos < llntokens && lltokens[llcpos].token == token) {
		if (lval)
			*lval = lltokens[llcpos].lval;
		*llout = *llin;
		llout->pos = lltokens[llcpos].pos;
		llcpos++;
		LLCHECKSTK;
		llcstp++;
		return 1;
	}
	llfailed(&lltokens[llcpos].pos, NULL);
	llstk[llcstp] = 1;
	return 0;
}

int
llanyterm(LLSTYPE *lval, LLSTATE *llin, LLSTATE *llout)
{
#if LLDEBUG > 0
	if (lldebug > 0 && (lltokens[llcpos].pos.line > last_linenr || strcmp(lltokens[llcpos].pos.file, last_file))) {
	fprintf(stderr, "File \"%s\", Line %5d                    \r",
		lltokens[llcpos].pos.file, lltokens[llcpos].pos.line);
	last_linenr = lltokens[llcpos].pos.line / 10 * 10 + 9;
	last_file = lltokens[llcpos].pos.file;
	}
#endif
	if (llstk[llcstp] != 1 && llstk[llcstp] != -1) {
		LLDEBUG_BACKTRACKING("llanyterm");
		llstk[llcstp] = 1;
		return 0;
	}
	LLDEBUG_ANYTOKEN(llcpos);
	if (llcpos < llntokens) {
		if (lval)
			*lval = lltokens[llcpos].lval;
		*llout = *llin;
		llout->pos = lltokens[llcpos].pos;
		llcpos++;
		LLCHECKSTK;
		llcstp++;
		return 1;
	}
	llfailed(&lltokens[llcpos].pos, NULL);
	llstk[llcstp] = 1;
	return 0;
}
void
llscanner(LLTERM **tokens, unsigned *ntokens)
{
	unsigned i = 0;
#if LLDEBUG > 0
	int line = -1;
#endif

	*ntokens = 1024;
	*tokens = (LLTERM *)malloc(*ntokens * sizeof(LLTERM));
	while (llgettoken(&(*tokens)[i].token, &(*tokens)[i].lval, &(*tokens)[i].pos)) {
#if LLDEBUG > 0
		if (lldebug > 0 && (*tokens)[i].pos.line > line) {
			line = (*tokens)[i].pos.line / 10 * 10 + 9;
			fprintf(stderr, "File \"%s\", Line %5d                    \r",
				(*tokens)[i].pos.file, (*tokens)[i].pos.line);
		}
#endif
		if (++i >= *ntokens) {
			*ntokens *= 2;
			*tokens = (LLTERM *)realloc(*tokens, *ntokens * sizeof(LLTERM));
		}
	}
	(*tokens)[i].token = 0;
	*ntokens = i;
#if LLDEBUG > 0
	lldebug_init();
#endif
	llresizestk();
}

void
llfailed(LLPOS *pos, char *fmt, ...)
{
	va_list args;

	va_start(args, fmt);
	if (llcpos > llepos || llcpos == llepos && !*llerrormsg) {
		llepos = llcpos;
		if (fmt)
			vsprintf(llerrormsg, fmt, args);
		else
			*llerrormsg = 0;
		llerrorpos = *pos;
	}
	va_end(args);
}

void
llprinterror(FILE *f)
{
#if LLDEBUG > 0
	fputs("                                \r", stderr);
#endif
	if (*llerrormsg)
		llerror(f, &llerrorpos, llerrormsg);
	else
		llerror(f, &llerrorpos, "Syntax error");
}

void
llerror(FILE *f, LLPOS *pos, char *fmt, ...)
{
	va_list args;
	va_start(args, fmt);
	llverror(f, pos, fmt, args);
	va_end(args);
}

void
llresizestk()
{
	unsigned i;

	if (llcstp + 1 >= llstksize) {
		i = llstksize;
		if (!llstksize)
			llstk = (int *)malloc((llstksize = 4096) * sizeof(int));
		else
			llstk = (int *)realloc(llstk, (llstksize *= 2) * sizeof(int));
		for (; i < llstksize; i++)
			llstk[i] = 1;
	}
}

#if LLDEBUG > 0
int lldepth;
char *lltokentab[] = {
"EOF","#1","#2","#3","#4","#5","#6","#7"
,"#8","#9","#10","#11","#12","#13","#14","#15"
,"#16","#17","#18","#19","#20","#21","#22","#23"
,"#24","#25","#26","#27","#28","#29","#30","#31"
,"' '","'!'","'\"'","'#'","'$'","'%'","'&'","'''"
,"'('","')'","'*'","'+'","','","'-'","'.'","'/'"
,"'0'","'1'","'2'","'3'","'4'","'5'","'6'","'7'"
,"'8'","'9'","':'","';'","'<'","'='","'>'","'?'"
,"'@'","'A'","'B'","'C'","'D'","'E'","'F'","'G'"
,"'H'","'I'","'J'","'K'","'L'","'M'","'N'","'O'"
,"'P'","'Q'","'R'","'S'","'T'","'U'","'V'","'W'"
,"'X'","'Y'","'Z'","'['","'\\'","']'","'^'","'_'"
,"'`'","'a'","'b'","'c'","'d'","'e'","'f'","'g'"
,"'h'","'i'","'j'","'k'","'l'","'m'","'n'","'o'"
,"'p'","'q'","'r'","'s'","'t'","'u'","'v'","'w'"
,"'x'","'y'","'z'","'{'","'|'","'}'","'~'","#127"
,"#128","#129","#130","#131","#132","#133","#134","#135"
,"#136","#137","#138","#139","#140","#141","#142","#143"
,"#144","#145","#146","#147","#148","#149","#150","#151"
,"#152","#153","#154","#155","#156","#157","#158","#159"
,"#160","#161","#162","#163","#164","#165","#166","#167"
,"#168","#169","#170","#171","#172","#173","#174","#175"
,"#176","#177","#178","#179","#180","#181","#182","#183"
,"#184","#185","#186","#187","#188","#189","#190","#191"
,"#192","#193","#194","#195","#196","#197","#198","#199"
,"#200","#201","#202","#203","#204","#205","#206","#207"
,"#208","#209","#210","#211","#212","#213","#214","#215"
,"#216","#217","#218","#219","#220","#221","#222","#223"
,"#224","#225","#226","#227","#228","#229","#230","#231"
,"#232","#233","#234","#235","#236","#237","#238","#239"
,"#240","#241","#242","#243","#244","#245","#246","#247"
,"#248","#249","#250","#251","#252","#253","#254","#255"
,"#256","IDENTIFIER","ARG","CCODE","TAGDEF","PERCENT_PERCENT","PERCENT_TOKEN","PERCENT_TYPE"
,"PERCENT_EXTERNAL","PERCENT_UNION","PERCENT_STATE","PERCENT_START","PERCENT_PREFIX","PERCENT_MODULE","PERCENT_LBRACE","PERCENT_RBRACE"
};

void
lldebug_init()
{
	char *p;
	p = getenv("LLDEBUG");
	if (p)
		lldebug = atoi(p);
}

void
lldebug_enter(char *ident)
{
	int i;

	if (lldebug < 2)
		return;
	for (i = 0; i < lldepth; i++)
		fputs("| ", stdout);
	printf("/--- trying rule %s\n", ident);
	lldepth++;
}

void
lldebug_leave(char *ident, int succ)
{
	int i;

	if (lldebug < 2)
		return;
	lldepth--;
	for (i = 0; i < lldepth; i++)
		fputs("| ", stdout);
	if (succ)
		printf("\\--- succeeded to apply rule %s\n", ident);
	else
		printf("\\--- failed to apply rule %s\n", ident);
}

void
lldebug_alternative(char *ident, int alt)
{
	int i;

	if (lldebug < 2)
		return;
	for (i = 0; i < lldepth - 1; i++)
		fputs("| ", stdout);
	printf(">--- trying alternative %d for rule %s\n", alt, ident);
}

lldebug_iteration(char *ident, int num)
{
	int i;

	if (lldebug < 2)
		return;
	for (i = 0; i < lldepth - 1; i++)
		fputs("| ", stdout);
	printf(">--- trying iteration %d for rule %s\n", num, ident);
}

void
lldebug_token(int expected, unsigned pos)
{
	int i;

	if (lldebug < 2)
		return;
	for (i = 0; i < lldepth; i++)
		fputs("| ", stdout);
	if (pos < llntokens && expected == lltokens[pos].token)
		printf("   found token ");
	else
		printf("   expected token %s, found token ", lltokentab[expected]);
	if (pos >= llntokens)
		printf("<EOF>");
	else
		llprinttoken(lltokens + pos, lltokentab[lltokens[pos].token], stdout);
	putchar('\n');
}

void
lldebug_anytoken(unsigned pos)
{
	int i;

	if (lldebug < 2)
		return;
	for (i = 0; i < lldepth; i++)
		fputs("| ", stdout);
	printf("   found token ");
	if (pos >= llntokens)
		printf("<EOF>");
	else
		llprinttoken(lltokens + pos, lltokentab[lltokens[pos].token], stdout);
	putchar('\n');
}

void
lldebug_backtracking(char *ident)
{
	int i;

	if (lldebug < 2)
		return;
	for (i = 0; i < lldepth; i++)
		fputs("| ", stdout);
	printf("   backtracking rule %s\n", ident);
}

#endif