fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-05-28 23:21:26 +00:00
Code Issues Projects Releases Wiki Activity

I'm lost

Browse Source
This commit is contained in:
dcode 2019-03-12 02:14:30 +01:00
parent 146dfdbb4a
commit 8e9586783f
3 changed files with 69 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
std/assembly/arraybuffer.ts
View File

@ -5,45 +5,48 @@ import {
} from "./runtime";
import {
Uint8ClampedArray,
Uint8Array,
Int8Array,
Uint16Array,
Uint8Array,
Uint8ClampedArray,
Int16Array,
Uint32Array,
Uint16Array,
Int32Array,
Uint32Array,
Int64Array,
Uint64Array,
Int64Array
Float32Array,
Float64Array
} from "./typedarray";
import {
DataView
} from "./dataview";
@sealed
export class ArrayBuffer extends ArrayBufferBase {
@sealed export class ArrayBuffer extends ArrayBufferBase {
@inline static isView<T>(value: T): bool {
if (value === null) return false;
if (value instanceof Uint8ClampedArray) return true;
if (value instanceof Uint8Array) return true;
if (value instanceof Int8Array) return true;
if (value instanceof Uint16Array) return true;
if (value instanceof Int16Array) return true;
if (value instanceof Uint32Array) return true;
if (value instanceof Int32Array) return true;
if (value instanceof Uint64Array) return true;
if (value instanceof Int64Array) return true;
if (value instanceof DataView) return true;
if (value) {
if (value instanceof Int8Array) return true;
if (value instanceof Uint8Array) return true;
if (value instanceof Uint8ClampedArray) return true;
if (value instanceof Int16Array) return true;
if (value instanceof Uint16Array) return true;
if (value instanceof Int32Array) return true;
if (value instanceof Uint32Array) return true;
if (value instanceof Int64Array) return true;
if (value instanceof Uint64Array) return true;
if (value instanceof Float32Array) return true;
if (value instanceof Float64Array) return true;
if (value instanceof DataView) return true;
}
return false;
}
slice(begin: i32 = 0, end: i32 = ArrayBuffer.MAX_BYTELENGTH): ArrayBuffer {
var len = this.byteLength;
begin = begin < 0 ? max(len + begin, 0) : min(begin, len);
end = end < 0 ? max(len + end, 0) : min(end, len);
len = max(end - begin, 0);
var outSize = <usize>len;
var length = this.byteLength;
begin = begin < 0 ? max(length + begin, 0) : min(begin, length);
end = end < 0 ? max(length + end , 0) : min(end , length);
var outSize = <usize>max(end - begin, 0);
var out = ALLOC_RAW(outSize);
memory.copy(out, changetype<usize>(this) + <usize>begin, outSize);
return REGISTER<ArrayBuffer>(out);

8
std/assembly/internal/typedarray.ts
View File

@ -1,5 +1,5 @@
import {
ALLOC,
ALLOC_RAW,
REGISTER,
LINK
} from "../runtime";
@ -109,11 +109,13 @@ export abstract class TypedArray<T> {
else begin = min(begin, length);
if (end < 0) end = max(length + end, begin);
else end = max(min(end, length), begin);
var out = ALLOC(offsetof<TArray>());
var out = ALLOC_RAW(offsetof<TArray>());
store<usize>(out, buffer, offsetof<TArray>("buffer"));
store<usize>(out, buffer + (<usize>begin << alignof<T>()), offsetof<TArray>("dataStart"));
store<usize>(out, buffer + (<usize>end << alignof<T>()), offsetof<TArray>("dataStart"));
store<i32>(out, <i32>array.byteOffset + (begin << alignof<T>()), offsetof<TArray>("byteOffset"));
store<i32>(out, (end - begin) << alignof<T>(), offsetof<TArray>("byteLength"));
LINK(buffer, REGISTER<TArray,usize>(out)); // register first, then link
LINK(buffer, REGISTER<TArray>(out)); // register first, then link
return changetype<TArray>(out);
}

61
std/assembly/runtime.ts
View File

@ -113,17 +113,18 @@ function unref(ref: usize): HEADER {
}
/** Frees an object. Must not have been registered with GC yet. */
@unsafe export function FREE(ref: usize): void {
memory.free(changetype<usize>(unref(ref)));
@unsafe @inline export function FREE<T>(ref: T): void {
memory.free(changetype<usize>(unref(changetype<usize>(ref))));
}
/** Registers a managed object. Cannot be free'd anymore afterwards. */
@unsafe @inline export function REGISTER<T,TRet = T>(ref: usize): TRet {
@unsafe @inline export function REGISTER<T>(ref: usize): T {
if (!isReference<T>()) ERROR("reference expected");
// see comment in REALLOC why this is useful. also inline this because
// it's generic so we don't get a bunch of functions.
unref(ref).classId = gc.classId<T>();
if (GC) gc.register(ref);
return changetype<TRet>(ref);
return changetype<T>(ref);
}
/** Links a managed object with its managed parent. */
@ -134,51 +135,51 @@ function unref(ref: usize): HEADER {
if (GC) gc.link(changetype<usize>(ref), changetype<usize>(parentRef)); // tslint:disable-line
}
/** ArrayBuffer base class. */
export abstract class ArrayBufferBase {
@lazy static readonly MAX_BYTELENGTH: i32 = MAX_SIZE_32 - HEADER_SIZE;
get byteLength(): i32 {
return changetype<HEADER>(changetype<usize>(this) - HEADER_SIZE).payloadSize;
}
constructor(length: i32) {
if (<u32>length > <u32>ArrayBufferBase.MAX_BYTELENGTH) throw new RangeError("Invalid array buffer length");
return REGISTER<ArrayBuffer>(ALLOC(<usize>length));
}
get byteLength(): i32 {
return changetype<HEADER>(changetype<usize>(this) - HEADER_SIZE).payloadSize;
}
}
/** Typed array base class. */
export abstract class ArrayBufferView {
[key: number]: number;
@unsafe buffer: ArrayBuffer;
@unsafe dataStart: usize;
@unsafe dataEnd: usize;
protected data: ArrayBuffer;
protected dataStart: usize;
protected dataEnd: usize;
constructor(length: i32, alignLog2: i32) {
if (<u32>length > <u32>ArrayBufferBase.MAX_BYTELENGTH >>> alignLog2) throw new RangeError("Invalid length");
var byteLength = length << alignLog2;
var buffer = new ArrayBuffer(byteLength);
this.buffer = buffer;
this.data = buffer;
this.dataStart = changetype<usize>(buffer);
this.dataEnd = changetype<usize>(buffer) + length;
}
get buffer(): ArrayBuffer {
return this.data;
}
get byteOffset(): i32 {
return this.dataStart - changetype<usize>(this.buffer);
return <i32>(this.dataStart - changetype<usize>(this.data));
}
get byteLength(): i32 {
return this.dataEnd - this.dataStart;
}
get length(): i32 {
return <i32>unreachable();
return <i32>(this.dataEnd - this.dataStart);
}
}
/** String base class. */
export abstract class StringBase {
@lazy static readonly MAX_LENGTH: i32 = (MAX_SIZE_32 - HEADER_SIZE) >> 1;
get length(): i32 {
return changetype<HEADER>(changetype<usize>(this) - HEADER_SIZE).payloadSize >> 1;
}
@ -186,35 +187,44 @@ export abstract class StringBase {
import { memcmp, memmove, memset } from "./internal/memory";
/** Memory manager interface. */
export namespace memory {
@builtin export declare function size(): i32;
@builtin @unsafe export declare function grow(pages: i32): i32;
@builtin @unsafe @inline export function fill(dst: usize, c: u8, n: usize): void {
memset(dst, c, n); // fallback if "bulk-memory" isn't enabled
}
@builtin @unsafe @inline export function copy(dst: usize, src: usize, n: usize): void {
memmove(dst, src, n); // fallback if "bulk-memory" isn't enabled
}
@unsafe export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {
ERROR("not implemented");
}
@unsafe export function drop(segmentIndex: u32): void {
ERROR("not implemented");
}
@stub @inline export function allocate(size: usize): usize {
ERROR("stub: missing memory manager");
return <usize>unreachable();
}
@stub @unsafe @inline export function free(ptr: usize): void {
ERROR("stub: missing memory manager");
}
@stub @unsafe @inline export function reset(): void {
ERROR("stub: not supported by memory manager");
}
@inline export function compare(vl: usize, vr: usize, n: usize): i32 {
return memcmp(vl, vr, n);
}
@unsafe export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {
var index: usize = 0;
var total = srcLength * count;
@ -225,15 +235,20 @@ export namespace memory {
}
}
/** Garbage collector interface. */
export namespace gc {
@builtin @unsafe export declare function classId<T>(): u32;
@builtin @unsafe export declare function iterateRoots(fn: (ref: usize) => void): void;
@stub @unsafe export function register(ref: usize): void {
ERROR("stub: missing garbage collector");
}
@stub @unsafe export function link(ref: usize, parentRef: usize): void {
ERROR("stub: missing garbage collector");
}
@stub export function collect(): void {}
@stub export function collect(): void {
WARNING("stub: missing garbage collector");
}
}