mirror of
https://github.com/fluencelabs/assemblyscript
synced 2025-05-09 22:02:15 +00:00
it's all broken
This commit is contained in:
dcode
parent
d9a5681489
commit
146dfdbb4a
@ -1,17 +1,29 @@
|
||||
import {
|
||||
MAX_BLENGTH,
|
||||
HEADER_SIZE,
|
||||
allocateUnsafe,
|
||||
reallocateUnsafe,
|
||||
LOAD,
|
||||
STORE
|
||||
} from "./internal/arraybuffer";
|
||||
// import {
|
||||
// MAX_BLENGTH,
|
||||
// HEADER_SIZE,
|
||||
// allocateUnsafe,
|
||||
// reallocateUnsafe,
|
||||
// LOAD,
|
||||
// STORE
|
||||
// } from "./internal/arraybuffer";
|
||||
|
||||
import {
|
||||
allocateUnsafe as allocateUnsafeString,
|
||||
freeUnsafe as freeUnsafeString,
|
||||
copyUnsafe as copyUnsafeString
|
||||
} from "./internal/string";
|
||||
ALLOC,
|
||||
REALLOC,
|
||||
REGISTER,
|
||||
LINK,
|
||||
ArrayBufferView
|
||||
} from "./runtime";
|
||||
|
||||
import {
|
||||
ArrayBuffer
|
||||
} from "./arraybuffer";
|
||||
|
||||
// import {
|
||||
// allocateUnsafe as allocateUnsafeString,
|
||||
// freeUnsafe as freeUnsafeString,
|
||||
// copyUnsafe as copyUnsafeString
|
||||
// } from "./internal/string";
|
||||
|
||||
import {
|
||||
COMPARATOR,
|
||||
@ -30,119 +42,114 @@ import {
|
||||
isArray as builtin_isArray
|
||||
} from "./builtins";
|
||||
|
||||
export class Array<T> {
|
||||
[key: number]: T; // compatibility only
|
||||
|
||||
/* @internal */ buffer_: ArrayBuffer;
|
||||
/* @internal */ length_: i32;
|
||||
export class Array<T> extends ArrayBufferView {
|
||||
private length_: i32;
|
||||
|
||||
@inline static isArray<U>(value: U): bool {
|
||||
return builtin_isArray(value) && value !== null;
|
||||
}
|
||||
|
||||
constructor(length: i32 = 0) {
|
||||
const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
|
||||
if (<u32>length > <u32>MAX_LENGTH) throw new RangeError("Invalid array length");
|
||||
var byteLength = length << alignof<T>();
|
||||
var buffer = allocateUnsafe(byteLength);
|
||||
this.buffer_ = buffer;
|
||||
super(length, alignof<T>());
|
||||
this.length_ = length;
|
||||
memory.fill(
|
||||
changetype<usize>(buffer) + HEADER_SIZE,
|
||||
0,
|
||||
<usize>byteLength
|
||||
);
|
||||
}
|
||||
|
||||
@inline
|
||||
get length(): i32 {
|
||||
return this.length_;
|
||||
}
|
||||
|
||||
set length(length: i32) {
|
||||
var buffer = this.buffer_;
|
||||
var capacity = buffer.byteLength >>> alignof<T>();
|
||||
if (<u32>length > <u32>capacity) {
|
||||
const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
|
||||
if (<u32>length > <u32>MAX_LENGTH) throw new RangeError("Invalid array length");
|
||||
buffer = reallocateUnsafe(buffer, length << alignof<T>());
|
||||
this.buffer_ = buffer;
|
||||
}
|
||||
this.resize(length);
|
||||
this.length_ = length;
|
||||
}
|
||||
|
||||
resize(length: i32): void {
|
||||
var buffer = this.buffer;
|
||||
var oldCapacity = buffer.byteLength >>> alignof<T>();
|
||||
if (<u32>length > <u32>oldCapacity) {
|
||||
const MAX_LENGTH = ArrayBuffer.MAX_BYTELENGTH >>> alignof<T>();
|
||||
if (<u32>length > <u32>MAX_LENGTH) throw new RangeError("Invalid array length");
|
||||
let newCapacity = length << alignof<T>();
|
||||
let newBuffer = REALLOC(changetype<usize>(buffer), newCapacity);
|
||||
if (newBuffer !== changetype<usize>(buffer)) {
|
||||
this.buffer = changetype<ArrayBuffer>(newBuffer); // links
|
||||
this.dataStart = newBuffer;
|
||||
this.dataEnd = newBuffer + newCapacity;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
every(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
|
||||
for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
|
||||
if (!callbackfn(LOAD<T>(this.buffer_, index), index, this)) return false;
|
||||
if (!callbackfn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
findIndex(predicate: (element: T, index: i32, array: Array<T>) => bool): i32 {
|
||||
for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
|
||||
if (predicate(LOAD<T>(this.buffer_, index), index, this)) return index;
|
||||
if (predicate(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return index;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
@operator("[]")
|
||||
private __get(index: i32): T {
|
||||
var buffer = this.buffer_;
|
||||
return <u32>index < <u32>(buffer.byteLength >>> alignof<T>())
|
||||
? LOAD<T>(buffer, index)
|
||||
: <T>unreachable();
|
||||
}
|
||||
// @operator("[]")
|
||||
// private __get(index: i32): T {
|
||||
// var buffer = this.buffer_;
|
||||
// return <u32>index < <u32>(buffer.byteLength >>> alignof<T>())
|
||||
// ? LOAD<T>(buffer, index)
|
||||
// : <T>unreachable();
|
||||
// }
|
||||
|
||||
@operator("{}")
|
||||
private __unchecked_get(index: i32): T {
|
||||
return LOAD<T>(this.buffer_, index);
|
||||
}
|
||||
// @operator("{}")
|
||||
// private __unchecked_get(index: i32): T {
|
||||
// return LOAD<T>(this.buffer_, index);
|
||||
// }
|
||||
|
||||
@operator("[]=")
|
||||
private __set(index: i32, value: T): void {
|
||||
var buffer = this.buffer_;
|
||||
var capacity = buffer.byteLength >>> alignof<T>();
|
||||
if (<u32>index >= <u32>capacity) {
|
||||
const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
|
||||
if (<u32>index >= <u32>MAX_LENGTH) throw new Error("Invalid array length");
|
||||
buffer = reallocateUnsafe(buffer, (index + 1) << alignof<T>());
|
||||
this.buffer_ = buffer;
|
||||
this.length_ = index + 1;
|
||||
}
|
||||
STORE<T>(buffer, index, value);
|
||||
if (isManaged<T>()) __gc_link(changetype<usize>(this), changetype<usize>(value)); // tslint:disable-line
|
||||
}
|
||||
// @operator("[]=")
|
||||
// private __set(index: i32, value: T): void {
|
||||
// var buffer = this.buffer_;
|
||||
// var capacity = buffer.byteLength >>> alignof<T>();
|
||||
// if (<u32>index >= <u32>capacity) {
|
||||
// const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
|
||||
// if (<u32>index >= <u32>MAX_LENGTH) throw new Error("Invalid array length");
|
||||
// buffer = reallocateUnsafe(buffer, (index + 1) << alignof<T>());
|
||||
// this.buffer_ = buffer;
|
||||
// this.length_ = index + 1;
|
||||
// }
|
||||
// STORE<T>(buffer, index, value);
|
||||
// if (isManaged<T>()) __gc_link(changetype<usize>(this), changetype<usize>(value)); // tslint:disable-line
|
||||
// }
|
||||
|
||||
@operator("{}=")
|
||||
private __unchecked_set(index: i32, value: T): void {
|
||||
STORE<T>(this.buffer_, index, value);
|
||||
if (isManaged<T>()) __gc_link(changetype<usize>(this), changetype<usize>(value)); // tslint:disable-line
|
||||
}
|
||||
// @operator("{}=")
|
||||
// private __unchecked_set(index: i32, value: T): void {
|
||||
// STORE<T>(this.buffer_, index, value);
|
||||
// if (isManaged<T>()) __gc_link(changetype<usize>(this), changetype<usize>(value)); // tslint:disable-line
|
||||
// }
|
||||
|
||||
fill(value: T, start: i32 = 0, end: i32 = i32.MAX_VALUE): this {
|
||||
var buffer = this.buffer_;
|
||||
var len = this.length_;
|
||||
var base = this.dataStart;
|
||||
var length = this.length_;
|
||||
|
||||
start = start < 0 ? max(len + start, 0) : min(start, len);
|
||||
end = end < 0 ? max(len + end, 0) : min(end, len);
|
||||
start = start < 0 ? max(length + start, 0) : min(start, length);
|
||||
end = end < 0 ? max(length + end, 0) : min(end, length);
|
||||
|
||||
if (sizeof<T>() == 1) {
|
||||
if (start < end) {
|
||||
memory.fill(
|
||||
changetype<usize>(buffer) + start + HEADER_SIZE,
|
||||
base + <usize>start,
|
||||
<u8>value,
|
||||
<usize>(end - start)
|
||||
);
|
||||
}
|
||||
} else {
|
||||
for (; start < end; ++start) {
|
||||
STORE<T>(buffer, start, value);
|
||||
store<T>(base + (<usize>start << alignof<T>()), value);
|
||||
}
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
@inline
|
||||
includes(searchElement: T, fromIndex: i32 = 0): bool {
|
||||
return this.indexOf(searchElement, fromIndex) >= 0;
|
||||
}
|
||||
@ -151,9 +158,9 @@ export class Array<T> {
|
||||
var length = this.length_;
|
||||
if (length == 0 || fromIndex >= length) return -1;
|
||||
if (fromIndex < 0) fromIndex = max(length + fromIndex, 0);
|
||||
var buffer = this.buffer_;
|
||||
var base = this.dataStart;
|
||||
while (fromIndex < length) {
|
||||
if (LOAD<T>(buffer, fromIndex) == searchElement) return fromIndex;
|
||||
if (load<T>(base + (<usize>fromIndex << alignof<T>())) == searchElement) return fromIndex;
|
||||
++fromIndex;
|
||||
}
|
||||
return -1;
|
||||
@ -164,50 +171,33 @@ export class Array<T> {
|
||||
if (length == 0) return -1;
|
||||
if (fromIndex < 0) fromIndex = length + fromIndex; // no need to clamp
|
||||
else if (fromIndex >= length) fromIndex = length - 1;
|
||||
var buffer = this.buffer_;
|
||||
var base = this.dataStart;
|
||||
while (fromIndex >= 0) { // ^
|
||||
if (LOAD<T>(buffer, fromIndex) == searchElement) return fromIndex;
|
||||
if (load<T>(base + (<usize>fromIndex << alignof<T>())) == searchElement) return fromIndex;
|
||||
--fromIndex;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
push(element: T): i32 {
|
||||
var length = this.length_;
|
||||
var buffer = this.buffer_;
|
||||
var capacity = buffer.byteLength >>> alignof<T>();
|
||||
var newLength = length + 1; // safe only if length is checked
|
||||
if (<u32>length >= <u32>capacity) {
|
||||
const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
|
||||
if (<u32>length >= <u32>MAX_LENGTH) throw new Error("Invalid array length");
|
||||
buffer = reallocateUnsafe(buffer, newLength << alignof<T>());
|
||||
this.buffer_ = buffer;
|
||||
}
|
||||
var newLength = this.length_ + 1;
|
||||
this.resize(newLength);
|
||||
this.length_ = newLength;
|
||||
STORE<T>(buffer, length, element);
|
||||
if (isManaged<T>()) __gc_link(changetype<usize>(this), changetype<usize>(element)); // tslint:disable-line
|
||||
store<T>(this.dataStart + (<usize>(newLength - 1) << alignof<T>()), element);
|
||||
if (isManaged<T>()) LINK(changetype<usize>(element), changetype<usize>(this));
|
||||
return newLength;
|
||||
}
|
||||
|
||||
concat(items: Array<T>): Array<T> {
|
||||
concat(other: Array<T>): Array<T> {
|
||||
var thisLen = this.length_;
|
||||
var otherLen = select(0, items.length_, items === null);
|
||||
var otherLen = select(0, other.length_, other === null);
|
||||
var outLen = thisLen + otherLen;
|
||||
var out = new Array<T>(outLen);
|
||||
|
||||
if (thisLen) {
|
||||
memory.copy(
|
||||
changetype<usize>(out.buffer_) + HEADER_SIZE,
|
||||
changetype<usize>(this.buffer_) + HEADER_SIZE,
|
||||
<usize>thisLen << alignof<T>()
|
||||
);
|
||||
memory.copy(out.dataStart, this.dataStart, <usize>thisLen << alignof<T>());
|
||||
}
|
||||
if (otherLen) {
|
||||
memory.copy(
|
||||
changetype<usize>(out.buffer_) + HEADER_SIZE + (<usize>thisLen << alignof<T>()),
|
||||
changetype<usize>(items.buffer_) + HEADER_SIZE,
|
||||
<usize>otherLen << alignof<T>()
|
||||
);
|
||||
memory.copy(out.dataStart + (<usize>thisLen << alignof<T>()), other.dataStart, <usize>otherLen << alignof<T>());
|
||||
}
|
||||
return out;
|
||||
}
|
||||
@ -242,23 +232,25 @@ export class Array<T> {
|
||||
pop(): T {
|
||||
var length = this.length_;
|
||||
if (length < 1) throw new RangeError("Array is empty");
|
||||
var element = LOAD<T>(this.buffer_, --length);
|
||||
var element = load<T>(this.dataStart + (<usize>--length << alignof<T>()));
|
||||
this.length_ = length;
|
||||
return element;
|
||||
}
|
||||
|
||||
forEach(callbackfn: (value: T, index: i32, array: Array<T>) => void): void {
|
||||
for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
|
||||
callbackfn(LOAD<T>(this.buffer_, index), index, this);
|
||||
callbackfn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);
|
||||
}
|
||||
}
|
||||
|
||||
map<U>(callbackfn: (value: T, index: i32, array: Array<T>) => U): Array<U> {
|
||||
var length = this.length_;
|
||||
var result = new Array<U>(length);
|
||||
var buffer = result.buffer_;
|
||||
var resultStart = result.dataStart;
|
||||
for (let index = 0; index < min(length, this.length_); ++index) {
|
||||
STORE<U>(buffer, index, callbackfn(LOAD<T>(this.buffer_, index), index, this));
|
||||
let element = load<T>(this.dataStart + (<usize>index << alignof<T>()));
|
||||
store<U>(resultStart + (<usize>index << alignof<T>()), element);
|
||||
if (isManaged<U>()) LINK(changetype<usize>(element), changetype<usize>(result));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
@ -266,7 +258,7 @@ export class Array<T> {
|
||||
filter(callbackfn: (value: T, index: i32, array: Array<T>) => bool): Array<T> {
|
||||
var result = new Array<T>();
|
||||
for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
|
||||
let value = LOAD<T>(this.buffer_, index);
|
||||
let value = load<T>(this.dataStart + (<usize>index << alignof<T>()));
|
||||
if (callbackfn(value, index, this)) result.push(value);
|
||||
}
|
||||
return result;
|
||||
@ -278,7 +270,7 @@ export class Array<T> {
|
||||
): U {
|
||||
var accum = initialValue;
|
||||
for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
|
||||
accum = callbackfn(accum, LOAD<T>(this.buffer_, index), index, this);
|
||||
accum = callbackfn(accum, load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);
|
||||
}
|
||||
return accum;
|
||||
}
|
||||
@ -289,7 +281,7 @@ export class Array<T> {
|
||||
): U {
|
||||
var accum = initialValue;
|
||||
for (let index = this.length_ - 1; index >= 0; --index) {
|
||||
accum = callbackfn(accum, LOAD<T>(this.buffer_, index), index, this);
|
||||
accum = callbackfn(accum, load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this);
|
||||
}
|
||||
return accum;
|
||||
}
|
||||
@ -297,87 +289,86 @@ export class Array<T> {
|
||||
shift(): T {
|
||||
var length = this.length_;
|
||||
if (length < 1) throw new RangeError("Array is empty");
|
||||
var buffer = this.buffer_;
|
||||
var element = LOAD<T>(buffer, 0);
|
||||
var base = this.dataStart;
|
||||
var element = load<T>(base);
|
||||
var lastIndex = length - 1;
|
||||
memory.copy(
|
||||
changetype<usize>(buffer) + HEADER_SIZE,
|
||||
changetype<usize>(buffer) + HEADER_SIZE + sizeof<T>(),
|
||||
base,
|
||||
base + sizeof<T>(),
|
||||
<usize>lastIndex << alignof<T>()
|
||||
);
|
||||
STORE<T>(buffer, lastIndex, <T>null);
|
||||
store<T>(base + (<usize>lastIndex << alignof<T>()), <T>null);
|
||||
this.length_ = lastIndex;
|
||||
return element;
|
||||
}
|
||||
|
||||
some(callbackfn: (element: T, index: i32, array: Array<T>) => bool): bool {
|
||||
for (let index = 0, length = this.length_; index < min(length, this.length_); ++index) {
|
||||
if (callbackfn(LOAD<T>(this.buffer_, index), index, this)) return true;
|
||||
if (callbackfn(load<T>(this.dataStart + (<usize>index << alignof<T>())), index, this)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
unshift(element: T): i32 {
|
||||
var buffer = this.buffer_;
|
||||
var capacity = buffer.byteLength >>> alignof<T>();
|
||||
var length = this.length_;
|
||||
var newLength = length + 1; // safe only if length is checked
|
||||
if (<u32>length >= <u32>capacity) {
|
||||
const MAX_LENGTH = MAX_BLENGTH >>> alignof<T>();
|
||||
if (<u32>length >= <u32>MAX_LENGTH) throw new Error("Invalid array length");
|
||||
buffer = reallocateUnsafe(buffer, newLength << alignof<T>());
|
||||
capacity = buffer.byteLength >>> alignof<T>();
|
||||
this.buffer_ = buffer;
|
||||
}
|
||||
var newLength = this.length_;
|
||||
this.resize(newLength);
|
||||
var base = this.dataStart;
|
||||
memory.copy(
|
||||
changetype<usize>(buffer) + HEADER_SIZE + sizeof<T>(),
|
||||
changetype<usize>(buffer) + HEADER_SIZE,
|
||||
<usize>(capacity - 1) << alignof<T>()
|
||||
base + sizeof<T>(),
|
||||
base,
|
||||
<usize>(newLength - 1) << alignof<T>()
|
||||
);
|
||||
STORE<T>(buffer, 0, element);
|
||||
store<T>(base, element);
|
||||
if (isManaged<T>()) LINK(changetype<usize>(element), changetype<usize>(this));
|
||||
this.length_ = newLength;
|
||||
if (isManaged<T>()) __gc_link(changetype<usize>(this), changetype<usize>(element)); // tslint:disable-line
|
||||
return newLength;
|
||||
}
|
||||
|
||||
slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Array<T> {
|
||||
var len = this.length_;
|
||||
begin = begin < 0 ? max(begin + len, 0) : min(begin, len);
|
||||
end = end < 0 ? max(end + len, 0) : min(end, len);
|
||||
len = max(end - begin, 0);
|
||||
var sliced = new Array<T>(len);
|
||||
if (len) {
|
||||
memory.copy(
|
||||
changetype<usize>(sliced.buffer_) + HEADER_SIZE,
|
||||
changetype<usize>(this.buffer_) + HEADER_SIZE + (<usize>begin << alignof<T>()),
|
||||
<usize>len << alignof<T>()
|
||||
);
|
||||
var length = this.length_;
|
||||
begin = begin < 0 ? max(begin + length, 0) : min(begin, length);
|
||||
end = end < 0 ? max(end + length, 0) : min(end , length);
|
||||
length = max(end - begin, 0);
|
||||
var slice = new Array<T>(length);
|
||||
var sliceBase = slice.dataStart;
|
||||
var thisBase = this.dataStart + (<usize>begin << alignof<T>());
|
||||
for (let i = 0; i < length; ++i) {
|
||||
let offset = <usize>i << alignof<T>();
|
||||
let element = load<T>(thisBase + offset);
|
||||
store<T>(sliceBase + offset, element);
|
||||
if (isManaged<T>()) LINK(changetype<usize>(element), changetype<usize>(slice));
|
||||
}
|
||||
return sliced;
|
||||
return slice;
|
||||
}
|
||||
|
||||
splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): Array<T> {
|
||||
var length = this.length_;
|
||||
start = start < 0 ? max<i32>(length + start, 0) : min<i32>(start, length);
|
||||
deleteCount = max<i32>(min<i32>(deleteCount, length - start), 0);
|
||||
var buffer = this.buffer_;
|
||||
var spliced = new Array<T>(deleteCount);
|
||||
var source = changetype<usize>(buffer) + HEADER_SIZE + (<usize>start << alignof<T>());
|
||||
var splice = new Array<T>(deleteCount);
|
||||
var spliceStart = splice.dataStart;
|
||||
var thisStart = this.dataStart;
|
||||
var thisBase = thisStart + (<usize>start << alignof<T>());
|
||||
for (let i = 0; i < deleteCount; ++i) {
|
||||
let element = load<T>(thisBase + (<usize>i << alignof<T>()));
|
||||
store<T>(spliceStart + (<usize>i << alignof<T>()), element);
|
||||
if (isManaged<T>()) LINK(changetype<usize>(element), changetype<usize>(splice));
|
||||
}
|
||||
memory.copy(
|
||||
changetype<usize>(spliced.buffer_) + HEADER_SIZE,
|
||||
source,
|
||||
splice.dataStart,
|
||||
thisBase,
|
||||
<usize>deleteCount << alignof<T>()
|
||||
);
|
||||
var offset = start + deleteCount;
|
||||
if (length != offset) {
|
||||
memory.copy(
|
||||
source,
|
||||
changetype<usize>(buffer) + HEADER_SIZE + (<usize>offset << alignof<T>()),
|
||||
thisBase,
|
||||
thisStart + (<usize>offset << alignof<T>()),
|
||||
<usize>(length - offset) << alignof<T>()
|
||||
);
|
||||
}
|
||||
this.length_ = length - deleteCount;
|
||||
return spliced;
|
||||
return splice;
|
||||
}
|
||||
|
||||
reverse(): Array<T> {
|
||||
|
||||
2
std/assembly/index.d.ts
vendored
2
std/assembly/index.d.ts
vendored
@ -1020,8 +1020,6 @@ declare namespace table {
|
||||
declare class ArrayBuffer {
|
||||
/** The size, in bytes, of the array. */
|
||||
readonly byteLength: i32;
|
||||
/** Unsafe pointer to the start of the data in memory. */
|
||||
readonly data: usize;
|
||||
/** Returns true if value is one of the ArrayBuffer views, such as typed array or a DataView **/
|
||||
static isView<T>(value: T): bool;
|
||||
/** Constructs a new array buffer of the given length in bytes. */
|
||||
|
||||
@ -1,12 +1,3 @@
|
||||
import {
|
||||
LOAD,
|
||||
STORE
|
||||
} from "./arraybuffer";
|
||||
|
||||
import {
|
||||
compareUnsafe
|
||||
} from "./string";
|
||||
|
||||
/** Obtains the default comparator for the specified value type. */
|
||||
@inline
|
||||
export function COMPARATOR<T>(): (a: T, b: T) => i32 {
|
||||
@ -42,7 +33,7 @@ export function COMPARATOR<T>(): (a: T, b: T) => i32 {
|
||||
if (!alen && !blen) return 0;
|
||||
if (!alen) return -1;
|
||||
if (!blen) return 1;
|
||||
return compareUnsafe(<string>a, 0, <string>b, 0, <usize>min(alen, blen));
|
||||
return String.cmp(<string>a, 0, <string>b, 0, <usize>min(alen, blen));
|
||||
};
|
||||
} else {
|
||||
return (a: T, b: T): i32 => (<i32>(a > b) - <i32>(a < b));
|
||||
@ -51,47 +42,44 @@ export function COMPARATOR<T>(): (a: T, b: T) => i32 {
|
||||
|
||||
@inline
|
||||
export function SORT<T>(
|
||||
buffer: ArrayBuffer,
|
||||
byteOffset: i32,
|
||||
dataStart: usize,
|
||||
length: i32,
|
||||
comparator: (a: T, b: T) => i32
|
||||
): void {
|
||||
if (isReference<T>()) {
|
||||
// TODO replace this to faster stable sort (TimSort) when it implemented
|
||||
insertionSort<T>(buffer, byteOffset, length, comparator);
|
||||
insertionSort<T>(dataStart, length, comparator);
|
||||
} else {
|
||||
if (length < 256) {
|
||||
insertionSort<T>(buffer, byteOffset, length, comparator);
|
||||
insertionSort<T>(dataStart, length, comparator);
|
||||
} else {
|
||||
weakHeapSort<T>(buffer, byteOffset, length, comparator);
|
||||
weakHeapSort<T>(dataStart, length, comparator);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Sorts an Array with the 'Insertion Sort' algorithm. */
|
||||
function insertionSort<T>(
|
||||
buffer: ArrayBuffer,
|
||||
byteOffset: i32,
|
||||
dataStart: usize,
|
||||
length: i32,
|
||||
comparator: (a: T, b: T) => i32
|
||||
): void {
|
||||
for (let i = 0; i < length; i++) {
|
||||
let a = LOAD<T>(buffer, i, byteOffset); // a = arr[i]
|
||||
let a: T = load<T>(dataStart + (<usize>i << alignof<T>())); // a = arr[i]
|
||||
let j = i - 1;
|
||||
while (j >= 0) {
|
||||
let b = LOAD<T>(buffer, j, byteOffset); // b = arr[j]
|
||||
let b: T = load<T>(dataStart + (<usize>j << alignof<T>())); // b = arr[j]
|
||||
if (comparator(a, b) < 0) {
|
||||
STORE<T>(buffer, j-- + 1, b, byteOffset); // arr[j + 1] = b
|
||||
store<T>(dataStart + (<usize>(j-- + 1) << alignof<T>()), b); // arr[j + 1] = b
|
||||
} else break;
|
||||
}
|
||||
STORE<T>(buffer, j + 1, a, byteOffset); // arr[j + 1] = a
|
||||
store<T>(dataStart + (<usize>(j + 1) << alignof<T>()), a); // arr[j + 1] = a
|
||||
}
|
||||
}
|
||||
|
||||
/** Sorts an Array with the 'Weak Heap Sort' algorithm. */
|
||||
function weakHeapSort<T>(
|
||||
buffer: ArrayBuffer,
|
||||
byteOffset: i32,
|
||||
dataStart: usize,
|
||||
length: i32,
|
||||
comparator: (a: T, b: T) => i32
|
||||
): void {
|
||||
@ -108,37 +96,37 @@ function weakHeapSort<T>(
|
||||
while ((j & 1) == (load<u32>(bitset + (j >> 6 << shift32)) >> (j >> 1 & 31) & 1)) j >>= 1;
|
||||
|
||||
let p = j >> 1;
|
||||
let a = LOAD<T>(buffer, p, byteOffset); // a = arr[p]
|
||||
let b = LOAD<T>(buffer, i, byteOffset); // b = arr[i]
|
||||
let a: T = load<T>(dataStart + (<usize>p << alignof<T>())); // a = arr[p]
|
||||
let b: T = load<T>(dataStart + (<usize>i << alignof<T>())); // b = arr[i]
|
||||
if (comparator(a, b) < 0) {
|
||||
store<u32>(
|
||||
bitset + (i >> 5 << shift32),
|
||||
load<u32>(bitset + (i >> 5 << shift32)) ^ (1 << (i & 31))
|
||||
);
|
||||
STORE<T>(buffer, i, a, byteOffset); // arr[i] = a
|
||||
STORE<T>(buffer, p, b, byteOffset); // arr[p] = b
|
||||
store<T>(dataStart + (<usize>i << alignof<T>()), a); // arr[i] = a
|
||||
store<T>(dataStart + (<usize>p << alignof<T>()), b); // arr[p] = b
|
||||
}
|
||||
}
|
||||
|
||||
for (let i = length - 1; i >= 2; i--) {
|
||||
let a = LOAD<T>(buffer, 0, byteOffset);
|
||||
STORE<T>(buffer, 0, LOAD<T>(buffer, i, byteOffset), byteOffset);
|
||||
STORE<T>(buffer, i, a, byteOffset);
|
||||
let a: T = load<T>(dataStart); // a = arr[0]
|
||||
store<T>(dataStart, load<T>(dataStart + (<usize>i << alignof<T>()))); // arr[0] = arr[i]
|
||||
store<T>(dataStart + (<usize>i << alignof<T>()), a); // arr[i] = a
|
||||
|
||||
let x = 1, y: i32;
|
||||
while ((y = (x << 1) + ((load<u32>(bitset + (x >> 5 << shift32)) >> (x & 31)) & 1)) < i) x = y;
|
||||
|
||||
while (x > 0) {
|
||||
a = LOAD<T>(buffer, 0, byteOffset); // a = arr[0]
|
||||
let b = LOAD<T>(buffer, x, byteOffset); // b = arr[x]
|
||||
a = load<T>(dataStart); // a = arr[0]
|
||||
let b: T = load<T>(dataStart + (<usize>x << alignof<T>())); // b = arr[x]
|
||||
|
||||
if (comparator(a, b) < 0) {
|
||||
store<u32>(
|
||||
bitset + (x >> 5 << shift32),
|
||||
load<u32>(bitset + (x >> 5 << shift32)) ^ (1 << (x & 31))
|
||||
);
|
||||
STORE<T>(buffer, x, a, byteOffset); // arr[x] = a
|
||||
STORE<T>(buffer, 0, b, byteOffset); // arr[0] = b
|
||||
store<T>(dataStart + (<usize>x << alignof<T>()), a); // arr[x] = a
|
||||
store<T>(dataStart, b); // arr[0] = b
|
||||
}
|
||||
x >>= 1;
|
||||
}
|
||||
@ -146,7 +134,7 @@ function weakHeapSort<T>(
|
||||
|
||||
memory.free(bitset);
|
||||
|
||||
var t = LOAD<T>(buffer, 1, byteOffset); // t = arr[1]
|
||||
STORE<T>(buffer, 1, LOAD<T>(buffer, 0, byteOffset), byteOffset);
|
||||
STORE<T>(buffer, 0, t, byteOffset); // arr[0] = t
|
||||
var t: T = load<T>(dataStart, sizeof<T>()); // t = arr[1]
|
||||
store<T>(dataStart, load<T>(dataStart), sizeof<T>()); // arr[1] = arr[0]
|
||||
store<T>(dataStart, t); // arr[0] = t
|
||||
}
|
||||
|
||||
@ -1,3 +1,13 @@
|
||||
export function compareImpl(str1: String, index1: usize, str2: String, index2: usize, len: usize): i32 {
|
||||
var result: i32 = 0;
|
||||
var ptr1 = changetype<usize>(str1) + (index1 << 1);
|
||||
var ptr2 = changetype<usize>(str2) + (index2 << 1);
|
||||
while (len && !(result = <i32>load<u16>(ptr1) - <i32>load<u16>(ptr2))) {
|
||||
--len, ptr1 += 2, ptr2 += 2;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
import { MAX_SIZE_32 } from "./allocator";
|
||||
import { String } from "../string";
|
||||
|
||||
@ -38,16 +48,6 @@ export function copyUnsafe(dest: String, destOffset: usize, src: String, srcOffs
|
||||
);
|
||||
}
|
||||
|
||||
export function compareUnsafe(str1: String, offset1: usize, str2: String, offset2: usize, len: usize): i32 {
|
||||
var cmp: i32 = 0;
|
||||
var ptr1 = changetype<usize>(str1) + (offset1 << 1);
|
||||
var ptr2 = changetype<usize>(str2) + (offset2 << 1);
|
||||
while (len && !(cmp = <i32>load<u16>(ptr1, HEADER_SIZE) - <i32>load<u16>(ptr2, HEADER_SIZE))) {
|
||||
--len, ptr1 += 2, ptr2 += 2;
|
||||
}
|
||||
return cmp;
|
||||
}
|
||||
|
||||
export function repeatUnsafe(dest: String, destOffset: usize, src: String, count: i32): void {
|
||||
var length = src.length;
|
||||
if (ASC_SHRINK_LEVEL > 1) {
|
||||
|
||||
@ -87,6 +87,9 @@ export function ADJUST(payloadSize: usize): usize {
|
||||
// free right away if not registered yet
|
||||
assert(ref > HEAP_BASE); // static objects aren't scratch objects
|
||||
memory.free(changetype<usize>(header));
|
||||
} else if (GC) {
|
||||
// if previously registered, register again
|
||||
gc.register(ref);
|
||||
}
|
||||
header = newHeader;
|
||||
ref = newRef;
|
||||
@ -124,11 +127,11 @@ function unref(ref: usize): HEADER {
|
||||
}
|
||||
|
||||
/** Links a managed object with its managed parent. */
|
||||
@unsafe export function LINK(ref: usize, parentRef: usize): void {
|
||||
assert(ref >= HEAP_BASE + HEADER_SIZE); // must be a heap object
|
||||
var header = changetype<HEADER>(ref - HEADER_SIZE);
|
||||
@unsafe @inline export function LINK<T, TParent>(ref: T, parentRef: TParent): void {
|
||||
assert(changetype<usize>(ref) >= HEAP_BASE + HEADER_SIZE); // must be a heap object
|
||||
var header = changetype<HEADER>(changetype<usize>(ref) - HEADER_SIZE);
|
||||
assert(header.classId != HEADER_MAGIC && header.gc1 != 0 && header.gc2 != 0); // must be registered
|
||||
if (GC) gc.link(ref, parentRef); // tslint:disable-line
|
||||
if (GC) gc.link(changetype<usize>(ref), changetype<usize>(parentRef)); // tslint:disable-line
|
||||
}
|
||||
|
||||
/** ArrayBuffer base class. */
|
||||
@ -146,14 +149,13 @@ export abstract class ArrayBufferBase {
|
||||
/** Typed array base class. */
|
||||
export abstract class ArrayBufferView {
|
||||
[key: number]: number;
|
||||
readonly buffer: ArrayBuffer;
|
||||
|
||||
@unsafe buffer: ArrayBuffer;
|
||||
@unsafe dataStart: usize;
|
||||
@unsafe dataEnd: usize;
|
||||
|
||||
constructor(length: i32, alignLog2: i32) {
|
||||
if (<u32>length > <u32>ArrayBufferBase.MAX_BYTELENGTH >> alignLog2) {
|
||||
throw new RangeError("Invalid typed array length");
|
||||
}
|
||||
if (<u32>length > <u32>ArrayBufferBase.MAX_BYTELENGTH >>> alignLog2) throw new RangeError("Invalid length");
|
||||
var byteLength = length << alignLog2;
|
||||
var buffer = new ArrayBuffer(byteLength);
|
||||
this.buffer = buffer;
|
||||
|
||||
@ -5,42 +5,13 @@ import {
|
||||
} from "./runtime";
|
||||
|
||||
import {
|
||||
compareImpl,
|
||||
parse,
|
||||
CharCode,
|
||||
parse
|
||||
isWhiteSpaceOrLineTerminator
|
||||
} from "./internal/string";
|
||||
|
||||
import {
|
||||
STORE
|
||||
} from "./internal/arraybuffer";
|
||||
|
||||
function compareImpl(str1: String, index1: usize, str2: String, index2: usize, len: usize): i32 {
|
||||
var result: i32 = 0;
|
||||
var ptr1 = changetype<usize>(str1) + (index1 << 1);
|
||||
var ptr2 = changetype<usize>(str2) + (index2 << 1);
|
||||
while (len && !(result = <i32>load<u16>(ptr1) - <i32>load<u16>(ptr2))) {
|
||||
--len, ptr1 += 2, ptr2 += 2;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
function isWhiteSpaceOrLineTerminator(c: u16): bool {
|
||||
switch (c) {
|
||||
case 9: // <TAB>
|
||||
case 10: // <LF>
|
||||
case 13: // <CR>
|
||||
case 11: // <VT>
|
||||
case 12: // <FF>
|
||||
case 32: // <SP>
|
||||
case 160: // <NBSP>
|
||||
case 8232: // <LS>
|
||||
case 8233: // <PS>
|
||||
case 65279: return true; // <ZWNBSP>
|
||||
default: return false;
|
||||
}
|
||||
}
|
||||
|
||||
@sealed
|
||||
export class String extends StringBase {
|
||||
@sealed export class String extends StringBase {
|
||||
|
||||
// TODO Add and handle second argument
|
||||
static fromCharCode(code: i32): String {
|
||||
@ -393,7 +364,7 @@ export class String extends StringBase {
|
||||
changetype<usize>(this) + (<usize>i << 1)
|
||||
)
|
||||
);
|
||||
STORE<usize>(buffer, i, char); // FIXME: use store<T> once AB is done as well
|
||||
store<usize>(changetype<usize>(buffer) + (<usize>i << 1), char);
|
||||
}
|
||||
return result;
|
||||
} else if (!length) {
|
||||
|
||||
@ -6,7 +6,8 @@ import {
|
||||
} from "./runtime";
|
||||
|
||||
import {
|
||||
COMPARATOR
|
||||
COMPARATOR,
|
||||
SORT as SORT_IMPL
|
||||
} from "./internal/sort";
|
||||
|
||||
function clampToByte(value: i32): i32 {
|
||||
@ -651,16 +652,15 @@ export class Float64Array extends ArrayBufferView {
|
||||
if (length <= 1) return array;
|
||||
var base = array.dataStart;
|
||||
if (length == 2) {
|
||||
let a = load<T>(base, sizeof<T>());
|
||||
let b = load<T>(base);
|
||||
let a: T = load<T>(base, sizeof<T>()); // a = arr[1]
|
||||
let b: T = load<T>(base); // b = arr[0]
|
||||
if (comparator(a, b) < 0) {
|
||||
store<T>(base, b, sizeof<T>());
|
||||
store<T>(base, a);
|
||||
store<T>(base, b, sizeof<T>()); // arr[1] = b
|
||||
store<T>(base, a); // arr[0] = a
|
||||
}
|
||||
return array;
|
||||
}
|
||||
// TODO
|
||||
// SORT_IMPL<T>(buffer, byteOffset, length, comparator);
|
||||
SORT_IMPL<T>(base, length, comparator);
|
||||
return array;
|
||||
}
|
||||
|
||||
|
||||
@ -0,0 +1,9 @@
|
||||
import "allocator/arena";
|
||||
|
||||
var arr = new Uint8Array(8);
|
||||
arr[0] = 10;
|
||||
arr[4] = 5;
|
||||
var arr2 = arr.sort();
|
||||
arr2.forEach(x => {
|
||||
trace("", 1, x);
|
||||
});
|
||||
Loading…
x
Reference in New Issue
Block a user