1092 lines
26 KiB
GDScript
1092 lines
26 KiB
GDScript
class_name Interp
|
|
|
|
var variables: Variant
|
|
var locals: Variant
|
|
var binops: Variant
|
|
var depth: int
|
|
var inTry: bool
|
|
var declared: Array[Variant]
|
|
var returnValue
|
|
|
|
func _init() -> void:
|
|
self.locals = haxe_ds_StringMap.new()
|
|
self.declared = []
|
|
self.resetVariables()
|
|
self.initOps()
|
|
|
|
func resetVariables() -> void:
|
|
var _gthis: Interp = self
|
|
|
|
self.variables = haxe_ds_StringMap.new()
|
|
|
|
if true:
|
|
var this1: Variant = self.variables
|
|
this1.__set("null", null)
|
|
if true:
|
|
var this1: Variant = self.variables
|
|
this1.__set("true", true)
|
|
if true:
|
|
var this1: Variant = self.variables
|
|
this1.__set("false", false)
|
|
if true:
|
|
var this1: Variant = self.variables
|
|
var value = Reflect.makeVarArgs(func(el: Array[Variant]) -> void:
|
|
var inf: Variant = _gthis.posInfos()
|
|
var v = el.pop_front()
|
|
if (el.size() > 0):
|
|
inf.set("customParams", el)
|
|
haxe_Log.trace.call(str(v), inf))
|
|
this1.__set("trace", value)
|
|
|
|
func posInfos() -> Variant:
|
|
return {
|
|
"fileName": "hscript",
|
|
"lineNumber": 0
|
|
}
|
|
|
|
func initOps() -> void:
|
|
var me: Interp = self
|
|
|
|
self.binops = haxe_ds_StringMap.new()
|
|
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("+", func(e1: Variant, e2: Variant):
|
|
return me.expr(e1) + me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("-", func(e1: Variant, e2: Variant) -> float:
|
|
return me.expr(e1) - me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("*", func(e1: Variant, e2: Variant) -> float:
|
|
return me.expr(e1) * me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("/", func(e1: Variant, e2: Variant) -> float:
|
|
return me.expr(e1) / me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("%", func(e1: Variant, e2: Variant) -> float:
|
|
return me.expr(e1) % me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("&", func(e1: Variant, e2: Variant) -> int:
|
|
return me.expr(e1) & me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("|", func(e1: Variant, e2: Variant) -> int:
|
|
return me.expr(e1) | me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("^", func(e1: Variant, e2: Variant) -> int:
|
|
return me.expr(e1) ^ me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("<<", func(e1: Variant, e2: Variant) -> int:
|
|
return me.expr(e1) << me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set(">>", func(e1: Variant, e2: Variant) -> int:
|
|
return me.expr(e1) >> me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set(">>>", func(e1: Variant, e2: Variant) -> int:
|
|
return ((me.expr(e1) & -1) >> me.expr(e2)) & -1)
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("==", func(e1: Variant, e2: Variant) -> bool:
|
|
return me.expr(e1) == me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("!=", func(e1: Variant, e2: Variant) -> bool:
|
|
return me.expr(e1) != me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set(">=", func(e1: Variant, e2: Variant) -> bool:
|
|
return me.expr(e1) >= me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("<=", func(e1: Variant, e2: Variant) -> bool:
|
|
return me.expr(e1) <= me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set(">", func(e1: Variant, e2: Variant) -> bool:
|
|
return me.expr(e1) > me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("<", func(e1: Variant, e2: Variant) -> bool:
|
|
return me.expr(e1) < me.expr(e2))
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("||", func(e1: Variant, e2: Variant) -> bool:
|
|
return me.expr(e1) == true || me.expr(e2) == true)
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("&&", func(e1: Variant, e2: Variant) -> bool:
|
|
return me.expr(e1) == true && me.expr(e2) == true)
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("=", self.assign)
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
this1.__set("...", func(e1: Variant, e2: Variant) -> IntIterator:
|
|
return IntIterator.new(me.expr(e1), me.expr(e2)))
|
|
|
|
self.assignOp("+=", func(v1, v2):
|
|
return v1 + v2)
|
|
self.assignOp("-=", func(v1: float, v2: float) -> float:
|
|
return v1 - v2)
|
|
self.assignOp("*=", func(v1: float, v2: float) -> float:
|
|
return v1 * v2)
|
|
self.assignOp("/=", func(v1: float, v2: float) -> float:
|
|
return v1 / v2)
|
|
self.assignOp("%=", func(v1: int, v2: int) -> int:
|
|
return v1 % v2)
|
|
self.assignOp("&=", func(v1: int, v2: int) -> int:
|
|
return v1 & v2)
|
|
self.assignOp("|=", func(v1: int, v2: int) -> int:
|
|
return v1 | v2)
|
|
self.assignOp("^=", func(v1: int, v2: int) -> int:
|
|
return v1 ^ v2)
|
|
self.assignOp("<<=", func(v1: int, v2: int) -> int:
|
|
return v1 << v2)
|
|
self.assignOp(">>=", func(v1: int, v2: int) -> int:
|
|
return v1 >> v2)
|
|
self.assignOp(">>>=", func(v1: int, v2: int) -> int:
|
|
return ((v1 & -1) >> v2) & -1)
|
|
|
|
func setVar(name: String, v) -> void:
|
|
var this1: Variant = self.variables
|
|
|
|
this1.__set(name, v)
|
|
|
|
func assign(e1: Variant, e2: Variant):
|
|
var v = self.expr(e2)
|
|
|
|
match (e1._index):
|
|
1:
|
|
var _g: String = e1.v
|
|
var id: String = _g
|
|
var tempMaybeStruct
|
|
var this1: Variant = self.locals
|
|
tempMaybeStruct = this1.__get(id)
|
|
var l = tempMaybeStruct
|
|
if (l == null):
|
|
self.setVar(id, v)
|
|
else:
|
|
l.set("r", v)
|
|
5:
|
|
var _g: Variant = e1.e
|
|
var _g1: String = e1.f
|
|
if true:
|
|
var e: Variant = _g
|
|
var f: String = _g1
|
|
v = self.__set(self.expr(e), f, v)
|
|
16:
|
|
var _g: Variant = e1.e
|
|
var _g1: Variant = e1.index
|
|
if true:
|
|
var e: Variant = _g
|
|
var index: Variant = _g1
|
|
if true:
|
|
var arr = self.expr(e)
|
|
var index2 = self.expr(index)
|
|
if (((arr as Variant) is Variant)):
|
|
((arr as Variant)).__set(index2, v)
|
|
else:
|
|
arr[index2] = v
|
|
_:
|
|
var e: Variant = { "_index": 7, "op": "=" }
|
|
var rethrow: bool = false
|
|
if (rethrow):
|
|
assert(false, str(e))
|
|
else:
|
|
assert(false, str(e))
|
|
null
|
|
|
|
return v
|
|
|
|
func assignOp(op: String, fop) -> void:
|
|
var me: Interp = self
|
|
var this1: Variant = self.binops
|
|
|
|
this1.__set(op, func(e1: Variant, e2: Variant):
|
|
return me.evalAssignOp(op, fop, e1, e2))
|
|
|
|
func evalAssignOp(op: String, fop, e1: Variant, e2: Variant):
|
|
var v
|
|
|
|
match (e1._index):
|
|
1:
|
|
var _g: String = e1.v
|
|
var id: String = _g
|
|
var tempMaybeStruct
|
|
var this1: Variant = self.locals
|
|
tempMaybeStruct = this1.__get(id)
|
|
var l = tempMaybeStruct
|
|
v = fop.call(self.expr(e1), self.expr(e2))
|
|
if (l == null):
|
|
self.setVar(id, v)
|
|
else:
|
|
l.set("r", v)
|
|
5:
|
|
var _g: Variant = e1.e
|
|
var _g1: String = e1.f
|
|
if true:
|
|
var e: Variant = _g
|
|
var f: String = _g1
|
|
if true:
|
|
var obj = self.expr(e)
|
|
v = fop.call(self.__get(obj, f), self.expr(e2))
|
|
v = self.__set(obj, f, v)
|
|
16:
|
|
var _g: Variant = e1.e
|
|
var _g1: Variant = e1.index
|
|
if true:
|
|
var e: Variant = _g
|
|
var index: Variant = _g1
|
|
if true:
|
|
var arr = self.expr(e)
|
|
var index2 = self.expr(index)
|
|
if (((arr as Variant) is Variant)):
|
|
v = fop.call(((arr as Variant)).__get(index2), self.expr(e2))
|
|
((arr as Variant)).__set(index2, v)
|
|
else:
|
|
v = fop.call(arr[index2], self.expr(e2))
|
|
arr[index2] = v
|
|
_:
|
|
var tempResult
|
|
if true:
|
|
var e: Variant = { "_index": 7, "op": op }
|
|
var rethrow: bool = false
|
|
if (rethrow):
|
|
assert(false, str(e))
|
|
else:
|
|
assert(false, str(e))
|
|
tempResult = null
|
|
return tempResult
|
|
|
|
return v
|
|
|
|
func increment(e: Variant, prefix: bool, delta: int):
|
|
match (e._index):
|
|
1:
|
|
var _g: String = e.v
|
|
var id: String = _g
|
|
if true:
|
|
var tempMaybeStruct
|
|
if true:
|
|
var this1: Variant = self.locals
|
|
tempMaybeStruct = this1.__get(id)
|
|
var l = tempMaybeStruct
|
|
var tempVar
|
|
if (l == null):
|
|
tempVar = self.resolve(id)
|
|
else:
|
|
tempVar = l.get("r")
|
|
var v = tempVar
|
|
if (prefix):
|
|
v += delta
|
|
if (l == null):
|
|
self.setVar(id, v)
|
|
else:
|
|
l.set("r", v)
|
|
else:
|
|
if (l == null):
|
|
self.setVar(id, v + delta)
|
|
else:
|
|
l.set("r", v + delta)
|
|
return v
|
|
5:
|
|
var _g: Variant = e.e
|
|
var _g1: String = e.f
|
|
if true:
|
|
var e2: Variant = _g
|
|
var f: String = _g1
|
|
if true:
|
|
var obj = self.expr(e2)
|
|
var v = self.__get(obj, f)
|
|
if (prefix):
|
|
v += delta
|
|
self.__set(obj, f, v)
|
|
else:
|
|
self.__set(obj, f, v + delta)
|
|
return v
|
|
16:
|
|
var _g: Variant = e.e
|
|
var _g1: Variant = e.index
|
|
if true:
|
|
var e2: Variant = _g
|
|
var index: Variant = _g1
|
|
if true:
|
|
var arr = self.expr(e2)
|
|
var index2 = self.expr(index)
|
|
if (((arr as Variant) is Variant)):
|
|
var v: int = ((arr as Variant)).__get(index2)
|
|
if (prefix):
|
|
v += delta
|
|
((arr as Variant)).__set(index2, v)
|
|
else:
|
|
((arr as Variant)).__set(index2, v + delta)
|
|
return v
|
|
else:
|
|
var v: int = arr[index2]
|
|
if (prefix):
|
|
v += delta
|
|
arr[index2] = v
|
|
else:
|
|
arr[index2] = v + delta
|
|
return v
|
|
_:
|
|
var tempResult
|
|
if true:
|
|
var tempString
|
|
if (delta > 0):
|
|
tempString = "++"
|
|
else:
|
|
tempString = "--"
|
|
var e2: Variant = { "_index": 7, "op": tempString }
|
|
var rethrow: bool = false
|
|
if (rethrow):
|
|
assert(false, str(e2))
|
|
else:
|
|
assert(false, str(e2))
|
|
tempResult = null
|
|
return tempResult
|
|
|
|
func execute(expr: Variant):
|
|
self.depth = 0
|
|
self.locals = haxe_ds_StringMap.new()
|
|
self.declared = []
|
|
|
|
return self.exprReturn(expr)
|
|
|
|
func exprReturn(e: Variant):
|
|
return self.expr(e)
|
|
|
|
return null
|
|
|
|
func duplicate(h: Variant) -> haxe_ds_StringMap:
|
|
var h2: haxe_ds_StringMap = haxe_ds_StringMap.new()
|
|
var k: Variant = h.keys()
|
|
|
|
while (k.get("hasNext").call()):
|
|
var k2: String = k.get("next").call()
|
|
var value = h.__get(k2)
|
|
h2.__set(k2, value)
|
|
|
|
return h2
|
|
|
|
func restore(old: int) -> void:
|
|
while (self.declared.size() > old):
|
|
var d = self.declared.pop_back()
|
|
var this1: Variant = self.locals
|
|
var key: String = d.get("n")
|
|
var value: Variant = d.get("old")
|
|
this1.__set(key, value)
|
|
|
|
func error(e: Variant, rethrow: bool = false):
|
|
if (rethrow):
|
|
assert(false, str(e))
|
|
else:
|
|
assert(false, str(e))
|
|
|
|
return null
|
|
|
|
func rethrow(e) -> void:
|
|
assert(false, str(e))
|
|
|
|
func resolve(id: String):
|
|
var tempMaybeStruct
|
|
|
|
if true:
|
|
var this1: Variant = self.locals
|
|
tempMaybeStruct = this1.__get(id)
|
|
|
|
var l = tempMaybeStruct
|
|
|
|
if (l != null):
|
|
return l.get("r")
|
|
|
|
var tempMaybeVar
|
|
|
|
if true:
|
|
var this1: Variant = self.variables
|
|
tempMaybeVar = this1.__get(id)
|
|
|
|
var v = tempMaybeVar
|
|
var tempBool
|
|
|
|
if true:
|
|
var this1: Variant = self.variables
|
|
tempBool = this1.exists(id)
|
|
|
|
if (v == null && !tempBool):
|
|
var e: Variant = { "_index": 5, "v": id }
|
|
var rethrow: bool = false
|
|
if (rethrow):
|
|
assert(false, str(e))
|
|
else:
|
|
assert(false, str(e))
|
|
null
|
|
|
|
return v
|
|
|
|
func expr(e: Variant):
|
|
var _gthis: Interp = self
|
|
|
|
match (e._index):
|
|
0:
|
|
var _g: Variant = e.c
|
|
if true:
|
|
var c: Variant = _g
|
|
match (c._index):
|
|
0:
|
|
var _g2: int = c.v
|
|
if true:
|
|
var v: int = _g2
|
|
return v
|
|
1:
|
|
var _g2: float = c.f
|
|
if true:
|
|
var f: float = _g2
|
|
return f
|
|
2:
|
|
var _g2: String = c.s
|
|
if true:
|
|
var s: String = _g2
|
|
return s
|
|
1:
|
|
var _g: String = e.v
|
|
var id: String = _g
|
|
return self.resolve(id)
|
|
2:
|
|
var _g: String = e.n
|
|
var _g1 = e.t
|
|
var _g2 = e.e
|
|
if true:
|
|
var n: String = _g
|
|
var e2 = _g2
|
|
if true:
|
|
var tempMaybeStruct
|
|
if true:
|
|
var this1: Variant = self.locals
|
|
tempMaybeStruct = this1.__get(n)
|
|
self.declared.push_back({
|
|
"n": n,
|
|
"old": tempMaybeStruct
|
|
})
|
|
if true:
|
|
var this1: Variant = self.locals
|
|
var tempVar
|
|
if (e2 == null):
|
|
tempVar = null
|
|
else:
|
|
tempVar = self.expr(e2)
|
|
var value: Variant = {
|
|
"r": tempVar
|
|
}
|
|
this1.__set(n, value)
|
|
return null
|
|
3:
|
|
var _g: Variant = e.e
|
|
if true:
|
|
var e2: Variant = _g
|
|
return self.expr(e2)
|
|
4:
|
|
var _g: Array[Variant] = e.e
|
|
var exprs: Array[Variant] = _g
|
|
if true:
|
|
var old: int = self.declared.size()
|
|
var v = null
|
|
if true:
|
|
var _g2: int = 0
|
|
while (_g2 < exprs.size()):
|
|
var e2: Variant = exprs[_g2]
|
|
_g2 += 1
|
|
v = self.expr(e2)
|
|
self.restore(old)
|
|
return v
|
|
5:
|
|
var _g: Variant = e.e
|
|
var _g1: String = e.f
|
|
if true:
|
|
var e2: Variant = _g
|
|
var f: String = _g1
|
|
return self.__get(self.expr(e2), f)
|
|
6:
|
|
var _g: String = e.op
|
|
var _g1: Variant = e.e1
|
|
var _g2: Variant = e.e2
|
|
if true:
|
|
var op: String = _g
|
|
var e1: Variant = _g1
|
|
var e2: Variant = _g2
|
|
if true:
|
|
var tempMaybeFunction
|
|
if true:
|
|
var this1: Variant = self.binops
|
|
tempMaybeFunction = this1.__get(op)
|
|
var fop = tempMaybeFunction
|
|
if (fop == null):
|
|
var e3: Variant = { "_index": 7, "op": op }
|
|
var rethrow: bool = false
|
|
if (rethrow):
|
|
assert(false, str(e3))
|
|
else:
|
|
assert(false, str(e3))
|
|
null
|
|
return fop.call(e1, e2)
|
|
7:
|
|
var _g: String = e.op
|
|
var _g1: bool = e.prefix
|
|
var _g2: Variant = e.e
|
|
if true:
|
|
var op: String = _g
|
|
var prefix: bool = _g1
|
|
var e2: Variant = _g2
|
|
match (op):
|
|
"!":
|
|
return self.expr(e2) != true
|
|
"++":
|
|
return self.increment(e2, prefix, 1)
|
|
"-":
|
|
return -self.expr(e2)
|
|
"--":
|
|
return self.increment(e2, prefix, -1)
|
|
"~":
|
|
return ~self.expr(e2)
|
|
_:
|
|
var e3: Variant = { "_index": 7, "op": op }
|
|
var rethrow: bool = false
|
|
if (rethrow):
|
|
assert(false, str(e3))
|
|
else:
|
|
assert(false, str(e3))
|
|
null
|
|
8:
|
|
var _g: Variant = e.e
|
|
var _g1: Array[Variant] = e.params
|
|
if true:
|
|
var e2: Variant = _g
|
|
var params: Array[Variant] = _g1
|
|
if true:
|
|
var args: Array[Variant] = []
|
|
if true:
|
|
var _g2: int = 0
|
|
while (_g2 < params.size()):
|
|
var p: Variant = params[_g2]
|
|
_g2 += 1
|
|
args.push_back(self.expr(p))
|
|
if (e2._index == 5):
|
|
var _g2: Variant = e2.e
|
|
var _g3: String = e2.f
|
|
if true:
|
|
var e3: Variant = _g2
|
|
var f: String = _g3
|
|
if true:
|
|
var obj = self.expr(e3)
|
|
if (obj == null):
|
|
var e4: Variant = { "_index": 8, "f": f }
|
|
var rethrow: bool = false
|
|
if (rethrow):
|
|
assert(false, str(e4))
|
|
else:
|
|
assert(false, str(e4))
|
|
null
|
|
return self.fcall(obj, f, args)
|
|
else:
|
|
return self._call(null, self.expr(e2), args)
|
|
9:
|
|
var _g: Variant = e.cond
|
|
var _g1: Variant = e.e1
|
|
var _g2 = e.e2
|
|
if true:
|
|
var econd: Variant = _g
|
|
var e1: Variant = _g1
|
|
var e2 = _g2
|
|
var tempResult
|
|
if (self.expr(econd) == true):
|
|
tempResult = self.expr(e1)
|
|
else:
|
|
if (e2 == null):
|
|
tempResult = null
|
|
else:
|
|
tempResult = self.expr(e2)
|
|
return tempResult
|
|
10:
|
|
var _g: Variant = e.cond
|
|
var _g1: Variant = e.e
|
|
if true:
|
|
var econd: Variant = _g
|
|
var e2: Variant = _g1
|
|
if true:
|
|
self.whileLoop(econd, e2)
|
|
return null
|
|
11:
|
|
var _g: String = e.v
|
|
var _g1: Variant = e.it
|
|
var _g2: Variant = e.e
|
|
if true:
|
|
var v: String = _g
|
|
var it: Variant = _g1
|
|
var e2: Variant = _g2
|
|
if true:
|
|
self.forLoop(v, it, e2)
|
|
return null
|
|
12:
|
|
assert(false, str(Stop.Stop.SBreak))
|
|
13:
|
|
assert(false, str(Stop.Stop.SContinue))
|
|
14:
|
|
var _g: Array[Variant] = e.args
|
|
var _g1: Variant = e.e
|
|
var _g2 = e.name
|
|
var _g3 = e.ret
|
|
if true:
|
|
var params: Array[Variant] = _g
|
|
var fexpr: Variant = _g1
|
|
var name = _g2
|
|
if true:
|
|
var capturedLocals: haxe_ds_StringMap = self.duplicate(self.locals)
|
|
var me: Interp = self
|
|
var hasOpt: bool = false
|
|
var minParams = [0]
|
|
if true:
|
|
var _g4: int = 0
|
|
while (_g4 < params.size()):
|
|
var p: Variant = params[_g4]
|
|
_g4 += 1
|
|
if (p.get("opt")):
|
|
hasOpt = true
|
|
else:
|
|
minParams[0] += 1
|
|
var f = func(args: Array[Variant]):
|
|
var tempNumber
|
|
if (args == null):
|
|
tempNumber = 0
|
|
else:
|
|
tempNumber = args.size()
|
|
if ((tempNumber) != params.size()):
|
|
if (args.size() < minParams[0]):
|
|
var _str: String = "Invalid number of parameters. Got " + str(args.size()) + ", required " + str(minParams[0])
|
|
if (name != null):
|
|
_str += " for function '" + name + "'"
|
|
if true:
|
|
var e2: Variant = { "_index": 9, "msg": _str }
|
|
var rethrow: bool = false
|
|
if (rethrow):
|
|
assert(false, str(e2))
|
|
else:
|
|
assert(false, str(e2))
|
|
null
|
|
var args2: Array[Variant] = ([] as Array[Variant])
|
|
var extraParams: int = args.size() - minParams[0]
|
|
var pos: int = 0
|
|
if true:
|
|
var _g4: int = 0
|
|
while (_g4 < params.size()):
|
|
var p: Variant = params[_g4]
|
|
_g4 += 1
|
|
if (p.get("opt")):
|
|
if (extraParams > 0):
|
|
var tempIndex
|
|
if true:
|
|
pos += 1
|
|
tempIndex = pos - 1
|
|
args2.push_back(args[tempIndex])
|
|
extraParams -= 1
|
|
else:
|
|
args2.push_back(null)
|
|
else:
|
|
var tempIndex1
|
|
if true:
|
|
pos += 1
|
|
tempIndex1 = pos - 1
|
|
args2.push_back(args[tempIndex1])
|
|
args = args2
|
|
var old: Variant = me.locals
|
|
var depth2: int = me.depth
|
|
me.depth += 1
|
|
me.locals = me.duplicate(capturedLocals)
|
|
if true:
|
|
var _g4: int = 0
|
|
var _g5: int = params.size()
|
|
while (_g4 < _g5):
|
|
var tempNumber1
|
|
if true:
|
|
_g4 += 1
|
|
tempNumber1 = _g4 - 1
|
|
var i: int = tempNumber1
|
|
if true:
|
|
var this1: Variant = me.locals
|
|
var key: String = params[i].get("name")
|
|
this1.__set(key, {
|
|
"r": args[i]
|
|
})
|
|
var r = null
|
|
var oldDecl: int = _gthis.declared.size()
|
|
if (_gthis.inTry):
|
|
r = me.exprReturn(fexpr)
|
|
else:
|
|
r = me.exprReturn(fexpr)
|
|
_gthis.restore(oldDecl)
|
|
me.locals = old
|
|
me.depth = depth2
|
|
return r
|
|
var f2 = Reflect.makeVarArgs(f)
|
|
if (name != null):
|
|
if (self.depth == 0):
|
|
var this1: Variant = self.variables
|
|
this1.__set(name, f2)
|
|
else:
|
|
var tempMaybeStruct1
|
|
if true:
|
|
var this1: Variant = self.locals
|
|
tempMaybeStruct1 = this1.__get(name)
|
|
self.declared.push_back({
|
|
"n": name,
|
|
"old": tempMaybeStruct1
|
|
})
|
|
var ref: Variant = {
|
|
"r": f2
|
|
}
|
|
if true:
|
|
var this1: Variant = self.locals
|
|
this1.__set(name, ref)
|
|
capturedLocals.__set(name, ref)
|
|
return f2
|
|
15:
|
|
var _g = e.e
|
|
if true:
|
|
var e2 = _g
|
|
if true:
|
|
var tempRight
|
|
if (e2 == null):
|
|
tempRight = null
|
|
else:
|
|
tempRight = self.expr(e2)
|
|
self.returnValue = tempRight
|
|
assert(false, str(Stop.Stop.SReturn))
|
|
16:
|
|
var _g: Variant = e.e
|
|
var _g1: Variant = e.index
|
|
if true:
|
|
var e2: Variant = _g
|
|
var index: Variant = _g1
|
|
if true:
|
|
var arr = self.expr(e2)
|
|
var index2 = self.expr(index)
|
|
if (((arr as Variant) is Variant)):
|
|
return ((arr as Variant)).__get(index2)
|
|
else:
|
|
return arr[index2]
|
|
17:
|
|
var _g: Array[Variant] = e.e
|
|
if true:
|
|
var arr: Array[Variant] = _g
|
|
var tempRight1
|
|
if true:
|
|
var _g2: Variant = arr[0]
|
|
if (_g2._index == 6):
|
|
var _g1: String = _g2.op
|
|
var _g3: Variant = _g2.e1
|
|
var _g4: Variant = _g2.e2
|
|
if (_g1 == "=>"):
|
|
tempRight1 = true
|
|
else:
|
|
tempRight1 = false
|
|
else:
|
|
tempRight1 = false
|
|
if (arr.size() > 0 && tempRight1):
|
|
var isAllString: bool = true
|
|
var isAllInt: bool = true
|
|
var isAllObject: bool = true
|
|
var isAllEnum: bool = true
|
|
var keys: Array[Variant] = ([] as Array[Variant])
|
|
var values: Array[Variant] = ([] as Array[Variant])
|
|
if true:
|
|
var _g2: int = 0
|
|
while (_g2 < arr.size()):
|
|
var e2: Variant = arr[_g2]
|
|
_g2 += 1
|
|
if (e2._index == 6):
|
|
var _g3: String = e2.op
|
|
var _g1: Variant = e2.e1
|
|
var _g4: Variant = e2.e2
|
|
if (_g3 == "=>"):
|
|
var eKey: Variant = _g1
|
|
var eValue: Variant = _g4
|
|
if true:
|
|
var key = self.expr(eKey)
|
|
var value = self.expr(eValue)
|
|
isAllString = isAllString && ((key as Variant) is String)
|
|
isAllInt = isAllInt && ((key as Variant) is int)
|
|
isAllObject = isAllObject && (key as Variant) is Object
|
|
isAllEnum = isAllEnum && (key as Variant) is Dictionary
|
|
keys.push_back(key)
|
|
values.push_back(value)
|
|
else:
|
|
assert(false, str("=> expected"))
|
|
else:
|
|
assert(false, str("=> expected"))
|
|
var tempVar1
|
|
if (isAllInt):
|
|
tempVar1 = haxe_ds_IntMap.new()
|
|
else:
|
|
if (isAllString):
|
|
tempVar1 = haxe_ds_StringMap.new()
|
|
else:
|
|
if (isAllObject):
|
|
tempVar1 = haxe_ds_ObjectMap.new()
|
|
else:
|
|
assert(false, str("Inconsistent key types"))
|
|
var map = tempVar1
|
|
if true:
|
|
var _g2: int = 0
|
|
var _g1: int = keys.size()
|
|
while (_g2 < _g1):
|
|
var tempNumber2
|
|
if true:
|
|
_g2 += 1
|
|
tempNumber2 = _g2 - 1
|
|
var n: int = tempNumber2
|
|
((map as Variant)).__set(keys[n], values[n])
|
|
return map
|
|
else:
|
|
var a: Array[Variant] = []
|
|
if true:
|
|
var _g2: int = 0
|
|
while (_g2 < arr.size()):
|
|
var e2: Variant = arr[_g2]
|
|
_g2 += 1
|
|
a.push_back(self.expr(e2))
|
|
return a
|
|
18:
|
|
var _g: String = e.cl
|
|
var _g1: Array[Variant] = e.params
|
|
if true:
|
|
var cl: String = _g
|
|
var params: Array[Variant] = _g1
|
|
if true:
|
|
var a: Array[Variant] = []
|
|
if true:
|
|
var _g2: int = 0
|
|
while (_g2 < params.size()):
|
|
var e2: Variant = params[_g2]
|
|
_g2 += 1
|
|
a.push_back(self.expr(e2))
|
|
return self.cnew(cl, a)
|
|
19:
|
|
var _g: Variant = e.e
|
|
if true:
|
|
var e2: Variant = _g
|
|
assert(false, str(self.expr(e2)))
|
|
20:
|
|
var _g: Variant = e.e
|
|
var _g1: String = e.v
|
|
var _g2 = e.t
|
|
var _g3: Variant = e.ecatch
|
|
if true:
|
|
var e2: Variant = _g
|
|
var n: String = _g1
|
|
var ecatch: Variant = _g3
|
|
if true:
|
|
var old: int = self.declared.size()
|
|
var oldTry: bool = self.inTry
|
|
if true:
|
|
self.inTry = true
|
|
var v = self.expr(e2)
|
|
self.restore(old)
|
|
self.inTry = oldTry
|
|
return v
|
|
21:
|
|
var _g: Array[Variant] = e.fl
|
|
var fl: Array[Variant] = _g
|
|
var o: Variant = {
|
|
}
|
|
if true:
|
|
var _g2: int = 0
|
|
while (_g2 < fl.size()):
|
|
var f: Variant = fl[_g2]
|
|
_g2 += 1
|
|
self.__set(o, f.get("name"), self.expr(f.get("e")))
|
|
return o
|
|
22:
|
|
var _g: Variant = e.cond
|
|
var _g1: Variant = e.e1
|
|
var _g2: Variant = e.e2
|
|
if true:
|
|
var econd: Variant = _g
|
|
var e1: Variant = _g1
|
|
var e2: Variant = _g2
|
|
var tempResult1
|
|
if (self.expr(econd) == true):
|
|
tempResult1 = self.expr(e1)
|
|
else:
|
|
tempResult1 = self.expr(e2)
|
|
return tempResult1
|
|
23:
|
|
var _g: Variant = e.e
|
|
var _g1: Array[Variant] = e.cases
|
|
var _g2 = e.defaultExpr
|
|
if true:
|
|
var e2: Variant = _g
|
|
var cases: Array[Variant] = _g1
|
|
var def = _g2
|
|
if true:
|
|
var val = self.expr(e2)
|
|
var _match: bool = false
|
|
if true:
|
|
var _g3: int = 0
|
|
while (_g3 < cases.size()):
|
|
var c: Variant = cases[_g3]
|
|
_g3 += 1
|
|
if true:
|
|
var _g4: int = 0
|
|
var _g5: Array[Variant] = c.get("values")
|
|
while (_g4 < _g5.size()):
|
|
var v: Variant = _g5[_g4]
|
|
_g4 += 1
|
|
if (self.expr(v) == val):
|
|
_match = true
|
|
break
|
|
if (_match):
|
|
val = self.expr(c.get("expr"))
|
|
break
|
|
if (!_match):
|
|
var tempRight2
|
|
if (def == null):
|
|
tempRight2 = null
|
|
else:
|
|
tempRight2 = self.expr(def)
|
|
val = tempRight2
|
|
return val
|
|
24:
|
|
var _g: Variant = e.cond
|
|
var _g1: Variant = e.e
|
|
if true:
|
|
var econd: Variant = _g
|
|
var e2: Variant = _g1
|
|
if true:
|
|
self.doWhileLoop(econd, e2)
|
|
return null
|
|
25:
|
|
var _g: String = e.name
|
|
var _g2: Array[Variant] = e.args
|
|
var _g3: Variant = e.e
|
|
if true:
|
|
var e2: Variant = _g3
|
|
return self.expr(e2)
|
|
26:
|
|
var _g: Variant = e.e
|
|
var _g1: Variant = e.t
|
|
if true:
|
|
var e2: Variant = _g
|
|
return self.expr(e2)
|
|
|
|
return null
|
|
|
|
func doWhileLoop(econd: Variant, e: Variant) -> void:
|
|
var old: int = self.declared.size()
|
|
|
|
while true:
|
|
self.expr(e)
|
|
if !(self.expr(econd) == true):
|
|
break
|
|
|
|
self.restore(old)
|
|
|
|
func whileLoop(econd: Variant, e: Variant) -> void:
|
|
var old: int = self.declared.size()
|
|
|
|
while (self.expr(econd) == true):
|
|
self.expr(e)
|
|
|
|
self.restore(old)
|
|
|
|
func makeIterator(v) -> Variant:
|
|
v = v.iterator.call()
|
|
|
|
if (v.hasNext == null || v.next == null):
|
|
var e: Variant = { "_index": 6, "v": v }
|
|
var rethrow: bool = false
|
|
if (rethrow):
|
|
assert(false, str(e))
|
|
else:
|
|
assert(false, str(e))
|
|
null
|
|
|
|
return v
|
|
|
|
func forLoop(n: String, it: Variant, e: Variant) -> void:
|
|
var old: int = self.declared.size()
|
|
var tempMaybeStruct
|
|
|
|
if true:
|
|
var this1: Variant = self.locals
|
|
tempMaybeStruct = this1.__get(n)
|
|
|
|
self.declared.push_back({
|
|
"n": n,
|
|
"old": tempMaybeStruct
|
|
})
|
|
|
|
var it2: Variant = self.makeIterator(self.expr(it))
|
|
|
|
while (it2.get("hasNext").call()):
|
|
if true:
|
|
var this1: Variant = self.locals
|
|
var value: Variant = {
|
|
"r": it2.get("next").call()
|
|
}
|
|
this1.__set(n, value)
|
|
self.expr(e)
|
|
|
|
self.restore(old)
|
|
|
|
func isMap(o) -> bool:
|
|
return ((o as Variant) is Variant)
|
|
|
|
func getMapValue(map, key):
|
|
return ((map as Variant)).__get(key)
|
|
|
|
func setMapValue(map, key, value) -> void:
|
|
((map as Variant)).__set(key, value)
|
|
|
|
func __get(o, f: String):
|
|
if (o == null):
|
|
var e: Variant = { "_index": 8, "f": f }
|
|
var rethrow: bool = false
|
|
if (rethrow):
|
|
assert(false, str(e))
|
|
else:
|
|
assert(false, str(e))
|
|
null
|
|
|
|
return Reflect.getProperty(o, f)
|
|
|
|
func __set(o, f: String, v):
|
|
if (o == null):
|
|
var e: Variant = { "_index": 8, "f": f }
|
|
var rethrow: bool = false
|
|
if (rethrow):
|
|
assert(false, str(e))
|
|
else:
|
|
assert(false, str(e))
|
|
null
|
|
|
|
Reflect.setProperty(o, f, v)
|
|
|
|
return v
|
|
|
|
func fcall(o, f: String, args: Array[Variant]):
|
|
return self._call(o, self.__get(o, f), args)
|
|
|
|
func _call(o, f, args: Array[Variant]):
|
|
return f.callv(args)
|
|
|
|
func cnew(cl: String, args: Array[Variant]):
|
|
return null
|