module dmdscript.parse;

import dmdscript.script;

import dmdscript.lexer;

import dmdscript.functiondefinition;

import dmdscript.expression;

import dmdscript.statement;

import dmdscript.identifier;

import dmdscript.ir;

import dmdscript.errmsgs;

class Parser : Lexer

{

uint flags;

enum

{

normal = 0,

initial = 1,

allowIn = 0,

noIn = 2,

// Flag if we're in the for statement header, as

// automatic semicolon insertion is suppressed inside it.

inForHeader = 4,

}

FunctionDefinition lastnamedfunc;

this(d_string sourcename, d_string base, int useStringtable)

{

//writefln("Parser.this(base = '%s')", base);

super(sourcename, base, useStringtable);

nextToken(); // start up the scanner

}

~this()

{

lastnamedfunc = null;

}

/**********************************************

static int parseFunctionDefinition(out FunctionDefinition pfd,

immutable(char)[] params, immutable(char)[] bdy, out ErrInfo perrinfo)

{

Parser p;

Identifier*[] parameters;

TopStatement[] topstatements;

FunctionDefinition fd = null;

int result;

p = new Parser("anonymous", params, 0);

// Parse FormalParameterList

while(p.token.value != TOKeof)

{

if(p.token.value != TOKidentifier)

{

p.error(errmsgtbl[ERR_FPL_EXPECTED_IDENTIFIER], p.token.toString());

goto Lreturn;

}

parameters ~= p.token.ident;

p.nextToken();

if(p.token.value == TOKcomma)

p.nextToken();

else if(p.token.value == TOKeof)

break;

else

{

p.error(errmsgtbl[ERR_FPL_EXPECTED_COMMA], p.token.toString());

goto Lreturn;

}

}

if(p.errinfo.message)

goto Lreturn;

destroy(p);

// Parse StatementList

p = new Parser("anonymous", bdy, 0);

for(;; )

{

TopStatement ts;

if(p.token.value == TOKeof)

break;

ts = p.parseStatement();

topstatements ~= ts;

}

fd = new FunctionDefinition(0, 0, null, parameters, topstatements);

Lreturn:

pfd = fd;

perrinfo = p.errinfo;

result = (p.errinfo.message != null);

destroy(p);

p = null;

return result;

}

/**********************************************

int parseProgram(out TopStatement[] topstatements, ErrInfo *perrinfo)

{

topstatements = parseTopStatements();

check(TOKeof);

//writef("parseProgram done\n");

*perrinfo = errinfo;

//clearstack();

return errinfo.message != null;

}

TopStatement[] parseTopStatements()

{

TopStatement[] topstatements;

TopStatement ts;

//writefln("parseTopStatements()");

for(;; )

{

switch(token.value)

{

case TOKfunction:

ts = parseFunction(0);

topstatements ~= ts;

break;

case TOKeof:

return topstatements;

case TOKrbrace:

return topstatements;

default:

ts = parseStatement();

topstatements ~= ts;

break;

}

}

assert(0);

}

/***************************

TopStatement parseFunction(int flag)

{

Identifier* name;

Identifier*[] parameters;

TopStatement[] topstatements;

FunctionDefinition f;

Expression e = null;

Loc loc;

//writef("parseFunction()\n");

loc = currentline;

nextToken();

name = null;

if(token.value == TOKidentifier)

{

name = token.ident;

nextToken();

if(!flag && token.value == TOKdot)

{

// Regard:

// function A.B() { }

// as:

// A.B = function() { }

// This is not ECMA, but a jscript feature

e = new IdentifierExpression(loc, name);

name = null;

while(token.value == TOKdot)

{

nextToken();

if(token.value == TOKidentifier)

{

e = new DotExp(loc, e, token.ident);

nextToken();

}

else

{

error(errmsgtbl[ERR_EXPECTED_IDENTIFIER_2PARAM], ".", token.toString());

break;

}

}

}

}

check(TOKlparen);

if(token.value == TOKrparen)

nextToken();

else

{

for(;; )

{

if(token.value == TOKidentifier)

{

parameters ~= token.ident;

nextToken();

if(token.value == TOKcomma)

{

nextToken();

continue;

}

if(!check(TOKrparen))

break;

}

else

error(ERR_EXPECTED_IDENTIFIER);

break;

}

}

check(TOKlbrace);

topstatements = parseTopStatements();

check(TOKrbrace);

f = new FunctionDefinition(loc, 0, name, parameters, topstatements);

f.isliteral = flag;

lastnamedfunc = f;

//writef("parseFunction() done\n");

if(!e)

return f;

// Construct:

// A.B = function() { }

Expression e2 = new FunctionLiteral(loc, f);

e = new AssignExp(loc, e, e2);

Statement s = new ExpStatement(loc, e);

return s;

}

/*****************************************

Statement parseStatement()

{

Statement s;

Token *t;

Loc loc;

//writefln("parseStatement()");

loc = currentline;

switch(token.value)

{

case TOKidentifier:

case TOKthis:

// Need to look ahead to see if it is a declaration, label, or expression

t = peek(&token);

if(t.value == TOKcolon && token.value == TOKidentifier)

{ // It's a label

Identifier *ident;

ident = token.ident;

nextToken();

nextToken();

s = parseStatement();

s = new LabelStatement(loc, ident, s);

}

else if(t.value == TOKassign ||

t.value == TOKdot ||

t.value == TOKlbracket)

{

Expression exp;

exp = parseExpression();

parseOptionalSemi();

s = new ExpStatement(loc, exp);

}

else

{

Expression exp;

exp = parseExpression(initial);

parseOptionalSemi();

s = new ExpStatement(loc, exp);

}

break;

case TOKreal:

case TOKstring:

case TOKdelete:

case TOKlparen:

case TOKplusplus:

case TOKminusminus:

case TOKplus:

case TOKminus:

case TOKnot:

case TOKtilde:

case TOKtypeof:

case TOKnull:

case TOKnew:

case TOKtrue:

case TOKfalse:

case TOKvoid:

{ Expression exp;

exp = parseExpression(initial);

parseOptionalSemi();

s = new ExpStatement(loc, exp);

break; }

case TOKvar:

{

Identifier *ident;

Expression init;

VarDeclaration v;

VarStatement vs;

vs = new VarStatement(loc);

s = vs;

nextToken();

for(;; )

{

loc = currentline;

if(token.value != TOKidentifier)

{

error(errmsgtbl[ERR_EXPECTED_IDENTIFIER_PARAM], token.toString());

break;

}

ident = token.ident;

init = null;

nextToken();

if(token.value == TOKassign)

{

uint flags_save;

nextToken();

flags_save = flags;

flags &= ~initial;

init = parseAssignExp();

flags = flags_save;

}

v = new VarDeclaration(loc, ident, init);

vs.vardecls ~= v;

if(token.value != TOKcomma)

break;

nextToken();

}

if(!(flags & inForHeader))

parseOptionalSemi();

break;

}

case TOKlbrace:

{ BlockStatement bs;

nextToken();

bs = new BlockStatement(loc);

/*while(token.value != TOKrbrace)

bs.statements ~= parseTopStatements();

s = bs;

nextToken();

// The following is to accommodate the jscript bug:

// if (i) {return(0);}; else ...

/*if(token.value == TOKsemicolon)

break; }

case TOKif:

{ Expression condition;

Statement ifbody;

Statement elsebody;

nextToken();

condition = parseParenExp();

ifbody = parseStatement();

if(token.value == TOKelse)

{

nextToken();

elsebody = parseStatement();

}

else

elsebody = null;

s = new IfStatement(loc, condition, ifbody, elsebody);

break; }

case TOKswitch:

{ Expression condition;

Statement bdy;

nextToken();

condition = parseParenExp();

bdy = parseStatement();

s = new SwitchStatement(loc, condition, bdy);

break; }

case TOKcase:

{ Expression exp;

nextToken();

exp = parseExpression();

check(TOKcolon);

s = new CaseStatement(loc, exp);

break; }

case TOKdefault:

nextToken();

check(TOKcolon);

s = new DefaultStatement(loc);

break;

case TOKwhile:

{ Expression condition;

Statement bdy;

nextToken();

condition = parseParenExp();

bdy = parseStatement();

s = new WhileStatement(loc, condition, bdy);

break; }

case TOKsemicolon:

nextToken();

s = new EmptyStatement(loc);

break;

case TOKdo:

{ Statement bdy;

Expression condition;

nextToken();

bdy = parseStatement();

check(TOKwhile);

condition = parseParenExp();

//We do what most browsers now do, ie allow missing ';'

//like " do{ statement; }while(e) statement; " and that even w/o linebreak

if(token.value == TOKsemicolon)

nextToken();

//parseOptionalSemi();

s = new DoStatement(loc, bdy, condition);

break; }

case TOKfor:

{

Statement init;

Statement bdy;

nextToken();

flags |= inForHeader;

check(TOKlparen);

if(token.value == TOKvar)

{

init = parseStatement();

}

else

{

Expression e;

e = parseOptionalExpression(noIn);

init = e ? new ExpStatement(loc, e) : null;

}

if(token.value == TOKsemicolon)

{

Expression condition;

Expression increment;

nextToken();

condition = parseOptionalExpression();

check(TOKsemicolon);

increment = parseOptionalExpression();

check(TOKrparen);

flags &= ~inForHeader;

bdy = parseStatement();

s = new ForStatement(loc, init, condition, increment, bdy);

}

else if(token.value == TOKin)

{

Expression inexp;

VarStatement vs;

// Check that there's only one VarDeclaration

// in init.

if(init.st == VARSTATEMENT)

{

vs = cast(VarStatement)init;

if(vs.vardecls.length != 1)

error(errmsgtbl[ERR_TOO_MANY_IN_VARS], vs.vardecls.length);

}

nextToken();

inexp = parseExpression();

check(TOKrparen);

flags &= ~inForHeader;

bdy = parseStatement();

s = new ForInStatement(loc, init, inexp, bdy);

}

else

{

error(errmsgtbl[ERR_IN_EXPECTED], token.toString());

s = null;

}

break;

}

case TOKwith:

{ Expression exp;

Statement bdy;

nextToken();

exp = parseParenExp();

bdy = parseStatement();

s = new WithStatement(loc, exp, bdy);

break; }

case TOKbreak:

{ Identifier *ident;

nextToken();

if(token.sawLineTerminator && token.value != TOKsemicolon)

{ // Assume we saw a semicolon

ident = null;

}

else

{

if(token.value == TOKidentifier)

{

ident = token.ident;

nextToken();

}

else

ident = null;

parseOptionalSemi();

}

s = new BreakStatement(loc, ident);

break; }

case TOKcontinue:

{ Identifier *ident;

nextToken();

if(token.sawLineTerminator && token.value != TOKsemicolon)

{ // Assume we saw a semicolon

ident = null;

}

else

{

if(token.value == TOKidentifier)

{

ident = token.ident;

nextToken();

}

else

ident = null;

parseOptionalSemi();

}

s = new ContinueStatement(loc, ident);

break; }

case TOKgoto:

{ Identifier *ident;

nextToken();

if(token.value != TOKidentifier)

{

error(errmsgtbl[ERR_GOTO_LABEL_EXPECTED], token.toString());

s = null;

break;

}

ident = token.ident;

nextToken();

parseOptionalSemi();

s = new GotoStatement(loc, ident);

break; }

case TOKreturn:

{ Expression exp;

nextToken();

if(token.sawLineTerminator && token.value != TOKsemicolon)

{ // Assume we saw a semicolon

s = new ReturnStatement(loc, null);

}

else

{

exp = parseOptionalExpression();

parseOptionalSemi();

s = new ReturnStatement(loc, exp);

}

break; }

case TOKthrow:

{ Expression exp;

nextToken();

exp = parseExpression();

parseOptionalSemi();

s = new ThrowStatement(loc, exp);

break; }

case TOKtry:

{ Statement bdy;

Identifier *catchident;

Statement catchbody;

Statement finalbody;

nextToken();

bdy = parseStatement();

if(token.value == TOKcatch)

{

nextToken();

check(TOKlparen);

catchident = null;

if(token.value == TOKidentifier)

catchident = token.ident;

check(TOKidentifier);

check(TOKrparen);

catchbody = parseStatement();

}

else

{

catchident = null;

catchbody = null;

}

if(token.value == TOKfinally)

{

nextToken();

finalbody = parseStatement();

}

else

finalbody = null;

if(!catchbody && !finalbody)

{

error(ERR_TRY_CATCH_EXPECTED);

s = null;

}

else

{

s = new TryStatement(loc, bdy, catchident, catchbody, finalbody);

}

break; }

default:

error(errmsgtbl[ERR_STATEMENT_EXPECTED], token.toString());

nextToken();

s = null;

break;

}

//writefln("parseStatement() done");

return s;

}

Expression parseOptionalExpression(uint flags = 0)

{

Expression e;

if(token.value == TOKsemicolon || token.value == TOKrparen)

e = null;

else

e = parseExpression(flags);

return e;

}

// Follow ECMA 7.8.1 rules for inserting semicolons

void parseOptionalSemi()

{

if(token.value != TOKeof &&

token.value != TOKrbrace &&

!(token.sawLineTerminator && (flags & inForHeader) == 0)

)

check(TOKsemicolon);

}

int check(TOK value)

{

if(token.value != value)

{

error(errmsgtbl[ERR_EXPECTED_GENERIC], token.toString(), Token.toString(value));

return 0;

}

nextToken();

return 1;

}

/********************************* Expression Parser ***************************/

Expression parseParenExp()

{

Expression e;

check(TOKlparen);

e = parseExpression();

check(TOKrparen);

return e;

}

Expression parsePrimaryExp(int innew)

{

Expression e;

Loc loc;

loc = currentline;

switch(token.value)

{

case TOKthis:

e = new ThisExpression(loc);

nextToken();

break;

case TOKnull:

e = new NullExpression(loc);

nextToken();

break;

case TOKtrue:

e = new BooleanExpression(loc, 1);

nextToken();

break;

case TOKfalse:

e = new BooleanExpression(loc, 0);

nextToken();

break;

case TOKreal:

e = new RealExpression(loc, token.realvalue);

nextToken();

break;

case TOKstring:

e = new StringExpression(loc, token.string);

token.string = null; // release to gc

nextToken();

break;

case TOKregexp:

e = new RegExpLiteral(loc, token.string);

token.string = null; // release to gc

nextToken();

break;

case TOKidentifier:

e = new IdentifierExpression(loc, token.ident);

token.ident = null; // release to gc

nextToken();

break;

case TOKlparen:

e = parseParenExp();

break;

case TOKlbracket:

e = parseArrayLiteral();

break;

case TOKlbrace:

/*if(flags & initial)

e = parseObjectLiteral();

break;

case TOKfunction:

// if (flags & initial)

// goto Lerror;

e = parseFunctionLiteral();

break;

case TOKnew:

{ Expression newarg;

Expression[] arguments;

nextToken();

newarg = parsePrimaryExp(1);

arguments = parseArguments();

e = new NewExp(loc, newarg, arguments);

break; }

default:

// Lerror:

error(errmsgtbl[ERR_EXPECTED_EXPRESSION], token.toString());

nextToken();

return null;

}

return parsePostExp(e, innew);

}

Expression[] parseArguments()

{

Expression[] arguments = null;

if(token.value == TOKlparen)

{

nextToken();

if(token.value != TOKrparen)

{

for(;; )

{

Expression arg;

arg = parseAssignExp();

arguments ~= arg;

if(token.value == TOKrparen)

break;

if(!check(TOKcomma))

break;

}

}

nextToken();

}

return arguments;

}

Expression parseArrayLiteral()

{

Expression e;

Expression[] elements;

Loc loc;

//writef("parseArrayLiteral()\n");

loc = currentline;

check(TOKlbracket);

if(token.value != TOKrbracket)

{

for(;; )

{

if(token.value == TOKcomma)

// Allow things like [1,2,,,3,]

// Like Explorer 4, and unlike Netscape, the

// trailing , indicates another null element.

//Netscape was right - FIXED

elements ~= cast(Expression)null;

else if(token.value == TOKrbracket)

{

//elements ~= cast(Expression)null;

break;

}

else

{

e = parseAssignExp();

elements ~= e;

if(token.value != TOKcomma)

break;

}

nextToken();

}

}

check(TOKrbracket);

e = new ArrayLiteral(loc, elements);

return e;

}

Expression parseObjectLiteral()

{

Expression e;

Field[] fields;

Loc loc;

//writef("parseObjectLiteral()\n");

loc = currentline;

check(TOKlbrace);

if(token.value == TOKrbrace)

nextToken();

else

{

for(;; )

{

Field f;

Identifier* ident;

switch(token.value){

case TOKidentifier:

ident = token.ident;

break;

case TOKstring,TOKnumber,TOKreal:

ident = Identifier.build(token.toString());

break;

default:

error(ERR_EXPECTED_IDENTIFIER);

break;

}

nextToken();

check(TOKcolon);

f = new Field(ident, parseAssignExp());

fields ~= f;

if(token.value != TOKcomma)

break;

nextToken();

if(token.value == TOKrbrace)//allow trailing comma

break;

}

check(TOKrbrace);

}

e = new ObjectLiteral(loc, fields);

return e;

}

Expression parseFunctionLiteral()

{

FunctionDefinition f;

Loc loc;

loc = currentline;

f = cast(FunctionDefinition)parseFunction(1);

return new FunctionLiteral(loc, f);

}

Expression parsePostExp(Expression e, int innew)

{

Loc loc;

for(;; )

{

loc = currentline;

//loc = (Loc)token.ptr;

switch(token.value)

{

case TOKdot:

nextToken();

if(token.value == TOKidentifier)

{

e = new DotExp(loc, e, token.ident);

}

else

{

error(errmsgtbl[ERR_EXPECTED_IDENTIFIER_2PARAM], ".", token.toString());

return e;

}

break;

case TOKplusplus:

if(token.sawLineTerminator && !(flags & inForHeader))

goto Linsert;

e = new PostIncExp(loc, e);

break;

case TOKminusminus:

if(token.sawLineTerminator && !(flags & inForHeader))

{

Linsert:

// insert automatic semicolon

insertSemicolon(token.sawLineTerminator);

return e;

}

e = new PostDecExp(loc, e);

break;

case TOKlparen:

{ // function call

Expression[] arguments;