/*
 * Copyright (C) 2000 Sony Corporation
 * See license.txt for License Agreement
 *
 _______________________________________________________________________
 |
 |
 |   Description:
 |	This file contains the bison rules for the Blendo Parser
 |
 |   Author(s)		: Chris Marrin
 |
 _______________________________________________________________________
 */

%{
#include <stdlib.h>
#include <string.h>

#define alloca malloc

#include "BbAtom.h"
#include "BbStack.h"
#include "BpRawDefNode.h"
#include "BpRawUseNode.h"
#include "BpRawField.h"
#include "BpRawBlendoProto.h"
#include "BpRawExternProto.h"  
#include "BpRawScript.h"

#include "BpParseHandler.h"

#ifdef BISON_DEBUG
#define YYDEBUG 1
#endif

#define YYERROR_VERBOSE
#define YYPARSE_PARAM  ph
#define YYLEX_PARAM    ph

#define PH ((BpParseHandler *) ph)
#define SC (PH->getCurrentScript())
#define yyerror(msg) PH->error(msg)

int
yylex(void *lvalp, void *ph)
{
    return PH->scan((YYSTYPE *) lvalp);
}

#if 0
%}

%union {
    char*					string;
    BpRawNode*				node;
    BpRawProto*				proto;
    double					num;
    BbRawAtom				atom;
    BpTreeStmt*				stmt;
    BpTreeExpr*				expr;
    BpTreeArg*				arg;
    BpTreeArrayElt*			elt;
    BpTreeObjectProp*		prop;
    BpTreeLeaf*				leaf;
    BpTreeBinaryOp::Type    assignType;
    BpRawScript*			script;
    int						fieldAttr;
    int						keyword;
	int32_t					int32;
};

%{
#endif
%}

%type <atom> IDENTIFIER BLENDOS_VERSION
%type <string> STRING
%type <node> node nodeDeclaration exportNodeDeclaration nodeDefinition
%type <int32> nodeExposeDeclaration
%type <node> anonymousProtoDeclaration anonymousProto
%type <proto> protoDefinition namedProto domProto
%type <num> NUMBER
%type <num> unsignedNumber signedNumber
%type <expr> primaryExpression memberExpression newExpression callExpression arguments
%type <expr> leftHandSideExpression postfixExpression unaryExpression
%type <expr> multiplicativeExpression additiveExpression shiftExpression
%type <expr> relationalExpression equalityExpression bitwiseANDExpression
%type <expr> relationalExpressionNoIn equalityExpressionNoIn bitwiseANDExpressionNoIn
%type <expr> bitwiseXORExpression bitwiseORExpression logicalANDExpression logicalORExpression
%type <expr> bitwiseXORExpressionNoIn bitwiseORExpressionNoIn
%type <expr> logicalANDExpressionNoIn logicalORExpressionNoIn
%type <expr> conditionalExpression assignmentExpression expression expressionOpt initializer
%type <expr> conditionalExpressionNoIn assignmentExpressionNoIn
%type <expr> expressionNoIn expressionNoInOpt initializerNoIn
%type <arg>  argumentList
%type <elt>  elisionOpt elision elementList arrayLiteral
%type <prop> objectLiteral propertyNameAndValueList
%type <leaf> propertyName
%type <assignType> assignmentOperator
%type <stmt> sourceElements sourceElement
%type <stmt> expressionStatement triggeredStatement statement statementList 
%type <stmt> labelledStatement statementListOpt switchStatement
%type <stmt> block emptyStatement functionDeclaration
%type <stmt> variableStatement ifStatement iterationStatement continueStatement
%type <stmt> breakStatement returnStatement withStatement
%type <stmt> variableDeclarationList variableDeclaration
%type <stmt> variableDeclarationListNoIn variableDeclarationNoIn
%type <expr> variableDeclarationForIn
%type <script> script functionDefinition ecmascriptProgram ecmascriptExpression
%type <fieldAttr> fieldAttribute
%type <keyword> K_DEF K_USE K_PROTO K_DOMPROTO K_EXTERNPROTO K_TO K_FROM K_ROUTE
%type <keyword> K_FIELD K_EVENTIN K_EVENTOUT K_IS K_FUNCTION
%type <keyword> K_DO K_EXPOSE K_AS K_SHARED K_PRIVATE
%type <keyword> K_TRUE K_FALSE K_NULL K_SCRIPT
%type <keyword> K_RETURN K_IF K_ELSE K_FOR K_IN K_BREAK K_CONTINUE K_WHILE 
%type <keyword> K_NEW K_THIS K_DELETE K_VOID K_TYPEOF K_VAR K_WITH

%token JS JSEXPR BLENDOS BLENDO LITNUM BLOCK_START FUNCTION_START XML
%token BLENDOS_VRML BLENDOS_BLENDO BLENDOS_VERSION BLENDOS_ENCODING_UTF8
%token IDENTIFIER STRING NUMBER
%token K_DEF K_USE K_PROTO K_DOMPROTO K_EXTERNPROTO K_TO K_FROM K_ROUTE
%token K_FIELD K_EVENTIN K_EVENTOUT K_IS K_FUNCTION
%token K_DO K_EXPOSE K_AS K_SHARED K_PRIVATE 
%token K_TRUE K_FALSE K_NULL K_SCRIPT
%token K_RETURN K_IF K_ELSE K_FOR K_IN K_BREAK K_CONTINUE K_WHILE K_ECMADO
%token O_PLUSEQ O_MINUSEQ O_MULTIPLYEQ O_DIVIDEEQ K_SWITCH K_CASE K_DEFAULT
%token O_MODEQ O_ANDEQ O_OREQ O_XOREQ O_LSHIFTEQ
%token O_RSHIFTEQ O_RSHIFTFILLEQ O_INCREMENT O_DECREMENT 
%token O_EQ O_NE O_LE O_GE O_AND O_OR
%token O_LSHIFT O_RSHIFT O_RSHIFTFILL 
%token K_NEW K_THIS K_DELETE K_VOID K_TYPEOF K_VAR K_WITH

/*  we expect if..then..else to produce a shift/reduce conflict
*/
%expect 1

%pure_parser

%%

program:
	JS				{ PH->lookahead(); }
	ecmascriptProgram		{ PH->getRoot()->setTopLevelScript($3); }
    |	JSEXPR ecmascriptExpression	{ PH->getRoot()->setTopLevelScript($2); }
    |	BLENDOS vrmlStart		{ PH->setToken(BLENDO); }
	BLENDO blendoScene
    |	BLENDO blendoScene
    |	LITNUM unsignedNumber		{ PH->setLitNumber($2); }
    ;

vrmlStart:
	BLENDOS_VRML BLENDOS_VERSION	{
					    PH->setVRMLFormat(true);

					    // VRML V2.0 is the only version we support
					    if (BbAtom($2) != "2.0") {
						PH->error("invalid VRML version (only V2.0 supported)");
						YYABORT;
					    }
					}
	BLENDOS_ENCODING_UTF8
    |	BLENDOS_BLENDO BLENDOS_VERSION	{
					    PH->setVRMLFormat(false);

					    // VRML V2.0 is the only version we support
					    if (atof(BbAtom($2).getString()) > 0.9) {
						PH->error("invalid Blendo version (only V0.9 and below supported)");
						YYABORT;
					    }
					}
	BLENDOS_ENCODING_UTF8
    |	/* empty */	{ PH->error("File is missing a valid header"); YYABORT; }  
    ;

blendoScene:
	declarations
    ;

declarations:
	/* Empty is OK */
    |	declarations declaration
    ;

declaration:
	nodeDeclaration			{ $<node>$ = $1; }
    |	routeDeclaration
    |	fieldDeclaration
    |	namedProtoDeclaration
    |	externProtoDeclaration
    |	K_FUNCTION { PH->setToken(JS); } 
			JS functionDefinition { PH->setToken(BLENDO); } BLENDO
    |	K_PRIVATE K_FUNCTION { PH->setToken(JS); } 
			JS functionDefinition { PH->setToken(BLENDO); } BLENDO { $5->setPrivate(true); }
    ;

nodeDeclaration:
	exportNodeDeclaration				{ PH->addNode($1); }
    |	nodeExposeDeclaration exportNodeDeclaration
										{
											PH->exitNodeExpose($1, $2, BbAtom());
											PH->addNode($2);
											$$ = $2;
										}
    |	nodeExposeDeclaration exportNodeDeclaration K_AS IDENTIFIER  
										{
											PH->exitNodeExpose($1, $2, $4);
											PH->addNode($2);
											$$ = $2;
										}
    |	K_USE IDENTIFIER				{ $$ = PH->createUseNode($2); }
    ;

nodeExposeDeclaration:
		K_EXPOSE						{ $$ = PH->enterNodeExpose(); }
    ;

exportNodeDeclaration:
	node				    { $$ = $1; }
    |	K_DEF IDENTIFIER node		    { $$ = $3; PH->setNodeName($2, $3); }
    ;

namedProtoDeclaration:
		K_PROTO    { PH->setDOMProto(false); }				namedProto
    |	K_PRIVATE K_PROTO { PH->setDOMProto(false);  }		namedProto	{ $4->setPrivate(true); }
    |	K_DOMPROTO { PH->setDOMProto(true);  }				domProto
    |	K_PRIVATE K_DOMPROTO { PH->setDOMProto(true);  }	domProto	{ $4->setPrivate(true); }
    ;

anonymousProtoDeclaration:
	K_PROTO { PH->setCurrentProtoName(""); } anonymousProto { $$ = $3; }
    ;

anonymousProto:
	protoDefinition			    { $1 = PH->exitBlendoProto(); PH->enterDefNode(); }
	nodeDefinition			    { $$ = $3; PH->setProto($3, $1); }
    ;

namedProto:
	IDENTIFIER { PH->setCurrentProtoName($1); } protoDefinition oldProtoDefinition
					    { $$ = PH->exitBlendoProto(); }
    ;

domProto:
	IDENTIFIER { PH->setCurrentProtoName($1); } protoDefinition oldProtoDefinition
					    { $$ = PH->exitBlendoProto(); }
    ;

oldProtoDefinition:
	/* empty */
    |	'{' declarations '}'
    ;

protoDefinition:
	'[' protoDeclarations ']'	    { }
    |	{ PH->createExternProto(false); } externProtoString { }
    ;

protoDeclarations:
	{ PH->enterBlendoProto(); }  declarations
    |	{ PH->createExternProto(false); } nonEmptyExternProtoStrings
    ;

externProtoDeclaration:
	K_EXTERNPROTO IDENTIFIER	    { PH->setCurrentProtoName($2); }
	'[' externInterfaceDeclarations ']' { PH->createExternProto(true); }
	externProtoDefinition		    { PH->exitBlendoProto(); }
    ;

externProtoDefinition:
        '[' externProtoStrings ']'
    |	externProtoString
    ;

externInterfaceDeclarations:
	/* Empty is OK */
     |  externInterfaceDeclarations externInterfaceDeclaration
     ;

externInterfaceDeclaration:
	K_EVENTIN IDENTIFIER IDENTIFIER		{ }
    |   K_EVENTOUT IDENTIFIER IDENTIFIER	{ }
    |	K_FIELD IDENTIFIER IDENTIFIER		{ }
    ;

nonEmptyExternProtoStrings:
	externProtoString
    |	nonEmptyExternProtoStrings externProtoString
    ;

externProtoStrings:
	/* Empty is OK */
    |	nonEmptyExternProtoStrings
    ;

externProtoString:
	STRING				    { PH->addStringToExternProto($1); }
    ;

fieldDeclaration:
	fieldAttribute IDENTIFIER IDENTIFIER
					    { PH->enterField($2, $3, $1); }
	fieldContent			    { PH->exitField(); }
    |	K_EVENTIN IDENTIFIER IDENTIFIER	    {
						PH->enterField($2, $3, K_EVENTIN);
						PH->exitField(true);
					    }
    |	K_EVENTOUT IDENTIFIER IDENTIFIER    {
						PH->enterField($2, $3, K_EVENTOUT);
						PH->exitField();
					    }
    ;

fieldAttribute:
	K_FIELD				    { $$ = K_FIELD; }
    |	K_SHARED			    { $$ = K_SHARED; }
    |	K_PRIVATE			    { $$ = K_PRIVATE; }
    |	K_SHARED K_FIELD		{ $$ = K_SHARED; }
    |	K_PRIVATE K_FIELD		{ $$ = K_PRIVATE; }
    ;

routeDeclaration:
	K_ROUTE IDENTIFIER '.' IDENTIFIER K_TO IDENTIFIER '.' IDENTIFIER
					    { PH->addRoute($2, $4, $6, $8, $1); }
    |	K_ROUTE IDENTIFIER K_TO IDENTIFIER '.' IDENTIFIER
        				    { PH->addRoute("", $2, $4, $6, $1); }
    |	K_ROUTE IDENTIFIER '.' IDENTIFIER K_TO IDENTIFIER
        				    { PH->addRoute($2, $4, "", $6, $1); }
    |	K_ROUTE IDENTIFIER K_TO IDENTIFIER  { PH->addRoute("", $2, "", $4, $1); }
    ;

script:
					    {
							PH->setToken(JS);
							PH->setCurrentInlineScript(new BpRawScript(PH->getFileName(),
														PH->getLineNumber()));
							BbBasic::incNumObj(2);
							BbBasic::addTotObj(2, sizeof(BpRawScript));

							PH->setCurrentScript(PH->getCurrentInlineScript());
					    }
	JS block 			{ PH->setToken(BLENDO); }
	BLENDO 				{
							SC->setStmt($3);
							$$ = SC;
							PH->setCurrentInlineScript(NULL);
							PH->setCurrentScript(NULL);
					    }
    ;

fieldInitialization:
	IDENTIFIER			    { PH->enterField("", $1, 0); }
	fieldContent			    { PH->exitField(); }
    |	IDENTIFIER K_IS IDENTIFIER	    {
						PH->enterField("", $1, 0);
						PH->addISMapToCurrentField($3);
						PH->exitField();
					    }
    ;

node:
	nodeNames			    { PH->finishAddingNodeTypeNames(); }
        nodeDefinition			    { $$ = $3; }
    |	anonymousProtoDeclaration	    { $$ = $1; }
    |	K_SCRIPT			    { PH->enterVRMLScript(); }
	'{' scriptStatements '}'	    { $$ = PH->exitVRMLScript(); }
    ;

nodeNames:
	nodeName
    |	nodeNames '.' nodeName
    ;

nodeName:
	IDENTIFIER			    { PH->addNodeTypeName($1); }
    ;

nodeDefinition:
	'{' nodeStatements '}'		    { $$ = PH->exitDefNode(); }
    ;

nodeStatements:
	/* empty */
    |	nodeStatements nodeStatement
    ;

nodeStatement:
	fieldInitialization
    |	routeDeclaration
    |	namedProtoDeclaration
    |	externProtoDeclaration
    ;

scriptStatements:
	/* empty */
    | 	scriptStatements scriptStatement
    ;

scriptStatement:
	nodeStatement
    |	K_FIELD IDENTIFIER IDENTIFIER	    { PH->enterField($2, $3, K_FIELD); }
	fieldContent			    {
						// add a route to the internal PROTO field. 
						// Note that, unlike eventIn and eventOut, 
						// the current field is in the outer node
						// not the proto. So we have to use a full
						// route call, not a TO route call.
						PH->addRoute("top", $3, "__S__", $3, $1);
						PH->exitField();
					    }
    |	K_EVENTIN IDENTIFIER IDENTIFIER	    {
						PH->enterField($2, $3, K_EVENTIN);
						PH->addEventInScriptCall($3);
						PH->exitField(true);
					    }
    |	K_EVENTOUT IDENTIFIER IDENTIFIER    {
						PH->enterField($2, $3, K_EVENTOUT);
						PH->addRouteFromCurrentField("__S__", $3, $1);
						PH->exitField();
					    }
    |	K_FIELD IDENTIFIER IDENTIFIER K_IS IDENTIFIER
					    {
						PH->enterField($2, $3, K_FIELD);
						PH->addISMapToCurrentField($5);
						PH->exitField();
					    }
    |	K_EVENTIN IDENTIFIER IDENTIFIER	K_IS IDENTIFIER
					    {
						PH->enterField($2, $3, K_EVENTIN);
						PH->addEventInScriptCall($3);
						PH->addISMapToCurrentField($5);
						PH->exitField(true);
					    }
    |	K_EVENTOUT IDENTIFIER IDENTIFIER K_IS IDENTIFIER
					    {
						PH->enterField($2, $3, K_EVENTOUT);
						PH->addISMapToCurrentField($5);
						PH->exitField();
					    }
    ;

fieldContent:
	fieldValue
    |	actions
    |	';'
    |	fieldValue actions
    |	fieldValue ';'
    |	actions ';'
    |	fieldValue actions ';'
    ;
		
fieldValue:
	value
    |	numbers
    ;

actions:
	actions action
    |	action
    ;

action:
	K_DO script			    { PH->addScriptToCurrentField($2); }
    |	K_TO IDENTIFIER '.' IDENTIFIER	    { PH->addRouteToCurrentField($2, $4, $1); }
    |	K_TO IDENTIFIER			    { PH->addRouteToCurrentField("", $2, $1); }
    |	K_FROM IDENTIFIER '.' IDENTIFIER    { PH->addRouteFromCurrentField($2, $4, $1); }
    |	K_FROM IDENTIFIER		    { PH->addRouteFromCurrentField("", $2, $1); }
    ;

value:
        STRING				    { PH->addStringToField($1); }
    |   K_NULL				    { PH->addNodeToField(NULL); }
    |	K_TRUE				    { PH->addBoolToField(true); }
    |	K_FALSE				    { PH->addBoolToField(false); }
    |	nodeDeclaration			{ $<node>$ = $1; PH->addNodeToField($1); }
    |	'['						{ PH->addBeginArrayToField(); } 
		arrayValues ']'			{ PH->addEndArrayToField(); }
	|	nodeNames				{
									PH->finishAddingNodeTypeNames();
									PH->setNodeProtoOnly(true);
									PH->addNodeToField(PH->exitDefNode());
								}
    ;

arrayValues:
	/* empty */
    |	arrayValues arrayValue
    ;

arrayValue:
	value
    |	number
    ;

numbers:
	number
    |	numbers number
    ;

number:
    	signedNumber			    { PH->addNumberToField($1); }
    ;

signedNumber:
	unsignedNumber			    { $$ = $1; }
    |	'+' unsignedNumber		    { $$ = $2; }
    |	'-' unsignedNumber		    { $$ = -$2; }
    ;
unsignedNumber:
    	NUMBER				    { $$ = $1; }
    ;

/********************* ECMAScript *********************/

ecmascriptProgram:
					    {
							PH->setCurrentInlineScript(
									new BpRawScript(PH->getFileName(), PH->getLineNumber()));
							BbBasic::incNumObj(2);
							BbBasic::addTotObj(2, sizeof(BpRawScript));
							PH->setCurrentScript(
							PH->getCurrentInlineScript());
					    }
	sourceElements		{
							$$ = PH->getCurrentInlineScript();
							PH->getCurrentInlineScript()->setStmt($2);
							PH->setCurrentInlineScript(NULL);
							PH->setCurrentScript(NULL);
					    }
    |	/* empty */		{
							$$ = new BpRawScript(PH->getFileName(), PH->getLineNumber());
							BbBasic::incNumObj(2);
							BbBasic::addTotObj(2, sizeof(BpRawScript));
							$$->setStmt(NULL);
					    }
    ;

ecmascriptExpression:
					    {
							PH->setCurrentInlineScript(
									new BpRawScript(PH->getFileName(), PH->getLineNumber()));
							BbBasic::incNumObj(2);
							BbBasic::addTotObj(2, sizeof(BpRawScript));
							PH->setCurrentScript(
							PH->getCurrentInlineScript());
					    }
	expression			{
							$$ = PH->getCurrentInlineScript();
							PH->getCurrentInlineScript()->setStmt(new BpTreeReturnStmt(SC, $2));
							BbBasic::incNumObj(2);
							BbBasic::addTotObj(2, sizeof(BpTreeReturnStmt));
							PH->setCurrentInlineScript(NULL);
							PH->setCurrentScript(NULL);
					    }
    |	/* empty */		{
							$$ = new BpRawScript(PH->getFileName(), PH->getLineNumber());
							BbBasic::incNumObj(2);
							BbBasic::addTotObj(2, sizeof(BpRawScript));
							$$->setStmt(NULL);
					    }
    ;

sourceElements:
		{ PH->lookahead(); } sourceElement					{ $$ = $2; }
    |	sourceElements { PH->lookahead(); } sourceElement	{ $$ = $1 ? ($1->append($3)) : $3; }
    ;

sourceElement:
		statement				{ $$ = $1; }			
    |	functionDeclaration		{ $$ = NULL; }
    ;

primaryExpression:
	K_THIS						{
									$$ = new BpTreeThis(SC);
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeThis));
								}
    |	IDENTIFIER			    {
									$$ = new BpTreeIdRef(SC, $1);
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeIdRef));
								}
    |	K_NULL				    {
									$$ = new BpTreeNull(SC);
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeNull));
								}
    |	K_TRUE				    {
									$$ = new BpTreeBoolean(SC, true);
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeBoolean));
								}
    |	K_FALSE				    {
									$$ = new BpTreeBoolean(SC, false);
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeBoolean));
								}
    |	NUMBER				    {
									$$ = new BpTreeNumber(SC, $1);
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeNumber));
								}
    |	STRING				    {
									$$ = new BpTreeString(SC, $1);
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeString));
								}
    |	arrayLiteral			{
									$$ = new BpTreeArray(SC, $1);
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeArray));
								}
    |	objectLiteral			{
									$$ = new BpTreeObject(SC, $1);
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeObject));
								}
    |	'(' expression ')'		{ $$ = $2; }
    ;

memberExpression:
	primaryExpression
    |	memberExpression '[' expression ']' {
												$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_DEREF, $3);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
											}
    |	memberExpression '.' IDENTIFIER	    {
												$$ = new BpTreeDerefId(SC, $1, $3);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeDerefId));
											}
    |	K_NEW memberExpression arguments    {
												$$ = new BpTreeBinaryOp(SC, $2, BpTree::RAW_NEW, $3);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
											}
    ;

newExpression:
	memberExpression
    |	K_NEW newExpression					{
												$$ = new BpTreeBinaryOp(SC, $2, BpTree::RAW_NEW, 
																		new BpTreeArgList(SC, NULL));
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
											}
    ;

callExpression:
	memberExpression arguments				{
												$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_CALL, $2);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
											}
    |	callExpression arguments			{
												$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_CALL, $2);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
											}
    |	callExpression '[' expression ']'   {
												$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_DEREF, $3);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
											}
    |	callExpression '.' IDENTIFIER	    {
												$$ = new BpTreeDerefId(SC, $1, $3);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeDerefId));
											}
    ;

arguments:
	'(' ')'									{
												$$ = new BpTreeArgList(SC, NULL);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeArgList));
											}
    |	'(' argumentList ')'				{
												$$ = new BpTreeArgList(SC, $2);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeArgList));
											}
    ;

argumentList:
	assignmentExpression					{
												$$ = new BpTreeArg(SC, $1);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeArg));
											}
    |	argumentList ',' assignmentExpression	{
													$$ = $1->append(new BpTreeArg(SC, $3));
													BbBasic::incNumObj(2);
													BbBasic::addTotObj(2, sizeof(BpTreeArg));
												}
    ;

leftHandSideExpression:
	newExpression
    |	callExpression
    ;

postfixExpression:
	leftHandSideExpression
    |	leftHandSideExpression O_INCREMENT	{
												$$ = new BpTreeUnaryOp(SC, BpTree::RAW_POST_INC, $1);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeUnaryOp));
											}
    |	leftHandSideExpression O_DECREMENT	{
												$$ = new BpTreeUnaryOp(SC, BpTree::RAW_POST_DEC, $1);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeUnaryOp));
											}
    ;

unaryExpression:
	postfixExpression
    |	K_DELETE unaryExpression			{
												$$ = new BpTreeUnaryOp(SC, BpTree::RAW_DELETE, $2);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeUnaryOp));
											}
    |	K_VOID unaryExpression				{
												$$ = new BpTreeUnaryOp(SC, BpTree::RAW_VOID, $2);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeUnaryOp));
											}
    |	K_TYPEOF unaryExpression			{
												$$ = new BpTreeUnaryOp(SC, BpTree::RAW_TYPEOF, $2);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeUnaryOp));
											}
    |	O_INCREMENT unaryExpression			{
												$$ = new BpTreeUnaryOp(SC, BpTree::RAW_PRE_INC, $2);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeUnaryOp));
											}
    |	O_DECREMENT unaryExpression			{
												$$ = new BpTreeUnaryOp(SC, BpTree::RAW_PRE_DEC, $2);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeUnaryOp));
											}
    |	'-' unaryExpression					{
												$$ = new BpTreeUnaryOp(SC, BpTree::RAW_NEGATE, $2);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeUnaryOp));
											}
    |	'~' unaryExpression					{
												$$ = new BpTreeUnaryOp(SC, BpTree::RAW_INVERT, $2);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeUnaryOp));
											}
    |	'!' unaryExpression					{
												$$ = new BpTreeUnaryOp(SC, BpTree::RAW_NOT, $2);
												BbBasic::incNumObj(2);
												BbBasic::addTotObj(2, sizeof(BpTreeUnaryOp));
											}
    ;

multiplicativeExpression:
	unaryExpression
    |	multiplicativeExpression '*' unaryExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_MUL, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    |	multiplicativeExpression '/' unaryExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_DIV, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    |	multiplicativeExpression '%' unaryExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_MOD, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

additiveExpression:
	multiplicativeExpression
    |	additiveExpression '+' multiplicativeExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_ADD, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    |	additiveExpression '-' multiplicativeExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_SUB, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

shiftExpression:
	additiveExpression
    |	shiftExpression O_RSHIFT additiveExpression		{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_RSH, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    |	shiftExpression O_RSHIFTFILL additiveExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_RSF, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    |	shiftExpression O_LSHIFT additiveExpression		{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_LSH, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

relationalExpression:
	shiftExpression
    |	relationalExpression '<' shiftExpression		{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_LT, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    |	relationalExpression '>' shiftExpression		{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_GT, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    |	relationalExpression O_LE shiftExpression		{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_LE, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    |	relationalExpression O_GE shiftExpression		{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_GE, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    |	relationalExpression K_IN shiftExpression		{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_IN, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

relationalExpressionNoIn:
	shiftExpression
    |	relationalExpressionNoIn '<' shiftExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_LT, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    |	relationalExpressionNoIn '>' shiftExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_GT, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    |	relationalExpressionNoIn O_LE shiftExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_LE, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    |	relationalExpressionNoIn O_GE shiftExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_GE, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

equalityExpressionNoIn:
	relationalExpressionNoIn
    |	equalityExpressionNoIn O_EQ relationalExpressionNoIn
														{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_EQ, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    |	equalityExpressionNoIn O_NE relationalExpressionNoIn
														{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_NE, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

equalityExpression:
	relationalExpression
    |	equalityExpression O_EQ relationalExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_EQ, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    |	equalityExpression O_NE relationalExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_NE, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

bitwiseANDExpressionNoIn:
	equalityExpressionNoIn
    |	bitwiseANDExpressionNoIn '&' equalityExpressionNoIn
														{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_AND, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

bitwiseANDExpression:
	equalityExpression
    |	bitwiseANDExpression '&' equalityExpression		{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_AND, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

bitwiseXORExpressionNoIn:
	bitwiseANDExpressionNoIn
    |	bitwiseXORExpressionNoIn '^' bitwiseANDExpressionNoIn
														{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_XOR, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

bitwiseXORExpression:
	bitwiseANDExpression
    |	bitwiseXORExpression '^' bitwiseANDExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_XOR, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

bitwiseORExpressionNoIn:
	bitwiseXORExpressionNoIn
    |	bitwiseORExpressionNoIn '|' bitwiseXORExpressionNoIn
														{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_OR, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

bitwiseORExpression:
	bitwiseXORExpression
    |	bitwiseORExpression '|' bitwiseXORExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_OR, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

logicalANDExpressionNoIn:
	bitwiseORExpressionNoIn
    |	logicalANDExpressionNoIn O_AND bitwiseORExpressionNoIn
														{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_LAND, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

logicalANDExpression:
	bitwiseORExpression
    |	logicalANDExpression O_AND bitwiseORExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_LAND, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

logicalORExpressionNoIn:
	logicalANDExpressionNoIn
    |	logicalORExpressionNoIn O_OR logicalANDExpressionNoIn
														{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_LOR, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

logicalORExpression:
	logicalANDExpression
    |	logicalORExpression O_OR logicalANDExpression	{
															$$ = new BpTreeBinaryOp(SC, $1, BpTree::RAW_LOR, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

conditionalExpressionNoIn:
	logicalORExpressionNoIn
    |	logicalORExpressionNoIn '?' assignmentExpression ':' assignmentExpressionNoIn
														{
															$$ = new BpTreeTertiaryOp(SC, $1, BpTree::RAW_COND, $3, $5);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeTertiaryOp));
														}
    ;

conditionalExpression:
	logicalORExpression
    |	logicalORExpression '?' assignmentExpression ':' assignmentExpression
														{
															$$ = new BpTreeTertiaryOp(SC, $1, BpTree::RAW_COND, $3, $5);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeTertiaryOp));
														}
    ;

assignmentExpressionNoIn:
	conditionalExpressionNoIn
    |	leftHandSideExpression '=' assignmentExpressionNoIn
														{
															$$ = new BpTreeAssign(SC, $1, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeAssignOp));
														}
    |	leftHandSideExpression assignmentOperator assignmentExpressionNoIn
														{
															$$ = new BpTreeAssignOp(SC, $1, $2, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeAssignOp));
														}
    ;

assignmentExpression:
	conditionalExpression
    |	leftHandSideExpression '=' assignmentExpression	{
															$$ = new BpTreeAssign(SC, $1, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeAssign));
														}
    |	leftHandSideExpression assignmentOperator assignmentExpression
														{
															$$ = new BpTreeAssignOp(SC, $1, $2, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeAssignOp));
														}
    ;

assignmentOperator:
	O_MULTIPLYEQ	{ $$ = BpTree::RAW_MUL; }
    |	O_DIVIDEEQ	{ $$ = BpTree::RAW_DIV; }
    |	O_MODEQ		{ $$ = BpTree::RAW_MOD; }
    |	O_PLUSEQ	{ $$ = BpTree::RAW_ADD; }
    |	O_MINUSEQ	{ $$ = BpTree::RAW_SUB; }
    |	O_LSHIFTEQ	{ $$ = BpTree::RAW_LSH; }
    |	O_RSHIFTEQ	{ $$ = BpTree::RAW_RSH; }
    |	O_RSHIFTFILLEQ	{ $$ = BpTree::RAW_RSF; }
    |	O_ANDEQ		{ $$ = BpTree::RAW_AND; }
    |	O_XOREQ		{ $$ = BpTree::RAW_XOR; }
    |	O_OREQ		{ $$ = BpTree::RAW_OR; }
    ;

expressionNoIn:
	assignmentExpressionNoIn
    |	expressionNoIn ',' assignmentExpressionNoIn		{
															$$ = new BpTreeBinaryOp(SC, $1, BpTreeBinaryOp::RAW_COMMA, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

expression:
	assignmentExpression
    |	expression ',' assignmentExpression				{
															$$ = new BpTreeBinaryOp(SC, $1, BpTreeBinaryOp::RAW_COMMA, $3);
															BbBasic::incNumObj(2);
															BbBasic::addTotObj(2, sizeof(BpTreeBinaryOp));
														}
    ;

expressionOpt:
	expression
    |	/* empty */			    { $$ = NULL; }
    ;

expressionNoInOpt:
	expressionNoIn
    |	/* empty */				{ $$ = NULL; }
    ;

/* 
    ECMAScript is an ambiguous grammar in a way that this parser
    generator cannot cope. A '{' character at the beginning of a
    statement could be the start of a block or an object initializer.
    The ECMAScript explicitly forbids expressionStatements from 
    starting with '{' to avoid this ambiguity. We handle this here
    by looking ahead at next token when we start to parse a statement.
    If that token is '{' we insert a special token (BLOCK_START) to
    disambiguate block from expressionStatement.
    
    TODO: CFM - The lookahead code also generates a special token when
    'function' is the next token. This is because ECMAScript v4 allows
    function statements within blocks. We don't support this syntax yet
    so this is just for the future.

    We also must deal with line number updates here. We want to generate
    line numbers before each statement. But by the time we add a statement
    to the code gen tree, we have scanned past the desired line number. So
    the lookahead function remembers the linenumber when the first token
    of a statement was scanned and then sets the statement line number to that.
*/

statement:
						{ SC->pushLineNumber(PH->lookahead()); }
	triggeredStatement			{
						    $$ = $2;
						    int lineno = SC->popLineNumber();
						    if ($$ != NULL)
							$$->setLineNumber(lineno);
						}
    ;

triggeredStatement:
	BLOCK_START block			{ $$ = $2; }
    |	variableStatement
    |	emptyStatement
    |	ifStatement
    |	iterationStatement
    |	continueStatement
    |	breakStatement
    |	returnStatement
    |	withStatement
    |	expressionStatement
	|	labelledStatement
	|	switchStatement
    ;

block:
	'{' '}'					{ $$ = NULL; }
    |	'{' statementList '}'			{
											$$ = new BpTreeBlockStmt(SC, $2);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeBlockStmt));
										}
    ;

statementListOpt:
		statementList					{ $$ = $1; }
	|	/* empty */						{ $$ = NULL; }
	;

statementList:
	statement				{ $$ = $1; }
    |	statementList statement			{ $$ = $1 ? ($1->append($2)) : $2; }
    ;

variableStatement:
	K_VAR variableDeclarationList ';'	{ $$ = $2; }
    ;

variableDeclarationListNoIn:
	variableDeclarationNoIn			{ $$ = $1; }
    |	variableDeclarationListNoIn ',' variableDeclarationNoIn
						{ $$ = ($1) ? $1->append($3) : NULL; }
    ;

variableDeclarationList:
	variableDeclaration			{ $$ = $1; }
    |	variableDeclarationList ',' variableDeclaration
						{ $$ = ($1) ? $1->append($3) : NULL; }
    ;

variableDeclarationForIn:
    	IDENTIFIER						{
											$$ = new BpTreeIdRef(SC, $1);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeIdRef));
											SC->addVar($1);
										}
    |	IDENTIFIER initializerNoIn		{
											$$ = new BpTreeAssign(SC, new BpTreeIdRef(SC, $1), $2); 
											SC->addVar($1);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeAssign));
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeIdRef));
										}
    ;

variableDeclarationNoIn:
    	IDENTIFIER				{
						    $$ = NULL;
						    SC->addVar($1);
						}
    |	IDENTIFIER initializerNoIn		{
											$$ = new BpTreeExprStmt(SC, new BpTreeAssign(SC, 
																	new BpTreeIdRef(SC, $1), $2)); 
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeExprStmt));
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeAssign));
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeIdRef));
											SC->addVar($1);
										}
    ;

variableDeclaration:
    	IDENTIFIER				{
						    $$ = NULL;
						    SC->addVar($1);
						}
    |	IDENTIFIER initializer			{
											$$ = new BpTreeExprStmt(SC, new BpTreeAssign(SC, 
																	new BpTreeIdRef(SC, $1), $2)); 
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeExprStmt));
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeAssign));
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeIdRef));
											SC->addVar($1);
										}
    ;

initializerNoIn:
    	'=' assignmentExpressionNoIn		{ $$ = $2; }
    ;

initializer:
    	'=' assignmentExpression		{ $$ = $2; }
    ;

emptyStatement:
	';'					{ $$ = NULL; }
    ;

expressionStatement:
	expression ';'						{
											$$ = new BpTreeExprStmt(SC, $1);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeExprStmt));
										}
    ;

ifStatement:
	K_IF '(' expression ')' statement K_ELSE statement
										{
											$$ = new BpTreeIfStmt(SC, $3, $5, $7);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeIfStmt));
										}
    |	K_IF '(' expression ')' statement	
										{
											$$ = new BpTreeIfStmt(SC, $3, $5, NULL);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeIfStmt));
										}
    ;

iterationStatement:
		K_ECMADO statement K_WHILE '(' expression ')' ';' {
											$$ = new BpTreeDoStmt(SC, $2, $5);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeWhileStmt));
										}
	|	K_WHILE '(' expression ')' statement {
											$$ = new BpTreeWhileStmt(SC, $3, $5);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeWhileStmt));
										}
    |	K_FOR '(' expressionNoInOpt ';' expressionOpt ';' expressionOpt ')' statement
										{
											$$ = new BpTreeForStmt(SC, $3, $5, $7, $9);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeForStmt));
										}
    |	K_FOR '(' K_VAR variableDeclarationListNoIn ';' expressionOpt ';' expressionOpt ')' statement
										{
											$$ = new BpTreeForStmt(SC, $4, $6, $8, $10);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeForStmt));
										}
    |	K_FOR '(' leftHandSideExpression K_IN expression ')' statement
										{
											$$ = new BpTreeForInStmt(SC, $3, $5, $7);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeForInStmt));
										}
    |	K_FOR '(' K_VAR variableDeclarationForIn K_IN expression ')' statement
										{
											$$ = new BpTreeForInStmt(SC, $4, $6, $8);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeForInStmt));
										}
    ;

continueStatement:
		K_CONTINUE ';'					{
											$$ = new BpTreeContinueStmt(SC);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeContinueStmt));
										}
	|	K_CONTINUE IDENTIFIER ';'		{
											$$ = new BpTreeContinueStmt(SC);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeContinueStmt));
										}
    ;

breakStatement:
		K_BREAK ';'						{
											$$ = new BpTreeBreakStmt(SC);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeBreakStmt));
										}
	|	K_BREAK IDENTIFIER ';'			{
											$$ = new BpTreeBreakStmt(SC);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeBreakStmt));
										}
    ;

returnStatement:
	K_RETURN expressionOpt ';'			{
											$$ = new BpTreeReturnStmt(SC, $2);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeReturnStmt));
										}
    ;

withStatement:
	K_WITH '(' expression ')' statement {
											$$ = new BpTreeWithStmt(SC, $3, $5);
											BbBasic::incNumObj(2);
											BbBasic::addTotObj(2, sizeof(BpTreeWithStmt));
										}
    ;

labelledStatement:
		IDENTIFIER ':' statement		{ $$ = $3; }
	;

switchStatement:
		K_SWITCH '(' expression ')' caseBlock	{ $$ = NULL; }
	;

caseBlock:
		'{' caseClausesOpt '}'
	|	'{' caseClausesOpt defaultClause caseClausesOpt '}'
	;

caseClausesOpt:
		caseClauses
	|	/* empty */
	;

caseClauses:
		caseClause
	|	caseClauses caseClause
	;

caseClause:
		K_CASE expression ':' statementListOpt
	;

defaultClause:
		K_DEFAULT ':' statementListOpt
	;

functionDeclaration:
	K_FUNCTION functionDefinition		{ $$ = NULL; }
	;

functionDefinition:		{
							PH->setCurrentFunctionScript(new BpRawScript(PH->getFileName(),
														 PH->getLineNumber()));
							BbBasic::incNumObj(2);
							BbBasic::addTotObj(2, sizeof(BpRawScript));
							PH->setCurrentScript(PH->getCurrentFunctionScript());
					    }
	IDENTIFIER '(' formalParameterListOpt ')' block
					    {
							SC->setName($2);
							SC->setStmt($6);
							PH->addFunctionToProto(SC);
							$$ = SC;
							PH->setCurrentFunctionScript(NULL);
							PH->setCurrentScript(PH->getCurrentInlineScript());
					    }
    ;

formalParameterListOpt:
	formalParameterList
    |	/* empty */
    ;

formalParameterList:
	IDENTIFIER				{ SC->addArg($1); }
    |	formalParameterList ',' IDENTIFIER	{ SC->addArg($3); }
    ;

/*  objectLiteral must come after block because they produce a reduce/reduce
    conflict (they both match "{ }"). Putting objectLiteral last causes
    the parser to select the empty block in cases where both are possible
*/
arrayLiteral:
	'[' elisionOpt ']'		    { $$ = $2; }
    |	'[' elementList ']'		    { $$ = $2; }
    |	'[' elementList ',' elisionOpt ']'  { $$ = $2->append($4); }
    ;

elementList:
	elisionOpt assignmentExpression	    {
						$$ = new BpTreeArrayElt(SC, $2);
						BbBasic::incNumObj(2);
						BbBasic::addTotObj(2, sizeof(BpTreeArrayElt));
						if ($1 != NULL)
						    $$ = $1->append($$);
					    }
    |	elementList ',' elisionOpt assignmentExpression
					    {
							$1->append($3);
							$$ = $1->append(new BpTreeArrayElt(SC, $4));
							BbBasic::incNumObj(2);
							BbBasic::addTotObj(2, sizeof(BpTreeArrayElt));
					    }
    ;

elisionOpt:
	/* empty */			    { $$ = NULL; }
    |	elision				    { $$ = $1; }
    ;

elision:
	','							{
									$$ = new BpTreeArrayElt(SC, NULL);
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeArrayElt));
								}
    |	elision ','			    {
									$$ = $1->append(new BpTreeArrayElt(SC, NULL));
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeArrayElt));
								}
    ;

objectLiteral:
	'{' propertyNameAndValueList '}'    { $$ = $2; }
    ;

propertyNameAndValueList:
	/* empty */			    { $$ = NULL; }
    |	propertyName ':' assignmentExpression
								{
									$$ = new BpTreeObjectProp(SC, $1, $3);
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeObjectProp));
								}
    |	propertyNameAndValueList ',' propertyName ':' assignmentExpression
								{
									$$ = $1->append(new BpTreeObjectProp(SC, $3, $5));
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeObjectProp));
								}
    ;

propertyName:
	IDENTIFIER					{
									$$ = new BpTreeString(SC, BbString($1));
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeString));
								}
    |	STRING				    {
									$$ = new BpTreeString(SC, $1);
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeString));
								}
    |	NUMBER				    {
									$$ = new BpTreeNumber(SC, $1);
									BbBasic::incNumObj(2);
									BbBasic::addTotObj(2, sizeof(BpTreeNumber));
								}
    ;

%%