+ compile the sysconst unit for wasm32-wasi

+ started working on the SysUtils unit for the WASI platform

+ enabled compilation of unit SysUtils for the WASI target. Note that WASI
snapshot building fails, when compiler is built with -CR, because of a
use-after-free bug in the compiler, related to generics. A fix for this bug
is currently being worked on.

+ enabled compilation of unit sortbase for the WASI target

+ enabled compilation of unit math for the WASI target

+ enable compilation of unit rtlconsts for the WASI target

+ enabled compilation of unit types for the WASI target

+ enabled compilation of unit typinfo for the WASI target

+ enabled compilation of unit fgl for the WASI target

+ enabled compilation of unit macpas for the WASI target

+ enabled compilation of unit iso7185 for the WASI target

+ enabled compilation of unit getopts for the WASI target

+ enabled compilation of unit charset for the WASI target

+ enabled compilation of unit cpall for the WASI target

+ enabled compilation of unit character for the WASI target

+ enabled compilation of units unicodedata and unicodenumtable for the WASI target
* fixed the dependencies of unit character

+ enabled compilation of unit fpwidestring 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

+ enabled compilation of unit classes for the WASI target

+ enabled compilation of unit uuchar for the WASI platform

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

+ enabled compilation of unit extpas for the WASI target

+ enabled the fcl-xml package for the WASI target

+ enabled the fcl-sound package for the WASI target

+ enabled the regexpr package 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

* set EXEEXT to .wasm for the WASI target in fpcmake

+ started working on DOS.FindFirst

+ initial working implementation of FindFirst/FindNext

* use -1 instead of 0 for indicating empty DirFD

+ enabled compilation of unit heaptrc for the WASI target

- removed commented out code from the WASI startup code

+ added unhandled exception handling code for the branchful exceptions mode

+ implemented GetMsCount in the DOS unit for WASI

Disable utils for wasi target, because paszlib cannot be compiled due to use of goto labels

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

* Wasmtime support

+ define USE_NOTHREADMANAGER in the WASI system unit

Unicode' unicodenumtable.pas removed : update Makefile.fpc.

Regenerate Makefile's with trunk fpcmake

* Export wasiAlloc and wasiFree

* 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.

Add implicit units to wasi rtl

Regenerate Makefile after: Add implicit units to wasi rtl

+ added AtomicStore() to the WebAssembly unit

* Export wasiAlloc, wasiFree

* anonymous method overloads for synchronize/queue.

* fix missing ifdef for the non win32/64/unix targets.
* also do watcom.

* 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

* Dotted filenames for package winunits-jedi

+ added promising _start and _initialize exports

* Adjust wasmtime interface to latest version

* 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: protect SysOSAlloc against race conditions via a critical section

* WebAssembly: allow specifying the initial and max memory size via the $M
directive

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

* WebAssembly: optimized SysOSAlloc to use memory area left at the end of the
page (64kb). This reduces memory use, when SysOSAlloc is called with sizes,
smaller than 64kb.

* 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.

* WebAssembly threads: use the stack size, specified for the main thread (via
the $M directive, or the '-Cs' compiler option) as the default stack size for
other spawned threads

+ 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

* 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

+ 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

* 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