Utils/Parser Generator/INCLUDE/clex.h

@@ -0,0 +1,237 @@
+#ifndef CLEX_H
+#define CLEX_H
+
+/************************************************************
+clex.h
+This file can be freely modified for the generation of
+custom code.
+
+Copyright (c) 1999 Bumble-Bee Software Ltd.
+************************************************************/
+
+#include <stdio.h>
+#include <assert.h>
+
+// defines
+#include <yytdefs.h>
+
+// user defines
+#if defined(YYTUDEFS) || defined(YYUDEFS)
+#include <yytudefs.h>
+#endif
+
+#define YY_ALEX
+
+// modifiers
+#ifndef YYCDECL
+#define YYCDECL
+#endif
+#ifndef YYDCDECL
+#define YYDCDECL
+#endif
+#ifndef YYNEAR
+#define YYNEAR
+#endif
+#ifndef YYFAR
+#define YYFAR
+#endif
+#ifndef YYNEARFAR
+#define YYNEARFAR
+#endif
+#ifndef YYBASED_CODE
+#define YYBASED_CODE
+#endif
+
+// forward references
+class YYFAR yyparser;
+
+// yylex return values
+#define YYEOF 0			// end of file
+
+#ifndef YYSTATE_T
+#define YYSTATE_T
+typedef struct yystate {
+	short def;			// default state
+	short base;			// base
+	short match;		// action associated with state
+} yystate_t;
+#endif
+
+#ifndef YYTRANSITION_T
+#define YYTRANSITION_T
+typedef struct yytransition {
+	short next;			// next state on transition
+	short check;		// check
+} yytransition_t;
+#endif
+
+#ifndef YYCTRANSITION_T
+#define YYCTRANSITION_T
+typedef struct yyctransition {
+	unsigned char first;	// first character in range
+	unsigned char last;		// last character in range
+	short next;				// next state on transition
+} yyctransition_t;
+#endif
+
+typedef short yymatch_t;
+typedef unsigned char yybackup_t;
+
+class YYFAR yylexer {
+public:
+	yylexer();
+	virtual ~yylexer();
+
+// Attributes
+protected:
+	// left context
+	int yystart;					// current start state
+	unsigned char yyeol;			// whether an end-of-line '\n' has been seen
+	unsigned char yyoldeol;			// previous end-of-line value
+
+	// text buffer
+	int YYFAR* yystatebuf;			// state buffer
+	int YYFAR* yysstatebuf;			// initial (static) state buffer
+	char YYFAR* yystext;			// initial (static) text buffer
+	int yytext_size;				// text buffer size
+	int yystext_size;				// initial (static) text buffer size
+
+	// unput buffer
+	int YYFAR* yyunputbufptr;		// unput buffer
+	int YYFAR* yysunputbufptr;		// initial (static) unput buffer
+	int yyunput_size;				// unput buffer size
+	int yysunput_size;				// initial (static) unput buffer size
+	int yyunputindex;				// unput buffer position
+
+	// actions
+	unsigned char yymoreflg;		// concatenate matched strings
+	unsigned char yyrejectflg;		// yyreject called from an action
+	unsigned char yyreturnflg;		// return from an action
+public:
+	yyparser YYFAR* yyparserptr;	// pointer to the attached parser
+
+	// buffer flags
+	unsigned char yytextgrow;		// whether text buffer is allowed to grow
+	unsigned char yyunputgrow;		// whether unput buffer is allowed to grow
+
+	// streams
+	FILE YYFAR* yyin;				// input text stream
+	FILE YYFAR* yyout;				// output text stream
+	FILE YYFAR* yyerr;				// error stream
+
+	// matched string
+	char YYFAR* yytext;				// text buffer
+	int yyleng;						// matched string length
+	int yylineno;					// current line number
+
+// Operations
+protected:
+	// helper functions
+	int yyback(const yymatch_t YYNEARFAR* p, int action) const;
+public:
+	// instance functions
+	int yycreate(yyparser YYFAR* parserptr = NULL);
+	void yydestroy();
+
+	// general functions
+	void yycleanup();
+	virtual int yylex() = 0;
+	void yyreset();
+	int yysettextsize(int size);
+	int yysetunputsize(int size);
+
+	// service functions
+	virtual int yyinput();
+	virtual void yyoutput(int ch);
+	virtual void yyunput(int ch);
+	virtual int yywrap();
+	virtual int yygetchar();
+	virtual void yytextoverflow();
+	virtual void yyunputoverflow();
+	virtual int yyaction(int action) = 0;
+
+	// action functions
+	void yyecho();
+	void yyless(int length);
+	void yybegin(int state) { yystart = state; }
+	void yymore() { yymoreflg = 1; }
+	void yynewline(int newline) { newline ? yyeol = 1 : (yyeol = 0); }
+	void yyreject() { yyrejectflg = 1; }
+	int yyunputcount() const { return yyunputindex; }
+
+	// compatibility
+	int yyclex() { return yylex(); }
+	void yylexcleanup() { yycleanup(); }
+	void yylexinit() { /* do nothing */ }
+#define BEGIN yystart = 
+#define ECHO yyecho()
+#define REJECT yyreject()
+#define YYSTATE yystart
+#define YY_START yystart
+
+// Tables
+protected:
+	const yymatch_t YYNEARFAR* yymatch;
+	const yystate_t YYNEARFAR* yystate;
+	const yybackup_t YYNEARFAR* yybackup;
+
+// Debugging
+#ifdef YYDEBUG
+public:
+	int yydebug;					// whether debug information should be output
+	int yydebugflush;				// whether debug output should be flushed
+	FILE YYFAR* yydebugout;			// debug output file
+protected:
+	void yydebugoutput(int ch) const;
+	void yydmatch(int expr) const;
+	void yydebugoutput(const char* string) const;
+#endif
+};
+
+class YYFAR yyflexer : public yylexer {
+public:
+	yyflexer() { /* do nothing */ }
+
+// Operations
+public:
+	virtual int yylex();
+
+// Tables
+protected:
+	const yytransition_t YYNEARFAR* yytransition;
+	int yytransitionmax;
+};
+
+class YYFAR yyclexer : public yylexer {
+public:
+	yyclexer() { /* do nothing */ }
+
+// Operations
+public:
+	virtual int yylex();
+
+// Tables
+protected:
+	const yyctransition_t YYNEARFAR* yyctransition;
+};
+
+// helper functions
+#ifndef yyassert
+#define yyassert(expr) assert(expr)
+#endif
+
+// debugging variables
+#ifdef YYDEBUG
+extern "C" int YYNEAR YYDCDECL yydebug;
+extern "C" int YYNEAR YYDCDECL yydebugflush;
+#endif
+
+// user defines
+#if defined(YYBUDEFS) || defined(YYUDEFS)
+#include <yybudefs.h>
+#endif
+
+// defines
+#include <yybdefs.h>
+
+#endif

Utils/Parser Generator/INCLUDE/cyacc.h

@@ -0,0 +1,375 @@
+#ifndef CYACC_H
+#define CYACC_H
+
+/************************************************************
+cyacc.h
+This file can be freely modified for the generation of
+custom code.
+
+Copyright (c) 1999 Bumble-Bee Software Ltd.
+************************************************************/
+
+#include <stdio.h>
+#include <stddef.h>
+#include <assert.h>
+
+// defines
+#include <yytdefs.h>
+
+// user defines
+#if defined(YYTUDEFS) || defined(YYUDEFS)
+#include <yytudefs.h>
+#endif
+
+#define YY_AYACC
+
+// modifiers
+#ifndef YYCDECL
+#define YYCDECL
+#endif
+#ifndef YYDCDECL
+#define YYDCDECL
+#endif
+#ifndef YYNEAR
+#define YYNEAR
+#endif
+#ifndef YYFAR
+#define YYFAR
+#endif
+#ifndef YYNEARFAR
+#define YYNEARFAR
+#endif
+#ifndef YYBASED_CODE
+#define YYBASED_CODE
+#endif
+
+// forward references
+class YYFAR yylexer;
+
+typedef short yystack_t;
+
+// yyparse return values
+#define YYEXIT_SUCCESS	0
+#define YYEXIT_FAILURE	1
+
+// common tokens
+#define YYTK_ALL		(-1)		// match all tokens
+#define YYTK_END		0			// $end token
+#define YYTK_ERROR		256			// error token
+
+#ifndef YYCSTATEGOTO_T
+#define YYCSTATEGOTO_T
+typedef short yycstategoto_t;
+#endif
+
+#ifndef YYCNONTERMGOTO_T
+#define YYCNONTERMGOTO_T
+typedef struct yycnontermgoto {
+	short nonterm;					// nonterminal
+	short next;						// next state
+} yycnontermgoto_t;
+#endif
+
+#ifndef YYSTATEGOTO_T
+#define YYSTATEGOTO_T
+typedef struct yystategoto {
+	short base;						// base
+	short def;						// default state
+} yystategoto_t;
+#endif
+
+#ifndef YYNONTERMGOTO_T
+#define YYNONTERMGOTO_T
+typedef struct yynontermgoto {
+	short check;					// check
+	short next;						// next state
+} yynontermgoto_t;
+#endif
+
+// action types
+#define YYAT_SHIFT		0			// shift action
+#define YYAT_REDUCE		1			// reduce action
+#define YYAT_ERROR		2			// error
+#define YYAT_ACCEPT		3			// accept
+#define YYAT_DEFAULT	4			// default state
+
+#ifndef YYCSTATEACTION_T
+#define YYCSTATEACTION_T
+typedef short yycstateaction_t;
+#endif
+
+#ifndef YYCTOKENACTION_T
+#define YYCTOKENACTION_T
+typedef struct yyctokenaction {
+	int token;						// lookahead token
+	unsigned char type;				// action to perform
+	short sr;						// state to shift/production to reduce
+} yyctokenaction_t;
+#endif
+
+#ifndef YYSTATEACTION_T
+#define YYSTATEACTION_T
+typedef struct yystateaction {
+	short base;						// base
+	unsigned char lookahead;		// lookahead needed
+	unsigned char type;				// action to perform
+	short sr;						// shift/reduce
+} yystateaction_t;
+#endif
+
+#ifndef YYTOKENACTION_T
+#define YYTOKENACTION_T
+typedef struct yytokenaction {
+	short check;					// check
+	unsigned char type;				// action type
+	short sr;						// shift/reduce
+} yytokenaction_t;
+#endif
+
+// nonterminals
+#define YYNT_ALL		(-1)		// match all nonterminals
+
+// states
+#define YYST_ERROR		(-1)		// goto error
+
+#ifndef YYREDUCTION_T
+#define YYREDUCTION_T
+typedef struct yyreduction {
+	short nonterm;					// the rhs symbol
+	short length;					// number of symbols on lhs
+	short action;					// the user action
+} yyreduction_t;
+#endif
+
+typedef short yydestructor_t;
+
+typedef short yytokendest_t;
+
+#ifndef YYCTOKENDEST_T
+#define YYCTOKENDEST_T
+typedef struct yyctokendest {
+	int token;						/* token */
+	short action;					/* the user action */
+} yyctokendest_t;
+#endif
+
+// debugging
+#ifdef YYDEBUG
+#ifndef YYSYMBOL_T
+#define YYSYMBOL_T
+typedef struct yysymbol {
+	const char* name;				// symbol name
+	int token;						// symbol token
+} yysymbol_t;
+#endif
+#endif
+
+class YYFAR yyparser {
+public:
+	yyparser();
+	virtual ~yyparser();
+
+// Attributes
+protected:
+	// stack
+	yystack_t YYFAR* yystackptr;		// (state) stack
+	yystack_t YYFAR* yysstackptr;		// static (state) stack
+	void YYFAR* yyattributestackptr;	// attribute stack
+	void YYFAR* yysattributestackptr;	// static attribute stack
+	int yystack_size;					// number of elements in stack
+	int yysstack_size;					// initial number of elements in stack
+
+	int yytop;							// the current top of the stack
+	size_t yyattribute_size;			// size of attribute
+
+	void YYFAR* yyvalptr;				// attribute for $$
+
+	// lookahead token
+	unsigned char yylookahead;			// whether current lookahead token is valid
+	int yychar;							// current lookahead token
+
+	// error recovery
+	unsigned char yywipeflg;			// whether to "wipe" stack on abort
+	unsigned char yypopflg;				// popping symbols during error recovery
+	int yyskip;							// error recovery token shift counter
+
+	// actions
+	unsigned char yyexitflg;			// whether yymexit called
+	unsigned char yyretireflg;			// whether yymretire called
+	unsigned char yyerrorflg;			// whether yymforceerror called
+	int yyexitcode;						// yymexit exit code
+	int yyretirecode;					// yymretire exit code
+	int yyerrorpop;						// how many error transitions to pop
+public:
+	yylexer YYFAR* yylexerptr;			// pointer to the attached lexical analyser
+
+	unsigned char yystackgrow;			// whether stack can grow
+	void YYFAR* yylvalptr;				// current token attribute
+	FILE YYFAR* yyerr;					// error output file
+	int yyerrorcount;					// how many syntax errors have occurred
+
+// Operations
+protected:
+	virtual void yyaction(int action) = 0;
+
+// utility functions
+#ifdef YYDEBUG
+	void yypop(int num);
+	void yysetskip(int skip);
+#else
+	void yypop(int num) { yytop -= num; }
+	void yysetskip(int skip) { yyskip = skip; }
+#endif
+	int yypush(yystack_t state);
+	yystack_t yypeek() const { return yystackptr[yytop]; }
+
+public:
+	// instance functions
+	int yycreate(yylexer YYFAR* lexerptr = NULL);
+	void yydestroy();
+
+	// general functions
+	void yydestructpop(int num);
+	int yyparse();
+	void yycleanup();
+	int yysetstacksize(int size);
+	int yysetup();
+	void yywipe();
+	virtual int yywork() = 0;
+	virtual void yydestructclearin() = 0;
+
+	// service functions
+	virtual void yystackoverflow();
+	virtual void yyerror(const char YYFAR* text);
+	virtual void yysyntaxerror();
+	virtual void yydiscard(int token);
+	virtual int yygettoken();
+
+	// action functions
+	void yysetin(int token);
+	int yyunclearin();
+	void yyabort() { yyexit(1); }
+	void yyaccept() { yyexit(0); }
+#ifndef YY_COMPATIBLE
+	void yyclearin() { yylookahead = 0; }
+	void yyerrok() { yysetskip(0); }
+#else
+	void _yyclearin() { yylookahead = 0; }
+	void _yyerrok() { yysetskip(0); }
+#endif
+	void yyexit(int exitcode) { yyexitflg = 1; yyexitcode = exitcode; }
+	void yyforceerror() { yythrowerror(0); }
+	int yypopping() const { return yypopflg; }
+	int yyrecovering() const { return yyskip > 0; }
+	void yyretire(int retirecode) { yyretireflg = 1; yyretirecode = retirecode; }
+	void yythrowerror(int pop) { yyerrorflg = 1; yyerrorpop = pop; }
+
+	// compatibility
+	int yycparse() { return yyparse(); }
+	int yycwork() { return yywork(); }
+	void yyparsecleanup() { yycleanup(); }
+	void yyparseinit() { /* do nothing */ }
+#ifdef YY_COMPATIBLE
+#define yyclearin _yyclearin()
+#define yyerrok _yyerrok()
+#endif
+#define YYABORT yyexit(1)
+#define YYACCEPT yyexit(0)
+#define YYERROR yyforceerror()
+#define YYRECOVERING yyrecovering()
+
+// Tables
+protected:
+	const yyreduction_t YYNEARFAR* yyreduction;
+	const yydestructor_t YYNEARFAR* yydestructorptr;
+
+// Debugging
+#ifdef YYDEBUG
+public:
+	int yydebug;				// whether debug information should be output
+	int yydebugstack;			// whether stack debug information should be output
+	int yydebugflush;			// whether debug output should be flushed
+	FILE YYFAR* yydebugout;		// debug output file
+protected:
+	const yysymbol_t YYNEARFAR* yysymbol;
+	const char* const YYNEARFAR* yyrule;
+
+	// debugging functions
+protected:
+	const char* yytokenstring(int token) const;
+	void yydgettoken(int token) const;
+	void yydshift(int token) const;
+	void yydreduce(int rule) const;
+	void yydsyntaxerror() const;
+	void yydaccept() const;
+	void yydabort() const;
+	void yyddiscard(int token) const;
+	void yydexit(int exitcode) const;
+	void yydthrowerror(int errorpop) const;
+	void yydretire(int retirecode) const;
+	void yydattemptrecovery() const;
+	void yydebugoutput(const char *string) const;
+#endif
+};
+
+class YYFAR yyfparser : public yyparser {
+public:
+	yyfparser() { /* do nothing */ }
+
+// Operations
+public:
+	virtual int yywork();
+	virtual void yydestructclearin();
+
+// Tables
+protected:
+	const yystateaction_t YYNEARFAR* yystateaction;
+	const yytokenaction_t YYNEARFAR* yytokenaction;
+	int yytokenaction_size;
+	const yystategoto_t YYNEARFAR* yystategoto;
+	const yynontermgoto_t YYNEARFAR* yynontermgoto;
+	int yynontermgoto_size;
+	const yytokendest_t YYNEARFAR* yytokendestptr;
+	int yytokendest_size;
+	int yytokendestbase;
+};
+
+class YYFAR yycparser : public yyparser {
+public:
+	yycparser() { /* do nothing */ }
+
+// Operations
+public:
+	virtual int yywork();
+	virtual void yydestructclearin();
+
+// Tables
+protected:
+	const yycstateaction_t YYNEARFAR* yycstateaction;
+	const yyctokenaction_t YYNEARFAR* yyctokenaction;
+	const yycstategoto_t YYNEARFAR* yycstategoto;
+	const yycnontermgoto_t YYNEARFAR* yycnontermgoto;
+	const yyctokendest_t YYNEARFAR* yyctokendestptr;
+};
+
+// utility functions
+#ifndef yyassert
+#define yyassert(expr) assert(expr)
+#endif
+
+// debugging variables
+#ifdef YYDEBUG
+extern "C" int YYNEAR YYDCDECL yydebug;
+extern "C" int YYNEAR YYDCDECL yydebugstack;
+extern "C" int YYNEAR YYDCDECL yydebugflush;
+#endif
+
+// user defines
+#if defined(YYBUDEFS) || defined(YYUDEFS)
+#include <yybudefs.h>
+#endif
+
+// defines
+#include <yybdefs.h>
+
+#endif

Utils/Parser Generator/INCLUDE/lex.h

@@ -0,0 +1,259 @@
+#ifndef LEX_H
+#define LEX_H
+
+/************************************************************
+lex.h
+This file can be freely modified for the generation of
+custom code.
+
+Copyright (c) 1999 Bumble-Bee Software Ltd.
+************************************************************/
+
+#include <stdio.h>
+#include <assert.h>
+
+/* defines */
+#include <yytdefs.h>
+
+/* user defines */
+#if defined(YYTUDEFS) || defined(YYUDEFS)
+#include <yytudefs.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define YY_ALEX
+
+/* modifiers */
+#ifndef YYCDECL
+#define YYCDECL
+#endif
+#ifndef YYDCDECL
+#define YYDCDECL
+#endif
+#ifndef YYNEAR
+#define YYNEAR
+#endif
+#ifndef YYFAR
+#define YYFAR
+#endif
+#ifndef YYNEARFAR
+#define YYNEARFAR
+#endif
+#ifndef YYBASED_CODE
+#define YYBASED_CODE
+#endif
+
+/* function prototypes */
+#ifndef YYPROTOTYPE
+#if defined(__STDC__) || defined(__cplusplus)
+#define YYPROTOTYPE
+#endif
+#endif
+
+/* qualifiers */
+#ifndef YYCONST
+#if defined(__STDC__) || defined(__cplusplus)
+#define YYCONST const
+#else
+#define YYCONST
+#endif
+#endif
+
+/* testing */
+#ifdef YYNOPROTOTYPE
+#undef YYPROTOTYPE
+#endif
+#ifdef YYNOCONST
+#undef YYCONST
+#define YYCONST
+#endif
+
+/* yylex return values */
+#define YYEOF 0			/* end of file */
+
+#ifndef YYSTATE_T
+#define YYSTATE_T
+typedef struct yystate {
+	short def;			/* default state */
+	short base;			/* base */
+	short match;		/* action associated with state */
+} yystate_t;
+#endif
+
+#ifndef YYTRANSITION_T
+#define YYTRANSITION_T
+typedef struct yytransition {
+	short next;			/* next state on transition */
+	short check;		/* check */
+} yytransition_t;
+#endif
+
+#ifndef YYCTRANSITION_T
+#define YYCTRANSITION_T
+typedef struct yyctransition {
+	unsigned char first;	/* first character in range */
+	unsigned char last;		/* last character in range */
+	short next;				/* next state on transition */
+} yyctransition_t;
+#endif
+
+typedef short yymatch_t;
+typedef unsigned char yybackup_t;
+
+/* general functions */
+#ifdef YYPROTOTYPE
+int YYCDECL yyclex(void);
+int YYCDECL yylex(void);
+void YYCDECL yylexcleanup(void);
+void YYCDECL yylexinit(void);
+void YYCDECL yyreset(void);
+int YYCDECL yysettextsize(int size);
+int YYCDECL yysetunputsize(int size);
+#else
+int YYCDECL yyclex();
+int YYCDECL yylex();
+void YYCDECL yylexcleanup();
+void YYCDECL yylexinit();
+void YYCDECL yyreset();
+int YYCDECL yysettextsize();
+int YYCDECL yysetunputsize();
+#endif
+
+/* service functions */
+#ifdef YYPROTOTYPE
+int YYCDECL yygetchar(void);
+int YYCDECL yyinput(void);
+void YYCDECL yyoutput(int ch);
+void YYCDECL yytextoverflow(void);
+void YYCDECL yyunput(int ch);
+void YYCDECL yyunputoverflow(void);
+int YYCDECL yywrap(void);
+#else
+int YYCDECL yygetchar();
+int YYCDECL yyinput();
+void YYCDECL yyoutput();
+void YYCDECL yytextoverflow();
+void YYCDECL yyunput();
+void YYCDECL yyunputoverflow();
+int YYCDECL yywrap();
+#endif
+
+/* action functions */
+#ifdef YYPROTOTYPE
+void YYCDECL yyecho(void);
+void YYCDECL yyless(int length);
+#else
+void YYCDECL yyecho();
+void YYCDECL yyless();
+#endif
+#define yybegin(state) (yystart = (state))
+#define yymore() (yymoreflg = 1)
+#define yynewline(newline) ((newline) ? yyeol = 1 : (yyeol = 0))
+#define yyreject() (yyrejectflg = 1)
+#define yyunputcount() yyunputindex
+
+/* compatibility */
+#define BEGIN yystart = 
+#define ECHO yyecho()
+#define REJECT yyreject()
+#define YYSTATE yystart
+#define YY_START yystart
+
+/* helper functions */
+#ifdef YYPROTOTYPE
+int YYCDECL yyback(YYCONST yymatch_t YYNEARFAR *p, int action);
+#else
+int YYCDECL yyback();
+#endif
+#ifndef yyassert
+#define yyassert(expr) assert(expr)
+#endif
+
+/* variables */
+extern unsigned char YYNEAR YYDCDECL yymoreflg;
+extern unsigned char YYNEAR YYDCDECL yyrejectflg;
+extern unsigned char YYNEAR YYDCDECL yyreturnflg;
+extern unsigned char YYNEAR YYDCDECL yytextgrow;
+extern unsigned char YYNEAR YYDCDECL yyunputgrow;
+extern unsigned char YYNEAR YYDCDECL yyeol;
+extern unsigned char YYNEAR YYDCDECL yyoldeol;
+extern int YYNEAR YYDCDECL yystart;
+
+extern FILE YYFAR *YYNEAR YYDCDECL yyin;
+extern FILE YYFAR *YYNEAR YYDCDECL yyout;
+extern FILE YYFAR *YYNEAR YYDCDECL yylexerr;
+
+extern int YYNEAR YYDCDECL yyleng;
+extern int YYNEAR YYDCDECL yylineno;
+extern int YYNEAR YYDCDECL yyunputindex;
+
+/* debugging functions */
+#ifdef YYDEBUG
+#ifdef YYPROTOTYPE
+void YYCDECL yydebugoutput(int ch);
+void YYCDECL yydmatch(int expr);
+void YYCDECL yylexdebugoutput(YYCONST char *string);
+#else
+void YYCDECL yydebugoutput();
+void YYCDECL yydmatch();
+void YYCDECL yylexdebugoutput();
+#endif
+#endif
+
+/* debugging variables */
+#ifdef YYDEBUG
+extern int YYNEAR YYDCDECL yydebug;
+extern int YYNEAR YYDCDECL yydebugflush;
+extern int YYNEAR YYDCDECL yylexdebug;
+extern int YYNEAR YYDCDECL yylexdebugflush;
+extern FILE YYFAR *YYNEAR YYDCDECL yylexdebugout;
+#endif
+
+/* externally defined */
+#ifdef YYPROTOTYPE
+int YYCDECL yylexaction(int action);
+#else
+int YYCDECL yylexaction();
+#endif
+
+extern char YYFAR *YYNEAR YYDCDECL yytext;
+extern char YYFAR *YYNEAR YYDCDECL yystext;
+extern int YYNEAR YYDCDECL yytext_size;
+extern int YYNEAR YYDCDECL yystext_size;
+
+extern int YYFAR *YYNEAR YYDCDECL yystatebuf;
+extern int YYFAR *YYNEAR YYDCDECL yysstatebuf;
+
+/* unput buffer */
+extern int YYFAR *YYNEAR YYDCDECL yyunputbufptr;
+extern int YYFAR *YYNEAR YYDCDECL yysunputbufptr;
+extern int YYNEAR YYDCDECL yyunput_size;
+extern int YYNEAR YYDCDECL yysunput_size;
+
+/* fast lexical analyser */
+extern YYCONST yytransition_t YYNEARFAR YYDCDECL yytransition[];
+extern int YYNEAR YYDCDECL yytransitionmax;
+
+/* compact lexical analyser */
+extern YYCONST yyctransition_t YYNEARFAR YYDCDECL yyctransition[];
+
+extern YYCONST yymatch_t YYNEARFAR YYDCDECL yymatch[];
+extern YYCONST yystate_t YYNEARFAR YYDCDECL yystate[];
+extern YYCONST yybackup_t YYNEARFAR YYDCDECL yybackup[];
+
+#ifdef __cplusplus
+}
+#endif
+
+/* user defines */
+#if defined(YYBUDEFS) || defined(YYUDEFS)
+#include <yybudefs.h>
+#endif
+
+/* defines */
+#include <yybdefs.h>
+
+#endif

Utils/Parser Generator/INCLUDE/milconv.h

@@ -0,0 +1,88 @@
+#ifndef MILCONV_H
+#define MILCONV_H
+
+/************************************************************
+milconv.h
+This file can be freely modified for the generation of
+custom code.
+
+Copyright (c) 1999 Bumble-Bee Software Ltd.
+************************************************************/
+
+/* variables */
+#define yymoreflg (yy)->yymmoreflg
+#define yyrejectflg (yy)->yymrejectflg
+#define yyreturnflg (yy)->yymreturnflg
+#define yytextgrow (yy)->yymtextgrow
+#define yyunputgrow (yy)->yymunputgrow
+#define yyeol (yy)->yymeol
+#define yyoldeol (yy)->yymoldeol
+#define yystart (yy)->yymstart
+#define yyin (yy)->yymin
+#define yyout (yy)->yymout
+#define yylexerr (yy)->yymerr
+#define yyleng (yy)->yymleng
+#define yylineno (yy)->yymlineno
+#define yyunputindex (yy)->yymunputindex
+#define yytext (yy)->yymtext
+#define yystext (yy)->yymstext
+#define yytext_size (yy)->yymtext_size
+#define yystext_size (yy)->yymstext_size
+#define yystatebuf (yy)->yymstatebuf
+#define yysstatebuf (yy)->yymsstatebuf
+#define yyunputbufptr (yy)->yymunputbufptr
+#define yysunputbufptr (yy)->yymsunputbufptr
+#define yyunput_size (yy)->yymunputbufptr
+#define yysunput_size (yy)->yymsunput_size
+#define yylexdebug (yy)->yymdebug
+#define yylexdebugflush (yy)->yymdebugflush
+#define yylexdebugout (yy)->yymdebugout
+
+/* general functions */
+#define yylexinit() yymlexinit(yy)
+#define yylex() yymlex(yy)
+#define yyclex() yymclex(yy)
+#define yyreset() yymreset(yy)
+#define yylexcleanup() yymlexcleanup(yy)
+#define yysettextsize(size) yymsettextsize(yy, (size))
+#define yysetunputsize(size) yymsetunputsize(yy, (size))
+
+/* service functions */
+#define yyinput() (*yy->yyminput)(yy)
+#define yyoutput(ch) (*yy->yymoutput)(yy, (ch))
+#define yyunput(ch) (*yy->yymunput)(yy, (ch))
+#define yywrap() (*yy->yymwrap)(yy)
+#define yygetchar() (*yy->yymgetchar)(yy)
+#define yytextoverflow() (*yy->yymtextoverflow)(yy)
+#define yyunputoverflow() (*yy->yymunputoverflow)(yy)
+
+/* action functions */
+#define yybegin(state) yymbegin(yy, (state))
+#define yyecho() yymecho(yy)
+#define yyless(length) yymless(yy, (length))
+#define yymore() yymmore(yy)
+#define yynewline(newline) yymnewline(yy, (newline))
+#define yyreject() yymreject(yy)
+#define yyunputcount() yymunputcount(yy)
+
+/* compatibility */
+#define ECHO yyecho()
+#define REJECT yyreject()
+#define BEGIN (yy)->yymstart = 
+#define YYSTATE (yy)->yymstart
+#define YY_START (yy)->yymstart
+
+#ifndef input
+#define input() (*yy->yyminput)(yy)
+#define YY_INPUT
+#endif
+#ifndef output
+#define output(ch) (*yy->yymoutput)(yy, (ch))
+#define YY_OUTPUT
+#endif
+#ifdef unput
+#define unput(ch) (*yy->yymunput)(yy, (ch))
+#define YY_UNPUT
+#endif
+
+#endif

Utils/Parser Generator/INCLUDE/miyconv.h

@@ -0,0 +1,90 @@
+#ifndef MIYCONV_H
+#define MIYCONV_H
+
+/************************************************************
+miyconv.h
+This file can be freely modified for the generation of
+custom code.
+
+Copyright (c) 1999 Bumble-Bee Software Ltd.
+************************************************************/
+
+/* variables */
+#define yylookahead (yy)->yymlookahead
+#define yystackgrow (yy)->yymstackgrow
+#define yyexitflg (yy)->yymexitflg
+#define yyretireflg (yy)->yymretireflg
+#define yyerrorflg (yy)->yymerrorflg
+#define yypopflg (yy)->yympopflg
+#define yywipeflg (yy)->yymwipeflg
+#define yytop (yy)->yymtop
+#define yychar (yy)->yymchar
+#define yyskip (yy)->yymskip
+#define yyerrorcount (yy)->yymerrorcount
+#define yyexitcode (yy)->yymexitcode
+#define yyretirecode (yy)->yymretirecode
+#define yyerrorpop (yy)->yymerrorpop
+#define yyparseerr (yy)->yymerr
+#define yystackptr (yy)->yymstackptr
+#define yysstackptr (yy)->yymsstackptr
+#define yystack_size (yy)->yymstack_size
+#define yysstack_size (yy)->yymsstack_size
+#define yyattribute_size (yy)->yymattribute_size
+#define yyvalptr (yy)->yymvalptr
+#define yylvalptr (yy)->yymlvalptr
+#define yyattributestackptr (yy)->yymattributestackptr
+#define yysattributestackptr (yy)->yymsattributestackptr
+#define yyparsedebug (yy)->yymdebug
+#define yyparsedebugstack (yy)->yymdebugstack
+#define yyparsedebugflush (yy)->yymdebugflush
+#define yyparsedebugout (yy)->yymdebugout
+
+/* general functions */
+#define yycparse() yymcparse(yy)
+#define yycwipe() yymcwipe(yy)
+#define yycwork() yymcwork(yy)
+#define yydestructpop(num) yymdestructpop(yy, (pop))
+#define yyparse() yymparse(yy)
+#define yyparsecleanup() yymparsecleanup(yy)
+#define yyparseinit() yymparseinit(yy)
+#define yysetstacksize(size) yymsetstacksize(yy, (size))
+#define yysetup() yymsetup(yy)
+#define yywipe() yymwipe(yy)
+#define yywork() yymwork(yy)
+
+/* service functions */
+#define yygettoken() (*yy->yymgettoken)(yy)
+#define yystackoverflow() (*yy->yymstackoverflow)(yy)
+#define yyerror(text) (*yy->yymerror)(yy, text)
+#define yysyntaxerror() (*yy->yymsyntaxerror)(yy)
+#define yydiscard() (*yy->yymdiscard)(yy)
+
+/* action functions */
+#define yycdestructclearin() yymcdestructclearin(yy)
+#define yydestructclearin() yymdestructclearin(yy)
+#define yysetin(token) yymsetin(yy, (token)
+#define yyunclearin() yymunclearin(yy)
+#define yyabort() yymabort(yy)
+#define yyaccept() yymaccept(yy)
+#define yyclearin() yymclearin(yy)
+#define yydestructclearin() yymdestructclearin(yy)
+#define yyerrok() yymerrok(yy)
+#define yyexit(exitcode) yymexit(yy, (exitcode))
+#define yyforceerror() yymforceerror(yy)
+#define yypopping() yympopping(yy)
+#define yyrecovering() yymrecovering(yy)
+#define yyretire(retirecode) yymretire(yy, (retirecode))
+#define yythrowerror(pop) yymthrowerror(yy, (pop))
+
+#ifdef YY_COMPATIBLE
+#undef yyerrok
+#define yyerrok yymerrok(yy)
+#undef yyclearin
+#define yyclearin yymclearin(yy)
+#endif
+#define YYACCEPT yymaccept(yy)
+#define YYABORT yymabort(yy)
+#define YYERROR yymforceerror(yy)
+#define YYRECOVERING yymrecovering(yy)
+
+#endif

Utils/Parser Generator/INCLUDE/mlconv.h

@@ -0,0 +1,88 @@
+#ifndef MLCONV_H
+#define MLCONV_H
+
+/************************************************************
+mlconv.h
+This file can be freely modified for the generation of
+custom code.
+
+Copyright (c) 1999 Bumble-Bee Software Ltd.
+************************************************************/
+
+/* variables */
+#define yymoreflg (YYLEXNAME).yymmoreflg
+#define yyrejectflg (YYLEXNAME).yymrejectflg
+#define yyreturnflg (YYLEXNAME).yymreturnflg
+#define yytextgrow (YYLEXNAME).yymtextgrow
+#define yyunputgrow (YYLEXNAME).yymunputgrow
+#define yyeol (YYLEXNAME).yymeol
+#define yyoldeol (YYLEXNAME).yymoldeol
+#define yystart (YYLEXNAME).yymstart
+#define yyin (YYLEXNAME).yymin
+#define yyout (YYLEXNAME).yymout
+#define yylexerr (YYLEXNAME).yymerr
+#define yyleng (YYLEXNAME).yymleng
+#define yylineno (YYLEXNAME).yymlineno
+#define yyunputindex (YYLEXNAME).yymunputindex
+#define yytext (YYLEXNAME).yymtext
+#define yystext (YYLEXNAME).yymstext
+#define yytext_size (YYLEXNAME).yymtext_size
+#define yystext_size (YYLEXNAME).yymstext_size
+#define yystatebuf (YYLEXNAME).yymstatebuf
+#define yysstatebuf (YYLEXNAME).yymsstatebuf
+#define yyunputbufptr (YYLEXNAME).yymunputbufptr
+#define yysunputbufptr (YYLEXNAME).yymsunputbufptr
+#define yyunput_size (YYLEXNAME).yymunputbufptr
+#define yysunput_size (YYLEXNAME).yymsunput_size
+#define yylexdebug (YYLEXNAME).yymdebug
+#define yylexdebugflush (YYLEXNAME).yymdebugflush
+#define yylexdebugout (YYLEXNAME).yymdebugout
+
+/* general functions */
+#define yylexinit() yymlexinit(&(YYLEXNAME))
+#define yylex() yymlex(&(YYLEXNAME))
+#define yyclex() yymclex(&(YYLEXNAME))
+#define yyreset() yymreset(&(YYLEXNAME))
+#define yylexcleanup() yymlexcleanup(&(YYLEXNAME))
+#define yysettextsize(size) yymsettextsize(&(YYLEXNAME), (size))
+#define yysetunputsize(size) yymsetunputsize(&(YYLEXNAME), (size))
+
+/* service functions */
+#define yyinput() (*(YYLEXNAME).yyminput)(&(YYLEXNAME))
+#define yyoutput(ch) (*(YYLEXNAME).yymoutput)(&(YYLEXNAME), (ch))
+#define yyunput(ch) (*(YYLEXNAME).yymunput)(&(YYLEXNAME), (ch))
+#define yywrap() (*(YYLEXNAME).yymwrap)(&(YYLEXNAME))
+#define yygetchar() (*(YYLEXNAME).yymgetchar)(&(YYLEXNAME))
+#define yytextoverflow() (*(YYLEXNAME).yymtextoverflow)(&(YYLEXNAME))
+#define yyunputoverflow() (*(YYLEXNAME).yymunputoverflow)(&(YYLEXNAME))
+
+/* action functions */
+#define yybegin(state) yymbegin(&(YYLEXNAME), (state))
+#define yyecho() yymecho(&(YYLEXNAME))
+#define yyless(length) yymless(&(YYLEXNAME), (length))
+#define yymore() yymmore(&(YYLEXNAME))
+#define yynewline(newline) yymnewline(&(YYLEXNAME), (newline))
+#define yyreject() yymreject(&(YYLEXNAME))
+#define yyunputcount() yymunputcount(&(YYLEXNAME))
+
+/* compatibility */
+#define ECHO yyecho()
+#define REJECT yyreject()
+#define BEGIN (YYLEXNAME).yymstart = 
+#define YYSTATE (YYLEXNAME).yymstart
+#define YY_START (YYLEXNAME).yymstart
+
+#ifndef input
+#define input() (*(YYLEXNAME)->yyminput)(&(YYLEXNAME))
+#define YY_INPUT
+#endif
+#ifndef output
+#define output(ch) (*(YYLEXNAME)->yymoutput)(&(YYLEXNAME), (ch))
+#define YY_OUTPUT
+#endif
+#ifdef unput
+#define unput(ch) (*(YYLEXNAME)->yymunput)(&(YYLEXNAME), (ch))
+#define YY_UNPUT
+#endif
+
+#endif

Utils/Parser Generator/INCLUDE/mlex.h

@@ -0,0 +1,287 @@
+#ifndef MLEX_H
+#define MLEX_H
+
+/************************************************************
+mlex.h
+This file can be freely modified for the generation of
+custom code.
+
+Copyright (c) 1999 Bumble-Bee Software Ltd.
+************************************************************/
+
+#include <stdio.h>
+#include <assert.h>
+
+/* defines */
+#include <yytdefs.h>
+
+/* user defines */
+#if defined(YYTUDEFS) || defined(YYUDEFS)
+#include <yytudefs.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define YY_ALEX
+
+/* modifiers */
+#ifndef YYCDECL
+#define YYCDECL
+#endif
+#ifndef YYDCDECL
+#define YYDCDECL
+#endif
+#ifndef YYNEAR
+#define YYNEAR
+#endif
+#ifndef YYFAR
+#define YYFAR
+#endif
+#ifndef YYNEARFAR
+#define YYNEARFAR
+#endif
+#ifndef YYBASED_CODE
+#define YYBASED_CODE
+#endif
+
+/* function prototypes */
+#ifndef YYPROTOTYPE
+#if defined(__STDC__) || defined(__cplusplus)
+#define YYPROTOTYPE
+#endif
+#endif
+
+/* qualifiers */
+#ifndef YYCONST
+#if defined(__STDC__) || defined(__cplusplus)
+#define YYCONST const
+#else
+#define YYCONST
+#endif
+#endif
+
+/* testing */
+#ifdef YYNOPROTOTYPE
+#undef YYPROTOTYPE
+#endif
+#ifdef YYNOCONST
+#undef YYCONST
+#define YYCONST
+#endif
+
+/* yylex return values */
+#define YYEOF 0			/* end of file */
+
+#ifndef YYSTATE_T
+#define YYSTATE_T
+typedef struct yystate {
+	short def;			/* default state */
+	short base;			/* base */
+	short match;		/* action associated with state */
+} yystate_t;
+#endif
+
+#ifndef YYTRANSITION_T
+#define YYTRANSITION_T
+typedef struct yytransition {
+	short next;			/* next state on transition */
+	short check;		/* check */
+} yytransition_t;
+#endif
+
+#ifndef YYCTRANSITION_T
+#define YYCTRANSITION_T
+typedef struct yyctransition {
+	unsigned char first;	/* first character in range */
+	unsigned char last;		/* last character in range */
+	short next;				/* next state on transition */
+} yyctransition_t;
+#endif
+
+typedef short yymatch_t;
+typedef unsigned char yybackup_t;
+
+typedef struct yymlex {
+	/* flags */
+	unsigned char yymmoreflg;		/* concatenate matched strings */
+	unsigned char yymrejectflg;		/* yyreject called from an action */
+	unsigned char yymreturnflg;		/* return from an action */
+	unsigned char yymtextgrow;		/* whether text buffer is allowed to grow */
+	unsigned char yymunputgrow;		/* whether unput buffer is allowed to grow */
+	unsigned char yymeol;			/* whether an end-of-line '\n' has been seen */
+	unsigned char yymoldeol;		/* previous end-of-line value */
+	int yymstart;					/* current start state */
+
+	/* streams */
+	FILE YYFAR *yymin;				/* input text stream */
+	FILE YYFAR *yymout;				/* output text stream */
+	FILE YYFAR *yymerr;				/* error stream */
+
+	int yymleng;					/* matched string length */
+	int yymlineno;					/* current line number */
+	int yymunputindex;				/* unput buffer position */
+
+	char YYFAR *yymtext;			/* text buffer */
+	char YYFAR *yymstext;			/* initial (static) text buffer */
+	int yymtext_size;				/* text buffer size */
+	int yymstext_size;				/* initial (static) text buffer size */
+
+	int YYFAR *yymstatebuf;			/* state buffer */
+	int YYFAR *yymsstatebuf;		/* initial (static) state buffer */
+
+	/* unput buffer */
+	int YYFAR *yymunputbufptr;		/* unput buffer */
+	int YYFAR *yymsunputbufptr;		/* initial (static) unput buffer */
+	int yymunput_size;				/* unput buffer size */
+	int yymsunput_size;				/* initial (static) unput buffer size */
+
+	/* functions */
+#ifdef YYPROTOTYPE
+	int (YYCDECL *yyminput)(struct yymlex YYFAR *yy);
+	void (YYCDECL *yymoutput)(struct yymlex YYFAR *yy, int ch);
+	void (YYCDECL *yymunput)(struct yymlex YYFAR *yy, int ch);
+	int (YYCDECL *yymwrap)(struct yymlex YYFAR *yy);
+	int (YYCDECL *yymgetchar)(struct yymlex YYFAR *yy);
+	void (YYCDECL *yymtextoverflow)(struct yymlex YYFAR *yy);
+	void (YYCDECL *yymunputoverflow)(struct yymlex YYFAR *yy);
+	int (YYCDECL *yymlexaction)(struct yymlex YYFAR *yy, int action);
+#else
+	int (YYCDECL *yyminput)();
+	void (YYCDECL *yymoutput)();
+	void (YYCDECL *yymunput)();
+	int (YYCDECL *yymwrap)();
+	int (YYCDECL *yymgetchar)();
+	void (YYCDECL *yymtextoverflow)();
+	void (YYCDECL *yymunputoverflow)();
+	int (YYCDECL *yymlexaction)();
+#endif
+
+	/* tables */
+	/* fast lexical analyser */
+	YYCONST yytransition_t YYNEARFAR *yymtransition;
+	int yymtransitionmax;
+	/* compact lexical analyser */
+	YYCONST yyctransition_t YYNEARFAR *yymctransition;
+	/* common */
+	YYCONST yymatch_t YYNEARFAR *yymmatch;
+	YYCONST yystate_t YYNEARFAR *yymstate;
+	YYCONST yybackup_t YYNEARFAR *yymbackup;
+
+	void YYFAR *yymdata;			/* user data */
+
+	/* debugging */
+#ifdef YYDEBUG
+	int yymdebug;
+	int yymdebugflush;
+	FILE YYFAR *yymdebugout;
+#endif
+} yymlex_t;
+
+/* instance functions */
+#ifdef YYPROTOTYPE
+int YYCDECL yymcreatelex(yymlex_t YYFAR *yy, YYCONST yymlex_t YYFAR *src);
+void YYCDECL yymdestroylex(yymlex_t YYFAR *yy);
+#else
+int YYCDECL yymcreatelex();
+void YYCDECL yymdestroylex();
+#endif
+
+/* general functions */
+#ifdef YYPROTOTYPE
+int YYCDECL yymclex(yymlex_t YYFAR *yy);
+int YYCDECL yymlex(yymlex_t YYFAR *yy);
+void YYCDECL yymlexcleanup(yymlex_t YYFAR *yy);
+void YYCDECL yymlexinit(yymlex_t YYFAR *yy);
+void YYCDECL yymreset(yymlex_t YYFAR *yy);
+int YYCDECL yymsettextsize(yymlex_t YYFAR *yy, int size);
+int YYCDECL yymsetunputsize(yymlex_t YYFAR *yy, int size);
+#else
+int YYCDECL yymclex();
+int YYCDECL yymlex();
+void YYCDECL yymlexcleanup();
+void YYCDECL yymlexinit();
+void YYCDECL yymreset();
+int YYCDECL yymsettextsize();
+int YYCDECL yymsetunputsize();
+#endif
+
+/* service functions */
+#ifdef YYPROTOTYPE
+int YYCDECL yymgetchar(yymlex_t YYFAR *yy);
+int YYCDECL yyminput(yymlex_t YYFAR *yy);
+void YYCDECL yymoutput(yymlex_t YYFAR *yy, int ch);
+void YYCDECL yymtextoverflow(yymlex_t YYFAR *yy);
+void YYCDECL yymunput(yymlex_t YYFAR *yy, int ch);
+void YYCDECL yymunputoverflow(yymlex_t YYFAR *yy);
+int YYCDECL yymwrap(yymlex_t YYFAR *yy);
+#else
+int YYCDECL yymgetchar();
+int YYCDECL yyminput();
+void YYCDECL yymoutput();
+void YYCDECL yymtextoverflow();
+void YYCDECL yymunput();
+void YYCDECL yymunputoverflow();
+int YYCDECL yymwrap();
+#endif
+
+/* action functions */
+#ifdef YYPROTOTYPE
+void YYCDECL yymecho(yymlex_t YYFAR *yy);
+void YYCDECL yymless(yymlex_t YYFAR *yy, int length);
+#else
+void YYCDECL yymecho();
+void YYCDECL yymless();
+#endif
+#define yymbegin(yy, state) ((yy)->yymstart = (state))
+#define yymmore(yy) ((yy)->yymmoreflg = 1)
+#define yymnewline(yy, newline) ((newline) ? (yy)->yymeol = 1 : ((yy)->yymeol = 0))
+#define yymreject(yy) ((yy)->yymrejectflg = 1)
+#define yymunputcount(yy) (yy)->yymunputindex
+
+/* helper functions */
+#ifdef YYPROTOTYPE
+int YYCDECL yymback(YYCONST yymatch_t YYNEARFAR *p, int action);
+#else
+int YYCDECL yymback();
+#endif
+#ifndef yyassert
+#define yyassert(expr) assert(expr)
+#endif
+
+/* debugging functions */
+#ifdef YYDEBUG
+#ifdef YYPROTOTYPE
+void YYCDECL yymdebugoutput(yymlex_t YYFAR *yy, int ch);
+void YYCDECL yymdmatch(yymlex_t YYFAR *yy, int expr);
+void YYCDECL yymlexdebugoutput(yymlex_t YYFAR *yy, YYCONST char *string);
+#else
+void YYCDECL yymdebugoutput();
+void YYCDECL yymdmatch();
+void YYCDECL yymlexdebugoutput();
+#endif
+#endif
+
+#define yymisfastlexer(yy) ((yy)->yymtransition != NULL)
+#define yymiscompactlexer(yy) ((yy)->yymctransition != NULL)
+
+/* debugging variables */
+#ifdef YYDEBUG
+extern int YYNEAR YYDCDECL yydebug;
+extern int YYNEAR YYDCDECL yydebugflush;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+/* user defines */
+#if defined(YYBUDEFS) || defined(YYUDEFS)
+#include <yybudefs.h>
+#endif
+
+/* defines */
+#include <yybdefs.h>
+
+#endif

Utils/Parser Generator/INCLUDE/myacc.h

@@ -0,0 +1,436 @@
+#ifndef MYACC_H
+#define MYACC_H
+
+/************************************************************
+myacc.h
+This file can be freely modified for the generation of
+custom code.
+
+Copyright (c) 1999 Bumble-Bee Software Ltd.
+************************************************************/
+
+#include <stdio.h>
+#include <stddef.h>
+#include <assert.h>
+
+/* defines */
+#include <yytdefs.h>
+
+/* user defines */
+#if defined(YYTUDEFS) || defined(YYUDEFS)
+#include <yytudefs.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define YY_AYACC
+
+/* modifiers */
+#ifndef YYCDECL
+#define YYCDECL
+#endif
+#ifndef YYDCDECL
+#define YYDCDECL
+#endif
+#ifndef YYNEAR
+#define YYNEAR
+#endif
+#ifndef YYFAR
+#define YYFAR
+#endif
+#ifndef YYNEARFAR
+#define YYNEARFAR
+#endif
+#ifndef YYBASED_CODE
+#define YYBASED_CODE
+#endif
+
+/* function prototypes */
+#ifndef YYPROTOTYPE
+#if defined(__STDC__) || defined(__cplusplus)
+#define YYPROTOTYPE
+#endif
+#endif
+
+/* qualifiers */
+#ifndef YYCONST
+#if defined(__STDC__) || defined(__cplusplus)
+#define YYCONST const
+#else
+#define YYCONST
+#endif
+#endif
+
+/* testing */
+#ifdef YYNOPROTOTYPE
+#undef YYPROTOTYPE
+#endif
+#ifdef YYNOCONST
+#undef YYCONST
+#define YYCONST
+#endif
+
+typedef short yystack_t;
+
+/* yyparse return values */
+#define YYEXIT_SUCCESS	0
+#define YYEXIT_FAILURE	1
+
+/* common tokens */
+#define YYTK_ALL		(-1)		/* match all tokens */
+#define YYTK_END		0			/* $end token */
+#define YYTK_ERROR		256			/* error token */
+
+#ifndef YYCSTATEGOTO_T
+#define YYCSTATEGOTO_T
+typedef short yycstategoto_t;
+#endif
+
+#ifndef YYCNONTERMGOTO_T
+#define YYCNONTERMGOTO_T
+typedef struct yycnontermgoto {
+	short nonterm;					/* nonterminal */
+	short next;						/* next state */
+} yycnontermgoto_t;
+#endif
+
+#ifndef YYSTATEGOTO_T
+#define YYSTATEGOTO_T
+typedef struct yystategoto {
+	short base;						/* base */
+	short def;						/* default state */
+} yystategoto_t;
+#endif
+
+#ifndef YYNONTERMGOTO_T
+#define YYNONTERMGOTO_T
+typedef struct yynontermgoto {
+	short check;					/* check */
+	short next;						/* next state */
+} yynontermgoto_t;
+#endif
+
+/* action types */
+#define YYAT_SHIFT		0			/* shift action */
+#define YYAT_REDUCE		1			/* reduce action */
+#define YYAT_ERROR		2			/* error */
+#define YYAT_ACCEPT		3			/* accept */
+#define YYAT_DEFAULT	4			/* default state */
+
+#ifndef YYCSTATEACTION_T
+#define YYCSTATEACTION_T
+typedef short yycstateaction_t;
+#endif
+
+#ifndef YYCTOKENACTION_T
+#define YYCTOKENACTION_T
+typedef struct yyctokenaction {
+	int token;						/* lookahead token */
+	unsigned char type;				/* action to perform */
+	short sr;						/* state to shift/production to reduce */
+} yyctokenaction_t;
+#endif
+
+#ifndef YYSTATEACTION_T
+#define YYSTATEACTION_T
+typedef struct yystateaction {
+	short base;						/* base */
+	unsigned char lookahead;		/* lookahead needed */
+	unsigned char type;				/* action to perform */
+	short sr;						/* shift/reduce */
+} yystateaction_t;
+#endif
+
+#ifndef YYTOKENACTION_T
+#define YYTOKENACTION_T
+typedef struct yytokenaction {
+	short check;					/* check */
+	unsigned char type;				/* action type */
+	short sr;						/* shift/reduce */
+} yytokenaction_t;
+#endif
+
+/* nonterminals */
+#define YYST_ALL		(-1)		/* match all states */
+
+/* states */
+#define YYST_ERROR		(-1)		/* goto error */
+
+#ifndef YYREDUCTION_T
+#define YYREDUCTION_T
+typedef struct yyreduction {
+	short nonterm;					/* the rhs symbol */
+	short length;					/* number of symbols on lhs */
+	short action;					/* the user action */
+} yyreduction_t;
+#endif
+
+typedef short yydestructor_t;
+
+typedef short yytokendest_t;
+
+#ifndef YYCTOKENDEST_T
+#define YYCTOKENDEST_T
+typedef struct yyctokendest {
+	int token;						/* token */
+	short action;					/* the user action */
+} yyctokendest_t;
+#endif
+
+/* debugging */
+#ifdef YYDEBUG
+#ifndef YYSYMBOL_T
+#define YYSYMBOL_T
+typedef struct yysymbol {
+	YYCONST char *name;				/* symbol name */
+	int token;						/* symbol token */
+} yysymbol_t;
+#endif
+#endif
+
+typedef struct yymparse {
+	/* flags */
+	unsigned char yymlookahead;			/* whether current lookahead token is valid */
+	unsigned char yymstackgrow;			/* whether stack can grow */
+	unsigned char yymexitflg;			/* whether yymexit called */
+	unsigned char yymretireflg;			/* whether yymretire called */
+	unsigned char yymerrorflg;			/* whether yymforceerror called */
+	unsigned char yympopflg;			/* popping symbols during error recovery */
+	unsigned char yymwipeflg;			/* whether to "wipe" stack on abort */
+
+	int yymtop;							/* the current top of the stack */
+	int yymchar;						/* current lookahead token */
+	int yymskip;						/* error recovery token shift counter */
+	int yymerrorcount;					/* how many syntax errors have occurred */
+	int yymexitcode;					/* yymexit exit code */
+	int yymretirecode;					/* yymretire exit code */
+	int yymerrorpop;					/* how many error transitions to pop */
+	FILE YYFAR *yymerr;					/* error output file */
+
+	/* stack */
+	yystack_t YYFAR *yymstackptr;		/* (state) stack */
+	yystack_t YYFAR *yymsstackptr;		/* static (state) stack */
+	int yymstack_size;					/* number of elements in stack */
+	int yymsstack_size;					/* initial number of elements in stack */
+
+	size_t yymattribute_size;			/* size of attribute */
+
+#ifdef YYPROTOTYPE
+	void YYFAR *yymvalptr;				/* attribute for $$ */
+	void YYFAR *yymlvalptr;				/* current token attribute */
+	void YYFAR *yymattributestackptr;	/* attribute stack */
+	void YYFAR *yymsattributestackptr;	/* static attribute stack */
+#else
+	char YYFAR *yymvalptr;				/* attribute for $$ */
+	char YYFAR *yymlvalptr;				/* current token attribute */
+	char YYFAR *yymattributestackptr;	/* attribute stack */
+	char YYFAR *yymsattributestackptr;	/* static attribute stack */
+#endif
+
+	/* service functions */
+#ifdef YYPROTOTYPE
+	void (YYCDECL *yymstackoverflow)(struct yymparse YYFAR *yy);
+	void (YYCDECL *yymerror)(struct yymparse YYFAR *yy, YYCONST char YYFAR *text);
+	void (YYCDECL *yymsyntaxerror)(struct yymparse YYFAR *yy);
+	void (YYCDECL *yymdiscard)(struct yymparse YYFAR *yy, int token);
+	int (YYCDECL *yymgettoken)(struct yymparse YYFAR *yy);
+	void (YYCDECL *yymparseaction)(struct yymparse YYFAR *yy, int action);
+#else
+	void (YYCDECL *yymstackoverflow)();
+	void (YYCDECL *yymerror)();
+	void (YYCDECL *yymsyntaxerror)();
+	void (YYCDECL *yymdiscard)();
+	int (YYCDECL *yymgettoken)();
+	void (YYCDECL *yymparseaction)();
+#endif
+
+	/* tables */
+	/* fast parser */
+	YYCONST yystateaction_t YYNEARFAR *yymstateaction;
+	YYCONST yytokenaction_t YYNEARFAR *yymtokenaction;
+	int yymtokenaction_size;
+	YYCONST yystategoto_t YYNEARFAR *yymstategoto;
+	YYCONST yynontermgoto_t YYNEARFAR *yymnontermgoto;
+	int yymnontermgoto_size;
+	YYCONST yytokendest_t YYNEARFAR *yymtokendestptr;
+	int yymtokendest_size;
+	int yymtokendestbase;
+	/* compact parser */
+	YYCONST yycstateaction_t YYNEARFAR *yymcstateaction;
+	YYCONST yyctokenaction_t YYNEARFAR *yymctokenaction;
+	YYCONST yycstategoto_t YYNEARFAR *yymcstategoto;
+	YYCONST yycnontermgoto_t YYNEARFAR *yymcnontermgoto;
+	YYCONST yyctokendest_t YYNEARFAR *yymctokendestptr;
+	/* common */
+	YYCONST yyreduction_t YYNEARFAR *yymreduction;
+
+	YYCONST yydestructor_t YYNEARFAR *yymdestructorptr;
+
+	void YYFAR *yymdata;				/* user data */
+
+	/* debugging */
+#ifdef YYDEBUG
+	int yymdebug;
+	int yymdebugstack;
+	int yymdebugflush;
+	FILE YYFAR *yymdebugout;
+	YYCONST yysymbol_t YYNEARFAR *yymsymbol;
+	YYCONST char *YYCONST YYNEARFAR *yymrule;
+#endif
+} yymparse_t;
+
+/* instance functions */
+#ifdef YYPROTOTYPE
+int YYCDECL yymcreateparse(yymparse_t YYFAR *yy, YYCONST yymparse_t YYFAR *src);
+void YYCDECL yymdestroyparse(yymparse_t YYFAR *yy);
+#else
+int YYCDECL yymcreateparse();
+void YYCDECL yymdestroyparse();
+#endif
+
+/* general functions */
+#ifdef YYPROTOTYPE
+int YYCDECL yymcparse(yymparse_t YYFAR *yy);
+void YYCDECL yymcwipe(yymparse_t YYFAR *yy);
+int YYCDECL yymcwork(yymparse_t YYFAR *yy);
+void YYCDECL yymdestructpop(yymparse_t YYFAR *yy, int num);
+int YYCDECL yymparse(yymparse_t YYFAR *yy);
+void YYCDECL yymparsecleanup(yymparse_t YYFAR *yy);
+void YYCDECL yymparseinit(yymparse_t YYFAR *yy);
+int YYCDECL yymsetstacksize(yymparse_t YYFAR *yy, int size);
+int YYCDECL yymsetup(yymparse_t YYFAR *yy);
+void YYCDECL yymwipe(yymparse_t YYFAR *yy);
+int YYCDECL yymwork(yymparse_t YYFAR *yy);
+#else
+int YYCDECL yymcparse();
+void YYCDECL yymcwipe();
+int YYCDECL yymcwork();
+void YYCDECL yymdestructpop();
+int YYCDECL yymparse();
+void YYCDECL yymparsecleanup();
+void YYCDECL yymparseinit();
+int YYCDECL yymsetstacksize();
+int YYCDECL yymsetup();
+void YYCDECL yymwipe();
+int YYCDECL yymwork();
+#endif
+
+/* service functions */
+#ifdef YYPROTOTYPE
+void YYCDECL yymdiscard(yymparse_t YYFAR *yy, int token);
+void YYCDECL yymerror(yymparse_t YYFAR *yy, YYCONST char YYFAR *text);
+int YYCDECL yymgettoken(yymparse_t YYFAR *yy);
+void YYCDECL yymstackoverflow(yymparse_t YYFAR *yy);
+void YYCDECL yymsyntaxerror(yymparse_t YYFAR *yy);
+#else
+void YYCDECL yymdiscard();
+void YYCDECL yymerror();
+int YYCDECL yymgettoken();
+void YYCDECL yymstackoverflow();
+void YYCDECL yymsyntaxerror();
+#endif
+
+/* action functions */
+#ifdef YYPROTOTYPE
+void YYCDECL yymcdestructclearin(yymparse_t YYFAR *yy);
+void YYCDECL yymdestructclearin(yymparse_t YYFAR *yy);
+void YYCDECL yymsetin(yymparse_t YYFAR *yy, int token);
+int YYCDECL yymunclearin(yymparse_t YYFAR *yy);
+#else
+void YYCDECL yymcdestructclearin();
+void YYCDECL yymdestructclearin();
+void YYCDECL yymsetin();
+int YYCDECL yymunclearin();
+#endif
+#define yymabort(yy) yymexit(1)
+#define yymaccept(yy) yymexit(0)
+#define yymclearin(yy) ((yy)->yymlookahead = 0)
+#define yymerrok(yy) yymsetskip((yy), 0)
+#define yymexit(yy, exitcode) ((yy)->yymexitflg = 1, (yy)->yymexitcode = (exitcode))
+#define yymforceerror(yy) yymthrowerror(0)
+#define yympopping(yy) (yy)->yympopflg
+#define yymrecovering(yy) ((yy)->yymskip > 0)
+#define yymretire(yy, retirecode) ((yy)->yymretireflg = 1, (yy)->yymretirecode = (retirecode))
+#define yymthrowerror(yy, pop) ((yy)->yymerrorflg = 1, (yy)->yymerrorpop = (pop))
+
+/* utility functions */
+#ifdef YYPROTOTYPE
+#ifdef YYDEBUG
+void YYCDECL yympop(yymparse_t YYFAR *yy, int num);
+void YYCDECL yymsetskip(yymparse_t YYFAR *yy, int skip);
+#endif
+int YYCDECL yympush(yymparse_t YYFAR *yy, yystack_t state);
+#else
+#ifdef YYDEBUG
+void YYCDECL yympop();
+void YYCDECL yymsetskip();
+#endif
+int YYCDECL yympush();
+#endif
+#ifndef yyassert
+#define yyassert(expr) assert(expr)
+#endif
+#define yympeek(yy) ((yy)->yymstackptr[(yy)->yymtop])
+#ifndef YYDEBUG
+#define yympop(yy, num) ((yy)->yymtop -= (num))
+#define yymsetskip(yy, skip) ((yy)->yymskip = (skip))
+#endif
+
+/* debugging functions */
+#ifdef YYDEBUG
+#ifdef YYPROTOTYPE
+YYCONST char *YYCDECL yymtokenstring(yymparse_t YYFAR *yy, int token);
+void YYCDECL yymdgettoken(yymparse_t YYFAR *yy, int token);
+void YYCDECL yymdshift(yymparse_t YYFAR *yy, int token);
+void YYCDECL yymdreduce(yymparse_t YYFAR *yy, int rule);
+void YYCDECL yymdsyntaxerror(yymparse_t YYFAR *yy);
+void YYCDECL yymdaccept(yymparse_t YYFAR *yy);
+void YYCDECL yymdabort(yymparse_t YYFAR *yy);
+void YYCDECL yymddiscard(yymparse_t YYFAR *yy, int token);
+void YYCDECL yymdexit(yymparse_t YYFAR *yy, int exitcode);
+void YYCDECL yymdthrowerror(yymparse_t YYFAR *yy, int errorpop);
+void YYCDECL yymdretire(yymparse_t YYFAR *yy, int retirecode);
+void YYCDECL yymdattemptrecovery(yymparse_t YYFAR *yy);
+void YYCDECL yymparsedebugoutput(yymparse_t YYFAR *yy, YYCONST char *string);
+#else
+YYCONST char *YYCDECL yymtokenstring();
+void YYCDECL yymdgettoken();
+void YYCDECL yymdshift();
+void YYCDECL yymdreduce();
+void YYCDECL yymdsyntaxerror();
+void YYCDECL yymdaccept();
+void YYCDECL yymdabort();
+void YYCDECL yymddiscard();
+void YYCDECL yymdexit();
+void YYCDECL yymdthrowerror();
+void YYCDECL yymdretire();
+void YYCDECL yymdattemptrecovery();
+void YYCDECL yymparsedebugoutput();
+#endif
+#endif
+
+#define yymisfastparser(yy) ((yy)->yymstateaction != NULL)
+#define yymiscompactparser(yy) ((yy)->yymcstateaction != NULL)
+
+/* debugging variables */
+#ifdef YYDEBUG
+extern int YYNEAR YYDCDECL yydebug;
+extern int YYNEAR YYDCDECL yydebugstack;
+extern int YYNEAR YYDCDECL yydebugflush;
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+/* user defines */
+#if defined(YYBUDEFS) || defined(YYUDEFS)
+#include <yybudefs.h>
+#endif
+
+/* defines */
+#include <yybdefs.h>
+
+#endif

Utils/Parser Generator/INCLUDE/myconv.h

@@ -0,0 +1,90 @@
+#ifndef MYCONV_H
+#define MYCONV_H
+
+/************************************************************
+myconv.h
+This file can be freely modified for the generation of
+custom code.
+
+Copyright (c) 1999 Bumble-Bee Software Ltd.
+************************************************************/
+
+/* variables */
+#define yylookahead (YYPARSENAME).yymlookahead
+#define yystackgrow (YYPARSENAME).yymstackgrow
+#define yyexitflg (YYPARSENAME).yymexitflg
+#define yyretireflg (YYPARSENAME).yymretireflg
+#define yyerrorflg (YYPARSENAME).yymerrorflg
+#define yypopflg (YYPARSENAME).yympopflg
+#define yywipeflg (YYPARSENAME).yymwipeflg
+#define yytop (YYPARSENAME).yymtop
+#define yychar (YYPARSENAME).yymchar
+#define yyskip (YYPARSENAME).yymskip
+#define yyerrorcount (YYPARSENAME).yymerrorcount
+#define yyexitcode (YYPARSENAME).yymexitcode
+#define yyretirecode (YYPARSENAME).yymretirecode
+#define yyerrorpop (YYPARSENAME).yymerrorpop
+#define yyparseerr (YYPARSENAME).yymerr
+#define yystackptr (YYPARSENAME).yymstackptr
+#define yysstackptr (YYPARSENAME).yymsstackptr
+#define yystack_size (YYPARSENAME).yymstack_size
+#define yysstack_size (YYPARSENAME).yymsstack_size
+#define yyattribute_size (YYPARSENAME).yymattribute_size
+#define yyvalptr (YYPARSENAME).yymvalptr
+#define yylvalptr (YYPARSENAME).yymlvalptr
+#define yyattributestackptr (YYPARSENAME).yymattributestackptr
+#define yysattributestackptr (YYPARSENAME).yymsattributestackptr
+#define yyparsedebug (YYPARSENAME).yymdebug
+#define yyparsedebugstack (YYPARSENAME)->yymdebugstack
+#define yyparsedebugflush (YYPARSENAME).yymdebugflush
+#define yyparsedebugout (YYPARSENAME).yymdebugout
+
+/* general functions */
+#define yycparse() yymcparse(&(YYPARSENAME))
+#define yycwipe() yymcwipe(&(YYPARSENAME))
+#define yycwork() yymcwork(&(YYPARSENAME))
+#define yydestructpop(num) yymdestructpop(&(YYPARSENAME), (pop))
+#define yyparse() yymparse(&(YYPARSENAME))
+#define yyparsecleanup() yymparsecleanup(&(YYPARSENAME))
+#define yyparseinit() yymparseinit(&(YYPARSENAME))
+#define yysetstacksize(size) yymsetstacksize(&(YYPARSENAME), (size))
+#define yysetup() yymsetup(&(YYPARSENAME))
+#define yywipe() yymwipe(&(YYPARSENAME))
+#define yywork() yymwork(&(YYPARSENAME))
+
+/* service functions */
+#define yygettoken() (*(YYPARSENAME).yymgettoken)(&(YYPARSENAME))
+#define yystackoverflow() (*(YYPARSENAME).yymstackoverflow)(&(YYPARSENAME))
+#define yyerror(text) (*(YYPARSENAME).yymerror)(&(YYPARSENAME), (text))
+#define yysyntaxerror() (*(YYPARSENAME).yymsyntaxerror)(&(YYPARSENAME))
+#define yydiscard() (*(YYPARSENAME).yymdiscard)(&(YYPARSENAME))
+
+/* action functions */
+#define yycdestructclearin() yymcdestructclearin(&(YYPARSENAME))
+#define yydestructclearin() yymdestructclearin(&(YYPARSENAME))
+#define yysetin(token) yymsetin(&(YYPARSENAME), (token)
+#define yyunclearin() yymunclearin(&(YYPARSENAME))
+#define yyabort() yymabort(&(YYPARSENAME))
+#define yyaccept() yymaccept(&(YYPARSENAME))
+#define yyclearin() yymclearin(&(YYPARSENAME))
+#define yydestructclearin() yymdestructclearin(&(YYPARSENAME))
+#define yyerrok() yymerrok(&(YYPARSENAME))
+#define yyexit(exitcode) yymexit(&(YYPARSENAME), (exitcode))
+#define yyforceerror() yymforceerror(&(YYPARSENAME))
+#define yypopping() yympopping(&(YYPARSENAME))
+#define yyrecovering() yymrecovering(&(YYPARSENAME))
+#define yyretire(retirecode) yymretire(&(YYPARSENAME), (retirecode))
+#define yythrowerror(pop) yymthrowerror(&YYPARSENAME), (pop))
+
+#ifdef YY_COMPATIBLE
+#undef yyerrok
+#define yyerrok yymerrok(&(YYPARSENAME))
+#undef yyclearin
+#define yyclearin yymclearin(&(YYPARSENAME))
+#endif
+#define YYACCEPT yymaccept(&(YYPARSENAME))
+#define YYABORT yymabort(&(YYPARSENAME))
+#define YYERROR yymforceerror(&(YYPARSENAME))
+#define YYRECOVERING yymrecovering(&(YYPARSENAME))
+
+#endif

Utils/Parser Generator/INCLUDE/yacc.h

@@ -0,0 +1,418 @@
+#ifndef YACC_H
+#define YACC_H
+
+/************************************************************
+yacc.h
+This file can be freely modified for the generation of
+custom code.
+
+Copyright (c) 1999 Bumble-Bee Software Ltd.
+************************************************************/
+
+#include <stdio.h>
+#include <stddef.h>
+#include <assert.h>
+
+/* defines */
+#include <yytdefs.h>
+
+/* user defines */
+#if defined(YYTUDEFS) || defined(YYUDEFS)
+#include <yytudefs.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define YY_AYACC
+
+/* modifiers */
+#ifndef YYCDECL
+#define YYCDECL
+#endif
+#ifndef YYDCDECL
+#define YYDCDECL
+#endif
+#ifndef YYNEAR
+#define YYNEAR
+#endif
+#ifndef YYFAR
+#define YYFAR
+#endif
+#ifndef YYNEARFAR
+#define YYNEARFAR
+#endif
+#ifndef YYBASED_CODE
+#define YYBASED_CODE
+#endif
+
+/* function prototypes */
+#ifndef YYPROTOTYPE
+#if defined(__STDC__) || defined(__cplusplus)
+#define YYPROTOTYPE
+#endif
+#endif
+
+/* qualifiers */
+#ifndef YYCONST
+#if defined(__STDC__) || defined(__cplusplus)
+#define YYCONST const
+#else
+#define YYCONST
+#endif
+#endif
+
+/* testing */
+#ifdef YYNOPROTOTYPE
+#undef YYPROTOTYPE
+#endif
+#ifdef YYNOCONST
+#undef YYCONST
+#define YYCONST
+#endif
+
+typedef short yystack_t;
+
+/* yyparse return values */
+#define YYEXIT_SUCCESS	0
+#define YYEXIT_FAILURE	1
+
+/* common tokens */
+#define YYTK_ALL		(-1)		/* match all tokens */
+#define YYTK_END		0			/* $end token */
+#define YYTK_ERROR		256			/* error token */
+
+#ifndef YYCSTATEGOTO_T
+#define YYCSTATEGOTO_T
+typedef short yycstategoto_t;
+#endif
+
+#ifndef YYCNONTERMGOTO_T
+#define YYCNONTERMGOTO_T
+typedef struct yycnontermgoto {
+	short nonterm;					/* nonterminal */
+	short next;						/* next state */
+} yycnontermgoto_t;
+#endif
+
+#ifndef YYSTATEGOTO_T
+#define YYSTATEGOTO_T
+typedef struct yystategoto {
+	short base;						/* base */
+	short def;						/* default state */
+} yystategoto_t;
+#endif
+
+#ifndef YYNONTERMGOTO_T
+#define YYNONTERMGOTO_T
+typedef struct yynontermgoto {
+	short check;					/* check */
+	short next;						/* next state */
+} yynontermgoto_t;
+#endif
+
+/* action types */
+#define YYAT_SHIFT		0			/* shift action */
+#define YYAT_REDUCE		1			/* reduce action */
+#define YYAT_ERROR		2			/* error */
+#define YYAT_ACCEPT		3			/* accept */
+#define YYAT_DEFAULT	4			/* default state */
+
+#ifndef YYCSTATEACTION_T
+#define YYCSTATEACTION_T
+typedef short yycstateaction_t;
+#endif
+
+#ifndef YYCTOKENACTION_T
+#define YYCTOKENACTION_T
+typedef struct yyctokenaction {
+	int token;						/* lookahead token */
+	unsigned char type;				/* action to perform */
+	short sr;						/* state to shift/production to reduce */
+} yyctokenaction_t;
+#endif
+
+#ifndef YYSTATEACTION_T
+#define YYSTATEACTION_T
+typedef struct yystateaction {
+	short base;						/* base */
+	unsigned char lookahead;		/* lookahead needed */
+	unsigned char type;				/* action to perform */
+	short sr;						/* shift/reduce */
+} yystateaction_t;
+#endif
+
+#ifndef YYTOKENACTION_T
+#define YYTOKENACTION_T
+typedef struct yytokenaction {
+	short check;					/* check */
+	unsigned char type;				/* action type */
+	short sr;						/* shift/reduce */
+} yytokenaction_t;
+#endif
+
+/* nonterminals */
+#define YYNT_ALL		(-1)		/* match all nonterminals */
+
+/* states */
+#define YYST_ERROR		(-1)		/* goto error */
+
+#ifndef YYREDUCTION_T
+#define YYREDUCTION_T
+typedef struct yyreduction {
+	short nonterm;					/* the rhs symbol */
+	short length;					/* number of symbols on lhs */
+	short action;					/* the user action */
+} yyreduction_t;
+#endif
+
+typedef short yydestructor_t;
+
+typedef short yytokendest_t;
+
+#ifndef YYCTOKENDEST_T
+#define YYCTOKENDEST_T
+typedef struct yyctokendest {
+	int token;						/* token */
+	short action;					/* the user action */
+} yyctokendest_t;
+#endif
+
+/* debugging */
+#ifdef YYDEBUG
+#ifndef YYSYMBOL_T
+#define YYSYMBOL_T
+typedef struct yysymbol {
+	YYCONST char *name;				/* symbol name */
+	int token;						/* symbol token */
+} yysymbol_t;
+#endif
+#endif
+
+/* general functions */
+#ifdef YYPROTOTYPE
+int YYCDECL yycparse(void);
+void YYCDECL yycwipe(void);
+int YYCDECL yycwork(void);
+void YYCDECL yydestructpop(int num);
+int YYCDECL yyparse(void);
+void YYCDECL yyparsecleanup(void);
+void YYCDECL yyparseinit(void);
+int YYCDECL yysetstacksize(int size);
+int YYCDECL yysetup(void);
+void YYCDECL yywipe(void);
+int YYCDECL yywork(void);
+#else
+int YYCDECL yycparse();
+void YYCDECL yycwipe();
+int YYCDECL yycwork();
+void YYCDECL yydestructpop();
+int YYCDECL yyparse();
+void YYCDECL yyparsecleanup();
+void YYCDECL yyparseinit();
+int YYCDECL yysetstacksize();
+int YYCDECL yysetup();
+void YYCDECL yywipe();
+int YYCDECL yywork();
+#endif
+
+/* service functions */
+#ifdef YYPROTOTYPE
+void YYCDECL yydiscard(int token);
+void YYCDECL yyerror(YYCONST char YYFAR *text);
+int YYCDECL yygettoken(void);
+void YYCDECL yystackoverflow(void);
+void YYCDECL yysyntaxerror(void);
+#else
+void YYCDECL yydiscard();
+void YYCDECL yyerror();
+int YYCDECL yygettoken();
+void YYCDECL yystackoverflow();
+void YYCDECL yysyntaxerror();
+#endif
+
+/* action functions */
+#ifdef YYPROTOTYPE
+void YYCDECL yycdestructclearin(void);
+void YYCDECL yydestructclearin(void);
+void YYCDECL yysetin(int token);
+int YYCDECL yyunclearin(void);
+#else
+void YYCDECL yycdestructclearin();
+void YYCDECL yydestructclearin();
+void YYCDECL yysetin();
+int YYCDECL yyunclearin();
+#endif
+#define yyabort() yyexit(1)
+#define yyaccept() yyexit(0)
+#define yyclearin() (yylookahead = 0)
+#define yyerrok() yysetskip(0)
+#define yyexit(exitcode) (yyexitflg = 1, yyexitcode = (exitcode))
+#define yyforceerror() yythrowerror(0)
+#define yypopping() yypopflg
+#define yyrecovering() (yyskip > 0)
+#define yyretire(retirecode) (yyretireflg = 1, yyretirecode = (retirecode))
+#define yythrowerror(pop) (yyerrorflg = 1, yyerrorpop = (pop))
+
+/* compatibility */
+#ifdef YY_COMPATIBLE
+#undef yyclearin
+#define yyclearin (yylookahead = 0)
+#undef yyerrok
+#define yyerrok yysetskip(0)
+#endif
+#define YYABORT yyexit(1)
+#define YYACCEPT yyexit(0)
+#define YYERROR yyforceerror()
+#define YYRECOVERING yyrecovering()
+
+/* helper functions */
+#ifdef YYPROTOTYPE
+#ifdef YYDEBUG
+void YYCDECL yypop(int num);
+void YYCDECL yysetskip(int skip);
+#endif
+int YYCDECL yypush(yystack_t state);
+#else
+#ifdef YYDEBUG
+void YYCDECL yypop();
+void YYCDECL yysetskip();
+#endif
+int YYCDECL yypush();
+#endif
+#ifndef yyassert
+#define yyassert(expr) assert(expr)
+#endif
+#define yypeek() (yystackptr[yytop])
+#ifndef YYDEBUG
+#define yypop(num) (yytop -= (num))
+#define yysetskip(skip) (yyskip = (skip))
+#endif
+
+/* variables */
+extern unsigned char YYNEAR YYDCDECL yylookahead;
+extern unsigned char YYNEAR YYDCDECL yystackgrow;
+extern unsigned char YYNEAR YYDCDECL yyexitflg;
+extern unsigned char YYNEAR YYDCDECL yyretireflg;
+extern unsigned char YYNEAR YYDCDECL yyerrorflg;
+extern unsigned char YYNEAR YYDCDECL yypopflg;
+extern unsigned char YYNEAR YYDCDECL yywipeflg;
+extern int YYNEAR YYDCDECL yytop;				/* the current top of the stack */
+extern int YYNEAR YYDCDECL yychar;
+extern int YYNEAR YYDCDECL yyskip;
+extern int YYNEAR YYDCDECL yyerrorcount;
+extern FILE YYFAR *YYNEAR YYDCDECL yyparseerr;
+extern int YYNEAR YYDCDECL yyexitcode;
+extern int YYNEAR YYDCDECL yyretirecode;
+extern int YYNEAR YYDCDECL yyerrorpop;
+
+/* debugging functions */
+#ifdef YYDEBUG
+#ifdef YYPROTOTYPE
+YYCONST char *YYCDECL yytokenstring(int token);
+void YYCDECL yydgettoken(int token);
+void YYCDECL yydshift(int token);
+void YYCDECL yydreduce(int rule);
+void YYCDECL yydsyntaxerror(void);
+void YYCDECL yydaccept(void);
+void YYCDECL yydabort(void);
+void YYCDECL yyddiscard(int token);
+void YYCDECL yydexit(int exitcode);
+void YYCDECL yydthrowerror(int errorpop);
+void YYCDECL yydretire(int retirecode);
+void YYCDECL yydattemptrecovery(void);
+void YYCDECL yyparsedebugoutput(YYCONST char *string);
+#else
+YYCONST char *YYCDECL yytokenstring();
+void YYCDECL yydgettoken();
+void YYCDECL yydshift();
+void YYCDECL yydreduce();
+void YYCDECL yydsyntaxerror();
+void YYCDECL yydaccept();
+void YYCDECL yydabort();
+void YYCDECL yyddiscard();
+void YYCDECL yydexit();
+void YYCDECL yydthrowerror();
+void YYCDECL yydretire();
+void YYCDECL yydattemptrecovery();
+void YYCDECL yyparsedebugoutput();
+#endif
+#endif
+
+/* debugging variables */
+#ifdef YYDEBUG
+extern int YYNEAR YYDCDECL yydebug;
+extern int YYNEAR YYDCDECL yydebugstack;
+extern int YYNEAR YYDCDECL yydebugflush;
+extern int YYNEAR YYDCDECL yyparsedebug;
+extern int YYNEAR YYDCDECL yyparsedebugstack;
+extern int YYNEAR YYDCDECL yyparsedebugflush;
+extern FILE YYFAR *YYNEAR YYDCDECL yyparsedebugout;
+extern YYCONST yysymbol_t YYNEARFAR YYDCDECL yysymbol[];
+extern YYCONST char *YYCONST YYNEARFAR YYDCDECL yyrule[];
+#endif
+
+/* externally defined */
+#ifdef YYPROTOTYPE
+int YYCDECL yylex(void);
+void YYCDECL yyparseaction(int action);
+#else
+int YYCDECL yylex();
+void YYCDECL yyparseaction();
+#endif
+
+extern yystack_t YYFAR *YYNEAR YYDCDECL yystackptr;			/* (state) stack */
+extern yystack_t YYFAR *YYNEAR YYDCDECL yysstackptr;		/* static (state) stack */
+extern int YYNEAR YYDCDECL yystack_size;					/* number of elements in stack */
+extern int YYNEAR YYDCDECL yysstack_size;					/* initial number of elements in stack */
+
+extern size_t YYNEAR YYDCDECL yyattribute_size;				/* size of attribute */
+
+#ifdef YYPROTOTYPE
+extern void YYFAR *YYNEAR YYDCDECL yyvalptr;				/* attribute for $$ */
+extern void YYFAR *YYNEAR YYDCDECL yylvalptr;				/* current token attribute */
+extern void YYFAR *YYNEAR YYDCDECL yyattributestackptr;		/* attribute stack */
+extern void YYFAR *YYNEAR YYDCDECL yysattributestackptr;	/* static attribute stack */
+#else
+extern char YYFAR *YYNEAR YYDCDECL yyvalptr;				/* attribute for $$ */
+extern char YYFAR *YYNEAR YYDCDECL yylvalptr;				/* current token attribute */
+extern char YYFAR *YYNEAR YYDCDECL yyattributestackptr;		/* attribute stack */
+extern char YYFAR *YYNEAR YYDCDECL yysattributestackptr;	/* static attribute stack */
+#endif
+
+/* compact parser */
+extern YYCONST yycstateaction_t YYNEARFAR YYDCDECL yycstateaction[];
+extern YYCONST yyctokenaction_t YYNEARFAR YYDCDECL yyctokenaction[];
+extern YYCONST yycstategoto_t YYNEARFAR YYDCDECL yycstategoto[];
+extern YYCONST yycnontermgoto_t YYNEARFAR YYDCDECL yycnontermgoto[];
+extern YYCONST yyctokendest_t YYNEARFAR *YYNEAR YYDCDECL yyctokendestptr;
+
+/* fast parser */
+extern YYCONST yystateaction_t YYNEARFAR YYDCDECL yystateaction[];
+extern YYCONST yytokenaction_t YYNEARFAR YYDCDECL yytokenaction[];
+extern int YYNEAR YYDCDECL yytokenaction_size;
+extern YYCONST yystategoto_t YYNEARFAR YYDCDECL yystategoto[];
+extern YYCONST yynontermgoto_t YYNEARFAR YYDCDECL yynontermgoto[];
+extern int YYNEAR YYDCDECL yynontermgoto_size;
+extern YYCONST yytokendest_t YYNEARFAR *YYNEAR YYDCDECL yytokendestptr;
+extern int YYNEAR YYDCDECL yytokendest_size;
+extern int YYNEAR YYDCDECL yytokendestbase;
+
+extern YYCONST yyreduction_t YYNEARFAR YYDCDECL yyreduction[];
+
+extern YYCONST yydestructor_t YYNEARFAR *YYNEAR YYDCDECL yydestructorptr;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* user defines */
+#if defined(YYBUDEFS) || defined(YYUDEFS)
+#include <yybudefs.h>
+#endif
+
+/* defines */
+#include <yybdefs.h>
+
+#endif

Utils/Parser Generator/INCLUDE/yybdefs.h

@@ -0,0 +1,49 @@
+/************************************************************
+yybdefs.h
+This file can be freely modified for the generation of
+custom code.
+
+Copyright (c) 1999 Bumble-Bee Software Ltd.
+************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Microsoft defines */
+#ifdef _MSC_VER
+
+/* structure alignment */
+#ifdef _WIN32
+#pragma pack(pop)
+#else
+#pragma pack()
+#endif
+
+#endif
+
+
+/* Borland defines */
+#ifdef __BORLANDC__
+
+#if !defined(RC_INVOKED)
+
+#if (__BORLANDC__) >= 0x0530
+/* restore default packing */
+#pragma pack(pop)
+#pragma nopackwarning
+#else
+#pragma option -a. /* restore default packing */
+#endif  /* (__BORLANDC__) >= 0x0530 */
+
+#if defined(__STDC__)
+#pragma warn .nak
+#endif
+
+#endif  /* !RC_INVOKED */
+
+#endif
+
+#ifdef __cplusplus
+};
+#endif

Utils/Parser Generator/INCLUDE/yytdefs.h

@@ -0,0 +1,148 @@
+/************************************************************
+yytdefs.h
+This file can be freely modified for the generation of
+custom code.
+
+Copyright (c) 1999 Bumble-Bee Software Ltd.
+************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Microsoft defines */
+#ifdef _MSC_VER
+
+/* version 6.0 compatibility */
+#if (_MSC_VER <= 600)
+#define __cdecl     _cdecl
+#define __far       _far
+#define __near      _near
+#define __segname   _segname
+#endif
+
+/* structure alignment */
+#ifdef _WIN32
+/*
+ * Currently, all MS C compilers for Win32 platforms default to 8 byte
+ * alignment.
+ */
+#pragma pack(push,8)
+#else
+#pragma pack(2)
+#endif
+
+/* stream initialisation */
+#ifdef _DLL
+#define YYNINITSTREAM
+#endif
+
+/* 32/16-bit modifiers */
+#ifndef YYCDECL
+#define YYCDECL __cdecl
+#endif
+
+/* 16-bit modifiers */
+#ifndef _WIN32
+#ifndef YYDCDECL
+#define YYDCDECL __cdecl
+#endif
+#ifndef YYNEAR
+#define YYNEAR __near
+#endif
+#ifndef YYNEARFAR
+#if defined(M_I86TM) || defined(M_I86SM)
+#define YYNEARFAR __near
+#else
+#define YYNEARFAR __far
+#endif
+#endif
+#ifndef YYBASED_CODE
+#if defined(M_I86MM) || defined(M_I86LM) || defined(M_I86HM)
+#define YYBASED_CODE __based(__segname("_CODE"))
+#endif
+#endif
+#endif
+
+/* function prototypes */
+#ifndef YYPROTOTYPE
+#define YYPROTOTYPE
+#endif
+
+/* qualifiers */
+#ifndef YYCONST
+#define YYCONST const
+#endif
+
+#endif
+
+
+/* Borland defines */
+#ifdef __BORLANDC__
+
+#if !defined(RC_INVOKED)
+
+#if defined(__STDC__)
+#pragma warn -nak
+#endif
+
+#if (__BORLANDC__) >= 0x0530
+#pragma pack(push, 1)
+#pragma nopackwarning
+#else
+#pragma option -a-
+#endif  /* (__BORLANDC__) >= 0x0530 */
+
+#pragma option -a-
+
+#endif  /* !RC_INVOKED */
+
+/* stream initialisation */
+#ifdef _RTLDLL
+#if (__BORLANDC__) >= 0x0530
+#define YYNINITSTREAM
+#endif
+#endif
+
+/* 32/16-bit modifiers */
+#ifndef YYCDECL
+#define YYCDECL __cdecl
+#endif
+#ifndef YYDCDECL
+#define YYDCDECL __cdecl
+#endif
+
+/* 16-bit modifiers */
+#ifndef __WIN32__
+#ifndef YYNEAR
+#define YYNEAR __near
+#endif
+#ifndef YYFAR
+#ifdef __DLL__
+#define YYFAR __far
+#endif
+#endif
+#ifndef YYNEARFAR
+#if defined(__TINY__) || defined(__SMALL__) || defined(__MEDIUM__)
+#define YYNEARFAR __near
+#else
+#define YYNEARFAR __far
+#endif
+#endif
+#endif
+
+/* function prototypes */
+#ifndef YYPROTOTYPE
+#define YYPROTOTYPE
+#endif
+
+/* qualifiers */
+#ifndef YYCONST
+#define YYCONST const
+#endif
+
+#endif
+
+#ifdef __cplusplus
+};
+#endif