/*
 * A n t l r  T r a n s l a t i o n  H e a d e r
 *
 * Terence Parr, Hank Dietz and Will Cohen: 1989, 1990, 1991
 * Purdue University Electrical Engineering
 * ANTLR Version 1.00
 */
#ident "$Id$"
#ifdef LL_K
#undef LL_K
#endif
#define LL_K	1
#define ZZLEXBUFSIZE        17000
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* typedef long Attrib; */
#include "utility.h"
#include "dbtype.h"
#include "language_support.h"
#include "message_catalog.h"
#include "int.h"
#include "loader.h"
#define ZZERRSTD_SUPPLIED 1
#define ZZSYNSUPPLIED     1
extern void ldr_push_c(long c);
int Lex_Buffer_Size;
long ldr_reread[10];
long ldr_rereadtop;
/*
* This little piece of state is required to tell us whether we should be
* interpreting double-quoted strings as delimited identifiers or as
* backward-compatible string literals.
*
* Be careful about when you set this: it's very easy to be thwarted by
* the lookahead mechanism.  Initializing it in act_init() isn't good
* enough, because by the time act_init() has been called we've already
* consumed the first token of input, and "initialization" may undo
* anything that the first token production might have done.  That's very
* bad news if the first token in a CMD_ID or CMD_CLASS token.
*/
int in_instance_line;
#include "memory_alloc.h"
#include "zzpref.h"
#include "antlr.h"
#include "loader_grammar_tokens.h"
#include "dlgdef.h"
#include "loader_grammar_mode.h"
ANTLR_INFO
/* Input function type for loader.  */
FILE *input;
/* Input function type for loader.  */
int (*ldr_lang_fgetc)(FILE * input_stream)=fgetc;
static void init_loader_lang(void)
{
	/* Set the appropriate language handler */
	ldr_lang_fgetc = fgetc;
}
long get_next()
{
	if (ldr_rereadtop > 0) {
		--ldr_rereadtop;
		return ldr_reread[ldr_rereadtop];
	}
	return ((ldr_lang_fgetc)(input));
}
void do_loader_parse(FILE *fp)
{
	input = fp;
	init_loader_lang();
	/*
	* Pretend that the first line we'll see is an instance line; if it
	* isn't, this state flag will be set to 0 by the CMD_ID or CMD_CLASS
	* tokens.  Do this before starting the parser, or the effects of
	* lookahead processing will make you lose if the first line is a
	* command line (which it almost always is).
	*/
	in_instance_line = 1;
	ANTLRf(loader_lines(), get_next);
}
#define zzEOF_TOKEN 1
void zzsyn(const char *text, long tok, const char *egroup,
unsigned long *eset, long etok)
{
	if (zzEOF_TOKEN == tok
	&& eset && strstr(zzedecode(eset), "EOF")) {
		/* This patch eliminates "expecting EOF at EOF" messages.
		* The parser generator has a bug which consumes
		* the EOF token, and generates another EOF token
		* that does not match. zzEOF_TOKEN is always 1,
		* and is always all of the tokens read after EOF.
		* The EOF token is some generated value besides 1.
		*/
		return;
	}
	ldr_increment_err_total(ldr_Current_context);
	fprintf(stderr, msgcat_message (MSGCAT_CATALOG_UTILS,
	MSGCAT_UTIL_SET_LOADDB,
	LOADDB_MSG_SYNTAX_ERR),
	zzlineLA[0], (tok==zzEOF_TOKEN)?"EOF":text);
	fprintf(stderr, " %s ", msgcat_message (MSGCAT_CATALOG_UTILS,
	MSGCAT_UTIL_SET_LOADDB,
	LOADDB_MSG_SYNTAX_MISSING));
	if ( !etok && eset) fprintf(stderr, "%s", zzedecode(eset));
	else fprintf(stderr, "%s", zztokens[etok]);
	if ( strlen(egroup) > 0 ) {
		fprintf(stderr, " ");
		fprintf(stderr, msgcat_message (MSGCAT_CATALOG_UTILS,
		MSGCAT_UTIL_SET_LOADDB,
		LOADDB_MSG_SYNTAX_IN), egroup);
	}
	fprintf(stderr, "\n");
}
static int String_Body_Size;
static char *String_Buffer = NULL;
static int String_Buffer_Size = 0;
/*
* Japanized migdb must not use default error report function,
* because one 8bit-set character is not printable.
* So, Japanese version must have its own error report function.
*/
void zzerrstd(s)
const char *s;
{
	long length;
	char buffer[DB_MAX_IDENTIFIER_LENGTH * 2];
	if (LANG_VARIABLE_CHARSET(lang_charset())) {
		length = strlen(zzlextext);
		if (length > 0) {
			if (((zzlextext[length - 1]) & (0x80) ) != 0) {
				strcpy(buffer, zzlextext);
				buffer[length] = (unsigned char)zzchar;
				buffer[length+1] = '\0';
				zzreplstr(buffer);
			}
		}
	}
	strcpy(buffer, msgcat_message (MSGCAT_CATALOG_UTILS,
	MSGCAT_UTIL_SET_LOADDB,
	LOADDB_MSG_LEX_ERROR));
	fprintf(stderr, msgcat_message (MSGCAT_CATALOG_UTILS,
	MSGCAT_UTIL_SET_LOADDB,
	LOADDB_MSG_STD_ERR),
	((s == NULL) ? buffer : s),
	zzline,
	((zzlextext == NULL) ? "" : zzlextext));
}

static void eof()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(1); zzCONSUME;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x1);
	}
}

static void end_of_line()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(NL);
	in_instance_line = 1; 
	zzCONSUME;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x2);
	}
}

static void loader_lines()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		while ( 1 ) {
			if ( (zzsetwd1[LA(1)]&0x4) ) {
				one_line();
			}
			else if ( (LA(1)==NL) ) {
				end_of_line();
			}
			else break;
			zzLOOP(zztasp2);
		}
		zzEXIT(zztasp2);
		}
	}
	eof();
	ldr_act_finish(ldr_Current_context, 0); 
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	ldr_act_finish(ldr_Current_context, 1); 
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x8);
	}
}

static void one_line()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	if ( (zzsetwd1[LA(1)]&0x10) ) {
		command_line();
	}
	else if ( (zzsetwd1[LA(1)]&0x20) ) {
		{
			zzBLOCK(zztasp2);
			zzMake0;
			{
			instance_line();
			ldr_act_finish_line(ldr_Current_context);
			zzEXIT(zztasp2);
			}
		}
	}
	else zzFAIL(zzerr1);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x40);
	}
}

static void command_line()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	if ( (LA(1)==CMD_CLASS) ) {
		class_command();
	}
	else if ( (LA(1)==CMD_ID) ) {
		id_command();
	}
	else zzFAIL(zzerr2);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x80);
	}
}

static void id_command()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(CMD_ID); zzCONSUME;
	zzmatch(IDENTIFIER);
	skipCurrentclass = false;
	ldr_act_start_id(ldr_Current_context, zzlextext);
	zzCONSUME;
	zzmatch(INT_LIT);
	ldr_act_set_id(ldr_Current_context, zzaArg(zztasp1,3)); 
	zzCONSUME;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x100);
	}
}

static void class_command()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(CMD_CLASS); zzCONSUME;
	zzmatch(IDENTIFIER);
	ldr_act_set_skipCurrentclass (zzlextext, strlen(zzlextext));
	ldr_act_init_context(ldr_Current_context, zzlextext, strlen(zzlextext));
	zzCONSUME;
	attribute_list_qualifier();
	attribute_list();
	constructor_spec();
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x200);
	}
}

static void attribute_list_qualifier()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	if ( (LA(1)==CLASS) ) {
		zzmatch(CLASS);
		ldr_act_restrict_attributes(ldr_Current_context,
		LDR_ATTRIBUTE_CLASS); 
		zzCONSUME;
	}
	else if ( (LA(1)==SHARED) ) {
		zzmatch(SHARED);
		ldr_act_restrict_attributes(ldr_Current_context,
		LDR_ATTRIBUTE_SHARED); 
		zzCONSUME;
	}
	else if ( (LA(1)==DEFAULT) ) {
		zzmatch(DEFAULT);
		ldr_act_restrict_attributes(ldr_Current_context,
		LDR_ATTRIBUTE_DEFAULT); 
		zzCONSUME;
	}
	else if ( (LA(1)==46) ) {
	}
	else zzFAIL(zzerr3);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x400);
	}
}

static void attribute_list()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(46); zzCONSUME;
	attribute_names();
	zzmatch(47);
	ldr_act_check_missing_non_null_attrs(ldr_Current_context); 
	zzCONSUME;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x800);
	}
}

static void attribute_names()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	if ( (LA(1)==IDENTIFIER) ) {
		{
			zzBLOCK(zztasp2);
			zzMake0;
			{
			attribute_name();
			{
				zzBLOCK(zztasp3);
				zzMake0;
				{
				while ( (zzsetwd1[LA(1)]&0x1000) ) {
					{
						zzBLOCK(zztasp4);
						zzMake0;
						{
						if ( (LA(1)==48) ) {
							zzmatch(48); zzCONSUME;
						}
						else if ( (LA(1)==IDENTIFIER) ) {
						}
						else zzFAIL(zzerr4);
						zzEXIT(zztasp4);
						}
					}
					attribute_name();
					zzLOOP(zztasp3);
				}
				zzEXIT(zztasp3);
				}
			}
			zzEXIT(zztasp2);
			}
		}
	}
	else if ( (LA(1)==47) ) {
	}
	else zzFAIL(zzerr5);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x2000);
	}
}

static void attribute_name()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(IDENTIFIER);
	ldr_act_add_attr(ldr_Current_context, zzlextext, strlen(zzlextext));
	zzCONSUME;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x4000);
	}
}

static void constructor_spec()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	if ( (LA(1)==CMD_CONSTRUCTOR) ) {
		zzmatch(CMD_CONSTRUCTOR); zzCONSUME;
		zzmatch(IDENTIFIER);
		ldr_act_set_constructor(ldr_Current_context, zzlextext);
		zzCONSUME;
		constructor_argument_list();
	}
	else if ( (zzsetwd1[LA(1)]&0x8000) ) {
	}
	else zzFAIL(zzerr6);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x10000);
	}
}

static void constructor_argument_list()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(46); zzCONSUME;
	argument_names();
	zzmatch(47); zzCONSUME;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x20000);
	}
}

static void argument_names()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	if ( (LA(1)==IDENTIFIER) ) {
		{
			zzBLOCK(zztasp2);
			zzMake0;
			{
			argument_name();
			{
				zzBLOCK(zztasp3);
				zzMake0;
				{
				while ( (zzsetwd1[LA(1)]&0x40000) ) {
					{
						zzBLOCK(zztasp4);
						zzMake0;
						{
						if ( (LA(1)==48) ) {
							zzmatch(48); zzCONSUME;
						}
						else if ( (LA(1)==IDENTIFIER) ) {
						}
						else zzFAIL(zzerr7);
						zzEXIT(zztasp4);
						}
					}
					argument_name();
					zzLOOP(zztasp3);
				}
				zzEXIT(zztasp3);
				}
			}
			zzEXIT(zztasp2);
			}
		}
	}
	else if ( (LA(1)==47) ) {
	}
	else zzFAIL(zzerr8);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x80000);
	}
}

static void argument_name()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(IDENTIFIER);
	ldr_act_add_argument(ldr_Current_context, zzlextext);
	zzCONSUME;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x100000);
	}
}

static void instance_line()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	if ( (LA(1)==OID) ) {
		{
			zzBLOCK(zztasp2);
			zzMake0;
			{
			object_id();
			{
				zzBLOCK(zztasp3);
				zzMake0;
				{
				if ( (zzsetwd1[LA(1)]&0x200000) ) {
					{
						zzBLOCK(zztasp4);
						zzMake0;
						{
						constant();
						{
							zzBLOCK(zztasp5);
							zzMake0;
							{
							while ( (zzsetwd1[LA(1)]&0x400000) ) {
								constant();
								zzLOOP(zztasp5);
							}
							zzEXIT(zztasp5);
							}
						}
						zzEXIT(zztasp4);
						}
					}
				}
				else if ( (zzsetwd1[LA(1)]&0x800000) ) {
				}
				else zzFAIL(zzerr9);
				zzEXIT(zztasp3);
				}
			}
			zzEXIT(zztasp2);
			}
		}
	}
	else if ( (zzsetwd1[LA(1)]&0x1000000) ) {
		{
			zzBLOCK(zztasp2);
			zzMake0;
			{
			null_id();
			{
				zzBLOCK(zztasp3);
				zzMake0;
				{
				constant();
				{
					zzBLOCK(zztasp4);
					zzMake0;
					{
					while ( (zzsetwd1[LA(1)]&0x2000000) ) {
						constant();
						zzLOOP(zztasp4);
					}
					zzEXIT(zztasp4);
					}
				}
				zzEXIT(zztasp3);
				}
			}
			zzEXIT(zztasp2);
			}
		}
	}
	else zzFAIL(zzerr10);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x4000000);
	}
}

static void null_id()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	ldr_act_start_instance(ldr_Current_context, -1); 
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x8000000);
	}
}

static void object_id()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(OID);
	ldr_act_start_instance(ldr_Current_context, (zzaArg(zztasp1,1))); 
	zzCONSUME;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x10000000);
	}
}

static void class_identifier()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	if ( (LA(1)==INT_LIT) ) {
		zzmatch(INT_LIT);
		ldr_act_set_ref_class_id(ldr_Current_context, (zzaArg(zztasp1,1)));
		zzCONSUME;
	}
	else if ( (LA(1)==IDENTIFIER) ) {
		zzmatch(IDENTIFIER);
		ldr_act_set_ref_class(ldr_Current_context, zzlextext);
		zzCONSUME;
	}
	else zzFAIL(zzerr11);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x20000000);
	}
}

static void object_reference()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(OBJECT_REFERENCE); zzCONSUME;
	class_identifier();
	instance_number();
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd1, 0x40000000);
	}
}

static void instance_number()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	if ( (LA(1)==49) ) {
		{
			zzBLOCK(zztasp2);
			zzMake0;
			{
			zzmatch(49); zzCONSUME;
			zzmatch(INT_LIT);
			{
				bool ignore_class = false;
				char * class_name;
				DB_OBJECT *ref_class = NULL;
				ldr_act_set_instance_id(ldr_Current_context, zzaArg(zztasp2,2));
				ref_class = ldr_act_get_ref_class(ldr_Current_context);
				if (ref_class != NULL)
				{
					class_name = db_get_class_name (ref_class);
					ignore_class =
					ldr_is_ignore_class(class_name, strlen(class_name));
				}
				(*ldr_act)(ldr_Current_context, zzlextext, strlen(zzlextext),
				(ignore_class)?LDR_NULL:LDR_OID);
			}
			zzCONSUME;
			zzEXIT(zztasp2);
			}
		}
	}
	else if ( (zzsetwd1[LA(1)]&0x80000000) ) {
		{
			bool ignore_class = false;
			char * class_name;
			DB_OBJECT *ref_class = NULL;
			ldr_act_set_instance_id(ldr_Current_context, zzaArg(zztasp1,2));
			ref_class = ldr_act_get_ref_class(ldr_Current_context);
			if (ref_class != NULL)
			{
				class_name = db_get_class_name (ref_class);
				ignore_class =
				ldr_is_ignore_class(class_name, strlen(class_name));
			}
			(*ldr_act)(ldr_Current_context, zzlextext, strlen(zzlextext),
			(ignore_class)?LDR_NULL:LDR_CLASS_OID);
		}
	}
	else zzFAIL(zzerr12);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x1);
	}
}

static void set_constant()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(SET_START_BRACE);
	(*ldr_act)(ldr_Current_context,
	zzlextext,
	strlen(zzlextext),
	LDR_COLLECTION); 
	zzCONSUME;
	set_elements();
	zzmatch(SET_END_BRACE);
	ldr_act_attr(ldr_Current_context, NULL, 0,
	LDR_COLLECTION); 
	zzCONSUME;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x2);
	}
}

static void set_elements()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	if ( (zzsetwd2[LA(1)]&0x4) ) {
		{
			zzBLOCK(zztasp2);
			zzMake0;
			{
			constant();
			{
				zzBLOCK(zztasp3);
				zzMake0;
				{
				while ( (zzsetwd2[LA(1)]&0x8) ) {
					{
						zzBLOCK(zztasp4);
						zzMake0;
						{
						if ( (LA(1)==48) ) {
							zzmatch(48); zzCONSUME;
						}
						else if ( (zzsetwd2[LA(1)]&0x10) ) {
						}
						else zzFAIL(zzerr13);
						zzEXIT(zztasp4);
						}
					}
					{
						zzBLOCK(zztasp4);
						zzMake0;
						{
						if ( (LA(1)==NL) ) {
							zzmatch(NL); zzCONSUME;
						}
						zzEXIT(zztasp4);
						}
					}
					constant();
					zzLOOP(zztasp3);
				}
				zzEXIT(zztasp3);
				}
			}
			zzEXIT(zztasp2);
			}
		}
	}
	else if ( (LA(1)==SET_END_BRACE) ) {
	}
	else zzFAIL(zzerr14);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x20);
	}
}

static void elo_internal()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(REF_ELO_INT); zzCONSUME;
	sys_string(LDR_ELO_INT);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x40);
	}
}

static void elo_external()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(REF_ELO_EXT); zzCONSUME;
	sys_string(LDR_ELO_EXT);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x80);
	}
}

static void user_object()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(REF_USER); zzCONSUME;
	sys_string(LDR_SYS_USER);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x100);
	}
}

static void class_object()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(REF_CLASS); zzCONSUME;
	sys_string(LDR_SYS_CLASS);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x200);
	}
}

static void system_object_reference()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	if ( (LA(1)==REF_ELO_INT) ) {
		elo_internal();
	}
	else if ( (LA(1)==REF_ELO_EXT) ) {
		elo_external();
	}
	else if ( (LA(1)==REF_USER) ) {
		user_object();
	}
	else if ( (LA(1)==REF_CLASS) ) {
		class_object();
	}
	else zzFAIL(zzerr15);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x400);
	}
}

static void currency()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	if ( (LA(1)==DOLLAR_SYMBOL) ) {
		zzmatch(DOLLAR_SYMBOL); zzCONSUME;
	}
	else if ( (LA(1)==YEN_SYMBOL) ) {
		zzmatch(YEN_SYMBOL); zzCONSUME;
	}
	else if ( (LA(1)==WON_SYMBOL) ) {
		zzmatch(WON_SYMBOL); zzCONSUME;
	}
	else if ( (LA(1)==BACKSLASH) ) {
		zzmatch(BACKSLASH); zzCONSUME;
	}
	else zzFAIL(zzerr16);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x800);
	}
}

static void monetary()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	currency();
	zzmatch(REAL_LIT);
	(*ldr_act)(ldr_Current_context, zzlextext, strlen(zzlextext),
	LDR_MONETARY);
	zzCONSUME;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x1000);
	}
}

static void constant()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	if ( (LA(1)==Quote) ) {
		ansi_string();
	}
	else if ( (LA(1)==DQS_String_Body) ) {
		dq_string();
	}
	else if ( (LA(1)==NQuote) ) {
		nchar_string();
	}
	else if ( (zzsetwd2[LA(1)]&0x2000) ) {
		bit_string();
	}
	else if ( (LA(1)==DATE) ) {
		sql2_date();
	}
	else if ( (LA(1)==TIME) ) {
		sql2_time();
	}
	else if ( (LA(1)==TIMESTAMP) ) {
		sql2_timestamp();
	}
	else if ( (LA(1)==UTIME) ) {
		utime();
	}
	else if ( (LA(1)==NULL_) ) {
		zzmatch(NULL_);
		(*ldr_act)(ldr_Current_context, NULL, 0, LDR_NULL); 
		zzCONSUME;
	}
	else if ( (LA(1)==TIME_LIT4) ) {
		zzmatch(TIME_LIT4);
		(*ldr_act)(ldr_Current_context, zzlextext,
		strlen(zzlextext), LDR_TIME); 
		zzCONSUME;
	}
	else if ( (LA(1)==TIME_LIT42) ) {
		zzmatch(TIME_LIT42);
		(*ldr_act)(ldr_Current_context, zzlextext,
		strlen(zzlextext), LDR_TIME); 
		zzCONSUME;
	}
	else if ( (LA(1)==TIME_LIT3) ) {
		zzmatch(TIME_LIT3);
		(*ldr_act)(ldr_Current_context, zzlextext,
		strlen(zzlextext), LDR_TIME); 
		zzCONSUME;
	}
	else if ( (LA(1)==TIME_LIT31) ) {
		zzmatch(TIME_LIT31);
		(*ldr_act)(ldr_Current_context, zzlextext,
		strlen(zzlextext), LDR_TIME); 
		zzCONSUME;
	}
	else if ( (LA(1)==TIME_LIT2) ) {
		zzmatch(TIME_LIT2);
		(*ldr_act)(ldr_Current_context, zzlextext,
		strlen(zzlextext), LDR_TIME); 
		zzCONSUME;
	}
	else if ( (LA(1)==TIME_LIT1) ) {
		zzmatch(TIME_LIT1);
		(*ldr_act)(ldr_Current_context, zzlextext,
		strlen(zzlextext), LDR_TIME); 
		zzCONSUME;
	}
	else if ( (LA(1)==INT_LIT) ) {
		zzmatch(INT_LIT);
		(*ldr_act)(ldr_Current_context, zzlextext,
		strlen(zzlextext), LDR_INT); 
		zzCONSUME;
	}
	else if ( (LA(1)==REAL_LIT) ) {
		zzmatch(REAL_LIT);
		/* Float notation */
		if (strchr(zzlextext, 'F') != NULL  ||
		strchr(zzlextext, 'f') != NULL) {
			(*ldr_act)(ldr_Current_context, zzlextext,
			strlen(zzlextext), LDR_FLOAT);
		} else  {
			/* Scientific Notation */
			if (strchr(zzlextext, 'E') != NULL  ||
			strchr(zzlextext, 'e') != NULL ) {
				(*ldr_act)(ldr_Current_context, zzlextext,
				strlen(zzlextext), LDR_DOUBLE);
			} else {  /* regular numeric */
				(*ldr_act)(ldr_Current_context, zzlextext,
				strlen(zzlextext), LDR_NUMERIC);
			}
		}
		zzCONSUME;
	}
	else if ( (LA(1)==DATE_LIT2) ) {
		zzmatch(DATE_LIT2);
		(*ldr_act)(ldr_Current_context, zzlextext,
		strlen(zzlextext), LDR_DATE); 
		zzCONSUME;
	}
	else if ( (zzsetwd2[LA(1)]&0x4000) ) {
		monetary();
	}
	else if ( (LA(1)==OBJECT_REFERENCE) ) {
		object_reference();
	}
	else if ( (LA(1)==SET_START_BRACE) ) {
		set_constant();
	}
	else if ( (zzsetwd2[LA(1)]&0x8000) ) {
		system_object_reference();
	}
	else zzFAIL(zzerr17);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x10000);
	}
}

static void ansi_string()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(Quote); zzCONSUME;
	string_body();
	(*ldr_act)(ldr_Current_context, String_Buffer,
	String_Body_Size, LDR_STR);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x20000);
	}
}

static void nchar_string()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(NQuote); zzCONSUME;
	string_body();
	(*ldr_act)(ldr_Current_context,
	String_Buffer,
	String_Body_Size,
	LDR_NSTR);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x40000);
	}
}

static void dq_string()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(DQS_String_Body);
	(*ldr_act)(ldr_Current_context,
	zzlextext,
	strlen(zzlextext),
	LDR_STR);
	zzCONSUME;
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x80000);
	}
}

static void sql2_date()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(DATE); zzCONSUME;
	zzmatch(Quote); zzCONSUME;
	string_body();
	(*ldr_act)(ldr_Current_context, String_Buffer, String_Body_Size,
	LDR_DATE); 
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x100000);
	}
}

static void sql2_time()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(TIME); zzCONSUME;
	zzmatch(Quote); zzCONSUME;
	string_body();
	(*ldr_act)(ldr_Current_context, String_Buffer, String_Body_Size,
	LDR_TIME); 
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x200000);
	}
}

static void sql2_timestamp()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(TIMESTAMP); zzCONSUME;
	zzmatch(Quote); zzCONSUME;
	string_body();
	(*ldr_act)(ldr_Current_context, String_Buffer, String_Body_Size,
	LDR_TIMESTAMP); 
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x400000);
	}
}

static void utime()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(UTIME); zzCONSUME;
	zzmatch(Quote); zzCONSUME;
	string_body();
	(*ldr_act)(ldr_Current_context, String_Buffer, String_Body_Size,
	LDR_TIMESTAMP); 
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x800000);
	}
}

static void bit_string()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	if ( (LA(1)==BQuote) ) {
		zzmatch(BQuote); zzCONSUME;
		string_body();
		(*ldr_act)(ldr_Current_context, String_Buffer,
		strlen(String_Buffer), LDR_BSTR); 
	}
	else if ( (LA(1)==XQuote) ) {
		zzmatch(XQuote); zzCONSUME;
		string_body();
		(*ldr_act)(ldr_Current_context, String_Buffer,
		strlen(String_Buffer), LDR_XSTR); 
	}
	else zzFAIL(zzerr18);
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x1000000);
	}
}

static void sys_string(LDR_TYPE context)
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	zzmatch(Quote); zzCONSUME;
	string_body();
	(*ldr_act)(ldr_Current_context, String_Buffer,
	strlen(String_Buffer), context); 
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x2000000);
	}
}

static void string_body()
{
	zzRULE;
	zzBLOCK(zztasp1);
	zzMake0;
	{
	int current;
	if (String_Buffer == NULL) {
		String_Buffer_Size = 100;
		String_Buffer = malloc(String_Buffer_Size);
	}
	String_Body_Size = 0;
	current = 0;
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		while ( (LA(1)==String_Prefix) ) {
			zzmatch(String_Prefix);
			current = String_Body_Size;
			String_Body_Size += Lex_Buffer_Size;
			if (String_Body_Size >= String_Buffer_Size) {
				String_Buffer_Size= String_Body_Size +1;
				String_Buffer = realloc
				(String_Buffer, String_Buffer_Size);
			}
			memcpy(&String_Buffer[current], zzlextext, Lex_Buffer_Size);
			zzCONSUME;
			zzmatch(NL); zzCONSUME;
			zzmatch(Quote); zzCONSUME;
			zzLOOP(zztasp2);
		}
		zzEXIT(zztasp2);
		}
	}
	{
		zzBLOCK(zztasp2);
		zzMake0;
		{
		current = String_Body_Size;
		String_Body_Size += Lex_Buffer_Size;
		if (String_Body_Size >= String_Buffer_Size) {
			String_Buffer_Size= String_Body_Size +1;
			String_Buffer = realloc
			(String_Buffer, String_Buffer_Size);
		}
		memcpy(&String_Buffer[current], zzlextext, Lex_Buffer_Size);
		String_Buffer[String_Body_Size] = 0;
		{
			zzBLOCK(zztasp3);
			zzMake0;
			{
			if ( (LA(1)==String_Completion) ) {
				zzmatch(String_Completion); zzCONSUME;
			}
			else if ( (LA(1)==String_Completion2) ) {
				zzmatch(String_Completion2); zzCONSUME;
			}
			else zzFAIL(zzerr19);
			zzEXIT(zztasp3);
			}
		}
		zzEXIT(zztasp2);
		}
	}
	zzEXIT(zztasp1);
	return;
fail:
	zzEXIT(zztasp1);
	zzsyn(zzlextext, LA(1), "", zzMissSet, zzMissTok);
	zzresynch(zzsetwd2, 0x4000000);
	}
}