forked from LeenkxTeam/LNXSDK
Update Files
This commit is contained in:
617
Kha/Tools/linux_arm64/std/jvm/Jvm.hx
Normal file
617
Kha/Tools/linux_arm64/std/jvm/Jvm.hx
Normal file
@ -0,0 +1,617 @@
|
||||
/*
|
||||
* 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";
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user