fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-04-27 07:52:14 +00:00
Code Issues Projects Releases Wiki Activity

srsly

Browse Source
This commit is contained in:
dcode 2019-03-14 05:11:03 +01:00
parent 6163a73ab5
commit a5e14a0eaa
24 changed files with 739 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
std/assembly/allocator/arena.ts
View File

@ -1,9 +1,13 @@
import { HEAP_BASE, memory } from "../memory";
import { AL_MASK, MAX_SIZE_32 } from "../util/allocator";
// @ts-ignore: decorator
@lazy var startOffset: usize = (HEAP_BASE + AL_MASK) & ~AL_MASK;
// @ts-ignore: decorator
@lazy var offset: usize = startOffset;
// @ts-ignore: decorator
@unsafe @global function __memory_allocate(size: usize): usize {
if (size > MAX_SIZE_32) unreachable();
var ptr = offset;
@ -22,9 +26,11 @@ import { AL_MASK, MAX_SIZE_32 } from "../util/allocator";
return ptr;
}
// @ts-ignore: decorator
@unsafe @global function __memory_free(ptr: usize): void {
}
// @ts-ignore: decorator
@unsafe @global function __memory_reset(): void {
offset = startOffset;
}

5
std/assembly/allocator/emscripten.ts
View File

@ -1,10 +1,15 @@
// @ts-ignore: decorator
@unsafe declare function _malloc(size: usize): usize;
// @ts-ignore: decorator
@unsafe declare function _free(ptr: usize): void;
// @ts-ignore: decorator
@unsafe @global function __memory_allocate(size: usize): usize {
return _malloc(size);
}
// @ts-ignore: decorator
@unsafe @global function __memory_free(ptr: usize): void {
_free(ptr);
}

5
std/assembly/allocator/system.ts
View File

@ -1,10 +1,15 @@
// @ts-ignore: decorator
@unsafe declare function malloc(size: usize): usize;
// @ts-ignore: decorator
@unsafe declare function free(ptr: usize): void;
// @ts-ignore: decorator
@unsafe @global function __memory_allocate(size: usize): usize {
return malloc(size);
}
// @ts-ignore: decorator
@unsafe @global function __memory_free(ptr: usize): void {
free(ptr);
}

14
std/assembly/allocator/tlsf.ts
View File

@ -44,8 +44,7 @@ const LEFT_FREE: usize = 1 << 1;
const TAGS: usize = FREE | LEFT_FREE;
/** Block structure. */
@unmanaged
class Block {
@unmanaged class Block {
/** Info field holding this block's size and tags. */
info: usize;
@ -110,8 +109,7 @@ class Block {
assert((1 << SL_BITS) <= 32); // second level must fit into 32 bits
/** Root structure. */
@unmanaged
class Root {
@unmanaged class Root {
/** First level bitmap. */
flMap: usize = 0;
@ -406,15 +404,17 @@ class Root {
}
/** Determines the first (LSB to MSB) set bit's index of a word. */
function ffs<T>(word: T): T {
function ffs<T extends number>(word: T): T {
assert(word != 0); // word cannot be 0
return ctz<T>(word); // differs from ffs only for 0
}
/** Determines the last (LSB to MSB) set bit's index of a word. */
function fls<T>(word: T): T {
function fls<T extends number>(word: T): T {
assert(word != 0); // word cannot be 0
// @ts-ignore: type
const inv: T = (sizeof<T>() << 3) - 1;
// @ts-ignore: type
return inv - clz<T>(word);
}
@ -422,6 +422,7 @@ function fls<T>(word: T): T {
var ROOT: Root = changetype<Root>(0);
/** Allocates a chunk of memory. */
// @ts-ignore: decorator
@unsafe @global function __memory_allocate(size: usize): usize {
// initialize if necessary
var root = ROOT;
@ -470,6 +471,7 @@ var ROOT: Root = changetype<Root>(0);
}
/** Frees the chunk of memory at the specified address. */
// @ts-ignore
@unsafe @global function __memory_free(data: usize): void {
if (data) {
let root = ROOT;

12
std/assembly/array.ts
View File

@ -95,6 +95,7 @@ export class Array<T> extends ArrayBufferView {
if (start < end) {
memory.fill(
dataStart + <usize>start,
// @ts-ignore: cast
<u8>value,
<usize>(end - start)
);
@ -268,6 +269,7 @@ export class Array<T> extends ArrayBufferView {
base + sizeof<T>(),
<usize>lastIndex << alignof<T>()
);
// @ts-ignore: cast
store<T>(base + (<usize>lastIndex << alignof<T>()), <T>null);
this.length_ = lastIndex;
return element;
@ -375,6 +377,7 @@ export class Array<T> extends ArrayBufferView {
join(separator: string = ","): string {
if (isInteger<T>()) {
// @ts-ignore: type
if (value instanceof bool) return this.join_bool(separator);
return this.join_int(separator);
}
@ -400,6 +403,7 @@ export class Array<T> extends ArrayBufferView {
var value: bool;
for (let i = 0; i < lastIndex; ++i) {
value = load<bool>(dataStart + i);
// @ts-ignore: cast
valueLen = 4 + <i32>(!value);
memory.copy(
result + (<usize>offset << 1),
@ -417,6 +421,7 @@ export class Array<T> extends ArrayBufferView {
}
}
value = load<bool>(dataStart + <usize>lastIndex);
// @ts-ignore: cast
valueLen = 4 + <i32>(!value);
memory.copy(
result + (<usize>offset << 1),
@ -440,6 +445,7 @@ export class Array<T> extends ArrayBufferView {
if (!lastIndex) return changetype<string>(itoa<T>(load<T>(dataStart)));
var sepLen = separator.length;
// @ts-ignore: cast
const valueLen = (sizeof<T>() <= 4 ? 10 : 20) + <i32>isSigned<T>();
var estLen = (valueLen + sepLen) * lastIndex + valueLen;
var result = runtime.alloc(estLen << 1);
@ -471,6 +477,7 @@ export class Array<T> extends ArrayBufferView {
var lastIndex = this.length_ - 1;
if (lastIndex < 0) return "";
var dataStart = this.dataStart;
// @ts-ignore: type
if (!lastIndex) return changetype<string>(dtoa(load<T>(dataStart)));
const valueLen = MAX_DOUBLE_LENGTH;
@ -481,6 +488,7 @@ export class Array<T> extends ArrayBufferView {
var value: T;
for (let i = 0; i < lastIndex; ++i) {
value = load<T>(dataStart + (<usize>i << alignof<T>()));
// @ts-ignore: type
offset += dtoa_stream(result, offset, value);
if (sepLen) {
memory.copy(
@ -492,6 +500,7 @@ export class Array<T> extends ArrayBufferView {
}
}
value = load<T>(dataStart + (<usize>lastIndex << alignof<T>()));
// @ts-ignore: type
offset += dtoa_stream(result, offset, value);
if (estLen > offset) {
let trimmed = changetype<string>(result).substring(0, offset);
@ -557,14 +566,17 @@ export class Array<T> extends ArrayBufferView {
var value: T;
if (!lastIndex) {
value = load<T>(base);
// @ts-ignore: type
return value ? value.join(separator) : "";
}
for (let i = 0; i < lastIndex; ++i) {
value = load<T>(base + (<usize>i << alignof<T>()));
// @ts-ignore: type
if (value) result += value.join(separator);
if (sepLen) result += separator;
}
value = load<T>(base + (<usize>lastIndex << alignof<T>()));
// @ts-ignore: type
if (value) result += value.join(separator);
return result; // registered by concatenation (FIXME: lots of garbage)
}

403
std/assembly/builtins.ts
View File

@ -1,501 +1,898 @@
/* tslint:disable */
// @ts-ignore: decorator
@builtin @inline export const NaN: f64 = 0 / 0;
// @ts-ignore: decorator
@builtin @inline export const Infinity: f64 = 1 / 0;
// @ts-ignore: decorator
@builtin export declare function isInteger<T>(value?: T): bool;
// @ts-ignore: decorator
@builtin export declare function isFloat<T>(value?: T): bool;
// @ts-ignore: decorator
@builtin export declare function isSigned<T>(value?: T): bool;
// @ts-ignore: decorator
@builtin export declare function isReference<T>(value?: T): bool;
// @ts-ignore: decorator
@builtin export declare function isString<T>(value?: T): bool;
// @ts-ignore: decorator
@builtin export declare function isArray<T>(value?: T): bool;
// @ts-ignore: decorator
@builtin export declare function isArrayLike<T>(value?: T): bool;
// @ts-ignore: decorator
@builtin export declare function isFunction<T>(value?: T): bool;
// @ts-ignore: decorator
@builtin export declare function isNullable<T>(value?: T): bool;
// @ts-ignore: decorator
@builtin export declare function isDefined(expression: void): bool;
// @ts-ignore: decorator
@builtin export declare function isConstant(expression: void): bool;
// @ts-ignore: decorator
@builtin export declare function isManaged<T>(value?: T): bool;
// @ts-ignore: decorator
@inline export function isNaN<T>(value: T): bool { return value != value; }
// @ts-ignore: decorator
@inline export function isFinite<T>(value: T): bool { return value - value == 0; }
// @ts-ignore: decorator
@builtin export declare function clz<T>(value: T): T;
// @ts-ignore: decorator
@builtin export declare function ctz<T>(value: T): T;
// @ts-ignore: decorator
@builtin export declare function popcnt<T>(value: T): T;
// @ts-ignore: decorator
@builtin export declare function rotl<T>(value: T, shift: T): T;
// @ts-ignore: decorator
@builtin export declare function rotr<T>(value: T, shift: T): T;
// @ts-ignore: decorator
@builtin export declare function abs<T>(value: T): T;
// @ts-ignore: decorator
@builtin export declare function max<T>(left: T, right: T): T;
// @ts-ignore: decorator
@builtin export declare function min<T>(left: T, right: T): T;
// @ts-ignore: decorator
@builtin export declare function ceil<T>(value: T): T;
// @ts-ignore: decorator
@builtin export declare function floor<T>(value: T): T;
// @ts-ignore: decorator
@builtin export declare function copysign<T>(left: T, right: T): T;
// @ts-ignore: decorator
@builtin export declare function nearest<T>(value: T): T;
@builtin export declare function reinterpret<T>(value: void): T;
// @ts-ignore: decorator
@builtin export declare function reinterpret<T>(value: number): T;
// @ts-ignore: decorator
@builtin export declare function sqrt<T>(value: T): T;
// @ts-ignore: decorator
@builtin export declare function trunc<T>(value: T): T;
// @ts-ignore: decorator
@builtin export declare function load<T>(offset: usize, immOffset?: usize, immAlign?: usize): T;
// @ts-ignore: decorator
@builtin export declare function store<T>(offset: usize, value: void, immOffset?: usize, immAlign?: usize): void;
// @ts-ignore: decorator
@builtin export declare function sizeof<T>(): usize; // | u32 / u64
// @ts-ignore: decorator
@builtin export declare function alignof<T>(): usize; // | u32 / u64
// @ts-ignore: decorator
@builtin export declare function offsetof<T>(fieldName?: string): usize; // | u32 / u64
// @ts-ignore: decorator
@builtin export declare function select<T>(ifTrue: T, ifFalse: T, condition: bool): T;
// @ts-ignore: decorator
@builtin export declare function unreachable(): void;
// @ts-ignore: decorator
@builtin export declare function changetype<T>(value: void): T;
// @ts-ignore: decorator
@builtin export declare function assert<T>(isTrueish: T, message?: string): T;
// @ts-ignore: decorator
@builtin export declare function unchecked<T>(expr: T): T;
// @ts-ignore: decorator
@builtin export declare function call_indirect<T>(target: void, ...args: void[]): T;
// @ts-ignore: decorator
@builtin export declare function instantiate<T>(...args: void[]): T;
export namespace atomic {
// @ts-ignore: decorator
@builtin export declare function load<T>(offset: usize, immOffset?: usize): T;
// @ts-ignore: decorator
@builtin export declare function store<T>(offset: usize, value: T, immOffset?: usize): void;
// @ts-ignore: decorator
@builtin export declare function add<T>(ptr: usize, value: T, immOffset?: usize): T;
// @ts-ignore: decorator
@builtin export declare function sub<T>(ptr: usize, value: T, immOffset?: usize): T;
// @ts-ignore: decorator
@builtin export declare function and<T>(ptr: usize, value: T, immOffset?: usize): T;
// @ts-ignore: decorator
@builtin export declare function or<T>(ptr: usize, value: T, immOffset?: usize): T;
// @ts-ignore: decorator
@builtin export declare function xor<T>(ptr: usize, value: T, immOffset?: usize): T;
// @ts-ignore: decorator
@builtin export declare function xchg<T>(ptr: usize, value: T, immOffset?: usize): T;
// @ts-ignore: decorator
@builtin export declare function cmpxchg<T>(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;
// @ts-ignore: decorator
@builtin export declare function wait<T>(ptr: usize, expected: T, timeout: i64): AtomicWaitResult;
// @ts-ignore: decorator
@builtin export declare function notify<T>(ptr: usize, count: i32): i32;
// @ts-ignore: decorators
}
// @ts-ignore: decorator
@lazy export const enum AtomicWaitResult {
OK = 0,
NOT_EQUAL = 1,
TIMED_OUT = 2
}
// @ts-ignore: decorator
@builtin export declare function i8(value: void): i8;
export namespace i8 {
// @ts-ignore: decorator
@lazy export const MIN_VALUE: i8 = -128;
// @ts-ignore: decorator
@lazy export const MAX_VALUE: i8 = 127;
}
// @ts-ignore: decorator
@builtin export declare function i16(value: void): i16;
export namespace i16 {
// @ts-ignore: decorator
@lazy export const MIN_VALUE: i16 = -32768;
// @ts-ignore: decorator
@lazy export const MAX_VALUE: i16 = 32767;
}
// @ts-ignore: decorator
@builtin export declare function i32(value: void): i32;
export namespace i32 {
// @ts-ignore: decorator
@lazy export const MIN_VALUE: i32 = -2147483648;
// @ts-ignore: decorator
@lazy export const MAX_VALUE: i32 = 2147483647;
// @ts-ignore: decorator
@builtin export declare function clz(value: i32): i32;
// @ts-ignore: decorator
@builtin export declare function ctz(value: i32): i32;
// @ts-ignore: decorator
@builtin export declare function popcnt(value: i32): i32;
// @ts-ignore: decorator
@builtin export declare function rotl(value: i32, shift: i32): i32;
// @ts-ignore: decorator
@builtin export declare function rotr(value: i32, shift: i32): i32;
// @ts-ignore: decorator
@builtin export declare function reinterpret_f32(value: f32): i32;
// @ts-ignore: decorator
@builtin export declare function load8_s(offset: usize, immOffset?: usize, immAlign?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function load8_u(offset: usize, immOffset?: usize, immAlign?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function load16_s(offset: usize, immOffset?: usize, immAlign?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function load16_u(offset: usize, immOffset?: usize, immAlign?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function load(offset: usize, immOffset?: usize, immAlign?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function store8(offset: usize, value: i32, immOffset?: usize, immAlign?: usize): void;
// @ts-ignore: decorator
@builtin export declare function store16(offset: usize, value: i32, immOffset?: usize, immAlign?: usize): void;
// @ts-ignore: decorator
@builtin export declare function store(offset: usize, value: i32, immOffset?: usize, immAlign?: usize): void;
export namespace atomic {
// @ts-ignore: decorator
@builtin export declare function load8_u(offset: usize, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function load16_u(offset: usize, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function load(offset: usize, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function store8(offset: usize, value: i32, immOffset?: usize): void;
// @ts-ignore: decorator
@builtin export declare function store16(offset: usize, value: i32, immOffset?: usize): void;
// @ts-ignore: decorator
@builtin export declare function store(offset: usize, value: i32, immOffset?: usize): void;
// @ts-ignore: decorator
@builtin export declare function wait(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;
// @ts-ignore: decorator
@builtin export declare function notify(ptr: usize, count: i32): i32;
export namespace rmw8 {
// @ts-ignore: decorator
@builtin export declare function add_u(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function sub_u(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function and_u(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function or_u(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function xor_u(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function xchg_u(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function cmpxchg_u(offset: usize, expected: i32, replacement: i32, immOffset?: usize): i32;
}
export namespace rmw16 {
// @ts-ignore: decorator
@builtin export declare function add_u(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function sub_u(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function and_u(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function or_u(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function xor_u(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function xchg_u(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function cmpxchg_u(offset: usize, expected: i32, replacement: i32, immOffset?: usize): i32;
}
export namespace rmw {
// @ts-ignore: decorator
@builtin export declare function add(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function sub(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function and(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function or(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function xor(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function xchg(offset: usize, value: i32, immOffset?: usize): i32;
// @ts-ignore: decorator
@builtin export declare function cmpxchg(offset: usize, expected: i32, replacement: i32, immOffset?: usize): i32;
}
}
}
// @ts-ignore: decorator
@builtin export declare function i64(value: void): i64;
export namespace i64 {
// @ts-ignore: decorator
@lazy export const MIN_VALUE: i64 = -9223372036854775808;
// @ts-ignore: decorator
@lazy export const MAX_VALUE: i64 = 9223372036854775807;
// @ts-ignore: decorator
@builtin export declare function clz(value: i64): i64;
// @ts-ignore: decorator
@builtin export declare function ctz(value: i64): i64;
// @ts-ignore: decorator
@builtin export declare function load8_s(offset: usize, immOffset?: usize, immAlign?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function load8_u(offset: usize, immOffset?: usize, immAlign?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function load16_s(offset: usize, immOffset?: usize, immAlign?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function load16_u(offset: usize, immOffset?: usize, immAlign?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function load32_s(offset: usize, immOffset?: usize, immAlign?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function load32_u(offset: usize, immOffset?: usize, immAlign?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function load(offset: usize, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function popcnt(value: i64): i64;
// @ts-ignore: decorator
@builtin export declare function rotl(value: i64, shift: i64): i64;
// @ts-ignore: decorator
@builtin export declare function rotr(value: i64, shift: i64): i64;
// @ts-ignore: decorator
@builtin export declare function reinterpret_f64(value: f64): i64;
// @ts-ignore: decorator
@builtin export declare function store8(offset: usize, value: i64, immOffset?: usize, immAlign?: usize): void;
// @ts-ignore: decorator
@builtin export declare function store16(offset: usize, value: i64, immOffset?: usize, immAlign?: usize): void;
// @ts-ignore: decorator
@builtin export declare function store32(offset: usize, value: i64, immOffset?: usize, immAlign?: usize): void;
// @ts-ignore: decorator
@builtin export declare function store(offset: usize, value: i64, immOffset?: usize, immAlign?: usize): void;
export namespace atomic {
// @ts-ignore: decorator
@builtin export declare function load8_u(offset: usize, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function load16_u(offset: usize, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function load32_u(offset: usize, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function load(offset: usize, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function store8(offset: usize, value: i64, immOffset?: usize): void;
// @ts-ignore: decorator
@builtin export declare function store16(offset: usize, value: i64, immOffset?: usize): void;
// @ts-ignore: decorator
@builtin export declare function store32(offset: usize, value: i64, immOffset?: usize): void;
// @ts-ignore: decorator
@builtin export declare function store(offset: usize, value: i64, immOffset?: usize): void;
// @ts-ignore: decorator
@builtin export declare function wait(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;
// @ts-ignore: decorator
@builtin export declare function notify(ptr: usize, count: i32): i32;
export namespace rmw8 {
// @ts-ignore: decorator
@builtin export declare function add_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function sub_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function and_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function or_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function xor_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function xchg_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function cmpxchg_u(offset: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
}
export namespace rmw16 {
// @ts-ignore: decorator
@builtin export declare function add_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function sub_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function and_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function or_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function xor_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function xchg_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function cmpxchg_u(offset: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
}
export namespace rmw32 {
// @ts-ignore: decorator
@builtin export declare function add_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function sub_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function and_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function or_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function xor_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function xchg_u(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function cmpxchg_u(offset: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
}
export namespace rmw {
// @ts-ignore: decorator
@builtin export declare function add(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function sub(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function and(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function or(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function xor(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function xchg(offset: usize, value: i64, immOffset?: usize): i64;
// @ts-ignore: decorator
@builtin export declare function cmpxchg(offset: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
}
}
}
// @ts-ignore: decorator
@builtin export declare function isize(value: void): isize;
export namespace isize {
// @ts-ignore: decorator
@lazy export const MIN_VALUE: isize = sizeof<i32>() == sizeof<isize>()
? -2147483648
: <isize>-9223372036854775808;
// @ts-ignore: decorator
@lazy export const MAX_VALUE: isize = sizeof<i32>() == sizeof<isize>()
? 2147483647
: <isize>9223372036854775807;
}
// @ts-ignore: decorator
@builtin export declare function u8(value: void): u8;
export namespace u8 {
// @ts-ignore: decorator
@lazy export const MIN_VALUE: u8 = 0;
// @ts-ignore: decorator
@lazy export const MAX_VALUE: u8 = 255;
}
// @ts-ignore: decorator
@builtin export declare function u16(value: void): u16;
export namespace u16 {
// @ts-ignore: decorator
@lazy export const MIN_VALUE: u16 = 0;
// @ts-ignore: decorator
@lazy export const MAX_VALUE: u16 = 65535;
}
// @ts-ignore: decorator
@builtin export declare function u32(value: void): u32;
export namespace u32 {
// @ts-ignore: decorator
@lazy export const MIN_VALUE: u32 = 0;
// @ts-ignore: decorator
@lazy export const MAX_VALUE: u32 = 4294967295;
}
// @ts-ignore: decorator
@builtin export declare function u64(value: void): u64;
export namespace u64 {
// @ts-ignore: decorator
@lazy export const MIN_VALUE: u64 = 0;
// @ts-ignore: decorator
@lazy export const MAX_VALUE: u64 = 18446744073709551615;
}
// @ts-ignore: decorator
@builtin export declare function usize(value: void): usize;
export namespace usize {
// @ts-ignore: decorator
@lazy export const MIN_VALUE: usize = 0;
// @ts-ignore: decorator
@lazy export const MAX_VALUE: usize = sizeof<u32>() == sizeof<usize>()
? 4294967295
: <usize>18446744073709551615;
}
// @ts-ignore: decorator
@builtin export declare function bool(value: void): bool;
export namespace bool {
// @ts-ignore: decorator
@lazy export const MIN_VALUE: bool = false;
// @ts-ignore: decorator
@lazy export const MAX_VALUE: bool = true;
}
// @ts-ignore: decorator
@builtin export declare function f32(value: void): f32;
export namespace f32 {
// @ts-ignore: decorator
@lazy export const EPSILON = reinterpret<f32>(0x34000000); // 0x1p-23f
// @ts-ignore: decorator
@lazy export const MIN_VALUE = reinterpret<f32>(0x00000001); // 0x0.000001p+0f
// @ts-ignore: decorator
@lazy export const MAX_VALUE = reinterpret<f32>(0x7F7FFFFF); // 0x1.fffffep+127f
// @ts-ignore: decorator
@lazy export const MIN_NORMAL_VALUE = reinterpret<f32>(0x00800000); // 0x1p-126f
// @ts-ignore: decorator
@lazy export const MIN_SAFE_INTEGER: f32 = -16777215;
// @ts-ignore: decorator
@lazy export const MAX_SAFE_INTEGER: f32 = 16777215;
// @ts-ignore: decorator
@builtin export declare function abs(value: f32): f32;
// @ts-ignore: decorator
@builtin export declare function ceil(value: f32): f32;
// @ts-ignore: decorator
@builtin export declare function copysign(x: f32, y: f32): f32;
// @ts-ignore: decorator
@builtin export declare function floor(value: f32): f32;
// @ts-ignore: decorator
@builtin export declare function load(offset: usize, immOffset?: usize, immAlign?: usize): f32;
// @ts-ignore: decorator
@builtin export declare function max(left: f32, right: f32): f32;
// @ts-ignore: decorator
@builtin export declare function min(left: f32, right: f32): f32;
// @ts-ignore: decorator
@builtin export declare function nearest(value: f32): f32;
// @ts-ignore: decorator
@builtin export declare function reinterpret_i32(value: i32): f32;
// @ts-ignore: decorator
@builtin export declare function sqrt(value: f32): f32;
// @ts-ignore: decorator
@builtin export declare function store(offset: usize, value: f32, immOffset?: usize, immAlign?: usize): void;
// @ts-ignore: decorator
@builtin export declare function trunc(value: f32): f32;
}
// @ts-ignore: decorator
@builtin export declare function f64(value: void): f64;
export namespace f64 {
// @ts-ignore: decorator
@lazy export const EPSILON = reinterpret<f64>(0x3CB0000000000000); // 0x1p-52
// @ts-ignore: decorator
@lazy export const MIN_VALUE = reinterpret<f64>(0x0000000000000001); // 0x0.0000000000001p+0
// @ts-ignore: decorator
@lazy export const MAX_VALUE = reinterpret<f64>(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023
// @ts-ignore: decorator
@lazy export const MIN_NORMAL_VALUE = reinterpret<f64>(0x0010000000000000); // 0x1p-1022
// @ts-ignore: decorator
@lazy export const MIN_SAFE_INTEGER: f64 = -9007199254740991;
// @ts-ignore: decorator
@lazy export const MAX_SAFE_INTEGER: f64 = 9007199254740991;
// @ts-ignore: decorator
@builtin export declare function abs(value: f64): f64;
// @ts-ignore: decorator
@builtin export declare function ceil(value: f64): f64;
// @ts-ignore: decorator
@builtin export declare function copysign(x: f64, y: f64): f64;
// @ts-ignore: decorator
@builtin export declare function floor(value: f64): f64;
// @ts-ignore: decorator
@builtin export declare function load(offset: usize, immOffset?: usize, immAlign?: usize): f64;
// @ts-ignore: decorator
@builtin export declare function max(left: f64, right: f64): f64;
// @ts-ignore: decorator
@builtin export declare function min(left: f64, right: f64): f64;
// @ts-ignore: decorator
@builtin export declare function nearest(value: f64): f64;
// @ts-ignore: decorator
@builtin export declare function reinterpret_i64(value: i64): f64;
// @ts-ignore: decorator
@builtin export declare function sqrt(value: f64): f64;
// @ts-ignore: decorator
@builtin export declare function store(offset: usize, value: f64, immOffset?: usize, immAlign?: usize): void;
// @ts-ignore: decorator
@builtin export declare function trunc(value: f64): f64;
}
// @ts-ignore: decorator
@builtin export declare function v128(a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8, i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8): v128;
export namespace v128 {
// @ts-ignore: decorator
@builtin export declare function splat<T>(x: T): v128;
// @ts-ignore: decorator
@builtin export declare function extract_lane<T>(x: v128, idx: u8): T;
// @ts-ignore: decorator
@builtin export declare function replace_lane<T>(x: v128, idx: u8, value: T): v128;
// @ts-ignore: decorator
@builtin export declare function shuffle<T>(a: v128, b: v128, ...lanes: u8[]): v128;
// @ts-ignore: decorator
@builtin export declare function load(offset: usize, immOffset?: usize, immAlign?: usize): v128;
// @ts-ignore: decorator
@builtin export declare function store(offset: usize, value: v128, immOffset?: usize, immAlign?: usize): void;
// @ts-ignore: decorator
@builtin export declare function add<T>(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function sub<T>(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function mul<T>(a: v128, b: v128): v128; // except i64
// @ts-ignore: decorator
@builtin export declare function div<T>(a: v128, b: v128): v128; // f32, f64 only
// @ts-ignore: decorator
@builtin export declare function neg<T>(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function add_saturate<T>(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function sub_saturate<T>(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function shl<T>(a: v128, b: i32): v128;
// @ts-ignore: decorator
@builtin export declare function shr<T>(a: v128, b: i32): v128;
// @ts-ignore: decorator
@builtin export declare function and(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function or(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function xor(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function not(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function bitselect(v1: v128, v2: v128, c: v128): v128;
// @ts-ignore: decorator
@builtin export declare function any_true<T>(a: v128): bool;
// @ts-ignore: decorator
@builtin export declare function all_true<T>(a: v128): bool;
// @ts-ignore: decorator
@builtin export declare function min<T>(a: v128, b: v128): v128; // f32, f64 only
// @ts-ignore: decorator
@builtin export declare function max<T>(a: v128, b: v128): v128; // f32, f64 only
// @ts-ignore: decorator
@builtin export declare function abs<T>(a: v128): v128; // f32, f64 only
// @ts-ignore: decorator
@builtin export declare function sqrt<T>(a: v128): v128; // f32, f64 only
// @ts-ignore: decorator
@builtin export declare function eq<T>(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function ne<T>(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function lt<T>(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function le<T>(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function gt<T>(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function ge<T>(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function convert<T>(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function trunc<T>(a: v128): v128;
}
// @ts-ignore: decorator
@builtin export declare function i8x16(a: i8, b: i8, c: i8, d: i8, e: i8, f: i8, g: i8, h: i8, i: i8, j: i8, k: i8, l: i8, m: i8, n: i8, o: i8, p: i8): v128;
export namespace i8x16 {
// @ts-ignore: decorator
@builtin export declare function splat(x: i8): v128;
// @ts-ignore: decorator
@builtin export declare function extract_lane_s(x: v128, idx: u8): i8;
// @ts-ignore: decorator
@builtin export declare function extract_lane_u(x: v128, idx: u8): u8;
// @ts-ignore: decorator
@builtin export declare function replace_lane(x: v128, idx: u8, value: i8): v128;
// @ts-ignore: decorator
@builtin export declare function add(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function sub(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function mul(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function neg(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function add_saturate_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function add_saturate_u(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function sub_saturate_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function sub_saturate_u(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function shl(a: v128, b: i32): v128;
// @ts-ignore: decorator
@builtin export declare function shr_s(a: v128, b: i32): v128;
// @ts-ignore: decorator
@builtin export declare function shr_u(a: v128, b: i32): v128;
// @ts-ignore: decorator
@builtin export declare function any_true(a: v128): bool;
// @ts-ignore: decorator
@builtin export declare function all_true(a: v128): bool;
// @ts-ignore: decorator
@builtin export declare function eq(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function ne(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function lt_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function lt_u(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function le_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function le_u(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function gt_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function gt_u(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function ge_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function ge_u(a: v128, b: v128): v128;
}
// @ts-ignore: decorator
@builtin export declare function i16x8(a: i16, b: i16, c: i16, d: i16, e: i16, f: i16, g: i16, h: i16): v128;
export namespace i16x8 {
// @ts-ignore: decorator
@builtin export declare function splat(x: i16): v128;
// @ts-ignore: decorator
@builtin export declare function extract_lane_s(x: v128, idx: u8): i16;
// @ts-ignore: decorator
@builtin export declare function extract_lane_u(x: v128, idx: u8): u16;
// @ts-ignore: decorator
@builtin export declare function replace_lane(x: v128, idx: u8, value: i16): v128;
// @ts-ignore: decorator
@builtin export declare function add(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function sub(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function mul(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function neg(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function add_saturate_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function add_saturate_u(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function sub_saturate_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function sub_saturate_u(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function shl(a: v128, b: i32): v128;
// @ts-ignore: decorator
@builtin export declare function shr_s(a: v128, b: i32): v128;
// @ts-ignore: decorator
@builtin export declare function shr_u(a: v128, b: i32): v128;
// @ts-ignore: decorator
@builtin export declare function any_true(a: v128): bool;
// @ts-ignore: decorator
@builtin export declare function all_true(a: v128): bool;
// @ts-ignore: decorator
@builtin export declare function eq(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function ne(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function lt_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function lt_u(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function le_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function le_u(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function gt_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function gt_u(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function ge_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function ge_u(a: v128, b: v128): v128;
}
// @ts-ignore: decorator
@builtin export declare function i32x4(a: i32, b: i32, c: i32, d: i32): v128;
export namespace i32x4 {
// @ts-ignore: decorator
@builtin export declare function splat(x: i32): v128;
// @ts-ignore: decorator
@builtin export declare function extract_lane(x: v128, idx: u8): i32;
// @ts-ignore: decorator
@builtin export declare function replace_lane(x: v128, idx: u8, value: i32): v128;
// @ts-ignore: decorator
@builtin export declare function add(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function sub(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function mul(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function neg(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function shl(a: v128, b: i32): v128;
// @ts-ignore: decorator
@builtin export declare function shr_s(a: v128, b: i32): v128;
// @ts-ignore: decorator
@builtin export declare function shr_u(a: v128, b: i32): v128;
// @ts-ignore: decorator
@builtin export declare function any_true(a: v128): bool;
// @ts-ignore: decorator
@builtin export declare function all_true(a: v128): bool;
// @ts-ignore: decorator
@builtin export declare function eq(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function ne(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function lt_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function lt_u(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function le_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function le_u(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function gt_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function gt_u(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function ge_s(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function ge_u(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function trunc_s_f32x4_sat(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function trunc_u_f32x4_sat(a: v128): v128;
}
// @ts-ignore: decorator
@builtin export declare function i64x2(a: i64, b: i64): v128;
export namespace i64x2 {
// @ts-ignore: decorator
@builtin export declare function splat(x: i64): v128;
// @ts-ignore: decorator
@builtin export declare function extract_lane(x: v128, idx: u8): i64;
// @ts-ignore: decorator
@builtin export declare function replace_lane(x: v128, idx: u8, value: i64): v128;
// @ts-ignore: decorator
@builtin export declare function add(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function sub(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function mul(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function neg(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function shl(a: v128, b: i32): v128;
// @ts-ignore: decorator
@builtin export declare function shr_s(a: v128, b: i32): v128;
// @ts-ignore: decorator
@builtin export declare function shr_u(a: v128, b: i32): v128;
// @ts-ignore: decorator
@builtin export declare function any_true(a: v128): bool;
// @ts-ignore: decorator
@builtin export declare function all_true(a: v128): bool;
// @ts-ignore: decorator
@builtin export declare function trunc_s_f64x2_sat(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function trunc_u_f64x2_sat(a: v128): v128;
}
// @ts-ignore: decorator
@builtin export declare function f32x4(a: f32, b: f32, c: f32, d: f32): v128;
export namespace f32x4 {
// @ts-ignore: decorator
@builtin export declare function splat(x: f32): v128;
// @ts-ignore: decorator
@builtin export declare function extract_lane(x: v128, idx: u8): f32;
// @ts-ignore: decorator
@builtin export declare function replace_lane(x: v128, idx: u8, value: f32): v128;
// @ts-ignore: decorator
@builtin export declare function add(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function sub(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function mul(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function div(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function neg(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function min(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function max(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function abs(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function sqrt(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function eq(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function ne(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function lt(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function le(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function gt(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function ge(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function convert_s_i32x4(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function convert_u_i32x4(a: v128): v128;
}
// @ts-ignore: decorator
@builtin export declare function f64x2(a: f64, b: f64): v128;
export namespace f64x2 {
// @ts-ignore: decorator
@builtin export declare function splat(x: f64): v128;
// @ts-ignore: decorator
@builtin export declare function extract_lane(x: v128, idx: u8): f64;
// @ts-ignore: decorator
@builtin export declare function replace_lane(x: v128, idx: u8, value: f64): v128;
// @ts-ignore: decorator
@builtin export declare function add(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function sub(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function mul(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function div(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function neg(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function min(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function max(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function abs(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function sqrt(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function eq(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function ne(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function lt(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function le(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function gt(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function ge(a: v128, b: v128): v128;
// @ts-ignore: decorator
@builtin export declare function convert_s_i64x2(a: v128): v128;
// @ts-ignore: decorator
@builtin export declare function convert_u_i64x2(a: v128): v128;
}
export namespace v8x16 {
// @ts-ignore: decorator
@builtin export declare function shuffle(a: v128, b: v128, l0: u8, l1: u8, l2: u8, l3: u8, l4: u8, l5: u8, l6: u8, l7: u8, l8: u8, l9: u8, l10: u8, l11: u8, l12: u8, l13: u8, l14: u8, l15: u8): v128;
}

11
std/assembly/collector/itcm.ts
View File

@ -1,8 +1,10 @@
// Largely based on Bach Le's μgc, see: https://github.com/bullno1/ugc
// @ts-ignore: decorator
@inline const TRACE = false;
/** Size of a managed object header. */
// @ts-ignore: decorator
@inline export const HEADER_SIZE: usize = (offsetof<ManagedObject>() + AL_MASK) & ~AL_MASK;
import { AL_MASK, MAX_SIZE_32 } from "../util/allocator";
@ -146,6 +148,7 @@ function step(): void {
if (obj !== toSpace) {
if (TRACE) trace("gc~step/MARK iterate", 1, objToRef(obj));
iter = obj;
// @ts-ignore: cast
obj.color = <i32>!white;
// if (TRACE) {
// trace(" next/prev/hook", 3,
@ -163,6 +166,7 @@ function step(): void {
let from = fromSpace;
fromSpace = toSpace;
toSpace = from;
// @ts-ignore: cast
white = <i32>!white;
iter = from.next;
state = State.SWEEP;
@ -188,14 +192,17 @@ function step(): void {
}
}
// @ts-ignore: decorator
@inline function refToObj(ref: usize): ManagedObject {
return changetype<ManagedObject>(ref - HEADER_SIZE);
}
// @ts-ignore: decorator
@inline function objToRef(obj: ManagedObject): usize {
return changetype<usize>(obj) + HEADER_SIZE;
}
// @ts-ignore: decorator
@global @unsafe export function __gc_allocate( // TODO: make this register only / reuse header
size: usize,
markFn: (ref: usize) => void
@ -210,12 +217,15 @@ function step(): void {
return objToRef(obj);
}
// @ts-ignore: decorator
@global @unsafe export function __gc_link(parentRef: usize, childRef: usize): void {
if (TRACE) trace("gc.link", 2, parentRef, childRef);
var parent = refToObj(parentRef);
// @ts-ignore: cast
if (parent.color == <i32>!white && refToObj(childRef).color == white) parent.makeGray();
}
// @ts-ignore: decorator
@global @unsafe export function __gc_mark(ref: usize): void {
if (TRACE) trace("gc.mark", 1, ref);
if (ref) {
@ -224,6 +234,7 @@ function step(): void {
}
}
// @ts-ignore: decorator
@global @unsafe export function __gc_collect(): void {
if (TRACE) trace("gc.collect");
// begin collecting if not yet collecting

5
std/assembly/diagnostics.ts
View File

@ -1,3 +1,8 @@
// @ts-ignore: decorator
@builtin export declare function ERROR(message?: string): void;
// @ts-ignore: decorator
@builtin export declare function WARNING(message?: string): void;
// @ts-ignore: decorator
@builtin export declare function INFO(message?: string): void;

5
std/assembly/gc.ts
View File

@ -2,6 +2,7 @@
export namespace gc {
/** Whether the garbage collector interface is implemented. */
// @ts-ignore: decorator, undefined
@lazy export const implemented: bool = isDefined(__gc_register);
/** Gets the computed unique class id of a class type. */
@ -12,24 +13,28 @@ export namespace gc {
/** Registers a managed object to be tracked by the garbage collector. */
@unsafe export function register(ref: usize): void {
// @ts-ignore: undefined
if (isDefined(__gc_register)) __gc_register(ref);
else ERROR("missing implementation: gc.register");
}
/** Links a registered object with the registered object now referencing it. */
@unsafe export function link(ref: usize, parentRef: usize): void {
// @ts-ignore: undefined
if (isDefined(__gc_link)) __gc_link(ref, parentRef);
else ERROR("missing implementation: gc.link");
}
/** Marks an object as being reachable. */
@unsafe export function mark(ref: usize): void {
// @ts-ignore: undefined
if (isDefined(__gc_mark)) __gc_mark(ref);
else ERROR("missing implementation: gc.mark");
}
/** Performs a full garbage collection cycle. */
export function collect(): void {
// @ts-ignore: undefined
if (isDefined(__gc_collect)) __gc_collect();
else WARNING("missing implementation: gc.collect");
}

9
std/assembly/map.ts
View File

@ -3,8 +3,13 @@ import { HASH } from "./util/hash";
// A deterministic hash map based on CloseTable from https://github.com/jorendorff/dht
// @ts-ignore: decorator
@inline const INITIAL_CAPACITY = 4;
// @ts-ignore: decorator
@inline const FILL_FACTOR: f64 = 8 / 3;
// @ts-ignore: decorator
@inline const FREE_FACTOR: f64 = 3 / 4;
/** Structure of a map entry. */
@ -15,12 +20,15 @@ import { HASH } from "./util/hash";
}
/** Empty bit. */
// @ts-ignore: decorator
@inline const EMPTY: usize = 1 << 0;
/** Size of a bucket. */
// @ts-ignore: decorator
@inline const BUCKET_SIZE = sizeof<usize>();
/** Computes the alignment of an entry. */
// @ts-ignore: decorator
@inline function ENTRY_ALIGN<K,V>(): usize {
// can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits
const maxkv = sizeof<K>() > sizeof<V>() ? sizeof<K>() : sizeof<V>();
@ -29,6 +37,7 @@ import { HASH } from "./util/hash";
}
/** Computes the aligned size of an entry. */
// @ts-ignore: decorator
@inline function ENTRY_SIZE<K,V>(): usize {
const align = ENTRY_ALIGN<K,V>();
const size = (offsetof<MapEntry<K,V>>() + align) & ~align;

200
std/assembly/math.ts
View File

@ -42,6 +42,7 @@ function R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3
return p / q;
}
// @ts-ignore: decorator
@inline function expo2(x: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX)
const // see: musl/src/math/__expo2.c
k = <u32>2043,
@ -50,11 +51,15 @@ function R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3
return NativeMath.exp(x - kln2) * scale * scale;
}
/** @internal */
// @ts-ignore: decorator
@lazy var random_seeded = false;
// @ts-ignore: decorator
@lazy var random_state0_64: u64;
// @ts-ignore: decorator
@lazy var random_state1_64: u64;
// @ts-ignore: decorator
@lazy var random_state0_32: u32;
// @ts-ignore: decorator
@lazy var random_state1_32: u32;
function murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche
@ -75,17 +80,25 @@ function splitMix32(h: u32): u32 {
export namespace NativeMath {
// @ts-ignore: decorator
@lazy export const E = reinterpret<f64>(0x4005BF0A8B145769); // 2.7182818284590452354
// @ts-ignore: decorator
@lazy export const LN2 = reinterpret<f64>(0x3FE62E42FEFA39EF); // 0.69314718055994530942
// @ts-ignore: decorator
@lazy export const LN10 = reinterpret<f64>(0x40026BB1BBB55516); // 2.30258509299404568402
// @ts-ignore: decorator
@lazy export const LOG2E = reinterpret<f64>(0x3FF71547652B82FE); // 1.4426950408889634074
// @ts-ignore: decorator
@lazy export const LOG10E = reinterpret<f64>(0x3FDBCB7B1526E50E); // 0.43429448190325182765
// @ts-ignore: decorator
@lazy export const PI = reinterpret<f64>(0x400921FB54442D18); // 3.14159265358979323846
// @ts-ignore: decorator
@lazy export const SQRT1_2 = reinterpret<f64>(0x3FE6A09E667F3BCD); // 0.70710678118654752440
// @ts-ignore: decorator
@lazy export const SQRT2 = reinterpret<f64>(0x3FF6A09E667F3BCD); // 1.41421356237309504880
@inline
export function abs(x: f64): f64 {
// @ts-ignore: decorator
@inline export function abs(x: f64): f64 {
return builtin_abs<f64>(x);
}
@ -346,8 +359,8 @@ export namespace NativeMath {
return t;
}
@inline
export function ceil(x: f64): f64 {
// @ts-ignore: decorator
@inline export function ceil(x: f64): f64 {
return builtin_ceil<f64>(x);
}
@ -497,13 +510,13 @@ export namespace NativeMath {
return (x + y) * twopk;
}
@inline
export function floor(x: f64): f64 {
// @ts-ignore: decorator
@inline export function floor(x: f64): f64 {
return builtin_floor<f64>(x);
}
@inline
export function fround(x: f64): f32 {
// @ts-ignore: decorator
@inline export function fround(x: f64): f32 {
return <f32>x;
}
@ -763,13 +776,13 @@ export namespace NativeMath {
return val_lo + val_hi;
}
@inline
export function max(value1: f64, value2: f64): f64 {
// @ts-ignore: decorator
@inline export function max(value1: f64, value2: f64): f64 {
return builtin_max<f64>(value1, value2);
}
@inline
export function min(value1: f64, value2: f64): f64 {
// @ts-ignore: decorator
@inline export function min(value1: f64, value2: f64): f64 {
return builtin_min<f64>(value1, value2);
}
@ -997,13 +1010,13 @@ export namespace NativeMath {
return reinterpret<f64>(r) - 1;
}
@inline
export function round(x: f64): f64 {
// @ts-ignore: decorator
@inline export function round(x: f64): f64 {
return builtin_copysign<f64>(builtin_floor<f64>(x + 0.5), x);
}
@inline
export function sign(x: f64): f64 {
// @ts-ignore: decorator
@inline export function sign(x: f64): f64 {
if (ASC_SHRINK_LEVEL > 0) {
return builtin_abs(x) > 0 ? builtin_copysign<f64>(1, x) : x;
} else {
@ -1011,10 +1024,11 @@ export namespace NativeMath {
}
}
@inline
export function signbit(x: f64): bool {
// @ts-ignore: decorator
@inline export function signbit(x: f64): bool {
// In ECMAScript all NaN values are indistinguishable from each other
// so we need handle NaN and negative NaN in similar way
// @ts-ignore: type
return <bool>(<i32>(reinterpret<u64>(x) >>> 63) & (x == x));
}
@ -1041,8 +1055,8 @@ export namespace NativeMath {
return t;
}
@inline
export function sqrt(x: f64): f64 {
// @ts-ignore: decorator
@inline export function sqrt(x: f64): f64 {
return builtin_sqrt<f64>(x);
}
@ -1074,8 +1088,8 @@ export namespace NativeMath {
return builtin_copysign<f64>(t, x);
}
@inline
export function trunc(x: f64): f64 {
// @ts-ignore: decorator
@inline export function trunc(x: f64): f64 {
return builtin_trunc<f64>(x);
}
@ -1232,8 +1246,9 @@ export namespace NativeMath {
}
}
/** @internal */
// @ts-ignore: decorator
@lazy var rempio2f_y: f64;
// @ts-ignore: decorator
@lazy const PIO2_TABLE: u64[] = [
0xA2F9836E4E441529,
0xFC2757D1F534DDC0,
@ -1241,7 +1256,6 @@ export namespace NativeMath {
0xFE5163ABDEBBC561
];
/** @internal */
function Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3
const // see: musl/src/math/asinf.c and SUN COPYRIGHT NOTICE above
pS0 = reinterpret<f32>(0x3E2AAA75), // 1.6666586697e-01f
@ -1253,6 +1267,7 @@ function Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3
return p / q;
}
// @ts-ignore: decorator
@inline function expo2f(x: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX)
const // see: musl/src/math/__expo2f.c
k = <u32>235,
@ -1261,8 +1276,8 @@ function Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3
return NativeMathf.exp(x - kln2) * scale * scale;
}
@inline /** @internal */
function pio2_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c
// @ts-ignore: decorator
@inline function pio2_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c
const coeff = reinterpret<f64>(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20
const bits = PIO2_TABLE;
@ -1291,8 +1306,8 @@ function pio2_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob
return q;
}
@inline /** @internal */
function rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c
// @ts-ignore: decorator
@inline function rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c
const pi2hi = reinterpret<f64>(0x3FF921FB50000000); // 1.57079631090164184570
const pi2lo = reinterpret<f64>(0x3E5110B4611A6263); // 1.58932547735281966916e-8
const _2_pi = reinterpret<f64>(0x3FE45F306DC9C883); // 0.63661977236758134308
@ -1308,8 +1323,8 @@ function rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob
}
/* |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]). */
@inline /** @internal */
function sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c
// @ts-ignore: decorator
@inline function sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c
const S1 = reinterpret<f64>(0xBFC5555554CBAC77); // -0x15555554cbac77.0p-55
const S2 = reinterpret<f64>(0x3F811110896EFBB2); // 0x111110896efbb2.0p-59
const S3 = reinterpret<f64>(0xBF2A00F9E2CAE774); // -0x1a00f9e2cae774.0p-65
@ -1323,8 +1338,8 @@ function sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c
}
/* |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]). */
@inline /** @internal */
function cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c
// @ts-ignore: decorator
@inline function cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c
const C0 = reinterpret<f64>(0xBFDFFFFFFD0C5E81); // -0x1ffffffd0c5e81.0p-54
const C1 = reinterpret<f64>(0x3FA55553E1053A42); // 0x155553e1053a42.0p-57
const C2 = reinterpret<f64>(0xBF56C087E80F1E27); // -0x16c087e80f1e27.0p-62
@ -1337,8 +1352,8 @@ function cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c
}
/* |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]). */
@inline /** @internal */
function tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c
// @ts-ignore: decorator
@inline function tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c
const T0 = reinterpret<f64>(0x3FD5554D3418C99F); /* 0x15554d3418c99f.0p-54 */
const T1 = reinterpret<f64>(0x3FC112FD38999F72); /* 0x1112fd38999f72.0p-55 */
@ -1360,21 +1375,31 @@ function tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c
export namespace NativeMathf {
// @ts-ignore: decorator
@lazy export const E = <f32>NativeMath.E;
// @ts-ignore: decorator
@lazy export const LN2 = <f32>NativeMath.LN2;
// @ts-ignore: decorator
@lazy export const LN10 = <f32>NativeMath.LN10;
// @ts-ignore: decorator
@lazy export const LOG2E = <f32>NativeMath.LOG2E;
// @ts-ignore: decorator
@lazy export const LOG10E = <f32>NativeMath.LOG10E;
// @ts-ignore: decorator
@lazy export const PI = <f32>NativeMath.PI;
// @ts-ignore: decorator
@lazy export const SQRT1_2 = <f32>NativeMath.SQRT1_2;
// @ts-ignore: decorator
@lazy export const SQRT2 = <f32>NativeMath.SQRT2;
/** Used as return values from Mathf.sincos */
// @ts-ignore: decorator
@lazy export var sincos_sin: f32 = 0;
// @ts-ignore: decorator
@lazy export var sincos_cos: f32 = 0;
@inline
export function abs(x: f32): f32 {
// @ts-ignore: decorator
@inline export function abs(x: f32): f32 {
return builtin_abs<f32>(x);
}
@ -1609,8 +1634,8 @@ export namespace NativeMathf {
return <f32>t;
}
@inline
export function ceil(x: f32): f32 {
// @ts-ignore: decorator
@inline export function ceil(x: f32): f32 {
return builtin_ceil<f32>(x);
}
@ -1685,8 +1710,8 @@ export namespace NativeMathf {
return expo2f(x);
}
@inline
export function floor(x: f32): f32 {
// @ts-ignore: decorator
@inline export function floor(x: f32): f32 {
return builtin_floor<f32>(x);
}
@ -1796,8 +1821,8 @@ export namespace NativeMathf {
return (x + y) * twopk;
}
@inline
export function fround(x: f32): f32 {
// @ts-ignore: decorator
@inline export function fround(x: f32): f32 {
return x;
}
@ -1831,8 +1856,8 @@ export namespace NativeMathf {
return z * builtin_sqrt<f32>(<f32>(<f64>x * x + <f64>y * y));
}
@inline
export function imul(x: f32, y: f32): f32 {
// @ts-ignore: decorator
@inline export function imul(x: f32, y: f32): f32 {
/*
* Wasm (MVP) and JS have different approaches for double->int conversions.
*
@ -2010,13 +2035,13 @@ export namespace NativeMathf {
return (lo + hi) * ivln2lo + lo * ivln2hi + hi * ivln2hi + dk;
}
@inline
export function max(value1: f32, value2: f32): f32 {
// @ts-ignore: decorator
@inline export function max(value1: f32, value2: f32): f32 {
return builtin_max<f32>(value1, value2);
}
@inline
export function min(value1: f32, value2: f32): f32 {
// @ts-ignore: decorator
@inline export function min(value1: f32, value2: f32): f32 {
return builtin_min<f32>(value1, value2);
}
@ -2209,8 +2234,8 @@ export namespace NativeMathf {
return sn * z;
}
@inline
export function seedRandom(value: i64): void {
// @ts-ignore: decorator
@inline export function seedRandom(value: i64): void {
NativeMath.seedRandom(value);
}
@ -2229,13 +2254,13 @@ export namespace NativeMathf {
return reinterpret<f32>((r >> 9) | (127 << 23)) - 1.0;
}
@inline
export function round(x: f32): f32 {
// @ts-ignore: decorator
@inline export function round(x: f32): f32 {
return builtin_copysign<f32>(builtin_floor<f32>(x + 0.5), x);
}
@inline
export function sign(x: f32): f32 {
// @ts-ignore: decorator
@inline export function sign(x: f32): f32 {
if (ASC_SHRINK_LEVEL > 0) {
return builtin_abs(x) > 0 ? builtin_copysign<f32>(1, x) : x;
} else {
@ -2243,8 +2268,9 @@ export namespace NativeMathf {
}
}
@inline
export function signbit(x: f32): bool {
// @ts-ignore: decorator
@inline export function signbit(x: f32): bool {
// @ts-ignore: type
return <bool>((reinterpret<u32>(x) >>> 31) & (x == x));
}
@ -2308,8 +2334,8 @@ export namespace NativeMathf {
return t;
}
@inline
export function sqrt(x: f32): f32 {
// @ts-ignore: decorator
@inline export function sqrt(x: f32): f32 {
return builtin_sqrt<f32>(x);
}
@ -2377,8 +2403,8 @@ export namespace NativeMathf {
return builtin_copysign<f32>(t, x);
}
@inline
export function trunc(x: f32): f32 {
// @ts-ignore: decorator
@inline export function trunc(x: f32): f32 {
return builtin_trunc<f32>(x);
}
@ -2541,12 +2567,12 @@ export namespace NativeMathf {
if (ix <= 0x3f490fda) { /* |x| ~<= π/4 */
if (ix < 0x39800000) { /* |x| < 2**-12 */
sincos_s32 = x;
sincos_c32 = 1;
sincos_sin = x;
sincos_cos = 1;
return;
}
sincos_s32 = sin_kernf(x);
sincos_c32 = cos_kernf(x);
sincos_sin = sin_kernf(x);
sincos_cos = cos_kernf(x);
return;
}
@ -2554,33 +2580,33 @@ export namespace NativeMathf {
if (ix <= 0x407b53d1) { /* |x| ~<= 5π/4 */
if (ix <= 0x4016cbe3) { /* |x| ~<= 3π/4 */
if (sign) {
sincos_s32 = -cos_kernf(x + s1pio2);
sincos_c32 = sin_kernf(x + s1pio2);
sincos_sin = -cos_kernf(x + s1pio2);
sincos_cos = sin_kernf(x + s1pio2);
} else {
sincos_s32 = cos_kernf(s1pio2 - x);
sincos_c32 = sin_kernf(s1pio2 - x);
sincos_sin = cos_kernf(s1pio2 - x);
sincos_cos = sin_kernf(s1pio2 - x);
}
return;
}
/* -sin(x + c) is not correct if x+c could be 0: -0 vs +0 */
sincos_s32 = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);
sincos_c32 = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);
sincos_sin = -sin_kernf(sign ? x + s2pio2 : x - s2pio2);
sincos_cos = -cos_kernf(sign ? x + s2pio2 : x - s2pio2);
return;
}
if (ix <= 0x40e231d5) { /* |x| ~<= 9π/4 */
if (ix <= 0x40afeddf) { /* |x| ~<= 7π/4 */
if (sign) {
sincos_s32 = cos_kernf(x + s3pio2);
sincos_c32 = -sin_kernf(x + s3pio2);
sincos_sin = cos_kernf(x + s3pio2);
sincos_cos = -sin_kernf(x + s3pio2);
} else {
sincos_s32 = -cos_kernf(x - s3pio2);
sincos_c32 = sin_kernf(x - s3pio2);
sincos_sin = -cos_kernf(x - s3pio2);
sincos_cos = sin_kernf(x - s3pio2);
}
return;
}
sincos_s32 = sin_kernf(sign ? x + s4pio2 : x - s4pio2);
sincos_c32 = cos_kernf(sign ? x + s4pio2 : x - s4pio2);
sincos_sin = sin_kernf(sign ? x + s4pio2 : x - s4pio2);
sincos_cos = cos_kernf(sign ? x + s4pio2 : x - s4pio2);
return;
}
}
@ -2588,8 +2614,8 @@ export namespace NativeMathf {
/* sin(Inf or NaN) is NaN */
if (ix >= 0x7f800000) {
let xx = x - x;
sincos_s32 = xx;
sincos_c32 = xx;
sincos_sin = xx;
sincos_cos = xx;
return;
}
@ -2601,24 +2627,24 @@ export namespace NativeMathf {
switch (n & 3) {
case 0: {
sincos_s32 = s;
sincos_c32 = c;
sincos_sin = s;
sincos_cos = c;
break;
}
case 1: {
sincos_s32 = c;
sincos_c32 = -s;
sincos_sin = c;
sincos_cos = -s;
break;
}
case 2: {
sincos_s32 = -s;
sincos_c32 = -c;
sincos_sin = -s;
sincos_cos = -c;
break;
}
case 3:
default: {
sincos_s32 = -c;
sincos_c32 = s;
sincos_sin = -c;
sincos_cos = s;
break;
}
}

15
std/assembly/memory.ts
View File

@ -1,56 +1,70 @@
import { memcmp, memmove, memset } from "./util/memory";
// @ts-ignore: decorator
@builtin export declare const HEAP_BASE: usize;
/** Memory manager interface. */
export namespace memory {
/** Gets the size of the memory in pages. */
// @ts-ignore: decorator
@builtin export declare function size(): i32;
/** Grows the memory by the given size in pages and returns the previous size in pages. */
// @ts-ignore: decorator
@unsafe @builtin export declare function grow(pages: i32): i32;
/** Fills a section in memory with the specified byte value. */
// @ts-ignore: decorator
@unsafe @builtin export function fill(dst: usize, c: u8, n: usize): void {
memset(dst, c, n); // fallback if "bulk-memory" isn't enabled
}
/** Copies a section of memory to another. Has move semantics. */
// @ts-ignore: decorator
@unsafe @builtin export function copy(dst: usize, src: usize, n: usize): void {
memmove(dst, src, n); // fallback if "bulk-memory" isn't enabled
}
/** Initializes a memory segment. */
// @ts-ignore: decorator
@unsafe export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {
ERROR("not implemented");
}
/** Drops a memory segment. */
// @ts-ignore: decorator
@unsafe export function drop(segmentIndex: u32): void {
ERROR("not implemented");
}
/** Dynamically allocates a section of memory and returns its address. */
// @ts-ignore: decorator
@unsafe export function allocate(size: usize): usize {
// @ts-ignore: undefined
if (isDefined(__memory_allocate)) return __memory_allocate(size);
else ERROR("missing implementation: memory.allocate");
return <usize>unreachable();
}
/** Dynamically frees a section of memory by the previously allocated address. */
// @ts-ignore: decorator
@unsafe export function free(ptr: usize): void {
// @ts-ignore: undefined
if (isDefined(__memory_free)) __memory_free(ptr);
else ERROR("missing implementation: memory.free");
}
/** Resets the memory to its initial state. Arena allocator only. */
// @ts-ignore: decorator
@unsafe export function reset(): void {
// @ts-ignore: undefined
if (isDefined(__memory_reset)) __memory_reset();
else ERROR("missing implementation: memory.reset");
}
/** Repeats a section of memory at a specific address. */
// @ts-ignore: decorator
@unsafe export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {
var index: usize = 0;
var total = srcLength * count;
@ -61,6 +75,7 @@ export namespace memory {
}
/** Compares a section of memory to another. */
// @ts-ignore: decorator
@inline export function compare(vl: usize, vr: usize, n: usize): i32 {
return memcmp(vl, vr, n);
}

38
std/assembly/number.ts
View File

@ -3,7 +3,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class I8 {
// @ts-ignore: decorator
@lazy static readonly MIN_VALUE: i8 = i8.MIN_VALUE;
// @ts-ignore: decorator
@lazy static readonly MAX_VALUE: i8 = i8.MAX_VALUE;
static parseInt(value: string, radix: i32 = 0): i8 {
@ -18,7 +20,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class I16 {
// @ts-ignore: decorator
@lazy static readonly MIN_VALUE: i16 = i16.MIN_VALUE;
// @ts-ignore: decorator
@lazy static readonly MAX_VALUE: i16 = i16.MAX_VALUE;
static parseInt(value: string, radix: i32 = 0): i16 {
@ -33,7 +37,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class I32 {
// @ts-ignore: decorator
@lazy static readonly MIN_VALUE: i32 = i32.MIN_VALUE;
// @ts-ignore: decorator
@lazy static readonly MAX_VALUE: i32 = i32.MAX_VALUE;
static parseInt(value: string, radix: i32 = 0): i32 {
@ -48,7 +54,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class I64 {
// @ts-ignore: decorator
@lazy static readonly MIN_VALUE: i64 = i64.MIN_VALUE;
// @ts-ignore: decorator
@lazy static readonly MAX_VALUE: i64 = i64.MAX_VALUE;
static parseInt(value: string, radix: i32 = 0): i64 {
@ -63,7 +71,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class Isize {
// @ts-ignore: decorator
@lazy static readonly MIN_VALUE: isize = isize.MIN_VALUE;
// @ts-ignore: decorator
@lazy static readonly MAX_VALUE: isize = isize.MAX_VALUE;
static parseInt(value: string, radix: i32 = 0): isize {
@ -78,7 +88,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class U8 {
// @ts-ignore: decorator
@lazy static readonly MIN_VALUE: u8 = u8.MIN_VALUE;
// @ts-ignore: decorator
@lazy static readonly MAX_VALUE: u8 = u8.MAX_VALUE;
static parseInt(value: string, radix: i32 = 0): u8 {
@ -93,7 +105,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class U16 {
// @ts-ignore: decorator
@lazy static readonly MIN_VALUE: u16 = u16.MIN_VALUE;
// @ts-ignore: decorator
@lazy static readonly MAX_VALUE: u16 = u16.MAX_VALUE;
static parseInt(value: string, radix: i32 = 0): u16 {
@ -108,7 +122,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class U32 {
// @ts-ignore: decorator
@lazy static readonly MIN_VALUE: u32 = u32.MIN_VALUE;
// @ts-ignore: decorator
@lazy static readonly MAX_VALUE: u32 = u32.MAX_VALUE;
static parseInt(value: string, radix: i32 = 0): u32 {
@ -123,7 +139,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class U64 {
// @ts-ignore: decorator
@lazy static readonly MIN_VALUE: u64 = u64.MIN_VALUE;
// @ts-ignore: decorator
@lazy static readonly MAX_VALUE: u64 = u64.MAX_VALUE;
static parseInt(value: string, radix: i32 = 0): u64 {
@ -138,7 +156,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class Usize {
// @ts-ignore: decorator
@lazy static readonly MIN_VALUE: usize = usize.MIN_VALUE;
// @ts-ignore: decorator
@lazy static readonly MAX_VALUE: usize = usize.MAX_VALUE;
static parseInt(value: string, radix: i32 = 0): usize {
@ -153,7 +173,9 @@ import { isNaN as builtin_isNaN, isFinite as builtin_isFinite } from "./builtins
@sealed export abstract class Bool {
// @ts-ignore: decorator
@lazy static readonly MIN_VALUE: bool = bool.MIN_VALUE;
// @ts-ignore: decorator
@lazy static readonly MAX_VALUE: bool = bool.MAX_VALUE;
toString(this: bool): String {
@ -166,13 +188,21 @@ export { Bool as Boolean };
@sealed export abstract class F32 {
// @ts-ignore: decorator
@lazy static readonly EPSILON: f32 = f32.EPSILON;
// @ts-ignore: decorator
@lazy static readonly MIN_VALUE: f32 = f32.MIN_VALUE;
// @ts-ignore: decorator
@lazy static readonly MAX_VALUE: f32 = f32.MAX_VALUE;
// @ts-ignore: decorator
@lazy static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;
// @ts-ignore: decorator
@lazy static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;
// @ts-ignore: decorator
@lazy static readonly POSITIVE_INFINITY: f32 = Infinity;
// @ts-ignore: decorator
@lazy static readonly NEGATIVE_INFINITY: f32 = -Infinity;
// @ts-ignore: decorator
@lazy static readonly NaN: f32 = NaN;
static isNaN(value: f32): bool {
@ -207,13 +237,21 @@ export { Bool as Boolean };
@sealed export abstract class F64 {
// @ts-ignore: decorator
@lazy static readonly EPSILON: f64 = f64.EPSILON;
// @ts-ignore: decorator
@lazy static readonly MIN_VALUE: f64 = f64.MIN_VALUE;
// @ts-ignore: decorator
@lazy static readonly MAX_VALUE: f64 = f64.MAX_VALUE;
// @ts-ignore: decorator
@lazy static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;
// @ts-ignore: decorator
@lazy static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;
// @ts-ignore: decorator
@lazy static readonly POSITIVE_INFINITY: f64 = Infinity;
// @ts-ignore: decorator
@lazy static readonly NEGATIVE_INFINITY: f64 = -Infinity;
// @ts-ignore: decorator
@lazy static readonly NaN: f64 = NaN;
static isNaN(value: f64): bool {

2
std/assembly/polyfills.ts
View File

@ -25,7 +25,7 @@ export function bswap<T extends number>(value: T): T {
return value;
}
@inline export function bswap16<T extends number>(value: T): T {
export function bswap16<T extends number>(value: T): T {
if (isInteger<T>() && sizeof<T>() <= 4) {
if (sizeof<T>() == 2) {
return <T>((value << 8) | ((value >> 8) & <T>0x00FF));

11
std/assembly/runtime.ts
View File

@ -9,11 +9,13 @@ export namespace runtime {
@unmanaged export class Header {
/** Size of a runtime header. */
// @ts-ignore: decorator
@lazy @inline static readonly SIZE: usize = gc.implemented
? (offsetof<Header>( ) + AL_MASK) & ~AL_MASK // full header if GC is present
: (offsetof<Header>("gc1") + AL_MASK) & ~AL_MASK; // half header if GC is absent
/** Magic value used to validate runtime headers. */
// @ts-ignore: decorator
@lazy @inline static readonly MAGIC: u32 = 0xA55E4B17;
/** Unique id of the respective class or a magic value if not yet registered.*/
@ -42,6 +44,7 @@ export namespace runtime {
}
/** Allocates a new object and returns a pointer to its payload. Does not fill. */
// @ts-ignore: decorator
@unsafe export function allocRaw(payloadSize: u32): usize {
var header = changetype<Header>(memory.allocate(adjust(payloadSize)));
header.classId = Header.MAGIC;
@ -54,6 +57,7 @@ export namespace runtime {
}
/** Allocates a new object and returns a pointer to its payload. Fills with zeroes.*/
// @ts-ignore: decorator
@unsafe export function alloc(payloadSize: u32): usize {
var ref = allocRaw(payloadSize);
memory.fill(ref, 0, payloadSize);
@ -61,6 +65,7 @@ export namespace runtime {
}
/** Reallocates an object if necessary. Returns a pointer to its (moved) payload. */
// @ts-ignore: decorator
@unsafe export function realloc(ref: usize, newPayloadSize: u32): usize {
// Background: When managed objects are allocated these aren't immediately registered with GC
// but can be used as scratch objects while unregistered. This is useful in situations where
@ -111,11 +116,13 @@ export namespace runtime {
}
/** Frees an object. Must not have been registered with GC yet. */
// @ts-ignore: decorator
@unsafe @inline export function free<T>(ref: T): void {
memory.free(changetype<usize>(unref(changetype<usize>(ref))));
}
/** Registers a managed object. Cannot be free'd anymore afterwards. */
// @ts-ignore: decorator
@unsafe @inline export function register<T>(ref: usize): T {
if (!isReference<T>()) ERROR("reference expected");
// see comment in REALLOC why this is useful. also inline this because
@ -126,6 +133,7 @@ export namespace runtime {
}
/** Links a managed object with its managed parent. */
// @ts-ignore: decorator
@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);
@ -141,8 +149,11 @@ export abstract class ArrayBufferView {
[key: number]: number;
// @ts-ignore: decorator
@unsafe data: ArrayBuffer;
// @ts-ignore: decorator
@unsafe dataStart: usize;
// @ts-ignore: decorator
@unsafe dataEnd: usize;
constructor(length: i32, alignLog2: i32) {

7
std/assembly/set.ts
View File

@ -3,8 +3,11 @@ import { HASH } from "./util/hash";
// A deterministic hash set based on CloseTable from https://github.com/jorendorff/dht
// @ts-ignore: decorator
@inline const INITIAL_CAPACITY = 4;
// @ts-ignore: decorator
@inline const FILL_FACTOR: f64 = 8 / 3;
// @ts-ignore: decorator
@inline const FREE_FACTOR: f64 = 3 / 4;
/** Structure of a set entry. */
@ -14,12 +17,15 @@ import { HASH } from "./util/hash";
}
/** Empty bit. */
// @ts-ignore: decorator
@inline const EMPTY: usize = 1 << 0;
/** Size of a bucket. */
// @ts-ignore: decorator
@inline const BUCKET_SIZE = sizeof<usize>();
/** Computes the alignment of an entry. */
// @ts-ignore: decorator
@inline function ENTRY_ALIGN<K>(): usize {
// can align to 4 instead of 8 if 32-bit and K is <= 32-bits
const align = (sizeof<K>() > sizeof<usize>() ? sizeof<K>() : sizeof<usize>()) - 1;
@ -27,6 +33,7 @@ import { HASH } from "./util/hash";
}
/** Computes the aligned size of an entry. */
// @ts-ignore: decorator
@inline function ENTRY_SIZE<K>(): usize {
const align = ENTRY_ALIGN<K>();
const size = (offsetof<SetEntry<K>>() + align) & ~align;

13
std/assembly/string.ts
View File

@ -3,6 +3,7 @@ import { MAX_SIZE_32 } from "./util/allocator";
import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./util/string";
@sealed export abstract class String {
// @ts-ignore: decorator
@lazy static readonly MAX_LENGTH: i32 = (MAX_SIZE_32 - runtime.Header.SIZE) >> alignof<u16>();
get length(): i32 {
@ -19,6 +20,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
static fromCodePoint(code: i32): String {
assert(<u32>code <= 0x10FFFF);
var sur = code > 0xFFFF;
// @ts-ignore: type
var out = runtime.allocRaw((<i32>sur + 1) << 1);
if (!sur) {
store<u16>(out, <u16>code);
@ -80,6 +82,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
var searchLength: isize = searchString.length;
var start: isize = end - searchLength;
if (start < 0) return false;
// @ts-ignore: string/String
return !compareImpl(this, start, searchString, 0, searchLength);
}
@ -88,6 +91,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
if (left === null || right === null) return false;
var leftLength = left.length;
if (leftLength != right.length) return false;
// @ts-ignore: string/String
return !compareImpl(left, 0, right, 0, leftLength);
}
@ -101,6 +105,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
var rightLength = right.length;
if (!leftLength) return false;
if (!rightLength) return true;
// @ts-ignore: string/String
return compareImpl(left, 0, right, 0, min(leftLength, rightLength)) > 0;
}
@ -114,6 +119,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
var rightLength = right.length;
if (!rightLength) return false;
if (!leftLength) return true;
// @ts-ignore: string/String
return compareImpl(left, 0, right, 0, min(leftLength, rightLength)) < 0;
}
@ -135,6 +141,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
var start = min<isize>(max<isize>(fromIndex, 0), len);
len -= searchLen;
for (let k: isize = start; k <= len; ++k) {
// @ts-ignore: string/String
if (!compareImpl(this, k, searchString, 0, searchLen)) return <i32>k;
}
return -1;
@ -149,6 +156,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
if (!len) return -1;
var start = min<isize>(max(fromIndex, 0), len - searchLen);
for (let k = start; k >= 0; --k) {
// @ts-ignore: string/String
if (!compareImpl(this, k, searchString, 0, searchLen)) return <i32>k;
}
return -1;
@ -162,6 +170,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
var start = min(max(pos, 0), len);
var searchLength: isize = searchString.length;
if (searchLength + start > len) return false;
// @ts-ignore: string/String
return !compareImpl(this, start, searchString, 0, searchLength);
}
@ -510,17 +519,21 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut
}
}
// @ts-ignore: nolib
export type string = String;
export function parseInt(str: String, radix: i32 = 0): f64 {
// @ts-ignore: string/String
return parse<f64>(str, radix);
}
export function parseI32(str: String, radix: i32 = 0): i32 {
// @ts-ignore: string/String
return parse<i32>(str, radix);
}
export function parseI64(str: String, radix: i32 = 0): i64 {
// @ts-ignore: string/String
return parse<i64>(str, radix);
}

2
std/assembly/symbol.ts
View File

@ -4,6 +4,7 @@ import { Map } from "./map";
@lazy var idToString: Map<usize, string>;
@lazy var nextId: usize = 12; // Symbol.unscopables + 1
// @ts-ignore: nolib
@unmanaged export class symbol {
toString(): string {
var id = changetype<usize>(this);
@ -52,6 +53,7 @@ export namespace Symbol {
@lazy export const unscopables = changetype<symbol>(11);
/* tslint:disable */// not valid TS
// @ts-ignore: identifier
export function for(key: string): symbol {
if (!stringToId) { stringToId = new Map(); idToString = new Map(); }
else if (stringToId.has(key)) return changetype<symbol>(stringToId.get(key));

21
std/assembly/typedarray.ts
View File

@ -6,6 +6,7 @@ function clampToByte(value: i32): i32 {
}
export class Int8Array extends ArrayBufferView {
// @ts-ignore: decorator
@lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<i8>();
constructor(length: i32) {
@ -68,6 +69,7 @@ export class Int8Array extends ArrayBufferView {
}
export class Uint8Array extends ArrayBufferView {
// @ts-ignore: decorator
@lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<u8>();
constructor(length: i32) {
@ -124,6 +126,7 @@ export class Uint8Array extends ArrayBufferView {
}
export class Uint8ClampedArray extends Uint8Array {
// @ts-ignore: decorator
@lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<u8>();
fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray {
@ -174,6 +177,7 @@ export class Uint8ClampedArray extends Uint8Array {
}
export class Int16Array extends ArrayBufferView {
// @ts-ignore: decorator
@lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<i16>();
constructor(length: i32) {
@ -236,6 +240,7 @@ export class Int16Array extends ArrayBufferView {
}
export class Uint16Array extends ArrayBufferView {
// @ts-ignore: decorator
@lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<u16>();
constructor(length: i32) {
@ -298,6 +303,7 @@ export class Uint16Array extends ArrayBufferView {
}
export class Int32Array extends ArrayBufferView {
// @ts-ignore: decorator
@lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<i32>();
constructor(length: i32) {
@ -360,6 +366,7 @@ export class Int32Array extends ArrayBufferView {
}
export class Uint32Array extends ArrayBufferView {
// @ts-ignore: decorator
@lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<u32>();
constructor(length: i32) {
@ -422,6 +429,7 @@ export class Uint32Array extends ArrayBufferView {
}
export class Int64Array extends ArrayBufferView {
// @ts-ignore: decorator
@lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<i64>();
constructor(length: i32) {
@ -484,6 +492,7 @@ export class Int64Array extends ArrayBufferView {
}
export class Uint64Array extends ArrayBufferView {
// @ts-ignore: decorator
@lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<u64>();
constructor(length: i32) {
@ -546,6 +555,7 @@ export class Uint64Array extends ArrayBufferView {
}
export class Float32Array extends ArrayBufferView {
// @ts-ignore: decorator
@lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<f32>();
constructor(length: i32) {
@ -608,6 +618,7 @@ export class Float32Array extends ArrayBufferView {
}
export class Float64Array extends ArrayBufferView {
// @ts-ignore: decorator
@lazy static readonly BYTES_PER_ELEMENT: usize = sizeof<f64>();
constructor(length: i32) {
@ -669,6 +680,7 @@ export class Float64Array extends ArrayBufferView {
}
}
// @ts-ignore: decorator
@inline function FILL<TArray extends ArrayBufferView, T extends number>(
array: TArray,
value: native<T>,
@ -689,6 +701,7 @@ export class Float64Array extends ArrayBufferView {
return array;
}
// @ts-ignore: decorator
@inline function SORT<TArray extends ArrayBufferView, T>(
array: TArray,
comparator: (a: T, b: T) => i32
@ -709,6 +722,7 @@ export class Float64Array extends ArrayBufferView {
return array;
}
// @ts-ignore: decorator
@inline function SUBARRAY<TArray extends ArrayBufferView, T>(
array: TArray,
begin: i32,
@ -728,6 +742,7 @@ export class Float64Array extends ArrayBufferView {
return changetype<TArray>(out);
}
// @ts-ignore: decorator
@inline function REDUCE<TArray extends ArrayBufferView, T, TRet>(
array: TArray,
callbackfn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,
@ -740,6 +755,7 @@ export class Float64Array extends ArrayBufferView {
return initialValue;
}
// @ts-ignore: decorator
@inline function REDUCE_RIGHT<TArray extends ArrayBufferView, T, TRet>(
array: TArray,
callbackfn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet,
@ -752,6 +768,7 @@ export class Float64Array extends ArrayBufferView {
return initialValue;
}
// @ts-ignore: decorator
@inline function MAP<TArray extends ArrayBufferView, T>(
array: TArray,
callbackfn: (value: T, index: i32, self: TArray) => T,
@ -769,6 +786,7 @@ export class Float64Array extends ArrayBufferView {
return out;
}
// @ts-ignore: decorator
@inline function FIND_INDEX<TArray extends ArrayBufferView, T>(
array: TArray,
callbackfn: (value: T, index: i32, array: TArray) => bool,
@ -780,6 +798,7 @@ export class Float64Array extends ArrayBufferView {
return -1;
}
// @ts-ignore: decorator
@inline function SOME<TArray extends ArrayBufferView, T>(
array: TArray,
callbackfn: (value: T, index: i32, array: TArray) => bool,
@ -791,6 +810,7 @@ export class Float64Array extends ArrayBufferView {
return false;
}
// @ts-ignore: decorator
@inline function EVERY<TArray extends ArrayBufferView, T>(
array: TArray,
callbackfn: (value: T, index: i32, array: TArray) => bool,
@ -803,6 +823,7 @@ export class Float64Array extends ArrayBufferView {
return true;
}
// @ts-ignore: decorator
@inline function FOREACH<TArray extends ArrayBufferView, T>(
array: TArray,
callbackfn: (value: T, index: i32, array: TArray) => void,

7
std/assembly/util/allocator.ts
View File

@ -1,8 +1,15 @@
/** Number of alignment bits. */
// @ts-ignore: decorator
@inline export const AL_BITS: u32 = 3;
/** Number of possible alignment values. */
// @ts-ignore: decorator
@inline export const AL_SIZE: usize = 1 << <usize>AL_BITS;
/** Mask to obtain just the alignment bits. */
// @ts-ignore: decorator
@inline export const AL_MASK: usize = AL_SIZE - 1;
/** Maximum 32-bit allocation size. */
// @ts-ignore: decorator
@inline export const MAX_SIZE_32: usize = 1 << 30; // 1GB

10
std/assembly/util/hash.ts
View File

@ -1,16 +1,24 @@
// @ts-ignore: decorator
@inline export function HASH<T>(key: T): u32 {
if (isString(key)) {
// @ts-ignore: type
return hashStr(key);
} else if (isReference<T>()) {
if (sizeof<T>() == 4) return hash32(changetype<u32>(key));
if (sizeof<T>() == 8) return hash64(changetype<u64>(key));
} else if (isFloat<T>()) {
// @ts-ignore: type
if (sizeof<T>() == 4) return hash32(reinterpret<u32>(key));
// @ts-ignore: type
if (sizeof<T>() == 8) return hash64(reinterpret<u64>(key));
} else {
// @ts-ignore: type
if (sizeof<T>() == 1) return hash8 (<u32>key);
// @ts-ignore: type
if (sizeof<T>() == 2) return hash16(<u32>key);
// @ts-ignore: type
if (sizeof<T>() == 4) return hash32(<u32>key);
// @ts-ignore: type
if (sizeof<T>() == 8) return hash64(<u64>key);
}
unreachable();
@ -18,7 +26,9 @@
// FNV-1a 32-bit as a starting point, see: http://isthe.com/chongo/tech/comp/fnv/
// @ts-ignore: decorator
@inline const FNV_OFFSET: u32 = 2166136261;
// @ts-ignore: decorator
@inline const FNV_PRIME: u32 = 16777619;
function hash8(key: u32): u32 {

5
std/assembly/util/number.ts
View File

@ -1,8 +1,10 @@
import { runtime } from "../runtime";
import { CharCode } from "./string";
// @ts-ignore: decorator
@inline export const MAX_DOUBLE_LENGTH = 28;
// @ts-ignore: decorator
@lazy @inline const POWERS10: u32[] = [
1,
10,
@ -30,6 +32,7 @@ import { CharCode } from "./string";
"80", "81", "82", "83", "84", "85", "86", "87", "88", "89",
"90", "91", "92", "93", "94", "95", "96", "97", "98", "99"
*/
// @ts-ignore: decorator
@lazy @inline const DIGITS: u32[] = [
0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030,
0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030,
@ -53,6 +56,7 @@ import { CharCode } from "./string";
0x00350039, 0x00360039, 0x00370039, 0x00380039, 0x00390039
];
// @ts-ignore: decorator
@lazy @inline const EXP_POWERS: i16[] = [
-1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,
-954, -927, -901, -874, -847, -821, -794, -768, -741, -715,
@ -66,6 +70,7 @@ import { CharCode } from "./string";
];
// 1e-348, 1e-340, ..., 1e340
// @ts-ignore: decorator
@lazy @inline const FRC_POWERS: u64[] = [
0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA,
0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F,

14
std/assembly/util/sort.ts
View File

@ -1,45 +1,59 @@
import { compareImpl } from "./string";
// @ts-ignore: decorator
@inline export function COMPARATOR<T>(): (a: T, b: T) => i32 {
if (isInteger<T>()) {
if (isSigned<T>() && sizeof<T>() <= 4) {
// @ts-ignore: type
return (a: T, b: T): i32 => (<i32>(a - b));
} else {
// @ts-ignore: type
return (a: T, b: T): i32 => (<i32>(a > b) - <i32>(a < b));
}
} else if (isFloat<T>()) {
if (sizeof<T>() == 4) {
return (a: T, b: T): i32 => {
// @ts-ignore: type
var ia = reinterpret<i32>(a);
// @ts-ignore: type
var ib = reinterpret<i32>(b);
ia ^= (ia >> 31) >>> 1;
ib ^= (ib >> 31) >>> 1;
// @ts-ignore: type
return <i32>(ia > ib) - <i32>(ia < ib);
};
} else {
return (a: T, b: T): i32 => {
// @ts-ignore: type
var ia = reinterpret<i64>(a);
// @ts-ignore: type
var ib = reinterpret<i64>(b);
ia ^= (ia >> 63) >>> 1;
ib ^= (ib >> 63) >>> 1;
// @ts-ignore: type
return <i32>(ia > ib) - <i32>(ia < ib);
};
}
} else if (isString<T>()) {
return (a: T, b: T): i32 => {
if (a === b || a === null || b === null) return 0;
// @ts-ignore: type
var alen = (<string>a).length;
// @ts-ignore: type
var blen = (<string>b).length;
if (!alen && !blen) return 0;
if (!alen) return -1;
if (!blen) return 1;
// @ts-ignore: type
return compareImpl(<string>a, 0, <string>b, 0, <usize>min(alen, blen));
};
} else {
// @ts-ignore: type
return (a: T, b: T): i32 => (<i32>(a > b) - <i32>(a < b));
}
}
// @ts-ignore: decorator
@inline export function SORT<T>(
dataStart: usize,
length: i32,

21
std/assembly/util/string.ts
View File

@ -8,6 +8,7 @@ export function compareImpl(str1: string, index1: usize, str2: string, index2: u
return result;
}
// @ts-ignore: decorator
@inline export const enum CharCode {
PLUS = 0x2B,
MINUS = 0x2D,
@ -57,29 +58,35 @@ export function isWhiteSpaceOrLineTerminator(c: u16): bool {
/** Parses a string to an integer (usually), using the specified radix. */
export function parse<T>(str: string, radix: i32 = 0): T {
var len: i32 = str.length;
// @ts-ignore: type
if (!len) return <T>NaN;
var ptr = changetype<usize>(str) /* + HEAD -> offset */;
var code = <i32>load<u16>(ptr, HEADER_SIZE);
var code = <i32>load<u16>(ptr);
// determine sign
var sign: T;
if (code == CharCode.MINUS) {
// @ts-ignore: type
if (!--len) return <T>NaN;
code = <i32>load<u16>(ptr += 2, HEADER_SIZE);
code = <i32>load<u16>(ptr += 2);
// @ts-ignore: type
sign = -1;
} else if (code == CharCode.PLUS) {
// @ts-ignore: type
if (!--len) return <T>NaN;
code = <i32>load<u16>(ptr += 2, HEADER_SIZE);
code = <i32>load<u16>(ptr += 2);
// @ts-ignore: type
sign = 1;
} else {
// @ts-ignore: type
sign = 1;
}
// determine radix
if (!radix) {
if (code == CharCode._0 && len > 2) {
switch (<i32>load<u16>(ptr + 2, HEADER_SIZE)) {
switch (<i32>load<u16>(ptr + 2)) {
case CharCode.B:
case CharCode.b: {
ptr += 4; len -= 2;
@ -102,13 +109,15 @@ export function parse<T>(str: string, radix: i32 = 0): T {
}
} else radix = 10;
} else if (radix < 2 || radix > 36) {
// @ts-ignore: cast
return <T>NaN;
}
// calculate value
// @ts-ignore: type
var num: T = 0;
while (len--) {
code = <i32>load<u16>(ptr, HEADER_SIZE);
code = <i32>load<u16>(ptr);
if (code >= CharCode._0 && code <= CharCode._9) {
code -= CharCode._0;
} else if (code >= CharCode.A && code <= CharCode.Z) {
@ -117,8 +126,10 @@ export function parse<T>(str: string, radix: i32 = 0): T {
code -= CharCode.a - 10;
} else break;
if (code >= radix) break;
// @ts-ignore: type
num = (num * radix) + code;
ptr += 2;
}
// @ts-ignore: type
return sign * num;
}