18 Oct
2009
18 Oct
'09
6:40 p.m.
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
5560
days inactive
5560
days old
0 comments
1 participants
participants (1)
-
cwittich＠svn.reactos.org