package hscript;

import haxe.rtti.Meta;

import hscript.Expr;

import hscript.Expr.FieldPropertyAccess;

enum Token {

TEof;

TConst( c : Const );

TId( s : String );

TOp( s : String );

TPOpen;

TPClose;

TBrOpen;

TBrClose;

TDot;

TQuestionDot;

TComma;

TSemicolon;

TBkOpen;

TBkClose;

TQuestion;

TDoubleDot;

TMeta( s : String );

TPrepro( s : String );

}

@:structInit

final class TokenInfo {

public var min : Int;

public var max : Int;

public var t : Token;

}

@:analyzer(optimize, local_dce, fusion, user_var_fusion)

class Parser {

// config / variables

public var line : Int;

public var opChars : String;

public var identChars : String;

public var opPriority : Map<String,Int>;

public var opRightAssoc : Map<String,Bool>;

/**

public var preprocessorValues : Map<String,Dynamic> = new Map();

/**

public var allowJSON : Bool;

/**

public var allowTypes : Bool;

/**

public var allowMetadata : Bool;

/**

public var resumeErrors : Bool;

/*

public var packageName:String = null;

// implementation

var input : String;

var readPos : Int;

var char : Int;

var ops : Array<Bool>;

var idents : Array<Bool>;

var uid : Int = 0;

var disableOrOp : Bool = false;

var isVar : Bool = false;

#if hscriptPos

var origin : String;

var tokenMin : Int;

var tokenMax : Int;

var oldTokenMin : Int;

var oldTokenMax : Int;

var tokens : List<TokenInfo>;

#else

static inline var p1 = 0;

static inline var tokenMin = 0;

static inline var tokenMax = 0;

var tokens : haxe.ds.GenericStack<Token>;

#end

public function new() {

line = 1;

opChars = "+*/-=!><&|^%~";

identChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_";

var priorities = [

["%"],

["*", "/"],

["+", "-"],

["<<", ">>", ">>>"],

["|", "&", "^"],

["==", "!=", ">", "<", ">=", "<="],

["..."],

["&&"],

["||"],

["=","+=","-=","*=","/=","%=","<<=",">>=",">>>=","|=","&=","^=","=>","??" + "="],

["->", "??"],

["is"]

];

opPriority = new Map();

opRightAssoc = new Map();

for( i in 0...priorities.length )

for( x in priorities[i] ) {

opPriority.set(x, i);

if( i == 9 ) opRightAssoc.set(x, true);

}

for( x in ["!", "++", "--", "~"] ) // unary "-" handled in parser directly!

opPriority.set(x, x == "++" || x == "--" ? -1 : -2);

}

public inline function error( err:#if hscriptPos ErrorDef #else Error #end, pmin:Int, pmax:Int ) {

if( !resumeErrors )

#if hscriptPos

throw new Error(err, pmin, pmax, origin, line);

#else

throw err;

#end

}

public function invalidChar(c:Int) {

error(EInvalidChar(c), readPos-1, readPos-1);

}

function initParser( origin:String ) {

// line=1 - don't reset line : it might be set manualy

preprocStack = [];

#if hscriptPos

this.origin = origin;

readPos = 0;

tokenMin = oldTokenMin = 0;

tokenMax = oldTokenMax = 0;

tokens = new List();

#else

tokens = new haxe.ds.GenericStack<Token>();

#end

char = -1;

ops = [];

idents = [];

uid = 0;

for( i in 0...opChars.length )

ops[opChars.charCodeAt(i)] = true;

for( i in 0...identChars.length )

idents[identChars.charCodeAt(i)] = true;

}

public function parseString( s : String, ?origin : String = "hscript" ):Expr {

initParser(origin);

if(s == "") s = "0;"; // fixing crash with empty file

input = s;

readPos = 0;

var a = [];

while( true ) {

var tk = token();

if( tk == TEof ) break;

push(tk);

parseFullExpr(a);

}

return if( a.length == 1 ) a[0] else mk(EBlock(a),0);

}

function unexpected( tk:Token ) : Any {

error(EUnexpected(tokenString(tk)),tokenMin,tokenMax);

return null;

}

inline function push(tk: Token):Void {

#if hscriptPos

tokens.push( { t : tk, min : tokenMin, max : tokenMax } );

tokenMin = oldTokenMin;

tokenMax = oldTokenMax;

#else

tokens.add(tk);

#end

}

inline function ensure(tk:Token):Void {

var t = token();

if( t != tk ) unexpected(t);

}

inline function ensureToken(tk:Token):Void {

var t = token();

if( !Type.enumEq(t,tk) ) unexpected(t);

}

function maybe(tk:Token):Bool {

var t = token();

if( Type.enumEq(t, tk) )

return true;

push(t);

return false;

}

function getIdent():String {

var tk = token();

switch( tk ) {

case TId(id): return id;

default:

unexpected(tk);

return null;

}

}

function extractIdent(tk: Token): String {

switch (tk) {

case TId(id):

return id;

default:

unexpected(tk);

return null;

}

}

inline function expr(e:Expr):#if hscriptPos ExprDef #else Expr #end {

#if hscriptPos

return e.e;

#else

return e;

#end

}

inline function pmin(e:Expr):Int {

#if hscriptPos

return e == null ? 0 : e.pmin;

#else

return 0;

#end

}

inline function pmax(e:Expr):Int {

#if hscriptPos

return e == null ? 0 : e.pmax;

#else

return 0;

#end

}

inline function mk(e:#if hscriptPos ExprDef #else Expr #end,?pmin:Int,?pmax:Int) : Expr {

#if hscriptPos

if( e == null ) return null;

if( pmin == null ) pmin = tokenMin;

if( pmax == null ) pmax = tokenMax;

return { e : e, pmin : pmin, pmax : pmax, origin : origin, line : line };

#else

return e;

#end

}

function isBlock(e:Expr):Bool {

if( e == null ) return false;

return switch( expr(e) ) {

case EBlock(_), EObject(_), ESwitch(_), EEnum(_, _): true;

case EFunction(_,e,_,_,_,_): isBlock(e);

case EClass(_,e,_,_): true;

case EVar(_, t, e, _,_): e != null ? isBlock(e) : t != null ? t.match(CTAnon(_)) : false;

case EIf(_,e1,e2): if( e2 != null ) isBlock(e2) else isBlock(e1);

case EBinop(_,_,e): isBlock(e);

case EUnop(_,prefix,e): !prefix && isBlock(e);

case EWhile(_,e): isBlock(e);

case EDoWhile(_,e): isBlock(e);

case EFor(_,_,e): isBlock(e);

case EReturn(e): e != null && isBlock(e);

case ETry(_, _, _, e): isBlock(e);

case EMeta(_, _, e): isBlock(e);

case EIgnore(skip): skip;

default: false;

}

}

function parseFullExpr( exprs : Array<Expr> ):Void {

var e = parseExpr();

if(!expr(e).match(EIgnore(_)))

exprs.push(e);

var tk = token();

// this is a hack to support var a,b,c; with a single EVar

while( tk == TComma && e != null && expr(e).match(EVar(_)) ) {

e = parseStructure("var"); // next variable

if(!expr(e).match(EIgnore(_)))

exprs.push(e);

tk = token();

}

if( tk != TSemicolon && tk != TEof ) {

if( isBlock(e) )

push(tk);

else

unexpected(tk);

}

}

function parseObject(p1:Int):Expr {

// parse object

var fl:Array<ObjectField> = [];

while( true ) {

var tk = token();

var id = null;

switch( tk ) {

case TId(i): id = i;

case TConst(c):

if( !allowJSON )

unexpected(tk);

switch( c ) {

case CString(s): id = s;

default: unexpected(tk);

}

case TBrClose:

break;

default:

unexpected(tk);

break;

}

ensure(TDoubleDot);

fl.push({ name : id, e : parseExpr() });

tk = token();

switch( tk ) {

case TBrClose:

break;

case TComma:

default:

unexpected(tk);

}

}

return parseExprNext(mk(EObject(fl),p1));

}

function parseExpr():Expr {

var oldPos = readPos;

var tk = token();

#if hscriptPos

var p1 = tokenMin;

#end

switch( tk ) {

case TId(id):

var e = parseStructure(id, oldPos);

if( e == null )

e = mk(EIdent(id));

return parseExprNext(e);

case TConst(c):

return parseExprNext(mk(EConst(c)));

case TPOpen:

tk = token();

if( tk == TPClose ) {

ensureToken(TOp("->"));

var eret = parseExpr();

return mk(EFunction([], mk(EReturn(eret),p1)), p1);

}

push(tk);

var oldoo = disableOrOp;

disableOrOp = false;

var e = parseExpr();

disableOrOp = oldoo;

tk = token();

switch( tk ) {

case TPClose:

return parseExprNext(mk(EParent(e),p1,tokenMax));

case TDoubleDot:

var t = parseType();

tk = token();

switch( tk ) {

case TPClose:

return parseExprNext(mk(ECheckType(e,t),p1,tokenMax));

case TComma:

switch( expr(e) ) {

case EIdent(v): return parseLambda([{ name : v, t : t, opt: false, value: null }], pmin(e));

default:

}

default:

}

case TComma:

switch( expr(e) ) {

case EIdent(v): return parseLambda([{name: v, opt: false, value: null, t: null}], pmin(e));

default:

}

default:

}

return unexpected(tk);

case TBrOpen:

tk = token();

switch( tk ) {

case TBrClose:

return parseExprNext(mk(EObject([]),p1));

case TId(_):

var tk2 = token();

push(tk2);

push(tk);

switch( tk2 ) {

case TDoubleDot:

return parseExprNext(parseObject(p1));

default:

}

case TConst(c):

if( allowJSON ) {

switch( c ) {

case CString(_):

var tk2 = token();

push(tk2);

push(tk);

switch( tk2 ) {

case TDoubleDot:

return parseExprNext(parseObject(p1));

default:

}

default:

push(tk);

}

} else

push(tk);

default:

push(tk);

}

var a = [];

while( true ) {

parseFullExpr(a);

tk = token();

if( tk == TBrClose || (resumeErrors && tk == TEof) )

break;

push(tk);

}

return mk(EBlock(a),p1);

case TOp(op):

if( op == "-" ) {

var start = tokenMin;

var oldoo = disableOrOp;

disableOrOp = false;

var e = parseExpr();

disableOrOp = oldoo;

if( e == null )

return makeUnop(op,e);

switch( expr(e) ) {

case EConst(CInt(i)):

return mk(EConst(CInt(-i)), start, pmax(e));

case EConst(CFloat(f)):

return mk(EConst(CFloat(-f)), start, pmax(e));

default:

return makeUnop(op,e);

}

}

if( opPriority.get(op) < 0 )

return makeUnop(op,parseExpr());

return unexpected(tk);

case TBkOpen:

var a = [];

tk = token();

var first:Bool = true;

while( tk != TBkClose && (!resumeErrors || tk != TEof) ) {

if(!first) {

if(tk != TComma)

unexpected(tk);

else {

tk = token();

if (tk == TBkClose)

break;

}

}

first = false;

push(tk);

var oldoo = disableOrOp;

disableOrOp = false;

a.push(parseExpr());

disableOrOp = oldoo;

tk = token();

}

if( a.length == 1 && a[0] != null ) // What is this for???

switch( expr(a[0]) ) {

case EFor(_), EWhile(_), EDoWhile(_):

var tmp = "__a_" + (uid++);

var e = mk(EBlock([

mk(EVar(tmp, null, mk(EArrayDecl([]), p1)), p1),

mapCompr(tmp, a[0]),

mk(EIdent(tmp),p1),

]),p1);

return parseExprNext(e);

default:

}

return parseExprNext(mk(EArrayDecl(a, nextType), p1));

case TMeta(id) if( allowMetadata ):

var args = parseMetaArgs();

return mk(EMeta(id, args, parseExpr()),p1);

default:

return unexpected(tk);

}

}

function parseLambda( args : Array<Argument>, pmin: Int ): Expr {

while( true ) {

var id = getIdent();

var t = maybe(TDoubleDot) ? parseType() : null;

args.push({ name : id, t : t, opt: false, value: null });

var tk = token();

switch( tk ) {

case TComma:

case TPClose:

break;

default:

unexpected(tk);

break;

}

}

ensureToken(TOp("->"));

var eret = parseExpr();

return mk(EFunction(args, mk(EReturn(eret),pmin)), pmin);

}

function parseMetaArgs():Array<Expr> {

var tk = token();

if( tk != TPOpen ) {

push(tk);

return null;

}

var args:Array<Expr> = [];

tk = token();

if( tk != TPClose ) {

push(tk);

while( true ) {

args.push(parseExpr());

switch( token() ) {

case TComma:

case TPClose:

break;

case tk:

unexpected(tk);

}

}

}

return args;

}

function mapCompr( tmp : String, e : Expr ):Expr {

if( e == null ) return null;

var edef = switch( expr(e) ) {

case EFor(v, it, e2, ithv):

EFor(v, it, mapCompr(tmp, e2), ithv);

case EWhile(cond, e2):

EWhile(cond, mapCompr(tmp, e2));

case EDoWhile(cond, e2):

EDoWhile(cond, mapCompr(tmp, e2));

case EIf(cond, e1, e2) if( e2 == null ):

EIf(cond, mapCompr(tmp, e1), null);

case EBlock([e]):

EBlock([mapCompr(tmp, e)]);

case EParent(e2):

EParent(mapCompr(tmp, e2));

default:

ECall( mk(EField(mk(EIdent(tmp), pmin(e), pmax(e)), "push"), pmin(e), pmax(e)), [e]);

}

return mk(edef, pmin(e), pmax(e));

}

function makeUnop( op:String, e:Expr ):Expr {

if( e == null && resumeErrors )

return null;

return switch( expr(e) ) {

case EBinop(bop, e1, e2): mk(EBinop(bop, makeUnop(op, e1), e2), pmin(e1), pmax(e2));

case ETernary(e1, e2, e3): mk(ETernary(makeUnop(op, e1), e2, e3), pmin(e1), pmax(e3));

default: mk(EUnop(op,true,e),pmin(e),pmax(e));

}

}

function makeBinop( op:String, e1:Expr, e:Expr ):Expr {

if( e == null && resumeErrors )

return mk(EBinop(op,e1,e),pmin(e1),pmax(e1));

return switch( expr(e) ) {

case EBinop(op2,e2,e3):

if( opPriority.get(op) <= opPriority.get(op2) && !opRightAssoc.exists(op) )

mk(EBinop(op2,makeBinop(op,e1,e2),e3),pmin(e1),pmax(e3));

else

mk(EBinop(op, e1, e), pmin(e1), pmax(e));

case ETernary(e2,e3,e4):

if( opRightAssoc.exists(op) )

mk(EBinop(op,e1,e),pmin(e1),pmax(e));

else

mk(ETernary(makeBinop(op, e1, e2), e3, e4), pmin(e1), pmax(e));

default:

mk(EBinop(op,e1,e),pmin(e1),pmax(e));

}

}

var nextIsOverride:Bool = false;

var nextIsStatic:Bool = false;

var nextIsPublic:Bool = false;

var nextIsPrivate:Bool = false;

var nextIsFinal:Bool = false;

var nextIsInline:Bool = false;

var nextType:CType = null;

function parseStructure(id:String, ?oldPos:Int):Expr {

#if hscriptPos

var p1 = tokenMin;

#end

return switch( id ) {

case "if":

ensure(TPOpen);

var cond = parseExpr();

ensure(TPClose);

var e1 = parseExpr();

var e2 = null;

var semic = false;

var tk = token();

if( tk == TSemicolon ) {

semic = true;

tk = token();

}

if( Type.enumEq(tk,TId("else")) )

e2 = parseExpr();

else {

push(tk);

if( semic ) push(TSemicolon);

}

mk(EIf(cond,e1,e2),p1,(e2 == null) ? tokenMax : pmax(e2));

case "override":

nextIsOverride = true;

var nextToken = token();

switch(nextToken) {

case TId("public"):

var str = parseStructure("public"); // override public

nextIsOverride = false;

str;

case TId("function"):

var str = parseStructure("function"); // override function

nextIsOverride = false;

str;

case TId("static"):

var str = parseStructure("static"); // override static

nextIsOverride = false;

str;

case TId("var"):

var str = parseStructure("var"); // override var

nextIsOverride = false;

str;

case TId("final"):

var str = parseStructure("final"); // override final

nextIsOverride = false;

str;

case TId("private"):

var str = parseStructure("private"); // override private

nextIsOverride = false;

str;

case TId("inline"):

var str = parseStructure("inline"); // override inline

nextIsOverride = false;

str;

default:

unexpected(nextToken);

nextIsOverride = false;

null;

}

case "static":

nextIsStatic = true;

var nextToken = token();

switch(nextToken) {

case TId("public"):

var str = parseStructure("public"); // static public

nextIsStatic = false;

str;

case TId("function"):

var str = parseStructure("function"); // static function

nextIsStatic = false;

str;

case TId("override"):

var str = parseStructure("override"); // static override

nextIsStatic = false;

str;

case TId("var"):

var str = parseStructure("var"); // static var

nextIsStatic = false;

str;

case TId("final"):

var str = parseStructure("final"); // static final

nextIsStatic = false;

str;

case TId("private"):

var str = parseStructure("private"); // static private

nextIsStatic = false;

str;

case TId("inline"):

var str = parseStructure("inline"); // static inline

nextIsStatic = false;

str;

default:

unexpected(nextToken);

nextIsStatic = false;

null;

}

case "public":

nextIsPublic = true;

var nextToken = token();

switch(nextToken) {

case TId("static"):

var str = parseStructure("static"); // public static

nextIsPublic = false;

str;

case TId("function"):

var str = parseStructure("function"); // public function

nextIsPublic = false;

str;

case TId("override"):

var str = parseStructure("override"); // public override

nextIsPublic = false;

str;

case TId("var"):

var str = parseStructure("var"); // public var

nextIsPublic = false;

str;

case TId("final"):

var str = parseStructure("final"); // public final

nextIsPublic = false;

str;

case TId("class"):

var str = parseStructure("class"); // public class

nextIsPublic = false;

str;

//case TId("private"):

// var str = parseStructure("private"); // public private

// nextIsPublic = false;

// str;

case TId("inline"):

var str = parseStructure("inline"); // public inline

nextIsPublic = false;

str;

default:

unexpected(nextToken);

nextIsPublic = false;

null;

}

case "private":

nextIsPrivate = true;

var nextToken = token();

switch(nextToken) {

case TId("static"):

var str = parseStructure("static"); // private static

nextIsPrivate = false;

str;

case TId("function"):

var str = parseStructure("function"); // private function

nextIsPrivate = false;

str;

case TId("override"):

var str = parseStructure("override"); // private override

nextIsPrivate = false;

str;

case TId("var"):

var str = parseStructure("var"); // private var

nextIsPrivate = false;

str;

case TId("final"):

var str = parseStructure("final"); // private final

nextIsPrivate = false;

str;

case TId("class"):

var str = parseStructure("class"); // private class

nextIsPrivate = false;

str;

case TId("inline"):

var str = parseStructure("inline"); // private inline

nextIsPrivate = false;

str;

default:

unexpected(nextToken);

nextIsPrivate = false;

null;

}

case "inline":

nextIsInline = true;

var nextToken = token();

switch(nextToken) {

case TId("static"):

var str = parseStructure("static"); // inline static

nextIsInline = false;

str;

case TId("function"):

var str = parseStructure("function"); // inline function

nextIsInline = false;

str;

case TId("override"):

var str = parseStructure("override"); // inline override

nextIsInline = false;

str;

case TId("var"):

var str = parseStructure("var"); // inline var

nextIsInline = false;

str;

case TId("final"):

var str = parseStructure("final"); // inline final

nextIsInline = false;

str;

case TId("class"):

var str = parseStructure("class"); // inline class

nextIsInline = false;

str;

case TId("private"): // inline private

var str = parseStructure("private"); // inline private

nextIsInline = false;

str;

default:

unexpected(nextToken);

nextIsInline = false;

null;

}

case "var" | "final":

if(id == "final") {

var nextToken = token();

switch(nextToken) {

case TId("class"):

nextIsFinal = true;

var str = parseStructure("class"); // final class

nextIsFinal = false;

return str;

case TId("function"):

nextIsFinal = true;

var str = parseStructure("function"); // final function

nextIsFinal = false;

return str;

default:

push(nextToken);

}

}

var ident = getIdent();

var get = ADefault, set = ADefault;

var hasGetSet:Bool = false;

var tk = token();

if( tk == TPOpen) {

if( id == "final" )

unexpected(tk);

var getId = getIdent();

switch (getId) {

case 'default': // Do nothing

case 'get': get = AGet;

case 'null': get = ANull;

case 'dynamic': get = ADynamic;

case 'never': get = ANever;

default: error(ECustom("Custom property accessor is not supported"), p1, tokenMax);

}

ensure(TComma);

var setId = getIdent();

switch (setId) {

case 'default': // Do nothing

case 'set': set = ASet;

case 'null': set = ANull;

case 'dynamic': set = ADynamic;

case 'never': set = ANever;

default: error(ECustom("Custom property accessor is not supported"), p1, tokenMax);

}

ensure(TPClose);

hasGetSet = true;

tk = token();

}

var t = null;

nextType = null;

if( tk == TDoubleDot && allowTypes ) {

t = parseType();

tk = token();

nextType = t;

}

var e = null;

if( Type.enumEq(tk,TOp("=")) )

e = parseExpr();

else

push(tk);

if(hasGetSet)

checkAccess(get, set, e, t);

nextType = null;

mk(EVar(ident, t, e, nextIsPublic, nextIsStatic, nextIsPrivate, id == "final", nextIsInline, get, set), p1, (e == null) ? tokenMax : pmax(e));

case "while":

var econd = parseExpr();

var e = parseExpr();

mk(EWhile(econd,e),p1,pmax(e));

case "do":

var e = parseExpr();

var tk = token();

switch(tk)

{

case TId("while"): // Valid

default: unexpected(tk);

}

var econd = parseExpr();

mk(EDoWhile(econd,e),p1,pmax(econd));

case "for":

ensure(TPOpen);

var ithv:String = null;

var vname = getIdent();

var tk = token();

if( Type.enumEq(tk,TOp("=>")) ) {

var old = vname;

vname = getIdent();

ithv = old;

} else {

push(tk);

}

ensureToken(TId("in"));

var eiter = parseExpr();

ensure(TPClose);

var e = parseExpr();

mk(EFor(vname,eiter,e,ithv),p1,pmax(e));

case "break": mk(EBreak);

case "continue": mk(EContinue);

case "else": unexpected(TId(id));

//case "inline":

// if( !maybe(TId("function")) ) unexpected(TId("inline"));

// return parseStructure("function");

case "function":

var tk = token();

var name = null;

switch( tk ) {

case TId(id): name = id;

default: push(tk);

}

var inf = parseFunctionDecl();

var tk = token();

push(tk);

mk(EFunction(inf.args, inf.body, name, inf.ret, nextIsPublic, nextIsStatic, nextIsOverride, nextIsPrivate, nextIsFinal, nextIsInline),p1,pmax(inf.body));

case "package":

// ignore package

var tk = token();

push(tk);

packageName = "";

if (tk == TSemicolon)

return mk(EIgnore(false));

var path = parsePath();

// mk(EPackage(path.join(".")));

packageName = path.join(".");

mk(EIgnore(false));

case "import":

var oldReadPos = readPos;

var tk = token();

switch( tk ) {

case TPOpen:

var tok = token();

switch(tok) {

case TConst(c):

switch(c) {

case CString(s):

token();

ensure(TSemicolon);

push(TSemicolon);

mk(EImport(s), p1);

default:

unexpected(tok);

null;

}

default:

unexpected(tok);

null;

}

case TId(id):

var path = [id];

var asname:String = null;

var t = null;

while( true ) {