[ros-diffs] [cwittich] 43568: add a regression test for RosBE (flex/bison)

Author: cwittich
Date: Sun Oct 18 20:40:13 2009
New Revision: 43568

URL: http://svn.reactos.org/svn/reactos?rev=43568&view=rev
Log:
add a regression test for RosBE (flex/bison)

Added:
    trunk/tools/RosBE/RosBE-Windows/regtest/   (with props)
    trunk/tools/RosBE/RosBE-Windows/regtest/parser.l   (with props)
    trunk/tools/RosBE/RosBE-Windows/regtest/parser.y   (with props)
    trunk/tools/RosBE/RosBE-Windows/regtest/regtest.cmd   (with props)

Propchange: trunk/tools/RosBE/RosBE-Windows/regtest/
------------------------------------------------------------------------------
--- bugtraq:logregex (added)
+++ bugtraq:logregex Sun Oct 18 20:40:13 2009
@@ -1,0 +1,2 @@
+([Ii]ssue|[Bb]ug)s? #?(\d+)(,? ?#?(\d+))*(,? ?(and |or )?#?(\d+))?
+(\d+)

Propchange: trunk/tools/RosBE/RosBE-Windows/regtest/
------------------------------------------------------------------------------
    bugtraq:message = See issue #%BUGID% for more details.

Propchange: trunk/tools/RosBE/RosBE-Windows/regtest/
------------------------------------------------------------------------------
    bugtraq:url = http://www.reactos.org/bugzilla/show_bug.cgi?id=%BUGID%

Added: trunk/tools/RosBE/RosBE-Windows/regtest/parser.l
URL:
http://svn.reactos.org/svn/reactos/trunk/tools/RosBE/RosBE-Windows/regtest/…
==============================================================================
--- trunk/tools/RosBE/RosBE-Windows/regtest/parser.l (added)
+++ trunk/tools/RosBE/RosBE-Windows/regtest/parser.l [iso-8859-1] Sun Oct 18 20:40:13
2009
@@ -1,0 +1,482 @@
+/* -*-C-*-
+ * IDL Compiler
+ *
+ * Copyright 2002 Ove Kaaven
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+%option stack
+%option noinput nounput noyy_top_state
+%option 8bit never-interactive prefix="parser_"
+
+nl	\r?\n
+ws	[ \f\t\r]
+cident	[a-zA-Z_][0-9a-zA-Z_]*
+u_suffix	(u|U)
+l_suffix	(l|L)
+int	[0-9]+({l_suffix}?{u_suffix}?|{u_suffix}?{l_suffix}?)?
+hexd	[0-9a-fA-F]
+hex	0(x|X){hexd}+({l_suffix}?{u_suffix}?|{u_suffix}?{l_suffix}?)?
+uuid	{hexd}{8}-{hexd}{4}-{hexd}{4}-{hexd}{4}-{hexd}{12}
+double	[0-9]+\.[0-9]+([eE][+-]?[0-9]+)*
+
+%x QUOTE
+%x WSTRQUOTE
+%x ATTR
+%x PP_LINE
+
+%{
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#else
+#define YY_NO_UNISTD_H
+#endif
+
+#include "widl.h"
+#include "utils.h"
+#include "parser.h"
+#include "wine/wpp.h"
+
+#include "parser.tab.h"
+
+extern char *temp_name;
+
+static void addcchar(char c);
+static char *get_buffered_cstring(void);
+
+static char *cbuffer;
+static int cbufidx;
+static int cbufalloc = 0;
+
+static int kw_token(const char *kw);
+static int attr_token(const char *kw);
+
+#define MAX_IMPORT_DEPTH 10
+struct {
+  YY_BUFFER_STATE state;
+  char *input_name;
+  int   line_number;
+  char *temp_name;
+} import_stack[MAX_IMPORT_DEPTH];
+int import_stack_ptr = 0;
+
+/* converts an integer in string form to an unsigned long and prints an error
+ * on overflow */
+static unsigned long xstrtoul(const char *nptr, char **endptr, int base)
+{
+    unsigned long l;
+
+    errno = 0;
+    l = strtoul(nptr, endptr, base);
+    if (l == ULONG_MAX && errno == ERANGE)
+        error_loc("integer constant %s is too large\n", nptr);
+    return l;
+}
+
+UUID *parse_uuid(const char *u)
+{
+  UUID* uuid = xmalloc(sizeof(UUID));
+  char b[3];
+  /* it would be nice to use UuidFromStringA */
+  uuid->Data1 = strtoul(u, NULL, 16);
+  uuid->Data2 = strtoul(u+9, NULL, 16);
+  uuid->Data3 = strtoul(u+14, NULL, 16);
+  b[2] = 0;
+  memcpy(b, u+19, 2); uuid->Data4[0] = strtoul(b, NULL, 16);
+  memcpy(b, u+21, 2); uuid->Data4[1] = strtoul(b, NULL, 16);
+  memcpy(b, u+24, 2); uuid->Data4[2] = strtoul(b, NULL, 16);
+  memcpy(b, u+26, 2); uuid->Data4[3] = strtoul(b, NULL, 16);
+  memcpy(b, u+28, 2); uuid->Data4[4] = strtoul(b, NULL, 16);
+  memcpy(b, u+30, 2); uuid->Data4[5] = strtoul(b, NULL, 16);
+  memcpy(b, u+32, 2); uuid->Data4[6] = strtoul(b, NULL, 16);
+  memcpy(b, u+34, 2); uuid->Data4[7] = strtoul(b, NULL, 16);
+  return uuid;
+}
+
+%}
+
+/*
+ **************************************************************************
+ * The flexer starts here
+ **************************************************************************
+ */
+%%
+<INITIAL,ATTR>^{ws}*\#{ws}*	yy_push_state(PP_LINE);
+<PP_LINE>[^\n]*         {
+                            int lineno;
+                            char *cptr, *fname;
+                            yy_pop_state();
+                            lineno = (int)strtol(yytext, &cptr, 10);
+                            if(!lineno)
+                                error_loc("Malformed '#...' line-directive;
invalid linenumber\n");
+                            fname = strchr(cptr, '"');
+                            if(!fname)
+                                error_loc("Malformed '#...' line-directive;
missing filename\n");
+                            fname++;
+                            cptr = strchr(fname, '"');
+                            if(!cptr)
+                                error_loc("Malformed '#...' line-directive;
missing terminating \"\n");
+                            *cptr = '\0';
+                            line_number = lineno - 1;  /* We didn't read the newline
*/
+                            free( input_name );
+                            input_name = xstrdup(fname);
+                        }
+<INITIAL,ATTR>\"	yy_push_state(QUOTE); cbufidx = 0;
+<QUOTE>\"		{
+				yy_pop_state();
+				parser_lval.str = get_buffered_cstring();
+				return aSTRING;
+			}
+<INITIAL,ATTR>L\"	yy_push_state(WSTRQUOTE);
+<WSTRQUOTE>\"		{
+				yy_pop_state();
+				parser_lval.str = get_buffered_cstring();
+				return aWSTRING;
+			}
+<QUOTE,WSTRQUOTE>\\\\	|
+<QUOTE,WSTRQUOTE>\\\"	addcchar(yytext[1]);
+<QUOTE,WSTRQUOTE>\\.	addcchar('\\'); addcchar(yytext[1]);
+<QUOTE,WSTRQUOTE>.	addcchar(yytext[0]);
+<INITIAL,ATTR>\[	yy_push_state(ATTR); return '[';
+<ATTR>\]		yy_pop_state(); return ']';
+<ATTR>{cident}		return attr_token(yytext);
+<ATTR>{uuid}			{
+				parser_lval.uuid = parse_uuid(yytext);
+				return aUUID;
+			}
+<INITIAL,ATTR>{hex}	{
+				parser_lval.num = xstrtoul(yytext, NULL, 0);
+				return aHEXNUM;
+			}
+<INITIAL,ATTR>{int}	{
+				parser_lval.num = xstrtoul(yytext, NULL, 0);
+				return aNUM;
+			}
+<INITIAL>{double}	{
+				parser_lval.dbl = strtod(yytext, NULL);
+				return aDOUBLE;
+			}
+SAFEARRAY{ws}*/\(	return tSAFEARRAY;
+{cident}		return kw_token(yytext);
+<INITIAL,ATTR>\n	line_number++;
+<INITIAL,ATTR>{ws}
+<INITIAL,ATTR>\<\<	return SHL;
+<INITIAL,ATTR>\>\>	return SHR;
+<INITIAL,ATTR>\-\>	return MEMBERPTR;
+<INITIAL,ATTR>==	return EQUALITY;
+<INITIAL,ATTR>!=	return INEQUALITY;
+<INITIAL,ATTR>\>=	return GREATEREQUAL;
+<INITIAL,ATTR>\<=	return LESSEQUAL;
+<INITIAL,ATTR>\|\|	return LOGICALOR;
+<INITIAL,ATTR>&&	return LOGICALAND;
+<INITIAL,ATTR>.		return yytext[0];
+<<EOF>>			{
+				if (import_stack_ptr)
+					return aEOF;
+				else yyterminate();
+			}
+%%
+
+#ifndef parser_wrap
+int parser_wrap(void)
+{
+	return 1;
+}
+#endif
+
+struct keyword {
+	const char *kw;
+	int token;
+};
+
+/* This table MUST be alphabetically sorted on the kw field */
+static const struct keyword keywords[] = {
+	{"FALSE",			tFALSE},
+	{"NULL",			tNULL},
+	{"TRUE",			tTRUE},
+	{"__cdecl",			tCDECL},
+	{"__fastcall",			tFASTCALL},
+	{"__int64",			tINT64},
+	{"__pascal",			tPASCAL},
+	{"__stdcall",			tSTDCALL},
+	{"_cdecl",			tCDECL},
+	{"_fastcall",			tFASTCALL},
+	{"_pascal",			tPASCAL},
+	{"_stdcall",			tSTDCALL},
+	{"boolean",			tBOOLEAN},
+	{"byte",			tBYTE},
+	{"case",			tCASE},
+	{"cdecl",			tCDECL},
+	{"char",			tCHAR},
+	{"coclass",			tCOCLASS},
+	{"const",			tCONST},
+	{"cpp_quote",			tCPPQUOTE},
+	{"default",			tDEFAULT},
+	{"dispinterface",		tDISPINTERFACE},
+	{"double",			tDOUBLE},
+	{"enum",			tENUM},
+	{"error_status_t",		tERRORSTATUST},
+	{"extern",			tEXTERN},
+	{"float",			tFLOAT},
+	{"handle_t",			tHANDLET},
+	{"hyper",			tHYPER},
+	{"import",			tIMPORT},
+	{"importlib",			tIMPORTLIB},
+	{"inline",			tINLINE},
+	{"int",				tINT},
+	{"interface",			tINTERFACE},
+	{"library",			tLIBRARY},
+	{"long",			tLONG},
+	{"methods",			tMETHODS},
+	{"module",			tMODULE},
+	{"pascal",			tPASCAL},
+	{"properties",			tPROPERTIES},
+	{"register",			tREGISTER},
+	{"short",			tSHORT},
+	{"signed",			tSIGNED},
+	{"sizeof",			tSIZEOF},
+        {"small",			tSMALL},
+	{"static",			tSTATIC},
+	{"stdcall",			tSTDCALL},
+	{"struct",			tSTRUCT},
+	{"switch",			tSWITCH},
+	{"typedef",			tTYPEDEF},
+	{"union",			tUNION},
+	{"unsigned",			tUNSIGNED},
+	{"void",			tVOID},
+	{"wchar_t",			tWCHAR},
+};
+#define NKEYWORDS (sizeof(keywords)/sizeof(keywords[0]))
+
+/* keywords only recognized in attribute lists
+ * This table MUST be alphabetically sorted on the kw field
+ */
+static const struct keyword attr_keywords[] =
+{
+        {"aggregatable",                tAGGREGATABLE},
+        {"allocate",                    tALLOCATE},
+        {"appobject",                   tAPPOBJECT},
+        {"async",                       tASYNC},
+        {"async_uuid",                  tASYNCUUID},
+        {"auto_handle",                 tAUTOHANDLE},
+        {"bindable",                    tBINDABLE},
+        {"broadcast",                   tBROADCAST},
+        {"byte_count",                  tBYTECOUNT},
+        {"call_as",                     tCALLAS},
+        {"callback",                    tCALLBACK},
+        {"code",                        tCODE},
+        {"comm_status",                 tCOMMSTATUS},
+        {"context_handle",              tCONTEXTHANDLE},
+        {"context_handle_noserialize",  tCONTEXTHANDLENOSERIALIZE},
+        {"context_handle_serialize",    tCONTEXTHANDLENOSERIALIZE},
+        {"control",                     tCONTROL},
+        {"defaultcollelem",             tDEFAULTCOLLELEM},
+        {"defaultvalue",                tDEFAULTVALUE},
+        {"defaultvtable",               tDEFAULTVTABLE},
+        {"displaybind",                 tDISPLAYBIND},
+        {"dllname",                     tDLLNAME},
+        {"dual",                        tDUAL},
+        {"endpoint",                    tENDPOINT},
+        {"entry",                       tENTRY},
+        {"explicit_handle",             tEXPLICITHANDLE},
+        {"handle",                      tHANDLE},
+        {"helpcontext",                 tHELPCONTEXT},
+        {"helpfile",                    tHELPFILE},
+        {"helpstring",                  tHELPSTRING},
+        {"helpstringcontext",           tHELPSTRINGCONTEXT},
+        {"helpstringdll",               tHELPSTRINGDLL},
+        {"hidden",                      tHIDDEN},
+        {"id",                          tID},
+        {"idempotent",                  tIDEMPOTENT},
+        {"iid_is",                      tIIDIS},
+        {"immediatebind",               tIMMEDIATEBIND},
+        {"implicit_handle",             tIMPLICITHANDLE},
+        {"in",                          tIN},
+        {"in_line",                     tIN_LINE},
+        {"input_sync",                  tINPUTSYNC},
+        {"lcid",                        tLCID},
+        {"length_is",                   tLENGTHIS},
+        {"local",                       tLOCAL},
+        {"nonbrowsable",                tNONBROWSABLE},
+        {"noncreatable",                tNONCREATABLE},
+        {"nonextensible",               tNONEXTENSIBLE},
+        {"object",                      tOBJECT},
+        {"odl",                         tODL},
+        {"oleautomation",               tOLEAUTOMATION},
+        {"optional",                    tOPTIONAL},
+        {"out",                         tOUT},
+        {"pointer_default",             tPOINTERDEFAULT},
+        {"propget",                     tPROPGET},
+        {"propput",                     tPROPPUT},
+        {"propputref",                  tPROPPUTREF},
+        {"ptr",                         tPTR},
+        {"public",                      tPUBLIC},
+        {"range",                       tRANGE},
+        {"readonly",                    tREADONLY},
+        {"ref",                         tREF},
+        {"requestedit",                 tREQUESTEDIT},
+        {"restricted",                  tRESTRICTED},
+        {"retval",                      tRETVAL},
+        {"size_is",                     tSIZEIS},
+        {"source",                      tSOURCE},
+        {"strict_context_handle",       tSTRICTCONTEXTHANDLE},
+        {"string",                      tSTRING},
+        {"switch_is",                   tSWITCHIS},
+        {"switch_type",                 tSWITCHTYPE},
+        {"transmit_as",                 tTRANSMITAS},
+        {"unique",                      tUNIQUE},
+        {"uuid",                        tUUID},
+        {"v1_enum",                     tV1ENUM},
+        {"vararg",                      tVARARG},
+        {"version",                     tVERSION},
+        {"wire_marshal",                tWIREMARSHAL},
+};
+
+
+#define KWP(p) ((const struct keyword *)(p))
+
+static int kw_cmp_func(const void *s1, const void *s2)
+{
+	return strcmp(KWP(s1)->kw, KWP(s2)->kw);
+}
+
+static int kw_token(const char *kw)
+{
+	struct keyword key, *kwp;
+	key.kw = kw;
+	kwp = bsearch(&key, keywords, NKEYWORDS, sizeof(keywords[0]), kw_cmp_func);
+	if (kwp) {
+		parser_lval.str = xstrdup(kwp->kw);
+		return kwp->token;
+	}
+	parser_lval.str = xstrdup(kw);
+	return is_type(kw) ? aKNOWNTYPE : aIDENTIFIER;
+}
+
+static int attr_token(const char *kw)
+{
+        struct keyword key, *kwp;
+        key.kw = kw;
+        kwp = bsearch(&key, attr_keywords,
sizeof(attr_keywords)/sizeof(attr_keywords[0]),
+                      sizeof(attr_keywords[0]), kw_cmp_func);
+        if (kwp) {
+            parser_lval.str = xstrdup(kwp->kw);
+            return kwp->token;
+        }
+        return kw_token(kw);
+}
+
+static void addcchar(char c)
+{
+	if(cbufidx >= cbufalloc)
+	{
+		cbufalloc += 1024;
+		cbuffer = xrealloc(cbuffer, cbufalloc * sizeof(cbuffer[0]));
+		if(cbufalloc > 65536)
+			parser_warning("Reallocating string buffer larger than 64kB\n");
+	}
+	cbuffer[cbufidx++] = c;
+}
+
+static char *get_buffered_cstring(void)
+{
+	addcchar(0);
+	return xstrdup(cbuffer);
+}
+
+void pop_import(void)
+{
+	int ptr = import_stack_ptr-1;
+
+	fclose(yyin);
+	yy_delete_buffer( YY_CURRENT_BUFFER );
+	yy_switch_to_buffer( import_stack[ptr].state );
+	if (temp_name) {
+		unlink(temp_name);
+		free(temp_name);
+	}
+	temp_name = import_stack[ptr].temp_name;
+	input_name = import_stack[ptr].input_name;
+	line_number = import_stack[ptr].line_number;
+	import_stack_ptr--;
+}
+
+struct imports {
+	char *name;
+	struct imports *next;
+} *first_import;
+
+int do_import(char *fname)
+{
+	FILE *f;
+	char *path;
+	struct imports *import;
+	int ptr = import_stack_ptr;
+	int ret;
+
+	import = first_import;
+	while (import && strcmp(import->name, fname))
+		import = import->next;
+	if (import) return 0; /* already imported */
+
+	import = xmalloc(sizeof(struct imports));
+	import->name = xstrdup(fname);
+	import->next = first_import;
+	first_import = import;
+
+        /* don't search for a file name with a path in the include directories,
+         * for compatibility with MIDL */
+        if (strchr( fname, '/' ) || strchr( fname, '\\' ))
+            path = strdup( fname );
+        else if (!(path = wpp_find_include( fname, input_name )))
+            error_loc("Unable to open include file %s\n", fname);
+
+	import_stack[ptr].temp_name = temp_name;
+	import_stack[ptr].input_name = input_name;
+	import_stack[ptr].line_number = line_number;
+	import_stack_ptr++;
+        input_name = path;
+        line_number = 1;
+
+        ret = wpp_parse_temp( path, NULL, &temp_name );
+        if (ret) exit(1);
+
+	if((f = fopen(temp_name, "r")) == NULL)
+		error_loc("Unable to open %s\n", temp_name);
+
+	import_stack[ptr].state = YY_CURRENT_BUFFER;
+	yy_switch_to_buffer(yy_create_buffer(f, YY_BUF_SIZE));
+	return 1;
+}
+
+void abort_import(void)
+{
+	int ptr;
+
+	for (ptr=0; ptr<import_stack_ptr; ptr++)
+		unlink(import_stack[ptr].temp_name);
+}

Propchange: trunk/tools/RosBE/RosBE-Windows/regtest/parser.l
------------------------------------------------------------------------------
    svn:eol-style = native

Added: trunk/tools/RosBE/RosBE-Windows/regtest/parser.y
URL:
http://svn.reactos.org/svn/reactos/trunk/tools/RosBE/RosBE-Windows/regtest/…
==============================================================================
--- trunk/tools/RosBE/RosBE-Windows/regtest/parser.y (added)
+++ trunk/tools/RosBE/RosBE-Windows/regtest/parser.y [iso-8859-1] Sun Oct 18 20:40:13
2009
@@ -1,0 +1,1636 @@
+/*
+ * Copyright 2008 Jacek Caban for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+%{
+
+#include "jscript.h"
+#include "engine.h"
+
+#define YYLEX_PARAM ctx
+#define YYPARSE_PARAM ctx
+
+static int parser_error(const char*);
+static void set_error(parser_ctx_t*,UINT);
+static BOOL explicit_error(parser_ctx_t*,void*,WCHAR);
+static BOOL allow_auto_semicolon(parser_ctx_t*);
+static void program_parsed(parser_ctx_t*,source_elements_t*);
+static source_elements_t *function_body_parsed(parser_ctx_t*,source_elements_t*);
+
+typedef struct _statement_list_t {
+    statement_t *head;
+    statement_t *tail;
+} statement_list_t;
+
+static literal_t *new_string_literal(parser_ctx_t*,const WCHAR*);
+static literal_t *new_null_literal(parser_ctx_t*);
+static literal_t *new_undefined_literal(parser_ctx_t*);
+static literal_t *new_boolean_literal(parser_ctx_t*,VARIANT_BOOL);
+
+typedef struct _property_list_t {
+    prop_val_t *head;
+    prop_val_t *tail;
+} property_list_t;
+
+static property_list_t *new_property_list(parser_ctx_t*,literal_t*,expression_t*);
+static property_list_t
*property_list_add(parser_ctx_t*,property_list_t*,literal_t*,expression_t*);
+
+typedef struct _element_list_t {
+    array_element_t *head;
+    array_element_t *tail;
+} element_list_t;
+
+static element_list_t *new_element_list(parser_ctx_t*,int,expression_t*);
+static element_list_t
*element_list_add(parser_ctx_t*,element_list_t*,int,expression_t*);
+
+typedef struct _argument_list_t {
+    argument_t *head;
+    argument_t *tail;
+} argument_list_t;
+
+static argument_list_t *new_argument_list(parser_ctx_t*,expression_t*);
+static argument_list_t *argument_list_add(parser_ctx_t*,argument_list_t*,expression_t*);
+
+typedef struct _case_list_t {
+    case_clausule_t *head;
+    case_clausule_t *tail;
+} case_list_t;
+
+static catch_block_t *new_catch_block(parser_ctx_t*,const WCHAR*,statement_t*);
+static case_clausule_t
*new_case_clausule(parser_ctx_t*,expression_t*,statement_list_t*);
+static case_list_t *new_case_list(parser_ctx_t*,case_clausule_t*);
+static case_list_t *case_list_add(parser_ctx_t*,case_list_t*,case_clausule_t*);
+static case_clausule_t
*new_case_block(parser_ctx_t*,case_list_t*,case_clausule_t*,case_list_t*);
+
+typedef struct _variable_list_t {
+    variable_declaration_t *head;
+    variable_declaration_t *tail;
+} variable_list_t;
+
+static variable_declaration_t *new_variable_declaration(parser_ctx_t*,const
WCHAR*,expression_t*);
+static variable_list_t *new_variable_list(parser_ctx_t*,variable_declaration_t*);
+static variable_list_t
*variable_list_add(parser_ctx_t*,variable_list_t*,variable_declaration_t*);
+
+static statement_t *new_block_statement(parser_ctx_t*,statement_list_t*);
+static statement_t *new_var_statement(parser_ctx_t*,variable_list_t*);
+static statement_t *new_empty_statement(parser_ctx_t*);
+static statement_t *new_expression_statement(parser_ctx_t*,expression_t*);
+static statement_t
*new_if_statement(parser_ctx_t*,expression_t*,statement_t*,statement_t*);
+static statement_t *new_while_statement(parser_ctx_t*,BOOL,expression_t*,statement_t*);
+static statement_t
*new_for_statement(parser_ctx_t*,variable_list_t*,expression_t*,expression_t*,
+        expression_t*,statement_t*);
+static statement_t
*new_forin_statement(parser_ctx_t*,variable_declaration_t*,expression_t*,expression_t*,statement_t*);
+static statement_t *new_continue_statement(parser_ctx_t*,const WCHAR*);
+static statement_t *new_break_statement(parser_ctx_t*,const WCHAR*);
+static statement_t *new_return_statement(parser_ctx_t*,expression_t*);
+static statement_t *new_with_statement(parser_ctx_t*,expression_t*,statement_t*);
+static statement_t *new_labelled_statement(parser_ctx_t*,const WCHAR*,statement_t*);
+static statement_t *new_switch_statement(parser_ctx_t*,expression_t*,case_clausule_t*);
+static statement_t *new_throw_statement(parser_ctx_t*,expression_t*);
+static statement_t
*new_try_statement(parser_ctx_t*,statement_t*,catch_block_t*,statement_t*);
+
+struct statement_list_t {
+   statement_t *head;
+   statement_t *tail;
+};
+
+static statement_list_t *new_statement_list(parser_ctx_t*,statement_t*);
+static statement_list_t *statement_list_add(statement_list_t*,statement_t*);
+
+typedef struct _parameter_list_t {
+    parameter_t *head;
+    parameter_t *tail;
+} parameter_list_t;
+
+static parameter_list_t *new_parameter_list(parser_ctx_t*,const WCHAR*);
+static parameter_list_t *parameter_list_add(parser_ctx_t*,parameter_list_t*,const
WCHAR*);
+
+static void push_func(parser_ctx_t*);
+static inline void pop_func(parser_ctx_t *ctx)
+{
+    ctx->func_stack = ctx->func_stack->next;
+}
+
+static expression_t *new_function_expression(parser_ctx_t*,const
WCHAR*,parameter_list_t*,
+        source_elements_t*,const WCHAR*,DWORD);
+static expression_t
*new_binary_expression(parser_ctx_t*,expression_type_t,expression_t*,expression_t*);
+static expression_t
*new_unary_expression(parser_ctx_t*,expression_type_t,expression_t*);
+static expression_t
*new_conditional_expression(parser_ctx_t*,expression_t*,expression_t*,expression_t*);
+static expression_t *new_array_expression(parser_ctx_t*,expression_t*,expression_t*);
+static expression_t *new_member_expression(parser_ctx_t*,expression_t*,const WCHAR*);
+static expression_t *new_new_expression(parser_ctx_t*,expression_t*,argument_list_t*);
+static expression_t *new_call_expression(parser_ctx_t*,expression_t*,argument_list_t*);
+static expression_t *new_this_expression(parser_ctx_t*);
+static expression_t *new_identifier_expression(parser_ctx_t*,const WCHAR*);
+static expression_t *new_literal_expression(parser_ctx_t*,literal_t*);
+static expression_t *new_array_literal_expression(parser_ctx_t*,element_list_t*,int);
+static expression_t *new_prop_and_value_expression(parser_ctx_t*,property_list_t*);
+
+static source_elements_t *new_source_elements(parser_ctx_t*);
+static source_elements_t
*source_elements_add_statement(source_elements_t*,statement_t*);
+
+%}
+
+%pure_parser
+%start Program
+
+%union {
+    int                     ival;
+    const WCHAR             *srcptr;
+    LPCWSTR                 wstr;
+    literal_t               *literal;
+    struct _argument_list_t *argument_list;
+    case_clausule_t         *case_clausule;
+    struct _case_list_t     *case_list;
+    catch_block_t           *catch_block;
+    struct _element_list_t  *element_list;
+    expression_t            *expr;
+    const WCHAR            *identifier;
+    struct _parameter_list_t *parameter_list;
+    struct _property_list_t *property_list;
+    source_elements_t       *source_elements;
+    statement_t             *statement;
+    struct _statement_list_t *statement_list;
+    struct _variable_list_t *variable_list;
+    variable_declaration_t  *variable_declaration;
+}
+
+/* keywords */
+%token kBREAK kCASE kCATCH kCONTINUE kDEFAULT kDELETE kDO kELSE kIF kFINALLY kFOR kIN
+%token kINSTANCEOF kNEW kNULL kUNDEFINED kRETURN kSWITCH kTHIS kTHROW kTRUE kFALSE kTRY
kTYPEOF kVAR kVOID kWHILE kWITH
+%token tANDAND tOROR tINC tDEC tHTMLCOMMENT
+
+%token <srcptr> kFUNCTION '}'
+
+/* tokens */
+%token <identifier> tIdentifier
+%token <ival> tAssignOper tEqOper tShiftOper tRelOper
+%token <literal> tNumericLiteral
+%token <wstr> tStringLiteral
+
+%type <source_elements> SourceElements
+%type <source_elements> FunctionBody
+%type <statement> Statement
+%type <statement> Block
+%type <statement> VariableStatement
+%type <statement> EmptyStatement
+%type <statement> ExpressionStatement
+%type <statement> IfStatement
+%type <statement> IterationStatement
+%type <statement> ContinueStatement
+%type <statement> BreakStatement
+%type <statement> ReturnStatement
+%type <statement> WithStatement
+%type <statement> LabelledStatement
+%type <statement> SwitchStatement
+%type <statement> ThrowStatement
+%type <statement> TryStatement
+%type <statement> Finally
+%type <statement_list> StatementList StatementList_opt
+%type <parameter_list> FormalParameterList FormalParameterList_opt
+%type <expr> Expression Expression_opt Expression_err
+%type <expr> ExpressionNoIn ExpressionNoIn_opt
+%type <expr> FunctionExpression
+%type <expr> AssignmentExpression AssignmentExpressionNoIn
+%type <expr> ConditionalExpression ConditionalExpressionNoIn
+%type <expr> LeftHandSideExpression
+%type <expr> LogicalORExpression LogicalORExpressionNoIn
+%type <expr> LogicalANDExpression LogicalANDExpressionNoIn
+%type <expr> BitwiseORExpression BitwiseORExpressionNoIn
+%type <expr> BitwiseXORExpression BitwiseXORExpressionNoIn
+%type <expr> BitwiseANDExpression BitwiseANDExpressionNoIn
+%type <expr> EqualityExpression EqualityExpressionNoIn
+%type <expr> RelationalExpression RelationalExpressionNoIn
+%type <expr> ShiftExpression
+%type <expr> AdditiveExpression
+%type <expr> MultiplicativeExpression
+%type <expr> Initialiser_opt Initialiser
+%type <expr> InitialiserNoIn_opt InitialiserNoIn
+%type <expr> UnaryExpression
+%type <expr> PostfixExpression
+%type <expr> NewExpression
+%type <expr> CallExpression
+%type <expr> MemberExpression
+%type <expr> PrimaryExpression
+%type <identifier> Identifier_opt
+%type <variable_list> VariableDeclarationList
+%type <variable_list> VariableDeclarationListNoIn
+%type <variable_declaration> VariableDeclaration
+%type <variable_declaration> VariableDeclarationNoIn
+%type <case_list> CaseClausules CaseClausules_opt
+%type <case_clausule> CaseClausule DefaultClausule CaseBlock
+%type <catch_block> Catch
+%type <argument_list> Arguments
+%type <argument_list> ArgumentList
+%type <literal> Literal
+%type <expr> ArrayLiteral
+%type <expr> ObjectLiteral
+%type <ival> Elision Elision_opt
+%type <element_list> ElementList
+%type <property_list> PropertyNameAndValueList
+%type <literal> PropertyName
+%type <literal> BooleanLiteral
+%type <srcptr> KFunction
+
+%nonassoc LOWER_THAN_ELSE
+%nonassoc kELSE
+
+%%
+
+/* ECMA-262 3rd Edition    14 */
+Program
+       : SourceElements HtmlComment
+                                { program_parsed(ctx, $1); }
+
+HtmlComment
+        : tHTMLCOMMENT          {}
+        | /* empty */           {}
+
+/* ECMA-262 3rd Edition    14 */
+SourceElements
+        : /* empty */           { $$ = new_source_elements(ctx); }
+        | SourceElements Statement
+                                { $$ = source_elements_add_statement($1, $2); }
+
+/* ECMA-262 3rd Edition    13 */
+FunctionExpression
+        : KFunction Identifier_opt left_bracket FormalParameterList_opt right_bracket
'{' FunctionBody '}'
+                                { $$ = new_function_expression(ctx, $2, $4, $7, $1,
$8-$1+1); }
+
+KFunction
+        : kFUNCTION             { push_func(ctx); $$ = $1; }
+
+/* ECMA-262 3rd Edition    13 */
+FunctionBody
+        : SourceElements        { $$ = function_body_parsed(ctx, $1); }
+
+/* ECMA-262 3rd Edition    13 */
+FormalParameterList
+        : tIdentifier           { $$ = new_parameter_list(ctx, $1); }
+        | FormalParameterList ',' tIdentifier
+                                { $$ = parameter_list_add(ctx, $1, $3); }
+
+/* ECMA-262 3rd Edition    13 */
+FormalParameterList_opt
+        : /* empty */           { $$ = NULL; }
+        | FormalParameterList   { $$ = $1; }
+
+/* ECMA-262 3rd Edition    12 */
+Statement
+        : Block                 { $$ = $1; }
+        | VariableStatement     { $$ = $1; }
+        | EmptyStatement        { $$ = $1; }
+        | ExpressionStatement   { $$ = $1; }
+        | IfStatement           { $$ = $1; }
+        | IterationStatement    { $$ = $1; }
+        | ContinueStatement     { $$ = $1; }
+        | BreakStatement        { $$ = $1; }
+        | ReturnStatement       { $$ = $1; }
+        | WithStatement         { $$ = $1; }
+        | LabelledStatement     { $$ = $1; }
+        | SwitchStatement       { $$ = $1; }
+        | ThrowStatement        { $$ = $1; }
+        | TryStatement          { $$ = $1; }
+
+/* ECMA-262 3rd Edition    12.2 */
+StatementList
+        : Statement             { $$ = new_statement_list(ctx, $1); }
+        | StatementList Statement
+                                { $$ = statement_list_add($1, $2); }
+
+/* ECMA-262 3rd Edition    12.2 */
+StatementList_opt
+        : /* empty */           { $$ = NULL; }
+        | StatementList         { $$ = $1; }
+
+/* ECMA-262 3rd Edition    12.1 */
+Block
+        : '{' StatementList '}' { $$ = new_block_statement(ctx, $2); }
+        | '{' '}'               { $$ = new_block_statement(ctx, NULL); }
+
+/* ECMA-262 3rd Edition    12.2 */
+VariableStatement
+        : kVAR VariableDeclarationList semicolon_opt
+                                { $$ = new_var_statement(ctx, $2); }
+
+/* ECMA-262 3rd Edition    12.2 */
+VariableDeclarationList
+        : VariableDeclaration   { $$ = new_variable_list(ctx, $1); }
+        | VariableDeclarationList ',' VariableDeclaration
+                                { $$ = variable_list_add(ctx, $1, $3); }
+
+/* ECMA-262 3rd Edition    12.2 */
+VariableDeclarationListNoIn
+        : VariableDeclarationNoIn
+                                { $$ = new_variable_list(ctx, $1); }
+        | VariableDeclarationListNoIn ',' VariableDeclarationNoIn
+                                { $$ = variable_list_add(ctx, $1, $3); }
+
+/* ECMA-262 3rd Edition    12.2 */
+VariableDeclaration
+        : tIdentifier Initialiser_opt
+                                { $$ = new_variable_declaration(ctx, $1, $2); }
+
+/* ECMA-262 3rd Edition    12.2 */
+VariableDeclarationNoIn
+        : tIdentifier InitialiserNoIn_opt
+                                { $$ = new_variable_declaration(ctx, $1, $2); }
+
+/* ECMA-262 3rd Edition    12.2 */
+Initialiser_opt
+        : /* empty */           { $$ = NULL; }
+        | Initialiser           { $$ = $1; }
+
+/* ECMA-262 3rd Edition    12.2 */
+Initialiser
+        : '=' AssignmentExpression
+                                { $$ = $2; }
+
+/* ECMA-262 3rd Edition    12.2 */
+InitialiserNoIn_opt
+        : /* empty */           { $$ = NULL; }
+        | InitialiserNoIn       { $$ = $1; }
+
+/* ECMA-262 3rd Edition    12.2 */
+InitialiserNoIn
+        : '=' AssignmentExpressionNoIn
+                                { $$ = $2; }
+
+/* ECMA-262 3rd Edition    12.3 */
+EmptyStatement
+        : ';'                   { $$ = new_empty_statement(ctx); }
+
+/* ECMA-262 3rd Edition    12.4 */
+ExpressionStatement
+        : Expression semicolon_opt
+                                { $$ = new_expression_statement(ctx, $1); }
+
+/* ECMA-262 3rd Edition    12.5 */
+IfStatement
+        : kIF left_bracket Expression_err right_bracket Statement kELSE Statement
+                                { $$ = new_if_statement(ctx, $3, $5, $7); }
+        | kIF left_bracket Expression_err right_bracket Statement %prec LOWER_THAN_ELSE
+                                { $$ = new_if_statement(ctx, $3, $5, NULL); }
+
+/* ECMA-262 3rd Edition    12.6 */
+IterationStatement
+        : kDO Statement kWHILE left_bracket Expression_err right_bracket semicolon_opt
+                                { $$ = new_while_statement(ctx, TRUE, $5, $2); }
+        | kWHILE left_bracket Expression_err right_bracket Statement
+                                { $$ = new_while_statement(ctx, FALSE, $3, $5); }
+        | kFOR left_bracket ExpressionNoIn_opt
+                                { if(!explicit_error(ctx, $3, ';')) YYABORT; }
+        semicolon  Expression_opt
+                                { if(!explicit_error(ctx, $6, ';')) YYABORT; }
+        semicolon Expression_opt right_bracket Statement
+                                { $$ = new_for_statement(ctx, NULL, $3, $6, $9, $11); }
+        | kFOR left_bracket kVAR VariableDeclarationListNoIn
+                                { if(!explicit_error(ctx, $4, ';')) YYABORT; }
+        semicolon Expression_opt
+                                { if(!explicit_error(ctx, $7, ';')) YYABORT; }
+        semicolon Expression_opt right_bracket Statement
+                                { $$ = new_for_statement(ctx, $4, NULL, $7, $10, $12); }
+        | kFOR left_bracket LeftHandSideExpression kIN Expression_err right_bracket
Statement
+                                { $$ = new_forin_statement(ctx, NULL, $3, $5, $7); }
+        | kFOR left_bracket kVAR VariableDeclarationNoIn kIN Expression_err right_bracket
Statement
+                                { $$ = new_forin_statement(ctx, $4, NULL, $6, $8); }
+
+/* ECMA-262 3rd Edition    12.7 */
+ContinueStatement
+        : kCONTINUE /* NONL */ Identifier_opt semicolon_opt
+                                { $$ = new_continue_statement(ctx, $2); }
+
+/* ECMA-262 3rd Edition    12.8 */
+BreakStatement
+        : kBREAK /* NONL */ Identifier_opt semicolon_opt
+                                { $$ = new_break_statement(ctx, $2); }
+
+/* ECMA-262 3rd Edition    12.9 */
+ReturnStatement
+        : kRETURN /* NONL */ Expression_opt semicolon_opt
+                                { $$ = new_return_statement(ctx, $2); }
+
+/* ECMA-262 3rd Edition    12.10 */
+WithStatement
+        : kWITH left_bracket Expression right_bracket Statement
+                                { $$ = new_with_statement(ctx, $3, $5); }
+
+/* ECMA-262 3rd Edition    12.12 */
+LabelledStatement
+        : tIdentifier ':' Statement
+                                { $$ = new_labelled_statement(ctx, $1, $3); }
+
+/* ECMA-262 3rd Edition    12.11 */
+SwitchStatement
+        : kSWITCH left_bracket Expression right_bracket CaseBlock
+                                { $$ = new_switch_statement(ctx, $3, $5); }
+
+/* ECMA-262 3rd Edition    12.11 */
+CaseBlock
+        : '{' CaseClausules_opt '}'
+                                 { $$ = new_case_block(ctx, $2, NULL, NULL); }
+        | '{' CaseClausules_opt DefaultClausule CaseClausules_opt '}'
+                                 { $$ = new_case_block(ctx, $2, $3, $4); }
+
+/* ECMA-262 3rd Edition    12.11 */
+CaseClausules_opt
+        : /* empty */            { $$ = NULL; }
+        | CaseClausules          { $$ = $1; }
+
+/* ECMA-262 3rd Edition    12.11 */
+CaseClausules
+        : CaseClausule           { $$ = new_case_list(ctx, $1); }
+        | CaseClausules CaseClausule
+                                 { $$ = case_list_add(ctx, $1, $2); }
+
+/* ECMA-262 3rd Edition    12.11 */
+CaseClausule
+        : kCASE Expression ':' StatementList_opt
+                                 { $$ = new_case_clausule(ctx, $2, $4); }
+
+/* ECMA-262 3rd Edition    12.11 */
+DefaultClausule
+        : kDEFAULT ':' StatementList_opt
+                                 { $$ = new_case_clausule(ctx, NULL, $3); }
+
+/* ECMA-262 3rd Edition    12.13 */
+ThrowStatement
+        : kTHROW /* NONL */ Expression semicolon_opt
+                                { $$ = new_throw_statement(ctx, $2); }
+
+/* ECMA-262 3rd Edition    12.14 */
+TryStatement
+        : kTRY Block Catch      { $$ = new_try_statement(ctx, $2, $3, NULL); }
+        | kTRY Block Finally    { $$ = new_try_statement(ctx, $2, NULL, $3); }
+        | kTRY Block Catch Finally
+                                { $$ = new_try_statement(ctx, $2, $3, $4); }
+
+/* ECMA-262 3rd Edition    12.14 */
+Catch
+        : kCATCH left_bracket tIdentifier right_bracket Block
+                                { $$ = new_catch_block(ctx, $3, $5); }
+
+/* ECMA-262 3rd Edition    12.14 */
+Finally
+        : kFINALLY Block        { $$ = $2; }
+
+/* ECMA-262 3rd Edition    11.14 */
+Expression_opt
+        : /* empty */           { $$ = NULL; }
+        | Expression            { $$ = $1; }
+
+Expression_err
+        : Expression            { $$ = $1; }
+        | error                 { set_error(ctx, IDS_SYNTAX_ERROR); YYABORT; }
+
+/* ECMA-262 3rd Edition    11.14 */
+Expression
+        : AssignmentExpression  { $$ = $1; }
+        | Expression ',' AssignmentExpression
+                                { $$ = new_binary_expression(ctx, EXPR_COMMA, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.14 */
+ExpressionNoIn_opt
+        : /* empty */           { $$ = NULL; }
+        | ExpressionNoIn        { $$ = $1; }
+
+/* ECMA-262 3rd Edition    11.14 */
+ExpressionNoIn
+        : AssignmentExpressionNoIn
+                                { $$ = $1; }
+        | ExpressionNoIn ',' AssignmentExpressionNoIn
+                                { $$ = new_binary_expression(ctx, EXPR_COMMA, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.13 */
+AssignmentExpression
+        : ConditionalExpression { $$ = $1; }
+        | LeftHandSideExpression '=' AssignmentExpression
+                                { $$ = new_binary_expression(ctx, EXPR_ASSIGN, $1, $3);
}
+        | LeftHandSideExpression tAssignOper AssignmentExpression
+                                { $$ = new_binary_expression(ctx, $2, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.13 */
+AssignmentExpressionNoIn
+        : ConditionalExpressionNoIn
+                                { $$ = $1; }
+        | LeftHandSideExpression '=' AssignmentExpressionNoIn
+                                { $$ = new_binary_expression(ctx, EXPR_ASSIGN, $1, $3);
}
+        | LeftHandSideExpression tAssignOper AssignmentExpressionNoIn
+                                { $$ = new_binary_expression(ctx, $2, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.12 */
+ConditionalExpression
+        : LogicalORExpression   { $$ = $1; }
+        | LogicalORExpression '?' AssignmentExpression ':'
AssignmentExpression
+                                { $$ = new_conditional_expression(ctx, $1, $3, $5); }
+
+/* ECMA-262 3rd Edition    11.12 */
+ConditionalExpressionNoIn
+        : LogicalORExpressionNoIn
+                                { $$ = $1; }
+        | LogicalORExpressionNoIn '?' AssignmentExpressionNoIn ':'
AssignmentExpressionNoIn
+                                { $$ = new_conditional_expression(ctx, $1, $3, $5); }
+
+/* ECMA-262 3rd Edition    11.11 */
+LogicalORExpression
+        : LogicalANDExpression  { $$ = $1; }
+        | LogicalORExpression tOROR LogicalANDExpression
+                                { $$ = new_binary_expression(ctx, EXPR_OR, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.11 */
+LogicalORExpressionNoIn
+        : LogicalANDExpressionNoIn
+                                { $$ = $1; }
+        | LogicalORExpressionNoIn tOROR LogicalANDExpressionNoIn
+                                { $$ = new_binary_expression(ctx, EXPR_OR, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.11 */
+LogicalANDExpression
+        : BitwiseORExpression   { $$ = $1; }
+        | LogicalANDExpression tANDAND BitwiseORExpression
+                                { $$ = new_binary_expression(ctx, EXPR_AND, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.11 */
+LogicalANDExpressionNoIn
+        : BitwiseORExpressionNoIn
+                                { $$ = $1; }
+        | LogicalANDExpressionNoIn tANDAND BitwiseORExpressionNoIn
+                                { $$ = new_binary_expression(ctx, EXPR_AND, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.10 */
+BitwiseORExpression
+        : BitwiseXORExpression   { $$ = $1; }
+        | BitwiseORExpression '|' BitwiseXORExpression
+                                { $$ = new_binary_expression(ctx, EXPR_BOR, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.10 */
+BitwiseORExpressionNoIn
+        : BitwiseXORExpressionNoIn
+                                { $$ = $1; }
+        | BitwiseORExpressionNoIn '|' BitwiseXORExpressionNoIn
+                                { $$ = new_binary_expression(ctx, EXPR_BOR, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.10 */
+BitwiseXORExpression
+        : BitwiseANDExpression  { $$ = $1; }
+        | BitwiseXORExpression '^' BitwiseANDExpression
+                                { $$ = new_binary_expression(ctx, EXPR_BXOR, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.10 */
+BitwiseXORExpressionNoIn
+        : BitwiseANDExpressionNoIn
+                                { $$ = $1; }
+        | BitwiseXORExpressionNoIn '^' BitwiseANDExpressionNoIn
+                                { $$ = new_binary_expression(ctx, EXPR_BXOR, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.10 */
+BitwiseANDExpression
+        : EqualityExpression    { $$ = $1; }
+        | BitwiseANDExpression '&' EqualityExpression
+                                { $$ = new_binary_expression(ctx, EXPR_BAND, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.10 */
+BitwiseANDExpressionNoIn
+        : EqualityExpressionNoIn
+                                { $$ = $1; }
+        | BitwiseANDExpressionNoIn '&' EqualityExpressionNoIn
+                                { $$ = new_binary_expression(ctx, EXPR_BAND, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.9 */
+EqualityExpression
+        : RelationalExpression  { $$ = $1; }
+        | EqualityExpression tEqOper RelationalExpression
+                                { $$ = new_binary_expression(ctx, $2, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.9 */
+EqualityExpressionNoIn
+        : RelationalExpressionNoIn  { $$ = $1; }
+        | EqualityExpressionNoIn tEqOper RelationalExpressionNoIn
+                                { $$ = new_binary_expression(ctx, $2, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.8 */
+RelationalExpression
+        : ShiftExpression       { $$ = $1; }
+        | RelationalExpression tRelOper ShiftExpression
+                                { $$ = new_binary_expression(ctx, $2, $1, $3); }
+        | RelationalExpression kINSTANCEOF ShiftExpression
+                                { $$ = new_binary_expression(ctx, EXPR_INSTANCEOF, $1,
$3); }
+        | RelationalExpression kIN ShiftExpression
+                                { $$ = new_binary_expression(ctx, EXPR_IN, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.8 */
+RelationalExpressionNoIn
+        : ShiftExpression       { $$ = $1; }
+        | RelationalExpressionNoIn tRelOper ShiftExpression
+                                { $$ = new_binary_expression(ctx, $2, $1, $3); }
+        | RelationalExpressionNoIn kINSTANCEOF ShiftExpression
+                                { $$ = new_binary_expression(ctx, EXPR_INSTANCEOF, $1,
$3); }
+
+/* ECMA-262 3rd Edition    11.7 */
+ShiftExpression
+        : AdditiveExpression    { $$ = $1; }
+        | ShiftExpression tShiftOper AdditiveExpression
+                                { $$ = new_binary_expression(ctx, $2, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.6 */
+AdditiveExpression
+        : MultiplicativeExpression
+                                { $$ = $1; }
+        | AdditiveExpression '+' MultiplicativeExpression
+                                { $$ = new_binary_expression(ctx, EXPR_ADD, $1, $3); }
+        | AdditiveExpression '-' MultiplicativeExpression
+                                { $$ = new_binary_expression(ctx, EXPR_SUB, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.5 */
+MultiplicativeExpression
+        : UnaryExpression       { $$ = $1; }
+        | MultiplicativeExpression '*' UnaryExpression
+                                { $$ = new_binary_expression(ctx, EXPR_MUL, $1, $3); }
+        | MultiplicativeExpression '/' UnaryExpression
+                                { $$ = new_binary_expression(ctx, EXPR_DIV, $1, $3); }
+        | MultiplicativeExpression '%' UnaryExpression
+                                { $$ = new_binary_expression(ctx, EXPR_MOD, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.4 */
+UnaryExpression
+        : PostfixExpression     { $$ = $1; }
+        | kDELETE UnaryExpression
+                                { $$ = new_unary_expression(ctx, EXPR_DELETE, $2); }
+        | kVOID UnaryExpression { $$ = new_unary_expression(ctx, EXPR_VOID, $2); }
+        | kTYPEOF UnaryExpression
+                                { $$ = new_unary_expression(ctx, EXPR_TYPEOF, $2); }
+        | tINC UnaryExpression  { $$ = new_unary_expression(ctx, EXPR_PREINC, $2); }
+        | tDEC UnaryExpression  { $$ = new_unary_expression(ctx, EXPR_PREDEC, $2); }
+        | '+' UnaryExpression   { $$ = new_unary_expression(ctx, EXPR_PLUS, $2);
}
+        | '-' UnaryExpression   { $$ = new_unary_expression(ctx, EXPR_MINUS, $2);
}
+        | '~' UnaryExpression   { $$ = new_unary_expression(ctx, EXPR_BITNEG,
$2); }
+        | '!' UnaryExpression   { $$ = new_unary_expression(ctx, EXPR_LOGNEG,
$2); }
+
+/* ECMA-262 3rd Edition    11.2 */
+PostfixExpression
+        : LeftHandSideExpression
+                                { $$ = $1; }
+        | LeftHandSideExpression /* NONL */ tINC
+                                { $$ = new_unary_expression(ctx, EXPR_POSTINC, $1); }
+        | LeftHandSideExpression /* NONL */ tDEC
+                                { $$ = new_unary_expression(ctx, EXPR_POSTDEC, $1); }
+
+
+/* ECMA-262 3rd Edition    11.2 */
+LeftHandSideExpression
+        : NewExpression         { $$ = $1; }
+        | CallExpression        { $$ = $1; }
+
+/* ECMA-262 3rd Edition    11.2 */
+NewExpression
+        : MemberExpression      { $$ = $1; }
+        | kNEW NewExpression    { $$ = new_new_expression(ctx, $2, NULL); }
+
+/* ECMA-262 3rd Edition    11.2 */
+MemberExpression
+        : PrimaryExpression     { $$ = $1; }
+        | FunctionExpression    { $$ = $1; }
+        | MemberExpression '[' Expression ']'
+                                { $$ = new_array_expression(ctx, $1, $3); }
+        | MemberExpression '.' tIdentifier
+                                { $$ = new_member_expression(ctx, $1, $3); }
+        | kNEW MemberExpression Arguments
+                                { $$ = new_new_expression(ctx, $2, $3); }
+
+/* ECMA-262 3rd Edition    11.2 */
+CallExpression
+        : MemberExpression Arguments
+                                { $$ = new_call_expression(ctx, $1, $2); }
+        | CallExpression Arguments
+                                { $$ = new_call_expression(ctx, $1, $2); }
+        | CallExpression '[' Expression ']'
+                                { $$ = new_array_expression(ctx, $1, $3); }
+        | CallExpression '.' tIdentifier
+                                { $$ = new_member_expression(ctx, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.2 */
+Arguments
+        : '(' ')'               { $$ = NULL; }
+        | '(' ArgumentList ')'  { $$ = $2; }
+
+/* ECMA-262 3rd Edition    11.2 */
+ArgumentList
+        : AssignmentExpression  { $$ = new_argument_list(ctx, $1); }
+        | ArgumentList ',' AssignmentExpression
+                                { $$ = argument_list_add(ctx, $1, $3); }
+
+/* ECMA-262 3rd Edition    11.1 */
+PrimaryExpression
+        : kTHIS                 { $$ = new_this_expression(ctx); }
+        | tIdentifier           { $$ = new_identifier_expression(ctx, $1); }
+        | Literal               { $$ = new_literal_expression(ctx, $1); }
+        | ArrayLiteral          { $$ = $1; }
+        | ObjectLiteral         { $$ = $1; }
+        | '(' Expression ')'    { $$ = $2; }
+
+/* ECMA-262 3rd Edition    11.1.4 */
+ArrayLiteral
+        : '[' ']'               { $$ = new_array_literal_expression(ctx,
NULL, 0); }
+        | '[' Elision ']'       { $$ = new_array_literal_expression(ctx,
NULL, $2+1); }
+        | '[' ElementList ']'   { $$ = new_array_literal_expression(ctx,
$2, 0); }
+        | '[' ElementList ',' Elision_opt ']'
+                                { $$ = new_array_literal_expression(ctx, $2, $4+1); }
+
+/* ECMA-262 3rd Edition    11.1.4 */
+ElementList
+        : Elision_opt AssignmentExpression
+                                { $$ = new_element_list(ctx, $1, $2); }
+        | ElementList ',' Elision_opt AssignmentExpression
+                                { $$ = element_list_add(ctx, $1, $3, $4); }
+
+/* ECMA-262 3rd Edition    11.1.4 */
+Elision
+        : ','                   { $$ = 1; }
+        | Elision ','           { $$ = $1 + 1; }
+
+/* ECMA-262 3rd Edition    11.1.4 */
+Elision_opt
+        : /* empty */           { $$ = 0; }
+        | Elision               { $$ = $1; }
+
+/* ECMA-262 3rd Edition    11.1.5 */
+ObjectLiteral
+        : '{' '}'               { $$ = new_prop_and_value_expression(ctx,
NULL); }
+        | '{' PropertyNameAndValueList '}'
+                                { $$ = new_prop_and_value_expression(ctx, $2); }
+
+/* ECMA-262 3rd Edition    11.1.5 */
+PropertyNameAndValueList
+        : PropertyName ':' AssignmentExpression
+                                { $$ = new_property_list(ctx, $1, $3); }
+        | PropertyNameAndValueList ',' PropertyName ':'
AssignmentExpression
+                                { $$ = property_list_add(ctx, $1, $3, $5); }
+
+/* ECMA-262 3rd Edition    11.1.5 */
+PropertyName
+        : tIdentifier           { $$ = new_string_literal(ctx, $1); }
+        | tStringLiteral        { $$ = new_string_literal(ctx, $1); }
+        | tNumericLiteral       { $$ = $1; }
+
+/* ECMA-262 3rd Edition    7.6 */
+Identifier_opt
+        : /* empty*/            { $$ = NULL; }
+        | tIdentifier           { $$ = $1; }
+
+/* ECMA-262 3rd Edition    7.8 */
+Literal
+        : kNULL                 { $$ = new_null_literal(ctx); }
+        | kUNDEFINED            { $$ = new_undefined_literal(ctx); }
+        | BooleanLiteral        { $$ = $1; }
+        | tNumericLiteral       { $$ = $1; }
+        | tStringLiteral        { $$ = new_string_literal(ctx, $1); }
+        | '/'                   { $$ = parse_regexp(ctx);
+                                  if(!$$) YYABORT; }
+
+/* ECMA-262 3rd Edition    7.8.2 */
+BooleanLiteral
+        : kTRUE                 { $$ = new_boolean_literal(ctx, TRUE); }
+        | kFALSE                { $$ = new_boolean_literal(ctx, FALSE); }
+
+semicolon_opt
+        : ';'
+        | error                 { if(!allow_auto_semicolon(ctx)) {YYABORT;} }
+
+left_bracket
+        : '('
+        | error                 { set_error(ctx, IDS_LBRACKET); YYABORT; }
+
+right_bracket
+        : ')'
+        | error                 { set_error(ctx, IDS_RBRACKET); YYABORT; }
+
+semicolon
+        : ';'
+        | error                 { set_error(ctx, IDS_SEMICOLON); YYABORT; }
+
+%%
+
+static BOOL allow_auto_semicolon(parser_ctx_t *ctx)
+{
+    return ctx->nl || ctx->ptr == ctx->end || *(ctx->ptr-1) == '}';
+}
+
+static literal_t *new_string_literal(parser_ctx_t *ctx, const WCHAR *str)
+{
+    literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
+
+    ret->vt = VT_BSTR;
+    ret->u.wstr = str;
+
+    return ret;
+}
+
+static literal_t *new_null_literal(parser_ctx_t *ctx)
+{
+    literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
+
+    ret->vt = VT_NULL;
+
+    return ret;
+}
+
+static literal_t *new_undefined_literal(parser_ctx_t *ctx)
+{
+    literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
+
+    ret->vt = VT_EMPTY;
+
+    return ret;
+}
+
+static literal_t *new_boolean_literal(parser_ctx_t *ctx, VARIANT_BOOL bval)
+{
+    literal_t *ret = parser_alloc(ctx, sizeof(literal_t));
+
+    ret->vt = VT_BOOL;
+    ret->u.bval = bval;
+
+    return ret;
+}
+
+static prop_val_t *new_prop_val(parser_ctx_t *ctx, literal_t *name, expression_t *value)
+{
+    prop_val_t *ret = parser_alloc(ctx, sizeof(prop_val_t));
+
+    ret->name = name;
+    ret->value = value;
+    ret->next = NULL;
+
+    return ret;
+}
+
+static property_list_t *new_property_list(parser_ctx_t *ctx, literal_t *name,
expression_t *value)
+{
+    property_list_t *ret = parser_alloc_tmp(ctx, sizeof(property_list_t));
+
+    ret->head = ret->tail = new_prop_val(ctx, name, value);
+
+    return ret;
+}
+
+static property_list_t *property_list_add(parser_ctx_t *ctx, property_list_t *list,
literal_t *name, expression_t *value)
+{
+    list->tail = list->tail->next = new_prop_val(ctx, name, value);
+
+    return list;
+}
+
+static array_element_t *new_array_element(parser_ctx_t *ctx, int elision, expression_t
*expr)
+{
+    array_element_t *ret = parser_alloc(ctx, sizeof(array_element_t));
+
+    ret->elision = elision;
+    ret->expr = expr;
+    ret->next = NULL;
+
+    return ret;
+}
+
+static element_list_t *new_element_list(parser_ctx_t *ctx, int elision, expression_t
*expr)
+{
+    element_list_t *ret = parser_alloc_tmp(ctx, sizeof(element_list_t));
+
+    ret->head = ret->tail = new_array_element(ctx, elision, expr);
+
+    return ret;
+}
+
+static element_list_t *element_list_add(parser_ctx_t *ctx, element_list_t *list, int
elision, expression_t *expr)
+{
+    list->tail = list->tail->next = new_array_element(ctx, elision, expr);
+
+    return list;
+}
+
+static argument_t *new_argument(parser_ctx_t *ctx, expression_t *expr)
+{
+    argument_t *ret = parser_alloc(ctx, sizeof(argument_t));
+
+    ret->expr = expr;
+    ret->next = NULL;
+
+    return ret;
+}
+
+static argument_list_t *new_argument_list(parser_ctx_t *ctx, expression_t *expr)
+{
+    argument_list_t *ret = parser_alloc_tmp(ctx, sizeof(argument_list_t));
+
+    ret->head = ret->tail = new_argument(ctx, expr);
+
+    return ret;
+}
+
+static argument_list_t *argument_list_add(parser_ctx_t *ctx, argument_list_t *list,
expression_t *expr)
+{
+    list->tail = list->tail->next = new_argument(ctx, expr);
+
+    return list;
+}
+
+static catch_block_t *new_catch_block(parser_ctx_t *ctx, const WCHAR *identifier,
statement_t *statement)
+{
+    catch_block_t *ret = parser_alloc(ctx, sizeof(catch_block_t));
+
+    ret->identifier = identifier;
+    ret->statement = statement;
+
+    return ret;
+}
+
+static case_clausule_t *new_case_clausule(parser_ctx_t *ctx, expression_t *expr,
statement_list_t *stat_list)
+{
+    case_clausule_t *ret = parser_alloc(ctx, sizeof(case_clausule_t));
+
+    ret->expr = expr;
+    ret->stat = stat_list ? stat_list->head : NULL;
+    ret->next = NULL;
+
+    return ret;
+}
+
+static case_list_t *new_case_list(parser_ctx_t *ctx, case_clausule_t *case_clausule)
+{
+    case_list_t *ret = parser_alloc_tmp(ctx, sizeof(case_list_t));
+
+    ret->head = ret->tail = case_clausule;
+
+    return ret;
+}
+
+static case_list_t *case_list_add(parser_ctx_t *ctx, case_list_t *list, case_clausule_t
*case_clausule)
+{
+    list->tail = list->tail->next = case_clausule;
+
+    return list;
+}
+
+static case_clausule_t *new_case_block(parser_ctx_t *ctx, case_list_t *case_list1,
+        case_clausule_t *default_clausule, case_list_t *case_list2)
+{
+    case_clausule_t *ret = NULL, *iter = NULL, *iter2;
+    statement_t *stat = NULL;
+
+    if(case_list1) {
+        ret = case_list1->head;
+        iter = case_list1->tail;
+    }
+
+    if(default_clausule) {
+        if(ret)
+            iter = iter->next = default_clausule;
+        else
+            ret = iter = default_clausule;
+    }
+
+    if(case_list2) {
+        if(ret)
+            iter->next = case_list2->head;
+        else
+            ret = case_list2->head;
+    }
+
+    if(!ret)
+        return NULL;
+
+    for(iter = ret; iter; iter = iter->next) {
+        for(iter2 = iter; iter2 && !iter2->stat; iter2 = iter2->next);
+        if(!iter2)
+            break;
+
+        while(iter != iter2) {
+            iter->stat = iter2->stat;
+            iter = iter->next;
+        }
+
+        if(stat) {
+            while(stat->next)
+                stat = stat->next;
+            stat->next = iter->stat;
+        }else {
+            stat = iter->stat;
+        }
+    }
+
+    return ret;
+}
+
+static statement_t *new_block_statement(parser_ctx_t *ctx, statement_list_t *list)
+{
+    block_statement_t *ret = parser_alloc(ctx, sizeof(block_statement_t));
+
+    ret->stat.eval = block_statement_eval;
+    ret->stat.next = NULL;
+    ret->stat_list = list ? list->head : NULL;
+
+    return &ret->stat;
+}
+
+static variable_declaration_t *new_variable_declaration(parser_ctx_t *ctx, const WCHAR
*identifier, expression_t *expr)
+{
+    variable_declaration_t *ret = parser_alloc(ctx, sizeof(variable_declaration_t));
+    var_list_t *var_list = parser_alloc(ctx, sizeof(var_list_t));
+
+    ret->identifier = identifier;
+    ret->expr = expr;
+    ret->next = NULL;
+
+    var_list->identifier = identifier;
+    var_list->next = NULL;
+
+    if(ctx->func_stack->var_tail)
+        ctx->func_stack->var_tail = ctx->func_stack->var_tail->next =
var_list;
+    else
+        ctx->func_stack->var_head = ctx->func_stack->var_tail = var_list;
+
+    return ret;
+}
+
+static variable_list_t *new_variable_list(parser_ctx_t *ctx, variable_declaration_t
*decl)
+{
+    variable_list_t *ret = parser_alloc_tmp(ctx, sizeof(variable_list_t));
+
+    ret->head = ret->tail = decl;
+
+    return ret;
+}
+
+static variable_list_t *variable_list_add(parser_ctx_t *ctx, variable_list_t *list,
variable_declaration_t *decl)
+{
+    list->tail = list->tail->next = decl;
+
+    return list;
+}
+
+static statement_t *new_var_statement(parser_ctx_t *ctx, variable_list_t *variable_list)
+{
+    var_statement_t *ret = parser_alloc(ctx, sizeof(var_statement_t));
+
+    ret->stat.eval = var_statement_eval;
+    ret->stat.next = NULL;
+    ret->variable_list = variable_list->head;
+
+    return &ret->stat;
+}
+
+static statement_t *new_empty_statement(parser_ctx_t *ctx)
+{
+    statement_t *ret = parser_alloc(ctx, sizeof(statement_t));
+
+    ret->eval = empty_statement_eval;
+    ret->next = NULL;
+
+    return ret;
+}
+
+static statement_t *new_expression_statement(parser_ctx_t *ctx, expression_t *expr)
+{
+    expression_statement_t *ret = parser_alloc(ctx, sizeof(expression_statement_t));
+
+    ret->stat.eval = expression_statement_eval;
+    ret->stat.next = NULL;
+    ret->expr = expr;
+
+    return &ret->stat;
+}
+
+static statement_t *new_if_statement(parser_ctx_t *ctx, expression_t *expr, statement_t
*if_stat, statement_t *else_stat)
+{
+    if_statement_t *ret = parser_alloc(ctx, sizeof(if_statement_t));
+
+    ret->stat.eval = if_statement_eval;
+    ret->stat.next = NULL;
+    ret->expr = expr;
+    ret->if_stat = if_stat;
+    ret->else_stat = else_stat;
+
+    return &ret->stat;
+}
+
+static statement_t *new_while_statement(parser_ctx_t *ctx, BOOL dowhile, expression_t
*expr, statement_t *stat)
+{
+    while_statement_t *ret = parser_alloc(ctx, sizeof(while_statement_t));
+
+    ret->stat.eval = while_statement_eval;
+    ret->stat.next = NULL;
+    ret->do_while = dowhile;
+    ret->expr = expr;
+    ret->statement = stat;
+
+    return &ret->stat;
+}
+
+static statement_t *new_for_statement(parser_ctx_t *ctx, variable_list_t *variable_list,
expression_t *begin_expr,
+        expression_t *expr, expression_t *end_expr, statement_t *statement)
+{
+    for_statement_t *ret = parser_alloc(ctx, sizeof(for_statement_t));
+
+    ret->stat.eval = for_statement_eval;
+    ret->stat.next = NULL;
+    ret->variable_list = variable_list ? variable_list->head : NULL;
+    ret->begin_expr = begin_expr;
+    ret->expr = expr;
+    ret->end_expr = end_expr;
+    ret->statement = statement;
+
+    return &ret->stat;
+}
+
+static statement_t *new_forin_statement(parser_ctx_t *ctx, variable_declaration_t
*variable, expression_t *expr,
+        expression_t *in_expr, statement_t *statement)
+{
+    forin_statement_t *ret = parser_alloc(ctx, sizeof(forin_statement_t));
+
+    ret->stat.eval = forin_statement_eval;
+    ret->stat.next = NULL;
+    ret->variable = variable;
+    ret->expr = expr;
+    ret->in_expr = in_expr;
+    ret->statement = statement;
+
+    return &ret->stat;
+}
+
+static statement_t *new_continue_statement(parser_ctx_t *ctx, const WCHAR *identifier)
+{
+    branch_statement_t *ret = parser_alloc(ctx, sizeof(branch_statement_t));
+
+    ret->stat.eval = continue_statement_eval;
+    ret->stat.next = NULL;
+    ret->identifier = identifier;
+
+    return &ret->stat;
+}
+
+static statement_t *new_break_statement(parser_ctx_t *ctx, const WCHAR *identifier)
+{
+    branch_statement_t *ret = parser_alloc(ctx, sizeof(branch_statement_t));
+
+    ret->stat.eval = break_statement_eval;
+    ret->stat.next = NULL;
+    ret->identifier = identifier;
+
+    return &ret->stat;
+}
+
+static statement_t *new_return_statement(parser_ctx_t *ctx, expression_t *expr)
+{
+    expression_statement_t *ret = parser_alloc(ctx, sizeof(expression_statement_t));
+
+    ret->stat.eval = return_statement_eval;
+    ret->stat.next = NULL;
+    ret->expr = expr;
+
+    return &ret->stat;
+}
+
+static statement_t *new_with_statement(parser_ctx_t *ctx, expression_t *expr, statement_t
*statement)
+{
+    with_statement_t *ret = parser_alloc(ctx, sizeof(with_statement_t));
+
+    ret->stat.eval = with_statement_eval;
+    ret->stat.next = NULL;
+    ret->expr = expr;
+    ret->statement = statement;
+
+    return &ret->stat;
+}
+
+static statement_t *new_labelled_statement(parser_ctx_t *ctx, const WCHAR *identifier,
statement_t *statement)
+{
+    labelled_statement_t *ret = parser_alloc(ctx, sizeof(labelled_statement_t));
+
+    ret->stat.eval = labelled_statement_eval;
+    ret->stat.next = NULL;
+    ret->identifier = identifier;
+    ret->statement = statement;
+
+    return &ret->stat;
+}
+
+static statement_t *new_switch_statement(parser_ctx_t *ctx, expression_t *expr,
case_clausule_t *case_list)
+{
+    switch_statement_t *ret = parser_alloc(ctx, sizeof(switch_statement_t));
+
+    ret->stat.eval = switch_statement_eval;
+    ret->stat.next = NULL;
+    ret->expr = expr;
+    ret->case_list = case_list;
+
+    return &ret->stat;
+}
+
+static statement_t *new_throw_statement(parser_ctx_t *ctx, expression_t *expr)
+{
+    expression_statement_t *ret = parser_alloc(ctx, sizeof(expression_statement_t));
+
+    ret->stat.eval = throw_statement_eval;
+    ret->stat.next = NULL;
+    ret->expr = expr;
+
+    return &ret->stat;
+}
+
+static statement_t *new_try_statement(parser_ctx_t *ctx, statement_t *try_statement,
+       catch_block_t *catch_block, statement_t *finally_statement)
+{
+    try_statement_t *ret = parser_alloc(ctx, sizeof(try_statement_t));
+
+    ret->stat.eval = try_statement_eval;
+    ret->stat.next = NULL;
+    ret->try_statement = try_statement;
+    ret->catch_block = catch_block;
+    ret->finally_statement = finally_statement;
+
+    return &ret->stat;
+}
+
+static parameter_t *new_parameter(parser_ctx_t *ctx, const WCHAR *identifier)
+{
+    parameter_t *ret = parser_alloc(ctx, sizeof(parameter_t));
+
+    ret->identifier = identifier;
+    ret->next = NULL;
+
+    return ret;
+}
+
+static parameter_list_t *new_parameter_list(parser_ctx_t *ctx, const WCHAR *identifier)
+{
+    parameter_list_t *ret = parser_alloc_tmp(ctx, sizeof(parameter_list_t));
+
+    ret->head = ret->tail = new_parameter(ctx, identifier);
+
+    return ret;
+}
+
+static parameter_list_t *parameter_list_add(parser_ctx_t *ctx, parameter_list_t *list,
const WCHAR *identifier)
+{
+    list->tail = list->tail->next = new_parameter(ctx, identifier);
+
+    return list;
+}
+
+static expression_t *new_function_expression(parser_ctx_t *ctx, const WCHAR *identifier,
+       parameter_list_t *parameter_list, source_elements_t *source_elements, const WCHAR
*src_str, DWORD src_len)
+{
+    function_expression_t *ret = parser_alloc(ctx, sizeof(function_expression_t));
+
+    ret->expr.eval = function_expression_eval;
+    ret->identifier = identifier;
+    ret->parameter_list = parameter_list ? parameter_list->head : NULL;
+    ret->source_elements = source_elements;
+    ret->src_str = src_str;
+    ret->src_len = src_len;
+
+    if(ret->identifier) {
+        function_declaration_t *decl = parser_alloc(ctx,
sizeof(function_declaration_t));
+
+        decl->expr = ret;
+        decl->next = NULL;
+
+        if(ctx->func_stack->func_tail)
+            ctx->func_stack->func_tail = ctx->func_stack->func_tail->next
= decl;
+        else
+            ctx->func_stack->func_head = ctx->func_stack->func_tail = decl;
+    }
+
+    return &ret->expr;
+}
+
+static const expression_eval_t expression_eval_table[] = {
+   comma_expression_eval,
+   logical_or_expression_eval,
+   logical_and_expression_eval,
+   binary_or_expression_eval,
+   binary_xor_expression_eval,
+   binary_and_expression_eval,
+   instanceof_expression_eval,
+   in_expression_eval,
+   add_expression_eval,
+   sub_expression_eval,
+   mul_expression_eval,
+   div_expression_eval,
+   mod_expression_eval,
+   delete_expression_eval,
+   void_expression_eval,
+   typeof_expression_eval,
+   minus_expression_eval,
+   plus_expression_eval,
+   post_increment_expression_eval,
+   post_decrement_expression_eval,
+   pre_increment_expression_eval,
+   pre_decrement_expression_eval,
+   equal_expression_eval,
+   equal2_expression_eval,
+   not_equal_expression_eval,
+   not_equal2_expression_eval,
+   less_expression_eval,
+   lesseq_expression_eval,
+   greater_expression_eval,
+   greatereq_expression_eval,
+   binary_negation_expression_eval,
+   logical_negation_expression_eval,
+   left_shift_expression_eval,
+   right_shift_expression_eval,
+   right2_shift_expression_eval,
+   assign_expression_eval,
+   assign_lshift_expression_eval,
+   assign_rshift_expression_eval,
+   assign_rrshift_expression_eval,
+   assign_add_expression_eval,
+   assign_sub_expression_eval,
+   assign_mul_expression_eval,
+   assign_div_expression_eval,
+   assign_mod_expression_eval,
+   assign_and_expression_eval,
+   assign_or_expression_eval,
+   assign_xor_expression_eval,
+};
+
+static expression_t *new_binary_expression(parser_ctx_t *ctx, expression_type_t type,
+       expression_t *expression1, expression_t *expression2)
+{
+    binary_expression_t *ret = parser_alloc(ctx, sizeof(binary_expression_t));
+
+    ret->expr.eval = expression_eval_table[type];
+    ret->expression1 = expression1;
+    ret->expression2 = expression2;
+
+    return &ret->expr;
+}
+
+static expression_t *new_unary_expression(parser_ctx_t *ctx, expression_type_t type,
expression_t *expression)
+{
+    unary_expression_t *ret = parser_alloc(ctx, sizeof(unary_expression_t));
+
+    ret->expr.eval = expression_eval_table[type];
+    ret->expression = expression;
+
+    return &ret->expr;
+}
+
+static expression_t *new_conditional_expression(parser_ctx_t *ctx, expression_t
*expression,
+       expression_t *true_expression, expression_t *false_expression)
+{
+    conditional_expression_t *ret = parser_alloc(ctx, sizeof(conditional_expression_t));
+
+    ret->expr.eval = conditional_expression_eval;
+    ret->expression = expression;
+    ret->true_expression = true_expression;
+    ret->false_expression = false_expression;
+
+    return &ret->expr;
+}
+
+static expression_t *new_array_expression(parser_ctx_t *ctx, expression_t *member_expr,
expression_t *expression)
+{
+    array_expression_t *ret = parser_alloc(ctx, sizeof(array_expression_t));
+
+    ret->expr.eval = array_expression_eval;
+    ret->member_expr = member_expr;
+    ret->expression = expression;
+
+    return &ret->expr;
+}
+
+static expression_t *new_member_expression(parser_ctx_t *ctx, expression_t *expression,
const WCHAR *identifier)
+{
+    member_expression_t *ret = parser_alloc(ctx, sizeof(member_expression_t));
+
+    ret->expr.eval = member_expression_eval;
+    ret->expression = expression;
+    ret->identifier = identifier;
+
+    return &ret->expr;
+}
+
+static expression_t *new_new_expression(parser_ctx_t *ctx, expression_t *expression,
argument_list_t *argument_list)
+{
+    call_expression_t *ret = parser_alloc(ctx, sizeof(call_expression_t));
+
+    ret->expr.eval = new_expression_eval;
+    ret->expression = expression;
+    ret->argument_list = argument_list ? argument_list->head : NULL;
+
+    return &ret->expr;
+}
+
+static expression_t *new_call_expression(parser_ctx_t *ctx, expression_t *expression,
argument_list_t *argument_list)
+{
+    call_expression_t *ret = parser_alloc(ctx, sizeof(call_expression_t));
+
+    ret->expr.eval = call_expression_eval;
+    ret->expression = expression;
+    ret->argument_list = argument_list ? argument_list->head : NULL;
+
+    return &ret->expr;
+}
+
+static expression_t *new_this_expression(parser_ctx_t *ctx)
+{
+    expression_t *ret = parser_alloc(ctx, sizeof(expression_t));
+
+    ret->eval = this_expression_eval;
+
+    return ret;
+}
+
+static int parser_error(const char *str)
+{
+    return 0;
+}
+
+static void set_error(parser_ctx_t *ctx, UINT error)
+{
+    ctx->hres = JSCRIPT_ERROR|error;
+}
+
+static BOOL explicit_error(parser_ctx_t *ctx, void *obj, WCHAR next)
+{
+    if(obj || *(ctx->ptr-1)==next) return TRUE;
+
+    set_error(ctx, IDS_SYNTAX_ERROR);
+    return FALSE;
+}
+
+
+static expression_t *new_identifier_expression(parser_ctx_t *ctx, const WCHAR
*identifier)
+{
+    identifier_expression_t *ret = parser_alloc(ctx, sizeof(identifier_expression_t));
+
+    ret->expr.eval = identifier_expression_eval;
+    ret->identifier = identifier;
+
+    return &ret->expr;
+}
+
+static expression_t *new_array_literal_expression(parser_ctx_t *ctx, element_list_t
*element_list, int length)
+{
+    array_literal_expression_t *ret = parser_alloc(ctx,
sizeof(array_literal_expression_t));
+
+    ret->expr.eval = array_literal_expression_eval;
+    ret->element_list = element_list ? element_list->head : NULL;
+    ret->length = length;
+
+    return &ret->expr;
+}
+
+static expression_t *new_prop_and_value_expression(parser_ctx_t *ctx, property_list_t
*property_list)
+{
+    property_value_expression_t *ret = parser_alloc(ctx,
sizeof(property_value_expression_t));
+
+    ret->expr.eval = property_value_expression_eval;
+    ret->property_list = property_list ? property_list->head : NULL;
+
+    return &ret->expr;
+}
+
+static expression_t *new_literal_expression(parser_ctx_t *ctx, literal_t *literal)
+{
+    literal_expression_t *ret = parser_alloc(ctx, sizeof(literal_expression_t));
+
+    ret->expr.eval = literal_expression_eval;
+    ret->literal = literal;
+
+    return &ret->expr;
+}
+
+static source_elements_t *new_source_elements(parser_ctx_t *ctx)
+{
+    source_elements_t *ret = parser_alloc(ctx, sizeof(source_elements_t));
+
+    memset(ret, 0, sizeof(*ret));
+
+    return ret;
+}
+
+static source_elements_t *source_elements_add_statement(source_elements_t
*source_elements, statement_t *statement)
+{
+    if(source_elements->statement_tail)
+        source_elements->statement_tail = source_elements->statement_tail->next
= statement;
+    else
+        source_elements->statement = source_elements->statement_tail = statement;
+
+    return source_elements;
+}
+
+static statement_list_t *new_statement_list(parser_ctx_t *ctx, statement_t *statement)
+{
+    statement_list_t *ret =  parser_alloc_tmp(ctx, sizeof(statement_list_t));
+
+    ret->head = ret->tail = statement;
+
+    return ret;
+}
+
+static statement_list_t *statement_list_add(statement_list_t *list, statement_t
*statement)
+{
+    list->tail = list->tail->next = statement;
+
+    return list;
+}
+
+static void push_func(parser_ctx_t *ctx)
+{
+    func_stack_t *new_func = parser_alloc_tmp(ctx, sizeof(func_stack_t));
+
+    new_func->func_head = new_func->func_tail = NULL;
+    new_func->var_head = new_func->var_tail = NULL;
+
+    new_func->next = ctx->func_stack;
+    ctx->func_stack = new_func;
+}
+
+static source_elements_t *function_body_parsed(parser_ctx_t *ctx, source_elements_t
*source)
+{
+    source->functions = ctx->func_stack->func_head;
+    source->variables = ctx->func_stack->var_head;
+    pop_func(ctx);
+
+    return source;
+}
+
+static void program_parsed(parser_ctx_t *ctx, source_elements_t *source)
+{
+    source->functions = ctx->func_stack->func_head;
+    source->variables = ctx->func_stack->var_head;
+    pop_func(ctx);
+
+    ctx->source = source;
+    if(!ctx->lexer_error)
+        ctx->hres = S_OK;
+}
+
+void parser_release(parser_ctx_t *ctx)
+{
+    obj_literal_t *iter;
+
+    if(--ctx->ref)
+        return;
+
+    for(iter = ctx->obj_literals; iter; iter = iter->next)
+        jsdisp_release(iter->obj);
+
+    jsheap_free(&ctx->heap);
+    heap_free(ctx);
+}
+
+HRESULT script_parse(script_ctx_t *ctx, const WCHAR *code, const WCHAR *delimiter,
+        parser_ctx_t **ret)
+{
+    parser_ctx_t *parser_ctx;
+    jsheap_t *mark;
+    HRESULT hres;
+
+    const WCHAR html_tagW[] =
{'<','/','s','c','r','i','p','t','>',0};
+
+    parser_ctx = heap_alloc_zero(sizeof(parser_ctx_t));
+    if(!parser_ctx)
+        return E_OUTOFMEMORY;
+
+    parser_ctx->ref = 1;
+    parser_ctx->hres = JSCRIPT_ERROR|IDS_SYNTAX_ERROR;
+    parser_ctx->is_html = delimiter && !strcmpiW(delimiter, html_tagW);
+
+    parser_ctx->begin = parser_ctx->ptr = code;
+    parser_ctx->end = code + strlenW(code);
+
+    script_addref(ctx);
+    parser_ctx->script = ctx;
+
+    mark = jsheap_mark(&ctx->tmp_heap);
+    jsheap_init(&parser_ctx->heap);
+
+    push_func(parser_ctx);
+
+    parser_parse(parser_ctx);
+    jsheap_clear(mark);
+    if(FAILED(parser_ctx->hres)) {
+        hres = parser_ctx->hres;
+        parser_release(parser_ctx);
+        return hres;
+    }
+
+    *ret = parser_ctx;
+    return S_OK;
+}

Propchange: trunk/tools/RosBE/RosBE-Windows/regtest/parser.y
------------------------------------------------------------------------------
    svn:eol-style = native

Added: trunk/tools/RosBE/RosBE-Windows/regtest/regtest.cmd
URL:
http://svn.reactos.org/svn/reactos/trunk/tools/RosBE/RosBE-Windows/regtest/…
==============================================================================
--- trunk/tools/RosBE/RosBE-Windows/regtest/regtest.cmd (added)
+++ trunk/tools/RosBE/RosBE-Windows/regtest/regtest.cmd [iso-8859-1] Sun Oct 18 20:40:13
2009
@@ -1,0 +1,32 @@
+@echo off
+setlocal enabledelayedexpansion 
+
+echo RosBE Regression Test
+echo.
+
+set /p "dummyvar=Checking for Bison......" < NUL
+bison 2> NUL
+
+if %ERRORLEVEL% == 1 (
+  start /min bison parser.y -p parser_ -d -o parser.tab.c
+  choice /C:AB /T 3 /D A > NUL
+  taskkill /f /im "bison.exe" > NUL
+  if !ERRORLEVEL! == 0 (
+      echo [broken]
+  ) else (
+      echo [ok]
+  )
+) else (
+    echo [missing]
+)
+
+set /p "dummyvar=Checking for Flex......." <nul 
+flex -oparser.yy.c -Pparser_ parser.l
+if %ERRORLEVEL% == 0 (
+    echo [ok]
+) else (
+    echo [missing]
+)
+del parser.yy.c 2> NUL
+del parser.tab.c 2> NUL
+del parser.tab.h 2> NUL

Propchange: trunk/tools/RosBE/RosBE-Windows/regtest/regtest.cmd
------------------------------------------------------------------------------
    svn:eol-style = native