+ started working on the SysUtils unit for the WASI platform

+ enabled compilation of unit math for the WASI target

+ added classes unit for the WASI target (not yet enabled in the makefiles)

+ added tthread.inc rtl include file for WASI

+ compile the unit dos (OS-specific functions are dummies for now) for the WASI target

* enumerate preopened dirs on startup and store them in a list, accessible via global vars in the system unit

+ initial implementation of GetDir() for WASI

+ keep also the fds for the current dirs

+ initial implementation of resolving relative paths

+ implemented MkDir for the WASI target

+ implemented RmDir for the WASI target

+ implemented Erase() for the WASI target

+ implemented do_truncate for the WASI target

+ implemented Do_FilePos for the WASI target

+ implemented Do_FileSize for the WASI target

+ implemented Do_Seek and Do_Seekend for the WASI target

+ implemented Do_Rename for the WASI target

+ also resolve absolute paths in ConvertToFdRelativePath

+ initial WASI implementation of DOS.GetFTime. Not working yet, due to a
compiler bug, related to the import of fd_filestat_get from the wasiapi unit.

* also set doserror to 5 for access denied in dos.getfattr

+ request the FD_FILESTAT_GET capability when opening files

* fixed date calculation in WasiDateToDT

+ workaround for newer wasmtime versions that don't report the fd type of
stdin/stdout/stderr. Always assume handles 0..2 are a device, so that
standard input and output are flushed.

+ request fd_seek and fd_tell rights when opening a file

+ request the rights to set size (truncate) and set times, when a file is opened for writing

+ request fd_allocate rights when opening a file for writing

* changed the formatting of the setting of fs_rights_base in Do_Open. No functional changes.

+ request FD_DATASYNC and FD_SYNC rights when a file is opened for writing

+ always request FD_FDSTAT_SET_FLAGS rights

+ always request FD_ADVISE rights, when opening a file

+ always request pollfd_readwrite rights, when opening a file

+ implemented Randomize

+ implemented environment variables support in the DOS unit for the WASI target

+ started working on DOS.FindFirst

+ initial working implementation of FindFirst/FindNext

* use -1 instead of 0 for indicating empty DirFD

+ added except_native.inc include file (empty for now, but will provide RTL
support for the native wasm exceptions in the future)

+ RTL support for raising exceptions in native wasm exceptions mode

* don't include except.inc if wasm32 native exception is turned on, instead
replace it with except_native.inc

* longjmp in fpc_reraise changed to a throw instruction intrinsic in wasm native exceptions mode

+ implemented GetDate, GetTime and WeekDay in the WASI dos unit. They return
UTC time (I don't know how to obtain the local time zone from within WASI).

* always return error in SysUtils.FindFirst and .FindNext on the WASI platform,
in order to prevent infinite loops in tests

* instead of using the 'throw' intrinsic, set a boolean flag, in the branchful
exceptions support code

- removed commented out code from the WASI startup code

+ added unhandled exception handling code for the branchful exceptions mode

+ return a small, fake backtrace for WebAssembly, so that in case of a runtime
error, the message 'Runtime error XXX at $EEEEEEEE' appears.

+ default exception handling in WebAssembly native exceptions mode

+ implemented GetMsCount in the DOS unit for WASI

+ implemented SysUtils.GetTickCount64 for WASI

+ implemented SysUtils.Sleep for WASI

+ implemented SysUtils.GetEnvironmentVariable, GetEnvironmentVariableCount and
GetEnvironmentString for WASI

* preopened dirs structure in the system unit modified to be a pointer to an
array of records

* preopen fd names and current dir changed to use ansistring, as well as the
parameters and result of ConvertToFdRelativePath. This will allow easier
implementation of ChDir.

* fixed handling of relative paths that are not directly relative to a preopened
dir in ConvertToFdRelativePath. This is a preparation for ChDir support.

+ implemented ChDir() for WASI

- removed the DebugWriteXXX functions from the WASI system unit, since console
output is now quite stable and can be used for debugging

* moved the preopened dir and current dir handling types and variables to the
implementation part of the system unit, so their implementation is not exposed
and can be changed in the future (e.g. for thread safety when WebAssembly
gets multithreading support, etc.)

* keep the drive string separate in the preopen and the current dir records on
the WASI platform

* replaced ['/','\'] with AllowDirectorySeparators in the WASI directory
parsing code

* replaced '/' with DirectorySeparator in the WASI directory parsing code

* another instance of ['/','\'] replaced with AllowDirectorySeparators

* use AllowDirectorySeparators, instead of checking for '/' and '\'

* use rawbytestring instead of ansistring for the WASI file name handling

+ implemented SysUtils.FileClose for WASI

+ implemented SysUtils.FileOpen for WASI

+ implemented SysUtils.FileCreate for WASI

- removed the zero constants from the implementation of SysUtils.FileOpen for WASI

+ implemented SysUtils.FileRead for WASI

* fixed WASI bug in do_read, where the result of the __wasi_fd_read syscall function was ignored

+ implemented SysUtils.FileWrite for WASI

+ implemented SysUtils.FileSeek for WASI

+ implemented SysUtils.RenameFile for WASI

- don't call ToSingleByteFileSystemEncodedFileName in SysUtils.FileOpen and
.FileCreate, because ConvertToFdRelativePath already calls it

+ implemented SysUtils.DeleteFile for WASI

+ implemented SysUtils.FileAge for WASI

+ implemented SysUtils.FileSetDate for WASI

+ also implemented FileSetDate(FileName) for WASI, via the __wasi_path_filestat_set_times API call

* fixed off-by-one error when initializing current_drive in the WASI system unit

* fixed range check error in HasDriveLetter when path is 1 character long

+ implemented SysUtils.FileExists for WASI

* don't set InOutRes in ConvertToFdRelativePath, but return it instead. This
fixes issues in places where this function is used in a way that should not
set IOResult.

+ implemented SysUtils.DirectoryExists for WASI

+ implemented SysUtils.FileGetSymLinkTarget for WASI

* always return an error in SysUtils.FileSetAttr on WASI - this function is not supported by the WASI API

+ implemented SysUtils.FileGetAttr for WASI

+ dummy implementation of dos.SetFAttr for WASI, based on the Unix version

+ implemented DOS.GetFAttr for WASI

+ added platform-specific helper function dos.DTToWasiDate, similar to
DTToUnixDate on Unix

+ implemented dos.SetFTime for WASI

* fix for the WASI datetime to epoch conversion

+ implemented SysUtils.GetLocalTime for WASI

+ init the ansistring upper and lower case tables in the WASI SysUtils unit initialization

+ added a wrapper function around __wasi_path_readlink that calls it iteratively
with doubling buffer sizes, starting with 64 bytes, until it reaches 16384
bytes, and reads the link into a rawbytestring. Use that function in all
places in the WASI rtl that need to read a symlink.

* ConvertToFdRelativePath removed from the interface part of the WASI system
unit (to avoid cluttering the WASI system unit interface with platform
dependent routines) and added to a new unit, called wasiutil

* added the fpc_wasi_path_readlink_ansistring helper function to unit wasiutil

* the FNMatch private helper function moved from unit DOS to unit WasiUtil, and
changed to have rawbytestring parameters, so it can be used from SysUtils as
well.

- removed unused, commented out fields from the RtlInfoType record

- removed the RtlInfoType record, because it is only used only once in a local
variable. Use an anonymous record instead.

* moved the FindFirst/FindNext/FindClose code from unit DOS to WasiUtil, using
RawByteString. This will allow to reuse the same implementation in SysUtils.

+ implemented DOS.FSearch for WASI

- removed TWasiSearchRec.Mode, because it was unused

* fixed range check error in the DOS unit

* Wasmtime support

* Add linking examples, change pcchar to pchar

+ define USE_NOTHREADMANAGER in the WASI system unit

* Export wasiAlloc and wasiFree

* fixes to the WebAssembly atomic function intrinsics

+ implemented InterlockedIncrement, InterlockedDecrement, InterlockedExchange,
InterlockedCompareExchange and InterlockedExchangeAdd for WebAssembly in a
thread safe way, using the thread and atomics extension, when the RTL is
compiled with -dFPC_WASM_THREADS

* patch from Pierre for working around the exitcode <= 125 limitation in wasmtime

+ added unit WebAssembly for WebAssembly-specific stuff. Currently contains
the AtomicFence intrinsic, which emits the atomic.fence instruction.

+ added AtomicAdd() and AtomicSub() intrinsics to the WebAssembly unit

+ added AtomicAnd(), AtomicOr() and AtomicXor() to the WebAssembly unit

+ added AtomicExchange() to the WebAssembly unit

+ added AtomicCompareExchange() to the WebAssembly unit

+ added AtomicLoad() to the WebAssembly unit

+ added AtomicStore() to the WebAssembly unit

+ added AtomicWait() to the WebAssembly unit

+ added AtomicNotify() to the WebAssembly unit

* AtomicWait marked as inline

* Export wasiAlloc, wasiFree

* added non-atomic implementations of the atomic operations in the WebAssembly unit, used when the RTL is compiled without -CTwasmthreads

* Correct windows DLL name

+ print more exceptions debug info, when the WebAssembly RTL is compiled with -dEXCDEBUG

* refactored duplicated code for epoch to datetime and vice versa conversion
between the dos and sysutils units for the WASI platform

+ setup a thread manager (functions are still not yet implemented), when the WASI RTL is compiled with multithreading support

* Wasm Threads (WIP)

* Comment out debug in loop

* Fix compilation without threads

* Char -> AnsiChar

* string -> shortstring

* Remove PChar/PPChar/PPPChar defines, they are in the system unit

* PChar -> PAnsiChar

* Dotted filenames for package wasmtime

* since exporting webassembly globals doesn't yet work accross units, added a
workaround by using property getters and setters

+ added promising _start and _initialize exports

* WasmEdge library import

* Git did not add .lst files

* Fix compilation in unicode rtl

* Correctly load library, make this public

* Adjust wasmtime interface to latest version

* Enable monitor support

* Add wasm-job for webassembly

* not automatically committed...

* Sample unit containing all browser apis

* Add create_object method

* Remove unqualified string type, use UTF8 string or Unicode string

* Create objects directly

* Constructor

* More complete example with dictionaries as objects

* Add TypedArray constructor

* New type of argument

* Fix memleak, objects created directly are owned by webassembly

* set method for typed array

* Add length

* Global memory object

* Add constructor to TJSArray that accepts array of const

* Promise implementation and demo

* Make methods protected, so one can override

* Allow to cache reject/resolve

* Getters & Setters for typed arrays

* Corrections for Float64

* Forgot to commit last version: allow to use thisid from function

* Hosting example for webassembly module

* Corrections from samples

* Fetch example, demo how to reconstruct object response

* Implement TJSArrayBuffer

* Define JSJSON to as to use static methods

* in the WASI system unit initialization, call InitSystemThreads even if
FPC_WASM_THREADS is not defined (but FPC_HAS_FEATURE_THREADING is defined),
to initialize the nothread manager. This fixes various regressions when WASI
threading is disabled, caused by calls to nil pointer functions.

* Add new constructor for typed array with length

* revert method property

* Correct Cast class functions which were recursively calling themselves instead of JOBCreate

* Add some utility properties

* use an empty TThread implementation in rtl/wasi/tthread.inc, in case
FPC_WASM_THREADS is not defined

* Add Error.Message

* NativeInt size depends on platform.

* Use Int32 for index

* Implement DataView

* Implement DataView properties

* Redefine (T|I)JSArrayBufferView

* Correct interface ArrayBufferView

* API to show objects in webassembly runtime in browser

* Remove debug writelns

* Set event handler-type properties

* String must not be shortstring

* Send properties sorted

+ implemented CheckInitialStkLen for the WASI target (just returns the parameter
stklen as a result value, unmodified)

* fixed WasiRTLCreateEvent to actually return the result

* fixes to WebAssembly RTLEventWaitFor:
* correct conversion from milliseconds to nanoseconds (multiply by 1000000,
instead of 1000)
* use a negative timeout value, instead of 0, to indicate infinite wait
timeout. Using 0 with the 'wait' instruction indicates no wait at all.

* fixed WasiRTLEventWaitFor_WaitAllowed: second parameter is expected value to wait on (0), not wait to wait for (1)

* WasiRTLEventWaitFor_WaitNotAllowed: treat timeout of 0 as zero wait time,
instead of infinite time, for consistency with WasiRTLEventWaitFor_WaitAllowed
(and other platforms, such as Windows)

* fixed WebAssembly InitMutex() and DoneMutex() - pass the parameter by reference

* optimization in WebAssembly's MutexKind() function - mark the first parameter
as const, to avoid making a copy on the stack

* WebAssembly threads: set M.Locked to 0 on UnLockMutex

* fixed conversion between milliseconds and nanoseconds in LockMutexTimeoutNoWait and LockMutexTimeoutWait

* fix typo in comment

* WebAssembly mutex: treat all negative values of aTimeoutMS as infinite, instead of just -1

* WebAssembly mutex: changed the aTimeoutMS parameters of LockMutexTimeoutNoWait
and LockMutexTimeoutWait to int64, instead of longint, since they're called
from LockMutexTimeout, which takes an int64 parameter

* WebAssembly mutex: changed the timeout parameter to be in nanoseconds (these
functions are only used internally, so this doesn't break compatibility)

* WebAssembly threads: bug fixes in LockMutexTimeoutWait

* WebAssembly threads: fixed race condition LockMutex in the check where Locked
is 1, but Owner still holds the current thread id, even though another thread
has just acquired a lock, but still haven't updated the owner thread ID. We
avoid this problem by setting Owner to nil before unlocking the mutex. And in
InitMutex/DoneMutex, we store the creator thread ID in a different field -
Creator, instead of Owner.

* WebAssembly threads: use atomic loads and stores for accessing TRTLCriticalSection.Locked

* WebAssembly threads: also access TRTLCriticalSection.Owner using atomic loads and stores

* WebAssembly threads: reformat code in LockMutexTimeoutNoWait for better
readability by removing begin..end blocks and replacing it with an 'else if'
chain. No functional changes.

* WebAssembly threads: fixed bug in LockMutexTimeoutNoWait, caused by the use of
Result instead of Res. This stupid bug broke WebAssembly critical sections,
causing random spurious hangs and it took me quite a lot of time to find it!

* WebAssembly threads: don't check for GetThreadState(MyThread)<>tsRunning in
LockMutexTimeoutWait and LockMutexTimeoutNoWait

+ WebAssembly threads: initial implementation of the WASI threads proposal:

https://github.com/WebAssembly/wasi-threads

Note that the WASI folk have already declared this proposal 'obsolete' and
only intended to be used for engines that support WASI v0.1. On the other
hand, the WASI v0.2 threads proposal is an early draft and not implemented
anywhere, so we have no choice, but to stay with v0.1 at this time, or give up
on multithreading for who knows how long it would take for the v0.2 spec to be
completed.

Regarding the WASI v0.1 engines that implement WASI threads correctly and can
be used with Free Pascal, I've discovered only one that works:

https://github.com/bytecodealliance/wasm-micro-runtime/tree/main

Wasmtime claims to support multithreading since version 15, however it doesn't
seem to work. I tested all versions until the 23.0.1, and none of them works.

Caveat: using the internal linker is not yet supported with WebAssembly and
multithreading. Please use the external linker (the -Xe option), if you want
to give this new feature a try.

* WebAssembly threads: fix threadvars with the new WASI-threads implementation

* WebAssembly threads: fix TThread.WaitFor (use -1 instead of 0 to signal infinite timeout)

* WebAssembly threads: simplified (optimized) the implementation of
TWasmRTLEvent, so it doesn't use a Mutex. Use atomic operations instead.

* proper implementation for the function Sptr (which returns the stack pointer) for WebAssembly

+ WASI: set StackLength on startup

+ WASI: set StackBottom on startup

* WebAssembly threads: pass the stack size to InitThread when starting a new thread

+ WebAssembly threads: init StackBottom (used for stack checking) more precisely
when starting a new thread. Precision is not that important for the stack
checking itself, because it uses a stack margin of 16kb, so the previous
value, set by InitThread is good enough, however it's easy to do it precisely,
since we allocate the stack and pass a pointer to it in TWasmThread, so why
not?

* WebAssembly threads: disable stack checking for the FPCWasmThreadStartPascal procedure

* Install error handler to examine exceptions during callback

* Export get_object_tree

* Correct callback handler for object tree

* WebAssembly threads: free the stack block and TLS block in case wasi_thread_spawn fails

* WebAssembly threads: use New and Dispose instead of GetMem/FreeMem for allocating/freeing TWasmThread

* WebAssembly threads: destroy the event and mutex in WasiBeginThread in case wasi_thread_spawn fails

* WebAssembly threads: implement WasiEndThread using exceptions. There's no
other way to end a thread in WebAssembly, except by ending the thread
procedure. Therefore, the only way to implement WasiEndThread is to have it
raise an exception and handle it at the outermost level. This, of course,
requires one of the WebAssembly exception modes to be turned on, in order for
this to work.

* WebAssembly threads: call fpc_wasm32_init_tls from inline asm code to avoid
race condition in branchful exceptions mode

+ added some more comments in wasi_thread_start

* removed TODO comment from WasiThreadSwitch

* Explicitly specify path to include files

* Correct dictionary construction

* Add CopyToMemory

+ WebAssembly threads: initialize the ThreadId threadvar for the main thread

+ WebAssembly threads: set IsMultiThread to true in WasiBeginThread

+ WebAssembly threads: implemented basic events (both manual and auto reset)

* WebAssembly threads: use high(uint32) as MaxThreadSignal

* Add overloads with offset and length for typed array constructor

* Objects passed in callback are ours to free

* WebAssembly threads: RTLEvents rewritten to implement an auto reset event.
Previous implementation did a manual reset event. However, at least on Windows
and Linux, an auto reset event is used.

+ WebAssembly threads: set FThreadReaped to true in TThread.WaitFor, to avoid
hang in TThread.SysDestroy after .WaitFor

* WebAssembly threads: moved the thread stack and TLS block free code to a new
procedure: FreeStackAndTlsBlock. No functional changes.

* WebAssembly threads: made FreeStackAndTlsBlock set the StackBlock and
TlsPointers to nil

+ WebAssembly threads: call FreeStackAndTlsBlock in WasiWaitForThreadTerminate

+ WebAssembly threads: introduced TWasmThread.ThreadHasFinished boolean

+ WebAssembly threads: initialize TWasmThread.ThreadHasFinished to false in WasiBeginThread

+ WebAssembly threads: spinwait until ThreadHasFinished becomes true in
WasiWaitForThreadTerminate, before freeing the thread TLS and stack block, to
avoid race condition with a thread that is finishing (i.e. the main threadproc
is done), but still executing internal Pascal code inside
FPCWasmThreadStartPascal.

* fixed compilation error, introduced in a0ac317aae017c1bf828084410210324448661c9

* Make sure reference count is properly managed

* Webassembly HTTP request API

* WebAssembly threads: in TThread.WaitFor, call CheckSynchronize in a loop,
while waiting on a thread that isn't finished, but the waiting happens on the
main thread. This fixes the hang in test tb0636.pp

* WebAssembly: fixed SysUtils.sleep() with large timeouts causing incorrect time
delay, due to arithmetic overflow

* WebAssembly threads: fix race condition, which causes sometimes an abandoned
basic event to be reported as signalled. This should fix the test tbrtlevt.pp
sometimes failing.

* Add some utility methods to TJSarray for easier pushing of values

* Webassembly websocket support and demo

* Regexp support for wasm target

* Rename some identifiers to be more unique. Fixes issue gitlab 0040915

* Add license header

* Allow to set lastindex

* CopyFromMemory

* Correct export name

* Add timer API and demo

* JOB debugobject call

* Allow message in ShowAsDebug

* Some minor improvements

DumpLiveObjects call

* Fix warnings, hints and notes

* Fix memleak

+ WASI threads: define FPC_WASM_WORKER_THREADS_CAN_WAIT. It is actually true in
all known cases (command line WASI or browser).

* Simple example for JOB call

* Some fixes in handling of headers

* Typecast to pointer of self() needed

* Store session info only for project files

* Make names unique across modules

* Unique names for imports

* Add SharedMemoryBuffer

* Fix compilation

* Remove erroneously commited commented line

* Atomics

* switch WebAssembly RTL to provide atomic intrinsic helpers instead of Interlocked* functions

Fix TJSArray._GetStrings: exit once you get correct value, do not fall through to raising error

* New fix for fpc_atomic_cmp_xchg_alu, as suggested by Sven

+ add intrinsic for 8-bit atomic cmpxchg for wasm32 (this way the fallback for cmxchg is no longer used for wasm32)

- remove unnecessary defines

* Fix compilation when using threading

+ added function fpc_wasm_invoke_helper to the WebAssembly RTL

* Add TJSAtomics.waitAsync

* Fix compilation for unicode

* Assign result in async

* Allow host environmentto get main and self thread IDs. Needed for inter-thread messaging in browser

* API to share JOB objects between threads (if browser allows)

* Object ID must be controlled by wasm side

* ID is now handled in webassembly

* WASI: workaround for FindFirst/FindNext opening the current directory, by using its full name

* WASI: avoid using inner preopened dirs, that escape to the parent with '..',
in case there's an outer preopened dir

* WASI system.pp: check that WebAssembly threads are always turned off for the wasip1 target, and always turned on for the wasip1threads target

* forgot to commit

* Some additional thread debugging statements

* Correctly set current thread

* Wake main thread when a thread is auto freed

* Fix mem leak (stack memory never freed) in wasm.

* Fix compilation, probably also bug with mem size

* License header

+ API to get exception info in host environment

* Compile in mode objfpc

* Demo for wasmedge

* performance.now interface

* Add some missing constants

* log exit to be symmetrical with entry in AllocateOSInfoBlock

* Webassembly browser storage API

* Demo for storage

* Add webassembly message channel api

* Message handler should be "of object"

* Correct type and len for unicodestring message

* Allow timezone correction on time call

* API to collect locale settings from browser

* Wasm semaphore implementation

* Add copyright header

+ added except_exnref.inc (RTL support for WebAssembly exnref exceptions)

* except_native.inc renamed except_legacy.inc

+ support FPC_WASM_EXNREF_EXCEPTIONS in the RTL, like the other exception modes

* Verify correctness of timer objects

* Some extra safety checks