memory.ts

import{memcmp,memmove,memset}from"./util/memory";
import{E_NOTIMPLEMENTED}from"./util/error";

/** Memory manager interface. */
exportnamespacememory{

/** Gets the size of the memory in pages. */
// @ts-ignore: decorator
 @builtin
exportdeclarefunctionsize(): i32;

/** Grows the memory by the given size in pages and returns the previous size in pages. */
// @ts-ignore: decorator
 @unsafe @builtin
exportdeclarefunctiongrow(pages: i32): i32;

/** Fills a section in memory with the specified byte value. */
// @ts-ignore: decorator
 @unsafe @builtin
exportfunctionfill(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
exportfunctioncopy(dst: usize,src: usize,n: usize): void{
memmove(dst,src,n);// fallback if "bulk-memory" isn't enabled
}

exportnamespaceatomic{

// @ts-ignore: decorator
 @unsafe @builtin
exportdeclarefunctionwait32(ptr: usize,expected: i32,timeout: i64): AtomicWaitResult;

// @ts-ignore: decorator
 @unsafe @builtin
exportdeclarefunctionwait64(ptr: usize,expected: i64,timeout: i64): AtomicWaitResult;
}

/** Initializes a memory segment. */
// @ts-ignore: decorator
 @unsafe
exportfunctioninit(segmentIndex: u32,srcOffset: usize,dstOffset: usize,n: usize): void{
thrownewError(E_NOTIMPLEMENTED);
}

/** Drops a memory segment. */
// @ts-ignore: decorator
 @unsafe
exportfunctiondrop(segmentIndex: u32): void{
thrownewError(E_NOTIMPLEMENTED);
}

/** Repeats a section of memory at a specific address. */
// @ts-ignore: decorator
 @unsafe
exportfunctionrepeat(dst: usize,src: usize,srcLength: usize,count: usize): void{
letindex: usize=0;
lettotal=srcLength*count;
while(index<total){
memory.copy(dst+index,src,srcLength);
index+=srcLength;
}
}

/** Compares a section of memory to another. */
// @ts-ignore: decorator
 @inline
exportfunctioncompare(vl: usize,vr: usize,n: usize): i32{
returnmemcmp(vl,vr,n);
}

/** Gets a pointer to a static chunk of memory of the given size. */
// @ts-ignore: decorator
 @builtin
exportdeclarefunctiondata<T>(size: T,align?: i32): usize;
}

// @ts-ignore: decorator
@builtin
exportdeclareconst__data_end: usize;

// @ts-ignore: decorator
@builtin
exportdeclarelet__stack_pointer: usize;

// @ts-ignore: decorator
@builtin
exportdeclareconst__heap_base: usize;

/** Heap memory interface. */
exportnamespaceheap{

/** Allocates a chunk of memory of at least the specified size. */
// @ts-ignore: decorator
 @unsafeexportfunctionalloc(size: usize): usize{
return__alloc(size);
}

/** Reallocates a chunk of memory to have at least the specified size. */
// @ts-ignore: decorator
 @unsafeexportfunctionrealloc(ptr: usize,size: usize): usize{
return__realloc(ptr,size);
}

/** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */
// @ts-ignore: decorator
 @unsafeexportfunctionfree(ptr: usize): void{
__free(ptr);
}

/** Dangerously resets the entire heap. Specific to the stub runtime. */
// @ts-ignore: decorator
 @unsafeexportfunctionreset(): void{
if(isDefined(__reset)){
__reset();
}else{
thrownewError(E_NOTIMPLEMENTED);
}
}
}