forked from LeenkxTeam/LNXSDK
618 lines
19 KiB
Haxe
618 lines
19 KiB
Haxe
/*
|
|
* Copyright (C)2005-2019 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.
|
|
*/
|
|
|
|
package jvm;
|
|
|
|
import Enum;
|
|
import haxe.Constraints;
|
|
import haxe.ds.Option;
|
|
import haxe.ds.Vector;
|
|
import haxe.extern.Rest;
|
|
import java.Init;
|
|
import java.NativeArray;
|
|
import java.lang.NullPointerException;
|
|
import jvm.DynamicObject;
|
|
import jvm.EmptyConstructor;
|
|
import jvm.Object;
|
|
import jvm.annotation.ClassReflectionInformation;
|
|
import jvm.annotation.EnumReflectionInformation;
|
|
import jvm.annotation.EnumValueReflectionInformation;
|
|
|
|
@:keep
|
|
@:native('haxe.jvm.Jvm')
|
|
class Jvm {
|
|
extern static public function instanceof<S, T>(obj:S, type:T):Bool;
|
|
|
|
extern static public function referenceEquals<T>(v1:T, v2:T):Bool;
|
|
|
|
static public function stringCompare(v1:String, v2:String):Int {
|
|
if (v1 == null) {
|
|
return v2 == null ? 0 : 1;
|
|
}
|
|
if (v2 == null) {
|
|
return -1;
|
|
}
|
|
return (cast v1 : java.NativeString).compareTo(v2);
|
|
}
|
|
|
|
static public function compare<T>(v1:T, v2:T):Int {
|
|
return Reflect.compare(v1, v2);
|
|
}
|
|
|
|
static public function enumEq(v1:Dynamic, v2:Dynamic) {
|
|
if (!instanceof(v1, jvm.Enum)) {
|
|
return false;
|
|
}
|
|
if (!instanceof(v2, jvm.Enum)) {
|
|
return false;
|
|
}
|
|
return Type.enumEq(v1, v2);
|
|
}
|
|
|
|
static public function maybeEnumEq(v1:Dynamic, v2:Dynamic) {
|
|
if (!instanceof(v1, jvm.Enum)) {
|
|
return compare(v1, v2) == 0;
|
|
}
|
|
if (!instanceof(v2, jvm.Enum)) {
|
|
return compare(v1, v2) == 0;
|
|
}
|
|
return Type.enumEq(v1, v2);
|
|
}
|
|
|
|
// calls
|
|
|
|
static public function getArgumentTypes(args:NativeArray<Dynamic>):NativeArray<java.lang.Class<Dynamic>> {
|
|
var argTypes:NativeArray<java.lang.Class<Dynamic>> = new NativeArray(args.length);
|
|
for (i in 0...args.length) {
|
|
var arg = (cast args[i] : java.lang.Object);
|
|
argTypes[i] = arg == null ? (cast java.lang.Object) : arg.getClass();
|
|
}
|
|
return argTypes;
|
|
}
|
|
|
|
static public function unifyCallArguments(args:NativeArray<Dynamic>, params:NativeArray<java.lang.Class<Dynamic>>,
|
|
allowPadding:Bool = false):Option<NativeArray<Dynamic>> {
|
|
var callArgs:NativeArray<Dynamic> = {
|
|
if (args.length < params.length) {
|
|
var callArgs = new NativeArray(params.length);
|
|
Vector.blit(cast args, 0, cast callArgs, 0, args.length);
|
|
callArgs;
|
|
} else {
|
|
Vector.fromData(args).copy().toData();
|
|
}
|
|
}
|
|
if (params.length < args.length) {
|
|
return None;
|
|
}
|
|
for (i in 0...params.length) {
|
|
var paramType = params[i];
|
|
if (i >= args.length) {
|
|
if (paramType == cast Bool) {
|
|
callArgs[i] = false;
|
|
} else if (paramType == cast Float) {
|
|
callArgs[i] = 0.0;
|
|
} else if (paramType == cast Int) {
|
|
callArgs[i] = 0;
|
|
} else {
|
|
if (!allowPadding) {
|
|
return None;
|
|
}
|
|
callArgs[i] = null;
|
|
}
|
|
continue;
|
|
}
|
|
var argValue = args[i];
|
|
if (argValue == null) {
|
|
if (paramType.isPrimitive()) {
|
|
if (paramType == cast Bool) {
|
|
callArgs[i] = false;
|
|
} else if (paramType == cast Float) {
|
|
callArgs[i] = 0.0;
|
|
} else if (paramType == cast Int) {
|
|
callArgs[i] = 0;
|
|
} else {
|
|
throw 'Unexpected basic type: $paramType';
|
|
}
|
|
} else {
|
|
callArgs[i] = null;
|
|
}
|
|
continue;
|
|
};
|
|
var argType = (argValue : java.lang.Object).getClass();
|
|
var arg = getWrapperClass(paramType);
|
|
if (arg.isAssignableFrom(argType)) {
|
|
callArgs[i] = args[i];
|
|
continue;
|
|
}
|
|
if (arg == (cast java.lang.Double.DoubleClass) && argType == cast java.lang.Integer.IntegerClass) {
|
|
callArgs[i] = numberToDouble(args[i]);
|
|
} else {
|
|
return None;
|
|
}
|
|
}
|
|
return Some(callArgs);
|
|
}
|
|
|
|
static public function call(func:jvm.Function, args:NativeArray<Dynamic>) {
|
|
return func.invokeDynamic(args);
|
|
}
|
|
|
|
// casts
|
|
|
|
static public function dynamicToByte<T>(d:T):Null<java.lang.Byte> {
|
|
if (instanceof(d, java.lang.Number)) {
|
|
return numberToByte(cast d);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static public function dynamicToShort<T>(d:T):Null<java.lang.Short> {
|
|
if (instanceof(d, java.lang.Number)) {
|
|
return numberToShort(cast d);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static public function dynamicToInteger<T>(d:T):Null<Int> {
|
|
if (instanceof(d, java.lang.Number)) {
|
|
return numberToInteger(cast d);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static public function dynamicToLong<T>(d:T):Null<java.lang.Long> {
|
|
if (instanceof(d, java.lang.Number)) {
|
|
return numberToLong(cast d);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static public function dynamicToFloat<T>(d:T):Null<java.lang.Float> {
|
|
if (instanceof(d, java.lang.Number)) {
|
|
return numberToFloat(cast d);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static public function dynamicToDouble<T>(d:T):Null<Float> {
|
|
if (instanceof(d, java.lang.Number)) {
|
|
return numberToDouble(cast d);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static public function numberToByte(n:java.lang.Number):Null<java.lang.Byte> {
|
|
return n == null ? null : n.byteValue();
|
|
}
|
|
|
|
static public function numberToShort(n:java.lang.Number):Null<java.lang.Short> {
|
|
return n == null ? null : n.shortValue();
|
|
}
|
|
|
|
static public function numberToInteger(n:java.lang.Number):Null<Int> {
|
|
return n == null ? null : n.intValue();
|
|
}
|
|
|
|
static public function numberToLong(n:java.lang.Number):Null<java.lang.Long> {
|
|
return n == null ? null : n.longValue();
|
|
}
|
|
|
|
static public function numberToFloat(n:java.lang.Number):Null<java.lang.Float> {
|
|
return n == null ? null : n.floatValue();
|
|
}
|
|
|
|
static public function numberToDouble(n:java.lang.Number):Null<Float> {
|
|
return n == null ? null : n.doubleValue();
|
|
}
|
|
|
|
static public function toByte(d:Dynamic) {
|
|
return d == null ? 0 : (d : java.lang.Number).byteValue();
|
|
}
|
|
|
|
static public function toChar(d:Dynamic) {
|
|
return d == null ? 0 : (d : java.lang.Character).charValue();
|
|
}
|
|
|
|
static public function toDouble(d:Dynamic) {
|
|
return d == null ? 0. : (d : java.lang.Number).doubleValue();
|
|
}
|
|
|
|
static public function toFloat(d:Dynamic):Single {
|
|
return d == null ? 0. : (d : java.lang.Number).floatValue();
|
|
}
|
|
|
|
static public function toInt(d:Dynamic) {
|
|
return d == null ? 0 : (d : java.lang.Number).intValue();
|
|
}
|
|
|
|
static public function toLong(d:Dynamic) {
|
|
return d == null ? 0 : (d : java.lang.Number).longValue();
|
|
}
|
|
|
|
static public function toShort(d:Dynamic) {
|
|
return d == null ? 0 : (d : java.lang.Number).shortValue();
|
|
}
|
|
|
|
static public function toBoolean(d:Dynamic) {
|
|
return d == null ? false : (d : java.lang.Boolean).booleanValue();
|
|
}
|
|
|
|
static public function getWrapperClass<S, T>(c:java.lang.Class<S>):java.lang.Class<S> {
|
|
if (!c.isPrimitive()) {
|
|
return c;
|
|
}
|
|
// TODO: other basic types
|
|
return if (c == cast Int) {
|
|
cast java.lang.Integer.IntegerClass;
|
|
} else if (c == cast Float) {
|
|
cast java.lang.Double.DoubleClass;
|
|
} else if (c == cast Bool) {
|
|
cast java.lang.Boolean.BooleanClass;
|
|
} else {
|
|
c;
|
|
}
|
|
}
|
|
|
|
// access
|
|
|
|
static public function arrayRead(obj:Dynamic, index:Int) {
|
|
if (instanceof(obj, Array)) {
|
|
return (obj : Array<Dynamic>)[index];
|
|
}
|
|
throw 'Cannot array-read on $obj';
|
|
}
|
|
|
|
static public function arrayWrite(obj:Dynamic, index:Int, value:Dynamic):Void {
|
|
if (instanceof(obj, Array)) {
|
|
(obj : Array<Dynamic>)[index] = value;
|
|
return;
|
|
}
|
|
throw 'Cannot array-write on $obj';
|
|
}
|
|
|
|
static public function readFieldClosure(obj:Dynamic, name:String, parameterTypes:NativeArray<java.lang.Class<Dynamic>>):Dynamic {
|
|
var cl = (obj : java.lang.Object).getClass();
|
|
var method = cl.getMethod(name, parameterTypes);
|
|
if (method.isBridge()) {
|
|
/* This is probably not what we want... go through all methods and see if we find one that
|
|
isn't a bridge. This is pretty awkward, but I can't figure out how to use the Java reflection
|
|
API properly. */
|
|
for (meth in cl.getMethods()) {
|
|
if (meth.getName() == name && !meth.isBridge() && method.getParameterTypes().length == parameterTypes.length) {
|
|
method = meth;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return new jvm.Closure(obj, method);
|
|
}
|
|
|
|
static function readStaticField<T>(cl:java.lang.Class<T>, name:String):Dynamic {
|
|
var methods = cl.getMethods();
|
|
for (m in methods) {
|
|
if (m.getName() == name && !m.isSynthetic()) {
|
|
return new jvm.Closure(null, m);
|
|
}
|
|
}
|
|
try {
|
|
var field = cl.getField(name);
|
|
field.setAccessible(true);
|
|
return field.get(null);
|
|
} catch (_:java.lang.NoSuchFieldException) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
static public function readFieldNoObject(obj:Dynamic, name:String):Dynamic {
|
|
var cl = (obj : java.lang.Object).getClass();
|
|
try {
|
|
var field = cl.getField(name);
|
|
field.setAccessible(true);
|
|
return field.get(obj);
|
|
} catch (_:java.lang.NoSuchFieldException) {
|
|
while (cl != null) {
|
|
var methods = cl.getMethods();
|
|
for (m in methods) {
|
|
if (m.getName() == name && !m.isSynthetic()) {
|
|
return new jvm.Closure(obj, m);
|
|
}
|
|
}
|
|
cl = cl.getSuperclass();
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
static public function readField(obj:Dynamic, name:String):Dynamic {
|
|
if (obj == null) {
|
|
throw new NullPointerException(name);
|
|
}
|
|
if (name == null) {
|
|
return null;
|
|
}
|
|
if (instanceof(obj, jvm.Object)) {
|
|
return (cast obj : jvm.Object)._hx_getField(name);
|
|
}
|
|
if (instanceof(obj, java.lang.Class)) {
|
|
return readStaticField(cast obj, name);
|
|
}
|
|
if (instanceof(obj, java.NativeString)) {
|
|
switch (name) {
|
|
case "length":
|
|
return (obj : String).length;
|
|
case "charAt":
|
|
return StringExt.charAt.bind(obj);
|
|
case "charCodeAt":
|
|
return StringExt.charCodeAt.bind(obj);
|
|
case "indexOf":
|
|
return StringExt.indexOf.bind(obj);
|
|
case "iterator":
|
|
return function() return new haxe.iterators.StringIterator(obj);
|
|
case "keyValueIterator":
|
|
return function() return new haxe.iterators.StringKeyValueIterator(obj);
|
|
case "lastIndexOf":
|
|
return StringExt.lastIndexOf.bind(obj);
|
|
case "split":
|
|
return StringExt.split.bind(obj);
|
|
case "substr":
|
|
return StringExt.substr.bind(obj);
|
|
case "substring":
|
|
return StringExt.substring.bind(obj);
|
|
case "toLowerCase":
|
|
return StringExt.toLowerCase.bind(obj);
|
|
case "toUpperCase":
|
|
return StringExt.toUpperCase.bind(obj);
|
|
}
|
|
}
|
|
return readFieldNoObject(obj, name);
|
|
}
|
|
|
|
static public function writeFieldNoObject<T>(obj:Dynamic, name:String, value:T) {
|
|
try {
|
|
var cl = (obj : java.lang.Object).getClass();
|
|
var field = cl.getField(name);
|
|
field.setAccessible(true);
|
|
try {
|
|
field.set(obj, value);
|
|
} catch (_:java.lang.IllegalArgumentException) {
|
|
if (value == null) {
|
|
field.setByte(obj, 0); // rely on widening
|
|
} else if (field.getType() == (cast Int) && instanceof(value, java.lang.Number)) {
|
|
// Can happen with ++ on Dynamic because that defaults to Float
|
|
field.setInt(obj, (cast value : java.lang.Number).intValue());
|
|
}
|
|
}
|
|
} catch (_:java.lang.NoSuchFieldException) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
static public function writeField<T>(obj:Dynamic, name:String, value:T) {
|
|
if (obj == null || name == null) {
|
|
return;
|
|
}
|
|
if (instanceof(obj, Object)) {
|
|
return (obj : Object)._hx_setField(name, value);
|
|
}
|
|
writeFieldNoObject(obj, name, value);
|
|
}
|
|
|
|
// string
|
|
|
|
static public function toString<T:java.lang.Object>(obj:T):String {
|
|
if (obj == null) {
|
|
return "null";
|
|
} else if (instanceof(obj, java.lang.Double.DoubleClass)) {
|
|
var n:java.lang.Number = cast obj;
|
|
if (n.doubleValue() == n.intValue()) {
|
|
return java.lang.Integer.IntegerClass.valueOf(n.intValue()).toString();
|
|
}
|
|
return obj.toString();
|
|
} else {
|
|
return obj.toString();
|
|
}
|
|
}
|
|
|
|
static public function stringConcat<A:java.lang.Object, B:java.lang.Object>(a:A, b:B):String {
|
|
return (cast toString(a) : java.NativeString).concat(toString(b));
|
|
}
|
|
|
|
// ops
|
|
|
|
static public function opAdd<T1:java.lang.Object, T2:java.lang.Object>(a:T1, b:T2):Dynamic {
|
|
if (instanceof(a, java.NativeString) || instanceof(b, java.NativeString)) {
|
|
return stringConcat(a, b);
|
|
}
|
|
if (instanceof(a, java.lang.Double.DoubleClass) || instanceof(b, java.lang.Double.DoubleClass)) {
|
|
return toDouble(a) + toDouble(b);
|
|
}
|
|
if (instanceof(a, java.lang.Long.LongClass) || instanceof(b, java.lang.Long.LongClass)) {
|
|
return toLong(a) + toLong(b);
|
|
}
|
|
if (instanceof(a, java.lang.Integer.IntegerClass) || instanceof(b, java.lang.Integer.IntegerClass)) {
|
|
return toInt(a) + toInt(b);
|
|
}
|
|
throw "Invalid operation";
|
|
}
|
|
|
|
static public function opSub<T1:java.lang.Object, T2:java.lang.Object>(a:T1, b:T2):Dynamic {
|
|
if (instanceof(a, java.lang.Double.DoubleClass) || instanceof(b, java.lang.Double.DoubleClass)) {
|
|
return toDouble(a) - toDouble(b);
|
|
}
|
|
if (instanceof(a, java.lang.Long.LongClass) || instanceof(b, java.lang.Long.LongClass)) {
|
|
return toLong(a) - toLong(b);
|
|
}
|
|
if (instanceof(a, java.lang.Integer.IntegerClass) || instanceof(b, java.lang.Integer.IntegerClass)) {
|
|
return toInt(a) - toInt(b);
|
|
}
|
|
throw "Invalid operation";
|
|
}
|
|
|
|
static public function opMul<T1:java.lang.Object, T2:java.lang.Object>(a:T1, b:T2):Dynamic {
|
|
if (instanceof(a, java.lang.Double.DoubleClass) || instanceof(b, java.lang.Double.DoubleClass)) {
|
|
return toDouble(a) * toDouble(b);
|
|
}
|
|
if (instanceof(a, java.lang.Long.LongClass) || instanceof(b, java.lang.Long.LongClass)) {
|
|
return toLong(a) * toLong(b);
|
|
}
|
|
if (instanceof(a, java.lang.Integer.IntegerClass) || instanceof(b, java.lang.Integer.IntegerClass)) {
|
|
return toInt(a) * toInt(b);
|
|
}
|
|
throw "Invalid operation";
|
|
}
|
|
|
|
static public function opDiv<T1:java.lang.Object, T2:java.lang.Object>(a:T1, b:T2):Dynamic {
|
|
if (instanceof(a, java.lang.Double.DoubleClass) || instanceof(b, java.lang.Double.DoubleClass)) {
|
|
return toDouble(a) / toDouble(b);
|
|
}
|
|
if (instanceof(a, java.lang.Long.LongClass) || instanceof(b, java.lang.Long.LongClass)) {
|
|
return toLong(a) / toLong(b);
|
|
}
|
|
if (instanceof(a, java.lang.Integer.IntegerClass) || instanceof(b, java.lang.Integer.IntegerClass)) {
|
|
return toInt(a) / toInt(b);
|
|
}
|
|
throw "Invalid operation";
|
|
}
|
|
|
|
static public function opMod<T1:java.lang.Object, T2:java.lang.Object>(a:T1, b:T2):Dynamic {
|
|
if (instanceof(a, java.lang.Double.DoubleClass) || instanceof(b, java.lang.Double.DoubleClass)) {
|
|
return toDouble(a) % toDouble(b);
|
|
}
|
|
if (instanceof(a, java.lang.Long.LongClass) || instanceof(b, java.lang.Long.LongClass)) {
|
|
return toLong(a) % toLong(b);
|
|
}
|
|
if (instanceof(a, java.lang.Integer.IntegerClass) || instanceof(b, java.lang.Integer.IntegerClass)) {
|
|
return toInt(a) % toInt(b);
|
|
}
|
|
throw "Invalid operation";
|
|
}
|
|
|
|
static public function opAnd<T1:java.lang.Object, T2:java.lang.Object>(a:T1, b:T2):Dynamic {
|
|
if (instanceof(a, java.lang.Long.LongClass) || instanceof(b, java.lang.Long.LongClass)) {
|
|
return toLong(a) & toLong(b);
|
|
}
|
|
if (instanceof(a, java.lang.Integer.IntegerClass) || instanceof(b, java.lang.Integer.IntegerClass)) {
|
|
return toInt(a) & toInt(b);
|
|
}
|
|
throw "Invalid operation";
|
|
}
|
|
|
|
static public function opOr<T1:java.lang.Object, T2:java.lang.Object>(a:T1, b:T2):Dynamic {
|
|
if (instanceof(a, java.lang.Long.LongClass) || instanceof(b, java.lang.Long.LongClass)) {
|
|
return toLong(a) | toLong(b);
|
|
}
|
|
if (instanceof(a, java.lang.Integer.IntegerClass) || instanceof(b, java.lang.Integer.IntegerClass)) {
|
|
return toInt(a) | toInt(b);
|
|
}
|
|
throw "Invalid operation";
|
|
}
|
|
|
|
static public function opXor<T1:java.lang.Object, T2:java.lang.Object>(a:T1, b:T2):Dynamic {
|
|
if (instanceof(a, java.lang.Long.LongClass) || instanceof(b, java.lang.Long.LongClass)) {
|
|
return toLong(a) ^ toLong(b);
|
|
}
|
|
if (instanceof(a, java.lang.Integer.IntegerClass) || instanceof(b, java.lang.Integer.IntegerClass)) {
|
|
return toInt(a) ^ toInt(b);
|
|
}
|
|
throw "Invalid operation";
|
|
}
|
|
|
|
static public function opShl<T1:java.lang.Object, T2:java.lang.Object>(a:T1, b:T2):Dynamic {
|
|
if (instanceof(a, java.lang.Long.LongClass) || instanceof(b, java.lang.Long.LongClass)) {
|
|
return toLong(a) << toInt(b);
|
|
}
|
|
if (instanceof(a, java.lang.Integer.IntegerClass) || instanceof(b, java.lang.Integer.IntegerClass)) {
|
|
return toInt(a) << toInt(b);
|
|
}
|
|
throw "Invalid operation";
|
|
}
|
|
|
|
static public function opShr<T1:java.lang.Object, T2:java.lang.Object>(a:T1, b:T2):Dynamic {
|
|
if (instanceof(a, java.lang.Long.LongClass) || instanceof(b, java.lang.Long.LongClass)) {
|
|
return toLong(a) >> toInt(b);
|
|
}
|
|
if (instanceof(a, java.lang.Integer.IntegerClass) || instanceof(b, java.lang.Integer.IntegerClass)) {
|
|
return toInt(a) >> toInt(b);
|
|
}
|
|
throw "Invalid operation";
|
|
}
|
|
|
|
static public function opUshr<T1:java.lang.Object, T2:java.lang.Object>(a:T1, b:T2):Dynamic {
|
|
if (instanceof(a, java.lang.Long.LongClass) || instanceof(b, java.lang.Long.LongClass)) {
|
|
return toLong(a) >>> toInt(b);
|
|
}
|
|
if (instanceof(a, java.lang.Integer.IntegerClass) || instanceof(b, java.lang.Integer.IntegerClass)) {
|
|
return toInt(a) >>> toInt(b);
|
|
}
|
|
throw "Invalid operation";
|
|
}
|
|
|
|
static public function opIncrement<T1:java.lang.Object>(a:T1):Dynamic {
|
|
if (instanceof(a, java.lang.Double.DoubleClass)) {
|
|
return toDouble(a) + 1.;
|
|
}
|
|
if (instanceof(a, java.lang.Long.LongClass)) {
|
|
return toLong(a) + 1.;
|
|
}
|
|
if (instanceof(a, java.lang.Integer.IntegerClass)) {
|
|
return toInt(a) + 1;
|
|
}
|
|
throw "Invalid operation";
|
|
}
|
|
|
|
static public function opDecrement<T1:java.lang.Object>(a:T1):Dynamic {
|
|
if (instanceof(a, java.lang.Double.DoubleClass)) {
|
|
return toDouble(a) - 1.;
|
|
}
|
|
if (instanceof(a, java.lang.Long.LongClass)) {
|
|
return toLong(a) - 1.;
|
|
}
|
|
if (instanceof(a, java.lang.Integer.IntegerClass)) {
|
|
return toInt(a) - 1;
|
|
}
|
|
throw "Invalid operation";
|
|
}
|
|
|
|
static public function opNeg<T1:java.lang.Object>(a:T1):Dynamic {
|
|
if (instanceof(a, java.lang.Double.DoubleClass)) {
|
|
return -toDouble(a);
|
|
}
|
|
if (instanceof(a, java.lang.Long.LongClass)) {
|
|
return -toLong(a);
|
|
}
|
|
if (instanceof(a, java.lang.Integer.IntegerClass)) {
|
|
return -toInt(a);
|
|
}
|
|
throw "Invalid operation";
|
|
}
|
|
|
|
static public function opNegBits<T1:java.lang.Object>(a:T1):Dynamic {
|
|
if (instanceof(a, java.lang.Long.LongClass)) {
|
|
return ~toLong(a);
|
|
}
|
|
if (instanceof(a, java.lang.Integer.IntegerClass)) {
|
|
return ~toInt(a);
|
|
}
|
|
throw "Invalid operation";
|
|
}
|
|
}
|