Jaime Humberto Macias Bustamante
1bcbce2d5b
Also, it parses 'dynamic'. Still working on getter/setter for variables
2081 lines
59 KiB
Haxe
2081 lines
59 KiB
Haxe
/*
|
|
* Copyright (C)2008-2017 Haxe Foundation
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
/*
|
|
* YoshiCrafter Engine fixes:
|
|
* - Added Error handler
|
|
* - Added Imports
|
|
* - Added @:bypassAccessor
|
|
*/
|
|
package hscript;
|
|
|
|
import hscript.proxy.ProxyType;
|
|
import hscript.Tools.EnumValue;
|
|
import hscript.Tools.HScriptEnum;
|
|
import haxe.Constraints.Function;
|
|
import hscript.utils.UsingHandler;
|
|
import hscript.customclass.CustomClassDecl;
|
|
import hscript.customclass.CustomClass;
|
|
import hscript.utils.UsingEntry;
|
|
import haxe.CallStack;
|
|
import hscript.utils.UnsafeReflect;
|
|
import haxe.PosInfos;
|
|
import hscript.Expr;
|
|
import haxe.Constraints.IMap;
|
|
import Type.ValueType;
|
|
|
|
using StringTools;
|
|
|
|
private enum Stop {
|
|
SBreak;
|
|
SContinue;
|
|
SReturn;
|
|
}
|
|
|
|
enum abstract ScriptObjectType(UInt8) {
|
|
var SClass;
|
|
var SObject;
|
|
var SStaticClass;
|
|
//var SCustomClass; // custom classes
|
|
var SBehaviourClass; // hget and hset
|
|
var SAccessBehaviourObject; // hget and hset with __allowSetGet
|
|
var SNull;
|
|
}
|
|
|
|
@:structInit
|
|
class DeclaredVar {
|
|
public var r:Dynamic;
|
|
public var depth:Int;
|
|
public var isFinal:Null<Bool> = null;
|
|
// TODO: getter/setter for variables
|
|
public var getter:Null<FieldPropertyAccess> = null;
|
|
public var setter:Null<FieldPropertyAccess> = null;
|
|
}
|
|
|
|
@:structInit
|
|
class RedeclaredVar {
|
|
public var n:String;
|
|
public var old:DeclaredVar;
|
|
public var depth:Int;
|
|
}
|
|
|
|
@:access(hscript.customclass.CustomClass)
|
|
@:access(hscript.customclass.CustomClassDecl)
|
|
@:analyzer(optimize, local_dce, fusion, user_var_fusion)
|
|
class Interp {
|
|
private static var _customClasses:Map<String, CustomClassDecl> = new Map<String, CustomClassDecl>();
|
|
private static var _customClassAliases:Map<String, String> = new Map<String, String>();
|
|
|
|
public static function getCustomClass(name:String) {
|
|
// Retrieves the real class name
|
|
var realName = _customClassAliases.get(name);
|
|
if(realName != null) name = realName;
|
|
return _customClasses.get(name);
|
|
}
|
|
|
|
public static function customClassExist(name:String):Bool {
|
|
return _customClassAliases.exists(name) || _customClasses.exists(name);
|
|
}
|
|
|
|
private static function registerCustomClass(c:CustomClassDecl, ?as:String, ?inCustomClass:Bool) {
|
|
#if CUSTOM_CLASSES
|
|
var name = c.classDecl.name;
|
|
if (c.pkg != null && (inCustomClass != null && inCustomClass)) {
|
|
name = '${c.pkg.join(".")}.$name';//c.pkg.join(".") + "." + name;
|
|
}
|
|
if (as != null) _customClassAliases.set(as, name);
|
|
_customClasses.set(name, c);
|
|
#end
|
|
}
|
|
|
|
public var scriptObject(default, set):Dynamic;
|
|
private var _hasScriptObject(default, null):Bool = false;
|
|
private var _scriptObjectType(default, null):ScriptObjectType = SNull;
|
|
public function set_scriptObject(v:Dynamic) {
|
|
switch(Type.typeof(v)) {
|
|
case TClass(c): // Class Access
|
|
__instanceFields = Type.getInstanceFields(c);
|
|
if(v is IHScriptCustomAccessBehaviour) {
|
|
_scriptObjectType = SAccessBehaviourObject;
|
|
} else if(v is IHScriptCustomBehaviour) {
|
|
_scriptObjectType = SBehaviourClass;
|
|
} else {
|
|
_scriptObjectType = SClass;
|
|
}
|
|
case TObject: // Object Access or Static Class Access
|
|
var cls = Type.getClass(v);
|
|
switch(Type.typeof(cls)) {
|
|
case TClass(c): // Static Class Access
|
|
__instanceFields = Type.getInstanceFields(c);
|
|
_scriptObjectType = SStaticClass;
|
|
default: // Object Access
|
|
__instanceFields = Reflect.fields(v);
|
|
_scriptObjectType = SObject;
|
|
}
|
|
default: // Null or other
|
|
__instanceFields = [];
|
|
_scriptObjectType = SNull;
|
|
}
|
|
_hasScriptObject = v != null;
|
|
return scriptObject = v;
|
|
}
|
|
public var errorHandler:Error->Void;
|
|
public var importFailedCallback:Array<String> -> ?Null<String> -> Bool;
|
|
|
|
public var customClasses:Map<String, Dynamic>;
|
|
public var variables:Map<String, Dynamic>;
|
|
public var publicVariables:Map<String, Dynamic>;
|
|
public var staticVariables:Map<String, Dynamic>;
|
|
|
|
// warning can be null
|
|
public var locals:Map<String, DeclaredVar>;
|
|
var binops:Map<String, Expr->Expr->Dynamic>;
|
|
|
|
var depth:Int = 0;
|
|
var inTry:Bool;
|
|
var declared:Array<RedeclaredVar>;
|
|
var returnValue:Dynamic;
|
|
|
|
var isBypassAccessor:Bool = false;
|
|
var isPrivateAccess:Bool = false;
|
|
//var isVar:Bool = false;
|
|
|
|
public var importEnabled:Bool = true;
|
|
|
|
public var allowStaticVariables:Bool = false;
|
|
public var allowPublicVariables:Bool = false;
|
|
|
|
public var importBlocklist:Array<String> = [
|
|
// "flixel.FlxG"
|
|
];
|
|
|
|
var __instanceFields:Array<String> = [];
|
|
#if hscriptPos
|
|
var curExpr:Expr;
|
|
#end
|
|
|
|
var _proxy(default, null):Null<CustomClass> = null; // Like "scriptObject" but for Custom Classes
|
|
var _nextCallObject(default, null):Dynamic = null;
|
|
var _inCustomClass(get, never):Bool;
|
|
|
|
private function get__inCustomClass():Bool {
|
|
return _proxy != null;
|
|
}
|
|
|
|
public function new(?proxy:CustomClass) {
|
|
locals = new Map();
|
|
declared = [];
|
|
resetVariables();
|
|
initOps();
|
|
|
|
this._proxy = proxy;
|
|
}
|
|
|
|
private function resetVariables():Void {
|
|
//customClasses = new Map<String, Dynamic>();
|
|
variables = new Map<String, Dynamic>();
|
|
publicVariables = new Map<String, Dynamic>();
|
|
staticVariables = new Map<String, Dynamic>();
|
|
variables.set("null", null);
|
|
variables.set("true", true);
|
|
variables.set("false", false);
|
|
variables.set("trace", Reflect.makeVarArgs(function(el) {
|
|
var inf = posInfos();
|
|
var v = el.shift();
|
|
if (el.length > 0)
|
|
inf.customParams = el;
|
|
haxe.Log.trace(Std.string(v), inf);
|
|
}));
|
|
}
|
|
|
|
public function posInfos():PosInfos {
|
|
#if hscriptPos
|
|
if (curExpr != null)
|
|
return cast {fileName: curExpr.origin, lineNumber: curExpr.line};
|
|
#end
|
|
return cast {fileName: "hscript", lineNumber: 0};
|
|
}
|
|
|
|
function initOps():Void {
|
|
var me = this;
|
|
binops = new Map();
|
|
binops.set("+", function(e1, e2) return me.expr(e1) + me.expr(e2));
|
|
binops.set("-", function(e1, e2) return me.expr(e1) - me.expr(e2));
|
|
binops.set("*", function(e1, e2) return me.expr(e1) * me.expr(e2));
|
|
binops.set("/", function(e1, e2) return me.expr(e1) / me.expr(e2));
|
|
binops.set("%", function(e1, e2) return me.expr(e1) % me.expr(e2));
|
|
binops.set("&", function(e1, e2) return me.expr(e1) & me.expr(e2));
|
|
binops.set("|", function(e1, e2) return me.expr(e1) | me.expr(e2));
|
|
binops.set("^", function(e1, e2) return me.expr(e1) ^ me.expr(e2));
|
|
binops.set("<<", function(e1, e2) return me.expr(e1) << me.expr(e2));
|
|
binops.set(">>", function(e1, e2) return me.expr(e1) >> me.expr(e2));
|
|
binops.set(">>>", function(e1, e2) return me.expr(e1) >>> me.expr(e2));
|
|
binops.set("==", function(e1, e2) return me.expr(e1) == me.expr(e2));
|
|
binops.set("!=", function(e1, e2) return me.expr(e1) != me.expr(e2));
|
|
binops.set(">=", function(e1, e2) return me.expr(e1) >= me.expr(e2));
|
|
binops.set("<=", function(e1, e2) return me.expr(e1) <= me.expr(e2));
|
|
binops.set(">", function(e1, e2) return me.expr(e1) > me.expr(e2));
|
|
binops.set("<", function(e1, e2) return me.expr(e1) < me.expr(e2));
|
|
binops.set("||", function(e1, e2) return me.expr(e1) == true || me.expr(e2) == true);
|
|
binops.set("&&", function(e1, e2) return me.expr(e1) == true && me.expr(e2) == true);
|
|
binops.set("is", checkIsType);
|
|
binops.set("=", assign);
|
|
binops.set("??", function(e1, e2) {
|
|
var expr1:Dynamic = me.expr(e1);
|
|
return expr1 == null ? me.expr(e2) : expr1;
|
|
});
|
|
binops.set("...", function(e1, e2) return new IntIterator(me.expr(e1), me.expr(e2)));
|
|
assignOp("+=", function(v1:Dynamic, v2:Dynamic) return v1 + v2);
|
|
assignOp("-=", function(v1:Float, v2:Float) return v1 - v2);
|
|
assignOp("*=", function(v1:Float, v2:Float) return v1 * v2);
|
|
assignOp("/=", function(v1:Float, v2:Float) return v1 / v2);
|
|
assignOp("%=", function(v1:Float, v2:Float) return v1 % v2);
|
|
assignOp("&=", function(v1, v2) return v1 & v2);
|
|
assignOp("|=", function(v1, v2) return v1 | v2);
|
|
assignOp("^=", function(v1, v2) return v1 ^ v2);
|
|
assignOp("<<=", function(v1, v2) return v1 << v2);
|
|
assignOp(">>=", function(v1, v2) return v1 >> v2);
|
|
assignOp(">>>=", function(v1, v2) return v1 >>> v2);
|
|
assignOp("??" + "=", function(v1, v2) return v1 == null ? v2 : v1);
|
|
}
|
|
|
|
function checkIsType(e1:Expr,e2:Expr): Bool {
|
|
var expr1:Dynamic = expr(e1);
|
|
|
|
return switch(Tools.expr(e2))
|
|
{
|
|
// TODO: type check for custom classes
|
|
case EIdent("Class"):
|
|
Std.isOfType(expr1, Class);
|
|
case EIdent("Map") | EIdent("IMap"):
|
|
Std.isOfType(expr1, IMap);
|
|
default:
|
|
var expr2:Dynamic = expr(e2);
|
|
expr2 != null ? Std.isOfType(expr1, expr2) : false;
|
|
}
|
|
}
|
|
|
|
public function varExists(name:String):Bool {
|
|
return allowStaticVariables && staticVariables.exists(name) || allowPublicVariables && publicVariables.exists(name) || variables.exists(name);
|
|
}
|
|
|
|
public function setVar(name:String, v:Dynamic):Void {
|
|
if (_inCustomClass && _proxy.superClass != null) {
|
|
if (_proxy.superHasField(name)) {
|
|
if (_proxy.superIsCustomClass) {
|
|
var oldPrivate = _proxy.__allowPrivateAccess;
|
|
_proxy.__allowPrivateAccess = true;
|
|
cast(_proxy.superClass, CustomClass).hset(name, v);
|
|
_proxy.__allowPrivateAccess = oldPrivate;
|
|
return;
|
|
}
|
|
|
|
Reflect.setProperty(_proxy.superClass, name, v);
|
|
return;
|
|
|
|
}
|
|
}
|
|
// Fallback to setting in local scope.
|
|
|
|
if (allowStaticVariables && staticVariables.exists(name))
|
|
staticVariables.set(name, v);
|
|
else if (allowPublicVariables && publicVariables.exists(name))
|
|
publicVariables.set(name, v);
|
|
else
|
|
variables.set(name, v);
|
|
}
|
|
|
|
function assign(e1:Expr, e2:Expr):Dynamic {
|
|
var v = expr(e2);
|
|
switch (Tools.expr(e1)) {
|
|
case EIdent(id):
|
|
// Make sure setting superclass/static fields directly works.
|
|
// Also ensures property functions are accounted for.
|
|
if (_inCustomClass) {
|
|
if (_proxy.__class.hasField(id)) {
|
|
var v = expr(e2);
|
|
_proxy.__class.hset(id, v);
|
|
return v;
|
|
}
|
|
|
|
if (_proxy.superClass == null && _proxy.__class.classDecl.extend != null && !_proxy.hasVar(id)) {
|
|
// Caches the declaration to set it once superClass is created
|
|
var v = expr(e2);
|
|
_proxy.cacheSuperField(id, v);
|
|
return v;
|
|
}
|
|
else if(_proxy.hasField(id) || _proxy.superHasField(id)){
|
|
try {
|
|
var v = expr(e2);
|
|
_proxy.hset(id, v); // superClass check already handled in Custom Class
|
|
return v;
|
|
}
|
|
catch(e) {}
|
|
}
|
|
}
|
|
// Fallback, which calls set()
|
|
var l = locals.get(id);
|
|
if (l == null) {
|
|
if (_hasScriptObject && !varExists(id)) {
|
|
var instanceHasField = __instanceFields.contains(id);
|
|
|
|
if (_scriptObjectType == SObject && instanceHasField) {
|
|
UnsafeReflect.setField(scriptObject, id, v);
|
|
return v;
|
|
}
|
|
else if(_scriptObjectType == SAccessBehaviourObject) {
|
|
var obj:IHScriptCustomAccessBehaviour = cast scriptObject;
|
|
var oldAccessor = obj.__allowSetGet;
|
|
var oldPrivate = obj.__allowPrivateAccess;
|
|
|
|
if (isBypassAccessor)
|
|
obj.__allowSetGet = false;
|
|
if (isPrivateAccess)
|
|
obj.__allowPrivateAccess = true;
|
|
|
|
var res = obj.hset(id, v);
|
|
|
|
obj.__allowSetGet = oldAccessor;
|
|
obj.__allowPrivateAccess = oldPrivate;
|
|
|
|
return res;
|
|
}
|
|
else if (_scriptObjectType == SBehaviourClass) {
|
|
var obj:IHScriptCustomBehaviour = cast scriptObject;
|
|
return obj.hset(id, v);
|
|
}
|
|
|
|
if (instanceHasField) {
|
|
if(isBypassAccessor) {
|
|
UnsafeReflect.setField(scriptObject, id, v);
|
|
return v;
|
|
} else {
|
|
UnsafeReflect.setProperty(scriptObject, id, v);
|
|
return UnsafeReflect.field(scriptObject, id);
|
|
}
|
|
} else if (__instanceFields.contains('set_$id')) { // setter
|
|
return UnsafeReflect.getProperty(scriptObject, 'set_$id')(v);
|
|
} else {
|
|
setVar(id, v);
|
|
}
|
|
} else {
|
|
setVar(id, v);
|
|
}
|
|
} else {
|
|
// TODO: call "set_" if available
|
|
l.r = v;
|
|
if (l.depth == 0) {
|
|
setVar(id, v);
|
|
}
|
|
}
|
|
// TODO
|
|
case EField(e, f, s):
|
|
if(_inCustomClass) {
|
|
switch (Tools.expr(e)) {
|
|
case EIdent(id0):
|
|
if (id0 == "this") {
|
|
if(_proxy.superClass == null && _proxy.__class.classDecl.extend != null && !_proxy.hasVar(f)){
|
|
// Caches the declaration to set it once superClass is created
|
|
var v = expr(e2);
|
|
_proxy.cacheSuperField(f, v);
|
|
return v;
|
|
}
|
|
else if (_proxy.hasField(f) || _proxy.superHasField(f)) {
|
|
try {
|
|
var v = expr(e2);
|
|
_proxy.hset(f, v);
|
|
return v;
|
|
}
|
|
catch(e){}
|
|
}
|
|
}
|
|
default:
|
|
// Do nothing
|
|
}
|
|
}
|
|
// Fallback, which calls set()
|
|
var obj = expr(e);
|
|
if(s && obj == null) return null;
|
|
v = set(obj, f, v);
|
|
case EArray(e, index):
|
|
var arr:Dynamic = expr(e);
|
|
var index:Dynamic = expr(index);
|
|
if (isMap(arr)) {
|
|
setMapValue(arr, index, v);
|
|
} else {
|
|
arr[index] = v;
|
|
}
|
|
|
|
default:
|
|
error(EInvalidOp("="));
|
|
}
|
|
return v;
|
|
}
|
|
|
|
function assignOp(op:String, fop:Dynamic->Dynamic->Dynamic):Void {
|
|
var me = this;
|
|
binops.set(op, function(e1, e2) return me.evalAssignOp(op, fop, e1, e2));
|
|
}
|
|
|
|
function evalAssignOp(op:String, fop:Dynamic->Dynamic->Dynamic, e1:Expr, e2:Expr):Dynamic {
|
|
var v;
|
|
switch (Tools.expr(e1)) {
|
|
case EIdent(id):
|
|
v = fop(expr(e1), expr(e2));
|
|
// Make sure setting superclass/static fields directly works.
|
|
// Also ensures property functions are accounted for.
|
|
if(_inCustomClass) {
|
|
if (_proxy.__class.hasField(id)) {
|
|
_proxy.__class.hset(id, v);
|
|
return v;
|
|
}
|
|
|
|
else if ((_proxy.superClass == null && _proxy.__class.classDecl.extend != null && !_proxy.hasVar(id))) {
|
|
_proxy.cacheSuperField(id, v);
|
|
return v;
|
|
}
|
|
else if (_proxy.hasField(id) || _proxy.superHasField(id)) {
|
|
try {
|
|
_proxy.hset(id, v); // superClass check already handled in Custom Class
|
|
return v;
|
|
}
|
|
catch(e) {}
|
|
}
|
|
}
|
|
var l = locals.get(id);
|
|
if (l == null) {
|
|
if(_hasScriptObject && !varExists(id)) {
|
|
var instanceHasField = __instanceFields.contains(id);
|
|
|
|
if (_scriptObjectType == SObject && instanceHasField) {
|
|
UnsafeReflect.setField(scriptObject, id, v);
|
|
return v;
|
|
}
|
|
else if(_scriptObjectType == SAccessBehaviourObject) {
|
|
var obj:IHScriptCustomAccessBehaviour = cast scriptObject;
|
|
|
|
var oldAccessor = obj.__allowSetGet;
|
|
var oldPrivate = obj.__allowPrivateAccess;
|
|
|
|
if (isBypassAccessor)
|
|
obj.__allowSetGet = false;
|
|
if (isPrivateAccess)
|
|
obj.__allowPrivateAccess = true;
|
|
|
|
var res = obj.hset(id, v);
|
|
|
|
obj.__allowSetGet = oldAccessor;
|
|
obj.__allowPrivateAccess = oldPrivate;
|
|
|
|
return res;
|
|
}
|
|
else if (_scriptObjectType == SBehaviourClass) {
|
|
var obj:IHScriptCustomBehaviour = cast scriptObject;
|
|
return obj.hset(id, v);
|
|
}
|
|
|
|
if (instanceHasField) {
|
|
if(isBypassAccessor) {
|
|
UnsafeReflect.setField(scriptObject, id, v);
|
|
return v;
|
|
} else {
|
|
UnsafeReflect.setProperty(scriptObject, id, v);
|
|
return UnsafeReflect.field(scriptObject, id);
|
|
}
|
|
} else if (__instanceFields.contains('set_$id')) { // setter
|
|
return UnsafeReflect.getProperty(scriptObject, 'set_$id')(v);
|
|
} else {
|
|
setVar(id, v);
|
|
}
|
|
} else {
|
|
setVar(id, v);
|
|
}
|
|
}
|
|
else {
|
|
var l = locals.get(id);
|
|
// TODO: call "set_" if available
|
|
l.r = v;
|
|
if (l.depth == 0) {
|
|
setVar(id, v);
|
|
}
|
|
}
|
|
case EField(e, f, s):
|
|
var obj = expr(e);
|
|
if(s && obj == null) return null;
|
|
|
|
if(_inCustomClass) {
|
|
switch(Tools.expr(e)) {
|
|
case EIdent(_id):
|
|
if (_id == 'this') {
|
|
if(_proxy.superClass == null && _proxy.__class.classDecl.extend != null && !_proxy.hasVar(f)){
|
|
// Caches the declaration to set it once superClass is created
|
|
v = fop(get(obj, f), expr(e2));
|
|
_proxy.cacheSuperField(f, v);
|
|
return v;
|
|
}
|
|
else if (_proxy.hasField(f) || _proxy.superHasField(f)) {
|
|
try {
|
|
v = fop(get(obj, f), expr(e2));
|
|
_proxy.hset(f, v); // superClass check already handled in Custom Class
|
|
return v;
|
|
}
|
|
catch(e) {}
|
|
}
|
|
}
|
|
default:
|
|
}
|
|
}
|
|
v = fop(get(obj, f), expr(e2));
|
|
v = set(obj, f, v);
|
|
case EArray(e, index):
|
|
var arr:Dynamic = expr(e);
|
|
var index:Dynamic = expr(index);
|
|
if (isMap(arr)) {
|
|
var map = getMap(arr);
|
|
|
|
v = fop(map.get(index), expr(e2));
|
|
map.set(index, v);
|
|
} else {
|
|
v = fop(arr[index], expr(e2));
|
|
arr[index] = v;
|
|
}
|
|
default:
|
|
return error(EInvalidOp(op));
|
|
}
|
|
return v;
|
|
}
|
|
|
|
function increment(e:Expr, prefix:Bool, delta:Int):Dynamic {
|
|
#if hscriptPos
|
|
curExpr = e;
|
|
var e = e.e;
|
|
#end
|
|
switch (e) {
|
|
case EIdent(id):
|
|
var l = locals.get(id);
|
|
// TODO: call "set_" if available
|
|
if(l != null) {
|
|
var v:Dynamic = l.r;
|
|
if (prefix) {
|
|
v += delta;
|
|
l.r = v;
|
|
} else
|
|
l.r = v + delta;
|
|
return v;
|
|
} else {
|
|
var v:Dynamic = resolve(id);
|
|
if (prefix) {
|
|
v += delta;
|
|
setVar(id, v);
|
|
} else
|
|
setVar(id, v + delta);
|
|
return v;
|
|
}
|
|
case EField(e, f, s):
|
|
var obj = expr(e);
|
|
if(s && obj == null) return null;
|
|
var v:Dynamic = get(obj, f);
|
|
if (prefix) {
|
|
v += delta;
|
|
set(obj, f, v);
|
|
} else
|
|
set(obj, f, v + delta);
|
|
return v;
|
|
case EArray(e, index):
|
|
var arr:Dynamic = expr(e);
|
|
var index:Dynamic = expr(index);
|
|
if (isMap(arr)) {
|
|
var map = getMap(arr);
|
|
|
|
var v = map.get(index);
|
|
if (prefix) {
|
|
v += delta;
|
|
map.set(index, v);
|
|
} else {
|
|
map.set(index, v + delta);
|
|
}
|
|
return v;
|
|
} else {
|
|
var v = arr[index];
|
|
if (prefix) {
|
|
v += delta;
|
|
arr[index] = v;
|
|
} else
|
|
arr[index] = v + delta;
|
|
return v;
|
|
}
|
|
default:
|
|
return error(EInvalidOp((delta > 0) ? "++" : "--"));
|
|
}
|
|
}
|
|
|
|
public function execute(expr:Expr):Dynamic {
|
|
depth = 0;
|
|
locals = new Map();
|
|
declared = [];
|
|
return exprReturn(expr);
|
|
}
|
|
|
|
public var printCallStack:Bool = false;
|
|
|
|
function exprReturn(e):Dynamic {
|
|
try {
|
|
try {
|
|
return expr(e);
|
|
} catch (e:Stop) {
|
|
switch (e) {
|
|
case SBreak:
|
|
throw "Invalid break";
|
|
case SContinue:
|
|
throw "Invalid continue";
|
|
case SReturn:
|
|
var v = returnValue;
|
|
returnValue = null;
|
|
return v;
|
|
}
|
|
} catch(e) {
|
|
if(printCallStack)
|
|
error(ECustom('${e.toString()}\n${CallStack.toString(CallStack.exceptionStack(true))}'));
|
|
else
|
|
error(ECustom(e.toString()));
|
|
return null;
|
|
}
|
|
} catch(e:Error) {
|
|
if (errorHandler != null)
|
|
errorHandler(e);
|
|
else
|
|
throw e;
|
|
return null;
|
|
} catch(e) {
|
|
trace(e);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function duplicate<T>(h:Map<String, T>) {
|
|
var h2 = new Map();
|
|
var keys = h.keys();
|
|
var _hasNext = keys.hasNext;
|
|
var _next = keys.next;
|
|
while (_hasNext()) {
|
|
var k = _next();
|
|
h2.set(k, h.get(k));
|
|
}
|
|
return h2;
|
|
}
|
|
|
|
function restore(old:Int):Void {
|
|
while (declared.length > old) {
|
|
var d = declared.pop();
|
|
locals.set(d.n, d.old);
|
|
}
|
|
}
|
|
|
|
public inline function error(e:#if hscriptPos ErrorDef #else Error #end, rethrow = false):Dynamic {
|
|
#if hscriptPos var e = new Error(e, curExpr.pmin, curExpr.pmax, curExpr.origin, curExpr.line); #end
|
|
|
|
if (rethrow) {
|
|
this.rethrow(e);
|
|
} else {
|
|
throw e;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
inline function rethrow(e:Dynamic):Void {
|
|
#if hl
|
|
hl.Api.rethrow(e);
|
|
#else
|
|
throw e;
|
|
#end
|
|
}
|
|
|
|
public function resolve(id:String, doException:Bool = true):Dynamic {
|
|
if (id == null)
|
|
return null;
|
|
id = StringTools.trim(id);
|
|
|
|
// Custom Class
|
|
if (_inCustomClass) {
|
|
_nextCallObject = null;
|
|
if (id == "super") {
|
|
if (_proxy.superClass == null) {
|
|
return _proxy.superConstructor;
|
|
} else {
|
|
return _proxy.superClass;
|
|
}
|
|
}
|
|
else if (id == "this")
|
|
return _proxy;
|
|
}
|
|
|
|
if (locals.exists(id)) {
|
|
var l = locals.get(id);
|
|
// TODO: call get or set if available.
|
|
if(l != null)
|
|
return l.r;
|
|
}
|
|
|
|
if(variables.exists(id))
|
|
return variables.get(id);
|
|
if(publicVariables.exists(id))
|
|
return publicVariables.get(id);
|
|
if(staticVariables.exists(id))
|
|
return staticVariables.get(id);
|
|
if(customClassExist(id))
|
|
return getCustomClass(id);
|
|
|
|
// Custom Class
|
|
if (_inCustomClass) {
|
|
// Static access
|
|
if (_proxy.__class.hasField(id)) {
|
|
var r = _proxy.__class.hget(id);
|
|
return r;
|
|
}
|
|
|
|
if (_proxy.hasVar(id)) {
|
|
var r = _proxy.hget(id);
|
|
return r;
|
|
}
|
|
// We are calling a LOCAL function from the same module.
|
|
// TODO: optimize this
|
|
if (_proxy.hasFunction(id)) {
|
|
_nextCallObject = _proxy;
|
|
return _proxy.hget(id);
|
|
}
|
|
if (_proxy.superHasField(id)) {
|
|
_nextCallObject = _proxy.superClass;
|
|
return !_proxy.superIsCustomClass ? Reflect.getProperty(_proxy.superClass, id) : _proxy.hget(id);
|
|
} else {
|
|
try {
|
|
var r = _proxy.hget(id);
|
|
_nextCallObject = _proxy;
|
|
return r;
|
|
} catch (e:Dynamic) {
|
|
if(doException)
|
|
error(EUnknownVariable(id));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (_hasScriptObject) {
|
|
// search in object
|
|
if (id == "this") {
|
|
return scriptObject;
|
|
}
|
|
var instanceHasField = __instanceFields.contains(id);
|
|
|
|
if (_scriptObjectType == SObject && instanceHasField) {
|
|
return UnsafeReflect.field(scriptObject, id);
|
|
}
|
|
else if(_scriptObjectType == SAccessBehaviourObject) {
|
|
var obj:IHScriptCustomAccessBehaviour = cast scriptObject;
|
|
|
|
var oldAccessor = obj.__allowSetGet;
|
|
var oldPrivate = obj.__allowPrivateAccess;
|
|
|
|
if (isBypassAccessor)
|
|
obj.__allowSetGet = false;
|
|
if (isPrivateAccess)
|
|
obj.__allowPrivateAccess = true;
|
|
|
|
var res = obj.hget(id);
|
|
|
|
obj.__allowSetGet = oldAccessor;
|
|
obj.__allowPrivateAccess = oldPrivate;
|
|
|
|
return res;
|
|
} else if(_scriptObjectType == SBehaviourClass) {
|
|
var obj:IHScriptCustomBehaviour = cast scriptObject;
|
|
return obj.hget(id);
|
|
}
|
|
|
|
if (instanceHasField) {
|
|
if(isBypassAccessor) {
|
|
return UnsafeReflect.field(scriptObject, id);
|
|
} else {
|
|
return UnsafeReflect.getProperty(scriptObject, id);
|
|
}
|
|
} else if (__instanceFields.contains('get_$id')) { // getter
|
|
return UnsafeReflect.getProperty(scriptObject, 'get_$id')();
|
|
}
|
|
}
|
|
if (doException)
|
|
error(EUnknownVariable(id));
|
|
return null;
|
|
}
|
|
|
|
// backwards compatibility
|
|
public static var importRedirects:Map<String, String> = new Map();
|
|
public static function getImportRedirect(className:String):String {
|
|
return importRedirects.exists(className) ? importRedirects.get(className) : className;
|
|
}
|
|
|
|
public var localImportRedirects:Map<String, String> = new Map();
|
|
public function getLocalImportRedirect(className:String):String {
|
|
var className = className;
|
|
if (InterpConfig.IMPORT_REDIRECTS.exists(className))
|
|
className = InterpConfig.IMPORT_REDIRECTS.get(className);
|
|
if (importRedirects.exists(className))
|
|
className = importRedirects.get(className);
|
|
if (localImportRedirects.exists(className))
|
|
className = localImportRedirects.get(className);
|
|
return className;
|
|
}
|
|
|
|
// Workaround for parsing custom classes if made inside of a script file
|
|
public var localImports:Map<String, CustomClassImport> = new Map();
|
|
public var localParsedClasses:Array<String> = []; // Prevents duplicated classes
|
|
public var newCustomClass:Bool = true; // Temporary
|
|
|
|
public function expr(e:Expr):Dynamic {
|
|
#if hscriptPos
|
|
curExpr = e;
|
|
var e = e.e;
|
|
#end
|
|
switch (e) {
|
|
case EIgnore(_):
|
|
case EClass(name, fields, extend, interfaces):
|
|
inline function importVar(thing:String):String {
|
|
if (thing == null)
|
|
return null;
|
|
final variable:Class<Any> = variables.exists(thing) ? cast variables.get(thing) : null;
|
|
return variable == null ? thing : Type.getClassName(variable);
|
|
}
|
|
|
|
if (localParsedClasses.contains(name))
|
|
error(EAlreadyExistingClass(name));
|
|
|
|
var customClassFields:Array<FieldDecl> = [];
|
|
for (f in fields) {
|
|
switch (Tools.expr(f)) {
|
|
case EFunction(args, e, name, ret, isPublic, isStatic, isOverride, isPrivate, isFinal, isInline):
|
|
var fnAcc:Array<FieldAccess> = [];
|
|
if (isPublic) fnAcc.push(APublic);
|
|
if (isStatic) fnAcc.push(AStatic);
|
|
if (isOverride) fnAcc.push(AOverride);
|
|
|
|
var fnd:FunctionDecl = {
|
|
args: args,
|
|
body: e,
|
|
ret: ret
|
|
};
|
|
var fd:FieldDecl = {
|
|
name: name,
|
|
meta: [],
|
|
kind: KFunction(fnd),
|
|
access: fnAcc
|
|
};
|
|
|
|
customClassFields.push(fd);
|
|
case EVar(n, t, e, isPublic, isStatic, _, isFinal, _, getter, setter):
|
|
var varAcc:Array<FieldAccess> = [];
|
|
if (isPublic) varAcc.push(APublic);
|
|
if (isStatic) varAcc.push(AStatic);
|
|
|
|
var vrd:VarDecl = {
|
|
get: getter,
|
|
set: setter,
|
|
expr: e,
|
|
type: t,
|
|
isFinal: isFinal
|
|
};
|
|
var fd:FieldDecl = {
|
|
name: n,
|
|
meta: [],
|
|
kind: KVar(vrd),
|
|
access: varAcc
|
|
};
|
|
|
|
customClassFields.push(fd);
|
|
default:
|
|
}
|
|
}
|
|
|
|
var extendPath:Null<CType> = extend != null ? CTPath(importVar(extend).split(".")) : null;
|
|
var interfacesPaths:Array<CType> = [for (i in interfaces) CTPath(importVar(i).split("."))];
|
|
|
|
var classDecl:ClassDecl = {
|
|
name: name,
|
|
params: {}, // TODO: make it parse and ignore it
|
|
meta: [],
|
|
isPrivate: false,
|
|
extend: extendPath,
|
|
implement: interfacesPaths,
|
|
fields: customClassFields,
|
|
isExtern: false,
|
|
};
|
|
|
|
var customClassDecl:CustomClassDecl = {
|
|
classDecl: classDecl,
|
|
imports: localImports, // TODO: better way to reuse imported classes
|
|
usings: [for(u in this.usings) u.name],
|
|
pkg: null,
|
|
ogInterp: this,
|
|
isInline: true
|
|
};
|
|
|
|
registerCustomClass(customClassDecl, null);
|
|
localParsedClasses.push(customClassDecl.classDecl.name);
|
|
case EImport(c, n):
|
|
if (!importEnabled)
|
|
return null;
|
|
var splitClassName = [for (e in c.split(".")) e.trim()];
|
|
var realClassName = splitClassName.join(".");
|
|
var claVarName = splitClassName[splitClassName.length - 1];
|
|
var toSetName = n != null ? n : claVarName;
|
|
var oldClassName = realClassName;
|
|
var oldSplitName = splitClassName.copy();
|
|
|
|
var customImport:CustomClassImport = {
|
|
name: claVarName,
|
|
pkg: splitClassName,
|
|
fullPath: realClassName
|
|
};
|
|
localImports.set(customImport.name, customImport);
|
|
|
|
if (variables.exists(toSetName)) // class is already imported
|
|
return null;
|
|
|
|
var realClassName = getLocalImportRedirect(realClassName);
|
|
|
|
if (importBlocklist.contains(realClassName))
|
|
return null;
|
|
if (InterpConfig.DISALLOW_IMPORT.contains(realClassName))
|
|
return null;
|
|
var cl = Type.resolveClass(realClassName);
|
|
if (cl == null)
|
|
cl = Type.resolveClass('${realClassName}_HSC');
|
|
|
|
var en = Type.resolveEnum(realClassName);
|
|
|
|
//trace(realClassName, cl, en, splitClassName);
|
|
|
|
// Allow for flixel.ui.FlxBar.FlxBarFillDirection;
|
|
if (cl == null && en == null) {
|
|
if(splitClassName.length > 1) {
|
|
splitClassName.splice(-2, 1); // Remove the last last item
|
|
realClassName = splitClassName.join(".");
|
|
|
|
var realClassName = getLocalImportRedirect(realClassName);
|
|
|
|
if (importBlocklist.contains(realClassName))
|
|
return null;
|
|
|
|
cl = Type.resolveClass(realClassName);
|
|
if (cl == null)
|
|
cl = Type.resolveClass('${realClassName}_HSC');
|
|
|
|
en = Type.resolveEnum(realClassName);
|
|
|
|
//trace(realClassName, cl, en, splitClassName);
|
|
}
|
|
}
|
|
|
|
if (cl == null && en == null) {
|
|
if (importFailedCallback == null || !importFailedCallback(oldSplitName, n))
|
|
error(EInvalidClass(oldClassName));
|
|
} else {
|
|
if (en != null) {
|
|
// ENUM!!!!
|
|
var enumThingy = {};
|
|
for (c in en.getConstructors()) {
|
|
try {
|
|
UnsafeReflect.setField(enumThingy, c, en.createByName(c));
|
|
} catch(e) {
|
|
try {
|
|
UnsafeReflect.setField(enumThingy, c, UnsafeReflect.field(en, c));
|
|
} catch(ex) {
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
variables.set(toSetName, enumThingy);
|
|
} else {
|
|
variables.set(toSetName, cl);
|
|
}
|
|
}
|
|
|
|
return null;
|
|
case ERedirect(n, cln, cl):
|
|
if(cl != null) {
|
|
setVar(n, cl);
|
|
}
|
|
localImportRedirects.set(n, cln);
|
|
case EConst(c):
|
|
switch (c) {
|
|
case CInt(v): return v;
|
|
case CFloat(f): return f;
|
|
case CString(s): return s;
|
|
}
|
|
case EIdent(id):
|
|
return resolve(id);
|
|
case EVar(n, _, e, isPublic, isStatic, _, isFinal, _, getter, setter):
|
|
if(depth > 0 && (getter != null || setter != null)) {
|
|
error(ECustom("Property Accessor for local variables is not allowed"));
|
|
return null;
|
|
}
|
|
declared.push({n: n, old: locals.get(n), depth: depth});
|
|
var declVar:DeclaredVar = {
|
|
r: (e == null) ? null : expr(e),
|
|
depth: depth,
|
|
isFinal: isFinal,
|
|
getter: getter,
|
|
setter: setter
|
|
};
|
|
locals.set(n, declVar);
|
|
if (depth == 0) {
|
|
if(allowStaticVariables && isStatic == true) {
|
|
if(!staticVariables.exists(n)) // make it so it only sets it once
|
|
staticVariables.set(n, locals[n].r);
|
|
} else if(allowPublicVariables && isPublic == true) {
|
|
publicVariables.set(n, locals[n].r);
|
|
} else {
|
|
variables.set(n, locals[n].r);
|
|
}
|
|
}
|
|
return null;
|
|
case EParent(e):
|
|
return expr(e);
|
|
case EBlock(exprs):
|
|
var old = declared.length;
|
|
var v = null;
|
|
for (e in exprs)
|
|
v = expr(e);
|
|
restore(old);
|
|
return v;
|
|
case EField(e, f, s):
|
|
var field = expr(e);
|
|
if(s && field == null)
|
|
return null;
|
|
return get(field, f);
|
|
case EBinop(op, e1, e2):
|
|
var fop = binops.get(op);
|
|
if (fop == null)
|
|
error(EInvalidOp(op));
|
|
return fop(e1, e2);
|
|
case EUnop(op, prefix, e):
|
|
switch (op) {
|
|
case "!":
|
|
return expr(e) != true;
|
|
case "-":
|
|
return -expr(e);
|
|
case "++":
|
|
return increment(e, prefix, 1);
|
|
case "--":
|
|
return increment(e, prefix, -1);
|
|
case "~":
|
|
return ~expr(e);
|
|
default:
|
|
error(EInvalidOp(op));
|
|
}
|
|
case ECall(e, params):
|
|
switch (Tools.expr(e)) {
|
|
case EField(e, f, s):
|
|
var obj:Dynamic = expr(e);
|
|
if (obj == null) {
|
|
if(s) return null;
|
|
error(EInvalidAccess(f));
|
|
}
|
|
|
|
if (f == "bind" && Reflect.isFunction(obj)) {
|
|
var obj: Function = obj;
|
|
if (params.length == 0) { // Special case for function.bind()
|
|
return Reflect.makeVarArgs(function(ar: Array<Dynamic>) {
|
|
return obj();
|
|
});
|
|
}
|
|
|
|
// bind(_, false) => function(a1) return obj(a1, false);
|
|
// bind(false, _) => function(a2) return obj(false, a2);
|
|
// bind(_, _) => function(a1, a2) return obj(a1, a2);
|
|
|
|
var totalNeeded = 0;
|
|
var bArgs = [];
|
|
for (p in params) {
|
|
switch (Tools.expr(p)) {
|
|
case EIdent(_):
|
|
bArgs.push(null);
|
|
totalNeeded++;
|
|
default:
|
|
bArgs.push(p);
|
|
}
|
|
}
|
|
var me = this;
|
|
// TODO: make it increment the depth?
|
|
return Reflect.makeVarArgs(function(ar: Array<Dynamic>) {
|
|
if (ar.length < totalNeeded)
|
|
error(ECustom("Too few arguments")); // TODO: make it say like "Not enough arguments, expected a:Int"
|
|
var i = 0;
|
|
var actualArgs = [];//[for (a in bArgs) if (a != null) me.expr(a) else ar[i++]];
|
|
for(a in bArgs) {
|
|
if(a != null) {
|
|
switch(Tools.expr(a)) {
|
|
case EIdent(id0):
|
|
var ident = resolve(id0);
|
|
if (ident is CustomClass) {
|
|
// Pass the underlying superclass if exist
|
|
var customClass:CustomClass = cast ident;
|
|
var objectToPush = customClass.superClass != null ? customClass.getSuperclass() : customClass;
|
|
actualArgs.push(objectToPush);
|
|
} else {
|
|
actualArgs.push(ident);
|
|
}
|
|
default:
|
|
actualArgs.push(me.expr(a));
|
|
}
|
|
}
|
|
else
|
|
actualArgs.push(ar[i++]);
|
|
}
|
|
return Reflect.callMethod(null, obj, actualArgs);
|
|
});
|
|
}
|
|
|
|
return fcall(obj, f, makeArgs(params));
|
|
default:
|
|
return call(null, expr(e), makeArgs(params));
|
|
}
|
|
case EIf(econd, e1, e2):
|
|
return if (expr(econd) == true) expr(e1) else if (e2 == null) null else expr(e2);
|
|
case EWhile(econd, e):
|
|
whileLoop(econd, e);
|
|
return null;
|
|
case EDoWhile(econd, e):
|
|
doWhileLoop(econd, e);
|
|
return null;
|
|
case EFor(v, it, e, ithv):
|
|
forLoop(v, it, e, ithv);
|
|
return null;
|
|
case EBreak:
|
|
throw SBreak;
|
|
case EContinue:
|
|
throw SContinue;
|
|
case EReturn(e):
|
|
returnValue = e == null ? null : expr(e);
|
|
throw SReturn;
|
|
case EFunction(params, fexpr, name, _, isPublic, isStatic, isOverride, isPrivate, isFinal, isInline):
|
|
var __capturedLocals = duplicate(locals);
|
|
var capturedLocals:Map<String, DeclaredVar> = [];
|
|
|
|
var keys = __capturedLocals.keys();
|
|
var _hasNext = keys.hasNext;
|
|
var _next = keys.next;
|
|
while (_hasNext()) {
|
|
var k = _next();
|
|
var e = __capturedLocals.get(k);
|
|
if (e != null && e.depth > 0)
|
|
capturedLocals.set(k, e);
|
|
}
|
|
|
|
var me = this;
|
|
var hasOpt = false, minParams = 0;
|
|
for (p in params)
|
|
if (p.opt)
|
|
hasOpt = true;
|
|
else
|
|
minParams++;
|
|
var f = function(args:Array<Dynamic>) {
|
|
if (me.locals == null || me.variables == null) return null;
|
|
|
|
if (((args == null) ? 0 : args.length) != params.length) {
|
|
if (args.length < minParams) {
|
|
var str = "Invalid number of parameters. Got " + args.length + ", required " + minParams;
|
|
if (name != null)
|
|
str += " for function '" + name + "'";
|
|
error(ECustom(str));
|
|
}
|
|
// make sure mandatory args are forced
|
|
var args2 = [];
|
|
var extraParams = args.length - minParams;
|
|
var pos = 0;
|
|
for (p in params)
|
|
if (p.opt) {
|
|
if (extraParams > 0) {
|
|
args2.push(args[pos++]);
|
|
extraParams--;
|
|
} else
|
|
args2.push(null);
|
|
} else
|
|
args2.push(args[pos++]);
|
|
args = args2;
|
|
}
|
|
var old = me.locals, depth = me.depth;
|
|
me.depth++;
|
|
me.locals = me.duplicate(capturedLocals);
|
|
for (i in 0...params.length)
|
|
me.locals.set(params[i].name, {r: args[i], depth: depth});
|
|
var r = null;
|
|
var oldDecl = declared.length;
|
|
if (inTry)
|
|
try {
|
|
r = me.exprReturn(fexpr);
|
|
} catch (e:Dynamic) {
|
|
me.locals = old;
|
|
me.depth = depth;
|
|
#if neko
|
|
neko.Lib.rethrow(e);
|
|
#else
|
|
throw e;
|
|
#end
|
|
}
|
|
else
|
|
r = me.exprReturn(fexpr);
|
|
restore(oldDecl);
|
|
me.locals = old;
|
|
me.depth = depth;
|
|
return r;
|
|
};
|
|
var fn:Function = Reflect.makeVarArgs(f);
|
|
if (name != null) {
|
|
if (depth == 0) {
|
|
// global function
|
|
if(isStatic && allowStaticVariables) {
|
|
staticVariables.set(name, fn);
|
|
} else if(isPublic && allowPublicVariables) {
|
|
publicVariables.set(name, fn);
|
|
} else {
|
|
variables.set(name, fn);
|
|
}
|
|
} else {
|
|
// function-in-function is a local function
|
|
declared.push({n: name, old: locals.get(name), depth: depth});
|
|
var ref:DeclaredVar = {r: fn, depth: depth};
|
|
locals.set(name, ref);
|
|
capturedLocals.set(name, ref); // allow self-recursion
|
|
}
|
|
}
|
|
return fn;
|
|
case EArrayDecl(arr, wantedType):
|
|
var isMap = false;
|
|
|
|
if (wantedType != null) {
|
|
isMap = switch (wantedType) {
|
|
case CTPath(["Map"], [_, _]): true;
|
|
case CTPath(["StringMap"], [_]): true;
|
|
case CTPath(["IntMap"], [_]): true;
|
|
case CTPath(["ObjectMap"], [_]): true;
|
|
case CTPath(["EnumMap"], [_]): true;
|
|
default: false;
|
|
};
|
|
}
|
|
|
|
if (!isMap && arr.length > 0) {
|
|
isMap = Tools.expr(arr[0]).match(EBinop("=>", _));
|
|
}
|
|
|
|
if (isMap) {
|
|
var isAllString:Bool = true;
|
|
var isAllInt:Bool = true;
|
|
var isAllObject:Bool = true;
|
|
var isAllEnum:Bool = true;
|
|
var keys:Array<Dynamic> = [];
|
|
var values:Array<Dynamic> = [];
|
|
|
|
for (e in arr) {
|
|
switch (Tools.expr(e)) {
|
|
case EBinop("=>", eKey, eValue):
|
|
var key:Dynamic = expr(eKey);
|
|
var value:Dynamic = expr(eValue);
|
|
isAllString = isAllString && (key is String);
|
|
isAllInt = isAllInt && (key is Int);
|
|
isAllObject = isAllObject && Reflect.isObject(key);
|
|
isAllEnum = isAllEnum && Reflect.isEnumValue(key);
|
|
keys.push(key);
|
|
values.push(value);
|
|
default:
|
|
throw "=> expected";
|
|
}
|
|
}
|
|
|
|
if (wantedType != null) {
|
|
isAllString = isAllString && (
|
|
wantedType.match(CTPath(["Map"], [CTPath(["String"], _), _])) || wantedType.match(CTPath(["StringMap"], [_]))
|
|
);
|
|
isAllInt = isAllInt && (
|
|
wantedType.match(CTPath(["Map"], [CTPath(["Int"], _), _])) || wantedType.match(CTPath(["IntMap"], [_]))
|
|
);
|
|
isAllObject = isAllObject && (
|
|
wantedType.match(CTPath(["Map"], [CTPath(["Dynamic"], _), _])) || wantedType.match(CTPath(["ObjectMap"], [_, _]))
|
|
);
|
|
isAllEnum = isAllEnum && (
|
|
wantedType.match(CTPath(["Map"], [CTPath(["Enum"], _), _])) || wantedType.match(CTPath(["EnumMap"], [_, _]))
|
|
);
|
|
|
|
if (!isAllString && !isAllInt && !isAllObject && !isAllEnum) {
|
|
isAllObject = true; // Assume dynamic
|
|
//throw "Unknown Type Key";
|
|
}
|
|
}
|
|
|
|
var map:Dynamic = {
|
|
if (isAllInt)
|
|
new haxe.ds.IntMap<Dynamic>();
|
|
else if (isAllString)
|
|
new haxe.ds.StringMap<Dynamic>();
|
|
else if (isAllEnum)
|
|
new haxe.ds.EnumValueMap<Dynamic, Dynamic>();
|
|
else if (isAllObject)
|
|
new haxe.ds.ObjectMap<Dynamic, Dynamic>();
|
|
else
|
|
throw 'Unknown Type Key';
|
|
}
|
|
for (n in 0...keys.length) {
|
|
setMapValue(map, keys[n], values[n]);
|
|
}
|
|
return map;
|
|
} else {
|
|
var a = [];
|
|
for (e in arr) {
|
|
a.push(expr(e));
|
|
}
|
|
return a;
|
|
}
|
|
case EArray(e, index):
|
|
var arr:Dynamic = expr(e);
|
|
var index:Dynamic = expr(index);
|
|
if (isMap(arr)) {
|
|
return getMapValue(arr, index);
|
|
} else {
|
|
return arr[index];
|
|
}
|
|
case ENew(cl, params):
|
|
return cnew(cl, makeArgs(params));
|
|
case EThrow(e):
|
|
throw expr(e);
|
|
case ETry(e, n, _, ecatch):
|
|
var old = declared.length;
|
|
var oldTry = inTry;
|
|
try {
|
|
inTry = true;
|
|
var v:Dynamic = expr(e);
|
|
restore(old);
|
|
inTry = oldTry;
|
|
return v;
|
|
} catch (err:Stop) {
|
|
inTry = oldTry;
|
|
throw err;
|
|
} catch (err:Dynamic) {
|
|
// restore vars
|
|
restore(old);
|
|
inTry = oldTry;
|
|
// declare 'v'
|
|
declared.push({n: n, old: locals.get(n), depth: depth});
|
|
locals.set(n, {r: err, depth: depth});
|
|
var v:Dynamic = expr(ecatch);
|
|
restore(old);
|
|
return v;
|
|
}
|
|
case EObject(fl):
|
|
var o = {};
|
|
for (f in fl)
|
|
UnsafeReflect.setField(o, f.name, expr(f.e));
|
|
return o;
|
|
case ETernary(econd, e1, e2):
|
|
return if (expr(econd) == true) expr(e1) else expr(e2);
|
|
case ESwitch(e, cases, def):
|
|
var val:Dynamic = expr(e);
|
|
var match = false;
|
|
for (c in cases) {
|
|
for (v in c.values)
|
|
if (expr(v) == val) {
|
|
match = true;
|
|
break;
|
|
}
|
|
if (match) {
|
|
val = expr(c.expr);
|
|
break;
|
|
}
|
|
}
|
|
if (!match)
|
|
val = def == null ? null : expr(def);
|
|
return val;
|
|
case EMeta(a, b, e):
|
|
var val:Dynamic = null;
|
|
|
|
switch(a) {
|
|
case ":bypassAccessor":
|
|
var oldAccessor = isBypassAccessor;
|
|
isBypassAccessor = true;
|
|
val = expr(e);
|
|
isBypassAccessor = oldAccessor;
|
|
return val;
|
|
case ":privateAccess":
|
|
var oldPrivate = isPrivateAccess;
|
|
isPrivateAccess = true;
|
|
val = expr(e);
|
|
isPrivateAccess = oldPrivate;
|
|
return val;
|
|
}
|
|
|
|
val = expr(e);
|
|
return val;
|
|
/*
|
|
var oldAccessor = isBypassAccessor;
|
|
if(a == ":bypassAccessor") {
|
|
isBypassAccessor = true;
|
|
}
|
|
var val = expr(e);
|
|
|
|
isBypassAccessor = oldAccessor;
|
|
return val;
|
|
*/
|
|
case ECheckType(e, _):
|
|
return expr(e);
|
|
case EUsing(name):
|
|
useUsing(name);
|
|
case EEnum(enumName, fields):
|
|
var obj:HScriptEnum = new HScriptEnum();
|
|
for (index => field in fields) {
|
|
switch (field) {
|
|
case ESimple(name):
|
|
obj.setEnum(name, new EnumValue(enumName, name, index, obj, null));
|
|
case EConstructor(name, params):
|
|
var hasOpt = false, minParams = 0;
|
|
for (p in params)
|
|
if (p.opt)
|
|
hasOpt = true;
|
|
else
|
|
minParams++;
|
|
var f = function(args: Array<Dynamic>) {
|
|
if (((args == null) ? 0 : args.length) != params.length) {
|
|
if (args.length < minParams) {
|
|
var str = "Invalid number of parameters. Got " + args.length + ", required " + minParams;
|
|
if (enumName != null)
|
|
str += " for enum '" + enumName + "'";
|
|
error(ECustom(str));
|
|
}
|
|
// make sure mandatory args are forced
|
|
var args2 = [];
|
|
var extraParams = args.length - minParams;
|
|
var pos = 0;
|
|
for (p in params)
|
|
if (p.opt) {
|
|
if (extraParams > 0) {
|
|
args2.push(args[pos++]);
|
|
extraParams--;
|
|
} else
|
|
args2.push(null);
|
|
} else
|
|
args2.push(args[pos++]);
|
|
args = args2;
|
|
}
|
|
return new Tools.EnumValue(enumName, name, index, obj, args);
|
|
};
|
|
var f = Reflect.makeVarArgs(f);
|
|
|
|
obj.setEnum(name, f);
|
|
}
|
|
}
|
|
variables.set(enumName, obj);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function doWhileLoop(econd:Expr, e:Expr):Void {
|
|
var old = declared.length;
|
|
do {
|
|
try {
|
|
expr(e);
|
|
} catch (err:Stop) {
|
|
switch (err) {
|
|
case SContinue:
|
|
case SBreak:
|
|
break;
|
|
case SReturn:
|
|
throw err;
|
|
}
|
|
}
|
|
} while (expr(econd) == true);
|
|
restore(old);
|
|
}
|
|
|
|
function whileLoop(econd:Expr, e:Expr):Void {
|
|
var old = declared.length;
|
|
while (expr(econd) == true) {
|
|
try {
|
|
expr(e);
|
|
} catch (err:Stop) {
|
|
switch (err) {
|
|
case SContinue:
|
|
case SBreak:
|
|
break;
|
|
case SReturn:
|
|
throw err;
|
|
}
|
|
}
|
|
}
|
|
restore(old);
|
|
}
|
|
|
|
function makeIterator(v:Dynamic, ?allowKeyValue = false):Iterator<Dynamic> {
|
|
#if ((flash && !flash9) || (php && !php7 && haxe_ver < '4.0.0'))
|
|
if (v.iterator != null)
|
|
v = v.iterator();
|
|
#else
|
|
if(allowKeyValue) {
|
|
try
|
|
v = v.keyValueIterator()
|
|
catch (e:Dynamic) {};
|
|
}
|
|
|
|
if(v.hasNext == null || v.next == null) {
|
|
try
|
|
v = v.iterator()
|
|
catch (e:Dynamic) {};
|
|
}
|
|
#end
|
|
if (v.hasNext == null || v.next == null)
|
|
error(EInvalidIterator(v));
|
|
return v;
|
|
}
|
|
|
|
function makeArgs(params:Array<Expr>):Array<Dynamic> {
|
|
var args:Array<Dynamic> = [];
|
|
for (p in params) {
|
|
switch (Tools.expr(p)) {
|
|
case EIdent(id):
|
|
var ident = resolve(id);
|
|
if (ident is CustomClass) {
|
|
var customClass:CustomClass = cast ident; // Pass the underlying superclass if exist
|
|
args.push(customClass.superClass != null ? customClass.getSuperclass() : customClass);
|
|
} else {
|
|
args.push(ident);
|
|
}
|
|
default:
|
|
args.push(expr(p));
|
|
}
|
|
}
|
|
|
|
return args;
|
|
}
|
|
|
|
function forLoop(n:String, it:Expr, e:Expr, ?ithv:String):Void {
|
|
var isKeyValue = ithv != null;
|
|
var old = declared.length;
|
|
if(isKeyValue)
|
|
declared.push({n: ithv, old: locals.get(ithv), depth: depth});
|
|
declared.push({n: n, old: locals.get(n), depth: depth});
|
|
var it = makeIterator(expr(it), isKeyValue);
|
|
var _hasNext = it.hasNext;
|
|
var _next = it.next;
|
|
while (_hasNext()) {
|
|
var next = _next();
|
|
if(isKeyValue)
|
|
locals.set(ithv, {r: next.key, depth: depth});
|
|
locals.set(n, {r: isKeyValue ? next.value : next, depth: depth});
|
|
try {
|
|
expr(e);
|
|
} catch (err:Stop) {
|
|
switch (err) {
|
|
case SContinue:
|
|
case SBreak:
|
|
break;
|
|
case SReturn:
|
|
throw err;
|
|
}
|
|
}
|
|
}
|
|
restore(old);
|
|
}
|
|
|
|
inline function isMap(o:Dynamic):Bool {
|
|
return (o is IMap);
|
|
}
|
|
|
|
inline function getMap(map:Dynamic):IMap<Dynamic, Dynamic> {
|
|
var map:IMap<Dynamic, Dynamic> = cast map;
|
|
return map;
|
|
}
|
|
|
|
inline function getMapValue(map:Dynamic, key:Dynamic):Dynamic {
|
|
var map:IMap<Dynamic, Dynamic> = cast map;
|
|
return map.get(key);
|
|
}
|
|
|
|
inline function setMapValue(map:Dynamic, key:Dynamic, value:Dynamic):Void {
|
|
var map:IMap<Dynamic, Dynamic> = cast map;
|
|
map.set(key, value);
|
|
}
|
|
|
|
public static var getRedirects:Map<String, Dynamic->String->Dynamic> = [];
|
|
public static var setRedirects:Map<String, Dynamic->String->Dynamic->Dynamic> = [];
|
|
|
|
private static var _getRedirect:Dynamic->String->Dynamic;
|
|
private static var _setRedirect:Dynamic->String->Dynamic->Dynamic;
|
|
|
|
public var useRedirects:Bool = false;
|
|
|
|
static function getClassType(o:Dynamic, ?cls:Class<Any>):Null<String> {
|
|
return switch (Type.typeof(o)) {
|
|
case TNull: "Null";
|
|
case TInt: "Int";
|
|
case TFloat: "Float";
|
|
case TBool: "Bool";
|
|
case _:
|
|
if (cls == null)
|
|
cls = Type.getClass(o);
|
|
cls != null ? Type.getClassName(cls) : null;
|
|
};
|
|
}
|
|
|
|
function get(o:Dynamic, f:String):Dynamic {
|
|
if (o == null)
|
|
error(EInvalidAccess(f));
|
|
|
|
if (o is CustomClass) {
|
|
if (cast(o, CustomClass).__class.hasField(f)) {
|
|
var clsName:String = cast(o, CustomClass).className;
|
|
error(ECustom('The field ${clsName}.${f} should be accessed in a static way.'));
|
|
}
|
|
|
|
cast(o, CustomClass).accessContext = _inCustomClass ? CInner(_proxy.className) : COuter;
|
|
}
|
|
|
|
var cls = Type.getClass(o);
|
|
if (useRedirects && {
|
|
var cl:Null<String> = getClassType(o, cls);
|
|
cl != null && getRedirects.exists(cl) && (_getRedirect = getRedirects[cl]) != null;
|
|
}) {
|
|
return _getRedirect(o, f);
|
|
}
|
|
if (o is IHScriptCustomAccessBehaviour) {
|
|
var obj:IHScriptCustomAccessBehaviour = cast o;
|
|
|
|
var oldAccessor = obj.__allowSetGet;
|
|
var oldPrivate = obj.__allowPrivateAccess;
|
|
|
|
if(isBypassAccessor)
|
|
obj.__allowSetGet = false;
|
|
if(isPrivateAccess)
|
|
obj.__allowPrivateAccess = true;
|
|
|
|
var res = obj.hget(f);
|
|
|
|
obj.__allowSetGet = oldAccessor;
|
|
obj.__allowPrivateAccess = oldPrivate;
|
|
|
|
return res;
|
|
}
|
|
|
|
if (o is IHScriptCustomBehaviour) {
|
|
var obj:IHScriptCustomBehaviour = cast o;
|
|
return obj.hget(f);
|
|
}
|
|
var v = null;
|
|
if(isBypassAccessor) {
|
|
if ((v = UnsafeReflect.field(o, f)) == null)
|
|
v = Reflect.field(cls, f);
|
|
}
|
|
|
|
if(v == null) {
|
|
if ((v = UnsafeReflect.getProperty(o, f)) == null)
|
|
v = Reflect.getProperty(cls, f);
|
|
}
|
|
return v;
|
|
}
|
|
|
|
function set(o:Dynamic, f:String, v:Dynamic):Dynamic {
|
|
if (o == null)
|
|
error(EInvalidAccess(f));
|
|
|
|
if (o is CustomClass) {
|
|
if (cast(o, CustomClass).__class.hasField(f)) {
|
|
var clsName:String = cast(o, CustomClass).className;
|
|
error(ECustom('The field ${clsName}.${f} should be accessed in a static way.'));
|
|
}
|
|
|
|
cast(o, CustomClass).accessContext = _inCustomClass ? CInner(_proxy.className) : COuter;
|
|
}
|
|
|
|
if (useRedirects && {
|
|
var cl:Null<String> = getClassType(o);
|
|
cl != null && setRedirects.exists(cl) && (_setRedirect = setRedirects[cl]) != null;
|
|
})
|
|
return _setRedirect(o, f, v);
|
|
if (o is IHScriptCustomAccessBehaviour) {
|
|
var obj:IHScriptCustomAccessBehaviour = cast o;
|
|
|
|
var oldAccessor = obj.__allowSetGet;
|
|
var oldPrivate = obj.__allowPrivateAccess;
|
|
|
|
if(isBypassAccessor)
|
|
obj.__allowSetGet = false;
|
|
if(isPrivateAccess)
|
|
obj.__allowPrivateAccess = true;
|
|
|
|
var res = obj.hset(f, v);
|
|
|
|
obj.__allowSetGet = oldAccessor;
|
|
obj.__allowPrivateAccess = oldPrivate;
|
|
|
|
return res;
|
|
}
|
|
|
|
if (o is IHScriptCustomBehaviour) {
|
|
var obj:IHScriptCustomBehaviour = cast o;
|
|
return obj.hset(f, v);
|
|
}
|
|
// Can use unsafe reflect here, since we checked for null above
|
|
if(isBypassAccessor) {
|
|
UnsafeReflect.setField(o, f, v);
|
|
} else {
|
|
UnsafeReflect.setProperty(o, f, v);
|
|
}
|
|
return v;
|
|
}
|
|
|
|
/**
|
|
* Meant for people to add their own usings.
|
|
**/
|
|
function registerUsingLocal(name: String, call: UsingCall): UsingEntry {
|
|
var entry = new UsingEntry(name, call);
|
|
usings.push(entry);
|
|
return entry;
|
|
}
|
|
|
|
function useUsing(name:String) {
|
|
for (us in UsingHandler.usingEntries) {
|
|
if (us.name == name) {
|
|
if (usings.indexOf(us) == -1)
|
|
usings.push(us);
|
|
return;
|
|
}
|
|
}
|
|
|
|
var cls = Tools.getClass(name);
|
|
if (cls != null) {
|
|
var entry:UsingEntry = null;
|
|
|
|
var fieldName = '_HX_USING__' + StringTools.replace(name, ".", "_");
|
|
if (Reflect.hasField(cls, fieldName)) {
|
|
var fields = Reflect.field(cls, fieldName);
|
|
if (fields == null)
|
|
return;
|
|
|
|
entry = new UsingEntry(name, function(o:Dynamic, f:String, args:Array<Dynamic>):Dynamic {
|
|
if (!fields.exists(f))
|
|
return null;
|
|
var type:ValueType = Type.typeof(o);
|
|
var valueType:ValueType = fields.get(f);
|
|
|
|
// If we figure out a better way to get the types as the real ValueType, we can use this instead
|
|
// if (Type.enumEq(valueType, type))
|
|
// return Reflect.callMethod(cls, Reflect.field(cls, f), [o].concat(args));
|
|
|
|
var canCall = valueType == null ? true : switch (valueType) {
|
|
case TEnum(null):
|
|
type.match(TEnum(_));
|
|
case TClass(null):
|
|
type.match(TClass(_));
|
|
case TClass(IMap): // if we don't check maps like this, it just doesn't work
|
|
type.match(TClass(IMap) | TClass(haxe.ds.ObjectMap) | TClass(haxe.ds.StringMap) | TClass(haxe.ds.IntMap) | TClass(haxe.ds.EnumValueMap));
|
|
default:
|
|
Type.enumEq(type, valueType);
|
|
}
|
|
|
|
return canCall ? Reflect.callMethod(cls, Reflect.field(cls, f), [o].concat(args)) : null;
|
|
});
|
|
|
|
#if debug
|
|
trace("Registered macro based using entry for " + name);
|
|
#end
|
|
|
|
UsingHandler.usingEntries.push(entry);
|
|
usings.push(entry);
|
|
return;
|
|
}
|
|
else {
|
|
// Use reflection to generate the using entry
|
|
entry = new UsingEntry(name, function(o:Dynamic, f:String, args:Array<Dynamic>):Dynamic {
|
|
if (!Reflect.hasField(cls, f))
|
|
return null;
|
|
var field = Reflect.field(cls, f);
|
|
if (!Reflect.isFunction(field))
|
|
return null;
|
|
|
|
// invalid if the function has no arguments
|
|
var totalArgs = Tools.argCount(field);
|
|
if (totalArgs == 0)
|
|
return null;
|
|
|
|
return Reflect.callMethod(cls, field, [o].concat(args));
|
|
});
|
|
|
|
#if debug
|
|
trace("Registered reflection based using entry for " + name);
|
|
#end
|
|
}
|
|
|
|
UsingHandler.usingEntries.push(entry);
|
|
usings.push(entry);
|
|
return;
|
|
}
|
|
error(ECustom("Unknown using class " + name));
|
|
}
|
|
|
|
/**
|
|
* List of components that allow using static methods on objects.
|
|
* This only works if you do
|
|
* ```haxe
|
|
* var result = "Hello ".trim();
|
|
* ```
|
|
* and not
|
|
* ```haxe
|
|
* var trim = "Hello ".trim;
|
|
* var result = trim();
|
|
* ```
|
|
*/
|
|
var usings: Array<UsingEntry> = [];
|
|
|
|
function fcall(o:Dynamic, f:String, args:Array<Dynamic>):Dynamic {
|
|
for(_us in usings) {
|
|
var v = _us.call(o, f, args);
|
|
if(v != null)
|
|
return v;
|
|
}
|
|
|
|
// Custom logic to handle super calls to prevent infinite recursion
|
|
if(_inCustomClass) {
|
|
// Force call super function.
|
|
if(o == _proxy.superClass) {
|
|
if(_proxy.superIsCustomClass)
|
|
return cast(_proxy.superClass, CustomClass).callFunction(f, args);
|
|
else
|
|
return call(o, Reflect.field(_proxy.superClass, '_HX_SUPER__${f}'), args);
|
|
}
|
|
}
|
|
else if (o is CustomClass) {
|
|
_nextCallObject = null;
|
|
var proxy:CustomClass = cast o;
|
|
return proxy.callFunction(f, args);
|
|
}
|
|
else if (o is CustomClassDecl) {
|
|
// Static function call
|
|
var staticClass:CustomClassDecl = cast o;
|
|
if(staticClass.hasFunction(f))
|
|
return staticClass.callFunction(f, args);
|
|
}
|
|
|
|
var func = get(o, f);
|
|
|
|
// Workaround for an HTML5-specific issue.
|
|
// https://github.com/HaxeFoundation/haxe/issues/11298
|
|
#if js
|
|
if (func == null && f == "contains") {
|
|
func = get(o, "includes");
|
|
}
|
|
#end
|
|
|
|
return call(o, func, args);
|
|
}
|
|
|
|
function call(o:Dynamic, f:Dynamic, args:Array<Dynamic>):Dynamic {
|
|
if (_inCustomClass) {
|
|
// Calling fn() in hscript won't resolve an object first. Thus, we need to change it to use this.fn() instead.
|
|
if (o == null && _nextCallObject != null) {
|
|
o = _nextCallObject;
|
|
}
|
|
|
|
if (f == null) {
|
|
error(EInvalidAccess(f));
|
|
}
|
|
|
|
if (o == _proxy) {
|
|
// If we are calling this.fn(), special handling is needed to prevent the local scope from being destroyed.
|
|
// By checking `o == _proxy`, we handle BOTH fn() and this.fn().
|
|
// super.fn() is exempt since it is not scripted.
|
|
return callThis(f, args);
|
|
}
|
|
try {
|
|
var r = Reflect.callMethod(o, f, args);
|
|
_nextCallObject = null;
|
|
return r;
|
|
} catch (e) {
|
|
error(ECustom('${_proxy.className} threw an exception: \n${e.message}'));
|
|
_nextCallObject = null;
|
|
return null;
|
|
}
|
|
}
|
|
|
|
return UnsafeReflect.callMethodSafe(o, f, args);
|
|
}
|
|
|
|
/**
|
|
* Call a given function on the current proxy with the given arguments.
|
|
* Ensures that the local scope is not destroyed.
|
|
* @param fun The function to call.
|
|
* @param args The arguments to apply to that function.
|
|
* @return The result of the function call.
|
|
*/
|
|
function callThis(fun:Dynamic, args:Array<Dynamic>):Dynamic {
|
|
// If we are calling this.fn(), special handling is needed to prevent the local scope from being destroyed.
|
|
// Store the local scope.
|
|
var capturedLocals = this.duplicate(locals);
|
|
var capturedDeclared = this.declared;
|
|
var capturedDepth = this.depth;
|
|
|
|
this.depth++;
|
|
|
|
// Call the function.
|
|
try {
|
|
var result = Reflect.callMethod(_proxy, fun, args);
|
|
|
|
// Restore the local scope.
|
|
this.locals = capturedLocals;
|
|
this.declared = capturedDeclared;
|
|
this.depth = capturedDepth;
|
|
|
|
return result;
|
|
} catch (e) {
|
|
error(ECustom('Custom Class threw an exception: \n${fun}'));
|
|
|
|
// Restore the local scope.
|
|
this.locals = capturedLocals;
|
|
this.declared = capturedDeclared;
|
|
this.depth = capturedDepth;
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function cnew(cl:String, args:Array<Dynamic>):Dynamic {
|
|
// Custom Class
|
|
if (customClassExist(cl)) {
|
|
var proxy:CustomClass = new CustomClass(getCustomClass(cl), args, null, this);
|
|
return proxy;
|
|
}
|
|
if (_inCustomClass) {
|
|
if (_proxy.__class.pkg != null) {
|
|
var packagedClass = _proxy.__class.pkg.join(".") + "." + cl;
|
|
if (customClassExist(packagedClass)) {
|
|
var proxy:CustomClass = new CustomClass(getCustomClass(cl), args, null, this);
|
|
return proxy;
|
|
}
|
|
}
|
|
|
|
if (_proxy.__class.imports != null && _proxy.__class.imports.exists(cl)) {
|
|
var importedClass = _proxy.__class.imports.get(cl).fullPath;
|
|
if (customClassExist(importedClass)) {
|
|
var proxy:CustomClass = new CustomClass(getCustomClass(cl), args, null, this);
|
|
return proxy;
|
|
}
|
|
|
|
var c = Type.resolveClass(importedClass);
|
|
if (c != null) {
|
|
return Type.createInstance(c, args);
|
|
}
|
|
}
|
|
}
|
|
|
|
var c:Dynamic = resolve(cl);
|
|
if (c == null)
|
|
c = Type.resolveClass(cl);
|
|
if(c is IHScriptCustomConstructor) {
|
|
var c:IHScriptCustomConstructor = cast c;
|
|
return c.hnew(args);
|
|
} else {
|
|
return Type.createInstance(c, args);
|
|
}
|
|
}
|
|
|
|
public function registerModule(module:Array<ModuleDecl>, ?as:String) {
|
|
var pkg:Array<String> = null;
|
|
var imports:Map<String, CustomClassImport> = [];
|
|
var usings:Array<String> = [];
|
|
var regAlias:Bool = false;
|
|
for (decl in module) {
|
|
switch (decl) {
|
|
case DPackage(path):
|
|
pkg = path;
|
|
case DImport(path, _, asname):
|
|
if (importBlocklist.contains(path.join(".")))
|
|
continue;
|
|
var last = path[path.length - 1];
|
|
var hasAlias = asname != null;
|
|
|
|
var importedClass:CustomClassImport = {
|
|
name: last,
|
|
pkg: [for (e in path) e.trim()],
|
|
fullPath: path.join("."),
|
|
as: asname
|
|
}
|
|
imports.set(hasAlias ? asname : importedClass.name, importedClass);
|
|
case DUsing(path):
|
|
usings.push(path.join("."));
|
|
case DTypedef(td):
|
|
switch(td.t) {
|
|
case CTPath(path, params):
|
|
if (params != null && params.length > 1)
|
|
error(ECustom("Typedefs can't have parameters"));
|
|
if (path.length < 1)
|
|
error(ECustom("Typedefs can't be empty"));
|
|
|
|
var last = path[path.length - 1];
|
|
|
|
var importedClass:CustomClassImport = {
|
|
name: last,
|
|
pkg: [for (e in path) e.trim()],
|
|
fullPath: path.join("."),
|
|
as: td.name
|
|
}
|
|
imports.set(td.name, importedClass);
|
|
default:
|
|
}
|
|
case DClass(c):
|
|
var extend = c.extend;
|
|
if (extend != null) {
|
|
var superClassPath = new Printer().typeToString(extend);
|
|
if (imports.exists(superClassPath)) {
|
|
switch (extend) {
|
|
case CTPath(_, params):
|
|
extend = CTPath(imports.get(superClassPath).pkg, params);
|
|
case _:
|
|
}
|
|
}
|
|
}
|
|
var classDecl:ClassDecl = {
|
|
name: c.name,
|
|
params: c.params,
|
|
meta: c.meta,
|
|
isPrivate: c.isPrivate,
|
|
extend: extend,
|
|
implement: c.implement,
|
|
fields: c.fields,
|
|
isExtern: c.isExtern
|
|
};
|
|
|
|
var customClassDecl:CustomClassDecl = {
|
|
classDecl: classDecl,
|
|
imports: imports,
|
|
usings: usings,
|
|
pkg: pkg,
|
|
ogInterp: this
|
|
}
|
|
//customClassDecl.cacheFields();
|
|
registerCustomClass(customClassDecl, !regAlias ? as : null, _inCustomClass);
|
|
if(as != null) regAlias = true;
|
|
}
|
|
}
|
|
}
|
|
}
|