Onek8/LNXSDK
1
0
Fork 0
forked from LeenkxTeam/LNXSDK
Code Pull Requests Activity

Update Files

Browse Source
This commit is contained in:
Onek8
2025-01-22 16:18:30 +01:00
parent ed4603cf95
commit a36294b518
16718 changed files with 2960346 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
Kha/Tools/macos/std/hl/_std/haxe/Exception.hx Normal file
View File

@ -0,0 +1,83 @@
package haxe;
@:coreApi
class Exception {
public var message(get,never):String;
public var stack(get,never):CallStack;
public var previous(get,never):Null<Exception>;
public var native(get,never):Any;
@:noCompletion var __exceptionMessage:String;
@:noCompletion var __exceptionStack:Null<CallStack>;
@:noCompletion var __nativeStack:hl.NativeArray<hl.Bytes>;
@:noCompletion @:ifFeature("haxe.Exception.get_stack") var __skipStack:Int = 0;
@:noCompletion var __nativeException:Any;
@:noCompletion var __previousException:Null<Exception>;
static function caught(value:Any):Exception {
if(Std.isOfType(value, Exception)) {
return value;
} else {
return new ValueException(value, null, value);
}
}
static function thrown(value:Any):Any {
if(Std.isOfType(value, Exception)) {
return (value:Exception).native;
} else {
var e = new ValueException(value);
e.__shiftStack();
return e;
}
}
public function new(message:String, ?previous:Exception, ?native:Any) {
__exceptionMessage = message;
__previousException = previous;
if(native != null) {
__nativeStack = NativeStackTrace.exceptionStack();
__nativeException = native;
} else {
__nativeStack = NativeStackTrace.callStack();
__nativeException = this;
}
}
function unwrap():Any {
return __nativeException;
}
public function toString():String {
return message;
}
public function details():String {
return inline CallStack.exceptionToString(this);
}
@:noCompletion
@:ifFeature("haxe.Exception.get_stack")
inline function __shiftStack():Void {
__skipStack++;
}
function get_message():String {
return __exceptionMessage;
}
function get_previous():Null<Exception> {
return __previousException;
}
final function get_native():Any {
return __nativeException;
}
function get_stack():CallStack {
return switch __exceptionStack {
case null: __exceptionStack = NativeStackTrace.toHaxe(__nativeStack, __skipStack);
case s: s;
}
}
}

58
Kha/Tools/macos/std/hl/_std/haxe/NativeStackTrace.hx Normal file
View File

@ -0,0 +1,58 @@
package haxe;
import hl.NativeArray;
import hl.Bytes;
import haxe.CallStack.StackItem;
/**
Do not use manually.
**/
@:dox(hide)
@:noCompletion
class NativeStackTrace {
@:ifFeature('haxe.NativeStackTrace.exceptionStack')
static public inline function saveStack(exception:Any):Void {
}
@:hlNative("std", "exception_stack")
static public function exceptionStack():NativeArray<Bytes> {
return null;
}
//TODO: implement in hashlink like `exceptionStack`
static public function callStack():NativeArray<Bytes> {
var stack:NativeArray<Bytes> = try {
throw new Exception('', null, 'stack');
} catch (e:Exception) {
exceptionStack();
}
var skip = 1;
for(i in 0...stack.length - 1) {
var s = @:privateAccess String.fromUCS2(stack[i]);
if(s.indexOf('NativeStackTrace.callStack') < 0) {
break;
}
skip++;
}
return skip < stack.length ? stack.sub(skip, stack.length - skip) : stack;
}
static public function toHaxe(native:NativeArray<Bytes>, skip:Int = 0):Array<StackItem> {
var stack = [];
var r = ~/^([A-Za-z0-9.$_]+)\.([~A-Za-z0-9_]+(\.[0-9]+)?)\((.+):([0-9]+)\)$/;
var r_fun = ~/^fun\$([0-9]+)\((.+):([0-9]+)\)$/;
for (i in 0...native.length - 1) {
if(skip > i) {
continue;
}
var str = @:privateAccess String.fromUCS2(native[i]);
if (r.match(str))
stack.push(FilePos(Method(r.matched(1), r.matched(2)), r.matched(4), Std.parseInt(r.matched(5))));
else if (r_fun.match(str))
stack.push(FilePos(LocalFunction(Std.parseInt(r_fun.matched(1))), r_fun.matched(2), Std.parseInt(r_fun.matched(3))));
else
stack.push(Module(str));
}
return stack;
}
}

56
Kha/Tools/macos/std/hl/_std/haxe/Resource.hx Normal file
View File

@ -0,0 +1,56 @@
/*
* 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 haxe;
private class ResourceContent {
public var name:hl.Bytes;
public var data:hl.Bytes;
public var dataLen:Int;
}
@:coreApi
class Resource {
static var content:hl.NativeArray<ResourceContent>;
public static function listNames():Array<String> {
return [for (x in content) @:privateAccess String.fromUCS2(x.name)];
}
public static function getString(name:String):String {
for (x in content)
if (x.name.compare(0, @:privateAccess name.bytes, 0, (name.length + 1) << 1) == 0)
return @:privateAccess String.fromUTF8(x.data);
return null;
}
public static function getBytes(name:String):haxe.io.Bytes {
for (x in content)
if (x.name.compare(0, @:privateAccess name.bytes, 0, (name.length + 1) << 1) == 0)
return @:privateAccess new haxe.io.Bytes(x.data, x.dataLen);
return null;
}
static function __init__():Void {
content = untyped $resources();
}
}

37
Kha/Tools/macos/std/hl/_std/haxe/crypto/Md5.hx Normal file
View File

@ -0,0 +1,37 @@
/*
* 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 haxe.crypto;
class Md5 {
public static function encode(s:String):String {
var out = haxe.io.Bytes.alloc(16);
@:privateAccess hl.Format.digest(out.b, s.bytes, s.length, 256);
return out.toHex();
}
public static function make(b:haxe.io.Bytes):haxe.io.Bytes {
var out = haxe.io.Bytes.alloc(16);
@:privateAccess hl.Format.digest(out.b, b.b, b.length, 0);
return out;
}
}

37
Kha/Tools/macos/std/hl/_std/haxe/crypto/Sha1.hx Normal file
View File

@ -0,0 +1,37 @@
/*
* 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 haxe.crypto;
class Sha1 {
public static function encode(s:String):String {
var out = haxe.io.Bytes.alloc(20);
@:privateAccess hl.Format.digest(out.b, s.bytes, s.length, 256 | 1);
return out.toHex();
}
public static function make(b:haxe.io.Bytes):haxe.io.Bytes {
var out = haxe.io.Bytes.alloc(20);
@:privateAccess hl.Format.digest(out.b, b.b, b.length, 1);
return out;
}
}

91
Kha/Tools/macos/std/hl/_std/haxe/ds/IntMap.hx Normal file
View File

@ -0,0 +1,91 @@
/*
* 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 haxe.ds;
@:coreApi
class IntMap<T> implements haxe.Constraints.IMap<Int, T> {
var h:hl.types.IntMap;
public function new():Void {
h = new hl.types.IntMap();
}
public function set(key:Int, value:T):Void {
@:privateAccess h.set(key, value);
}
public function get(key:Int):Null<T> {
return @:privateAccess h.get(key);
}
public function exists(key:Int):Bool {
return @:privateAccess h.exists(key);
}
public function remove(key:Int):Bool {
return @:privateAccess h.remove(key);
}
public function keys():Iterator<Int> {
return new hl.NativeArray.NativeArrayIterator<Int>(h.keysArray());
}
public function iterator():Iterator<T> {
return h.iterator();
}
@:runtime public inline function keyValueIterator():KeyValueIterator<Int, T> {
return new haxe.iterators.MapKeyValueIterator(this);
}
public function copy():IntMap<T> {
var copied = new IntMap();
for (key in keys())
copied.set(key, get(key));
return copied;
}
public function toString():String {
var s = new StringBuf();
var keys = h.keysArray();
var values = h.valuesArray();
s.addChar('{'.code);
for (i in 0...keys.length) {
if (i > 0)
s.add(", ");
s.add(keys[i]);
s.add(" => ");
s.add(values[i]);
}
s.addChar('}'.code);
return s.toString();
}
public function clear():Void {
#if (hl_ver >= version("1.11.0"))
@:privateAccess h.clear();
#else
h = new hl.types.IntMap();
#end
}
}

91
Kha/Tools/macos/std/hl/_std/haxe/ds/ObjectMap.hx Normal file
View File

@ -0,0 +1,91 @@
/*
* 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 haxe.ds;
@:coreApi
class ObjectMap<K:{}, T> implements haxe.Constraints.IMap<K, T> {
var h:hl.types.ObjectMap;
public function new():Void {
h = new hl.types.ObjectMap();
}
public function set(key:K, value:T):Void {
@:privateAccess h.set(key, value);
}
public function get(key:K):Null<T> {
return @:privateAccess h.get(key);
}
public function exists(key:K):Bool {
return @:privateAccess h.exists(key);
}
public function remove(key:K):Bool {
return @:privateAccess h.remove(key);
}
public function keys():Iterator<K> {
return new hl.NativeArray.NativeArrayIterator<K>(cast h.keysArray());
}
public function iterator():Iterator<T> {
return h.iterator();
}
@:runtime public inline function keyValueIterator():KeyValueIterator<K, T> {
return new haxe.iterators.MapKeyValueIterator(this);
}
public function copy():ObjectMap<K, T> {
var copied = new ObjectMap();
for (key in keys())
copied.set(key, get(key));
return copied;
}
public function toString():String {
var s = new StringBuf();
var keys = h.keysArray();
var values = h.valuesArray();
s.addChar('{'.code);
for (i in 0...keys.length) {
if (i > 0)
s.add(", ");
s.add(keys[i]);
s.add(" => ");
s.add(values[i]);
}
s.addChar('}'.code);
return s.toString();
}
public function clear():Void {
#if (hl_ver >= version("1.11.0"))
@:privateAccess h.clear();
#else
h = new hl.types.ObjectMap();
#end
}
}

119
Kha/Tools/macos/std/hl/_std/haxe/ds/StringMap.hx Normal file
View File

@ -0,0 +1,119 @@
/*
* 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 haxe.ds;
private class StringMapKeysIterator {
var arr:hl.NativeArray<hl.Bytes>;
var pos:Int;
var length:Int;
public inline function new(h:hl.types.BytesMap) {
this.arr = h.keysArray();
pos = 0;
length = arr.length;
}
public inline function hasNext() {
return pos < length;
}
public inline function next() @:privateAccess {
var b = arr[pos++];
return String.fromUCS2(b);
}
}
@:coreApi
class StringMap<T> implements haxe.Constraints.IMap<String, T> {
var h:hl.types.BytesMap;
public function new():Void {
h = new hl.types.BytesMap();
}
public function set(key:String, value:T):Void {
@:privateAccess h.set(key.bytes, value);
}
public function get(key:String):Null<T> {
if (key == null)
return null;
return @:privateAccess h.get(key.bytes);
}
public function exists(key:String):Bool {
if (key == null)
return false;
return @:privateAccess h.exists(key.bytes);
}
public function remove(key:String):Bool {
if (key == null)
return false;
return @:privateAccess h.remove(key.bytes);
}
public function keys():Iterator<String> {
return new StringMapKeysIterator(h);
}
public function iterator():Iterator<T> {
return h.iterator();
}
@:runtime public inline function keyValueIterator():KeyValueIterator<String, T> {
return new haxe.iterators.MapKeyValueIterator(this);
}
public function copy():StringMap<T> {
var copied = new StringMap();
for (key in keys())
copied.set(key, get(key));
return copied;
}
public function toString():String {
var s = new StringBuf();
var keys = h.keysArray();
var values = h.valuesArray();
s.addChar('{'.code);
for (i in 0...keys.length) {
if (i > 0)
s.add(", ");
var k = keys[i];
@:privateAccess s.__add(k, 0, (@:privateAccess k.ucs2Length(0)) << 1);
s.add(" => ");
s.add(values[i]);
}
s.addChar('}'.code);
return s.toString();
}
public function clear():Void {
#if (hl_ver >= version("1.11.0"))
@:privateAccess h.clear();
#else
h = new hl.types.BytesMap();
#end
}
}

90
Kha/Tools/macos/std/hl/_std/haxe/ds/Vector.hx Normal file
View File

@ -0,0 +1,90 @@
/*
* 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 haxe.ds;
private typedef VectorData<T> = Array<T>
@:coreApi
abstract Vector<T>(VectorData<T>) {
public inline function new(length:Int) {
this = [];
if (length > 0)
this[length - 1] = cast null;
}
@:op([]) public inline function get(index:Int):T {
return this[index];
}
@:op([]) public inline function set(index:Int, val:T):T {
return this[index] = val;
}
public var length(get, never):Int;
inline function get_length():Int {
return this.length;
}
public static inline function blit<T>(src:Vector<T>, srcPos:Int, dest:Vector<T>, destPos:Int, len:Int):Void {
(cast dest : hl.types.ArrayBase.ArrayAccess).blit(destPos, (cast src : hl.types.ArrayBase.ArrayAccess), srcPos, len);
}
public inline function toArray():Array<T> {
return this.copy();
}
public inline function toData():VectorData<T>
return this;
static public inline function fromData<T>(data:VectorData<T>):Vector<T>
return cast data;
static public inline function fromArrayCopy<T>(array:Array<T>):Vector<T> {
return cast array.copy();
}
public inline function copy<T>():Vector<T> {
return cast this.copy();
}
public inline function join<T>(sep:String):String {
return this.join(sep);
}
public inline function sort(f:T->T->Int):Void {
this.sort(f);
}
public inline function map<S>(f:T->S):Vector<S> {
var length = length;
var r = new Vector<S>(length);
var i = 0;
var len = length;
for (i in 0...len) {
var v = f(get(i));
r.set(i, v);
}
return r;
}
}

253
Kha/Tools/macos/std/hl/_std/haxe/io/Bytes.hx Normal file
View File

@ -0,0 +1,253 @@
/*
* 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 haxe.io;
@:coreApi
class Bytes {
public var length(default, null):Int;
var b:hl.Bytes;
function new(b:hl.Bytes, length:Int):Void {
this.b = b;
this.length = length;
}
inline function out(pos:Int):Bool {
return (pos : UInt) >= (length : UInt);
}
inline function outRange(pos:Int, len:Int):Bool {
return pos < 0 || len < 0 || ((pos + len) : UInt) > (length : UInt);
}
public function get(pos:Int):Int {
return if (out(pos)) 0 else b[pos];
}
public function set(pos:Int, v:Int):Void {
if (out(pos))
throw Error.OutsideBounds;
b[pos] = v;
}
public function blit(pos:Int, src:Bytes, srcpos:Int, len:Int):Void {
if (outRange(pos, len) || src.outRange(srcpos, len))
throw Error.OutsideBounds;
b.blit(pos, src.b, srcpos, len);
}
public function fill(pos:Int, len:Int, value:Int):Void {
if (outRange(pos, len))
throw Error.OutsideBounds;
b.fill(pos, len, value);
}
public function sub(pos:Int, len:Int):Bytes {
if (outRange(pos, len))
throw Error.OutsideBounds;
return new Bytes(b.sub(pos, len), len);
}
public function compare(other:Bytes):Int {
var len = length < other.length ? length : other.length;
var r = b.compare(0, other.b, 0, len);
if (r == 0)
r = length - other.length;
return r;
}
#if hl_check_align
static var alignBuffer:hl.Bytes = new hl.Bytes(8);
#end
public function getDouble(pos:Int):Float {
if (out(pos + 7))
return 0.;
#if hl_check_align
return if (pos & 3 == 0) b.getF64(pos) else {
alignBuffer.blit(0, b, pos, 8);
alignBuffer.getF64(0);
}
#else
return b.getF64(pos);
#end
}
public function getFloat(pos:Int):Float {
if (out(pos + 3))
return 0.;
#if hl_check_align
return if (pos & 3 == 0) b.getF32(pos) else {
alignBuffer.blit(0, b, pos, 4);
alignBuffer.getF32(0);
}
#else
return b.getF32(pos);
#end
}
public function setDouble(pos:Int, v:Float):Void {
if (out(pos + 7))
throw Error.OutsideBounds;
#if hl_check_align
if (pos & 7 == 0)
b.setF64(pos, v);
else {
alignBuffer.setF64(0, v);
b.blit(pos, alignBuffer, 0, 8);
}
#else
b.setF64(pos, v);
#end
}
public function setFloat(pos:Int, v:Float):Void {
if (out(pos + 3))
throw Error.OutsideBounds;
#if hl_check_align
if (pos & 3 == 0)
b.setF32(pos, v);
else {
alignBuffer.setF32(0, v);
b.blit(pos, alignBuffer, 0, 4);
}
#else
b.setF32(pos, v);
#end
}
public inline function getUInt16(pos:Int):Int {
return if (out(pos + 1)) 0 else b.getUI16(pos);
}
public inline function setUInt16(pos:Int, v:Int):Void {
if (out(pos + 1))
throw Error.OutsideBounds;
b.setUI16(pos, v);
}
public function getInt32(pos:Int):Int {
return if (out(pos + 3)) 0 else b.getI32(pos);
}
public function getInt64(pos:Int):haxe.Int64 {
if (out(pos + 7))
return haxe.Int64.ofInt(0);
return haxe.Int64.make(b.getI32(pos + 4), b.getI32(pos));
}
public function setInt32(pos:Int, v:Int):Void {
if (out(pos + 3))
throw Error.OutsideBounds;
b.setI32(pos, v);
}
public inline function setInt64(pos:Int, v:haxe.Int64):Void {
setInt32(pos + 4, v.high);
setInt32(pos, v.low);
}
public function getString(pos:Int, len:Int, ?encoding:Encoding):String {
if (outRange(pos, len))
throw Error.OutsideBounds;
var b = new hl.Bytes(len + 2);
b.blit(0, this.b, pos, len);
b[len] = 0;
b[len + 1] = 0;
return @:privateAccess (encoding == RawNative ? String.fromUCS2(b) : String.fromUTF8(b));
}
@:deprecated("readString is deprecated, use getString instead")
@:noCompletion
public inline function readString(pos:Int, len:Int):String {
return getString(pos, len);
}
public function toString():String {
return getString(0, length);
}
public function toHex():String {
var s = new StringBuf();
var chars = [];
var str = "0123456789abcdef";
for (i in 0...str.length)
chars.push(str.charCodeAt(i));
for (i in 0...length) {
var c = get(i);
s.addChar(chars[c >> 4]);
s.addChar(chars[c & 15]);
}
return s.toString();
}
public inline function getData():BytesData {
return new haxe.io.BytesData(b, length);
}
public static function alloc(length:Int):Bytes {
var b = new hl.Bytes(length);
b.fill(0, length, 0);
return new Bytes(b, length);
}
public static function ofString(s:String, ?encoding:Encoding):Bytes@:privateAccess {
if (encoding == null)
encoding = UTF8;
return switch (encoding) {
case RawNative:
return new Bytes(s.bytes.sub(0, s.length << 1), s.length << 1);
case UTF8:
var size = 0;
var b = s.bytes.utf16ToUtf8(s.length, size);
return new Bytes(b, size);
}
}
public static function ofData(b:BytesData):Bytes {
return new Bytes(b.bytes, b.length);
}
public static function ofHex(s:String):Bytes {
var len = s.length;
if ((len & 1) != 0)
throw "Not a hex string (odd number of digits)";
var l = len >> 1;
var b = new hl.Bytes(l);
for (i in 0...l) {
var high = s.charCodeAt(i * 2);
var low = s.charCodeAt(i * 2 + 1);
high = (high & 0xf) + ((high & 0x40) >> 6) * 9;
low = (low & 0xf) + ((low & 0x40) >> 6) * 9;
b.setUI8(i, ((high << 4) | low) & 0xff);
}
return new Bytes(b, l);
}
public inline static function fastGet(b:BytesData, pos:Int):Int {
return b[pos];
}
}

131
Kha/Tools/macos/std/hl/_std/haxe/io/BytesBuffer.hx Normal file
View File

@ -0,0 +1,131 @@
/*
* 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 haxe.io;
@:coreApi
class BytesBuffer {
var b:hl.Bytes;
var pos:Int;
var size:Int;
public var length(get, never):Int;
public function new() {
pos = 0;
size = 16; // ensure increment of 8
b = new hl.Bytes(size);
}
inline function get_length():Int {
return pos;
}
public inline function addByte(byte:Int):Void {
if (pos == size)
__expand(0);
b[pos++] = byte;
}
function __expand(req:Int):Void {
var nsize = (size * 3) >> 1;
if (nsize < req)
nsize = req;
var b2 = new hl.Bytes(nsize);
b2.blit(0, b, 0, pos);
b = b2;
size = nsize;
}
function __add(b:hl.Bytes, bpos:Int, blen:Int):Void {
if (pos + blen > size)
__expand(pos + blen);
this.b.blit(pos, b, bpos, blen);
pos += blen;
}
public inline function add(src:Bytes):Void {
__add(@:privateAccess src.b, 0, src.length);
}
public inline function addString(v:String, ?encoding:Encoding):Void {
var len = 0;
@:privateAccess (encoding == RawNative ? __add(v.bytes, 0, v.length << 1) : __add(v.bytes.utf16ToUtf8(0, len), 0, len));
}
public inline function addInt32(v:Int):Void {
if (pos + 4 > size)
__expand(0);
b.setI32(pos, v);
pos += 4;
}
public inline function addInt64(v:haxe.Int64):Void {
if (pos + 8 > size)
__expand(0);
b.setI32(pos, v.low);
b.setI32(pos + 4, v.high);
pos += 8;
}
public inline function addFloat(v:Float):Void {
if (pos + 4 > size)
__expand(0);
#if hl_check_align
if (pos & 3 == 0)
b.setF32(pos, v);
else @:privateAccess {
haxe.io.Bytes.alignBuffer.setF32(0, v);
b.blit(pos, haxe.io.Bytes.alignBuffer, 0, 4);
}
#else
b.setF32(pos, v);
#end
pos += 4;
}
public inline function addDouble(v:Float):Void {
if (pos + 8 > size)
__expand(0);
#if hl_check_align
if (pos & 7 == 0)
b.setF64(pos, v);
else @:privateAccess {
haxe.io.Bytes.alignBuffer.setF64(0, v);
b.blit(pos, haxe.io.Bytes.alignBuffer, 0, 8);
}
#else
b.setF64(pos, v);
#end
pos += 8;
}
public inline function addBytes(src:Bytes, pos:Int, len:Int):Void {
if (pos < 0 || len < 0 || pos + len > src.length)
throw Error.OutsideBounds;
__add(@:privateAccess src.b, pos, len);
}
public function getBytes():Bytes {
return @:privateAccess new haxe.io.Bytes(b, pos);
}
}

55
Kha/Tools/macos/std/hl/_std/haxe/io/FPHelper.hx Normal file
View File

@ -0,0 +1,55 @@
/*
* 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 haxe.io;
class FPHelper {
// note : this is not thread safe, use TLS when available
static var i64tmp = Int64.ofInt(0);
static var helper = new hl.Bytes(8);
public static function i32ToFloat(i:Int):Single {
helper.setI32(0, i);
return helper.getF32(0);
}
public static function floatToI32(f:Single):Int {
helper.setF32(0, f);
return helper.getI32(0);
}
public static function i64ToDouble(low:Int, high:Int):Float {
helper.setI32(0, low);
helper.setI32(4, high);
return helper.getF64(0);
}
public static function doubleToI64(v:Float):Int64 {
helper.setF64(0, v);
var i64 = i64tmp;
@:privateAccess {
i64.set_low(helper.getI32(0));
i64.set_high(helper.getI32(4));
}
return i64;
}
}

75
Kha/Tools/macos/std/hl/_std/haxe/zip/Compress.hx Normal file
View File

@ -0,0 +1,75 @@
/*
* 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 haxe.zip;
private typedef Deflater = hl.Abstract<"fmt_zip">;
@:coreApi @:hlNative("fmt")
class Compress {
var s:Deflater;
public function new(level:Int):Void {
s = deflate_init(level);
}
public function execute(src:haxe.io.Bytes, srcPos:Int, dst:haxe.io.Bytes, dstPos:Int):{done:Bool, read:Int, write:Int} {
var read = 0, write = 0;
var done = deflate_buffer(s, src.getData(), srcPos, src.length, dst.getData(), dstPos, dst.length, read, write);
return {done: done, read: read, write: write};
}
public function setFlushMode(f:FlushMode):Void {
@:privateAccess Uncompress.zip_flush_mode(cast s, f.getIndex());
}
public function close():Void {
@:privateAccess Uncompress.zip_end(cast s);
}
public static function run(s:haxe.io.Bytes, level:Int):haxe.io.Bytes {
var c = new Compress(level);
c.setFlushMode(FlushMode.FINISH);
var out = haxe.io.Bytes.alloc(deflate_bound(c.s, s.length));
var r = c.execute(s, 0, out, 0);
c.close();
if (!r.done || r.read != s.length)
throw "Compression failed";
if (r.write < out.length * 0.66)
return out.sub(0, r.write);
@:privateAccess out.length = r.write;
return out;
}
static function deflate_init(level:Int):Deflater {
return null;
}
static function deflate_buffer(i:Deflater, bytes:hl.Bytes, bytesPos:Int, bytesLen:Int, dst:hl.Bytes, dstPos:Int, dstLen:Int, read:hl.Ref<Int>,
write:hl.Ref<Int>):Bool {
return false;
}
static function deflate_bound(i:Deflater, length:Int):Int {
return 0;
}
}

80
Kha/Tools/macos/std/hl/_std/haxe/zip/Uncompress.hx Normal file
View File

@ -0,0 +1,80 @@
/*
* 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 haxe.zip;
private typedef Inflater = hl.Abstract<"fmt_zip">;
@:coreApi @:hlNative("fmt")
class Uncompress {
var s:Inflater;
public function new(?windowBits:Int):Void {
s = inflate_init(windowBits);
}
public function execute(src:haxe.io.Bytes, srcPos:Int, dst:haxe.io.Bytes, dstPos:Int):{done:Bool, read:Int, write:Int} {
var read = 0, write = 0;
var done = inflate_buffer(s, src.getData(), srcPos, src.length, dst.getData(), dstPos, dst.length, read, write);
return {done: done, read: read, write: write};
}
public function setFlushMode(f:FlushMode):Void {
zip_flush_mode(s, f.getIndex());
}
public function close():Void {
zip_end(s);
}
public static function run(src:haxe.io.Bytes, ?bufsize:Int):haxe.io.Bytes {
var u = new Uncompress(null);
if (bufsize == null)
bufsize = 1 << 16; // 64K
var tmp = haxe.io.Bytes.alloc(bufsize);
var b = new haxe.io.BytesBuffer();
var pos = 0;
u.setFlushMode(FlushMode.SYNC);
while (true) {
var r = u.execute(src, pos, tmp, 0);
b.addBytes(tmp, 0, r.write);
pos += r.read;
if (r.done)
break;
}
u.close();
return b.getBytes();
}
static function inflate_init(bits:Int):Inflater {
return null;
}
static function inflate_buffer(i:Inflater, bytes:hl.Bytes, bytesPos:Int, bytesLen:Int, dst:hl.Bytes, dstPos:Int, dstLen:Int, read:hl.Ref<Int>,
write:hl.Ref<Int>):Bool {
return false;
}
static function zip_end(i:Inflater):Void {}
static function zip_flush_mode(i:Inflater, flush:Int):Void {}
}