package hscript;

import hscript.Expr;

enum VarMode {

Defined;

ForceSync;

}

class Async {

var definedVars : Array<{ n : String, prev : Null<VarMode> }>;

var vars : Map<String,VarMode>;

var currentFun : String;

var currentLoop : Expr;

var currentBreak : Expr -> Expr;

var uid = 0;

public var asyncIdents : Map<String,Bool>;

static var nullExpr : Expr = #if hscriptPos { e : null, pmin : 0, pmax : 0, origin : "<null>", line : 0 } #else null #end;

static var nullId = mk(EIdent("null"), nullExpr);

inline static function expr( e : Expr ) {

return #if hscriptPos e.e #else e #end;

}

inline static function mk( e, inf : Expr ) : Expr {

return #if hscriptPos { e : e, pmin : inf.pmin, pmax : inf.pmax, origin : inf.origin, line : inf.line } #else e #end;

}

/**

public static function toAsync( e : Expr, topLevelSync = false ) {

var a = new Async();

return a.build(e, topLevelSync);

}

public dynamic function getTopLevelEnd() {

return ignore();

}

public function build( e : Expr, topLevelSync = false ) {

if( topLevelSync ) {

return buildSync(e,null);

} else {

var end = getTopLevelEnd();

return toCps(e, end, end);

}

}

function defineVar( v : String, mode ) {

definedVars.push({ n : v, prev : vars.get(v) });

vars.set(v, mode);

}

function lookupFunctions( el : Array<Expr> ) {

for( e in el )

switch( expr(e) ) {

case EFunction(_, _, name, _) if( name != null ): defineVar(name, Defined);

case EMeta("sync",_,expr(_) => EFunction(_,_,name,_)) if( name != null ): defineVar(name, ForceSync);

default:

}

}

function buildSync( e : Expr, exit : Expr ) : Expr {

switch( expr(e) ) {

case EFunction(_,_,name,_):

if( name != null )

return toCps(e, null, null);

return e;

case EBlock(el):

var v = saveVars();

lookupFunctions(el);

var e = block([for(e in el) buildSync(e,exit)], e);

restoreVars(v);

return e;

case EMeta("async", _, e):

return toCps(e, ignore(), ignore());

case EMeta("sync", args, ef = expr(_) => EFunction(fargs, body, name, ret)):

return mk(EMeta("sync",args,mk(EFunction(fargs, buildSync(body,null), name, ret),ef)),e);

case EBreak if( currentBreak != null ):

return currentBreak(e);

case EContinue if( currentLoop != null ):

return block([retNull(currentLoop, e), mk(EReturn(),e)],e);

case EFor(_), EWhile(_):

var oldLoop = currentLoop, oldBreak = currentBreak;

currentLoop = null;

currentBreak = null;

e = Tools.map(e, buildSync.bind(_, exit));

currentLoop = oldLoop;

currentBreak = oldBreak;

return e;

case EReturn(eret) if( exit != null ):

return block([eret == null ? retNull(exit, e) : call(exit,[eret], e), mk(EReturn(),e)], e);

default:

return Tools.map(e, buildSync.bind(_, exit));

}

}

public function new() {

vars = new Map();

definedVars = [];

}

function ignore(?e) : Expr {

var inf = e == null ? nullExpr : e;

return fun("_", block(e == null ? [] : [e],inf));

}

inline function ident(str, e) {

return mk(EIdent(str), e);

}

inline function fun(arg:String, e, ?name) {

return mk(EFunction([{ name : arg, t : null, opt: false, value: null }], e, name), e);

}

inline function funs(arg:Array<String>, e, ?name) {

return mk(EFunction([for( a in arg ) { name : a, t : null, opt: false, value: null }], e, name), e);

}

inline function block(arr:Array<Expr>, e) {

if( arr.length == 1 && expr(arr[0]).match(EBlock(_)) )

return arr[0];

return mk(EBlock(arr), e);

}

inline function field(e, f, inf) {

return mk(EField(e, f), inf);

}

inline function binop(op, e1, e2, inf) {

return mk(EBinop(op, e1, e2), inf);

}

inline function call(e, args, inf) {

return mk(ECall(e, args), inf);

}

function retNull(e:Expr,?pos) : Expr {

switch( expr(e) ) {

case EFunction([{name:"_"}], e, _, _): return e;

default:

}

return call(e, [nullId], pos == null ? e : pos);

}

function makeCall( ecall, args : Array<Expr>, rest : Expr, exit, sync = false ) {

var names = [for( i in 0...args.length ) "_a"+uid++];

var rargs = [for( i in 0...args.length ) ident(names[i],ecall)];

if( !sync )

rargs.unshift(rest);

var rest = mk(sync ? ECall(rest,[call(ecall, rargs,ecall)]) : ECall(ecall, rargs), ecall);

var i = args.length - 1;

while( i >= 0 ) {

rest = toCps(args[i], fun(names[i], rest), exit);

i--;

}

return rest;

}

var syncFlag : Bool;

function isSync( e : Expr ) {

syncFlag = true;

checkSync(e);

return syncFlag;

}

inline function isAsyncIdent( id : String ) {

return asyncIdents == null || asyncIdents.exists(id);

}

function checkSync( e : Expr ) {

if( !syncFlag )

return;

switch( expr(e) ) {

case ECall(expr(_) => EIdent(i),_) if( isAsyncIdent(i) || vars.get(i) == Defined ):

syncFlag = false;

case ECall(expr(_) => EField(_,i),_) if( isAsyncIdent(i) ):

syncFlag = false;

case EFunction(_,_,name,_) if( name != null ):

syncFlag = false;

case EMeta("sync" | "async", _, _):

// isolated from the sync part

default:

Tools.iter(e, checkSync);

}

}

function saveVars() {

return definedVars.length;

}

function restoreVars(k) {

while( definedVars.length > k ) {

var v = definedVars.pop();

if( v.prev == null ) vars.remove(v.n) else vars.set(v.n, v.prev);

}

}

public function toCps( e : Expr, rest : Expr, exit : Expr ) : Expr {

if( isSync(e) )

return call(rest, [buildSync(e, exit)],e);

switch( expr(e) ) {

case EBlock(el):

var el = el.copy();

var vold = saveVars();

lookupFunctions(el);

while( el.length > 0 ) {

var e = toCps(el.pop(), rest, exit);

rest = ignore(e);

}

restoreVars(vold);

return retNull(rest);

case EFunction(args, body, name, t):

var vold = saveVars();

if( name != null )

defineVar(name, Defined);

for( a in args )

defineVar(a.name, Defined);

args.unshift( { name : "_onEnd", t : null, opt: false, value: null } );

var frest = ident("_onEnd",e);

var oldFun = currentFun;

currentFun = name;

var body = toCps(body, frest, frest);

var f = mk(EFunction(args, body, name, t),e);

restoreVars(vold);

return rest == null ? f : call(rest, [f],e);

case EParent(e):

return mk(EParent(toCps(e, rest, exit)),e);

case EMeta("sync", _, e):

return call(rest,[buildSync(e,exit)],e);

case EMeta("async", _, e):

var nothing = ignore();

return block([toCps(e,nothing,nothing),retNull(rest)],e);

case EMeta("split", _, e):

var args = switch( expr(e) ) { case EArrayDecl(el): el; default: throw "@split expression should be an array"; };

var args = [for( a in args ) fun("_rest", toCps(block([a],a), ident("_rest",a), exit))];

return call(ident("split",e), [rest, mk(EArrayDecl(args),e)],e);

case ECall(expr(_) => EIdent(i), args):

var mode = vars.get(i);

return makeCall( ident( mode != null ? i : "a_" + i,e) , args, rest, exit, mode == ForceSync);

case ECall(expr(_) => EField(e, f), args):

return makeCall(field(e,"a_"+f,e), args, rest, exit);

case EFor(v, eit, eloop):

var id = ++uid;

var it = ident("_i" + id,e);

var oldLoop = currentLoop, oldBreak = currentBreak;

var loop = ident("_loop" + id,e);

currentLoop = loop;

currentBreak = function(inf) return block([retNull(rest, inf), mk(EReturn(),inf)], inf);

var efor = block([

mk(EVar("_i" + id, call(ident("makeIterator",eit),[eit],eit)),eit),

fun("_", block([

mk(EIf(mk(EUnop("!", true, call( field(it, "hasNext", it), [], it)),it), currentBreak(it)),it),

mk(EVar(v, call(field(it, "next",it), [], it)), it),

toCps(eloop, loop, exit),

], it),"_loop" + id),

retNull(loop, e),

], e);

currentLoop = oldLoop;

currentBreak = oldBreak;

return efor;

case EUnop(op = "!", prefix, eop):

return toCps(eop, fun("_r",call(rest, [mk(EUnop(op, prefix, ident("_r",e)),e)], e)), exit);

case EBinop(op, e1, e2):

switch( op ) {

case "=", "+=", "-=", "/=", "*=", "%=", "&=", "|=", "^=":

switch( expr(e1) ) {

case EIdent(_):

var id = "_r" + uid++;

return toCps(e2, fun(id, call(rest, [binop(op, e1, ident(id,e1),e1)], e1)), exit);

case EField(ef1, f):

var id1 = "_r" + uid++;

var id2 = "_r" + uid++;

return toCps(ef1, fun(id1, toCps(e2, fun(id2, call(rest, [binop(op, field(ident(id1, e1), f, ef1), ident(id2, e2), e)], e)), exit)), exit);

case EArray(earr, eindex):

var idArr = "_r" + uid++;

var idIndex = "_r" + uid++;

var idVal = "_r" + uid++;

return toCps(earr,fun(idArr, toCps(eindex, fun(idIndex, toCps(e2,

fun(idVal, call(rest, [binop(op, mk(EArray(ident(idArr,earr), ident(idIndex,eindex)),e1), ident(idVal,e1), e)], e))

, exit)), exit)),exit);

default:

throw "assert " + e1;

}

case "||":

var id1 = "_r" + uid++;

var id2 = "_r" + uid++;

return toCps(e1, fun(id1, mk(EIf(binop("==", ident(id1,e1), ident("true",e1), e1),call(rest,[ident("true",e1)],e1),toCps(e2, rest, exit)),e)), exit);

case "&&":

var id1 = "_r" + uid++;

var id2 = "_r" + uid++;

return toCps(e1, fun(id1, mk(EIf(binop("!=", ident(id1,e1), ident("true",e1), e1),call(rest,[ident("false",e1)],e1),toCps(e2, rest, exit)),e)), exit);

default:

var id1 = "_r" + uid++;

var id2 = "_r" + uid++;

return toCps(e1, fun(id1, toCps(e2, fun(id2, call(rest, [binop(op, ident(id1,e1), ident(id2,e2), e)], e)), exit)), exit);

}

case EIf(cond, e1, e2), ETernary(cond, e1, e2):

return toCps(cond, fun("_c", mk(EIf(ident("_c",cond), toCps(e1, rest, exit), e2 == null ? retNull(rest) : toCps(e2, rest, exit)),e)), exit);

case EWhile(cond, ewh):

var id = ++uid;

var loop = ident("_loop" + id, cond);

var oldLoop = currentLoop, oldBreak = currentBreak;

currentLoop = loop;

currentBreak = function(e) return block([retNull(rest,e), mk(EReturn(),e)],e);

var ewhile = block([

fun("_r",

toCps(cond, fun("_c", mk(EIf(ident("_c", cond), toCps(ewh, loop, exit), retNull(rest,cond)),cond)), exit)

, "_loop"+id),

retNull(loop, cond),

],e);

currentLoop = oldLoop;

currentBreak = oldBreak;

return ewhile;

case EReturn(eret):

return eret == null ? retNull(exit, e) : toCps(eret, exit, exit);

case EObject(fields):

var id = "_o" + uid++;

var rest = call(rest, [ident(id,e)], e);

fields.reverse();

for( f in fields )

rest = toCps(f.e, fun("_r", block([

binop("=", mk(EField(ident(id,f.e), f.name),f.e), ident("_r",f.e), f.e),

rest,

],f.e)),exit);

return block([

mk(EVar(id, mk(EObject([]),e)),e),

rest,

],e);

case EArrayDecl(el):

var id = "_a" + uid++;

var rest = call(rest, [ident(id,e)], e);

var i = el.length - 1;

while( i >= 0 ) {

var e = el[i];

rest = toCps(e, fun("_r", block([

binop("=", mk(EArray(ident(id,e), mk(EConst(CInt(i)),e)),e), ident("_r",e), e),

rest,

],e)), exit);

i--;

}

return block([

mk(EVar(id, mk(EArrayDecl([]),e)),e),

rest,

],e);

case EArray(earr, eindex):

var id1 = "_r" + uid++;

var id2 = "_r" + uid++;

return toCps(earr, fun(id1, toCps(eindex, fun(id2, call(rest, [mk(EArray(ident(id1,e), ident(id2,e)),e)], e)), exit)), exit);

case EVar(v, t, ev):

if( ev == null )

return block([e, retNull(rest, e)], e);

return block([

mk(EVar(v, t),e),

toCps(ev, fun("_r", block([binop("=", ident(v,e), ident("_r",e), e), retNull(rest,e)], e)), exit),

],e);

case EConst(_), EIdent(_), EUnop(_), EField(_):

return call(rest, [e], e);

case ENew(cl, args):

var names = [for( i in 0...args.length ) "_a"+uid++];

var rargs = [for( i in 0...args.length ) ident(names[i], args[i])];

var rest = call(rest,[mk(ENew(cl, rargs),e)],e);

var i = args.length - 1;

while( i >= 0 ) {

rest = toCps(args[i], fun(names[i], rest), exit);

i--;

}

return rest;

case EBreak:

if( currentBreak == null ) throw "Break outside loop";

return currentBreak(e);

case EContinue:

if( currentLoop == null ) throw "Continue outside loop";

return block([retNull(currentLoop, e), mk(EReturn(),e)], e);

case ESwitch(v, cases, def):

var cases:Array<SwitchCase> = [for( c in cases ) { values : c.values, expr : toCps(c.expr, rest, exit) } ];

return toCps(v, mk(EFunction([ { name : "_c", t : null, opt: false, value: null } ], mk(ESwitch(ident("_c",v), cases, def == null ? retNull(rest) : toCps(def, rest, exit)),e)),e), exit );

case EThrow(v):

return toCps(v, mk(EFunction([ { name : "_v", t : null, opt: false, value: null } ], mk(EThrow(v),v)), v), exit);

case EMeta(name,_,e) if( name.charCodeAt(0) == ":".code ): // ignore custom ":" metadata

return toCps(e, rest, exit);

//case EDoWhile(_), ETry(_), ECall(_):

default:

throw "Unsupported async expression " + Printer.toString(e);

}

}

}

class AsyncInterp extends Interp {

public function setContext( api : Dynamic ) {

var funs = [];

for( v in variables.keys() )

if( Reflect.isFunction(variables.get(v)) )

funs.push({ v : v, obj : null });

variables.set("split", split);

variables.set("makeIterator", makeIterator);

var c = Type.getClass(api);

for( f in (c == null ? Reflect.fields(api) : Type.getInstanceFields(c)) ) {

var fv = Reflect.field(api, f);

if( !Reflect.isFunction(fv) ) continue;

if( f.charCodeAt(0) == "_".code ) f = f.substr(1);

variables.set(f, fv);

// create the async wrapper if doesn't exists

if( f.substr(0, 2) != "a_" )

funs.push({ v : f, obj : api });

}

for( v in funs ) {

if( variables.exists("a_" + v.v) ) continue;

var fv : Dynamic = variables.get(v.v);

var obj = v.obj;

variables.set("a_" + v.v, Reflect.makeVarArgs(function(args:Array<Dynamic>) {

var onEnd = args.shift();

onEnd(Reflect.callMethod(obj, fv, args));

}));

}

}

public function hasMethod( name : String ) {

var v = variables.get(name);

return v != null && Reflect.isFunction(v);

}

public function callValue( value : Dynamic, args : Array<Dynamic>, ?onResult : Dynamic -> Void, ?vthis : {} ) {

var oldThis = variables.get("this");

if( vthis != null )

variables.set("this", vthis);

if( onResult == null )

onResult = function(_) {};

args.unshift(onResult);

Reflect.callMethod(null, value, args);

variables.set("this", oldThis);

}

public function callAsync( id : String, args, ?onResult, ?vthis : {} ) {

var v = variables.get(id);

if( v == null )

throw "Missing function " + id + "()";

callValue(v, args, onResult, vthis);

}

function split( rest : Dynamic -> Void, args : Array<Dynamic> ) {

if( args.length == 0 )

rest(null);

else {

var count = args.length;

function next(_) {

if( --count == 0 ) rest(null);

}

for( a in args )

a(next);

}

}

override function fcall( o : Dynamic, f : String, args : Array<Dynamic> ) : Dynamic {

var m = Reflect.field(o, f);

if( m == null ) {

if( f.substr(0, 2) == "a_" ) {

m = Reflect.field(o, f.substr(2));

// fallback on sync version

if( m != null ) {

var onEnd = args.shift();

onEnd(call(o, m, args));

return null;

}

// fallback on generic script

m = Reflect.field(o, "scriptCall");

if( m != null ) {

call(o, m, [args.shift(), f.substr(2), args]);

return null;

}

} else {

// fallback on generic script

m = Reflect.field(o, "scriptCall");

if( m != null ) {

var result : Dynamic = null;

call(o, m, [function(r) result = r, f, args]);

return result;

}

}

error(ECustom(o + " has no method " + f));

}

return call(o, m, args);

}

}