From 84ddd977617a75f990e715becee8ed7a295da1a6 Mon Sep 17 00:00:00 2001 From: dcode Date: Thu, 14 Mar 2019 06:09:49 +0100 Subject: [PATCH] if that's what's necessary --- src/builtins.ts | 9 + std/assembly/allocator/arena.ts | 15 +- std/assembly/allocator/emscripten.ts | 12 +- std/assembly/allocator/system.ts | 12 +- std/assembly/allocator/tlsf.ts | 8 +- std/assembly/array.ts | 45 +- std/assembly/builtins.ts | 1716 +++++++++++++++++++------- std/assembly/collector/itcm.ts | 33 +- std/assembly/diagnostics.ts | 9 +- std/assembly/gc.ts | 36 +- std/assembly/index.d.ts | 24 +- std/assembly/map.ts | 21 +- std/assembly/math.ts | 209 +++- std/assembly/memory.ts | 42 +- std/assembly/number.ts | 139 ++- std/assembly/runtime.ts | 40 +- std/assembly/set.ts | 23 +- std/assembly/string.ts | 27 +- std/assembly/symbol.ts | 5 +- std/assembly/typedarray.ts | 74 +- std/assembly/util/allocator.ts | 12 +- std/assembly/util/hash.ts | 33 +- std/assembly/util/number.ts | 19 +- std/assembly/util/sort.ts | 42 +- std/assembly/util/string.ts | 9 +- 25 files changed, 1845 insertions(+), 769 deletions(-) diff --git a/src/builtins.ts b/src/builtins.ts index 369fd4aa..5c5880dd 100644 --- a/src/builtins.ts +++ b/src/builtins.ts @@ -91,6 +91,7 @@ export namespace BuiltinSymbols { // std/builtins.ts export const isInteger = "~lib/builtins/isInteger"; export const isFloat = "~lib/builtins/isFloat"; + export const isBoolean = "~lib/builtins/isBoolean"; export const isSigned = "~lib/builtins/isSigned"; export const isReference = "~lib/builtins/isReference"; export const isString = "~lib/builtins/isString"; @@ -542,6 +543,14 @@ export function compileCall( ? module.createI32(1) : module.createI32(0); } + case BuiltinSymbols.isBoolean: { // isBoolean() / isBoolean(value: T) -> bool + let type = evaluateConstantType(compiler, typeArguments, operands, reportNode); + compiler.currentType = Type.bool; + if (!type) return module.createUnreachable(); + return type == Type.bool + ? module.createI32(1) + : module.createI32(0); + } case BuiltinSymbols.isSigned: { // isSigned() / isSigned(value: T) -> bool let type = evaluateConstantType(compiler, typeArguments, operands, reportNode); compiler.currentType = Type.bool; diff --git a/std/assembly/allocator/arena.ts b/std/assembly/allocator/arena.ts index 55fd770e..eb867ca1 100644 --- a/std/assembly/allocator/arena.ts +++ b/std/assembly/allocator/arena.ts @@ -2,13 +2,16 @@ 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; +@lazy +var startOffset: usize = (HEAP_BASE + AL_MASK) & ~AL_MASK; // @ts-ignore: decorator -@lazy var offset: usize = startOffset; +@lazy +var offset: usize = startOffset; // @ts-ignore: decorator -@unsafe @global function __memory_allocate(size: usize): usize { +@unsafe @global +function __memory_allocate(size: usize): usize { if (size > MAX_SIZE_32) unreachable(); var ptr = offset; var newPtr = (ptr + max(size, 1) + AL_MASK) & ~AL_MASK; @@ -27,10 +30,12 @@ import { AL_MASK, MAX_SIZE_32 } from "../util/allocator"; } // @ts-ignore: decorator -@unsafe @global function __memory_free(ptr: usize): void { +@unsafe @global +function __memory_free(ptr: usize): void { } // @ts-ignore: decorator -@unsafe @global function __memory_reset(): void { +@unsafe @global +function __memory_reset(): void { offset = startOffset; } diff --git a/std/assembly/allocator/emscripten.ts b/std/assembly/allocator/emscripten.ts index 9fc3cc7e..81c3700f 100644 --- a/std/assembly/allocator/emscripten.ts +++ b/std/assembly/allocator/emscripten.ts @@ -1,15 +1,19 @@ // @ts-ignore: decorator -@unsafe declare function _malloc(size: usize): usize; +@unsafe +declare function _malloc(size: usize): usize; // @ts-ignore: decorator -@unsafe declare function _free(ptr: usize): void; +@unsafe +declare function _free(ptr: usize): void; // @ts-ignore: decorator -@unsafe @global function __memory_allocate(size: usize): usize { +@unsafe @global +function __memory_allocate(size: usize): usize { return _malloc(size); } // @ts-ignore: decorator -@unsafe @global function __memory_free(ptr: usize): void { +@unsafe @global +function __memory_free(ptr: usize): void { _free(ptr); } diff --git a/std/assembly/allocator/system.ts b/std/assembly/allocator/system.ts index 70d3ba12..9ec0dc4a 100644 --- a/std/assembly/allocator/system.ts +++ b/std/assembly/allocator/system.ts @@ -1,15 +1,19 @@ // @ts-ignore: decorator -@unsafe declare function malloc(size: usize): usize; +@unsafe +declare function malloc(size: usize): usize; // @ts-ignore: decorator -@unsafe declare function free(ptr: usize): void; +@unsafe +declare function free(ptr: usize): void; // @ts-ignore: decorator -@unsafe @global function __memory_allocate(size: usize): usize { +@unsafe @global +function __memory_allocate(size: usize): usize { return malloc(size); } // @ts-ignore: decorator -@unsafe @global function __memory_free(ptr: usize): void { +@unsafe @global +function __memory_free(ptr: usize): void { free(ptr); } diff --git a/std/assembly/allocator/tlsf.ts b/std/assembly/allocator/tlsf.ts index 1146fa6b..c3c59ca1 100644 --- a/std/assembly/allocator/tlsf.ts +++ b/std/assembly/allocator/tlsf.ts @@ -423,7 +423,8 @@ var ROOT: Root = changetype(0); /** Allocates a chunk of memory. */ // @ts-ignore: decorator -@unsafe @global function __memory_allocate(size: usize): usize { +@unsafe @global +function __memory_allocate(size: usize): usize { // initialize if necessary var root = ROOT; if (!root) { @@ -471,8 +472,9 @@ var ROOT: Root = changetype(0); } /** Frees the chunk of memory at the specified address. */ -// @ts-ignore -@unsafe @global function __memory_free(data: usize): void { +// @ts-ignore: decorator +@unsafe @global +function __memory_free(data: usize): void { if (data) { let root = ROOT; if (root) { diff --git a/std/assembly/array.ts b/std/assembly/array.ts index 635465de..65911732 100644 --- a/std/assembly/array.ts +++ b/std/assembly/array.ts @@ -95,8 +95,7 @@ export class Array extends ArrayBufferView { if (start < end) { memory.fill( dataStart + start, - // @ts-ignore: cast - value, + u8(value), (end - start) ); } @@ -269,8 +268,10 @@ export class Array extends ArrayBufferView { base + sizeof(), lastIndex << alignof() ); - // @ts-ignore: cast - store(base + (lastIndex << alignof()), null); + store(base + (lastIndex << alignof()), + // @ts-ignore: cast + null + ); this.length_ = lastIndex; return element; } @@ -376,11 +377,8 @@ export class Array extends ArrayBufferView { } join(separator: string = ","): string { - if (isInteger()) { - // @ts-ignore: type - if (value instanceof bool) return this.join_bool(separator); - return this.join_int(separator); - } + if (isBoolean()) return this.join_bool(separator); + if (isInteger()) return this.join_int(separator); if (isFloat()) return this.join_flt(separator); if (isString()) return this.join_str(separator); if (isArray()) return this.join_arr(separator); @@ -403,8 +401,7 @@ export class Array extends ArrayBufferView { var value: bool; for (let i = 0; i < lastIndex; ++i) { value = load(dataStart + i); - // @ts-ignore: cast - valueLen = 4 + (!value); + valueLen = 4 + i32(!value); memory.copy( result + (offset << 1), changetype(select("true", "false", value)), @@ -421,8 +418,7 @@ export class Array extends ArrayBufferView { } } value = load(dataStart + lastIndex); - // @ts-ignore: cast - valueLen = 4 + (!value); + valueLen = 4 + i32(!value); memory.copy( result + (offset << 1), changetype(select("true", "false", value)), @@ -445,8 +441,7 @@ export class Array extends ArrayBufferView { if (!lastIndex) return changetype(itoa(load(dataStart))); var sepLen = separator.length; - // @ts-ignore: cast - const valueLen = (sizeof() <= 4 ? 10 : 20) + isSigned(); + const valueLen = (sizeof() <= 4 ? 10 : 20) + i32(isSigned()); var estLen = (valueLen + sepLen) * lastIndex + valueLen; var result = runtime.alloc(estLen << 1); var offset = 0; @@ -477,8 +472,12 @@ export class Array extends ArrayBufferView { var lastIndex = this.length_ - 1; if (lastIndex < 0) return ""; var dataStart = this.dataStart; - // @ts-ignore: type - if (!lastIndex) return changetype(dtoa(load(dataStart))); + if (!lastIndex) { + return changetype(dtoa( + // @ts-ignore: type + load(dataStart)) + ); + } const valueLen = MAX_DOUBLE_LENGTH; var sepLen = separator.length; @@ -488,8 +487,10 @@ export class Array extends ArrayBufferView { var value: T; for (let i = 0; i < lastIndex; ++i) { value = load(dataStart + (i << alignof())); - // @ts-ignore: type - offset += dtoa_stream(result, offset, value); + offset += dtoa_stream(result, offset, + // @ts-ignore: type + value + ); if (sepLen) { memory.copy( result + (offset << 1), @@ -500,8 +501,10 @@ export class Array extends ArrayBufferView { } } value = load(dataStart + (lastIndex << alignof())); - // @ts-ignore: type - offset += dtoa_stream(result, offset, value); + offset += dtoa_stream(result, offset, + // @ts-ignore: type + value + ); if (estLen > offset) { let trimmed = changetype(result).substring(0, offset); runtime.free(result); diff --git a/std/assembly/builtins.ts b/std/assembly/builtins.ts index 1349e1b7..ac0f1439 100644 --- a/std/assembly/builtins.ts +++ b/std/assembly/builtins.ts @@ -1,898 +1,1710 @@ // @ts-ignore: decorator -@builtin @inline export const NaN: f64 = 0 / 0; -// @ts-ignore: decorator -@builtin @inline export const Infinity: f64 = 1 / 0; +@builtin @inline +export const NaN: f64 = 0 / 0; // @ts-ignore: decorator -@builtin export declare function isInteger(value?: T): bool; -// @ts-ignore: decorator -@builtin export declare function isFloat(value?: T): bool; -// @ts-ignore: decorator -@builtin export declare function isSigned(value?: T): bool; -// @ts-ignore: decorator -@builtin export declare function isReference(value?: T): bool; -// @ts-ignore: decorator -@builtin export declare function isString(value?: T): bool; -// @ts-ignore: decorator -@builtin export declare function isArray(value?: T): bool; -// @ts-ignore: decorator -@builtin export declare function isArrayLike(value?: T): bool; -// @ts-ignore: decorator -@builtin export declare function isFunction(value?: T): bool; -// @ts-ignore: decorator -@builtin export declare function isNullable(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(value?: T): bool; -// @ts-ignore: decorator -@inline export function isNaN(value: T): bool { return value != value; } -// @ts-ignore: decorator -@inline export function isFinite(value: T): bool { return value - value == 0; } +@builtin @inline +export const Infinity: f64 = 1 / 0; // @ts-ignore: decorator -@builtin export declare function clz(value: T): T; -// @ts-ignore: decorator -@builtin export declare function ctz(value: T): T; -// @ts-ignore: decorator -@builtin export declare function popcnt(value: T): T; -// @ts-ignore: decorator -@builtin export declare function rotl(value: T, shift: T): T; -// @ts-ignore: decorator -@builtin export declare function rotr(value: T, shift: T): T; -// @ts-ignore: decorator -@builtin export declare function abs(value: T): T; -// @ts-ignore: decorator -@builtin export declare function max(left: T, right: T): T; -// @ts-ignore: decorator -@builtin export declare function min(left: T, right: T): T; -// @ts-ignore: decorator -@builtin export declare function ceil(value: T): T; -// @ts-ignore: decorator -@builtin export declare function floor(value: T): T; -// @ts-ignore: decorator -@builtin export declare function copysign(left: T, right: T): T; -// @ts-ignore: decorator -@builtin export declare function nearest(value: T): T; -// @ts-ignore: decorator -@builtin export declare function reinterpret(value: number): T; -// @ts-ignore: decorator -@builtin export declare function sqrt(value: T): T; -// @ts-ignore: decorator -@builtin export declare function trunc(value: T): T; -// @ts-ignore: decorator -@builtin export declare function load(offset: usize, immOffset?: usize, immAlign?: usize): T; -// @ts-ignore: decorator -@builtin export declare function store(offset: usize, value: void, immOffset?: usize, immAlign?: usize): void; -// @ts-ignore: decorator -@builtin export declare function sizeof(): usize; // | u32 / u64 -// @ts-ignore: decorator -@builtin export declare function alignof(): usize; // | u32 / u64 -// @ts-ignore: decorator -@builtin export declare function offsetof(fieldName?: string): usize; // | u32 / u64 -// @ts-ignore: decorator -@builtin export declare function select(ifTrue: T, ifFalse: T, condition: bool): T; -// @ts-ignore: decorator -@builtin export declare function unreachable(): void; -// @ts-ignore: decorator -@builtin export declare function changetype(value: void): T; -// @ts-ignore: decorator -@builtin export declare function assert(isTrueish: T, message?: string): T; -// @ts-ignore: decorator -@builtin export declare function unchecked(expr: T): T; -// @ts-ignore: decorator -@builtin export declare function call_indirect(target: void, ...args: void[]): T; -// @ts-ignore: decorator -@builtin export declare function instantiate(...args: void[]): T; +@builtin +export declare function isInteger(value?: T): bool; -export namespace atomic { - // @ts-ignore: decorator - @builtin export declare function load(offset: usize, immOffset?: usize): T; - // @ts-ignore: decorator - @builtin export declare function store(offset: usize, value: T, immOffset?: usize): void; - // @ts-ignore: decorator - @builtin export declare function add(ptr: usize, value: T, immOffset?: usize): T; - // @ts-ignore: decorator - @builtin export declare function sub(ptr: usize, value: T, immOffset?: usize): T; - // @ts-ignore: decorator - @builtin export declare function and(ptr: usize, value: T, immOffset?: usize): T; - // @ts-ignore: decorator - @builtin export declare function or(ptr: usize, value: T, immOffset?: usize): T; - // @ts-ignore: decorator - @builtin export declare function xor(ptr: usize, value: T, immOffset?: usize): T; - // @ts-ignore: decorator - @builtin export declare function xchg(ptr: usize, value: T, immOffset?: usize): T; - // @ts-ignore: decorator - @builtin export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T; - // @ts-ignore: decorator - @builtin export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult; - // @ts-ignore: decorator - @builtin export declare function notify(ptr: usize, count: i32): i32; - // @ts-ignore: decorators +// @ts-ignore: decorator +@builtin +export declare function isFloat(value?: T): bool; + +// @ts-ignore: decorator +@builtin +export declare function isBoolean(value?: T): bool; + +// @ts-ignore: decorator +@builtin +export declare function isSigned(value?: T): bool; + +// @ts-ignore: decorator +@builtin +export declare function isReference(value?: T): bool; + +// @ts-ignore: decorator +@builtin +export declare function isString(value?: T): bool; + +// @ts-ignore: decorator +@builtin +export declare function isArray(value?: T): bool; + +// @ts-ignore: decorator +@builtin +export declare function isArrayLike(value?: T): bool; + +// @ts-ignore: decorator +@builtin +export declare function isFunction(value?: T): bool; + +// @ts-ignore: decorator +@builtin +export declare function isNullable(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(value?: T): bool; + +// @ts-ignore: decorator +@inline +export function isNaN(value: T): bool { return value != value; } + +// @ts-ignore: decorator +@inline +export function isFinite(value: T): bool { + // @ts-ignore: type + return value - value == 0; } // @ts-ignore: decorator -@lazy export const enum AtomicWaitResult { +@builtin +export declare function clz(value: T): T; + +// @ts-ignore: decorator +@builtin +export declare function ctz(value: T): T; + +// @ts-ignore: decorator +@builtin +export declare function popcnt(value: T): T; + +// @ts-ignore: decorator +@builtin +export declare function rotl(value: T, shift: T): T; + +// @ts-ignore: decorator +@builtin +export declare function rotr(value: T, shift: T): T; + +// @ts-ignore: decorator +@builtin +export declare function abs(value: T): T; + +// @ts-ignore: decorator +@builtin +export declare function max(left: T, right: T): T; + +// @ts-ignore: decorator +@builtin +export declare function min(left: T, right: T): T; + +// @ts-ignore: decorator +@builtin +export declare function ceil(value: T): T; + +// @ts-ignore: decorator +@builtin +export declare function floor(value: T): T; + +// @ts-ignore: decorator +@builtin +export declare function copysign(left: T, right: T): T; + +// @ts-ignore: decorator +@builtin +export declare function nearest(value: T): T; + +// @ts-ignore: decorator +@builtin +export declare function reinterpret(value: number): T; + +// @ts-ignore: decorator +@builtin +export declare function sqrt(value: T): T; + +// @ts-ignore: decorator +@builtin +export declare function trunc(value: T): T; + +// @ts-ignore: decorator +@builtin +export declare function load(offset: usize, immOffset?: usize, immAlign?: usize): T; + +// @ts-ignore: decorator +@builtin +export declare function store(offset: usize, value: void, immOffset?: usize, immAlign?: usize): void; + +// @ts-ignore: decorator +@builtin +export declare function sizeof(): usize; // | u32 / u64 + +// @ts-ignore: decorator +@builtin +export declare function alignof(): usize; // | u32 / u64 + +// @ts-ignore: decorator +@builtin +export declare function offsetof(fieldName?: string): usize; // | u32 / u64 + +// @ts-ignore: decorator +@builtin +export declare function select(ifTrue: T, ifFalse: T, condition: bool): T; + +// @ts-ignore: decorator +@builtin +export declare function unreachable(): void; + +// @ts-ignore: decorator +@builtin +export declare function changetype(value: void): T; + +// @ts-ignore: decorator +@builtin +export declare function assert(isTrueish: T, message?: string): T; + +// @ts-ignore: decorator +@builtin +export declare function unchecked(expr: T): T; + +// @ts-ignore: decorator +@builtin +export declare function call_indirect(target: void, ...args: void[]): T; + +// @ts-ignore: decorator +@builtin +export declare function instantiate(...args: void[]): T; + +export namespace atomic { + // @ts-ignore: decorator + @builtin + export declare function load(offset: usize, immOffset?: usize): T; + + // @ts-ignore: decorator + @builtin + export declare function store(offset: usize, value: T, immOffset?: usize): void; + + // @ts-ignore: decorator + @builtin + export declare function add(ptr: usize, value: T, immOffset?: usize): T; + + // @ts-ignore: decorator + @builtin + export declare function sub(ptr: usize, value: T, immOffset?: usize): T; + + // @ts-ignore: decorator + @builtin + export declare function and(ptr: usize, value: T, immOffset?: usize): T; + + // @ts-ignore: decorator + @builtin + export declare function or(ptr: usize, value: T, immOffset?: usize): T; + + // @ts-ignore: decorator + @builtin + export declare function xor(ptr: usize, value: T, immOffset?: usize): T; + + // @ts-ignore: decorator + @builtin + export declare function xchg(ptr: usize, value: T, immOffset?: usize): T; + + // @ts-ignore: decorator + @builtin + export declare function cmpxchg(ptr: usize, expected: T, replacement: T, immOffset?: usize): T; + + // @ts-ignore: decorator + @builtin + export declare function wait(ptr: usize, expected: T, timeout: i64): AtomicWaitResult; + + // @ts-ignore: decorator + @builtin + export declare function notify(ptr: usize, count: i32): i32; +} + +// @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; +@builtin +export declare function i8(value: void): i8; + export namespace i8 { + // @ts-ignore: decorator - @lazy export const MIN_VALUE: i8 = -128; + @lazy + export const MIN_VALUE: i8 = -128; + // @ts-ignore: decorator - @lazy export const MAX_VALUE: i8 = 127; + @lazy + export const MAX_VALUE: i8 = 127; } // @ts-ignore: decorator -@builtin export declare function i16(value: void): i16; +@builtin +export declare function i16(value: void): i16; + export namespace i16 { + // @ts-ignore: decorator - @lazy export const MIN_VALUE: i16 = -32768; + @lazy + export const MIN_VALUE: i16 = -32768; + // @ts-ignore: decorator - @lazy export const MAX_VALUE: i16 = 32767; + @lazy + export const MAX_VALUE: i16 = 32767; } // @ts-ignore: decorator -@builtin export declare function i32(value: void): i32; +@builtin +export declare function i32(value: void): i32; + export namespace i32 { + // @ts-ignore: decorator - @lazy export const MIN_VALUE: i32 = -2147483648; + @lazy + export const MIN_VALUE: i32 = -2147483648; + // @ts-ignore: decorator - @lazy export const MAX_VALUE: i32 = 2147483647; + @lazy + export const MAX_VALUE: i32 = 2147483647; + // @ts-ignore: decorator - @builtin export declare function clz(value: i32): i32; + @builtin + export declare function clz(value: i32): i32; + // @ts-ignore: decorator - @builtin export declare function ctz(value: i32): i32; + @builtin + export declare function ctz(value: i32): i32; + // @ts-ignore: decorator - @builtin export declare function popcnt(value: i32): i32; + @builtin + export declare function popcnt(value: i32): i32; + // @ts-ignore: decorator - @builtin export declare function rotl(value: i32, shift: i32): i32; + @builtin + export declare function rotl(value: i32, shift: i32): i32; + // @ts-ignore: decorator - @builtin export declare function rotr(value: i32, shift: i32): i32; + @builtin + export declare function rotr(value: i32, shift: i32): i32; + // @ts-ignore: decorator - @builtin export declare function reinterpret_f32(value: f32): i32; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; - + @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; + @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; + @builtin + export declare function load16_u(offset: usize, immOffset?: usize): i32; + // @ts-ignore: decorator - @builtin export declare function load(offset: usize, immOffset?: usize): i32; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; +@builtin +export declare function i64(value: void): i64; + export namespace i64 { + // @ts-ignore: decorator - @lazy export const MIN_VALUE: i64 = -9223372036854775808; + @lazy + export const MIN_VALUE: i64 = -9223372036854775808; + // @ts-ignore: decorator - @lazy export const MAX_VALUE: i64 = 9223372036854775807; + @lazy + export const MAX_VALUE: i64 = 9223372036854775807; + // @ts-ignore: decorator - @builtin export declare function clz(value: i64): i64; + @builtin + export declare function clz(value: i64): i64; + // @ts-ignore: decorator - @builtin export declare function ctz(value: i64): i64; + @builtin + export declare function ctz(value: i64): i64; + // @ts-ignore: decorator - @builtin export declare function load8_s(offset: usize, immOffset?: usize, immAlign?: usize): i64; + @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; + @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; + @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; + @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; + @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; + @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; + @builtin + export declare function load(offset: usize, immOffset?: usize): i64; + // @ts-ignore: decorator - @builtin export declare function popcnt(value: i64): i64; + @builtin + export declare function popcnt(value: i64): i64; + // @ts-ignore: decorator - @builtin export declare function rotl(value: i64, shift: i64): i64; + @builtin + export declare function rotl(value: i64, shift: i64): i64; + // @ts-ignore: decorator - @builtin export declare function rotr(value: i64, shift: i64): i64; + @builtin + export declare function rotr(value: i64, shift: i64): i64; + // @ts-ignore: decorator - @builtin export declare function reinterpret_f64(value: f64): i64; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @builtin + export declare function load32_u(offset: usize, immOffset?: usize): i64; + // @ts-ignore: decorator - @builtin export declare function load(offset: usize, immOffset?: usize): i64; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; +@builtin +export declare function isize(value: void): isize; + export namespace isize { + // @ts-ignore: decorator - @lazy export const MIN_VALUE: isize = sizeof() == sizeof() + @lazy + export const MIN_VALUE: isize = sizeof() == sizeof() ? -2147483648 : -9223372036854775808; + // @ts-ignore: decorator - @lazy export const MAX_VALUE: isize = sizeof() == sizeof() + @lazy + export const MAX_VALUE: isize = sizeof() == sizeof() ? 2147483647 : 9223372036854775807; } // @ts-ignore: decorator -@builtin export declare function u8(value: void): u8; +@builtin +export declare function u8(value: void): u8; + export namespace u8 { + // @ts-ignore: decorator - @lazy export const MIN_VALUE: u8 = 0; + @lazy + export const MIN_VALUE: u8 = 0; + // @ts-ignore: decorator - @lazy export const MAX_VALUE: u8 = 255; + @lazy + export const MAX_VALUE: u8 = 255; } // @ts-ignore: decorator -@builtin export declare function u16(value: void): u16; +@builtin +export declare function u16(value: void): u16; + export namespace u16 { + // @ts-ignore: decorator - @lazy export const MIN_VALUE: u16 = 0; + @lazy + export const MIN_VALUE: u16 = 0; + // @ts-ignore: decorator - @lazy export const MAX_VALUE: u16 = 65535; + @lazy + export const MAX_VALUE: u16 = 65535; } // @ts-ignore: decorator -@builtin export declare function u32(value: void): u32; +@builtin +export declare function u32(value: void): u32; + export namespace u32 { + // @ts-ignore: decorator - @lazy export const MIN_VALUE: u32 = 0; + @lazy + export const MIN_VALUE: u32 = 0; + // @ts-ignore: decorator - @lazy export const MAX_VALUE: u32 = 4294967295; + @lazy + export const MAX_VALUE: u32 = 4294967295; } // @ts-ignore: decorator -@builtin export declare function u64(value: void): u64; +@builtin +export declare function u64(value: void): u64; + export namespace u64 { + // @ts-ignore: decorator - @lazy export const MIN_VALUE: u64 = 0; + @lazy + export const MIN_VALUE: u64 = 0; + // @ts-ignore: decorator - @lazy export const MAX_VALUE: u64 = 18446744073709551615; + @lazy + export const MAX_VALUE: u64 = 18446744073709551615; } // @ts-ignore: decorator -@builtin export declare function usize(value: void): usize; +@builtin +export declare function usize(value: void): usize; + export namespace usize { + // @ts-ignore: decorator - @lazy export const MIN_VALUE: usize = 0; + @lazy + export const MIN_VALUE: usize = 0; + // @ts-ignore: decorator - @lazy export const MAX_VALUE: usize = sizeof() == sizeof() + @lazy + export const MAX_VALUE: usize = sizeof() == sizeof() ? 4294967295 : 18446744073709551615; } // @ts-ignore: decorator -@builtin export declare function bool(value: void): bool; +@builtin +export declare function bool(value: void): bool; + export namespace bool { + // @ts-ignore: decorator - @lazy export const MIN_VALUE: bool = false; + @lazy + export const MIN_VALUE: bool = false; + // @ts-ignore: decorator - @lazy export const MAX_VALUE: bool = true; + @lazy + export const MAX_VALUE: bool = true; } // @ts-ignore: decorator -@builtin export declare function f32(value: void): f32; +@builtin +export declare function f32(value: void): f32; + export namespace f32 { + // @ts-ignore: decorator - @lazy export const EPSILON = reinterpret(0x34000000); // 0x1p-23f + @lazy + export const EPSILON = reinterpret(0x34000000); // 0x1p-23f + // @ts-ignore: decorator - @lazy export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f + @lazy + export const MIN_VALUE = reinterpret(0x00000001); // 0x0.000001p+0f + // @ts-ignore: decorator - @lazy export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f + @lazy + export const MAX_VALUE = reinterpret(0x7F7FFFFF); // 0x1.fffffep+127f + // @ts-ignore: decorator - @lazy export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f + @lazy + export const MIN_NORMAL_VALUE = reinterpret(0x00800000); // 0x1p-126f + // @ts-ignore: decorator - @lazy export const MIN_SAFE_INTEGER: f32 = -16777215; + @lazy + export const MIN_SAFE_INTEGER: f32 = -16777215; + // @ts-ignore: decorator - @lazy export const MAX_SAFE_INTEGER: f32 = 16777215; + @lazy + export const MAX_SAFE_INTEGER: f32 = 16777215; + // @ts-ignore: decorator - @builtin export declare function abs(value: f32): f32; + @builtin + export declare function abs(value: f32): f32; + // @ts-ignore: decorator - @builtin export declare function ceil(value: f32): f32; + @builtin + export declare function ceil(value: f32): f32; + // @ts-ignore: decorator - @builtin export declare function copysign(x: f32, y: f32): f32; + @builtin + export declare function copysign(x: f32, y: f32): f32; + // @ts-ignore: decorator - @builtin export declare function floor(value: f32): f32; + @builtin + export declare function floor(value: f32): f32; + // @ts-ignore: decorator - @builtin export declare function load(offset: usize, immOffset?: usize, immAlign?: usize): f32; + @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; + @builtin + export declare function max(left: f32, right: f32): f32; + // @ts-ignore: decorator - @builtin export declare function min(left: f32, right: f32): f32; + @builtin + export declare function min(left: f32, right: f32): f32; + // @ts-ignore: decorator - @builtin export declare function nearest(value: f32): f32; + @builtin + export declare function nearest(value: f32): f32; + // @ts-ignore: decorator - @builtin export declare function reinterpret_i32(value: i32): f32; + @builtin + export declare function reinterpret_i32(value: i32): f32; + // @ts-ignore: decorator - @builtin export declare function sqrt(value: f32): f32; + @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; + @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; + @builtin + export declare function trunc(value: f32): f32; } // @ts-ignore: decorator -@builtin export declare function f64(value: void): f64; +@builtin +export declare function f64(value: void): f64; + export namespace f64 { + // @ts-ignore: decorator - @lazy export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52 + @lazy + export const EPSILON = reinterpret(0x3CB0000000000000); // 0x1p-52 + // @ts-ignore: decorator - @lazy export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0 + @lazy + export const MIN_VALUE = reinterpret(0x0000000000000001); // 0x0.0000000000001p+0 + // @ts-ignore: decorator - @lazy export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023 + @lazy + export const MAX_VALUE = reinterpret(0x7FEFFFFFFFFFFFFF); // 0x1.fffffffffffffp+1023 + // @ts-ignore: decorator - @lazy export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022 + @lazy + export const MIN_NORMAL_VALUE = reinterpret(0x0010000000000000); // 0x1p-1022 + // @ts-ignore: decorator - @lazy export const MIN_SAFE_INTEGER: f64 = -9007199254740991; + @lazy + export const MIN_SAFE_INTEGER: f64 = -9007199254740991; + // @ts-ignore: decorator - @lazy export const MAX_SAFE_INTEGER: f64 = 9007199254740991; + @lazy + export const MAX_SAFE_INTEGER: f64 = 9007199254740991; + // @ts-ignore: decorator - @builtin export declare function abs(value: f64): f64; + @builtin + export declare function abs(value: f64): f64; + // @ts-ignore: decorator - @builtin export declare function ceil(value: f64): f64; + @builtin + export declare function ceil(value: f64): f64; + // @ts-ignore: decorator - @builtin export declare function copysign(x: f64, y: f64): f64; + @builtin + export declare function copysign(x: f64, y: f64): f64; + // @ts-ignore: decorator - @builtin export declare function floor(value: f64): f64; + @builtin + export declare function floor(value: f64): f64; + // @ts-ignore: decorator - @builtin export declare function load(offset: usize, immOffset?: usize, immAlign?: usize): f64; + @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; + @builtin + export declare function max(left: f64, right: f64): f64; + // @ts-ignore: decorator - @builtin export declare function min(left: f64, right: f64): f64; + @builtin + export declare function min(left: f64, right: f64): f64; + // @ts-ignore: decorator - @builtin export declare function nearest(value: f64): f64; + @builtin + export declare function nearest(value: f64): f64; + // @ts-ignore: decorator - @builtin export declare function reinterpret_i64(value: i64): f64; + @builtin + export declare function reinterpret_i64(value: i64): f64; + // @ts-ignore: decorator - @builtin export declare function sqrt(value: f64): f64; + @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; + @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; + @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; +@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(x: T): v128; + @builtin + export declare function splat(x: T): v128; + // @ts-ignore: decorator - @builtin export declare function extract_lane(x: v128, idx: u8): T; + @builtin + export declare function extract_lane(x: v128, idx: u8): T; + // @ts-ignore: decorator - @builtin export declare function replace_lane(x: v128, idx: u8, value: T): v128; + @builtin + export declare function replace_lane(x: v128, idx: u8, value: T): v128; + // @ts-ignore: decorator - @builtin export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128; + @builtin + export declare function shuffle(a: v128, b: v128, ...lanes: u8[]): v128; + // @ts-ignore: decorator - @builtin export declare function load(offset: usize, immOffset?: usize, immAlign?: usize): v128; + @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; + @builtin + export declare function store(offset: usize, value: v128, immOffset?: usize, immAlign?: usize): void; + // @ts-ignore: decorator - @builtin export declare function add(a: v128, b: v128): v128; + @builtin + export declare function add(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function sub(a: v128, b: v128): v128; + @builtin + export declare function sub(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function mul(a: v128, b: v128): v128; // except i64 + @builtin + export declare function mul(a: v128, b: v128): v128; // except i64 + // @ts-ignore: decorator - @builtin export declare function div(a: v128, b: v128): v128; // f32, f64 only + @builtin + export declare function div(a: v128, b: v128): v128; // f32, f64 only + // @ts-ignore: decorator - @builtin export declare function neg(a: v128): v128; + @builtin + export declare function neg(a: v128): v128; + // @ts-ignore: decorator - @builtin export declare function add_saturate(a: v128, b: v128): v128; + @builtin + export declare function add_saturate(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function sub_saturate(a: v128, b: v128): v128; + @builtin + export declare function sub_saturate(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function shl(a: v128, b: i32): v128; + @builtin + export declare function shl(a: v128, b: i32): v128; + // @ts-ignore: decorator - @builtin export declare function shr(a: v128, b: i32): v128; + @builtin + export declare function shr(a: v128, b: i32): v128; + // @ts-ignore: decorator - @builtin export declare function and(a: v128, b: v128): v128; + @builtin + export declare function and(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function or(a: v128, b: v128): v128; + @builtin + export declare function or(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function xor(a: v128, b: v128): v128; + @builtin + export declare function xor(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function not(a: v128): v128; + @builtin + export declare function not(a: v128): v128; + // @ts-ignore: decorator - @builtin export declare function bitselect(v1: v128, v2: v128, c: v128): v128; + @builtin + export declare function bitselect(v1: v128, v2: v128, c: v128): v128; + // @ts-ignore: decorator - @builtin export declare function any_true(a: v128): bool; + @builtin + export declare function any_true(a: v128): bool; + // @ts-ignore: decorator - @builtin export declare function all_true(a: v128): bool; + @builtin + export declare function all_true(a: v128): bool; + // @ts-ignore: decorator - @builtin export declare function min(a: v128, b: v128): v128; // f32, f64 only + @builtin + export declare function min(a: v128, b: v128): v128; // f32, f64 only + // @ts-ignore: decorator - @builtin export declare function max(a: v128, b: v128): v128; // f32, f64 only + @builtin + export declare function max(a: v128, b: v128): v128; // f32, f64 only + // @ts-ignore: decorator - @builtin export declare function abs(a: v128): v128; // f32, f64 only + @builtin + export declare function abs(a: v128): v128; // f32, f64 only + // @ts-ignore: decorator - @builtin export declare function sqrt(a: v128): v128; // f32, f64 only + @builtin + export declare function sqrt(a: v128): v128; // f32, f64 only + // @ts-ignore: decorator - @builtin export declare function eq(a: v128, b: v128): v128; + @builtin + export declare function eq(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function ne(a: v128, b: v128): v128; + @builtin + export declare function ne(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function lt(a: v128, b: v128): v128; + @builtin + export declare function lt(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function le(a: v128, b: v128): v128; + @builtin + export declare function le(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function gt(a: v128, b: v128): v128; + @builtin + export declare function gt(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function ge(a: v128, b: v128): v128; + @builtin + export declare function ge(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function convert(a: v128): v128; + @builtin + export declare function convert(a: v128): v128; + // @ts-ignore: decorator - @builtin export declare function trunc(a: v128): v128; + @builtin + export declare function trunc(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; +@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; + @builtin + export declare function splat(x: i8): v128; + // @ts-ignore: decorator - @builtin export declare function extract_lane_s(x: v128, idx: u8): i8; + @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; + @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; + @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; + @builtin + export declare function add(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function sub(a: v128, b: v128): v128; + @builtin + export declare function sub(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function mul(a: v128, b: v128): v128; + @builtin + export declare function mul(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function neg(a: v128): v128; + @builtin + export declare function neg(a: v128): v128; + // @ts-ignore: decorator - @builtin export declare function add_saturate_s(a: v128, b: v128): v128; + @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; + @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; + @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; + @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; + @builtin + export declare function shl(a: v128, b: i32): v128; + // @ts-ignore: decorator - @builtin export declare function shr_s(a: v128, b: i32): v128; + @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; + @builtin + export declare function shr_u(a: v128, b: i32): v128; + // @ts-ignore: decorator - @builtin export declare function any_true(a: v128): bool; + @builtin + export declare function any_true(a: v128): bool; + // @ts-ignore: decorator - @builtin export declare function all_true(a: v128): bool; + @builtin + export declare function all_true(a: v128): bool; + // @ts-ignore: decorator - @builtin export declare function eq(a: v128, b: v128): v128; + @builtin + export declare function eq(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function ne(a: v128, b: v128): v128; + @builtin + export declare function ne(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function lt_s(a: v128, b: v128): v128; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; +@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; + @builtin + export declare function splat(x: i16): v128; + // @ts-ignore: decorator - @builtin export declare function extract_lane_s(x: v128, idx: u8): i16; + @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; + @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; + @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; + @builtin + export declare function add(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function sub(a: v128, b: v128): v128; + @builtin + export declare function sub(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function mul(a: v128, b: v128): v128; + @builtin + export declare function mul(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function neg(a: v128): v128; + @builtin + export declare function neg(a: v128): v128; + // @ts-ignore: decorator - @builtin export declare function add_saturate_s(a: v128, b: v128): v128; + @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; + @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; + @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; + @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; + @builtin + export declare function shl(a: v128, b: i32): v128; + // @ts-ignore: decorator - @builtin export declare function shr_s(a: v128, b: i32): v128; + @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; + @builtin + export declare function shr_u(a: v128, b: i32): v128; + // @ts-ignore: decorator - @builtin export declare function any_true(a: v128): bool; + @builtin + export declare function any_true(a: v128): bool; + // @ts-ignore: decorator - @builtin export declare function all_true(a: v128): bool; + @builtin + export declare function all_true(a: v128): bool; + // @ts-ignore: decorator - @builtin export declare function eq(a: v128, b: v128): v128; + @builtin + export declare function eq(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function ne(a: v128, b: v128): v128; + @builtin + export declare function ne(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function lt_s(a: v128, b: v128): v128; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; +@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; + @builtin + export declare function splat(x: i32): v128; + // @ts-ignore: decorator - @builtin export declare function extract_lane(x: v128, idx: u8): i32; + @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; + @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; + @builtin + export declare function add(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function sub(a: v128, b: v128): v128; + @builtin + export declare function sub(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function mul(a: v128, b: v128): v128; + @builtin + export declare function mul(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function neg(a: v128): v128; + @builtin + export declare function neg(a: v128): v128; + // @ts-ignore: decorator - @builtin export declare function shl(a: v128, b: i32): v128; + @builtin + export declare function shl(a: v128, b: i32): v128; + // @ts-ignore: decorator - @builtin export declare function shr_s(a: v128, b: i32): v128; + @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; + @builtin + export declare function shr_u(a: v128, b: i32): v128; + // @ts-ignore: decorator - @builtin export declare function any_true(a: v128): bool; + @builtin + export declare function any_true(a: v128): bool; + // @ts-ignore: decorator - @builtin export declare function all_true(a: v128): bool; + @builtin + export declare function all_true(a: v128): bool; + // @ts-ignore: decorator - @builtin export declare function eq(a: v128, b: v128): v128; + @builtin + export declare function eq(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function ne(a: v128, b: v128): v128; + @builtin + export declare function ne(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function lt_s(a: v128, b: v128): v128; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @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; + @builtin + export declare function trunc_u_f32x4_sat(a: v128): v128; } // @ts-ignore: decorator -@builtin export declare function i64x2(a: i64, b: i64): v128; +@builtin +export declare function i64x2(a: i64, b: i64): v128; + export namespace i64x2 { + // @ts-ignore: decorator - @builtin export declare function splat(x: i64): v128; + @builtin + export declare function splat(x: i64): v128; + // @ts-ignore: decorator - @builtin export declare function extract_lane(x: v128, idx: u8): i64; + @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; + @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; + @builtin + export declare function add(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function sub(a: v128, b: v128): v128; + @builtin + export declare function sub(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function mul(a: v128, b: v128): v128; + @builtin + export declare function mul(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function neg(a: v128): v128; + @builtin + export declare function neg(a: v128): v128; + // @ts-ignore: decorator - @builtin export declare function shl(a: v128, b: i32): v128; + @builtin + export declare function shl(a: v128, b: i32): v128; + // @ts-ignore: decorator - @builtin export declare function shr_s(a: v128, b: i32): v128; + @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; + @builtin + export declare function shr_u(a: v128, b: i32): v128; + // @ts-ignore: decorator - @builtin export declare function any_true(a: v128): bool; + @builtin + export declare function any_true(a: v128): bool; + // @ts-ignore: decorator - @builtin export declare function all_true(a: v128): bool; + @builtin + export declare function all_true(a: v128): bool; + // @ts-ignore: decorator - @builtin export declare function trunc_s_f64x2_sat(a: v128): v128; + @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; + @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; +@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; + @builtin + export declare function splat(x: f32): v128; + // @ts-ignore: decorator - @builtin export declare function extract_lane(x: v128, idx: u8): f32; + @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; + @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; + @builtin + export declare function add(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function sub(a: v128, b: v128): v128; + @builtin + export declare function sub(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function mul(a: v128, b: v128): v128; + @builtin + export declare function mul(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function div(a: v128, b: v128): v128; + @builtin + export declare function div(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function neg(a: v128): v128; + @builtin + export declare function neg(a: v128): v128; + // @ts-ignore: decorator - @builtin export declare function min(a: v128, b: v128): v128; + @builtin + export declare function min(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function max(a: v128, b: v128): v128; + @builtin + export declare function max(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function abs(a: v128): v128; + @builtin + export declare function abs(a: v128): v128; + // @ts-ignore: decorator - @builtin export declare function sqrt(a: v128): v128; + @builtin + export declare function sqrt(a: v128): v128; + // @ts-ignore: decorator - @builtin export declare function eq(a: v128, b: v128): v128; + @builtin + export declare function eq(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function ne(a: v128, b: v128): v128; + @builtin + export declare function ne(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function lt(a: v128, b: v128): v128; + @builtin + export declare function lt(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function le(a: v128, b: v128): v128; + @builtin + export declare function le(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function gt(a: v128, b: v128): v128; + @builtin + export declare function gt(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function ge(a: v128, b: v128): v128; + @builtin + export declare function ge(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function convert_s_i32x4(a: v128): v128; + @builtin + export declare function convert_s_i32x4(a: v128): v128; + // @ts-ignore: decorator - @builtin export declare function convert_u_i32x4(a: v128): v128; + @builtin + export declare function convert_u_i32x4(a: v128): v128; } // @ts-ignore: decorator -@builtin export declare function f64x2(a: f64, b: f64): v128; +@builtin +export declare function f64x2(a: f64, b: f64): v128; + export namespace f64x2 { + // @ts-ignore: decorator - @builtin export declare function splat(x: f64): v128; + @builtin + export declare function splat(x: f64): v128; + // @ts-ignore: decorator - @builtin export declare function extract_lane(x: v128, idx: u8): f64; + @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; + @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; + @builtin + export declare function add(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function sub(a: v128, b: v128): v128; + @builtin + export declare function sub(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function mul(a: v128, b: v128): v128; + @builtin + export declare function mul(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function div(a: v128, b: v128): v128; + @builtin + export declare function div(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function neg(a: v128): v128; + @builtin + export declare function neg(a: v128): v128; + // @ts-ignore: decorator - @builtin export declare function min(a: v128, b: v128): v128; + @builtin + export declare function min(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function max(a: v128, b: v128): v128; + @builtin + export declare function max(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function abs(a: v128): v128; + @builtin + export declare function abs(a: v128): v128; + // @ts-ignore: decorator - @builtin export declare function sqrt(a: v128): v128; + @builtin + export declare function sqrt(a: v128): v128; + // @ts-ignore: decorator - @builtin export declare function eq(a: v128, b: v128): v128; + @builtin + export declare function eq(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function ne(a: v128, b: v128): v128; + @builtin + export declare function ne(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function lt(a: v128, b: v128): v128; + @builtin + export declare function lt(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function le(a: v128, b: v128): v128; + @builtin + export declare function le(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function gt(a: v128, b: v128): v128; + @builtin + export declare function gt(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function ge(a: v128, b: v128): v128; + @builtin + export declare function ge(a: v128, b: v128): v128; + // @ts-ignore: decorator - @builtin export declare function convert_s_i64x2(a: v128): v128; + @builtin + export declare function convert_s_i64x2(a: v128): v128; + // @ts-ignore: decorator - @builtin export declare function convert_u_i64x2(a: v128): v128; + @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; + @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; } diff --git a/std/assembly/collector/itcm.ts b/std/assembly/collector/itcm.ts index e63b7fdb..17d7a292 100644 --- a/std/assembly/collector/itcm.ts +++ b/std/assembly/collector/itcm.ts @@ -1,11 +1,13 @@ // Largely based on Bach Le's μgc, see: https://github.com/bullno1/ugc // @ts-ignore: decorator -@inline const TRACE = false; +@inline +const TRACE = false; /** Size of a managed object header. */ // @ts-ignore: decorator -@inline export const HEADER_SIZE: usize = (offsetof() + AL_MASK) & ~AL_MASK; +@inline +export const HEADER_SIZE: usize = (offsetof() + AL_MASK) & ~AL_MASK; import { AL_MASK, MAX_SIZE_32 } from "../util/allocator"; import { gc } from "../gc"; @@ -148,8 +150,7 @@ function step(): void { if (obj !== toSpace) { if (TRACE) trace("gc~step/MARK iterate", 1, objToRef(obj)); iter = obj; - // @ts-ignore: cast - obj.color = !white; + obj.color = i32(!white); // if (TRACE) { // trace(" next/prev/hook", 3, // changetype(obj.next), @@ -166,8 +167,7 @@ function step(): void { let from = fromSpace; fromSpace = toSpace; toSpace = from; - // @ts-ignore: cast - white = !white; + white = i32(!white); iter = from.next; state = State.SWEEP; if (TRACE) trace("gc~state = SWEEP"); @@ -193,17 +193,20 @@ function step(): void { } // @ts-ignore: decorator -@inline function refToObj(ref: usize): ManagedObject { +@inline +function refToObj(ref: usize): ManagedObject { return changetype(ref - HEADER_SIZE); } // @ts-ignore: decorator -@inline function objToRef(obj: ManagedObject): usize { +@inline +function objToRef(obj: ManagedObject): usize { return changetype(obj) + HEADER_SIZE; } // @ts-ignore: decorator -@global @unsafe export function __gc_allocate( // TODO: make this register only / reuse header +@global @unsafe +export function __gc_allocate( // TODO: make this register only / reuse header size: usize, markFn: (ref: usize) => void ): usize { @@ -218,15 +221,16 @@ function step(): void { } // @ts-ignore: decorator -@global @unsafe export function __gc_link(parentRef: usize, childRef: usize): void { +@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 == !white && refToObj(childRef).color == white) parent.makeGray(); + if (parent.color == i32(!white) && refToObj(childRef).color == white) parent.makeGray(); } // @ts-ignore: decorator -@global @unsafe export function __gc_mark(ref: usize): void { +@global @unsafe +export function __gc_mark(ref: usize): void { if (TRACE) trace("gc.mark", 1, ref); if (ref) { let obj = refToObj(ref); @@ -235,7 +239,8 @@ function step(): void { } // @ts-ignore: decorator -@global @unsafe export function __gc_collect(): void { +@global @unsafe +export function __gc_collect(): void { if (TRACE) trace("gc.collect"); // begin collecting if not yet collecting switch (state) { diff --git a/std/assembly/diagnostics.ts b/std/assembly/diagnostics.ts index 5254ac15..065364db 100644 --- a/std/assembly/diagnostics.ts +++ b/std/assembly/diagnostics.ts @@ -1,8 +1,11 @@ // @ts-ignore: decorator -@builtin export declare function ERROR(message?: string): void; +@builtin +export declare function ERROR(message?: string): void; // @ts-ignore: decorator -@builtin export declare function WARNING(message?: string): void; +@builtin +export declare function WARNING(message?: string): void; // @ts-ignore: decorator -@builtin export declare function INFO(message?: string): void; +@builtin +export declare function INFO(message?: string): void; diff --git a/std/assembly/gc.ts b/std/assembly/gc.ts index 26ae9df2..90926a36 100644 --- a/std/assembly/gc.ts +++ b/std/assembly/gc.ts @@ -2,39 +2,53 @@ export namespace gc { /** Whether the garbage collector interface is implemented. */ - // @ts-ignore: decorator, undefined - @lazy export const implemented: bool = isDefined(__gc_register); + // @ts-ignore: decorator + @lazy + export const implemented: bool = isDefined( + // @ts-ignore: stub + __gc_register + ); /** Gets the computed unique class id of a class type. */ - @unsafe @builtin export declare function classId(): u32; + // @ts-ignore: decorator + @unsafe @builtin + export declare function classId(): u32; /** Iterates reference root objects. */ - @unsafe @builtin export declare function iterateRoots(fn: (ref: usize) => void): void; + // @ts-ignore: decorator + @unsafe @builtin + export declare function iterateRoots(fn: (ref: usize) => void): void; /** Registers a managed object to be tracked by the garbage collector. */ - @unsafe export function register(ref: usize): void { - // @ts-ignore: undefined + // @ts-ignore: decorator + @unsafe + export function register(ref: usize): void { + // @ts-ignore: stub 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 + // @ts-ignore: decorator + @unsafe + export function link(ref: usize, parentRef: usize): void { + // @ts-ignore: stub 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 + // @ts-ignore: decorator + @unsafe + export function mark(ref: usize): void { + // @ts-ignore: stub 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 + // @ts-ignore: stub if (isDefined(__gc_collect)) __gc_collect(); else WARNING("missing implementation: gc.collect"); } diff --git a/std/assembly/index.d.ts b/std/assembly/index.d.ts index bafda538..2544d66a 100644 --- a/std/assembly/index.d.ts +++ b/std/assembly/index.d.ts @@ -128,6 +128,8 @@ declare function isFinite(value: T): bool; declare function isInteger(value?: any): value is number; /** Tests if the specified type *or* expression is of a float type. Compiles to a constant. */ declare function isFloat(value?: any): value is number; +/** Tests if the specified type *or* expression is of a boolean type. */ +declare function isBoolean(value?: any): value is number; /** Tests if the specified type *or* expression can represent negative numbers. Compiles to a constant. */ declare function isSigned(value?: any): value is number; /** Tests if the specified type *or* expression is of a reference type. Compiles to a constant. */ @@ -200,7 +202,7 @@ declare enum AtomicWaitResult { } /** Converts any other numeric value to an 8-bit signed integer. */ -declare function i8(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i8; +declare function i8(value: any): i8; declare namespace i8 { /** Smallest representable value. */ export const MIN_VALUE: i8; @@ -208,7 +210,7 @@ declare namespace i8 { export const MAX_VALUE: i8; } /** Converts any other numeric value to a 16-bit signed integer. */ -declare function i16(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i8; +declare function i16(value: any): i8; declare namespace i16 { /** Smallest representable value. */ export const MIN_VALUE: i16; @@ -216,7 +218,7 @@ declare namespace i16 { export const MAX_VALUE: i16; } /** Converts any other numeric value to a 32-bit signed integer. */ -declare function i32(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i32; +declare function i32(value: any): i32; declare namespace i32 { /** Smallest representable value. */ export const MIN_VALUE: i32; @@ -310,7 +312,7 @@ declare namespace i32 { } } /** Converts any other numeric value to a 64-bit signed integer. */ -declare function i64(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i64; +declare function i64(value: any): i64; declare namespace i64 { /** Smallest representable value. */ export const MIN_VALUE: i64; @@ -433,7 +435,7 @@ declare namespace i64 { /** Converts any other numeric value to a 32-bit (in WASM32) respectivel 64-bit (in WASM64) signed integer. */ declare var isize: typeof i32 | typeof i64; /** Converts any other numeric value to an 8-bit unsigned integer. */ -declare function u8(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i8; +declare function u8(value: any): i8; declare namespace u8 { /** Smallest representable value. */ export const MIN_VALUE: u8; @@ -441,7 +443,7 @@ declare namespace u8 { export const MAX_VALUE: u8; } /** Converts any other numeric value to a 16-bit unsigned integer. */ -declare function u16(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i8; +declare function u16(value: any): i8; declare namespace u16 { /** Smallest representable value. */ export const MIN_VALUE: u16; @@ -449,7 +451,7 @@ declare namespace u16 { export const MAX_VALUE: u16; } /** Converts any other numeric value to a 32-bit unsigned integer. */ -declare function u32(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i32; +declare function u32(value: any): i32; declare namespace u32 { /** Smallest representable value. */ export const MIN_VALUE: u32; @@ -457,7 +459,7 @@ declare namespace u32 { export const MAX_VALUE: u32; } /** Converts any other numeric value to a 64-bit unsigned integer. */ -declare function u64(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i64; +declare function u64(value: any): i64; declare namespace u64 { /** Smallest representable value. */ export const MIN_VALUE: u64; @@ -467,7 +469,7 @@ declare namespace u64 { /** Converts any other numeric value to a 32-bit (in WASM32) respectivel 64-bit (in WASM64) unsigned integer. */ declare var usize: typeof u32 | typeof u64; /** Converts any other numeric value to a 1-bit unsigned integer. */ -declare function bool(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): bool; +declare function bool(value: any): bool; declare namespace bool { /** Smallest representable value. */ export const MIN_VALUE: bool; @@ -475,7 +477,7 @@ declare namespace bool { export const MAX_VALUE: bool; } /** Converts any other numeric value to a 32-bit float. */ -declare function f32(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): f32; +declare function f32(value: any): f32; declare namespace f32 { /** Smallest representable value. */ export const MIN_VALUE: f32; @@ -495,7 +497,7 @@ declare namespace f32 { export function store(offset: usize, value: f32, immOffset?: usize, immAlign?: usize): void; } /** Converts any other numeric value to a 64-bit float. */ -declare function f64(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): f64; +declare function f64(value: any): f64; declare namespace f64 { /** Smallest representable value. */ export const MIN_VALUE: f64; diff --git a/std/assembly/map.ts b/std/assembly/map.ts index 2a8a1925..7f4e8c44 100644 --- a/std/assembly/map.ts +++ b/std/assembly/map.ts @@ -4,13 +4,16 @@ 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; +@inline +const INITIAL_CAPACITY = 4; // @ts-ignore: decorator -@inline const FILL_FACTOR: f64 = 8 / 3; +@inline const +FILL_FACTOR: f64 = 8 / 3; // @ts-ignore: decorator -@inline const FREE_FACTOR: f64 = 3 / 4; +@inline const +FREE_FACTOR: f64 = 3 / 4; /** Structure of a map entry. */ @unmanaged class MapEntry { @@ -21,15 +24,18 @@ import { HASH } from "./util/hash"; /** Empty bit. */ // @ts-ignore: decorator -@inline const EMPTY: usize = 1 << 0; +@inline +const EMPTY: usize = 1 << 0; /** Size of a bucket. */ // @ts-ignore: decorator -@inline const BUCKET_SIZE = sizeof(); +@inline +const BUCKET_SIZE = sizeof(); /** Computes the alignment of an entry. */ // @ts-ignore: decorator -@inline function ENTRY_ALIGN(): usize { +@inline +function ENTRY_ALIGN(): usize { // can align to 4 instead of 8 if 32-bit and K/V is <= 32-bits const maxkv = sizeof() > sizeof() ? sizeof() : sizeof(); const align = (maxkv > sizeof() ? maxkv : sizeof()) - 1; @@ -38,7 +44,8 @@ import { HASH } from "./util/hash"; /** Computes the aligned size of an entry. */ // @ts-ignore: decorator -@inline function ENTRY_SIZE(): usize { +@inline +function ENTRY_SIZE(): usize { const align = ENTRY_ALIGN(); const size = (offsetof>() + align) & ~align; return size; diff --git a/std/assembly/math.ts b/std/assembly/math.ts index 22efc2a3..58a39bed 100644 --- a/std/assembly/math.ts +++ b/std/assembly/math.ts @@ -43,7 +43,8 @@ function R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3 } // @ts-ignore: decorator -@inline function expo2(x: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX) +@inline +function expo2(x: f64): f64 { // exp(x)/2 for x >= log(DBL_MAX) const // see: musl/src/math/__expo2.c k = 2043, kln2 = reinterpret(0x40962066151ADD8B); // 0x1.62066151add8bp+10 @@ -52,15 +53,24 @@ function R(z: f64): f64 { // Rational approximation of (asin(x)-x)/x^3 } // @ts-ignore: decorator -@lazy var random_seeded = false; +@lazy +var random_seeded = false; + // @ts-ignore: decorator -@lazy var random_state0_64: u64; +@lazy +var random_state0_64: u64; + // @ts-ignore: decorator -@lazy var random_state1_64: u64; +@lazy +var random_state1_64: u64; + // @ts-ignore: decorator -@lazy var random_state0_32: u32; +@lazy +var random_state0_32: u32; + // @ts-ignore: decorator -@lazy var random_state1_32: u32; +@lazy +var random_state1_32: u32; function murmurHash3(h: u64): u64 { // Force all bits of a hash block to avalanche h ^= h >> 33; // see: https://github.com/aappleby/smhasher @@ -81,21 +91,36 @@ function splitMix32(h: u32): u32 { export namespace NativeMath { // @ts-ignore: decorator - @lazy export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354 + @lazy + export const E = reinterpret(0x4005BF0A8B145769); // 2.7182818284590452354 + // @ts-ignore: decorator - @lazy export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942 + @lazy + export const LN2 = reinterpret(0x3FE62E42FEFA39EF); // 0.69314718055994530942 + // @ts-ignore: decorator - @lazy export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402 + @lazy + export const LN10 = reinterpret(0x40026BB1BBB55516); // 2.30258509299404568402 + // @ts-ignore: decorator - @lazy export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074 + @lazy + export const LOG2E = reinterpret(0x3FF71547652B82FE); // 1.4426950408889634074 + // @ts-ignore: decorator - @lazy export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765 + @lazy + export const LOG10E = reinterpret(0x3FDBCB7B1526E50E); // 0.43429448190325182765 + // @ts-ignore: decorator - @lazy export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846 + @lazy + export const PI = reinterpret(0x400921FB54442D18); // 3.14159265358979323846 + // @ts-ignore: decorator - @lazy export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440 + @lazy + export const SQRT1_2 = reinterpret(0x3FE6A09E667F3BCD); // 0.70710678118654752440 + // @ts-ignore: decorator - @lazy export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880 + @lazy + export const SQRT2 = reinterpret(0x3FF6A09E667F3BCD); // 1.41421356237309504880 // @ts-ignore: decorator @inline export function abs(x: f64): f64 { @@ -360,7 +385,8 @@ export namespace NativeMath { } // @ts-ignore: decorator - @inline export function ceil(x: f64): f64 { + @inline + export function ceil(x: f64): f64 { return builtin_ceil(x); } @@ -511,12 +537,14 @@ export namespace NativeMath { } // @ts-ignore: decorator - @inline export function floor(x: f64): f64 { + @inline + export function floor(x: f64): f64 { return builtin_floor(x); } // @ts-ignore: decorator - @inline export function fround(x: f64): f32 { + @inline + export function fround(x: f64): f32 { return x; } @@ -777,12 +805,14 @@ export namespace NativeMath { } // @ts-ignore: decorator - @inline export function max(value1: f64, value2: f64): f64 { + @inline + export function max(value1: f64, value2: f64): f64 { return builtin_max(value1, value2); } // @ts-ignore: decorator - @inline export function min(value1: f64, value2: f64): f64 { + @inline + export function min(value1: f64, value2: f64): f64 { return builtin_min(value1, value2); } @@ -1011,12 +1041,14 @@ export namespace NativeMath { } // @ts-ignore: decorator - @inline export function round(x: f64): f64 { + @inline + export function round(x: f64): f64 { return builtin_copysign(builtin_floor(x + 0.5), x); } // @ts-ignore: decorator - @inline export function sign(x: f64): f64 { + @inline + export function sign(x: f64): f64 { if (ASC_SHRINK_LEVEL > 0) { return builtin_abs(x) > 0 ? builtin_copysign(1, x) : x; } else { @@ -1025,11 +1057,11 @@ export namespace NativeMath { } // @ts-ignore: decorator - @inline export function signbit(x: f64): bool { + @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 ((reinterpret(x) >>> 63) & (x == x)); + return ((reinterpret(x) >>> 63) & i32(x == x)); } export function sin(x: f64): f64 { // TODO @@ -1056,7 +1088,8 @@ export namespace NativeMath { } // @ts-ignore: decorator - @inline export function sqrt(x: f64): f64 { + @inline + export function sqrt(x: f64): f64 { return builtin_sqrt(x); } @@ -1089,7 +1122,8 @@ export namespace NativeMath { } // @ts-ignore: decorator - @inline export function trunc(x: f64): f64 { + @inline + export function trunc(x: f64): f64 { return builtin_trunc(x); } @@ -1247,9 +1281,12 @@ export namespace NativeMath { } // @ts-ignore: decorator -@lazy var rempio2f_y: f64; +@lazy +var rempio2f_y: f64; + // @ts-ignore: decorator -@lazy const PIO2_TABLE: u64[] = [ +@lazy +const PIO2_TABLE: u64[] = [ 0xA2F9836E4E441529, 0xFC2757D1F534DDC0, 0xDB6295993C439041, @@ -1268,7 +1305,8 @@ function Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3 } // @ts-ignore: decorator -@inline function expo2f(x: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX) +@inline +function expo2f(x: f32): f32 { // exp(x)/2 for x >= log(DBL_MAX) const // see: musl/src/math/__expo2f.c k = 235, kln2 = reinterpret(0x4322E3BC); // 0x1.45c778p+7f @@ -1277,7 +1315,8 @@ function Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3 } // @ts-ignore: decorator -@inline function pio2_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c +@inline +function pio2_large_quot(x: f32, u: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c const coeff = reinterpret(0x3BF921FB54442D18); // π * 0x1p-65 = 8.51530395021638647334e-20 const bits = PIO2_TABLE; @@ -1307,7 +1346,8 @@ function Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3 } // @ts-ignore: decorator -@inline function rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c +@inline +function rempio2f(x: f32, u: u32, sign: i32): i32 { // see: jdh8/metallic/blob/master/src/math/float/rem_pio2f.c const pi2hi = reinterpret(0x3FF921FB50000000); // 1.57079631090164184570 const pi2lo = reinterpret(0x3E5110B4611A6263); // 1.58932547735281966916e-8 const _2_pi = reinterpret(0x3FE45F306DC9C883); // 0.63661977236758134308 @@ -1324,7 +1364,8 @@ function Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3 /* |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]). */ // @ts-ignore: decorator -@inline function sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c +@inline +function sin_kernf(x: f64): f32 { // see: musl/tree/src/math/__sindf.c const S1 = reinterpret(0xBFC5555554CBAC77); // -0x15555554cbac77.0p-55 const S2 = reinterpret(0x3F811110896EFBB2); // 0x111110896efbb2.0p-59 const S3 = reinterpret(0xBF2A00F9E2CAE774); // -0x1a00f9e2cae774.0p-65 @@ -1339,7 +1380,8 @@ function Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3 /* |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]). */ // @ts-ignore: decorator -@inline function cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c +@inline +function cos_kernf(x: f64): f32 { // see: musl/tree/src/math/__cosdf.c const C0 = reinterpret(0xBFDFFFFFFD0C5E81); // -0x1ffffffd0c5e81.0p-54 const C1 = reinterpret(0x3FA55553E1053A42); // 0x155553e1053a42.0p-57 const C2 = reinterpret(0xBF56C087E80F1E27); // -0x16c087e80f1e27.0p-62 @@ -1353,7 +1395,8 @@ function Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3 /* |tan(x)/x - t(x)| < 2**-25.5 (~[-2e-08, 2e-08]). */ // @ts-ignore: decorator -@inline function tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c +@inline +function tan_kernf(x: f64, odd: i32): f32 { // see: musl/tree/src/math/__tandf.c const T0 = reinterpret(0x3FD5554D3418C99F); /* 0x15554d3418c99f.0p-54 */ const T1 = reinterpret(0x3FC112FD38999F72); /* 0x1112fd38999f72.0p-55 */ @@ -1376,30 +1419,48 @@ function Rf(z: f32): f32 { // Rational approximation of (asin(x)-x)/x^3 export namespace NativeMathf { // @ts-ignore: decorator - @lazy export const E = NativeMath.E; - // @ts-ignore: decorator - @lazy export const LN2 = NativeMath.LN2; - // @ts-ignore: decorator - @lazy export const LN10 = NativeMath.LN10; - // @ts-ignore: decorator - @lazy export const LOG2E = NativeMath.LOG2E; - // @ts-ignore: decorator - @lazy export const LOG10E = NativeMath.LOG10E; - // @ts-ignore: decorator - @lazy export const PI = NativeMath.PI; - // @ts-ignore: decorator - @lazy export const SQRT1_2 = NativeMath.SQRT1_2; - // @ts-ignore: decorator - @lazy export const SQRT2 = 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; + @lazy + export const E = NativeMath.E; // @ts-ignore: decorator - @inline export function abs(x: f32): f32 { + @lazy + export const LN2 = NativeMath.LN2; + + // @ts-ignore: decorator + @lazy + export const LN10 = NativeMath.LN10; + + // @ts-ignore: decorator + @lazy + export const LOG2E = NativeMath.LOG2E; + + // @ts-ignore: decorator + @lazy + export const LOG10E = NativeMath.LOG10E; + + // @ts-ignore: decorator + @lazy + export const PI = NativeMath.PI; + + // @ts-ignore: decorator + @lazy + export const SQRT1_2 = NativeMath.SQRT1_2; + + // @ts-ignore: decorator + @lazy + export const SQRT2 = NativeMath.SQRT2; + + // @ts-ignore: decorator + @lazy + export var sincos_sin: f32 = 0; + + // @ts-ignore: decorator + @lazy + export var sincos_cos: f32 = 0; + + // @ts-ignore: decorator + @inline + export function abs(x: f32): f32 { return builtin_abs(x); } @@ -1635,7 +1696,8 @@ export namespace NativeMathf { } // @ts-ignore: decorator - @inline export function ceil(x: f32): f32 { + @inline + export function ceil(x: f32): f32 { return builtin_ceil(x); } @@ -1711,7 +1773,8 @@ export namespace NativeMathf { } // @ts-ignore: decorator - @inline export function floor(x: f32): f32 { + @inline + export function floor(x: f32): f32 { return builtin_floor(x); } @@ -1822,7 +1885,8 @@ export namespace NativeMathf { } // @ts-ignore: decorator - @inline export function fround(x: f32): f32 { + @inline + export function fround(x: f32): f32 { return x; } @@ -1857,7 +1921,8 @@ export namespace NativeMathf { } // @ts-ignore: decorator - @inline export function imul(x: f32, y: f32): f32 { + @inline + export function imul(x: f32, y: f32): f32 { /* * Wasm (MVP) and JS have different approaches for double->int conversions. * @@ -2036,12 +2101,14 @@ export namespace NativeMathf { } // @ts-ignore: decorator - @inline export function max(value1: f32, value2: f32): f32 { + @inline + export function max(value1: f32, value2: f32): f32 { return builtin_max(value1, value2); } // @ts-ignore: decorator - @inline export function min(value1: f32, value2: f32): f32 { + @inline + export function min(value1: f32, value2: f32): f32 { return builtin_min(value1, value2); } @@ -2235,7 +2302,8 @@ export namespace NativeMathf { } // @ts-ignore: decorator - @inline export function seedRandom(value: i64): void { + @inline + export function seedRandom(value: i64): void { NativeMath.seedRandom(value); } @@ -2255,12 +2323,14 @@ export namespace NativeMathf { } // @ts-ignore: decorator - @inline export function round(x: f32): f32 { + @inline + export function round(x: f32): f32 { return builtin_copysign(builtin_floor(x + 0.5), x); } // @ts-ignore: decorator - @inline export function sign(x: f32): f32 { + @inline + export function sign(x: f32): f32 { if (ASC_SHRINK_LEVEL > 0) { return builtin_abs(x) > 0 ? builtin_copysign(1, x) : x; } else { @@ -2269,7 +2339,8 @@ export namespace NativeMathf { } // @ts-ignore: decorator - @inline export function signbit(x: f32): bool { + @inline + export function signbit(x: f32): bool { // @ts-ignore: type return ((reinterpret(x) >>> 31) & (x == x)); } @@ -2335,7 +2406,8 @@ export namespace NativeMathf { } // @ts-ignore: decorator - @inline export function sqrt(x: f32): f32 { + @inline + export function sqrt(x: f32): f32 { return builtin_sqrt(x); } @@ -2404,7 +2476,8 @@ export namespace NativeMathf { } // @ts-ignore: decorator - @inline export function trunc(x: f32): f32 { + @inline + export function trunc(x: f32): f32 { return builtin_trunc(x); } diff --git a/std/assembly/memory.ts b/std/assembly/memory.ts index bd276f03..022cfaed 100644 --- a/std/assembly/memory.ts +++ b/std/assembly/memory.ts @@ -1,47 +1,55 @@ import { memcmp, memmove, memset } from "./util/memory"; // @ts-ignore: decorator -@builtin export declare const HEAP_BASE: usize; +@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; + @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; + @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 { + @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 { + @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 { + @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 { + @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 + @unsafe + export function allocate(size: usize): usize { + // @ts-ignore: stub if (isDefined(__memory_allocate)) return __memory_allocate(size); else ERROR("missing implementation: memory.allocate"); return unreachable(); @@ -49,23 +57,26 @@ export namespace memory { /** Dynamically frees a section of memory by the previously allocated address. */ // @ts-ignore: decorator - @unsafe export function free(ptr: usize): void { - // @ts-ignore: undefined + @unsafe + export function free(ptr: usize): void { + // @ts-ignore: stub 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 + @unsafe + export function reset(): void { + // @ts-ignore: stub 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 { + @unsafe + export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void { var index: usize = 0; var total = srcLength * count; while (index < total) { @@ -76,7 +87,8 @@ export namespace memory { /** Compares a section of memory to another. */ // @ts-ignore: decorator - @inline export function compare(vl: usize, vr: usize, n: usize): i32 { + @inline + export function compare(vl: usize, vr: usize, n: usize): i32 { return memcmp(vl, vr, n); } } diff --git a/std/assembly/number.ts b/std/assembly/number.ts index b44b0654..bc97a3c1 100644 --- a/std/assembly/number.ts +++ b/std/assembly/number.ts @@ -4,9 +4,12 @@ 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; + @lazy + static readonly MIN_VALUE: i8 = i8.MIN_VALUE; + // @ts-ignore: decorator - @lazy static readonly MAX_VALUE: i8 = i8.MAX_VALUE; + @lazy + static readonly MAX_VALUE: i8 = i8.MAX_VALUE; static parseInt(value: string, radix: i32 = 0): i8 { return parseI32(value, radix); @@ -21,9 +24,12 @@ 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; + @lazy + static readonly MIN_VALUE: i16 = i16.MIN_VALUE; + // @ts-ignore: decorator - @lazy static readonly MAX_VALUE: i16 = i16.MAX_VALUE; + @lazy + static readonly MAX_VALUE: i16 = i16.MAX_VALUE; static parseInt(value: string, radix: i32 = 0): i16 { return parseI32(value, radix); @@ -38,9 +44,12 @@ 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; + @lazy + static readonly MIN_VALUE: i32 = i32.MIN_VALUE; + // @ts-ignore: decorator - @lazy static readonly MAX_VALUE: i32 = i32.MAX_VALUE; + @lazy + static readonly MAX_VALUE: i32 = i32.MAX_VALUE; static parseInt(value: string, radix: i32 = 0): i32 { return parseI32(value, radix); @@ -55,9 +64,12 @@ 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; + @lazy + static readonly MIN_VALUE: i64 = i64.MIN_VALUE; + // @ts-ignore: decorator - @lazy static readonly MAX_VALUE: i64 = i64.MAX_VALUE; + @lazy + static readonly MAX_VALUE: i64 = i64.MAX_VALUE; static parseInt(value: string, radix: i32 = 0): i64 { return parseI64(value, radix); @@ -72,9 +84,12 @@ 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; + @lazy + static readonly MIN_VALUE: isize = isize.MIN_VALUE; + // @ts-ignore: decorator - @lazy static readonly MAX_VALUE: isize = isize.MAX_VALUE; + @lazy + static readonly MAX_VALUE: isize = isize.MAX_VALUE; static parseInt(value: string, radix: i32 = 0): isize { return parseI64(value, radix); @@ -89,9 +104,12 @@ 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; + @lazy + static readonly MIN_VALUE: u8 = u8.MIN_VALUE; + // @ts-ignore: decorator - @lazy static readonly MAX_VALUE: u8 = u8.MAX_VALUE; + @lazy + static readonly MAX_VALUE: u8 = u8.MAX_VALUE; static parseInt(value: string, radix: i32 = 0): u8 { return parseI32(value, radix); @@ -106,9 +124,12 @@ 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; + @lazy + static readonly MIN_VALUE: u16 = u16.MIN_VALUE; + // @ts-ignore: decorator - @lazy static readonly MAX_VALUE: u16 = u16.MAX_VALUE; + @lazy + static readonly MAX_VALUE: u16 = u16.MAX_VALUE; static parseInt(value: string, radix: i32 = 0): u16 { return parseI32(value, radix); @@ -123,9 +144,12 @@ 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; + @lazy + static readonly MIN_VALUE: u32 = u32.MIN_VALUE; + // @ts-ignore: decorator - @lazy static readonly MAX_VALUE: u32 = u32.MAX_VALUE; + @lazy + static readonly MAX_VALUE: u32 = u32.MAX_VALUE; static parseInt(value: string, radix: i32 = 0): u32 { return parseI32(value, radix); @@ -140,9 +164,12 @@ 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; + @lazy + static readonly MIN_VALUE: u64 = u64.MIN_VALUE; + // @ts-ignore: decorator - @lazy static readonly MAX_VALUE: u64 = u64.MAX_VALUE; + @lazy + static readonly MAX_VALUE: u64 = u64.MAX_VALUE; static parseInt(value: string, radix: i32 = 0): u64 { return parseI64(value, radix); @@ -157,9 +184,12 @@ 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; + @lazy + static readonly MIN_VALUE: usize = usize.MIN_VALUE; + // @ts-ignore: decorator - @lazy static readonly MAX_VALUE: usize = usize.MAX_VALUE; + @lazy + static readonly MAX_VALUE: usize = usize.MAX_VALUE; static parseInt(value: string, radix: i32 = 0): usize { return parseI64(value, radix); @@ -174,9 +204,12 @@ 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; + @lazy + static readonly MIN_VALUE: bool = bool.MIN_VALUE; + // @ts-ignore: decorator - @lazy static readonly MAX_VALUE: bool = bool.MAX_VALUE; + @lazy + static readonly MAX_VALUE: bool = bool.MAX_VALUE; toString(this: bool): String { // TODO: radix? @@ -189,21 +222,36 @@ export { Bool as Boolean }; @sealed export abstract class F32 { // @ts-ignore: decorator - @lazy static readonly EPSILON: f32 = f32.EPSILON; + @lazy + static readonly EPSILON: f32 = f32.EPSILON; + // @ts-ignore: decorator - @lazy static readonly MIN_VALUE: f32 = f32.MIN_VALUE; + @lazy + static readonly MIN_VALUE: f32 = f32.MIN_VALUE; + // @ts-ignore: decorator - @lazy static readonly MAX_VALUE: f32 = f32.MAX_VALUE; + @lazy + static readonly MAX_VALUE: f32 = f32.MAX_VALUE; + // @ts-ignore: decorator - @lazy static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER; + @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; + @lazy + static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER; + // @ts-ignore: decorator - @lazy static readonly POSITIVE_INFINITY: f32 = Infinity; + @lazy + static readonly POSITIVE_INFINITY: f32 = Infinity; + // @ts-ignore: decorator - @lazy static readonly NEGATIVE_INFINITY: f32 = -Infinity; + @lazy + static readonly NEGATIVE_INFINITY: f32 = -Infinity; + // @ts-ignore: decorator - @lazy static readonly NaN: f32 = NaN; + @lazy + static readonly NaN: f32 = NaN; static isNaN(value: f32): bool { return isNaN(value); @@ -238,21 +286,36 @@ export { Bool as Boolean }; @sealed export abstract class F64 { // @ts-ignore: decorator - @lazy static readonly EPSILON: f64 = f64.EPSILON; + @lazy + static readonly EPSILON: f64 = f64.EPSILON; + // @ts-ignore: decorator - @lazy static readonly MIN_VALUE: f64 = f64.MIN_VALUE; + @lazy + static readonly MIN_VALUE: f64 = f64.MIN_VALUE; + // @ts-ignore: decorator - @lazy static readonly MAX_VALUE: f64 = f64.MAX_VALUE; + @lazy + static readonly MAX_VALUE: f64 = f64.MAX_VALUE; + // @ts-ignore: decorator - @lazy static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER; + @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; + @lazy + static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER; + // @ts-ignore: decorator - @lazy static readonly POSITIVE_INFINITY: f64 = Infinity; + @lazy + static readonly POSITIVE_INFINITY: f64 = Infinity; + // @ts-ignore: decorator - @lazy static readonly NEGATIVE_INFINITY: f64 = -Infinity; + @lazy + static readonly NEGATIVE_INFINITY: f64 = -Infinity; + // @ts-ignore: decorator - @lazy static readonly NaN: f64 = NaN; + @lazy + static readonly NaN: f64 = NaN; static isNaN(value: f64): bool { return builtin_isNaN(value); diff --git a/std/assembly/runtime.ts b/std/assembly/runtime.ts index 721b4198..8c3ab15e 100644 --- a/std/assembly/runtime.ts +++ b/std/assembly/runtime.ts @@ -10,13 +10,15 @@ export namespace runtime { /** Size of a runtime header. */ // @ts-ignore: decorator - @lazy @inline static readonly SIZE: usize = gc.implemented + @lazy @inline + static readonly SIZE: usize = gc.implemented ? (offsetof
( ) + AL_MASK) & ~AL_MASK // full header if GC is present : (offsetof
("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; + @lazy @inline + static readonly MAGIC: u32 = 0xA55E4B17; /** Unique id of the respective class or a magic value if not yet registered.*/ classId: u32; @@ -45,7 +47,8 @@ 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 { + @unsafe + export function allocRaw(payloadSize: u32): usize { var header = changetype
(memory.allocate(adjust(payloadSize))); header.classId = Header.MAGIC; header.payloadSize = payloadSize; @@ -58,7 +61,8 @@ 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 { + @unsafe + export function alloc(payloadSize: u32): usize { var ref = allocRaw(payloadSize); memory.fill(ref, 0, payloadSize); return ref; @@ -66,7 +70,8 @@ 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 { + @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 // the object must be reallocated multiple times because its final size isn't known beforehand, @@ -117,13 +122,15 @@ export namespace runtime { /** Frees an object. Must not have been registered with GC yet. */ // @ts-ignore: decorator - @unsafe @inline export function free(ref: T): void { + @unsafe @inline + export function free(ref: T): void { memory.free(changetype(unref(changetype(ref)))); } /** Registers a managed object. Cannot be free'd anymore afterwards. */ // @ts-ignore: decorator - @unsafe @inline export function register(ref: usize): T { + @unsafe @inline + export function register(ref: usize): T { if (!isReference()) ERROR("reference expected"); // see comment in REALLOC why this is useful. also inline this because // it's generic so we don't get a bunch of functions. @@ -134,7 +141,8 @@ export namespace runtime { /** Links a managed object with its managed parent. */ // @ts-ignore: decorator - @unsafe @inline export function link(ref: T, parentRef: TParent): void { + @unsafe @inline + export function link(ref: T, parentRef: TParent): void { assert(changetype(ref) >= HEAP_BASE + Header.SIZE); // must be a heap object var header = changetype
(changetype(ref) - Header.SIZE); assert(header.classId != Header.MAGIC && header.gc1 != 0 && header.gc2 != 0); // must be registered @@ -145,16 +153,24 @@ export namespace runtime { import { ArrayBuffer } from "./arraybuffer"; export abstract class ArrayBufferView { - @lazy static readonly MAX_BYTELENGTH: i32 = MAX_SIZE_32 - runtime.Header.SIZE; + + // @ts-ignore: decorator + @lazy + static readonly MAX_BYTELENGTH: i32 = MAX_SIZE_32 - runtime.Header.SIZE; [key: number]: number; // @ts-ignore: decorator - @unsafe data: ArrayBuffer; + @unsafe + data: ArrayBuffer; + // @ts-ignore: decorator - @unsafe dataStart: usize; + @unsafe + dataStart: usize; + // @ts-ignore: decorator - @unsafe dataEnd: usize; + @unsafe + dataEnd: usize; constructor(length: i32, alignLog2: i32) { if (length > ArrayBufferView.MAX_BYTELENGTH >>> alignLog2) throw new RangeError("Invalid length"); diff --git a/std/assembly/set.ts b/std/assembly/set.ts index ff8624a9..3874e372 100644 --- a/std/assembly/set.ts +++ b/std/assembly/set.ts @@ -4,11 +4,16 @@ 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; +@inline +const INITIAL_CAPACITY = 4; + // @ts-ignore: decorator -@inline const FILL_FACTOR: f64 = 8 / 3; +@inline +const FILL_FACTOR: f64 = 8 / 3; + // @ts-ignore: decorator -@inline const FREE_FACTOR: f64 = 3 / 4; +@inline +const FREE_FACTOR: f64 = 3 / 4; /** Structure of a set entry. */ @unmanaged class SetEntry { @@ -18,15 +23,18 @@ import { HASH } from "./util/hash"; /** Empty bit. */ // @ts-ignore: decorator -@inline const EMPTY: usize = 1 << 0; +@inline +const EMPTY: usize = 1 << 0; /** Size of a bucket. */ // @ts-ignore: decorator -@inline const BUCKET_SIZE = sizeof(); +@inline +const BUCKET_SIZE = sizeof(); /** Computes the alignment of an entry. */ // @ts-ignore: decorator -@inline function ENTRY_ALIGN(): usize { +@inline +function ENTRY_ALIGN(): usize { // can align to 4 instead of 8 if 32-bit and K is <= 32-bits const align = (sizeof() > sizeof() ? sizeof() : sizeof()) - 1; return align; @@ -34,7 +42,8 @@ import { HASH } from "./util/hash"; /** Computes the aligned size of an entry. */ // @ts-ignore: decorator -@inline function ENTRY_SIZE(): usize { +@inline +function ENTRY_SIZE(): usize { const align = ENTRY_ALIGN(); const size = (offsetof>() + align) & ~align; return size; diff --git a/std/assembly/string.ts b/std/assembly/string.ts index 77a1d24a..520c6bd8 100644 --- a/std/assembly/string.ts +++ b/std/assembly/string.ts @@ -3,8 +3,10 @@ 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(); + @lazy + static readonly MAX_LENGTH: i32 = (MAX_SIZE_32 - runtime.Header.SIZE) >> alignof(); get length(): i32 { return changetype(changetype(this) - runtime.Header.SIZE).payloadSize >> 1; @@ -20,8 +22,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut static fromCodePoint(code: i32): String { assert(code <= 0x10FFFF); var sur = code > 0xFFFF; - // @ts-ignore: type - var out = runtime.allocRaw((sur + 1) << 1); + var out = runtime.allocRaw((i32(sur) + 1) << 1); if (!sur) { store(out, code); } else { @@ -82,7 +83,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 + // @ts-ignore: string <-> String return !compareImpl(this, start, searchString, 0, searchLength); } @@ -91,7 +92,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 + // @ts-ignore: string <-> String return !compareImpl(left, 0, right, 0, leftLength); } @@ -105,7 +106,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut var rightLength = right.length; if (!leftLength) return false; if (!rightLength) return true; - // @ts-ignore: string/String + // @ts-ignore: string <-> String return compareImpl(left, 0, right, 0, min(leftLength, rightLength)) > 0; } @@ -119,7 +120,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut var rightLength = right.length; if (!rightLength) return false; if (!leftLength) return true; - // @ts-ignore: string/String + // @ts-ignore: string <-> String return compareImpl(left, 0, right, 0, min(leftLength, rightLength)) < 0; } @@ -141,7 +142,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut var start = min(max(fromIndex, 0), len); len -= searchLen; for (let k: isize = start; k <= len; ++k) { - // @ts-ignore: string/String + // @ts-ignore: string <-> String if (!compareImpl(this, k, searchString, 0, searchLen)) return k; } return -1; @@ -156,7 +157,7 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut if (!len) return -1; var start = min(max(fromIndex, 0), len - searchLen); for (let k = start; k >= 0; --k) { - // @ts-ignore: string/String + // @ts-ignore: string <-> String if (!compareImpl(this, k, searchString, 0, searchLen)) return k; } return -1; @@ -170,7 +171,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 + // @ts-ignore: string <-> String return !compareImpl(this, start, searchString, 0, searchLength); } @@ -523,17 +524,17 @@ import { compareImpl, parse, CharCode, isWhiteSpaceOrLineTerminator } from "./ut export type string = String; export function parseInt(str: String, radix: i32 = 0): f64 { - // @ts-ignore: string/String + // @ts-ignore: string <-> String return parse(str, radix); } export function parseI32(str: String, radix: i32 = 0): i32 { - // @ts-ignore: string/String + // @ts-ignore: string <-> String return parse(str, radix); } export function parseI64(str: String, radix: i32 = 0): i64 { - // @ts-ignore: string/String + // @ts-ignore: string <-> String return parse(str, radix); } diff --git a/std/assembly/symbol.ts b/std/assembly/symbol.ts index e50325f6..ed5eb766 100644 --- a/std/assembly/symbol.ts +++ b/std/assembly/symbol.ts @@ -4,8 +4,9 @@ import { Map } from "./map"; @lazy var idToString: Map; @lazy var nextId: usize = 12; // Symbol.unscopables + 1 +@unmanaged // @ts-ignore: nolib -@unmanaged export class symbol { +export class symbol { toString(): string { var id = changetype(this); var str = ""; @@ -52,6 +53,8 @@ export namespace Symbol { @lazy export const toStringTag = changetype(10); @lazy export const unscopables = changetype(11); + // FIXME + /* tslint:disable */// not valid TS // @ts-ignore: identifier export function for(key: string): symbol { diff --git a/std/assembly/typedarray.ts b/std/assembly/typedarray.ts index f23c2c9e..ff46d254 100644 --- a/std/assembly/typedarray.ts +++ b/std/assembly/typedarray.ts @@ -6,8 +6,10 @@ function clampToByte(value: i32): i32 { } export class Int8Array extends ArrayBufferView { + // @ts-ignore: decorator - @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof(); + @lazy + static readonly BYTES_PER_ELEMENT: usize = sizeof(); constructor(length: i32) { super(length, alignof()); @@ -69,8 +71,10 @@ export class Int8Array extends ArrayBufferView { } export class Uint8Array extends ArrayBufferView { + // @ts-ignore: decorator - @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof(); + @lazy + static readonly BYTES_PER_ELEMENT: usize = sizeof(); constructor(length: i32) { super(length, alignof()); @@ -126,8 +130,10 @@ export class Uint8Array extends ArrayBufferView { } export class Uint8ClampedArray extends Uint8Array { + // @ts-ignore: decorator - @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof(); + @lazy + static readonly BYTES_PER_ELEMENT: usize = sizeof(); fill(value: u32, start: i32 = 0, end: i32 = i32.MAX_VALUE): Uint8ClampedArray { return changetype(super.fill(value, start, end)); // safe because '.fill' reuses 'this' @@ -177,8 +183,10 @@ export class Uint8ClampedArray extends Uint8Array { } export class Int16Array extends ArrayBufferView { + // @ts-ignore: decorator - @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof(); + @lazy + static readonly BYTES_PER_ELEMENT: usize = sizeof(); constructor(length: i32) { super(length, alignof()); @@ -240,8 +248,10 @@ export class Int16Array extends ArrayBufferView { } export class Uint16Array extends ArrayBufferView { + // @ts-ignore: decorator - @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof(); + @lazy + static readonly BYTES_PER_ELEMENT: usize = sizeof(); constructor(length: i32) { super(length, alignof()); @@ -303,8 +313,10 @@ export class Uint16Array extends ArrayBufferView { } export class Int32Array extends ArrayBufferView { + // @ts-ignore: decorator - @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof(); + @lazy + static readonly BYTES_PER_ELEMENT: usize = sizeof(); constructor(length: i32) { super(length, alignof()); @@ -366,8 +378,10 @@ export class Int32Array extends ArrayBufferView { } export class Uint32Array extends ArrayBufferView { + // @ts-ignore: decorator - @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof(); + @lazy + static readonly BYTES_PER_ELEMENT: usize = sizeof(); constructor(length: i32) { super(length, alignof()); @@ -429,8 +443,10 @@ export class Uint32Array extends ArrayBufferView { } export class Int64Array extends ArrayBufferView { + // @ts-ignore: decorator - @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof(); + @lazy + static readonly BYTES_PER_ELEMENT: usize = sizeof(); constructor(length: i32) { super(length, alignof()); @@ -492,8 +508,10 @@ export class Int64Array extends ArrayBufferView { } export class Uint64Array extends ArrayBufferView { + // @ts-ignore: decorator - @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof(); + @lazy + static readonly BYTES_PER_ELEMENT: usize = sizeof(); constructor(length: i32) { super(length, alignof()); @@ -555,8 +573,10 @@ export class Uint64Array extends ArrayBufferView { } export class Float32Array extends ArrayBufferView { + // @ts-ignore: decorator - @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof(); + @lazy + static readonly BYTES_PER_ELEMENT: usize = sizeof(); constructor(length: i32) { super(length, alignof()); @@ -618,8 +638,10 @@ export class Float32Array extends ArrayBufferView { } export class Float64Array extends ArrayBufferView { + // @ts-ignore: decorator - @lazy static readonly BYTES_PER_ELEMENT: usize = sizeof(); + @lazy + static readonly BYTES_PER_ELEMENT: usize = sizeof(); constructor(length: i32) { super(length, alignof()); @@ -681,7 +703,8 @@ export class Float64Array extends ArrayBufferView { } // @ts-ignore: decorator -@inline function FILL( +@inline +function FILL( array: TArray, value: native, start: i32, @@ -702,7 +725,8 @@ export class Float64Array extends ArrayBufferView { } // @ts-ignore: decorator -@inline function SORT( +@inline +function SORT( array: TArray, comparator: (a: T, b: T) => i32 ): TArray { @@ -723,7 +747,8 @@ export class Float64Array extends ArrayBufferView { } // @ts-ignore: decorator -@inline function SUBARRAY( +@inline +function SUBARRAY( array: TArray, begin: i32, end: i32 @@ -743,7 +768,8 @@ export class Float64Array extends ArrayBufferView { } // @ts-ignore: decorator -@inline function REDUCE( +@inline +function REDUCE( array: TArray, callbackfn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet, initialValue: TRet @@ -756,7 +782,8 @@ export class Float64Array extends ArrayBufferView { } // @ts-ignore: decorator -@inline function REDUCE_RIGHT( +@inline +function REDUCE_RIGHT( array: TArray, callbackfn: (accumulator: TRet, value: T, index: i32, array: TArray) => TRet, initialValue: TRet @@ -769,7 +796,8 @@ export class Float64Array extends ArrayBufferView { } // @ts-ignore: decorator -@inline function MAP( +@inline +function MAP( array: TArray, callbackfn: (value: T, index: i32, self: TArray) => T, ): TArray { @@ -787,7 +815,8 @@ export class Float64Array extends ArrayBufferView { } // @ts-ignore: decorator -@inline function FIND_INDEX( +@inline +function FIND_INDEX( array: TArray, callbackfn: (value: T, index: i32, array: TArray) => bool, ): i32 { @@ -799,7 +828,8 @@ export class Float64Array extends ArrayBufferView { } // @ts-ignore: decorator -@inline function SOME( +@inline +function SOME( array: TArray, callbackfn: (value: T, index: i32, array: TArray) => bool, ): bool { @@ -811,7 +841,8 @@ export class Float64Array extends ArrayBufferView { } // @ts-ignore: decorator -@inline function EVERY( +@inline +function EVERY( array: TArray, callbackfn: (value: T, index: i32, array: TArray) => bool, ): bool { @@ -824,7 +855,8 @@ export class Float64Array extends ArrayBufferView { } // @ts-ignore: decorator -@inline function FOREACH( +@inline +function FOREACH( array: TArray, callbackfn: (value: T, index: i32, array: TArray) => void, ): void { diff --git a/std/assembly/util/allocator.ts b/std/assembly/util/allocator.ts index af722401..c0c2fdbe 100644 --- a/std/assembly/util/allocator.ts +++ b/std/assembly/util/allocator.ts @@ -1,15 +1,19 @@ /** Number of alignment bits. */ // @ts-ignore: decorator -@inline export const AL_BITS: u32 = 3; +@inline +export const AL_BITS: u32 = 3; /** Number of possible alignment values. */ // @ts-ignore: decorator -@inline export const AL_SIZE: usize = 1 << AL_BITS; +@inline +export const AL_SIZE: usize = 1 << AL_BITS; /** Mask to obtain just the alignment bits. */ // @ts-ignore: decorator -@inline export const AL_MASK: usize = AL_SIZE - 1; +@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 +@inline +export const MAX_SIZE_32: usize = 1 << 30; // 1GB diff --git a/std/assembly/util/hash.ts b/std/assembly/util/hash.ts index 86a3d92a..d8d131d2 100644 --- a/std/assembly/util/hash.ts +++ b/std/assembly/util/hash.ts @@ -1,35 +1,32 @@ // @ts-ignore: decorator -@inline export function HASH(key: T): u32 { +@inline +export function HASH(key: T): u32 { if (isString(key)) { - // @ts-ignore: type - return hashStr(key); + return hashStr(changetype(key)); } else if (isReference()) { if (sizeof() == 4) return hash32(changetype(key)); if (sizeof() == 8) return hash64(changetype(key)); } else if (isFloat()) { - // @ts-ignore: type - if (sizeof() == 4) return hash32(reinterpret(key)); - // @ts-ignore: type - if (sizeof() == 8) return hash64(reinterpret(key)); + if (sizeof() == 4) return hash32(reinterpret(f32(key))); + if (sizeof() == 8) return hash64(reinterpret(f64(key))); } else { - // @ts-ignore: type - if (sizeof() == 1) return hash8 (key); - // @ts-ignore: type - if (sizeof() == 2) return hash16(key); - // @ts-ignore: type - if (sizeof() == 4) return hash32(key); - // @ts-ignore: type - if (sizeof() == 8) return hash64(key); + if (sizeof() == 1) return hash8 (u32(key)); + if (sizeof() == 2) return hash16(u32(key)); + if (sizeof() == 4) return hash32(u32(key)); + if (sizeof() == 8) return hash64(u64(key)); } - unreachable(); + return unreachable(); } // 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; +@inline +const FNV_OFFSET: u32 = 2166136261; + // @ts-ignore: decorator -@inline const FNV_PRIME: u32 = 16777619; +@inline +const FNV_PRIME: u32 = 16777619; function hash8(key: u32): u32 { return (FNV_OFFSET ^ key) * FNV_PRIME; diff --git a/std/assembly/util/number.ts b/std/assembly/util/number.ts index 48bb41b4..9940518c 100644 --- a/std/assembly/util/number.ts +++ b/std/assembly/util/number.ts @@ -2,10 +2,12 @@ import { runtime } from "../runtime"; import { CharCode } from "./string"; // @ts-ignore: decorator -@inline export const MAX_DOUBLE_LENGTH = 28; +@inline +export const MAX_DOUBLE_LENGTH = 28; // @ts-ignore: decorator -@lazy @inline const POWERS10: u32[] = [ +@lazy @inline +const POWERS10: u32[] = [ 1, 10, 100, @@ -33,7 +35,8 @@ import { CharCode } from "./string"; "90", "91", "92", "93", "94", "95", "96", "97", "98", "99" */ // @ts-ignore: decorator -@lazy @inline const DIGITS: u32[] = [ +@lazy @inline +const DIGITS: u32[] = [ 0x00300030, 0x00310030, 0x00320030, 0x00330030, 0x00340030, 0x00350030, 0x00360030, 0x00370030, 0x00380030, 0x00390030, 0x00300031, 0x00310031, 0x00320031, 0x00330031, 0x00340031, @@ -57,7 +60,8 @@ import { CharCode } from "./string"; ]; // @ts-ignore: decorator -@lazy @inline const EXP_POWERS: i16[] = [ +@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, -688, -661, -635, -608, -582, -555, -529, -502, -475, -449, @@ -71,7 +75,8 @@ import { CharCode } from "./string"; // 1e-348, 1e-340, ..., 1e340 // @ts-ignore: decorator -@lazy @inline const FRC_POWERS: u64[] = [ +@lazy @inline +const FRC_POWERS: u64[] = [ 0xFA8FD5A0081C0288, 0xBAAEE17FA23EBF76, 0x8B16FB203055AC76, 0xCF42894A5DCE35EA, 0x9A6BB0AA55653B2D, 0xE61ACF033D1A45DF, 0xAB70FE17C79AC6CA, 0xFF77B1FCBEBCDC4F, 0xBE5691EF416BD60C, 0x8DD01FAD907FFC3C, 0xD3515C2831559A83, 0x9D71AC8FADA6C9B5, @@ -105,7 +110,7 @@ export function decimalCount32(value: u32): u32 { let lutbuf = POWERS10.buffer_; let power = LOAD(lutbuf, t); - t -= (value < power); + t -= u32(value < power); return t + 1; } else { if (value < 100000) { @@ -135,7 +140,7 @@ export function decimalCount64(value: u64): u32 { let lutbuf = POWERS10.buffer_; let power = LOAD(lutbuf, t - 10); - t -= (value < 10000000000 * power); + t -= u32(value < 10000000000 * power); return t + 1; } else { if (value < 1000000000000000) { diff --git a/std/assembly/util/sort.ts b/std/assembly/util/sort.ts index 6604972d..528c9864 100644 --- a/std/assembly/util/sort.ts +++ b/std/assembly/util/sort.ts @@ -1,60 +1,50 @@ import { compareImpl } from "./string"; // @ts-ignore: decorator -@inline export function COMPARATOR(): (a: T, b: T) => i32 { +@inline +export function COMPARATOR(): (a: T, b: T) => i32 { if (isInteger()) { if (isSigned() && sizeof() <= 4) { - // @ts-ignore: type - return (a: T, b: T): i32 => ((a - b)); + return (a: T, b: T): i32 => (i32(a) - i32(b)); } else { - // @ts-ignore: type - return (a: T, b: T): i32 => ((a > b) - (a < b)); + return (a: T, b: T): i32 => (i32(a > b) - i32(a < b)); } } else if (isFloat()) { if (sizeof() == 4) { return (a: T, b: T): i32 => { - // @ts-ignore: type - var ia = reinterpret(a); - // @ts-ignore: type - var ib = reinterpret(b); + var ia = reinterpret(f32(a)); + var ib = reinterpret(f32(b)); ia ^= (ia >> 31) >>> 1; ib ^= (ib >> 31) >>> 1; - // @ts-ignore: type - return (ia > ib) - (ia < ib); + return i32(ia > ib) - i32(ia < ib); }; } else { return (a: T, b: T): i32 => { - // @ts-ignore: type - var ia = reinterpret(a); - // @ts-ignore: type - var ib = reinterpret(b); + var ia = reinterpret(f64(a)); + var ib = reinterpret(f64(b)); ia ^= (ia >> 63) >>> 1; ib ^= (ib >> 63) >>> 1; - // @ts-ignore: type - return (ia > ib) - (ia < ib); + return i32(ia > ib) - i32(ia < ib); }; } } else if (isString()) { return (a: T, b: T): i32 => { if (a === b || a === null || b === null) return 0; - // @ts-ignore: type - var alen = (a).length; - // @ts-ignore: type - var blen = (b).length; + var alen = changetype(a).length; + var blen = changetype(b).length; if (!alen && !blen) return 0; if (!alen) return -1; if (!blen) return 1; - // @ts-ignore: type - return compareImpl(a, 0, b, 0, min(alen, blen)); + return compareImpl(changetype(a), 0, changetype(b), 0, min(alen, blen)); }; } else { - // @ts-ignore: type - return (a: T, b: T): i32 => ((a > b) - (a < b)); + return (a: T, b: T): i32 => (i32(a > b) - i32(a < b)); } } // @ts-ignore: decorator -@inline export function SORT( +@inline +export function SORT( dataStart: usize, length: i32, comparator: (a: T, b: T) => i32 diff --git a/std/assembly/util/string.ts b/std/assembly/util/string.ts index 49579ef6..e9d3a2d7 100644 --- a/std/assembly/util/string.ts +++ b/std/assembly/util/string.ts @@ -9,7 +9,8 @@ export function compareImpl(str1: string, index1: usize, str2: string, index2: u } // @ts-ignore: decorator -@inline export const enum CharCode { +@inline +export const enum CharCode { PLUS = 0x2B, MINUS = 0x2D, DOT = 0x2E, @@ -58,7 +59,7 @@ export function isWhiteSpaceOrLineTerminator(c: u16): bool { /** Parses a string to an integer (usually), using the specified radix. */ export function parse(str: string, radix: i32 = 0): T { var len: i32 = str.length; - // @ts-ignore: type + // @ts-ignore: cast if (!len) return NaN; var ptr = changetype(str) /* + HEAD -> offset */; @@ -67,13 +68,13 @@ export function parse(str: string, radix: i32 = 0): T { // determine sign var sign: T; if (code == CharCode.MINUS) { - // @ts-ignore: type + // @ts-ignore: cast if (!--len) return NaN; code = load(ptr += 2); // @ts-ignore: type sign = -1; } else if (code == CharCode.PLUS) { - // @ts-ignore: type + // @ts-ignore: cast if (!--len) return NaN; code = load(ptr += 2); // @ts-ignore: type