Merge pull request #113 from robdaemon/fix-gcc-15

Fixes build problems on gcc 15

.gitattributes

@@ -0,0 +1,40 @@
+# Cygwin git and github for windows differ in their eol convention: Github for
+# windows uses crlf, but cygwin git uses LF.
+# Since we want the same enlistment to work both ways, we need to specify and stick
+# with end of line convention for all files.
+# Therefore we choose LF for all files except windows command scripts.
+
+* text=auto
+
+*.md text eol=lf
+*.c text eol=lf
+*.h text eol=lf
+*.Mod text eol=lf
+*.mod text eol=lf
+*.Lola text eol=lf
+*.lola text eol=lf
+*.make text eol=lf
+*makefile text eol=lf
+*.sh text eol=lf
+.git* text eol=lf
+
+*.cmd text eol=crlf
+
+
+# Symbol files are binaries
+*.sym binary
+
+# Other binaries (these are not normally checked in.)
+*.o binary
+*.obj binary
+*stackdump binary
+*exe binary
+
+# Provide type information to improve block annotation in git diff output.
+*.Mod diff=pascal
+*.c   diff=cpp
+*.h   diff=cpp
+
+# Set the language to Oberon
+*.Mod linguist-language=Oberon
+*.mod linguist-language=Oberon

.gitconfig

@@ -0,0 +1,10 @@
+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = false
+	logallrefupdates = true
+	ignorecase = true
+	autocrlf = true
+#	safecrlf = false
+[push]
+	default = simple

.gitignore

@@ -0,0 +1,46 @@
+/*.sublime-*
+/Configuration.Mod
+/Configuration.Make
+/build/*
+/install/*
+/*.exe
+/*.obj
+/*.[cho]
+/*.lib
+/*.map
+/*.sym
+/*.asm
+/*.mod
+/Errors.Txt
+/Errors.txt
+/olang
+/src/test/**/*.exe
+/src/test/**/*.c
+/src/test/**/*.h
+/src/test/**/*.o
+/src/test/**/*.obj
+/src/test/**/*.sym
+**/*.stackdump
+!/src/test/confidence/**/expected
+/src/test/confidence/**/input
+/src/test/confidence/**/result
+/src/test/confidence/**/result-*
+/src/test/confidence/**/*[^.]*
+/src/test/confidence/**/*.asm
+/src/test/confidence/**/*.s
+/src/test/confidence/**/*.map
+/bootstrap/*/SYSTEM.[ch]
+/bootstrap/*/Errors.Txt
+/bootstrap/*/WindowsWrapper.h
+/.DS_store
+**/.DS_store
+**/*.dSYM
+**/.tmp.*
+/*.pdb
+/*.ilk
+/t/*
+/triage/BasicTypeSize.md
+/triage/Roadmap.md
+triage/system/*
+tags
+voc

COMPILE

@@ -1,21 +0,0 @@
-currently three bootstrap static binaries provided, for x86_64, x86, and armv6j_hardfp (works on raspberry pi) gnu/linux targets.
-
-0) prerequisites: libc6-dev on debian, glibc-devel, glibc-static on fedora.
-	
-1) make with corresponding makefile
-   if it's rasp pi or other armhf platform then do
-   # make -f makefile.gcc.armv6j_hardfp
-   if it's x86 then
-   # make -f makefile.gcc.x86
-   and if it's x86_64, then default makefile is for this platform
-   # make
-
-   (theoretically you can also change TARCH in makefile and type make)
-
-2) # sudo make install
-
-this will install voc in /opt/voc-<version> and create /opt/voc symlink to it.
-
-add /opt/voc/bin to your PATH and enjoy, compile, have fun!
-
--- noch

README.md

@@ -1,67 +0,0 @@
-
-vishap oberon compiler
-======================
-
-How to install
-==============
-
-just cd into source directory and type
-
->make -f makefile.linux.gcc.x86_64
-
-if you are on linux x86_64 system and you want voc to use gcc as backend.
-
-otherwise use corresponding makefile.
-
-then type
-
->sudo make install
-
-- or see COMPILE file.
-
-How to use
-==========
-
-Type voc and it'll show you help.
-
-voc -M will compile your module and link it statically to libVishapOberon.
-voc -m will link the module dynamically.
-
-If you have more than one module, and you want them to be compiled into elf filethen:
-Let's assume we have module M0 which imports M1;
-
->voc -l M1.Mod -s M0.Mod -M
-
-Here -l is a global option.
-Module M1 will be compiled with -s option, i. e. sym file will be generated.
-
-Module M0 will be compiled and linked statically.
-
-In case you have modules in different directories, like "ui", "logic", "math", then you need to export MODULES environment variable like this:
-
->export MODULES=".:ui:logic:math"
-
-and after call voc
-
->voc -s ui0.Mod
-
-Otherwise you can use full path:
-
->voc -s ui/ui0.Mod
-
-build rpm
-=========
-
-if you'd like to build an rpm installer, then
-
-* compress sources as voc-1.0.src.tar.bz2  
-  assuming you in voc directory
-> cd ..
-> tar -jcvpf voc-1.0.src.tar.bz2 voc
-* put them to ~/rpmbuild/SOURCES (on some systems as root to /usr/src/redhat/SOURCES/) or other similar location.  
-> mkdir -p ~/rpmbuild/SOURCES  
-> cp voc-1.0.src.tar.bz2 ~/rpmbuild/SOURCES  
-* cd to voc directory and run  
-> rpmbuild -ba voc.spec
-
-this should create voc rpm installers.

ReadMe.md

@@ -0,0 +1,305 @@
+![Build status](https://brownsmeet.com/githubhook/vishaps-status)
+
+# Ѵishap Oberon
+
+[Ѵishap Oberon](https://vishap.oberon.am/) is a free and open source (GPLv3)
+implementation of the Oberon-2 language and libraries for use on
+conventional operating systems such as Linux, BSD, Android, Mac and Windows.
+
+Vishap's Oberon Compiler (voc) uses a C backend (gcc, clang, tcc or msc) to compile
+Oberon programs under Unix, Mac or Windows. Vishap Oberon includes
+libraries from the Ulm, oo2c and Ofront Oberon compilers, as well as
+default libraries complying with the Oakwood Guidelines for Oberon-2 compilers.
+
+### Contents
+
+&nbsp;&nbsp;&nbsp;&nbsp;[**Installation**](#installation)<br>
+&nbsp;&nbsp;&nbsp;&nbsp;[**Compiling a 'Hello' application**](#a-hello-application)<br>
+&nbsp;&nbsp;&nbsp;&nbsp;[**License**](#license)<br>
+&nbsp;&nbsp;&nbsp;&nbsp;[**Platform support and porting**](#platform-support-and-porting)<br>
+&nbsp;&nbsp;&nbsp;&nbsp;[**Language support and libraries**](#language-support-and-libraries)<br>
+&nbsp;&nbsp;&nbsp;&nbsp;[**History**](#history)<br>
+&nbsp;&nbsp;&nbsp;&nbsp;[**Roadmap**](#roadmap)<br>
+&nbsp;&nbsp;&nbsp;&nbsp;[**Contributors**](#contributors)<br>
+&nbsp;&nbsp;&nbsp;&nbsp;[**Origin of the name "Ѵishap Oberon"**](#origin-of-the-name-Ѵishap-oberon)<br>
+&nbsp;&nbsp;&nbsp;&nbsp;[**References**](#references)<br>
+
+
+## Installation
+
+It is easy to install the Oberon compiler and libraries
+with the following simple steps:
+
+  1. Install pre-requisites such as git, gcc, static C libraries, diff utils.
+  2. Clone the repository: `git clone https://github.com/vishaps/voc`.
+  3. Optionally `export CC=clang` or `export CC=tcc`.
+  4. run `make full`.
+  5. Optionally install to a system directory such as /opt or /usr/local/share with `make install` (might be with sudo).
+  6. Set your PATH variable to include the compiler binary.
+
+These are detailed below:
+
+
+#### 1. Install prerequisites
+
+| Platform               | Packages                                                                      |
+| ---------              | ------------                                                                  |
+| Debian/Ubuntu/Mint ... | `apt-get install git`                                                         |
+| Fedora/RHEL/CentOS ... | `yum install git gcc glibc-static` (`dnf` instead of `yum` on recent Fedoras) |
+| FreeBSD/OpenBSD/NetBSD | `pkg install git`                                                             |
+| OpenSUSE               | `zypper install gcc git-core make glibc-devel-static`                         |
+| Cygwin                 | use setup-x86[_x64] to add packages git, make, diffutils and gcc-core         |
+| Darwin                 | type 'git' at the command line and accept the prompt to install it.           |
+
+More details, including for MingW and MS C, in [**Installation**](/doc/Installation.md).
+
+
+#### 2. Clone and build the compiler and libraries
+
+1. `git clone https://github.com/vishaps/voc`
+2. `cd voc`
+3. `make full`
+
+`make full` will create an installation directory under your local repository at voc/install.
+
+`mmake full` runs `ldconfig` to configure the linker to find libraries in voc/install, but you
+need to update your program search PATH yourself (see step 4 below).
+
+
+
+#### 3. Optionally install to a system directory
+
+Run `make install` as root to copy the voc/install directory to the appropriate directory
+for your OS as follows:
+
+| System  | Where `make install` puts the installation            |
+| ------- | --------------------------------------                |
+| Linux   | `/opt/voc`                                            |
+| BSD     | `/usr/local/share/voc`                                |
+| Windows | See [**Windows installation**](/doc/Winstallation.md) |
+| Termux  | `/data/data/com.termux/files/opt/voc`                 |
+
+`make install` updates `ldconfg` with the new library locations.
+
+
+#### 4. Set your PATH environment variable
+
+Since there are so many ways that different systems and users manage their PATHs, we leave
+it to you to update your path to include the compiler binary.
+
+Both `make full` and `make install` display instructions on setting the path specific to your
+system.
+
+For reference this will be:
+
+| Installation choice       | Set path                                                      |
+| ---------                 | --------------------------------------                        |
+| Just `make full`          | `export PATH="your-repository-clone/install/bin:$PATH"`       |
+| `make install` on Linux   | `export PATH="/opt/voc/bin:$PATH"`                            |
+| `make install` on BSD     | `export PATH="/usr/local/share/voc/bin:$PATH"`                |
+| `make install` on Windows | See [**Windows installation**](/doc/Winstallation.md)         |
+| `make install` on Termux  | `export PATH="/data/data/com.termux/files/opt/voc/bin:$PATH"` |
+
+Also see [**Installation**](/doc/Installation.md).
+
+The compiler finds the rest of the installation based on the location from which it is loaded.
+
+
+## A 'Hello' application
+
+Anything appended to Oberon.Log is automatically written to stdout, so the
+following conventional Oberon program will display 'Hello.':
+
+```Modula-2
+MODULE hello;
+  IMPORT Oberon, Texts;
+  VAR W: Texts.Writer;
+BEGIN
+  Texts.OpenWriter(W);
+  Texts.WriteString(W, "Hello."); Texts.WriteLn(W);
+  Texts.Append(Oberon.Log, W.buf)
+END hello.
+```
+
+Alternatively the Oakwood module Out can be used to write directly to stdout:
+
+```Modula-2
+MODULE hello;
+  IMPORT Out;
+BEGIN
+  Out.String("Hello."); Out.Ln
+END hello.
+```
+
+Compile as follows:
+
+    voc hello.mod -m
+
+The -m parameter tells voc that this is a main module, and to generate an
+executable binary.
+
+Execute as usual on Linux (`./hello`) or Windows (`hello`).
+
+For more details on compilation, see [**Compiling**](/doc/Compiling.md).
+
+### Viewing the interfaces of included modules.
+
+In order to see the definition of a module's interface, use the "showdef" program.
+
+```
+$ showdef Out
+DEFINITION Out;
+
+  VAR
+    IsConsole-: BOOLEAN;
+
+  PROCEDURE Char(ch: CHAR);
+  PROCEDURE Flush;
+  PROCEDURE Int(x: INT64; n: INT64);
+  PROCEDURE Ln;
+  PROCEDURE LongReal(x: LONGREAL; n: INT16);
+  PROCEDURE Open;
+  PROCEDURE Real(x: REAL; n: INT16);
+  PROCEDURE String(str: ARRAY OF CHAR);
+
+END Out.
+```
+
+
+## License
+
+Vishap Oberon's frontend and C backend engine is a fork of Josef Templ’s Ofront, which has been released
+under the FreeBSD License. Unlike Ofront, Vishap Oberon does not include the Oberon v4 GUI environment.
+
+The Ulm Oberon Library  and the Ooc libraries are distributed under GPL. Proprietry code
+using these libraries may not be statically linked.
+
+Voc tools are distributed under GPLv3.
+
+Most of the runtime in libVishapOberon is distributed under GPLv3 with runtime exception.
+
+
+## Platform support and porting
+
+Vishap Oberon supports 32 and 64 bit little-endian architectures including Intel x86 and x86_64, 32 bit arm and aarch64.
+
+It compiles under gcc, clang, tcc and Microsoft Visual C.
+
+Installation supports GNU/Linux, MAC OSX, BSD and Windows (native and cygwin).
+
+A C program (src/tools/make/configure.c) detects the details of the C compiler
+and operating system on which it is running.
+
+The following systems are recognised:
+
+ - Linux, including Ubuntu and Centos derivatives.
+ - The BSDs, including OpenBSD and FreeBSD.
+ - Cygwin under Windows, MingW under Cygwin, Bash on Ubuntu on Windows.
+
+Additionally a Windows .cmd is provided for building with Microsoft C.
+
+For details, including how to add support for unrecognised systems, see
+[**Porting**](/doc/Porting.md).
+
+
+## Language support and libraries
+
+Vishap Oberon supports the Oberon 2 programming language, including type-bound procedures. SYSTEM.Mod includes additional functionality and some changes for 64 bit support.
+
+#### Integer and set type sizes:
+
+| Type     | -O2 option (default) | -OC option |
+| ---      | ---                  | ---        |
+| SHORTINT | 8 bit                | 16 bit     |
+| INTEGER  | 16 bit               | 32 bit     |
+| LONGINT  | 32 bit               | 64 bit     |
+| SET      | 32 bit               | 64 bit     |
+
+#### Libraries
+
+Included libraries ease porting of code from the major Oberon systems:
+
+ - Oberon V4 and S3 compatible library set.
+ - Ooc (optimizing oberon-2 compiler) library port.
+ - Ulm’s Oberon system library port.
+ - Oakwood standard libraries.
+ - Some other freely redistributable libraries.
+
+Oakwood libraries are supported for both -O2 and -OC options, whereas the ULM, OOC and ETH system 3 libraries are only available on -O2 (default) compilations.
+
+
+Vishap Oberon also supports some features of Oberon-07.
+
+
+See also [**Features**](/doc/Features.md).
+
+
+## Contributors
+
+Joseph Templ developed ofront as a tool to translate Oberon-2 programs into semantically equivalent
+C programs. It was Copyrighted in 1995, and transferred to the Free BSD license in 2012.
+
+From Joseph's github repository:
+
+> Design and implementation of ofront is due to Josef Templ ... ofront has been based in part on Regis Crelier's PhD thesis and Stefan Gehring's diploma thesis, both at ETH Zurich, Institute for Computer Systems.
+
+Norayr Chilingarian forked ofront in 2013, porting extensive libraries from [ULM Oberon](http://www.mathematik.uni-ulm.de/oberon/), [OO2C](https://github.com/Spirit-of-Oberon/oo2c) and ETH Oberon System 3, and adding support for more platforms including 64 bit systems.
+
+David Brown has worked on adding support for more platforms incuding windows using MSC, cygwin or mingw since January 2016. More recently he has generalised basic type support within the compiler to allow e.g. 64 bit LONGINT on 32 bit systems, and 32 bit LONGINT on 64 bit systems.
+
+## Oberon
+
+Oberon is a programming language, an operating system and a graphical
+user interface. Originally designed and implemented by by Niklaus Wirth and
+Jürg Gutknecht at ETH Zürich in the late 1980s, it demonstrates that the
+fundamentals of a modern OS and GUI can be implemented in clean and simple code
+orders of magnitude smaller than found in contemporary systems.
+
+The Oberon programming language is an evolution of the Pascal and Modula
+languages. While it adds garbage collection, extensible types and (in
+Oberon-2) type-bound procedures, it is also simplified following the principals
+of Einstein and Antoine de Saint-Exupéry:
+
+>  Make it as simple as possible, but not simpler. (Albert Einstein)
+
+>  Perfection is finally attained not when there is no longer anything to add, but
+>  when there is no longer anything to take away. (Antoine de Saint-Exupéry,
+>  translated by Lewis Galantière.)
+
+## Origin of the name "Ѵishap Oberon"
+
+Vishaps are dragons inhabiting the Armenian Highlands.
+We decided to name the project “Vishap” because ties between compilers and dragons have ancient traditions.
+
+Also, Vishaps are known in tales, fiction. [This page](http://blog.fogus.me/2015/04/27/six-works-of-computer-science-fiction/) refers to some technologies as “computer science fiction”. Among them to Oberon. This brings another meaning, Oberon is like aliens, ghosts. And Vishaps.
+
+## References
+
+###### Oberon
+ - [The History of Modula-2 and Oberon](http://people.inf.ethz.ch/wirth/Articles/Modula-Oberon-June.pdf)
+ - [The Programming Language Oberon](https://www.inf.ethz.ch/personal/wirth/Oberon/Oberon.Report.pdf)
+ - [Project Oberon: The Design of an Operating System and Compiler ](https://people.inf.ethz.ch/wirth/ProjectOberon1992.pdf)
+ - [Oberon - the Overlooked Jewel](http://pascal.hansotten.com/uploads/oberonpi/Oberon%20article.pdf)
+
+###### Oberon 2
+ - [Differences between Oberon and Oberon-2](https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&doi=89e5bd3cf006bde4821599cdc57a37de5dc84bcd)
+ - [The Programming Language Oberon-2](http://www.ssw.uni-linz.ac.at/Research/Papers/Oberon2.pdf)
+ - [Programming in Oberon. Steps beyond Pascal and Modula](https://people.inf.ethz.ch/wirth/ProgInOberonWR.pdf)
+ - [The Oakwood Guidelines for Oberon-2 Compiler Developers](http://www.math.bas.bg/bantchev/place/oberon/oakwood-guidelines.pdf)
+
+###### Oberon 07
+ - [Difference between Oberon-07 and Oberon](https://www.inf.ethz.ch/personal/wirth/Oberon/Oberon07.pdf)
+ - [The Programming Language Oberon-07](https://www.inf.ethz.ch/personal/wirth/Oberon/Oberon07.Report.pdf)
+ - [Programming in Oberon - a Tutorial](https://www.inf.ethz.ch/personal/wirth/Oberon/PIO.pdf)
+
+###### Links
+ - [Niklaus Wirth's personal page at ETH Zurich](https://www.inf.ethz.ch/personal/wirth/)
+ - [Selected articles by Niklaus Wirth](https://people.inf.ethz.ch/wirth/SelectedArticles.pdf)
+ - [ETH Oberon publications page](https://web.archive.org/web/20191207155011/http://www.ethoberon.ethz.ch/books.html)
+ - [Joseph Templ's ofront on github](https://github.com/jtempl/ofront)
+ - [Software Templ OG](http://www.software-templ.com)
+
+
+## History
+
+See [**History**](/doc/History.md).

bootstrap/SYSTEM.c

@@ -0,0 +1,227 @@
+/*
+*   The body prefix file of the voc(jet backend) runtime system, Version 1.0
+*
+*   Copyright (c) Software Templ, 1994, 1995
+*
+*   Module SYSTEM is subject to change any time without prior notification.
+*   Software Templ disclaims all warranties with regard to module SYSTEM,
+*   in particular shall Software Templ not be liable for any damage resulting
+*   from inappropriate use or modification of module SYSTEM.
+*
+*   Version 1.1  jt, 24.11.95  fixes for correct pointer arithmetic on Cray computers
+*   jt 31.1.2007  ANSI prototypes for malloc and exit in order to avoid cc warnings
+*
+*/
+
+#include "SYSTEM.h"
+#include "stdarg.h"
+#include <signal.h>
+
+
+// Procedure verions of SYSTEM.H versions used when a multiply accessed
+// parameter has side effects.
+
+
+
+
+INT64 SYSTEM_DIV(INT64 x, INT64 y)
+{
+  if (x == 0) return 0;
+  if (x >= 0)
+    if (y >= 0) {return x/y;}
+    else        {return -((x-y-1)/(-y));}
+  else
+    if (y >= 0) {return -((y-x-1)/y);}
+    else        {return (-x)/(-y);}
+}
+
+INT64 SYSTEM_MOD(INT64 x, INT64 y)
+{
+  if (x == 0) return 0;
+  if (x >= 0)
+    if (y >= 0) {return x % y;}
+    else        {return (y+1) + ((x-1) % (-y));}
+  else
+    if (y >= 0) {return (y-1) - ((-x-1) % y);}
+    else        {return -((-x) % (-y));}
+}
+
+INT64 SYSTEM_ENTIER(double x)
+{
+    INT64 y;
+    if (x >= 0)
+        return (INT64)x;
+    else {
+        y = (INT64)x;
+        if (y <= x) return y; else return y - 1;
+    }
+}
+
+
+
+void SYSTEM_INHERIT(ADDRESS *t, ADDRESS *t0)
+{
+    t -= __TPROC0OFF;
+    t0 -= __TPROC0OFF;
+    while (*t0 != __EOM) {*t = *t0; t--; t0--;}
+}
+
+
+void SYSTEM_ENUMP(void *adr, ADDRESS n, void (*P)())
+{
+    while (n > 0) {
+        P((ADDRESS)(*((void**)(adr))));
+        adr = ((void**)adr) + 1;
+        n--;
+    }
+}
+
+void SYSTEM_ENUMR(void *adr, ADDRESS *typ, ADDRESS size, ADDRESS n, void (*P)())
+{
+    ADDRESS *t, off;
+    typ++;
+    while (n > 0) {
+        t = typ;
+        off = *t;
+        while (off >= 0) {P(*(ADDRESS*)((char*)adr+off)); t++; off = *t;}
+        adr = ((char*)adr) + size;
+        n--;
+    }
+}
+
+extern void Heap_Lock();
+extern void Heap_Unlock();
+
+SYSTEM_PTR SYSTEM_NEWARR(ADDRESS *typ, ADDRESS elemsz, int elemalgn, int nofdim, int nofdyn, ...)
+{
+    ADDRESS nofelems, size, dataoff, n, nptr, *x, *p, nofptrs, i, *ptab, off;
+    va_list ap;
+    va_start(ap, nofdyn);
+    nofelems = 1;
+    while (nofdim > 0) {
+        nofelems = nofelems * va_arg(ap, ADDRESS); nofdim--;
+        if (nofelems <= 0) __HALT(-20);
+    }
+    va_end(ap);
+    dataoff = nofdyn * sizeof(ADDRESS);
+    if (elemalgn > sizeof(ADDRESS)) {
+        n = dataoff % elemalgn;
+        if (n != 0) dataoff += elemalgn - n;
+    }
+    size = dataoff + nofelems * elemsz;
+    Heap_Lock();
+    if (typ == NIL) {
+        /* element typ does not contain pointers */
+        x = Heap_NEWBLK(size);
+    }
+    else if (typ == (ADDRESS*)POINTER__typ) {
+        /* element type is a pointer */
+        x = Heap_NEWBLK(size + nofelems * sizeof(ADDRESS));
+        p = (ADDRESS*)(ADDRESS)x[-1];
+        p[-nofelems] = *p;  /* build new type desc in situ: 1. copy block size; 2. setup ptr tab; 3. set sentinel; 4. patch tag */
+        p -= nofelems - 1; n = 1;   /* n =1 for skipping the size field */
+        while (n <= nofelems) {*p = n*sizeof(ADDRESS); p++; n++;}
+        *p = - (nofelems + 1) * sizeof(ADDRESS);    /* sentinel */
+        x[-1] -= nofelems * sizeof(ADDRESS);
+    }
+    else {
+        /* element type is a record that contains pointers */
+        ptab = typ + 1; nofptrs = 0;
+        while (ptab[nofptrs] >= 0) {nofptrs++;} /* number of pointers per element */
+        nptr = nofelems * nofptrs;  /* total number of pointers */
+        x = Heap_NEWBLK(size + nptr * sizeof(ADDRESS));
+        p = (ADDRESS*)(ADDRESS)x[- 1];
+        p[-nptr] = *p;  /* build new type desc in situ; 1. copy block size; 2. setup ptr tab; 3. set sentinel; 4. patch tag */
+        p -= nptr - 1; n = 0; off = dataoff;
+        while (n < nofelems) {i = 0;
+            while (i < nofptrs) {*p = off + ptab[i]; p++; i++;}
+            off += elemsz; n++;
+        }
+        *p = - (nptr + 1) * sizeof(ADDRESS);    /* sentinel */
+        x[-1] -= nptr * sizeof(ADDRESS);
+    }
+    if (nofdyn != 0) {
+        /* setup len vector for index checks */
+        va_start(ap, nofdyn);
+        p = x;
+        while (nofdyn > 0) {*p = va_arg(ap, ADDRESS); p++, nofdyn--;}
+        va_end(ap);
+    }
+    Heap_Unlock();
+    return x;
+}
+
+typedef void (*SystemSignalHandler)(INT32); // = Platform_SignalHandler
+
+#ifndef _WIN32
+    // Unix signal handling
+    SystemSignalHandler handler[10] = {0};  // Adjust the array size to include signal 11
+
+    void segfaultHandler(int signal) {
+      __HALT(-10);
+    }
+    // Revised signal handler to accommodate additional signals like SIGSEGV
+    void signalHandler(int s) {
+        if ((s >= 2 && s <= 4) || s == 11) {  // Include SIGSEGV (usually signal 11)
+            if (handler[s-2]) {
+                handler[s-2](s);
+            }
+        }
+        // Ignore other signals
+    }
+
+    void SystemSetHandler(int s, ADDRESS h) {
+        if ((s >= 2 && s <= 4) || s == 11) {
+            int needtosetsystemhandler = handler[s-2] == 0;
+            handler[s-2] = (SystemSignalHandler)h;
+            if (needtosetsystemhandler) {
+                signal(s, signalHandler);
+            }
+        }
+    }
+
+    void setupAutomaticSegfaultHandler() {
+        SystemSetHandler(11, (ADDRESS)segfaultHandler);  // Register handler for SIGSEGV
+    }
+
+#else
+    // Windows system remains as is since Windows does not use SIGSEGV in the same way
+    #include "WindowsWrapper.h"
+
+    SystemSignalHandler SystemInterruptHandler = 0;
+    SystemSignalHandler SystemQuitHandler = 0;
+    BOOL ConsoleCtrlHandlerSet = FALSE;
+
+    BOOL WINAPI SystemConsoleCtrlHandler(DWORD ctrlType) {
+        if ((ctrlType == CTRL_C_EVENT) || (ctrlType == CTRL_BREAK_EVENT)) {
+            if (SystemInterruptHandler) {
+                SystemInterruptHandler(2);  // SIGINT
+                return TRUE;
+            }
+        } else {
+            if (SystemQuitHandler) {
+                SystemQuitHandler(3);  // SIGQUIT
+                return TRUE;
+            }
+        }
+        return FALSE;
+    }
+    void EnsureConsoleCtrlHandler() {
+        if (!ConsoleCtrlHandlerSet) {
+        SetConsoleCtrlHandler(SystemConsoleCtrlHandler, TRUE);
+            ConsoleCtrlHandlerSet = TRUE;
+        }
+    }
+
+    void SystemSetInterruptHandler(ADDRESS h) {
+        EnsureConsoleCtrlHandler();
+        SystemInterruptHandler = (SystemSignalHandler)h;
+    }
+
+    void SystemSetQuitHandler(ADDRESS h) {
+        EnsureConsoleCtrlHandler();
+        SystemQuitHandler = (SystemSignalHandler)h;
+    }
+
+#endif
+

bootstrap/SYSTEM.h

@@ -0,0 +1,337 @@
+#ifndef SYSTEM__h
+#define SYSTEM__h
+
+
+// 64 bit system detection
+
+#if (__SIZEOF_POINTER__ == 8) || defined (_LP64) || defined(__LP64__) || defined(_WIN64)
+  #define o__64
+#endif
+
+
+// Declare memcpy in a way compatible with C compilers intrinsic
+// built in implementations.
+
+#if defined (o__64)
+  #if defined(_WIN64)
+    typedef unsigned long long size_t;
+  #else
+    typedef unsigned long      size_t;
+  #endif
+#else
+  #if defined(__OpenBSD__)
+    typedef unsigned long      size_t;
+  #else
+    typedef unsigned int       size_t;
+  #endif
+#endif
+
+#define _SIZE_T_DECLARED // For FreeBSD
+#define _SIZE_T_DEFINED_ // For OpenBSD
+
+void *memcpy(void *dest, const void *source, size_t size);
+#if defined _MSC_VER
+#define alloca _alloca
+#endif
+void *alloca(size_t size);
+
+
+// Declare fixed size versions of basic intger types
+
+#if defined (o__64) && !defined(_WIN64)
+  // LP64
+  typedef long               INT64;
+  typedef unsigned long      UINT64;
+#else
+  // ILP32 or LLP64
+  typedef long long          INT64;
+  typedef unsigned long long UINT64;
+#endif
+
+typedef int                  INT32;
+typedef unsigned int         UINT32;
+
+typedef short int            INT16;
+typedef unsigned short int   UINT16;
+
+typedef signed char          INT8;
+typedef unsigned char        UINT8;
+
+
+// The compiler uses 'import' and 'export' which translate to 'extern' and
+// nothing respectively.
+
+#define import extern
+#define export
+
+
+
+// Known constants
+
+#define NIL          ((void*)0)
+#define __MAXEXT     16
+#define POINTER__typ ((ADDRESS*)(1))  // not NIL and not a valid type
+
+
+// Oberon types
+
+typedef INT8   BOOLEAN;
+typedef INT8   SYSTEM_BYTE;
+typedef UINT8  CHAR;
+typedef float  REAL;
+typedef double LONGREAL;
+typedef void*  SYSTEM_PTR;
+
+
+
+// 'ADDRESS' is a synonym for an integer of pointer size
+
+#if defined (o__64)
+  #define ADDRESS INT64
+#else
+  #define ADDRESS INT32
+#endif
+
+
+
+// ----------------------------------------------------------------------
+// ----------------------------------------------------------------------
+
+
+
+// OS Memory allocation interfaces are in PlatformXXX.Mod
+
+extern ADDRESS Platform_OSAllocate (ADDRESS size);
+extern void    Platform_OSFree     (ADDRESS addr);
+
+
+// Assertions and Halts
+
+extern void Modules_Halt(INT32 x);
+extern void Modules_AssertFail(INT32 x);
+
+#define __HALT(x)         Modules_Halt((INT32)(x))
+#define __ASSERT(cond, x) if (!(cond)) Modules_AssertFail((INT32)(x))
+
+
+// Index checking
+
+static inline INT64 __XF(INT64 i, UINT64 ub) {
+  if (i < 0 || (UINT64)i >= ub) __HALT(-2);
+  return i;
+}
+#define __X(i, ub) (((i) >= 0 && (i) < (ub)) ? (i) : (__HALT(-2),0))
+
+// Range checking, and checked SHORT and CHR functions
+
+static inline INT64 __RF(UINT64 i, UINT64 ub) {if (i >= ub) {__HALT(-8);} return i;}
+#define __R(i, ub)      (((i)<(ub))?i:(__HALT(-8),0))
+#define __SHORT(x, ub)  ((int)((UINT64)(x)+(ub)<(ub)+(ub)?(x):(__HALT(-8),0)))
+#define __SHORTF(x, ub) ((int)(__RF((x)+(ub),(ub)+(ub))-(ub)))
+#define __CHR(x)        ((CHAR)__R(x, 256))
+#define __CHRF(x)       ((CHAR)__RF(x, 256))
+
+
+
+// Signal handling in SYSTEM.c
+
+#ifndef _WIN32
+  extern void SystemSetHandler(int s, ADDRESS h);
+#else
+  extern void SystemSetInterruptHandler(ADDRESS h);
+  extern void SystemSetQuitHandler     (ADDRESS h);
+#endif
+
+
+
+// String comparison
+
+static inline int __str_cmp(CHAR *x, CHAR *y){
+  INT64 i = 0;
+  CHAR ch1, ch2;
+  do {ch1 = x[i]; ch2 = y[i]; i++;
+    if (!ch1) return -(int)ch2;
+  } while (ch1==ch2);
+  return (int)ch1 - (int)ch2;
+}
+#define __STRCMP(a,b) __str_cmp((CHAR*)(a), (CHAR*)(b))
+
+
+
+// Inline string, record and array copy
+
+#define __COPY(s, d, n) {char*_a=(void*)s,*_b=(void*)d; LONGINT _i=0,_t=n-1; \
+                         while(_i<_t&&((_b[_i]=_a[_i])!=0)){_i++;};_b[_i]=0;}
+#define __DUPARR(v, t)  v=(void*)memcpy(v##__copy,v,sizeof(t))
+#define __DUP(x, l, t)  x=(void*)memcpy(alloca(l*sizeof(t)),x,l*sizeof(t))
+#define __DEL(x)
+
+
+/* SYSTEM ops */
+
+#define __VAL(t, x)     (*(t*)&(x))
+
+#define __GET(a, x, t)  x=*(t*)(ADDRESS)(a)
+#define __PUT(a, x, t)  *(t*)(ADDRESS)(a)=x
+
+#define __LSHL(x, n, s) ((INT##s)((UINT##s)(x)<<(n)))
+#define __LSHR(x, n, s) ((INT##s)((UINT##s)(x)>>(n)))
+#define __LSH(x, n, s)  ((n)>=0? __LSHL(x, n, s): __LSHR(x, -(n), s))
+
+#define __ROTL(x, n, s) ((INT##s)((UINT##s)(x)<<(n)|(UINT##s)(x)>>(s-(n))))
+#define __ROTR(x, n, s) ((INT##s)((UINT##s)(x)>>(n)|(UINT##s)(x)<<(s-(n))))
+#define __ROT(x, n, s)  ((n)>=0? __ROTL(x, n, s): __ROTR(x, -(n), s))
+
+#define __ASHL(x, n)    ((INT64)(x)<<(n))
+#define __ASHR(x, n)    ((INT64)(x)>>(n))
+#define __ASH(x, n)     ((n)>=0?__ASHL(x,n):__ASHR(x,-(n)))
+static inline INT64 SYSTEM_ASH(INT64 x, INT64 n) {return __ASH(x,n);}
+#define __ASHF(x, n)    SYSTEM_ASH((INT64)(x), (INT64)(n))
+
+#define __MOVE(s, d, n) memcpy((char*)(ADDRESS)(d),(char*)(ADDRESS)(s),n)
+
+
+extern INT64 SYSTEM_DIV(INT64 x, INT64 y);
+#define __DIVF(x, y) SYSTEM_DIV(x, y)
+#define __DIV(x, y) (((x)>0 && (y)>0) ? (x)/(y) : __DIVF(x, y))
+
+
+extern INT64 SYSTEM_MOD(INT64 x, INT64 y);
+#define __MODF(x, y) SYSTEM_MOD(x, y)
+#define __MOD(x, y) (((x)>0 && (y)>0) ? (x)%(y) : __MODF(x, y))
+
+
+extern INT64 SYSTEM_ENTIER (double x);
+#define __ENTIER(x) SYSTEM_ENTIER(x)
+
+
+#define __ABS(x) (((x)<0)?-(x):(x))
+
+static inline INT32 SYSTEM_ABS64(INT64 i) {return i >= 0 ? i : -i;}
+static inline INT64 SYSTEM_ABS32(INT32 i) {return i >= 0 ? i : -i;}
+#define __ABSF(x) ((sizeof(x) <= 4) ? SYSTEM_ABS32(x) : SYSTEM_ABS64(x))
+
+static inline double SYSTEM_ABSD(double i) {return i >= 0.0 ? i : -i;}
+#define __ABSFD(x) SYSTEM_ABSD(x)
+
+#define __CAP(ch)       ((CHAR)((ch)&0x5f))
+#define __ODD(x)        ((x)&1)
+
+#define __IN(x, s, size)     (((unsigned int)(x))<size && ((((UINT##size)(s))>>(x))&1))
+// todo tested versions of SETOF and SETRNG: check that x, l and h fit size
+#define __SETOF(x, size)     ((UINT##size)1<<(x))
+#define __SETRNG(l, h, size) ((~(UINT##size)0<<(l))&~(UINT##size)0>>(size-1-(h)))
+
+#define __MASK(x, m) ((x)&~(m))
+#define __BIT(x, n)  (*(UINT64*)(x)>>(n)&1)
+
+
+
+// Runtime checks
+
+#define __RETCHK     __retchk: __HALT(-3); return 0;
+#define __CASECHK    __HALT(-4)
+#define __WITHCHK    __HALT(-7)
+
+
+#define __IS(tag, typ, level) (*(tag-(__BASEOFF-level))==(ADDRESS)typ##__typ)
+#define  __TYPEOF(p)          (*(((ADDRESS**)(p))-1))
+#define __ISP(p, typ, level)  __IS(__TYPEOF(p),typ,level)
+
+
+#define __GUARDP(p, typ, level)    ((typ*)(__ISP(p,typ,level)?p:(__HALT(-5),p)))
+#define __GUARDR(r, typ, level)    (*((typ*)(__IS(r##__typ,typ,level)?r:(__HALT(-5),r))))
+#define __GUARDA(p, typ, level)    ((struct typ*)(__IS(__TYPEOF(p),typ,level)?p:(__HALT(-5),p)))
+#define __GUARDEQR(p, dyntyp, typ) if(dyntyp!=typ##__typ) __HALT(-6);*(p)
+#define __GUARDEQP(p, typ)         if(__TYPEOF(p)!=typ##__typ)__HALT(-6);*((typ*)p)
+
+
+
+// Module entry/registration/exit
+
+extern void       Heap_REGCMD();
+extern SYSTEM_PTR Heap_REGMOD();
+extern void       Heap_REGTYP();
+extern void       Heap_INCREF();
+
+#define __DEFMOD              static void *m; if (m!=0) {return m;}
+#define __REGCMD(name, cmd)   Heap_REGCMD(m, (CHAR*)name, cmd)
+#define __REGMOD(name, enum)  if (m==0) {m = Heap_REGMOD((CHAR*)name,enum);}
+#define __ENDMOD              return m
+#define __MODULE_IMPORT(name) Heap_INCREF(name##__init())
+
+
+
+// Main module initialisation, registration and finalisation
+
+extern void Modules_Init(INT32 argc, ADDRESS argv);
+extern void Heap_FINALL();
+
+extern void setupAutomaticSegfaultHandler();
+#ifndef _WIN32
+#define __INIT(argc, argv)    static void *m; setupAutomaticSegfaultHandler(); Modules_Init(argc, (ADDRESS)&argv);
+#else
+#define __INIT(argc, argv)    static void *m; Modules_Init(argc, (ADDRESS)&argv);
+#endif
+#define __REGMAIN(name, enum) m = Heap_REGMOD((CHAR*)name,enum)
+#define __FINI                Heap_FINALL(); return 0
+
+
+// Memory allocation
+
+extern SYSTEM_PTR Heap_NEWBLK (ADDRESS size);
+extern SYSTEM_PTR Heap_NEWREC (ADDRESS tag);
+extern SYSTEM_PTR SYSTEM_NEWARR(ADDRESS*, ADDRESS, int, int, int, ...);
+
+#define __SYSNEW(p, len) p = Heap_NEWBLK((ADDRESS)(len))
+#define __NEW(p, t)      p = Heap_NEWREC((ADDRESS)t##__typ)
+#define __NEWARR         SYSTEM_NEWARR
+
+
+
+/* Type handling */
+
+extern void SYSTEM_INHERIT(ADDRESS *t, ADDRESS *t0);
+extern void SYSTEM_ENUMP  (void *adr, ADDRESS n, void (*P)());
+extern void SYSTEM_ENUMR  (void *adr, ADDRESS *typ, ADDRESS size, ADDRESS n, void (*P)());
+
+
+#define __TDESC(t, m, n)                                                \
+  static struct t##__desc {                                             \
+    ADDRESS  tproc[m];         /* Proc for each ptr field            */ \
+    ADDRESS  tag;                                                       \
+    ADDRESS  next;             /* Module table type list points here */ \
+    ADDRESS  level;                                                     \
+    ADDRESS  module;                                                    \
+    char     name[24];                                                  \
+    ADDRESS  basep[__MAXEXT];  /* List of bases this extends         */ \
+    ADDRESS  reserved;                                                  \
+    ADDRESS  blksz;            /* xxx_typ points here                */ \
+    ADDRESS  ptr[n+1];         /* Offsets of ptrs up to -ve sentinel */ \
+  } t##__desc
+
+#define __BASEOFF   (__MAXEXT+1)                           // blksz as index to base.
+#define __TPROC0OFF (__BASEOFF+24/sizeof(ADDRESS)+5)       // blksz as index to tproc IFF m=1.
+#define __EOM 1
+#define __TDFLDS(name, size)          {__EOM}, 1, 0, 0, 0, name, {0}, 0, size
+#define __ENUMP(adr, n, P)            SYSTEM_ENUMP(adr, (ADDRESS)(n), P)
+#define __ENUMR(adr, typ, size, n, P) SYSTEM_ENUMR(adr, typ, (ADDRESS)(size), (ADDRESS)(n), P)
+
+#define __INITYP(t, t0, level) \
+  t##__typ               = (ADDRESS*)&t##__desc.blksz;                                                    \
+  memcpy(t##__desc.basep, t0##__typ - __BASEOFF, level*sizeof(ADDRESS));                                  \
+  t##__desc.basep[level] = (ADDRESS)t##__typ;                                                             \
+  t##__desc.module       = (ADDRESS)m;                                                                    \
+  if(t##__desc.blksz!=sizeof(struct t)) __HALT(-15);                                                      \
+  t##__desc.blksz        = (t##__desc.blksz+5*sizeof(ADDRESS)-1)/(4*sizeof(ADDRESS))*(4*sizeof(ADDRESS)); \
+  Heap_REGTYP(m, (ADDRESS)&t##__desc.next);                                                               \
+  SYSTEM_INHERIT(t##__typ, t0##__typ)
+
+// Oberon-2 type bound procedures support
+#define __INITBP(t, proc, num)            *(t##__typ-(__TPROC0OFF+num))=(ADDRESS)proc
+#define __SEND(typ, num, funtyp, parlist) ((funtyp)((ADDRESS)*(typ-(__TPROC0OFF+num))))parlist
+
+
+
+
+#endif

bootstrap/WindowsWrapper.h

@@ -0,0 +1,10 @@
+// WindowsWrapper.h
+//
+// Includes Windows.h while avoiding conflicts with Oberon types.
+
+
+#define BOOLEAN _BOOLEAN
+#define CHAR    _CHAR
+#include <windows.h>
+#undef BOOLEAN
+#undef CHAR

bootstrap/unix-44/Compiler.c

@@ -0,0 +1,213 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspamS */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "Configuration.h"
+#include "Heap.h"
+#include "OPB.h"
+#include "OPC.h"
+#include "OPM.h"
+#include "OPP.h"
+#include "OPT.h"
+#include "OPV.h"
+#include "Platform.h"
+#include "Strings.h"
+#include "VT100.h"
+#include "extTools.h"
+
+
+
+
+static void Compiler_FindLocalObjectFiles (CHAR *objectnames, ADDRESS objectnames__len);
+export void Compiler_Module (BOOLEAN *done);
+static void Compiler_PropagateElementaryTypeSizes (void);
+export void Compiler_Translate (void);
+static void Compiler_Trap (INT32 sig);
+
+
+void Compiler_Module (BOOLEAN *done)
+{
+	BOOLEAN ext, new;
+	OPT_Node p = NIL;
+	OPP_Module(&p, OPM_Options);
+	if (OPM_noerr) {
+		OPV_Init();
+		OPT_InitRecno();
+		OPV_AdrAndSize(OPT_topScope);
+		OPT_Export(&ext, &new);
+		if (OPM_noerr) {
+			OPM_OpenFiles((void*)OPT_SelfName, 256);
+			OPM_DeleteObj((void*)OPT_SelfName, 256);
+			OPC_Init();
+			OPV_Module(p);
+			if (OPM_noerr) {
+				if ((__IN(10, OPM_Options, 32) && __STRCMP(OPM_modName, "SYSTEM") != 0)) {
+					OPM_DeleteSym((void*)OPT_SelfName, 256);
+					OPM_LogVT100((CHAR*)"32m", 4);
+					OPM_LogWStr((CHAR*)"  Main program.", 16);
+					OPM_LogVT100((CHAR*)"0m", 3);
+				} else {
+					if (new) {
+						OPM_LogVT100((CHAR*)"32m", 4);
+						OPM_LogWStr((CHAR*)"  New symbol file.", 19);
+						OPM_LogVT100((CHAR*)"0m", 3);
+						OPM_RegisterNewSym();
+					} else if (ext) {
+						OPM_LogWStr((CHAR*)"  Extended symbol file.", 24);
+						OPM_RegisterNewSym();
+					}
+				}
+			} else {
+				OPM_DeleteSym((void*)OPT_SelfName, 256);
+			}
+		}
+	}
+	OPM_CloseFiles();
+	OPT_Close();
+	OPM_LogWLn();
+	*done = OPM_noerr;
+}
+
+static void Compiler_PropagateElementaryTypeSizes (void)
+{
+	OPT_Struct adrinttyp = NIL;
+	OPT_sysptrtyp->size = OPM_AddressSize;
+	OPT_sysptrtyp->idfp = OPT_sysptrtyp->form;
+	OPM_FPrint(&OPT_sysptrtyp->idfp, OPT_sysptrtyp->size);
+	OPT_adrtyp->size = OPM_AddressSize;
+	OPT_adrtyp->idfp = OPT_adrtyp->form;
+	OPM_FPrint(&OPT_adrtyp->idfp, OPT_adrtyp->size);
+	adrinttyp = OPT_IntType(OPM_AddressSize);
+	OPT_adrtyp->strobj = adrinttyp->strobj;
+	OPT_sinttyp = OPT_IntType(OPM_ShortintSize);
+	OPT_inttyp = OPT_IntType(OPM_IntegerSize);
+	OPT_linttyp = OPT_IntType(OPM_LongintSize);
+	OPT_sintobj->typ = OPT_sinttyp;
+	OPT_intobj->typ = OPT_inttyp;
+	OPT_lintobj->typ = OPT_linttyp;
+	switch (OPM_SetSize) {
+		case 4: 
+			OPT_settyp = OPT_set32typ;
+			break;
+		default: 
+			OPT_settyp = OPT_set64typ;
+			break;
+	}
+	OPT_setobj->typ = OPT_settyp;
+	if (__STRCMP(OPM_Model, "C") == 0) {
+		OPT_cpbytetyp->strobj->name[4] = 0x00;
+	} else {
+		OPT_cpbytetyp->strobj->name[4] = '@';
+	}
+}
+
+static void Compiler_FindLocalObjectFiles (CHAR *objectnames, ADDRESS objectnames__len)
+{
+	OPT_Link l = NIL;
+	CHAR fn[64];
+	Platform_FileIdentity id;
+	objectnames[0] = 0x00;
+	l = OPT_Links;
+	while (l != NIL) {
+		__COPY(l->name, fn, 64);
+		Strings_Append((CHAR*)".sym", 5, (void*)fn, 64);
+		if (Platform_IdentifyByName(fn, 64, &id, Platform_FileIdentity__typ) == 0) {
+			__COPY(l->name, fn, 64);
+			Strings_Append((CHAR*)".o", 3, (void*)fn, 64);
+			if (Platform_IdentifyByName(fn, 64, &id, Platform_FileIdentity__typ) == 0) {
+				Strings_Append((CHAR*)" ", 2, (void*)objectnames, objectnames__len);
+				Strings_Append(fn, 64, (void*)objectnames, objectnames__len);
+			} else {
+				OPM_LogVT100((CHAR*)"91m", 4);
+				OPM_LogWStr((CHAR*)"Link warning: a local symbol file is present for module ", 57);
+				OPM_LogWStr(l->name, 256);
+				OPM_LogWStr((CHAR*)", but local object file '", 26);
+				OPM_LogWStr(fn, 64);
+				OPM_LogWStr((CHAR*)"' is missing.", 14);
+				OPM_LogVT100((CHAR*)"0m", 3);
+				OPM_LogWLn();
+			}
+		}
+		l = l->next;
+	}
+}
+
+void Compiler_Translate (void)
+{
+	BOOLEAN done;
+	CHAR linkfiles[2048];
+	if (OPM_OpenPar()) {
+		for (;;) {
+			OPM_Init(&done);
+			if (!done) {
+				return;
+			}
+			OPM_InitOptions();
+			Compiler_PropagateElementaryTypeSizes();
+			Heap_GC(0);
+			Compiler_Module(&done);
+			if (!done) {
+				OPM_LogWLn();
+				OPM_LogWStr((CHAR*)"Module compilation failed.", 27);
+				OPM_LogWLn();
+				Platform_Exit(1);
+			}
+			if (!__IN(13, OPM_Options, 32)) {
+				if (__IN(14, OPM_Options, 32)) {
+					extTools_Assemble(OPM_modName, 32);
+				} else {
+					if (!__IN(10, OPM_Options, 32)) {
+						extTools_Assemble(OPM_modName, 32);
+					} else {
+						Compiler_FindLocalObjectFiles((void*)linkfiles, 2048);
+						extTools_LinkMain((void*)OPM_modName, 32, __IN(15, OPM_Options, 32), linkfiles, 2048);
+					}
+				}
+			}
+		}
+	}
+}
+
+static void Compiler_Trap (INT32 sig)
+{
+	Heap_FINALL();
+	if (sig == 3) {
+		Platform_Exit(0);
+	} else {
+		if (sig == 4) {
+			OPM_LogWStr((CHAR*)" --- Oberon compiler internal error", 36);
+			OPM_LogWLn();
+		}
+		Platform_Exit(2);
+	}
+}
+
+
+export int main(int argc, char **argv)
+{
+	__INIT(argc, argv);
+	__MODULE_IMPORT(Configuration);
+	__MODULE_IMPORT(Heap);
+	__MODULE_IMPORT(OPB);
+	__MODULE_IMPORT(OPC);
+	__MODULE_IMPORT(OPM);
+	__MODULE_IMPORT(OPP);
+	__MODULE_IMPORT(OPT);
+	__MODULE_IMPORT(OPV);
+	__MODULE_IMPORT(Platform);
+	__MODULE_IMPORT(Strings);
+	__MODULE_IMPORT(VT100);
+	__MODULE_IMPORT(extTools);
+	__REGMAIN("Compiler", 0);
+	__REGCMD("Translate", Compiler_Translate);
+/* BEGIN */
+	Platform_SetInterruptHandler(Compiler_Trap);
+	Platform_SetQuitHandler(Compiler_Trap);
+	Platform_SetBadInstructionHandler(Compiler_Trap);
+	Compiler_Translate();
+	__FINI;
+}

bootstrap/unix-44/Configuration.c

@@ -0,0 +1,24 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+
+
+export CHAR Configuration_versionLong[76];
+
+
+
+
+
+export void *Configuration__init(void)
+{
+	__DEFMOD;
+	__REGMOD("Configuration", 0);
+/* BEGIN */
+	__MOVE("2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8.", Configuration_versionLong, 76);
+	__ENDMOD;
+}

bootstrap/unix-44/Configuration.h

@@ -0,0 +1,15 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Configuration__h
+#define Configuration__h
+
+#include "SYSTEM.h"
+
+
+import CHAR Configuration_versionLong[76];
+
+
+import void *Configuration__init(void);
+
+
+#endif // Configuration

bootstrap/unix-44/Files.h

@@ -0,0 +1,70 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Files__h
+#define Files__h
+
+#include "SYSTEM.h"
+
+typedef
+	struct Files_FileDesc *Files_File;
+
+typedef
+	struct Files_FileDesc {
+		INT32 _prvt0;
+		char _prvt1[560];
+	} Files_FileDesc;
+
+typedef
+	struct Files_Rider {
+		INT32 res;
+		BOOLEAN eof;
+		char _prvt0[15];
+	} Files_Rider;
+
+
+import INT16 Files_MaxPathLength, Files_MaxNameLength;
+
+import ADDRESS *Files_FileDesc__typ;
+import ADDRESS *Files_Rider__typ;
+
+import Files_File Files_Base (Files_Rider *r, ADDRESS *r__typ);
+import void Files_ChangeDirectory (CHAR *path, ADDRESS path__len, INT16 *res);
+import void Files_Close (Files_File f);
+import void Files_Delete (CHAR *name, ADDRESS name__len, INT16 *res);
+import void Files_GetDate (Files_File f, INT32 *t, INT32 *d);
+import void Files_GetName (Files_File f, CHAR *name, ADDRESS name__len);
+import INT32 Files_Length (Files_File f);
+import Files_File Files_New (CHAR *name, ADDRESS name__len);
+import Files_File Files_Old (CHAR *name, ADDRESS name__len);
+import INT32 Files_Pos (Files_Rider *r, ADDRESS *r__typ);
+import void Files_Purge (Files_File f);
+import void Files_Read (Files_Rider *r, ADDRESS *r__typ, SYSTEM_BYTE *x);
+import void Files_ReadBool (Files_Rider *R, ADDRESS *R__typ, BOOLEAN *x);
+import void Files_ReadByte (Files_Rider *r, ADDRESS *r__typ, SYSTEM_BYTE *x);
+import void Files_ReadBytes (Files_Rider *r, ADDRESS *r__typ, SYSTEM_BYTE *x, ADDRESS x__len, INT32 n);
+import void Files_ReadInt (Files_Rider *R, ADDRESS *R__typ, INT16 *x);
+import void Files_ReadLInt (Files_Rider *R, ADDRESS *R__typ, INT32 *x);
+import void Files_ReadLReal (Files_Rider *R, ADDRESS *R__typ, LONGREAL *x);
+import void Files_ReadLine (Files_Rider *R, ADDRESS *R__typ, CHAR *x, ADDRESS x__len);
+import void Files_ReadNum (Files_Rider *R, ADDRESS *R__typ, SYSTEM_BYTE *x, ADDRESS x__len);
+import void Files_ReadReal (Files_Rider *R, ADDRESS *R__typ, REAL *x);
+import void Files_ReadSet (Files_Rider *R, ADDRESS *R__typ, UINT32 *x);
+import void Files_ReadString (Files_Rider *R, ADDRESS *R__typ, CHAR *x, ADDRESS x__len);
+import void Files_Register (Files_File f);
+import void Files_Rename (CHAR *old, ADDRESS old__len, CHAR *new, ADDRESS new__len, INT16 *res);
+import void Files_Set (Files_Rider *r, ADDRESS *r__typ, Files_File f, INT32 pos);
+import void Files_SetSearchPath (CHAR *path, ADDRESS path__len);
+import void Files_Write (Files_Rider *r, ADDRESS *r__typ, SYSTEM_BYTE x);
+import void Files_WriteBool (Files_Rider *R, ADDRESS *R__typ, BOOLEAN x);
+import void Files_WriteBytes (Files_Rider *r, ADDRESS *r__typ, SYSTEM_BYTE *x, ADDRESS x__len, INT32 n);
+import void Files_WriteInt (Files_Rider *R, ADDRESS *R__typ, INT16 x);
+import void Files_WriteLInt (Files_Rider *R, ADDRESS *R__typ, INT32 x);
+import void Files_WriteLReal (Files_Rider *R, ADDRESS *R__typ, LONGREAL x);
+import void Files_WriteNum (Files_Rider *R, ADDRESS *R__typ, INT64 x);
+import void Files_WriteReal (Files_Rider *R, ADDRESS *R__typ, REAL x);
+import void Files_WriteSet (Files_Rider *R, ADDRESS *R__typ, UINT32 x);
+import void Files_WriteString (Files_Rider *R, ADDRESS *R__typ, CHAR *x, ADDRESS x__len);
+import void *Files__init(void);
+
+
+#endif // Files

bootstrap/unix-44/Heap.c

@@ -0,0 +1,799 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. rtsSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+
+struct Heap__1 {
+	CHAR ch;
+	SYSTEM_PTR p;
+};
+
+typedef
+	struct Heap_CmdDesc *Heap_Cmd;
+
+typedef
+	CHAR Heap_CmdName[24];
+
+typedef
+	void (*Heap_Command)(void);
+
+typedef
+	struct Heap_CmdDesc {
+		Heap_Cmd next;
+		Heap_CmdName name;
+		Heap_Command cmd;
+	} Heap_CmdDesc;
+
+typedef
+	void (*Heap_EnumProc)(void(*)(SYSTEM_PTR));
+
+typedef
+	struct Heap_FinDesc *Heap_FinNode;
+
+typedef
+	void (*Heap_Finalizer)(SYSTEM_PTR);
+
+typedef
+	struct Heap_FinDesc {
+		Heap_FinNode next;
+		INT32 obj;
+		BOOLEAN marked;
+		Heap_Finalizer finalize;
+	} Heap_FinDesc;
+
+typedef
+	struct Heap_ModuleDesc *Heap_Module;
+
+typedef
+	CHAR Heap_ModuleName[20];
+
+typedef
+	struct Heap_ModuleDesc {
+		Heap_Module next;
+		Heap_ModuleName name;
+		INT32 refcnt;
+		Heap_Cmd cmds;
+		INT32 types;
+		Heap_EnumProc enumPtrs;
+		INT32 reserved1, reserved2;
+	} Heap_ModuleDesc;
+
+
+export SYSTEM_PTR Heap_modules;
+static INT32 Heap_freeList[10];
+static INT32 Heap_bigBlocks;
+export INT32 Heap_allocated;
+static BOOLEAN Heap_firstTry;
+static INT16 Heap_ldUnit;
+export INT32 Heap_heap;
+static INT32 Heap_heapMin, Heap_heapMax;
+export INT32 Heap_heapsize, Heap_heapMinExpand;
+static Heap_FinNode Heap_fin;
+static INT16 Heap_lockdepth;
+static BOOLEAN Heap_interrupted;
+export INT16 Heap_FileCount;
+
+export ADDRESS *Heap_ModuleDesc__typ;
+export ADDRESS *Heap_CmdDesc__typ;
+export ADDRESS *Heap_FinDesc__typ;
+export ADDRESS *Heap__1__typ;
+
+static void Heap_CheckFin (void);
+static void Heap_ExtendHeap (INT32 blksz);
+export void Heap_FINALL (void);
+static void Heap_Finalize (void);
+export INT32 Heap_FreeModule (CHAR *name, ADDRESS name__len);
+export void Heap_GC (BOOLEAN markStack);
+static void Heap_HeapSort (INT32 n, INT32 *a, ADDRESS a__len);
+export void Heap_INCREF (Heap_Module m);
+export void Heap_InitHeap (void);
+export void Heap_Lock (void);
+static void Heap_Mark (INT32 q);
+static void Heap_MarkCandidates (INT32 n, INT32 *cand, ADDRESS cand__len);
+static void Heap_MarkP (SYSTEM_PTR p);
+static void Heap_MarkStack (INT32 n, INT32 *cand, ADDRESS cand__len);
+export SYSTEM_PTR Heap_NEWBLK (INT32 size);
+export SYSTEM_PTR Heap_NEWREC (INT32 tag);
+static INT32 Heap_NewChunk (INT32 blksz);
+export void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd);
+export SYSTEM_PTR Heap_REGMOD (Heap_ModuleName name, Heap_EnumProc enumPtrs);
+export void Heap_REGTYP (Heap_Module m, INT32 typ);
+export void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize);
+static void Heap_Scan (void);
+static void Heap_Sift (INT32 l, INT32 r, INT32 *a, ADDRESS a__len);
+export void Heap_Unlock (void);
+
+extern void *Heap__init();
+extern ADDRESS Modules_MainStackFrame;
+extern ADDRESS Platform_OSAllocate(ADDRESS size);
+#define Heap_HeapModuleInit()	Heap__init()
+#define Heap_ModulesHalt(code)	Modules_Halt(code)
+#define Heap_ModulesMainStackFrame()	Modules_MainStackFrame
+#define Heap_OSAllocate(size)	Platform_OSAllocate(size)
+#define Heap_uLE(x, y)	((size_t)x <= (size_t)y)
+#define Heap_uLT(x, y)	((size_t)x <  (size_t)y)
+
+void Heap_Lock (void)
+{
+	Heap_lockdepth += 1;
+}
+
+void Heap_Unlock (void)
+{
+	Heap_lockdepth -= 1;
+	if ((Heap_interrupted && Heap_lockdepth == 0)) {
+		Heap_ModulesHalt(-9);
+	}
+}
+
+SYSTEM_PTR Heap_REGMOD (Heap_ModuleName name, Heap_EnumProc enumPtrs)
+{
+	Heap_Module m;
+	if (__STRCMP(name, "Heap") == 0) {
+		__SYSNEW(m, 48);
+	} else {
+		__NEW(m, Heap_ModuleDesc);
+	}
+	m->types = 0;
+	m->cmds = NIL;
+	__COPY(name, m->name, 20);
+	m->refcnt = 0;
+	m->enumPtrs = enumPtrs;
+	m->next = (Heap_Module)(ADDRESS)Heap_modules;
+	Heap_modules = (SYSTEM_PTR)m;
+	return (void*)m;
+}
+
+INT32 Heap_FreeModule (CHAR *name, ADDRESS name__len)
+{
+	Heap_Module m, p;
+	__DUP(name, name__len, CHAR);
+	m = (Heap_Module)(ADDRESS)Heap_modules;
+	while ((m != NIL && __STRCMP(m->name, name) != 0)) {
+		p = m;
+		m = m->next;
+	}
+	if ((m != NIL && m->refcnt == 0)) {
+		if (m == (Heap_Module)(ADDRESS)Heap_modules) {
+			Heap_modules = (SYSTEM_PTR)m->next;
+		} else {
+			p->next = m->next;
+		}
+		__DEL(name);
+		return 0;
+	} else {
+		if (m == NIL) {
+			__DEL(name);
+			return -1;
+		} else {
+			__DEL(name);
+			return m->refcnt;
+		}
+	}
+	__RETCHK;
+}
+
+void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd)
+{
+	Heap_Cmd c;
+	if (__STRCMP(m->name, "Heap") == 0) {
+		__SYSNEW(c, 32);
+	} else {
+		__NEW(c, Heap_CmdDesc);
+	}
+	__COPY(name, c->name, 24);
+	c->cmd = cmd;
+	c->next = m->cmds;
+	m->cmds = c;
+}
+
+void Heap_REGTYP (Heap_Module m, INT32 typ)
+{
+	__PUT(typ, m->types, INT32);
+	m->types = typ;
+}
+
+void Heap_INCREF (Heap_Module m)
+{
+	m->refcnt += 1;
+}
+
+static INT32 Heap_NewChunk (INT32 blksz)
+{
+	INT32 chnk, blk, end;
+	chnk = Heap_OSAllocate(blksz + 12);
+	if (chnk != 0) {
+		blk = chnk + 12;
+		end = blk + blksz;
+		__PUT(chnk + 4, end, INT32);
+		__PUT(blk, blk + 4, INT32);
+		__PUT(blk + 4, blksz, INT32);
+		__PUT(blk + 8, -4, INT32);
+		__PUT(blk + 12, Heap_bigBlocks, INT32);
+		Heap_bigBlocks = blk;
+		Heap_heapsize += blksz;
+		if (Heap_uLT(blk + 4, Heap_heapMin)) {
+			Heap_heapMin = blk + 4;
+		}
+		if (Heap_uLT(Heap_heapMax, end)) {
+			Heap_heapMax = end;
+		}
+	}
+	return chnk;
+}
+
+static void Heap_ExtendHeap (INT32 blksz)
+{
+	INT32 size, chnk, j, next;
+		if (Heap_uLT(Heap_heapMinExpand, blksz)) {
+		size = blksz;
+	} else {
+		size = Heap_heapMinExpand;
+	}
+	chnk = Heap_NewChunk(size);
+	if (chnk != 0) {
+		if (Heap_uLT(chnk, Heap_heap)) {
+			__PUT(chnk, Heap_heap, INT32);
+			Heap_heap = chnk;
+		} else {
+			j = Heap_heap;
+			__GET(j, next, INT32);
+			while ((next != 0 && Heap_uLT(next, chnk))) {
+				j = next;
+				__GET(j, next, INT32);
+			}
+			__PUT(chnk, next, INT32);
+			__PUT(j, chnk, INT32);
+		}
+	} else if (!Heap_firstTry) {
+		Heap_heapMinExpand = 16;
+	}
+}
+
+SYSTEM_PTR Heap_NEWREC (INT32 tag)
+{
+	INT32 i, i0, di, blksz, restsize, t, adr, end, next, prev;
+	SYSTEM_PTR new;
+	Heap_Lock();
+	__GET(tag, blksz, INT32);
+		i0 = __LSH(blksz, -Heap_ldUnit, 32);
+	i = i0;
+	if (i < 9) {
+		adr = Heap_freeList[i];
+		while (adr == 0) {
+			i += 1;
+			adr = Heap_freeList[i];
+		}
+	}
+	if (i < 9) {
+		__GET(adr + 12, next, INT32);
+		Heap_freeList[i] = next;
+		if (i != i0) {
+			di = i - i0;
+			restsize = __ASHL(di, 4);
+			end = adr + restsize;
+			__PUT(end + 4, blksz, INT32);
+			__PUT(end + 8, -4, INT32);
+			__PUT(end, end + 4, INT32);
+			__PUT(adr + 4, restsize, INT32);
+			__PUT(adr + 12, Heap_freeList[di], INT32);
+			Heap_freeList[di] = adr;
+			adr += restsize;
+		}
+	} else {
+		adr = Heap_bigBlocks;
+		prev = 0;
+		for (;;) {
+			if (adr == 0) {
+				if (Heap_firstTry) {
+					Heap_GC(1);
+					blksz += 16;
+					t = __LSH(Heap_allocated + blksz, -(2 + Heap_ldUnit), 32) * 80;
+					if (Heap_uLT(Heap_heapsize, t)) {
+						Heap_ExtendHeap(t - Heap_heapsize);
+					}
+					Heap_firstTry = 0;
+					new = Heap_NEWREC(tag);
+					if (new == NIL) {
+						Heap_ExtendHeap(blksz);
+						new = Heap_NEWREC(tag);
+					}
+					Heap_firstTry = 1;
+					Heap_Unlock();
+					return new;
+				} else {
+					Heap_Unlock();
+					return NIL;
+				}
+			}
+			__GET(adr + 4, t, INT32);
+			if (Heap_uLE(blksz, t)) {
+				break;
+			}
+			prev = adr;
+			__GET(adr + 12, adr, INT32);
+		}
+		restsize = t - blksz;
+		end = adr + restsize;
+		__PUT(end + 4, blksz, INT32);
+		__PUT(end + 8, -4, INT32);
+		__PUT(end, end + 4, INT32);
+		if (Heap_uLT(144, restsize)) {
+			__PUT(adr + 4, restsize, INT32);
+		} else {
+			__GET(adr + 12, next, INT32);
+			if (prev == 0) {
+				Heap_bigBlocks = next;
+			} else {
+				__PUT(prev + 12, next, INT32);
+			}
+			if (restsize != 0) {
+				di = __ASHR(restsize, 4);
+				__PUT(adr + 4, restsize, INT32);
+				__PUT(adr + 12, Heap_freeList[di], INT32);
+				Heap_freeList[di] = adr;
+			}
+		}
+		adr += restsize;
+	}
+	i = adr + 16;
+	end = adr + blksz;
+	while (Heap_uLT(i, end)) {
+		__PUT(i, 0, INT32);
+		__PUT(i + 4, 0, INT32);
+		__PUT(i + 8, 0, INT32);
+		__PUT(i + 12, 0, INT32);
+		i += 16;
+	}
+	__PUT(adr + 12, 0, INT32);
+	__PUT(adr, tag, INT32);
+	__PUT(adr + 4, 0, INT32);
+	__PUT(adr + 8, 0, INT32);
+	Heap_allocated += blksz;
+	Heap_Unlock();
+	return (SYSTEM_PTR)(ADDRESS)(adr + 4);
+}
+
+SYSTEM_PTR Heap_NEWBLK (INT32 size)
+{
+	INT32 blksz, tag;
+	SYSTEM_PTR new;
+	Heap_Lock();
+	blksz = __ASHL(__ASHR(size + 31, 4), 4);
+	new = Heap_NEWREC((ADDRESS)&blksz);
+	tag = ((INT32)(ADDRESS)new + blksz) - 12;
+	__PUT(tag - 4, 0, INT32);
+	__PUT(tag, blksz, INT32);
+	__PUT(tag + 4, -4, INT32);
+	__PUT((INT32)(ADDRESS)new - 4, tag, INT32);
+	Heap_Unlock();
+	return new;
+}
+
+static void Heap_Mark (INT32 q)
+{
+	INT32 p, tag, offset, fld, n, tagbits;
+	if (q != 0) {
+		__GET(q - 4, tagbits, INT32);
+		if (!__ODD(tagbits)) {
+			__PUT(q - 4, tagbits + 1, INT32);
+			p = 0;
+			tag = tagbits + 4;
+			for (;;) {
+				__GET(tag, offset, INT32);
+				if (offset < 0) {
+					__PUT(q - 4, (tag + offset) + 1, INT32);
+					if (p == 0) {
+						break;
+					}
+					n = q;
+					q = p;
+					__GET(q - 4, tag, INT32);
+					tag -= 1;
+					__GET(tag, offset, INT32);
+					fld = q + offset;
+					__GET(fld, p, INT32);
+					__PUT(fld, (SYSTEM_PTR)(ADDRESS)n, SYSTEM_PTR);
+				} else {
+					fld = q + offset;
+					__GET(fld, n, INT32);
+					if (n != 0) {
+						__GET(n - 4, tagbits, INT32);
+						if (!__ODD(tagbits)) {
+							__PUT(n - 4, tagbits + 1, INT32);
+							__PUT(q - 4, tag + 1, INT32);
+							__PUT(fld, (SYSTEM_PTR)(ADDRESS)p, SYSTEM_PTR);
+							p = q;
+							q = n;
+							tag = tagbits;
+						}
+					}
+				}
+				tag += 4;
+			}
+		}
+	}
+}
+
+static void Heap_MarkP (SYSTEM_PTR p)
+{
+	Heap_Mark((INT32)(ADDRESS)p);
+}
+
+static void Heap_Scan (void)
+{
+	INT32 chnk, adr, end, start, tag, i, size, freesize;
+	Heap_bigBlocks = 0;
+	i = 1;
+	while (i < 9) {
+		Heap_freeList[i] = 0;
+		i += 1;
+	}
+	freesize = 0;
+	Heap_allocated = 0;
+	chnk = Heap_heap;
+	while (chnk != 0) {
+		adr = chnk + 12;
+		__GET(chnk + 4, end, INT32);
+		while (Heap_uLT(adr, end)) {
+			__GET(adr, tag, INT32);
+			if (__ODD(tag)) {
+				if (freesize != 0) {
+					start = adr - freesize;
+					__PUT(start, start + 4, INT32);
+					__PUT(start + 4, freesize, INT32);
+					__PUT(start + 8, -4, INT32);
+					i = __LSH(freesize, -Heap_ldUnit, 32);
+					freesize = 0;
+					if (Heap_uLT(i, 9)) {
+						__PUT(start + 12, Heap_freeList[i], INT32);
+						Heap_freeList[i] = start;
+					} else {
+						__PUT(start + 12, Heap_bigBlocks, INT32);
+						Heap_bigBlocks = start;
+					}
+				}
+				tag -= 1;
+				__PUT(adr, tag, INT32);
+				__GET(tag, size, INT32);
+				Heap_allocated += size;
+				adr += size;
+			} else {
+				__GET(tag, size, INT32);
+				freesize += size;
+				adr += size;
+			}
+		}
+		if (freesize != 0) {
+			start = adr - freesize;
+			__PUT(start, start + 4, INT32);
+			__PUT(start + 4, freesize, INT32);
+			__PUT(start + 8, -4, INT32);
+			i = __LSH(freesize, -Heap_ldUnit, 32);
+			freesize = 0;
+			if (Heap_uLT(i, 9)) {
+				__PUT(start + 12, Heap_freeList[i], INT32);
+				Heap_freeList[i] = start;
+			} else {
+				__PUT(start + 12, Heap_bigBlocks, INT32);
+				Heap_bigBlocks = start;
+			}
+		}
+		__GET(chnk, chnk, INT32);
+	}
+}
+
+static void Heap_Sift (INT32 l, INT32 r, INT32 *a, ADDRESS a__len)
+{
+	INT32 i, j;
+	INT32 x;
+	j = l;
+	x = a[j];
+	for (;;) {
+		i = j;
+		j = __ASHL(j, 1) + 1;
+		if ((j < r && Heap_uLT(a[j], a[j + 1]))) {
+			j += 1;
+		}
+		if (j > r || Heap_uLE(a[j], x)) {
+			break;
+		}
+		a[i] = a[j];
+	}
+	a[i] = x;
+}
+
+static void Heap_HeapSort (INT32 n, INT32 *a, ADDRESS a__len)
+{
+	INT32 l, r;
+	INT32 x;
+	l = __ASHR(n, 1);
+	r = n - 1;
+	while (l > 0) {
+		l -= 1;
+		Heap_Sift(l, r, (void*)a, a__len);
+	}
+	while (r > 0) {
+		x = a[0];
+		a[0] = a[r];
+		a[r] = x;
+		r -= 1;
+		Heap_Sift(l, r, (void*)a, a__len);
+	}
+}
+
+static void Heap_MarkCandidates (INT32 n, INT32 *cand, ADDRESS cand__len)
+{
+	INT32 chnk, end, adr, tag, next, i, ptr, size;
+		chnk = Heap_heap;
+	i = 0;
+	while (chnk != 0) {
+		__GET(chnk + 4, end, INT32);
+		adr = chnk + 12;
+		while (Heap_uLT(adr, end)) {
+			__GET(adr, tag, INT32);
+			if (__ODD(tag)) {
+				__GET(tag - 1, size, INT32);
+				adr += size;
+				ptr = adr + 4;
+				while (Heap_uLT(cand[i], ptr)) {
+					i += 1;
+					if (i == n) {
+						return;
+					}
+				}
+			} else {
+				__GET(tag, size, INT32);
+				ptr = adr + 4;
+				adr += size;
+				while (Heap_uLT(cand[i], ptr)) {
+					i += 1;
+					if (i == n) {
+						return;
+					}
+				}
+				if (Heap_uLT(cand[i], adr)) {
+					Heap_Mark(ptr);
+				}
+			}
+			if (Heap_uLE(end, cand[i])) {
+				adr = end;
+			}
+		}
+		__GET(chnk, chnk, INT32);
+	}
+}
+
+static void Heap_CheckFin (void)
+{
+	Heap_FinNode n;
+	INT32 tag;
+	n = Heap_fin;
+	while (n != NIL) {
+		__GET(n->obj - 4, tag, INT32);
+		if (!__ODD(tag)) {
+			n->marked = 0;
+			Heap_Mark(n->obj);
+		} else {
+			n->marked = 1;
+		}
+		n = n->next;
+	}
+}
+
+static void Heap_Finalize (void)
+{
+	Heap_FinNode n, prev;
+	n = Heap_fin;
+	prev = NIL;
+	while (n != NIL) {
+		if (!n->marked) {
+			if (n == Heap_fin) {
+				Heap_fin = Heap_fin->next;
+			} else {
+				prev->next = n->next;
+			}
+			(*n->finalize)((SYSTEM_PTR)(ADDRESS)n->obj);
+			if (prev == NIL) {
+				n = Heap_fin;
+			} else {
+				n = n->next;
+			}
+		} else {
+			prev = n;
+			n = n->next;
+		}
+	}
+}
+
+void Heap_FINALL (void)
+{
+	Heap_FinNode n;
+	while (Heap_fin != NIL) {
+		n = Heap_fin;
+		Heap_fin = Heap_fin->next;
+		(*n->finalize)((SYSTEM_PTR)(ADDRESS)n->obj);
+	}
+}
+
+static void Heap_MarkStack (INT32 n, INT32 *cand, ADDRESS cand__len)
+{
+	SYSTEM_PTR frame;
+	INT32 nofcand;
+	INT32 inc, sp, p, stack0;
+	struct Heap__1 align;
+	if (n > 0) {
+		Heap_MarkStack(n - 1, cand, cand__len);
+		if (n > 100) {
+			return;
+		}
+	}
+	if (n == 0) {
+		nofcand = 0;
+		sp = (ADDRESS)&frame;
+		stack0 = Heap_ModulesMainStackFrame();
+		inc = (ADDRESS)&align.p - (ADDRESS)&align;
+		if (Heap_uLT(stack0, sp)) {
+			inc = -inc;
+		}
+		while (sp != stack0) {
+			__GET(sp, p, INT32);
+			if ((Heap_uLE(Heap_heapMin, p) && Heap_uLT(p, Heap_heapMax))) {
+				if (nofcand == cand__len) {
+					Heap_HeapSort(nofcand, (void*)cand, cand__len);
+					Heap_MarkCandidates(nofcand, (void*)cand, cand__len);
+					nofcand = 0;
+				}
+				cand[nofcand] = p;
+				nofcand += 1;
+			}
+			sp += inc;
+		}
+		if (nofcand > 0) {
+			Heap_HeapSort(nofcand, (void*)cand, cand__len);
+			Heap_MarkCandidates(nofcand, (void*)cand, cand__len);
+		}
+	}
+}
+
+void Heap_GC (BOOLEAN markStack)
+{
+	Heap_Module m;
+	INT32 i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23;
+	INT32 cand[10000];
+	Heap_Lock();
+	m = (Heap_Module)(ADDRESS)Heap_modules;
+	while (m != NIL) {
+		if (m->enumPtrs != NIL) {
+			(*m->enumPtrs)(Heap_MarkP);
+		}
+		m = m->next;
+	}
+	if (markStack) {
+		i0 = -100;
+		i1 = -101;
+		i2 = -102;
+		i3 = -103;
+		i4 = -104;
+		i5 = -105;
+		i6 = -106;
+		i7 = -107;
+		i8 = 1;
+		i9 = 2;
+		i10 = 3;
+		i11 = 4;
+		i12 = 5;
+		i13 = 6;
+		i14 = 7;
+		i15 = 8;
+		i16 = 9;
+		i17 = 10;
+		i18 = 11;
+		i19 = 12;
+		i20 = 13;
+		i21 = 14;
+		i22 = 15;
+		i23 = 16;
+		for (;;) {
+			i0 += 1;
+			i1 += 2;
+			i2 += 3;
+			i3 += 4;
+			i4 += 5;
+			i5 += 6;
+			i6 += 7;
+			i7 += 8;
+			i8 += 9;
+			i9 += 10;
+			i10 += 11;
+			i11 += 12;
+			i12 += 13;
+			i13 += 14;
+			i14 += 15;
+			i15 += 16;
+			i16 += 17;
+			i17 += 18;
+			i18 += 19;
+			i19 += 20;
+			i20 += 21;
+			i21 += 22;
+			i22 += 23;
+			i23 += 24;
+			if ((i0 == -99 && i15 == 24)) {
+				Heap_MarkStack(32, (void*)cand, 10000);
+				break;
+			}
+		}
+		if (((((((((((((((((((((((i0 + i1) + i2) + i3) + i4) + i5) + i6) + i7) + i8) + i9) + i10) + i11) + i12) + i13) + i14) + i15) + i16) + i17) + i18) + i19) + i20) + i21) + i22) + i23 > 10000) {
+			return;
+		}
+	}
+	Heap_CheckFin();
+	Heap_Scan();
+	Heap_Finalize();
+	Heap_Unlock();
+}
+
+void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize)
+{
+	Heap_FinNode f;
+	__NEW(f, Heap_FinDesc);
+	f->obj = (INT32)(ADDRESS)obj;
+	f->finalize = finalize;
+	f->marked = 1;
+	f->next = Heap_fin;
+	Heap_fin = f;
+}
+
+void Heap_InitHeap (void)
+{
+	Heap_heap = 0;
+	Heap_heapsize = 0;
+	Heap_allocated = 0;
+	Heap_lockdepth = 0;
+	Heap_heapMin = -1;
+	Heap_heapMax = 0;
+	Heap_bigBlocks = 0;
+	Heap_heapMinExpand = 128000;
+	Heap_ldUnit = 4;
+	Heap_heap = Heap_NewChunk(128000);
+	__PUT(Heap_heap, 0, INT32);
+	Heap_firstTry = 1;
+	Heap_freeList[9] = 1;
+	Heap_FileCount = 0;
+	Heap_modules = NIL;
+	Heap_fin = NIL;
+	Heap_interrupted = 0;
+	Heap_HeapModuleInit();
+}
+
+static void EnumPtrs(void (*P)(void*))
+{
+	P(Heap_modules);
+	P(Heap_fin);
+}
+
+__TDESC(Heap_ModuleDesc, 1, 2) = {__TDFLDS("ModuleDesc", 48), {0, 28, -12}};
+__TDESC(Heap_CmdDesc, 1, 1) = {__TDFLDS("CmdDesc", 32), {0, -8}};
+__TDESC(Heap_FinDesc, 1, 1) = {__TDFLDS("FinDesc", 16), {0, -8}};
+__TDESC(Heap__1, 1, 1) = {__TDFLDS("", 8), {4, -8}};
+
+export void *Heap__init(void)
+{
+	__DEFMOD;
+	__REGMOD("Heap", EnumPtrs);
+	__REGCMD("FINALL", Heap_FINALL);
+	__REGCMD("InitHeap", Heap_InitHeap);
+	__REGCMD("Lock", Heap_Lock);
+	__REGCMD("Unlock", Heap_Unlock);
+	__INITYP(Heap_ModuleDesc, Heap_ModuleDesc, 0);
+	__INITYP(Heap_CmdDesc, Heap_CmdDesc, 0);
+	__INITYP(Heap_FinDesc, Heap_FinDesc, 0);
+	__INITYP(Heap__1, Heap__1, 0);
+/* BEGIN */
+	__ENDMOD;
+}

bootstrap/unix-44/Heap.h

@@ -0,0 +1,73 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. rtsSF */
+
+#ifndef Heap__h
+#define Heap__h
+
+#include "SYSTEM.h"
+
+typedef
+	struct Heap_CmdDesc *Heap_Cmd;
+
+typedef
+	CHAR Heap_CmdName[24];
+
+typedef
+	void (*Heap_Command)(void);
+
+typedef
+	struct Heap_CmdDesc {
+		Heap_Cmd next;
+		Heap_CmdName name;
+		Heap_Command cmd;
+	} Heap_CmdDesc;
+
+typedef
+	void (*Heap_EnumProc)(void(*)(SYSTEM_PTR));
+
+typedef
+	void (*Heap_Finalizer)(SYSTEM_PTR);
+
+typedef
+	struct Heap_ModuleDesc *Heap_Module;
+
+typedef
+	CHAR Heap_ModuleName[20];
+
+typedef
+	struct Heap_ModuleDesc {
+		Heap_Module next;
+		Heap_ModuleName name;
+		INT32 refcnt;
+		Heap_Cmd cmds;
+		INT32 types;
+		Heap_EnumProc enumPtrs;
+		char _prvt0[8];
+	} Heap_ModuleDesc;
+
+
+import SYSTEM_PTR Heap_modules;
+import INT32 Heap_allocated;
+import INT32 Heap_heap;
+import INT32 Heap_heapsize, Heap_heapMinExpand;
+import INT16 Heap_FileCount;
+
+import ADDRESS *Heap_ModuleDesc__typ;
+import ADDRESS *Heap_CmdDesc__typ;
+
+import void Heap_FINALL (void);
+import INT32 Heap_FreeModule (CHAR *name, ADDRESS name__len);
+import void Heap_GC (BOOLEAN markStack);
+import void Heap_INCREF (Heap_Module m);
+import void Heap_InitHeap (void);
+import void Heap_Lock (void);
+import SYSTEM_PTR Heap_NEWBLK (INT32 size);
+import SYSTEM_PTR Heap_NEWREC (INT32 tag);
+import void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd);
+import SYSTEM_PTR Heap_REGMOD (Heap_ModuleName name, Heap_EnumProc enumPtrs);
+import void Heap_REGTYP (Heap_Module m, INT32 typ);
+import void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize);
+import void Heap_Unlock (void);
+import void *Heap__init(void);
+
+
+#endif // Heap

bootstrap/unix-44/Modules.c

@@ -0,0 +1,506 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "Heap.h"
+#include "Platform.h"
+
+
+export INT16 Modules_res;
+export CHAR Modules_resMsg[256];
+export Heap_ModuleName Modules_imported, Modules_importing;
+export INT32 Modules_MainStackFrame;
+export INT16 Modules_ArgCount;
+export INT32 Modules_ArgVector;
+export CHAR Modules_BinaryDir[1024];
+
+
+static void Modules_Append (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len);
+static void Modules_AppendPart (CHAR c, CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len);
+export INT16 Modules_ArgPos (CHAR *s, ADDRESS s__len);
+export void Modules_AssertFail (INT32 code);
+static void Modules_Canonify (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len);
+static INT16 Modules_CharCount (CHAR *s, ADDRESS s__len);
+static void Modules_DisplayHaltCode (INT32 code);
+static void Modules_ExtractPart (CHAR *s, ADDRESS s__len, INT16 *i, CHAR *p, ADDRESS p__len, CHAR *d, ADDRESS d__len);
+static void Modules_FindBinaryDir (CHAR *binarydir, ADDRESS binarydir__len);
+export void Modules_Free (CHAR *name, ADDRESS name__len, BOOLEAN all);
+export void Modules_GetArg (INT16 n, CHAR *val, ADDRESS val__len);
+export void Modules_GetIntArg (INT16 n, INT32 *val);
+export void Modules_Halt (INT32 code);
+export void Modules_Init (INT32 argc, INT32 argvadr);
+static BOOLEAN Modules_IsAbsolute (CHAR *d, ADDRESS d__len);
+static BOOLEAN Modules_IsFilePresent (CHAR *s, ADDRESS s__len);
+static BOOLEAN Modules_IsOneOf (CHAR c, CHAR *s, ADDRESS s__len);
+export Heap_Command Modules_ThisCommand (Heap_Module mod, CHAR *name, ADDRESS name__len);
+export Heap_Module Modules_ThisMod (CHAR *name, ADDRESS name__len);
+static void Modules_Trim (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len);
+static void Modules_errch (CHAR c);
+static void Modules_errint (INT32 l);
+static void Modules_errstring (CHAR *s, ADDRESS s__len);
+
+extern void Heap_InitHeap();
+extern void *Modules__init(void);
+#define Modules_InitHeap()	Heap_InitHeap()
+#define Modules_ModulesInit()	Modules__init()
+#define Modules_modules()	(Heap_Module)Heap_modules
+
+void Modules_Init (INT32 argc, INT32 argvadr)
+{
+	Modules_MainStackFrame = argvadr;
+	Modules_ArgCount = __VAL(INT16, argc);
+	__GET(argvadr, Modules_ArgVector, INT32);
+	Modules_InitHeap();
+	Modules_ModulesInit();
+}
+
+typedef
+	CHAR (*argptr__15)[1024];
+
+void Modules_GetArg (INT16 n, CHAR *val, ADDRESS val__len)
+{
+	argptr__15 arg = NIL;
+	if (n < Modules_ArgCount) {
+		__GET(Modules_ArgVector + __ASHL(n, 2), arg, argptr__15);
+		__COPY(*arg, val, val__len);
+	}
+}
+
+void Modules_GetIntArg (INT16 n, INT32 *val)
+{
+	CHAR s[64];
+	INT32 k, d, i;
+	s[0] = 0x00;
+	Modules_GetArg(n, (void*)s, 64);
+	i = 0;
+	if (s[0] == '-') {
+		i = 1;
+	}
+	k = 0;
+	d = (INT16)s[__X(i, 64)] - 48;
+	while ((d >= 0 && d <= 9)) {
+		k = k * 10 + d;
+		i += 1;
+		d = (INT16)s[__X(i, 64)] - 48;
+	}
+	if (s[0] == '-') {
+		k = -k;
+		i -= 1;
+	}
+	if (i > 0) {
+		*val = k;
+	}
+}
+
+INT16 Modules_ArgPos (CHAR *s, ADDRESS s__len)
+{
+	INT16 i;
+	CHAR arg[256];
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	Modules_GetArg(i, (void*)arg, 256);
+	while ((i < Modules_ArgCount && __STRCMP(s, arg) != 0)) {
+		i += 1;
+		Modules_GetArg(i, (void*)arg, 256);
+	}
+	__DEL(s);
+	return i;
+}
+
+static INT16 Modules_CharCount (CHAR *s, ADDRESS s__len)
+{
+	INT16 i;
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	while ((i < s__len && s[__X(i, s__len)] != 0x00)) {
+		i += 1;
+	}
+	__DEL(s);
+	return i;
+}
+
+static void Modules_Append (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len)
+{
+	INT16 i, j;
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	j = Modules_CharCount(d, d__len);
+	while (s[__X(i, s__len)] != 0x00) {
+		d[__X(j, d__len)] = s[__X(i, s__len)];
+		i += 1;
+		j += 1;
+	}
+	d[__X(j, d__len)] = 0x00;
+	__DEL(s);
+}
+
+static void Modules_AppendPart (CHAR c, CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len)
+{
+	INT16 i, j;
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	j = Modules_CharCount(d, d__len);
+	if ((j > 0 && d[__X(j - 1, d__len)] != c)) {
+		d[__X(j, d__len)] = c;
+		j += 1;
+	}
+	while (s[__X(i, s__len)] != 0x00) {
+		d[__X(j, d__len)] = s[__X(i, s__len)];
+		i += 1;
+		j += 1;
+	}
+	d[__X(j, d__len)] = 0x00;
+	__DEL(s);
+}
+
+static BOOLEAN Modules_IsOneOf (CHAR c, CHAR *s, ADDRESS s__len)
+{
+	INT16 i;
+	__DUP(s, s__len, CHAR);
+	if (c == 0x00) {
+		__DEL(s);
+		return 0;
+	}
+	i = 0;
+	while ((s[__X(i, s__len)] != c && s[__X(i, s__len)] != 0x00)) {
+		i += 1;
+	}
+	__DEL(s);
+	return s[__X(i, s__len)] == c;
+}
+
+static BOOLEAN Modules_IsAbsolute (CHAR *d, ADDRESS d__len)
+{
+	__DUP(d, d__len, CHAR);
+	if (d[0] == 0x00) {
+		__DEL(d);
+		return 0;
+	}
+	if (Modules_IsOneOf(d[0], (CHAR*)"/\\", 3)) {
+		__DEL(d);
+		return 1;
+	}
+	if (d[__X(1, d__len)] == ':') {
+		__DEL(d);
+		return 1;
+	}
+	__DEL(d);
+	return 0;
+}
+
+static void Modules_Canonify (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len)
+{
+	__DUP(s, s__len, CHAR);
+	if (Modules_IsAbsolute(s, s__len)) {
+		__COPY(s, d, d__len);
+	} else {
+		__COPY(Platform_CWD, d, d__len);
+		Modules_AppendPart('/', s, s__len, (void*)d, d__len);
+	}
+	__DEL(s);
+}
+
+static BOOLEAN Modules_IsFilePresent (CHAR *s, ADDRESS s__len)
+{
+	Platform_FileIdentity identity;
+	__DUP(s, s__len, CHAR);
+	__DEL(s);
+	return Platform_IdentifyByName(s, s__len, &identity, Platform_FileIdentity__typ) == 0;
+}
+
+static void Modules_ExtractPart (CHAR *s, ADDRESS s__len, INT16 *i, CHAR *p, ADDRESS p__len, CHAR *d, ADDRESS d__len)
+{
+	INT16 j;
+	__DUP(s, s__len, CHAR);
+	__DUP(p, p__len, CHAR);
+	j = 0;
+	while ((s[__X(*i, s__len)] != 0x00 && !Modules_IsOneOf(s[__X(*i, s__len)], p, p__len))) {
+		d[__X(j, d__len)] = s[__X(*i, s__len)];
+		*i += 1;
+		j += 1;
+	}
+	d[__X(j, d__len)] = 0x00;
+	while (Modules_IsOneOf(s[__X(*i, s__len)], p, p__len)) {
+		*i += 1;
+	}
+	__DEL(s);
+	__DEL(p);
+}
+
+static void Modules_Trim (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len)
+{
+	INT16 i, j;
+	CHAR part[1024];
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	j = 0;
+	while ((i < 2 && Modules_IsOneOf(s[__X(i, s__len)], (CHAR*)"/\\", 3))) {
+		i += 1;
+		d[__X(j, d__len)] = '/';
+		j += 1;
+	}
+	d[__X(j, d__len)] = 0x00;
+	while (s[__X(i, s__len)] != 0x00) {
+		Modules_ExtractPart(s, s__len, &i, (CHAR*)"/\\", 3, (void*)part, 1024);
+		if ((part[0] != 0x00 && __STRCMP(part, ".") != 0)) {
+			Modules_AppendPart('/', part, 1024, (void*)d, d__len);
+		}
+	}
+	__DEL(s);
+}
+
+typedef
+	CHAR pathstring__12[4096];
+
+static void Modules_FindBinaryDir (CHAR *binarydir, ADDRESS binarydir__len)
+{
+	pathstring__12 arg0, pathlist, pathdir, tempstr;
+	INT16 i, j, k;
+	BOOLEAN present;
+	if (Modules_ArgCount < 1) {
+		binarydir[0] = 0x00;
+		return;
+	}
+	Modules_GetArg(0, (void*)arg0, 4096);
+	i = 0;
+	while ((((arg0[__X(i, 4096)] != 0x00 && arg0[__X(i, 4096)] != '/')) && arg0[__X(i, 4096)] != '\\')) {
+		i += 1;
+	}
+	if (arg0[__X(i, 4096)] == '/' || arg0[__X(i, 4096)] == '\\') {
+		Modules_Trim(arg0, 4096, (void*)tempstr, 4096);
+		Modules_Canonify(tempstr, 4096, (void*)binarydir, binarydir__len);
+		present = Modules_IsFilePresent(binarydir, binarydir__len);
+	} else {
+		Platform_GetEnv((CHAR*)"PATH", 5, (void*)pathlist, 4096);
+		i = 0;
+		present = 0;
+		while ((!present && pathlist[__X(i, 4096)] != 0x00)) {
+			Modules_ExtractPart(pathlist, 4096, &i, (CHAR*)":;", 3, (void*)pathdir, 4096);
+			Modules_AppendPart('/', arg0, 4096, (void*)pathdir, 4096);
+			Modules_Trim(pathdir, 4096, (void*)tempstr, 4096);
+			Modules_Canonify(tempstr, 4096, (void*)binarydir, binarydir__len);
+			present = Modules_IsFilePresent(binarydir, binarydir__len);
+		}
+	}
+	if (present) {
+		k = Modules_CharCount(binarydir, binarydir__len);
+		while ((k > 0 && !Modules_IsOneOf(binarydir[__X(k - 1, binarydir__len)], (CHAR*)"/\\", 3))) {
+			k -= 1;
+		}
+		if (k == 0) {
+			binarydir[__X(k, binarydir__len)] = 0x00;
+		} else {
+			binarydir[__X(k - 1, binarydir__len)] = 0x00;
+		}
+	} else {
+		binarydir[0] = 0x00;
+	}
+}
+
+Heap_Module Modules_ThisMod (CHAR *name, ADDRESS name__len)
+{
+	Heap_Module m = NIL;
+	CHAR bodyname[64];
+	Heap_Command body;
+	__DUP(name, name__len, CHAR);
+	m = Modules_modules();
+	while ((m != NIL && __STRCMP(m->name, name) != 0)) {
+		m = m->next;
+	}
+	if (m != NIL) {
+		Modules_res = 0;
+		Modules_resMsg[0] = 0x00;
+	} else {
+		Modules_res = 1;
+		__COPY(name, Modules_importing, 20);
+		__MOVE(" module \"", Modules_resMsg, 10);
+		Modules_Append(name, name__len, (void*)Modules_resMsg, 256);
+		Modules_Append((CHAR*)"\" not found", 12, (void*)Modules_resMsg, 256);
+	}
+	__DEL(name);
+	return m;
+}
+
+Heap_Command Modules_ThisCommand (Heap_Module mod, CHAR *name, ADDRESS name__len)
+{
+	Heap_Cmd c = NIL;
+	__DUP(name, name__len, CHAR);
+	c = mod->cmds;
+	while ((c != NIL && __STRCMP(c->name, name) != 0)) {
+		c = c->next;
+	}
+	if (c != NIL) {
+		Modules_res = 0;
+		Modules_resMsg[0] = 0x00;
+		__DEL(name);
+		return c->cmd;
+	} else {
+		Modules_res = 2;
+		__MOVE(" command \"", Modules_resMsg, 11);
+		__COPY(name, Modules_importing, 20);
+		Modules_Append(mod->name, 20, (void*)Modules_resMsg, 256);
+		Modules_Append((CHAR*)".", 2, (void*)Modules_resMsg, 256);
+		Modules_Append(name, name__len, (void*)Modules_resMsg, 256);
+		Modules_Append((CHAR*)"\" not found", 12, (void*)Modules_resMsg, 256);
+		__DEL(name);
+		return NIL;
+	}
+	__RETCHK;
+}
+
+void Modules_Free (CHAR *name, ADDRESS name__len, BOOLEAN all)
+{
+	Heap_Module m = NIL, p = NIL;
+	INT32 refcount;
+	__DUP(name, name__len, CHAR);
+	m = Modules_modules();
+	if (all) {
+		Modules_res = 1;
+		__MOVE("unloading \"all\" not yet supported", Modules_resMsg, 34);
+	} else {
+		refcount = Heap_FreeModule(name, name__len);
+		if (refcount == 0) {
+			Modules_res = 0;
+		} else {
+			if (refcount < 0) {
+				__MOVE("module not found", Modules_resMsg, 17);
+			} else {
+				__MOVE("clients of this module exist", Modules_resMsg, 29);
+			}
+			Modules_res = 1;
+		}
+	}
+	__DEL(name);
+}
+
+static void Modules_errch (CHAR c)
+{
+	INT16 e;
+	e = Platform_Write(1, (ADDRESS)&c, 1);
+}
+
+static void Modules_errstring (CHAR *s, ADDRESS s__len)
+{
+	INT32 i;
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	while ((i < s__len && s[__X(i, s__len)] != 0x00)) {
+		Modules_errch(s[__X(i, s__len)]);
+		i += 1;
+	}
+	__DEL(s);
+}
+
+static void Modules_errint (INT32 l)
+{
+	if (l < 0) {
+		Modules_errch('-');
+		l = -l;
+	}
+	if (l >= 10) {
+		Modules_errint(__DIV(l, 10));
+	}
+	Modules_errch(__CHR((int)__MOD(l, 10) + 48));
+}
+
+static void Modules_DisplayHaltCode (INT32 code)
+{
+	switch (code) {
+		case -1: 
+			Modules_errstring((CHAR*)"Assertion failure.", 19);
+			break;
+		case -2: 
+			Modules_errstring((CHAR*)"Index out of range.", 20);
+			break;
+		case -3: 
+			Modules_errstring((CHAR*)"Reached end of function without reaching RETURN.", 49);
+			break;
+		case -4: 
+			Modules_errstring((CHAR*)"CASE statement: no matching label and no ELSE.", 47);
+			break;
+		case -5: 
+			Modules_errstring((CHAR*)"Type guard failed.", 19);
+			break;
+		case -6: 
+			Modules_errstring((CHAR*)"Implicit type guard in record assignment failed.", 49);
+			break;
+		case -7: 
+			Modules_errstring((CHAR*)"Invalid case in WITH statement.", 32);
+			break;
+		case -8: 
+			Modules_errstring((CHAR*)"Value out of range.", 20);
+			break;
+		case -9: 
+			Modules_errstring((CHAR*)"Heap interrupted while locked, but lockdepth = 0 at unlock.", 60);
+			break;
+		case -10: 
+			Modules_errstring((CHAR*)"NIL access.", 12);
+			break;
+		case -11: 
+			Modules_errstring((CHAR*)"Alignment error.", 17);
+			break;
+		case -12: 
+			Modules_errstring((CHAR*)"Divide by zero.", 16);
+			break;
+		case -13: 
+			Modules_errstring((CHAR*)"Arithmetic overflow/underflow.", 31);
+			break;
+		case -14: 
+			Modules_errstring((CHAR*)"Invalid function argument.", 27);
+			break;
+		case -15: 
+			Modules_errstring((CHAR*)"Internal error, e.g. Type descriptor size mismatch.", 52);
+			break;
+		case -20: 
+			Modules_errstring((CHAR*)"Too many, or negative number of, elements in dynamic array.", 60);
+			break;
+		default: 
+			break;
+	}
+}
+
+void Modules_Halt (INT32 code)
+{
+	Heap_FINALL();
+	Modules_errstring((CHAR*)"Terminated by Halt(", 20);
+	Modules_errint(code);
+	Modules_errstring((CHAR*)"). ", 4);
+	if (code < 0) {
+		Modules_DisplayHaltCode(code);
+	}
+	Modules_errstring(Platform_NL, 3);
+	Platform_Exit(code);
+}
+
+void Modules_AssertFail (INT32 code)
+{
+	Heap_FINALL();
+	Modules_errstring((CHAR*)"Assertion failure.", 19);
+	if (code != 0) {
+		Modules_errstring((CHAR*)" ASSERT code ", 14);
+		Modules_errint(code);
+		Modules_errstring((CHAR*)".", 2);
+	}
+	Modules_errstring(Platform_NL, 3);
+	if (code > 0) {
+		Platform_Exit(code);
+	} else {
+		Platform_Exit(-1);
+	}
+}
+
+
+export void *Modules__init(void)
+{
+	__DEFMOD;
+	__MODULE_IMPORT(Heap);
+	__MODULE_IMPORT(Platform);
+	__REGMOD("Modules", 0);
+/* BEGIN */
+	Modules_FindBinaryDir((void*)Modules_BinaryDir, 1024);
+	__ENDMOD;
+}

bootstrap/unix-44/Modules.h

@@ -0,0 +1,31 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Modules__h
+#define Modules__h
+
+#include "SYSTEM.h"
+#include "Heap.h"
+
+
+import INT16 Modules_res;
+import CHAR Modules_resMsg[256];
+import Heap_ModuleName Modules_imported, Modules_importing;
+import INT32 Modules_MainStackFrame;
+import INT16 Modules_ArgCount;
+import INT32 Modules_ArgVector;
+import CHAR Modules_BinaryDir[1024];
+
+
+import INT16 Modules_ArgPos (CHAR *s, ADDRESS s__len);
+import void Modules_AssertFail (INT32 code);
+import void Modules_Free (CHAR *name, ADDRESS name__len, BOOLEAN all);
+import void Modules_GetArg (INT16 n, CHAR *val, ADDRESS val__len);
+import void Modules_GetIntArg (INT16 n, INT32 *val);
+import void Modules_Halt (INT32 code);
+import void Modules_Init (INT32 argc, INT32 argvadr);
+import Heap_Command Modules_ThisCommand (Heap_Module mod, CHAR *name, ADDRESS name__len);
+import Heap_Module Modules_ThisMod (CHAR *name, ADDRESS name__len);
+import void *Modules__init(void);
+
+
+#endif // Modules

bootstrap/unix-44/OPB.h

@@ -0,0 +1,48 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPB__h
+#define OPB__h
+
+#include "SYSTEM.h"
+#include "OPS.h"
+#include "OPT.h"
+
+
+
+
+import void OPB_Assign (OPT_Node *x, OPT_Node y);
+import void OPB_Call (OPT_Node *x, OPT_Node apar, OPT_Object fp);
+import void OPB_CheckParameters (OPT_Object fp, OPT_Object ap, BOOLEAN checkNames);
+import void OPB_Construct (INT8 class, OPT_Node *x, OPT_Node y);
+import void OPB_DeRef (OPT_Node *x);
+import OPT_Node OPB_EmptySet (void);
+import void OPB_Enter (OPT_Node *procdec, OPT_Node stat, OPT_Object proc);
+import void OPB_Field (OPT_Node *x, OPT_Object y);
+import void OPB_In (OPT_Node *x, OPT_Node y);
+import void OPB_Index (OPT_Node *x, OPT_Node y);
+import void OPB_Inittd (OPT_Node *inittd, OPT_Node *last, OPT_Struct typ);
+import void OPB_Link (OPT_Node *x, OPT_Node *last, OPT_Node y);
+import void OPB_MOp (INT8 op, OPT_Node *x);
+import OPT_Node OPB_NewBoolConst (BOOLEAN boolval);
+import OPT_Node OPB_NewIntConst (INT64 intval);
+import OPT_Node OPB_NewLeaf (OPT_Object obj);
+import OPT_Node OPB_NewRealConst (LONGREAL realval, OPT_Struct typ);
+import OPT_Node OPB_NewString (OPS_String str, INT64 len);
+import OPT_Node OPB_Nil (void);
+import void OPB_Op (INT8 op, OPT_Node *x, OPT_Node y);
+import void OPB_OptIf (OPT_Node *x);
+import void OPB_Param (OPT_Node ap, OPT_Object fp);
+import void OPB_PrepCall (OPT_Node *x, OPT_Object *fpar);
+import void OPB_Return (OPT_Node *x, OPT_Object proc);
+import void OPB_SetElem (OPT_Node *x);
+import void OPB_SetRange (OPT_Node *x, OPT_Node y);
+import void OPB_StFct (OPT_Node *par0, INT8 fctno, INT16 parno);
+import void OPB_StPar0 (OPT_Node *par0, INT16 fctno);
+import void OPB_StPar1 (OPT_Node *par0, OPT_Node x, INT8 fctno);
+import void OPB_StParN (OPT_Node *par0, OPT_Node x, INT16 fctno, INT16 n);
+import void OPB_StaticLink (INT8 dlev);
+import void OPB_TypTest (OPT_Node *x, OPT_Object obj, BOOLEAN guard);
+import void *OPB__init(void);
+
+
+#endif // OPB

bootstrap/unix-44/OPC.h

@@ -0,0 +1,49 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPC__h
+#define OPC__h
+
+#include "SYSTEM.h"
+#include "OPT.h"
+
+
+
+
+import void OPC_Andent (OPT_Struct typ);
+import OPT_Object OPC_BaseTProc (OPT_Object obj);
+import void OPC_BegBlk (void);
+import void OPC_BegStat (void);
+import void OPC_Case (INT64 caseVal, INT16 form);
+import void OPC_Cmp (INT16 rel);
+import void OPC_CompleteIdent (OPT_Object obj);
+import void OPC_Constant (OPT_Const con, INT16 form);
+import void OPC_DefineInter (OPT_Object proc);
+import void OPC_EndBlk (void);
+import void OPC_EndBlk0 (void);
+import void OPC_EndStat (void);
+import void OPC_EnterBody (void);
+import void OPC_EnterProc (OPT_Object proc);
+import void OPC_ExitBody (void);
+import void OPC_ExitProc (OPT_Object proc, BOOLEAN eoBlock, BOOLEAN implicitRet);
+import void OPC_GenBdy (OPT_Node n);
+import void OPC_GenEnumPtrs (OPT_Object var);
+import void OPC_GenHdr (OPT_Node n);
+import void OPC_GenHdrIncludes (void);
+import void OPC_Halt (INT32 n);
+import void OPC_Ident (OPT_Object obj);
+import void OPC_Increment (BOOLEAN decrement);
+import void OPC_Indent (INT16 count);
+import void OPC_Init (void);
+import void OPC_InitTDesc (OPT_Struct typ);
+import void OPC_IntLiteral (INT64 n, INT32 size);
+import void OPC_Len (OPT_Object obj, OPT_Struct array, INT64 dim);
+import BOOLEAN OPC_NeedsRetval (OPT_Object proc);
+import INT32 OPC_NofPtrs (OPT_Struct typ);
+import void OPC_SetInclude (BOOLEAN exclude);
+import void OPC_TDescDecl (OPT_Struct typ);
+import void OPC_TypeDefs (OPT_Object obj, INT16 vis);
+import void OPC_TypeOf (OPT_Object ap);
+import void *OPC__init(void);
+
+
+#endif // OPC

bootstrap/unix-44/OPM.h

@@ -0,0 +1,76 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPM__h
+#define OPM__h
+
+#include "SYSTEM.h"
+
+
+import CHAR OPM_Model[10];
+import INT16 OPM_AddressSize, OPM_Alignment;
+import UINT32 OPM_GlobalOptions, OPM_Options;
+import INT16 OPM_ShortintSize, OPM_IntegerSize, OPM_LongintSize, OPM_SetSize;
+import INT64 OPM_MaxIndex;
+import LONGREAL OPM_MinReal, OPM_MaxReal, OPM_MinLReal, OPM_MaxLReal;
+import BOOLEAN OPM_noerr;
+import INT32 OPM_curpos, OPM_errpos, OPM_breakpc;
+import INT16 OPM_currFile, OPM_level, OPM_pc, OPM_entno;
+import CHAR OPM_modName[32];
+import CHAR OPM_objname[64];
+import CHAR OPM_InstallDir[1024];
+import CHAR OPM_ResourceDir[1024];
+
+
+import void OPM_CloseFiles (void);
+import void OPM_CloseOldSym (void);
+import void OPM_DeleteObj (CHAR *modulename, ADDRESS modulename__len);
+import void OPM_DeleteSym (CHAR *modulename, ADDRESS modulename__len);
+import void OPM_FPrint (INT32 *fp, INT64 val);
+import void OPM_FPrintLReal (INT32 *fp, LONGREAL val);
+import void OPM_FPrintReal (INT32 *fp, REAL val);
+import void OPM_FPrintSet (INT32 *fp, UINT64 val);
+import void OPM_Get (CHAR *ch);
+import void OPM_GetComment (CHAR *text, ADDRESS text__len);
+import void OPM_Init (BOOLEAN *done);
+import void OPM_InitOptions (void);
+import INT16 OPM_Integer (INT64 n);
+import void OPM_LogCompiling (CHAR *modname, ADDRESS modname__len);
+import void OPM_LogVT100 (CHAR *vt100code, ADDRESS vt100code__len);
+import void OPM_LogW (CHAR ch);
+import void OPM_LogWLn (void);
+import void OPM_LogWNum (INT64 i, INT64 len);
+import void OPM_LogWStr (CHAR *s, ADDRESS s__len);
+import INT32 OPM_Longint (INT64 n);
+import void OPM_Mark (INT16 n, INT32 pos);
+import void OPM_NewSym (CHAR *modName, ADDRESS modName__len);
+import void OPM_OldSym (CHAR *modName, ADDRESS modName__len, BOOLEAN *done);
+import void OPM_OpenFiles (CHAR *moduleName, ADDRESS moduleName__len);
+import BOOLEAN OPM_OpenPar (void);
+import void OPM_RegisterNewSym (void);
+import INT64 OPM_SignedMaximum (INT32 bytecount);
+import INT64 OPM_SignedMinimum (INT32 bytecount);
+import void OPM_StoreComment (CHAR *text, ADDRESS text__len);
+import void OPM_SymRCh (CHAR *ch);
+import INT32 OPM_SymRInt (void);
+import INT64 OPM_SymRInt64 (void);
+import void OPM_SymRLReal (LONGREAL *lr);
+import void OPM_SymRReal (REAL *r);
+import void OPM_SymRSet (UINT64 *s);
+import void OPM_SymWCh (CHAR ch);
+import void OPM_SymWInt (INT64 i);
+import void OPM_SymWLReal (LONGREAL lr);
+import void OPM_SymWReal (REAL r);
+import void OPM_SymWSet (UINT64 s);
+import void OPM_Write (CHAR ch);
+import void OPM_WriteHex (INT64 i);
+import void OPM_WriteInt (INT64 i);
+import void OPM_WriteLn (void);
+import void OPM_WriteReal (LONGREAL r, CHAR suffx);
+import void OPM_WriteString (CHAR *s, ADDRESS s__len);
+import void OPM_WriteStringVar (CHAR *s, ADDRESS s__len);
+import BOOLEAN OPM_eofSF (void);
+import void OPM_err (INT16 n);
+import void *OPM__init(void);
+
+
+#endif // OPM

bootstrap/unix-44/OPP.h

@@ -0,0 +1,16 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPP__h
+#define OPP__h
+
+#include "SYSTEM.h"
+#include "OPT.h"
+
+
+
+
+import void OPP_Module (OPT_Node *prog, UINT32 opt);
+import void *OPP__init(void);
+
+
+#endif // OPP

bootstrap/unix-44/OPS.c

@@ -0,0 +1,666 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "OPM.h"
+
+typedef
+	CHAR OPS_Name[256];
+
+typedef
+	CHAR OPS_String[256];
+
+
+export OPS_Name OPS_name;
+export OPS_String OPS_str;
+export INT16 OPS_numtyp;
+export INT64 OPS_intval;
+export REAL OPS_realval;
+export LONGREAL OPS_lrlval;
+static CHAR OPS_ch;
+
+
+export void OPS_Get (INT8 *sym);
+static void OPS_Identifier (INT8 *sym);
+export void OPS_Init (void);
+static void OPS_Number (void);
+static void OPS_Str (INT8 *sym);
+static void OPS_err (INT16 n);
+
+
+static void OPS_err (INT16 n)
+{
+	OPM_err(n);
+}
+
+static void OPS_Str (INT8 *sym)
+{
+	INT16 i;
+	CHAR och;
+	i = 0;
+	och = OPS_ch;
+	for (;;) {
+		OPM_Get(&OPS_ch);
+		if (OPS_ch == och) {
+			break;
+		}
+		if (OPS_ch < ' ') {
+			OPS_err(3);
+			break;
+		}
+		if (i == 255) {
+			OPS_err(241);
+			break;
+		}
+		OPS_str[__X(i, 256)] = OPS_ch;
+		i += 1;
+	}
+	OPM_Get(&OPS_ch);
+	OPS_str[__X(i, 256)] = 0x00;
+	OPS_intval = i + 1;
+	if (OPS_intval == 2) {
+		*sym = 35;
+		OPS_numtyp = 1;
+		OPS_intval = (INT16)OPS_str[0];
+	} else {
+		*sym = 37;
+	}
+}
+
+static void OPS_Identifier (INT8 *sym)
+{
+	INT16 i;
+	i = 0;
+	do {
+		OPS_name[__X(i, 256)] = OPS_ch;
+		i += 1;
+		OPM_Get(&OPS_ch);
+	} while (!(((OPS_ch < '0' || ('9' < OPS_ch && __CAP(OPS_ch) < 'A')) || 'Z' < __CAP(OPS_ch)) || i == 256));
+	if (i == 256) {
+		OPS_err(240);
+		i -= 1;
+	}
+	OPS_name[__X(i, 256)] = 0x00;
+	*sym = 38;
+}
+
+static struct Number__6 {
+	struct Number__6 *lnk;
+} *Number__6_s;
+
+static INT16 Ord__7 (CHAR ch, BOOLEAN hex);
+static LONGREAL Ten__9 (INT16 e);
+
+static LONGREAL Ten__9 (INT16 e)
+{
+	LONGREAL x, p;
+	x = (LONGREAL)1;
+	p = (LONGREAL)10;
+	while (e > 0) {
+		if (__ODD(e)) {
+			x = x * p;
+		}
+		e = __ASHR(e, 1);
+		if (e > 0) {
+			p = p * p;
+		}
+	}
+	return x;
+}
+
+static INT16 Ord__7 (CHAR ch, BOOLEAN hex)
+{
+	if (ch <= '9') {
+		return (INT16)ch - 48;
+	} else if (hex) {
+		return ((INT16)ch - 65) + 10;
+	} else {
+		OPS_err(2);
+		return 0;
+	}
+	__RETCHK;
+}
+
+static void OPS_Number (void)
+{
+	INT16 i, m, n, d, e;
+	CHAR dig[24];
+	LONGREAL f;
+	CHAR expCh;
+	BOOLEAN neg;
+	struct Number__6 _s;
+	_s.lnk = Number__6_s;
+	Number__6_s = &_s;
+	i = 0;
+	m = 0;
+	n = 0;
+	d = 0;
+	for (;;) {
+		if (('0' <= OPS_ch && OPS_ch <= '9') || (((d == 0 && 'A' <= OPS_ch)) && OPS_ch <= 'F')) {
+			if (m > 0 || OPS_ch != '0') {
+				if (n < 24) {
+					dig[__X(n, 24)] = OPS_ch;
+					n += 1;
+				}
+				m += 1;
+			}
+			OPM_Get(&OPS_ch);
+			i += 1;
+		} else if (OPS_ch == '.') {
+			OPM_Get(&OPS_ch);
+			if (OPS_ch == '.') {
+				OPS_ch = 0x7f;
+				break;
+			} else if (d == 0) {
+				d = i;
+			} else {
+				OPS_err(2);
+			}
+		} else {
+			break;
+		}
+	}
+	if (d == 0) {
+		if (n == m) {
+			OPS_intval = 0;
+			i = 0;
+			if (OPS_ch == 'X') {
+				OPM_Get(&OPS_ch);
+				OPS_numtyp = 1;
+				if (n <= 2) {
+					while (i < n) {
+						OPS_intval = __ASHL(OPS_intval, 4) + (INT64)Ord__7(dig[__X(i, 24)], 1);
+						i += 1;
+					}
+				} else {
+					OPS_err(203);
+				}
+			} else if (OPS_ch == 'H') {
+				OPM_Get(&OPS_ch);
+				OPS_numtyp = 2;
+				if (n <= 16) {
+					if ((n == 16 && dig[0] > '7')) {
+						OPS_intval = -1;
+					}
+					while (i < n) {
+						OPS_intval = __ASHL(OPS_intval, 4) + (INT64)Ord__7(dig[__X(i, 24)], 1);
+						i += 1;
+					}
+				} else {
+					OPS_err(203);
+				}
+			} else {
+				OPS_numtyp = 2;
+				while (i < n) {
+					d = Ord__7(dig[__X(i, 24)], 0);
+					i += 1;
+					if (OPS_intval <= __DIV(9223372036854775807LL - (INT64)d, 10)) {
+						OPS_intval = OPS_intval * 10 + (INT64)d;
+					} else {
+						OPS_err(203);
+					}
+				}
+			}
+		} else {
+			OPS_err(203);
+		}
+	} else {
+		f = (LONGREAL)0;
+		e = 0;
+		expCh = 'E';
+		while (n > 0) {
+			n -= 1;
+			f = (Ord__7(dig[__X(n, 24)], 0) + f) / (LONGREAL)(LONGREAL)10;
+		}
+		if (OPS_ch == 'E' || OPS_ch == 'D') {
+			expCh = OPS_ch;
+			OPM_Get(&OPS_ch);
+			neg = 0;
+			if (OPS_ch == '-') {
+				neg = 1;
+				OPM_Get(&OPS_ch);
+			} else if (OPS_ch == '+') {
+				OPM_Get(&OPS_ch);
+			}
+			if (('0' <= OPS_ch && OPS_ch <= '9')) {
+				do {
+					n = Ord__7(OPS_ch, 0);
+					OPM_Get(&OPS_ch);
+					if (e <= __DIV(32767 - n, 10)) {
+						e = e * 10 + n;
+					} else {
+						OPS_err(203);
+					}
+				} while (!(OPS_ch < '0' || '9' < OPS_ch));
+				if (neg) {
+					e = -e;
+				}
+			} else {
+				OPS_err(2);
+			}
+		}
+		e -= (i - d) - m;
+		if (expCh == 'E') {
+			OPS_numtyp = 3;
+			if ((-37 < e && e <= 38)) {
+				if (e < 0) {
+					OPS_realval = (f / (LONGREAL)Ten__9(-e));
+				} else {
+					OPS_realval = (f * Ten__9(e));
+				}
+			} else {
+				OPS_err(203);
+			}
+		} else {
+			OPS_numtyp = 4;
+			if ((-307 < e && e <= 308)) {
+				if (e < 0) {
+					OPS_lrlval = f / (LONGREAL)Ten__9(-e);
+				} else {
+					OPS_lrlval = f * Ten__9(e);
+				}
+			} else {
+				OPS_err(203);
+			}
+		}
+	}
+	Number__6_s = _s.lnk;
+}
+
+static struct Get__1 {
+	struct Get__1 *lnk;
+} *Get__1_s;
+
+static void Comment__2 (void);
+
+static void Comment__2 (void)
+{
+	BOOLEAN isExported;
+	CHAR commentText[256];
+	INT16 i, nestLevel;
+	CHAR prevCh, nextCh;
+	i = 0;
+	while (i <= 255) {
+		commentText[__X(i, 256)] = 0x00;
+		i += 1;
+	}
+	isExported = 0;
+	i = 0;
+	nestLevel = 1;
+	prevCh = 0x00;
+	OPM_Get(&OPS_ch);
+	if (OPS_ch == '*') {
+		isExported = 1;
+		OPM_Get(&OPS_ch);
+		if (OPS_ch == ')') {
+			commentText[0] = 0x00;
+			OPM_StoreComment(commentText, 256);
+			OPM_Get(&OPS_ch);
+			return;
+		}
+	}
+	while ((nestLevel > 0 && OPS_ch != 0x00)) {
+		if ((prevCh == '(' && OPS_ch == '*')) {
+			nestLevel += 1;
+			prevCh = 0x00;
+		} else if ((prevCh == '*' && OPS_ch == ')')) {
+			nestLevel -= 1;
+			if (nestLevel == 0) {
+				OPM_Get(&OPS_ch);
+			} else {
+				prevCh = 0x00;
+			}
+		} else {
+			if ((((isExported && nestLevel == 1)) && prevCh != 0x00)) {
+				if (i < 255) {
+					commentText[__X(i, 256)] = prevCh;
+					i += 1;
+				}
+			}
+			prevCh = OPS_ch;
+		}
+		if (nestLevel > 0) {
+			OPM_Get(&OPS_ch);
+		}
+	}
+	if (OPS_ch == 0x00) {
+		OPS_err(5);
+	}
+	if ((((((isExported && nestLevel == 0)) && prevCh != 0x00)) && prevCh != '*')) {
+		if (i < 255) {
+			commentText[__X(i, 256)] = prevCh;
+			i += 1;
+		} else {
+			OPM_LogWStr((CHAR*)"Truncating final comment character", 35);
+			OPM_LogWLn();
+		}
+	}
+	if (isExported) {
+		if (i >= 256) {
+			OPM_LogWStr((CHAR*)"Warning: commentText overflow", 30);
+			OPM_LogWLn();
+			i = 255;
+		}
+		commentText[__X(i, 256)] = 0x00;
+		OPM_StoreComment(commentText, 256);
+	}
+}
+
+void OPS_Get (INT8 *sym)
+{
+	INT8 s;
+	struct Get__1 _s;
+	_s.lnk = Get__1_s;
+	Get__1_s = &_s;
+	OPM_errpos = OPM_curpos - 1;
+	while (OPS_ch <= ' ') {
+		if (OPS_ch == 0x00) {
+			*sym = 64;
+			Get__1_s = _s.lnk;
+			return;
+		} else {
+			OPM_Get(&OPS_ch);
+		}
+	}
+	switch (OPS_ch) {
+		case '"': case '\'': 
+			OPS_Str(&s);
+			break;
+		case '#': 
+			s = 10;
+			OPM_Get(&OPS_ch);
+			break;
+		case '&': 
+			s = 5;
+			OPM_Get(&OPS_ch);
+			break;
+		case '(': 
+			OPM_Get(&OPS_ch);
+			if (OPS_ch == '*') {
+				Comment__2();
+				OPS_Get(&s);
+			} else {
+				s = 30;
+			}
+			break;
+		case ')': 
+			s = 22;
+			OPM_Get(&OPS_ch);
+			break;
+		case '*': 
+			s = 1;
+			OPM_Get(&OPS_ch);
+			break;
+		case '+': 
+			s = 6;
+			OPM_Get(&OPS_ch);
+			break;
+		case ',': 
+			s = 19;
+			OPM_Get(&OPS_ch);
+			break;
+		case '-': 
+			s = 7;
+			OPM_Get(&OPS_ch);
+			break;
+		case '.': 
+			OPM_Get(&OPS_ch);
+			if (OPS_ch == '.') {
+				OPM_Get(&OPS_ch);
+				s = 21;
+			} else {
+				s = 18;
+			}
+			break;
+		case '/': 
+			s = 2;
+			OPM_Get(&OPS_ch);
+			break;
+		case '0': case '1': case '2': case '3': case '4': 
+		case '5': case '6': case '7': case '8': case '9': 
+			OPS_Number();
+			s = 35;
+			break;
+		case ':': 
+			OPM_Get(&OPS_ch);
+			if (OPS_ch == '=') {
+				OPM_Get(&OPS_ch);
+				s = 34;
+			} else {
+				s = 20;
+			}
+			break;
+		case ';': 
+			s = 39;
+			OPM_Get(&OPS_ch);
+			break;
+		case '<': 
+			OPM_Get(&OPS_ch);
+			if (OPS_ch == '=') {
+				OPM_Get(&OPS_ch);
+				s = 12;
+			} else {
+				s = 11;
+			}
+			break;
+		case '=': 
+			s = 9;
+			OPM_Get(&OPS_ch);
+			break;
+		case '>': 
+			OPM_Get(&OPS_ch);
+			if (OPS_ch == '=') {
+				OPM_Get(&OPS_ch);
+				s = 14;
+			} else {
+				s = 13;
+			}
+			break;
+		case 'A': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "ARRAY") == 0) {
+				s = 54;
+			}
+			break;
+		case 'B': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "BEGIN") == 0) {
+				s = 57;
+			} else if (__STRCMP(OPS_name, "BY") == 0) {
+				s = 29;
+			}
+			break;
+		case 'C': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "CASE") == 0) {
+				s = 46;
+			} else if (__STRCMP(OPS_name, "CONST") == 0) {
+				s = 58;
+			}
+			break;
+		case 'D': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "DO") == 0) {
+				s = 27;
+			} else if (__STRCMP(OPS_name, "DIV") == 0) {
+				s = 3;
+			}
+			break;
+		case 'E': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "END") == 0) {
+				s = 41;
+			} else if (__STRCMP(OPS_name, "ELSE") == 0) {
+				s = 42;
+			} else if (__STRCMP(OPS_name, "ELSIF") == 0) {
+				s = 43;
+			} else if (__STRCMP(OPS_name, "EXIT") == 0) {
+				s = 52;
+			}
+			break;
+		case 'F': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "FOR") == 0) {
+				s = 49;
+			}
+			break;
+		case 'I': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "IF") == 0) {
+				s = 45;
+			} else if (__STRCMP(OPS_name, "IN") == 0) {
+				s = 15;
+			} else if (__STRCMP(OPS_name, "IS") == 0) {
+				s = 16;
+			} else if (__STRCMP(OPS_name, "IMPORT") == 0) {
+				s = 62;
+			}
+			break;
+		case 'L': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "LOOP") == 0) {
+				s = 50;
+			}
+			break;
+		case 'M': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "MOD") == 0) {
+				s = 4;
+			} else if (__STRCMP(OPS_name, "MODULE") == 0) {
+				s = 63;
+			}
+			break;
+		case 'N': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "NIL") == 0) {
+				s = 36;
+			}
+			break;
+		case 'O': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "OR") == 0) {
+				s = 8;
+			} else if (__STRCMP(OPS_name, "OF") == 0) {
+				s = 25;
+			}
+			break;
+		case 'P': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "PROCEDURE") == 0) {
+				s = 61;
+			} else if (__STRCMP(OPS_name, "POINTER") == 0) {
+				s = 56;
+			}
+			break;
+		case 'R': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "RECORD") == 0) {
+				s = 55;
+			} else if (__STRCMP(OPS_name, "REPEAT") == 0) {
+				s = 48;
+			} else if (__STRCMP(OPS_name, "RETURN") == 0) {
+				s = 53;
+			}
+			break;
+		case 'T': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "THEN") == 0) {
+				s = 26;
+			} else if (__STRCMP(OPS_name, "TO") == 0) {
+				s = 28;
+			} else if (__STRCMP(OPS_name, "TYPE") == 0) {
+				s = 59;
+			}
+			break;
+		case 'U': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "UNTIL") == 0) {
+				s = 44;
+			}
+			break;
+		case 'V': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "VAR") == 0) {
+				s = 60;
+			}
+			break;
+		case 'W': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "WHILE") == 0) {
+				s = 47;
+			} else if (__STRCMP(OPS_name, "WITH") == 0) {
+				s = 51;
+			}
+			break;
+		case 'G': case 'H': case 'J': case 'K': case 'Q': 
+		case 'S': case 'X': case 'Y': case 'Z': 
+			OPS_Identifier(&s);
+			break;
+		case '[': 
+			s = 31;
+			OPM_Get(&OPS_ch);
+			break;
+		case ']': 
+			s = 23;
+			OPM_Get(&OPS_ch);
+			break;
+		case '^': 
+			s = 17;
+			OPM_Get(&OPS_ch);
+			break;
+		case 'a': case 'b': case 'c': case 'd': case 'e': 
+		case 'f': case 'g': case 'h': case 'i': case 'j': 
+		case 'k': case 'l': case 'm': case 'n': case 'o': 
+		case 'p': case 'q': case 'r': case 's': case 't': 
+		case 'u': case 'v': case 'w': case 'x': case 'y': 
+		case 'z': 
+			OPS_Identifier(&s);
+			break;
+		case '{': 
+			s = 32;
+			OPM_Get(&OPS_ch);
+			break;
+		case '|': 
+			s = 40;
+			OPM_Get(&OPS_ch);
+			break;
+		case '}': 
+			s = 24;
+			OPM_Get(&OPS_ch);
+			break;
+		case '~': 
+			s = 33;
+			OPM_Get(&OPS_ch);
+			break;
+		case 0x7f: 
+			s = 21;
+			OPM_Get(&OPS_ch);
+			break;
+		default: 
+			s = 0;
+			OPM_Get(&OPS_ch);
+			break;
+	}
+	*sym = s;
+	Get__1_s = _s.lnk;
+}
+
+void OPS_Init (void)
+{
+	OPS_ch = ' ';
+}
+
+
+export void *OPS__init(void)
+{
+	__DEFMOD;
+	__MODULE_IMPORT(OPM);
+	__REGMOD("OPS", 0);
+	__REGCMD("Init", OPS_Init);
+/* BEGIN */
+	__ENDMOD;
+}

bootstrap/unix-44/OPS.h

@@ -0,0 +1,28 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPS__h
+#define OPS__h
+
+#include "SYSTEM.h"
+
+typedef
+	CHAR OPS_Name[256];
+
+typedef
+	CHAR OPS_String[256];
+
+
+import OPS_Name OPS_name;
+import OPS_String OPS_str;
+import INT16 OPS_numtyp;
+import INT64 OPS_intval;
+import REAL OPS_realval;
+import LONGREAL OPS_lrlval;
+
+
+import void OPS_Get (INT8 *sym);
+import void OPS_Init (void);
+import void *OPS__init(void);
+
+
+#endif // OPS

bootstrap/unix-44/OPT.h

@@ -0,0 +1,128 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPT__h
+#define OPT__h
+
+#include "SYSTEM.h"
+#include "OPS.h"
+
+typedef
+	struct OPT_ConstDesc *OPT_Const;
+
+typedef
+	OPS_String *OPT_ConstExt;
+
+typedef
+	struct OPT_ConstDesc {
+		OPT_ConstExt ext;
+		INT64 intval;
+		INT32 intval2;
+		UINT64 setval;
+		LONGREAL realval;
+	} OPT_ConstDesc;
+
+typedef
+	struct OPT_LinkDesc *OPT_Link;
+
+typedef
+	struct OPT_LinkDesc {
+		OPS_Name name;
+		OPT_Link next;
+	} OPT_LinkDesc;
+
+typedef
+	struct OPT_NodeDesc *OPT_Node;
+
+typedef
+	struct OPT_StrDesc *OPT_Struct;
+
+typedef
+	struct OPT_ObjDesc *OPT_Object;
+
+typedef
+	struct OPT_NodeDesc {
+		OPT_Node left, right, link;
+		INT8 class, subcl;
+		BOOLEAN readonly;
+		OPT_Struct typ;
+		OPT_Object obj;
+		OPT_Const conval;
+	} OPT_NodeDesc;
+
+typedef
+	struct OPT_ObjDesc {
+		OPT_Object left, right, link, scope;
+		OPS_Name name;
+		BOOLEAN leaf;
+		INT8 mode, mnolev, vis, history;
+		BOOLEAN used, fpdone;
+		INT32 fprint;
+		OPT_Struct typ;
+		OPT_Const conval;
+		INT32 adr, linkadr;
+		INT16 x;
+		OPT_ConstExt comment;
+	} OPT_ObjDesc;
+
+typedef
+	struct OPT_StrDesc {
+		INT8 form, comp, mno, extlev;
+		INT16 ref, sysflag;
+		INT32 n, size, align, txtpos;
+		BOOLEAN allocated, pbused, pvused;
+		char _prvt0[4];
+		INT32 idfp;
+		char _prvt1[8];
+		OPT_Struct BaseTyp;
+		OPT_Object link, strobj;
+	} OPT_StrDesc;
+
+
+import OPT_Object OPT_topScope;
+import OPT_Struct OPT_undftyp, OPT_niltyp, OPT_notyp, OPT_bytetyp, OPT_cpbytetyp, OPT_booltyp, OPT_chartyp, OPT_sinttyp, OPT_inttyp, OPT_linttyp, OPT_hinttyp, OPT_int8typ, OPT_int16typ, OPT_int32typ, OPT_int64typ, OPT_settyp, OPT_set32typ, OPT_set64typ, OPT_realtyp, OPT_lrltyp, OPT_stringtyp, OPT_adrtyp, OPT_sysptrtyp;
+import OPT_Object OPT_sintobj, OPT_intobj, OPT_lintobj, OPT_setobj;
+import INT8 OPT_nofGmod;
+import OPT_Object OPT_GlbMod[64];
+import OPS_Name OPT_SelfName;
+import BOOLEAN OPT_SYSimported;
+import OPT_Link OPT_Links;
+
+import ADDRESS *OPT_ConstDesc__typ;
+import ADDRESS *OPT_ObjDesc__typ;
+import ADDRESS *OPT_StrDesc__typ;
+import ADDRESS *OPT_NodeDesc__typ;
+import ADDRESS *OPT_LinkDesc__typ;
+
+import void OPT_Align (INT32 *adr, INT32 base);
+import INT32 OPT_BaseAlignment (OPT_Struct typ);
+import void OPT_Close (void);
+import void OPT_CloseScope (void);
+import void OPT_Export (BOOLEAN *ext, BOOLEAN *new);
+import void OPT_FPrintErr (OPT_Object obj, INT16 errcode);
+import void OPT_FPrintObj (OPT_Object obj);
+import void OPT_FPrintStr (OPT_Struct typ);
+import void OPT_Find (OPT_Object *res);
+import void OPT_FindField (OPS_Name name, OPT_Struct typ, OPT_Object *res);
+import void OPT_FindImport (OPT_Object mod, OPT_Object *res);
+import void OPT_IdFPrint (OPT_Struct typ);
+import void OPT_Import (OPS_Name aliasName, OPS_Name name, BOOLEAN *done);
+import void OPT_Init (OPS_Name name, UINT32 opt);
+import void OPT_InitRecno (void);
+import void OPT_Insert (OPS_Name name, OPT_Object *obj);
+import void OPT_InsertImport (OPT_Object obj, OPT_Object *root, OPT_Object *old);
+import INT16 OPT_IntSize (INT64 n);
+import OPT_Struct OPT_IntType (INT32 size);
+import OPT_Const OPT_NewConst (void);
+import OPT_ConstExt OPT_NewExt (void);
+import OPT_Node OPT_NewNode (INT8 class);
+import OPT_Object OPT_NewObj (void);
+import OPT_Struct OPT_NewStr (INT8 form, INT8 comp);
+import void OPT_OpenScope (INT8 level, OPT_Object owner);
+import OPT_Struct OPT_SetType (INT32 size);
+import OPT_Struct OPT_ShorterOrLongerType (OPT_Struct x, INT16 dir);
+import INT32 OPT_SizeAlignment (INT32 size);
+import void OPT_TypSize (OPT_Struct typ);
+import void *OPT__init(void);
+
+
+#endif // OPT

bootstrap/unix-44/OPV.h

@@ -0,0 +1,18 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPV__h
+#define OPV__h
+
+#include "SYSTEM.h"
+#include "OPT.h"
+
+
+
+
+import void OPV_AdrAndSize (OPT_Object topScope);
+import void OPV_Init (void);
+import void OPV_Module (OPT_Node prog);
+import void *OPV__init(void);
+
+
+#endif // OPV

bootstrap/unix-44/Out.c

@@ -0,0 +1,345 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "Heap.h"
+#include "Platform.h"
+
+
+export BOOLEAN Out_IsConsole;
+static CHAR Out_buf[128];
+static INT16 Out_in;
+
+
+export void Out_Char (CHAR ch);
+export void Out_Flush (void);
+export void Out_Hex (INT64 x, INT64 n);
+export void Out_Int (INT64 x, INT64 n);
+static INT32 Out_Length (CHAR *s, ADDRESS s__len);
+export void Out_Ln (void);
+export void Out_LongReal (LONGREAL x, INT16 n);
+export void Out_Open (void);
+export void Out_Real (REAL x, INT16 n);
+static void Out_RealP (LONGREAL x, INT16 n, BOOLEAN long_);
+export void Out_String (CHAR *str, ADDRESS str__len);
+export LONGREAL Out_Ten (INT16 e);
+static void Out_digit (INT64 n, CHAR *s, ADDRESS s__len, INT16 *i);
+static void Out_prepend (CHAR *t, ADDRESS t__len, CHAR *s, ADDRESS s__len, INT16 *i);
+
+#define Out_Entier64(x)	(INT64)(x)
+
+void Out_Flush (void)
+{
+	INT16 error;
+	if (Out_in > 0) {
+		error = Platform_Write(1, (ADDRESS)Out_buf, Out_in);
+	}
+	Out_in = 0;
+}
+
+void Out_Open (void)
+{
+}
+
+void Out_Char (CHAR ch)
+{
+	if (Out_in >= 128) {
+		Out_Flush();
+	}
+	Out_buf[__X(Out_in, 128)] = ch;
+	Out_in += 1;
+	if (ch == 0x0a) {
+		Out_Flush();
+	}
+}
+
+static INT32 Out_Length (CHAR *s, ADDRESS s__len)
+{
+	INT32 l;
+	l = 0;
+	while ((l < s__len && s[__X(l, s__len)] != 0x00)) {
+		l += 1;
+	}
+	return l;
+}
+
+void Out_String (CHAR *str, ADDRESS str__len)
+{
+	INT32 l;
+	INT16 error;
+	__DUP(str, str__len, CHAR);
+	l = Out_Length((void*)str, str__len);
+	if (Out_in + l > 128) {
+		Out_Flush();
+	}
+	if (l > 128) {
+		error = Platform_Write(1, (ADDRESS)str, l);
+	} else {
+		__MOVE((ADDRESS)str, (ADDRESS)&Out_buf[__X(Out_in, 128)], l);
+		Out_in += __SHORT(l, 32768);
+	}
+	__DEL(str);
+}
+
+void Out_Int (INT64 x, INT64 n)
+{
+	CHAR s[22];
+	INT16 i;
+	BOOLEAN negative;
+	negative = x < 0;
+	if (x == (-9223372036854775807LL-1)) {
+		__MOVE("8085774586302733229", s, 20);
+		i = 19;
+	} else {
+		if (x < 0) {
+			x = -x;
+		}
+		s[0] = __CHR(48 + __MOD(x, 10));
+		x = __DIV(x, 10);
+		i = 1;
+		while (x != 0) {
+			s[__X(i, 22)] = __CHR(48 + __MOD(x, 10));
+			x = __DIV(x, 10);
+			i += 1;
+		}
+	}
+	if (negative) {
+		s[__X(i, 22)] = '-';
+		i += 1;
+	}
+	while (n > (INT64)i) {
+		Out_Char(' ');
+		n -= 1;
+	}
+	while (i > 0) {
+		i -= 1;
+		Out_Char(s[__X(i, 22)]);
+	}
+}
+
+void Out_Hex (INT64 x, INT64 n)
+{
+	if (n < 1) {
+		n = 1;
+	} else if (n > 16) {
+		n = 16;
+	}
+	if (x >= 0) {
+		while ((n < 16 && __LSH(x, -__ASHL(n, 2), 64) != 0)) {
+			n += 1;
+		}
+	}
+	x = __ROT(x, __ASHL(16 - n, 2), 64);
+	while (n > 0) {
+		x = __ROTL(x, 4, 64);
+		n -= 1;
+		if (__MASK(x, -16) < 10) {
+			Out_Char(__CHR(__MASK(x, -16) + 48));
+		} else {
+			Out_Char(__CHR((__MASK(x, -16) - 10) + 65));
+		}
+	}
+}
+
+void Out_Ln (void)
+{
+	Out_String(Platform_NL, 3);
+	Out_Flush();
+}
+
+static void Out_digit (INT64 n, CHAR *s, ADDRESS s__len, INT16 *i)
+{
+	*i -= 1;
+	s[__X(*i, s__len)] = __CHR(__MOD(n, 10) + 48);
+}
+
+static void Out_prepend (CHAR *t, ADDRESS t__len, CHAR *s, ADDRESS s__len, INT16 *i)
+{
+	INT16 j;
+	INT32 l;
+	__DUP(t, t__len, CHAR);
+	l = Out_Length((void*)t, t__len);
+	if (l > *i) {
+		l = *i;
+	}
+	*i -= __SHORT(l, 32768);
+	j = 0;
+	while (j < l) {
+		s[__X(*i + j, s__len)] = t[__X(j, t__len)];
+		j += 1;
+	}
+	__DEL(t);
+}
+
+LONGREAL Out_Ten (INT16 e)
+{
+	LONGREAL r, power;
+	r = (LONGREAL)1;
+	power = (LONGREAL)10;
+	while (e > 0) {
+		if (__ODD(e)) {
+			r = r * power;
+		}
+		power = power * power;
+		e = __ASHR(e, 1);
+	}
+	return r;
+}
+
+static void Out_RealP (LONGREAL x, INT16 n, BOOLEAN long_)
+{
+	INT16 e;
+	INT64 f;
+	CHAR s[30];
+	INT16 i, el;
+	LONGREAL x0;
+	BOOLEAN nn, en;
+	INT64 m;
+	INT16 d, dr;
+	e = (INT16)__MASK(__ASHR((__VAL(INT64, x)), 52), -2048);
+	f = __MASK((__VAL(INT64, x)), -4503599627370496LL);
+	nn = (__VAL(INT64, x) < 0 && !((e == 2047 && f != 0)));
+	if (nn) {
+		n -= 1;
+	}
+	i = 30;
+	if (e == 2047) {
+		if (f == 0) {
+			Out_prepend((CHAR*)"Infinity", 9, (void*)s, 30, &i);
+		} else {
+			Out_prepend((CHAR*)"NaN", 4, (void*)s, 30, &i);
+		}
+	} else {
+		if (long_) {
+			el = 3;
+			dr = n - 6;
+			if (dr > 17) {
+				dr = 17;
+			}
+			d = dr;
+			if (d < 15) {
+				d = 15;
+			}
+		} else {
+			el = 2;
+			dr = n - 5;
+			if (dr > 9) {
+				dr = 9;
+			}
+			d = dr;
+			if (d < 6) {
+				d = 6;
+			}
+		}
+		if (e == 0) {
+			while (el > 0) {
+				i -= 1;
+				s[__X(i, 30)] = '0';
+				el -= 1;
+			}
+			i -= 1;
+			s[__X(i, 30)] = '+';
+			m = 0;
+		} else {
+			if (nn) {
+				x = -x;
+			}
+			e = __SHORT(__ASHR((e - 1023) * 77, 8), 32768);
+			if (e >= 0) {
+				x = x / (LONGREAL)Out_Ten(e);
+			} else {
+				x = Out_Ten(-e) * x;
+			}
+			if (x >= (LONGREAL)10) {
+				x =   1.00000000000000e-001 * x;
+				e += 1;
+			}
+			en = e < 0;
+			if (en) {
+				e = -e;
+			}
+			while (el > 0) {
+				Out_digit(e, (void*)s, 30, &i);
+				e = __DIV(e, 10);
+				el -= 1;
+			}
+			i -= 1;
+			if (en) {
+				s[__X(i, 30)] = '-';
+			} else {
+				s[__X(i, 30)] = '+';
+			}
+			x0 = Out_Ten(d - 1);
+			x = x0 * x;
+			x = x +   5.00000000000000e-001;
+			if (x >= (LONGREAL)10 * x0) {
+				x =   1.00000000000000e-001 * x;
+				e += 1;
+			}
+			m = Out_Entier64(x);
+		}
+		i -= 1;
+		if (long_) {
+			s[__X(i, 30)] = 'D';
+		} else {
+			s[__X(i, 30)] = 'E';
+		}
+		if (dr < 2) {
+			dr = 2;
+		}
+		while ((d > dr && __MOD(m, 10) == 0)) {
+			m = __DIV(m, 10);
+			d -= 1;
+		}
+		while (d > 1) {
+			Out_digit(m, (void*)s, 30, &i);
+			m = __DIV(m, 10);
+			d -= 1;
+		}
+		i -= 1;
+		s[__X(i, 30)] = '.';
+		Out_digit(m, (void*)s, 30, &i);
+	}
+	n -= 30 - i;
+	while (n > 0) {
+		Out_Char(' ');
+		n -= 1;
+	}
+	if (nn) {
+		Out_Char('-');
+	}
+	while (i < 30) {
+		Out_Char(s[__X(i, 30)]);
+		i += 1;
+	}
+}
+
+void Out_Real (REAL x, INT16 n)
+{
+	Out_RealP(x, n, 0);
+}
+
+void Out_LongReal (LONGREAL x, INT16 n)
+{
+	Out_RealP(x, n, 1);
+}
+
+
+export void *Out__init(void)
+{
+	__DEFMOD;
+	__MODULE_IMPORT(Heap);
+	__MODULE_IMPORT(Platform);
+	__REGMOD("Out", 0);
+	__REGCMD("Flush", Out_Flush);
+	__REGCMD("Ln", Out_Ln);
+	__REGCMD("Open", Out_Open);
+/* BEGIN */
+	Out_IsConsole = Platform_IsConsole(1);
+	Out_in = 0;
+	__ENDMOD;
+}

bootstrap/unix-44/Out.h

@@ -0,0 +1,25 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Out__h
+#define Out__h
+
+#include "SYSTEM.h"
+
+
+import BOOLEAN Out_IsConsole;
+
+
+import void Out_Char (CHAR ch);
+import void Out_Flush (void);
+import void Out_Hex (INT64 x, INT64 n);
+import void Out_Int (INT64 x, INT64 n);
+import void Out_Ln (void);
+import void Out_LongReal (LONGREAL x, INT16 n);
+import void Out_Open (void);
+import void Out_Real (REAL x, INT16 n);
+import void Out_String (CHAR *str, ADDRESS str__len);
+import LONGREAL Out_Ten (INT16 e);
+import void *Out__init(void);
+
+
+#endif // Out

bootstrap/unix-44/Platform.c

@@ -0,0 +1,535 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+
+typedef
+	struct Platform_FileIdentity {
+		INT32 volume, index, mtime;
+	} Platform_FileIdentity;
+
+typedef
+	void (*Platform_SignalHandler)(INT32);
+
+
+export BOOLEAN Platform_LittleEndian;
+export INT16 Platform_PID;
+export CHAR Platform_CWD[256];
+static INT32 Platform_TimeStart;
+export INT16 Platform_SeekSet, Platform_SeekCur, Platform_SeekEnd;
+export CHAR Platform_NL[3];
+
+export ADDRESS *Platform_FileIdentity__typ;
+
+export BOOLEAN Platform_Absent (INT16 e);
+export INT16 Platform_Chdir (CHAR *n, ADDRESS n__len);
+export INT16 Platform_Close (INT32 h);
+export BOOLEAN Platform_ConnectionFailed (INT16 e);
+export void Platform_Delay (INT32 ms);
+export BOOLEAN Platform_DifferentFilesystems (INT16 e);
+export INT16 Platform_Error (void);
+export void Platform_Exit (INT32 code);
+export void Platform_GetClock (INT32 *t, INT32 *d);
+export void Platform_GetEnv (CHAR *var, ADDRESS var__len, CHAR *val, ADDRESS val__len);
+export void Platform_GetTimeOfDay (INT32 *sec, INT32 *usec);
+export INT16 Platform_Identify (INT32 h, Platform_FileIdentity *identity, ADDRESS *identity__typ);
+export INT16 Platform_IdentifyByName (CHAR *n, ADDRESS n__len, Platform_FileIdentity *identity, ADDRESS *identity__typ);
+export BOOLEAN Platform_Inaccessible (INT16 e);
+export BOOLEAN Platform_Interrupted (INT16 e);
+export BOOLEAN Platform_IsConsole (INT32 h);
+export void Platform_MTimeAsClock (Platform_FileIdentity i, INT32 *t, INT32 *d);
+export INT16 Platform_MaxNameLength (void);
+export INT16 Platform_MaxPathLength (void);
+export INT16 Platform_New (CHAR *n, ADDRESS n__len, INT32 *h);
+export BOOLEAN Platform_NoSuchDirectory (INT16 e);
+export INT32 Platform_OSAllocate (INT32 size);
+export void Platform_OSFree (INT32 address);
+export INT16 Platform_OldRO (CHAR *n, ADDRESS n__len, INT32 *h);
+export INT16 Platform_OldRW (CHAR *n, ADDRESS n__len, INT32 *h);
+export INT16 Platform_Read (INT32 h, INT32 p, INT32 l, INT32 *n);
+export INT16 Platform_ReadBuf (INT32 h, SYSTEM_BYTE *b, ADDRESS b__len, INT32 *n);
+export INT16 Platform_Rename (CHAR *o, ADDRESS o__len, CHAR *n, ADDRESS n__len);
+export BOOLEAN Platform_SameFile (Platform_FileIdentity i1, Platform_FileIdentity i2);
+export BOOLEAN Platform_SameFileTime (Platform_FileIdentity i1, Platform_FileIdentity i2);
+export INT16 Platform_Seek (INT32 h, INT32 offset, INT16 whence);
+export void Platform_SetBadInstructionHandler (Platform_SignalHandler handler);
+export void Platform_SetInterruptHandler (Platform_SignalHandler handler);
+export void Platform_SetMTime (Platform_FileIdentity *target, ADDRESS *target__typ, Platform_FileIdentity source);
+export void Platform_SetQuitHandler (Platform_SignalHandler handler);
+export INT16 Platform_Size (INT32 h, INT32 *l);
+export INT16 Platform_Sync (INT32 h);
+export INT16 Platform_System (CHAR *cmd, ADDRESS cmd__len);
+static void Platform_TestLittleEndian (void);
+export INT32 Platform_Time (void);
+export BOOLEAN Platform_TimedOut (INT16 e);
+export BOOLEAN Platform_TooManyFiles (INT16 e);
+export INT16 Platform_Truncate (INT32 h, INT32 l);
+export INT16 Platform_Unlink (CHAR *n, ADDRESS n__len);
+export INT16 Platform_Write (INT32 h, INT32 p, INT32 l);
+static void Platform_YMDHMStoClock (INT32 ye, INT32 mo, INT32 da, INT32 ho, INT32 mi, INT32 se, INT32 *t, INT32 *d);
+export BOOLEAN Platform_getEnv (CHAR *var, ADDRESS var__len, CHAR *val, ADDRESS val__len);
+
+#include <errno.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define Platform_EACCES()	EACCES
+#define Platform_EAGAIN()	EAGAIN
+#define Platform_ECONNABORTED()	ECONNABORTED
+#define Platform_ECONNREFUSED()	ECONNREFUSED
+#define Platform_EHOSTUNREACH()	EHOSTUNREACH
+#define Platform_EINTR()	EINTR
+#define Platform_EMFILE()	EMFILE
+#define Platform_ENETUNREACH()	ENETUNREACH
+#define Platform_ENFILE()	ENFILE
+#define Platform_ENOENT()	ENOENT
+#define Platform_EROFS()	EROFS
+#define Platform_ETIMEDOUT()	ETIMEDOUT
+#define Platform_EXDEV()	EXDEV
+#define Platform_NAMEMAX()	NAME_MAX
+#define Platform_PATHMAX()	PATH_MAX
+#define Platform_allocate(size)	(ADDRESS)((void*)malloc((size_t)size))
+#define Platform_chdir(n, n__len)	chdir((char*)n)
+#define Platform_closefile(fd)	close(fd)
+#define Platform_err()	errno
+#define Platform_exit(code)	exit((int)code)
+#define Platform_free(address)	free((void*)address)
+#define Platform_fstat(fd)	fstat(fd, &s)
+#define Platform_fsync(fd)	fsync(fd)
+#define Platform_ftruncate(fd, l)	ftruncate(fd, l)
+#define Platform_getcwd(cwd, cwd__len)	getcwd((char*)cwd, cwd__len)
+#define Platform_getenv(var, var__len)	getenv((char*)var)
+#define Platform_getpid()	(INTEGER)getpid()
+#define Platform_gettimeval()	struct timeval tv; gettimeofday(&tv,0)
+#define Platform_isatty(fd)	isatty(fd)
+#define Platform_lseek(fd, o, w)	lseek(fd, o, w)
+#define Platform_nanosleep(s, ns)	struct timespec req, rem; req.tv_sec = s; req.tv_nsec = ns; nanosleep(&req, &rem)
+#define Platform_opennew(n, n__len)	open((char*)n, O_CREAT | O_TRUNC | O_RDWR, 0664)
+#define Platform_openro(n, n__len)	open((char*)n, O_RDONLY)
+#define Platform_openrw(n, n__len)	open((char*)n, O_RDWR)
+#define Platform_readfile(fd, p, l)	(LONGINT)read(fd, (void*)(ADDRESS)(p), l)
+#define Platform_rename(o, o__len, n, n__len)	rename((char*)o, (char*)n)
+#define Platform_sectotm(s)	struct tm *time = localtime((time_t*)&s)
+#define Platform_seekcur()	SEEK_CUR
+#define Platform_seekend()	SEEK_END
+#define Platform_seekset()	SEEK_SET
+#define Platform_sethandler(s, h)	SystemSetHandler(s, (ADDRESS)h)
+#define Platform_stat(n, n__len)	stat((char*)n, &s)
+#define Platform_statdev()	(LONGINT)s.st_dev
+#define Platform_statino()	(LONGINT)s.st_ino
+#define Platform_statmtime()	(LONGINT)s.st_mtime
+#define Platform_statsize()	(ADDRESS)s.st_size
+#define Platform_structstats()	struct stat s
+#define Platform_system(str, str__len)	system((char*)str)
+#define Platform_tmhour()	(LONGINT)time->tm_hour
+#define Platform_tmmday()	(LONGINT)time->tm_mday
+#define Platform_tmmin()	(LONGINT)time->tm_min
+#define Platform_tmmon()	(LONGINT)time->tm_mon
+#define Platform_tmsec()	(LONGINT)time->tm_sec
+#define Platform_tmyear()	(LONGINT)time->tm_year
+#define Platform_tvsec()	tv.tv_sec
+#define Platform_tvusec()	tv.tv_usec
+#define Platform_unlink(n, n__len)	unlink((char*)n)
+#define Platform_writefile(fd, p, l)	write(fd, (void*)(ADDRESS)(p), l)
+
+BOOLEAN Platform_TooManyFiles (INT16 e)
+{
+	return e == Platform_EMFILE() || e == Platform_ENFILE();
+}
+
+BOOLEAN Platform_NoSuchDirectory (INT16 e)
+{
+	return e == Platform_ENOENT();
+}
+
+BOOLEAN Platform_DifferentFilesystems (INT16 e)
+{
+	return e == Platform_EXDEV();
+}
+
+BOOLEAN Platform_Inaccessible (INT16 e)
+{
+	return (e == Platform_EACCES() || e == Platform_EROFS()) || e == Platform_EAGAIN();
+}
+
+BOOLEAN Platform_Absent (INT16 e)
+{
+	return e == Platform_ENOENT();
+}
+
+BOOLEAN Platform_TimedOut (INT16 e)
+{
+	return e == Platform_ETIMEDOUT();
+}
+
+BOOLEAN Platform_ConnectionFailed (INT16 e)
+{
+	return ((e == Platform_ECONNREFUSED() || e == Platform_ECONNABORTED()) || e == Platform_ENETUNREACH()) || e == Platform_EHOSTUNREACH();
+}
+
+BOOLEAN Platform_Interrupted (INT16 e)
+{
+	return e == Platform_EINTR();
+}
+
+INT16 Platform_MaxNameLength (void)
+{
+	return Platform_NAMEMAX();
+}
+
+INT16 Platform_MaxPathLength (void)
+{
+	return Platform_PATHMAX();
+}
+
+INT32 Platform_OSAllocate (INT32 size)
+{
+	return Platform_allocate(size);
+}
+
+void Platform_OSFree (INT32 address)
+{
+	Platform_free(address);
+}
+
+typedef
+	CHAR (*EnvPtr__83)[1024];
+
+BOOLEAN Platform_getEnv (CHAR *var, ADDRESS var__len, CHAR *val, ADDRESS val__len)
+{
+	EnvPtr__83 p = NIL;
+	__DUP(var, var__len, CHAR);
+	p = (EnvPtr__83)(ADDRESS)Platform_getenv(var, var__len);
+	if (p != NIL) {
+		__COPY(*p, val, val__len);
+	}
+	__DEL(var);
+	return p != NIL;
+}
+
+void Platform_GetEnv (CHAR *var, ADDRESS var__len, CHAR *val, ADDRESS val__len)
+{
+	__DUP(var, var__len, CHAR);
+	if (!Platform_getEnv(var, var__len, (void*)val, val__len)) {
+		val[0] = 0x00;
+	}
+	__DEL(var);
+}
+
+void Platform_SetInterruptHandler (Platform_SignalHandler handler)
+{
+	Platform_sethandler(2, handler);
+}
+
+void Platform_SetQuitHandler (Platform_SignalHandler handler)
+{
+	Platform_sethandler(3, handler);
+}
+
+void Platform_SetBadInstructionHandler (Platform_SignalHandler handler)
+{
+	Platform_sethandler(4, handler);
+}
+
+static void Platform_YMDHMStoClock (INT32 ye, INT32 mo, INT32 da, INT32 ho, INT32 mi, INT32 se, INT32 *t, INT32 *d)
+{
+	*d = (__ASHL((int)__MOD(ye, 100), 9) + __ASHL(mo + 1, 5)) + da;
+	*t = (__ASHL(ho, 12) + __ASHL(mi, 6)) + se;
+}
+
+void Platform_GetClock (INT32 *t, INT32 *d)
+{
+	Platform_gettimeval();
+	Platform_sectotm(Platform_tvsec());
+	Platform_YMDHMStoClock(Platform_tmyear(), Platform_tmmon(), Platform_tmmday(), Platform_tmhour(), Platform_tmmin(), Platform_tmsec(), &*t, &*d);
+}
+
+void Platform_GetTimeOfDay (INT32 *sec, INT32 *usec)
+{
+	Platform_gettimeval();
+	*sec = Platform_tvsec();
+	*usec = Platform_tvusec();
+}
+
+INT32 Platform_Time (void)
+{
+	INT32 ms;
+	Platform_gettimeval();
+	ms = (int)__DIVF(Platform_tvusec(), 1000) + Platform_tvsec() * 1000;
+	return (int)__MOD(ms - Platform_TimeStart, 2147483647);
+}
+
+void Platform_Delay (INT32 ms)
+{
+	INT32 s, ns;
+	s = __DIV(ms, 1000);
+	ns = (int)__MOD(ms, 1000) * 1000000;
+	Platform_nanosleep(s, ns);
+}
+
+INT16 Platform_System (CHAR *cmd, ADDRESS cmd__len)
+{
+	__DUP(cmd, cmd__len, CHAR);
+	__DEL(cmd);
+	return Platform_system(cmd, cmd__len);
+}
+
+INT16 Platform_Error (void)
+{
+	return Platform_err();
+}
+
+INT16 Platform_OldRO (CHAR *n, ADDRESS n__len, INT32 *h)
+{
+	INT16 fd;
+	fd = Platform_openro(n, n__len);
+	if (fd < 0) {
+		return Platform_err();
+	} else {
+		*h = fd;
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_OldRW (CHAR *n, ADDRESS n__len, INT32 *h)
+{
+	INT16 fd;
+	fd = Platform_openrw(n, n__len);
+	if (fd < 0) {
+		return Platform_err();
+	} else {
+		*h = fd;
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_New (CHAR *n, ADDRESS n__len, INT32 *h)
+{
+	INT16 fd;
+	fd = Platform_opennew(n, n__len);
+	if (fd < 0) {
+		return Platform_err();
+	} else {
+		*h = fd;
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Close (INT32 h)
+{
+	if (Platform_closefile(h) < 0) {
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+BOOLEAN Platform_IsConsole (INT32 h)
+{
+	return Platform_isatty(h) != 0;
+}
+
+INT16 Platform_Identify (INT32 h, Platform_FileIdentity *identity, ADDRESS *identity__typ)
+{
+	Platform_structstats();
+	if (Platform_fstat(h) < 0) {
+		return Platform_err();
+	}
+	(*identity).volume = Platform_statdev();
+	(*identity).index = Platform_statino();
+	(*identity).mtime = Platform_statmtime();
+	return 0;
+}
+
+INT16 Platform_IdentifyByName (CHAR *n, ADDRESS n__len, Platform_FileIdentity *identity, ADDRESS *identity__typ)
+{
+	__DUP(n, n__len, CHAR);
+	Platform_structstats();
+	if (Platform_stat(n, n__len) < 0) {
+		__DEL(n);
+		return Platform_err();
+	}
+	(*identity).volume = Platform_statdev();
+	(*identity).index = Platform_statino();
+	(*identity).mtime = Platform_statmtime();
+	__DEL(n);
+	return 0;
+}
+
+BOOLEAN Platform_SameFile (Platform_FileIdentity i1, Platform_FileIdentity i2)
+{
+	return (i1.index == i2.index && i1.volume == i2.volume);
+}
+
+BOOLEAN Platform_SameFileTime (Platform_FileIdentity i1, Platform_FileIdentity i2)
+{
+	return i1.mtime == i2.mtime;
+}
+
+void Platform_SetMTime (Platform_FileIdentity *target, ADDRESS *target__typ, Platform_FileIdentity source)
+{
+	(*target).mtime = source.mtime;
+}
+
+void Platform_MTimeAsClock (Platform_FileIdentity i, INT32 *t, INT32 *d)
+{
+	Platform_sectotm(i.mtime);
+	Platform_YMDHMStoClock(Platform_tmyear(), Platform_tmmon(), Platform_tmmday(), Platform_tmhour(), Platform_tmmin(), Platform_tmsec(), &*t, &*d);
+}
+
+INT16 Platform_Size (INT32 h, INT32 *l)
+{
+	Platform_structstats();
+	if (Platform_fstat(h) < 0) {
+		return Platform_err();
+	}
+	*l = Platform_statsize();
+	return 0;
+}
+
+INT16 Platform_Read (INT32 h, INT32 p, INT32 l, INT32 *n)
+{
+	*n = Platform_readfile(h, p, l);
+	if (*n < 0) {
+		*n = 0;
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_ReadBuf (INT32 h, SYSTEM_BYTE *b, ADDRESS b__len, INT32 *n)
+{
+	*n = Platform_readfile(h, (ADDRESS)b, b__len);
+	if (*n < 0) {
+		*n = 0;
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Write (INT32 h, INT32 p, INT32 l)
+{
+	INT32 written;
+	written = Platform_writefile(h, p, l);
+	if (written < 0) {
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Sync (INT32 h)
+{
+	if (Platform_fsync(h) < 0) {
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Seek (INT32 h, INT32 offset, INT16 whence)
+{
+	if (Platform_lseek(h, offset, whence) < 0) {
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Truncate (INT32 h, INT32 l)
+{
+	if (Platform_ftruncate(h, l) < 0) {
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Unlink (CHAR *n, ADDRESS n__len)
+{
+	if (Platform_unlink(n, n__len) < 0) {
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Chdir (CHAR *n, ADDRESS n__len)
+{
+	INT16 r;
+	if ((Platform_chdir(n, n__len) >= 0 && Platform_getcwd((void*)Platform_CWD, 256) != NIL)) {
+		return 0;
+	} else {
+		return Platform_err();
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Rename (CHAR *o, ADDRESS o__len, CHAR *n, ADDRESS n__len)
+{
+	if (Platform_rename(o, o__len, n, n__len) < 0) {
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+void Platform_Exit (INT32 code)
+{
+	Platform_exit(code);
+}
+
+static void Platform_TestLittleEndian (void)
+{
+	INT16 i;
+	i = 1;
+	__GET((ADDRESS)&i, Platform_LittleEndian, BOOLEAN);
+}
+
+__TDESC(Platform_FileIdentity, 1, 0) = {__TDFLDS("FileIdentity", 12), {-4}};
+
+export void *Platform__init(void)
+{
+	__DEFMOD;
+	__REGMOD("Platform", 0);
+	__INITYP(Platform_FileIdentity, Platform_FileIdentity, 0);
+/* BEGIN */
+	Platform_TestLittleEndian();
+	Platform_TimeStart = 0;
+	Platform_TimeStart = Platform_Time();
+	Platform_PID = Platform_getpid();
+	if (Platform_getcwd((void*)Platform_CWD, 256) == NIL) {
+		Platform_CWD[0] = 0x00;
+	}
+	Platform_SeekSet = Platform_seekset();
+	Platform_SeekCur = Platform_seekcur();
+	Platform_SeekEnd = Platform_seekend();
+	Platform_NL[0] = 0x0a;
+	Platform_NL[1] = 0x00;
+	__ENDMOD;
+}

bootstrap/unix-44/Platform.h

@@ -0,0 +1,74 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Platform__h
+#define Platform__h
+
+#include "SYSTEM.h"
+
+typedef
+	struct Platform_FileIdentity {
+		INT32 _prvt0;
+		char _prvt1[8];
+	} Platform_FileIdentity;
+
+typedef
+	void (*Platform_SignalHandler)(INT32);
+
+
+import BOOLEAN Platform_LittleEndian;
+import INT16 Platform_PID;
+import CHAR Platform_CWD[256];
+import INT16 Platform_SeekSet, Platform_SeekCur, Platform_SeekEnd;
+import CHAR Platform_NL[3];
+
+import ADDRESS *Platform_FileIdentity__typ;
+
+import BOOLEAN Platform_Absent (INT16 e);
+import INT16 Platform_Chdir (CHAR *n, ADDRESS n__len);
+import INT16 Platform_Close (INT32 h);
+import BOOLEAN Platform_ConnectionFailed (INT16 e);
+import void Platform_Delay (INT32 ms);
+import BOOLEAN Platform_DifferentFilesystems (INT16 e);
+import INT16 Platform_Error (void);
+import void Platform_Exit (INT32 code);
+import void Platform_GetClock (INT32 *t, INT32 *d);
+import void Platform_GetEnv (CHAR *var, ADDRESS var__len, CHAR *val, ADDRESS val__len);
+import void Platform_GetTimeOfDay (INT32 *sec, INT32 *usec);
+import INT16 Platform_Identify (INT32 h, Platform_FileIdentity *identity, ADDRESS *identity__typ);
+import INT16 Platform_IdentifyByName (CHAR *n, ADDRESS n__len, Platform_FileIdentity *identity, ADDRESS *identity__typ);
+import BOOLEAN Platform_Inaccessible (INT16 e);
+import BOOLEAN Platform_Interrupted (INT16 e);
+import BOOLEAN Platform_IsConsole (INT32 h);
+import void Platform_MTimeAsClock (Platform_FileIdentity i, INT32 *t, INT32 *d);
+import INT16 Platform_MaxNameLength (void);
+import INT16 Platform_MaxPathLength (void);
+import INT16 Platform_New (CHAR *n, ADDRESS n__len, INT32 *h);
+import BOOLEAN Platform_NoSuchDirectory (INT16 e);
+import INT32 Platform_OSAllocate (INT32 size);
+import void Platform_OSFree (INT32 address);
+import INT16 Platform_OldRO (CHAR *n, ADDRESS n__len, INT32 *h);
+import INT16 Platform_OldRW (CHAR *n, ADDRESS n__len, INT32 *h);
+import INT16 Platform_Read (INT32 h, INT32 p, INT32 l, INT32 *n);
+import INT16 Platform_ReadBuf (INT32 h, SYSTEM_BYTE *b, ADDRESS b__len, INT32 *n);
+import INT16 Platform_Rename (CHAR *o, ADDRESS o__len, CHAR *n, ADDRESS n__len);
+import BOOLEAN Platform_SameFile (Platform_FileIdentity i1, Platform_FileIdentity i2);
+import BOOLEAN Platform_SameFileTime (Platform_FileIdentity i1, Platform_FileIdentity i2);
+import INT16 Platform_Seek (INT32 h, INT32 offset, INT16 whence);
+import void Platform_SetBadInstructionHandler (Platform_SignalHandler handler);
+import void Platform_SetInterruptHandler (Platform_SignalHandler handler);
+import void Platform_SetMTime (Platform_FileIdentity *target, ADDRESS *target__typ, Platform_FileIdentity source);
+import void Platform_SetQuitHandler (Platform_SignalHandler handler);
+import INT16 Platform_Size (INT32 h, INT32 *l);
+import INT16 Platform_Sync (INT32 h);
+import INT16 Platform_System (CHAR *cmd, ADDRESS cmd__len);
+import INT32 Platform_Time (void);
+import BOOLEAN Platform_TimedOut (INT16 e);
+import BOOLEAN Platform_TooManyFiles (INT16 e);
+import INT16 Platform_Truncate (INT32 h, INT32 l);
+import INT16 Platform_Unlink (CHAR *n, ADDRESS n__len);
+import INT16 Platform_Write (INT32 h, INT32 p, INT32 l);
+import BOOLEAN Platform_getEnv (CHAR *var, ADDRESS var__len, CHAR *val, ADDRESS val__len);
+import void *Platform__init(void);
+
+
+#endif // Platform

bootstrap/unix-44/Reals.c

@@ -0,0 +1,157 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+
+
+
+
+static void Reals_BytesToHex (SYSTEM_BYTE *b, ADDRESS b__len, SYSTEM_BYTE *d, ADDRESS d__len);
+export void Reals_Convert (REAL x, INT16 n, CHAR *d, ADDRESS d__len);
+export void Reals_ConvertH (REAL y, CHAR *d, ADDRESS d__len);
+export void Reals_ConvertHL (LONGREAL x, CHAR *d, ADDRESS d__len);
+export void Reals_ConvertL (LONGREAL x, INT16 n, CHAR *d, ADDRESS d__len);
+export INT16 Reals_Expo (REAL x);
+export INT16 Reals_ExpoL (LONGREAL x);
+export void Reals_SetExpo (REAL *x, INT16 ex);
+export REAL Reals_Ten (INT16 e);
+export LONGREAL Reals_TenL (INT16 e);
+static CHAR Reals_ToHex (INT16 i);
+
+
+REAL Reals_Ten (INT16 e)
+{
+	LONGREAL r, power;
+	r = (LONGREAL)1;
+	power = (LONGREAL)10;
+	while (e > 0) {
+		if (__ODD(e)) {
+			r = r * power;
+		}
+		power = power * power;
+		e = __ASHR(e, 1);
+	}
+	return r;
+}
+
+LONGREAL Reals_TenL (INT16 e)
+{
+	LONGREAL r, power;
+	r = (LONGREAL)1;
+	power = (LONGREAL)10;
+	for (;;) {
+		if (__ODD(e)) {
+			r = r * power;
+		}
+		e = __ASHR(e, 1);
+		if (e <= 0) {
+			return r;
+		}
+		power = power * power;
+	}
+	__RETCHK;
+}
+
+INT16 Reals_Expo (REAL x)
+{
+	INT16 i;
+	__GET((ADDRESS)&x + 2, i, INT16);
+	return __MASK(__ASHR(i, 7), -256);
+}
+
+void Reals_SetExpo (REAL *x, INT16 ex)
+{
+	CHAR c;
+	__GET((ADDRESS)x + 3, c, CHAR);
+	__PUT((ADDRESS)x + 3, __CHR(__ASHL(__ASHR((INT16)c, 7), 7) + __MASK(__ASHR(ex, 1), -128)), CHAR);
+	__GET((ADDRESS)x + 2, c, CHAR);
+	__PUT((ADDRESS)x + 2, __CHR(__MASK((INT16)c, -128) + __ASHL(__MASK(ex, -2), 7)), CHAR);
+}
+
+INT16 Reals_ExpoL (LONGREAL x)
+{
+	INT16 i;
+	__GET((ADDRESS)&x + 6, i, INT16);
+	return __MASK(__ASHR(i, 4), -2048);
+}
+
+void Reals_ConvertL (LONGREAL x, INT16 n, CHAR *d, ADDRESS d__len)
+{
+	INT32 i, j, k;
+	if (x < (LONGREAL)0) {
+		x = -x;
+	}
+	k = 0;
+	if (n > 9) {
+		i = __SHORT(__ENTIER(x / (LONGREAL)(LONGREAL)1000000000), 2147483648LL);
+		j = __SHORT(__ENTIER(x - i * (LONGREAL)1000000000), 2147483648LL);
+		if (j < 0) {
+			j = 0;
+		}
+		while (k < 9) {
+			d[__X(k, d__len)] = __CHR((int)__MOD(j, 10) + 48);
+			j = __DIV(j, 10);
+			k += 1;
+		}
+	} else {
+		i = __SHORT(__ENTIER(x), 2147483648LL);
+	}
+	while (k < n) {
+		d[__X(k, d__len)] = __CHR((int)__MOD(i, 10) + 48);
+		i = __DIV(i, 10);
+		k += 1;
+	}
+}
+
+void Reals_Convert (REAL x, INT16 n, CHAR *d, ADDRESS d__len)
+{
+	Reals_ConvertL(x, n, (void*)d, d__len);
+}
+
+static CHAR Reals_ToHex (INT16 i)
+{
+	if (i < 10) {
+		return __CHR(i + 48);
+	} else {
+		return __CHR(i + 55);
+	}
+	__RETCHK;
+}
+
+static void Reals_BytesToHex (SYSTEM_BYTE *b, ADDRESS b__len, SYSTEM_BYTE *d, ADDRESS d__len)
+{
+	INT16 i;
+	INT32 l;
+	CHAR by;
+	i = 0;
+	l = b__len;
+	while (i < l) {
+		by = __VAL(CHAR, b[__X(i, b__len)]);
+		d[__X(__ASHL(i, 1), d__len)] = Reals_ToHex(__ASHR((INT16)by, 4));
+		d[__X(__ASHL(i, 1) + 1, d__len)] = Reals_ToHex(__MASK((INT16)by, -16));
+		i += 1;
+	}
+}
+
+void Reals_ConvertH (REAL y, CHAR *d, ADDRESS d__len)
+{
+	Reals_BytesToHex((void*)&y, 4, (void*)d, d__len * 1);
+}
+
+void Reals_ConvertHL (LONGREAL x, CHAR *d, ADDRESS d__len)
+{
+	Reals_BytesToHex((void*)&x, 8, (void*)d, d__len * 1);
+}
+
+
+export void *Reals__init(void)
+{
+	__DEFMOD;
+	__REGMOD("Reals", 0);
+/* BEGIN */
+	__ENDMOD;
+}

bootstrap/unix-44/Reals.h

@@ -0,0 +1,23 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Reals__h
+#define Reals__h
+
+#include "SYSTEM.h"
+
+
+
+
+import void Reals_Convert (REAL x, INT16 n, CHAR *d, ADDRESS d__len);
+import void Reals_ConvertH (REAL y, CHAR *d, ADDRESS d__len);
+import void Reals_ConvertHL (LONGREAL x, CHAR *d, ADDRESS d__len);
+import void Reals_ConvertL (LONGREAL x, INT16 n, CHAR *d, ADDRESS d__len);
+import INT16 Reals_Expo (REAL x);
+import INT16 Reals_ExpoL (LONGREAL x);
+import void Reals_SetExpo (REAL *x, INT16 ex);
+import REAL Reals_Ten (INT16 e);
+import LONGREAL Reals_TenL (INT16 e);
+import void *Reals__init(void);
+
+
+#endif // Reals

bootstrap/unix-44/Strings.c

@@ -0,0 +1,374 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "Reals.h"
+
+
+
+
+export void Strings_Append (CHAR *extra, ADDRESS extra__len, CHAR *dest, ADDRESS dest__len);
+export void Strings_Cap (CHAR *s, ADDRESS s__len);
+export void Strings_Delete (CHAR *s, ADDRESS s__len, INT16 pos, INT16 n);
+export void Strings_Extract (CHAR *source, ADDRESS source__len, INT16 pos, INT16 n, CHAR *dest, ADDRESS dest__len);
+export void Strings_Insert (CHAR *source, ADDRESS source__len, INT16 pos, CHAR *dest, ADDRESS dest__len);
+export INT16 Strings_Length (CHAR *s, ADDRESS s__len);
+export BOOLEAN Strings_Match (CHAR *string, ADDRESS string__len, CHAR *pattern, ADDRESS pattern__len);
+export INT16 Strings_Pos (CHAR *pattern, ADDRESS pattern__len, CHAR *s, ADDRESS s__len, INT16 pos);
+export void Strings_Replace (CHAR *source, ADDRESS source__len, INT16 pos, CHAR *dest, ADDRESS dest__len);
+export void Strings_StrToLongReal (CHAR *s, ADDRESS s__len, LONGREAL *r);
+export void Strings_StrToReal (CHAR *s, ADDRESS s__len, REAL *r);
+
+
+INT16 Strings_Length (CHAR *s, ADDRESS s__len)
+{
+	INT32 i;
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	while ((i < s__len && s[__X(i, s__len)] != 0x00)) {
+		i += 1;
+	}
+	if (i <= 32767) {
+		__DEL(s);
+		return __SHORT(i, 32768);
+	} else {
+		__DEL(s);
+		return 32767;
+	}
+	__RETCHK;
+}
+
+void Strings_Append (CHAR *extra, ADDRESS extra__len, CHAR *dest, ADDRESS dest__len)
+{
+	INT16 n1, n2, i;
+	__DUP(extra, extra__len, CHAR);
+	n1 = Strings_Length(dest, dest__len);
+	n2 = Strings_Length(extra, extra__len);
+	i = 0;
+	while ((i < n2 && (i + n1) < dest__len)) {
+		dest[__X(i + n1, dest__len)] = extra[__X(i, extra__len)];
+		i += 1;
+	}
+	if ((i + n1) < dest__len) {
+		dest[__X(i + n1, dest__len)] = 0x00;
+	}
+	__DEL(extra);
+}
+
+void Strings_Insert (CHAR *source, ADDRESS source__len, INT16 pos, CHAR *dest, ADDRESS dest__len)
+{
+	INT16 n1, n2, i;
+	__DUP(source, source__len, CHAR);
+	n1 = Strings_Length(dest, dest__len);
+	n2 = Strings_Length(source, source__len);
+	if (pos < 0) {
+		pos = 0;
+	}
+	if (pos > n1) {
+		Strings_Append(dest, dest__len, (void*)source, source__len);
+		__DEL(source);
+		return;
+	}
+	if ((pos + n2) < dest__len) {
+		i = n1;
+		while (i >= pos) {
+			if ((i + n2) < dest__len) {
+				dest[__X(i + n2, dest__len)] = dest[__X(i, dest__len)];
+			}
+			i -= 1;
+		}
+	}
+	i = 0;
+	while (i < n2) {
+		dest[__X(pos + i, dest__len)] = source[__X(i, source__len)];
+		i += 1;
+	}
+	__DEL(source);
+}
+
+void Strings_Delete (CHAR *s, ADDRESS s__len, INT16 pos, INT16 n)
+{
+	INT16 len, i;
+	len = Strings_Length(s, s__len);
+	if (pos < 0) {
+		pos = 0;
+	} else if (pos >= len) {
+		return;
+	}
+	if (pos + n < len) {
+		i = pos + n;
+		while (i < len) {
+			s[__X(i - n, s__len)] = s[__X(i, s__len)];
+			i += 1;
+		}
+		if ((i - n) < s__len) {
+			s[__X(i - n, s__len)] = 0x00;
+		}
+	} else {
+		s[__X(pos, s__len)] = 0x00;
+	}
+}
+
+void Strings_Replace (CHAR *source, ADDRESS source__len, INT16 pos, CHAR *dest, ADDRESS dest__len)
+{
+	__DUP(source, source__len, CHAR);
+	Strings_Delete((void*)dest, dest__len, pos, pos + Strings_Length(source, source__len));
+	Strings_Insert(source, source__len, pos, (void*)dest, dest__len);
+	__DEL(source);
+}
+
+void Strings_Extract (CHAR *source, ADDRESS source__len, INT16 pos, INT16 n, CHAR *dest, ADDRESS dest__len)
+{
+	INT16 len, destLen, i;
+	__DUP(source, source__len, CHAR);
+	len = Strings_Length(source, source__len);
+	destLen = __SHORT(dest__len, 32768) - 1;
+	if (pos < 0) {
+		pos = 0;
+	}
+	if (pos >= len) {
+		dest[0] = 0x00;
+		__DEL(source);
+		return;
+	}
+	i = 0;
+	while (((((pos + i) <= source__len && source[__X(pos + i, source__len)] != 0x00)) && i < n)) {
+		if (i < destLen) {
+			dest[__X(i, dest__len)] = source[__X(pos + i, source__len)];
+		}
+		i += 1;
+	}
+	dest[__X(i, dest__len)] = 0x00;
+	__DEL(source);
+}
+
+INT16 Strings_Pos (CHAR *pattern, ADDRESS pattern__len, CHAR *s, ADDRESS s__len, INT16 pos)
+{
+	INT16 n1, n2, i, j;
+	__DUP(pattern, pattern__len, CHAR);
+	__DUP(s, s__len, CHAR);
+	n1 = Strings_Length(s, s__len);
+	n2 = Strings_Length(pattern, pattern__len);
+	if (n2 == 0) {
+		__DEL(pattern);
+		__DEL(s);
+		return 0;
+	}
+	i = pos;
+	while (i <= n1 - n2) {
+		if (s[__X(i, s__len)] == pattern[0]) {
+			j = 1;
+			while ((j < n2 && s[__X(i + j, s__len)] == pattern[__X(j, pattern__len)])) {
+				j += 1;
+			}
+			if (j == n2) {
+				__DEL(pattern);
+				__DEL(s);
+				return i;
+			}
+		}
+		i += 1;
+	}
+	__DEL(pattern);
+	__DEL(s);
+	return -1;
+}
+
+void Strings_Cap (CHAR *s, ADDRESS s__len)
+{
+	INT16 i;
+	i = 0;
+	while (s[__X(i, s__len)] != 0x00) {
+		if (('a' <= s[__X(i, s__len)] && s[__X(i, s__len)] <= 'z')) {
+			s[__X(i, s__len)] = __CAP(s[__X(i, s__len)]);
+		}
+		i += 1;
+	}
+}
+
+static struct Match__7 {
+	struct Match__7 *lnk;
+} *Match__7_s;
+
+static BOOLEAN M__8 (CHAR *name, ADDRESS name__len, CHAR *mask, ADDRESS mask__len, INT16 n, INT16 m);
+
+static BOOLEAN M__8 (CHAR *name, ADDRESS name__len, CHAR *mask, ADDRESS mask__len, INT16 n, INT16 m)
+{
+	while ((((n >= 0 && m >= 0)) && mask[__X(m, mask__len)] != '*')) {
+		if (name[__X(n, name__len)] != mask[__X(m, mask__len)]) {
+			return 0;
+		}
+		n -= 1;
+		m -= 1;
+	}
+	if (m < 0) {
+		return n < 0;
+	}
+	while ((m >= 0 && mask[__X(m, mask__len)] == '*')) {
+		m -= 1;
+	}
+	if (m < 0) {
+		return 1;
+	}
+	while (n >= 0) {
+		if (M__8(name, name__len, mask, mask__len, n, m)) {
+			return 1;
+		}
+		n -= 1;
+	}
+	return 0;
+}
+
+BOOLEAN Strings_Match (CHAR *string, ADDRESS string__len, CHAR *pattern, ADDRESS pattern__len)
+{
+	struct Match__7 _s;
+	BOOLEAN __retval;
+	__DUP(string, string__len, CHAR);
+	__DUP(pattern, pattern__len, CHAR);
+	_s.lnk = Match__7_s;
+	Match__7_s = &_s;
+	__retval = M__8((void*)string, string__len, (void*)pattern, pattern__len, Strings_Length(string, string__len) - 1, Strings_Length(pattern, pattern__len) - 1);
+	Match__7_s = _s.lnk;
+	__DEL(string);
+	__DEL(pattern);
+	;
+	return __retval;
+}
+
+void Strings_StrToReal (CHAR *s, ADDRESS s__len, REAL *r)
+{
+	INT16 p, e;
+	REAL y, g;
+	BOOLEAN neg, negE;
+	__DUP(s, s__len, CHAR);
+	p = 0;
+	while (s[__X(p, s__len)] == ' ' || s[__X(p, s__len)] == '0') {
+		p += 1;
+	}
+	if (s[__X(p, s__len)] == '-') {
+		neg = 1;
+		p += 1;
+	} else {
+		neg = 0;
+	}
+	while (s[__X(p, s__len)] == ' ' || s[__X(p, s__len)] == '0') {
+		p += 1;
+	}
+	y = (REAL)0;
+	while (('0' <= s[__X(p, s__len)] && s[__X(p, s__len)] <= '9')) {
+		y = y * (REAL)10 + ((INT16)s[__X(p, s__len)] - 48);
+		p += 1;
+	}
+	if (s[__X(p, s__len)] == '.') {
+		p += 1;
+		g = (REAL)1;
+		while (('0' <= s[__X(p, s__len)] && s[__X(p, s__len)] <= '9')) {
+			g = g / (REAL)(REAL)10;
+			y = y + g * ((INT16)s[__X(p, s__len)] - 48);
+			p += 1;
+		}
+	}
+	if (s[__X(p, s__len)] == 'D' || s[__X(p, s__len)] == 'E') {
+		p += 1;
+		e = 0;
+		if (s[__X(p, s__len)] == '-') {
+			negE = 1;
+			p += 1;
+		} else {
+			negE = 0;
+		}
+		while (s[__X(p, s__len)] == '0') {
+			p += 1;
+		}
+		while (('0' <= s[__X(p, s__len)] && s[__X(p, s__len)] <= '9')) {
+			e = e * 10 + ((INT16)s[__X(p, s__len)] - 48);
+			p += 1;
+		}
+		if (negE) {
+			y = y / (REAL)Reals_Ten(e);
+		} else {
+			y = y * Reals_Ten(e);
+		}
+	}
+	if (neg) {
+		y = -y;
+	}
+	*r = y;
+	__DEL(s);
+}
+
+void Strings_StrToLongReal (CHAR *s, ADDRESS s__len, LONGREAL *r)
+{
+	INT16 p, e;
+	LONGREAL y, g;
+	BOOLEAN neg, negE;
+	__DUP(s, s__len, CHAR);
+	p = 0;
+	while (s[__X(p, s__len)] == ' ' || s[__X(p, s__len)] == '0') {
+		p += 1;
+	}
+	if (s[__X(p, s__len)] == '-') {
+		neg = 1;
+		p += 1;
+	} else {
+		neg = 0;
+	}
+	while (s[__X(p, s__len)] == ' ' || s[__X(p, s__len)] == '0') {
+		p += 1;
+	}
+	y = (LONGREAL)0;
+	while (('0' <= s[__X(p, s__len)] && s[__X(p, s__len)] <= '9')) {
+		y = y * (LONGREAL)10 + ((INT16)s[__X(p, s__len)] - 48);
+		p += 1;
+	}
+	if (s[__X(p, s__len)] == '.') {
+		p += 1;
+		g = (LONGREAL)1;
+		while (('0' <= s[__X(p, s__len)] && s[__X(p, s__len)] <= '9')) {
+			g = g / (LONGREAL)(LONGREAL)10;
+			y = y + g * ((INT16)s[__X(p, s__len)] - 48);
+			p += 1;
+		}
+	}
+	if (s[__X(p, s__len)] == 'D' || s[__X(p, s__len)] == 'E') {
+		p += 1;
+		e = 0;
+		if (s[__X(p, s__len)] == '-') {
+			negE = 1;
+			p += 1;
+		} else {
+			negE = 0;
+		}
+		while (s[__X(p, s__len)] == '0') {
+			p += 1;
+		}
+		while (('0' <= s[__X(p, s__len)] && s[__X(p, s__len)] <= '9')) {
+			e = e * 10 + ((INT16)s[__X(p, s__len)] - 48);
+			p += 1;
+		}
+		if (negE) {
+			y = y / (LONGREAL)Reals_Ten(e);
+		} else {
+			y = y * Reals_Ten(e);
+		}
+	}
+	if (neg) {
+		y = -y;
+	}
+	*r = y;
+	__DEL(s);
+}
+
+
+export void *Strings__init(void)
+{
+	__DEFMOD;
+	__MODULE_IMPORT(Reals);
+	__REGMOD("Strings", 0);
+/* BEGIN */
+	__ENDMOD;
+}

bootstrap/unix-44/Strings.h

@@ -0,0 +1,25 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Strings__h
+#define Strings__h
+
+#include "SYSTEM.h"
+
+
+
+
+import void Strings_Append (CHAR *extra, ADDRESS extra__len, CHAR *dest, ADDRESS dest__len);
+import void Strings_Cap (CHAR *s, ADDRESS s__len);
+import void Strings_Delete (CHAR *s, ADDRESS s__len, INT16 pos, INT16 n);
+import void Strings_Extract (CHAR *source, ADDRESS source__len, INT16 pos, INT16 n, CHAR *dest, ADDRESS dest__len);
+import void Strings_Insert (CHAR *source, ADDRESS source__len, INT16 pos, CHAR *dest, ADDRESS dest__len);
+import INT16 Strings_Length (CHAR *s, ADDRESS s__len);
+import BOOLEAN Strings_Match (CHAR *string, ADDRESS string__len, CHAR *pattern, ADDRESS pattern__len);
+import INT16 Strings_Pos (CHAR *pattern, ADDRESS pattern__len, CHAR *s, ADDRESS s__len, INT16 pos);
+import void Strings_Replace (CHAR *source, ADDRESS source__len, INT16 pos, CHAR *dest, ADDRESS dest__len);
+import void Strings_StrToLongReal (CHAR *s, ADDRESS s__len, LONGREAL *r);
+import void Strings_StrToReal (CHAR *s, ADDRESS s__len, REAL *r);
+import void *Strings__init(void);
+
+
+#endif // Strings

bootstrap/unix-44/Texts.h

@@ -0,0 +1,172 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Texts__h
+#define Texts__h
+
+#include "SYSTEM.h"
+#include "Files.h"
+
+typedef
+	struct Texts_BufDesc {
+		INT32 len;
+		char _prvt0[4];
+	} Texts_BufDesc;
+
+typedef
+	Texts_BufDesc *Texts_Buffer;
+
+typedef
+	struct Texts_ElemMsg {
+		char _prvt0[1];
+	} Texts_ElemMsg;
+
+typedef
+	struct Texts_ElemDesc *Texts_Elem;
+
+typedef
+	struct Texts_CopyMsg { /* Texts_ElemMsg */
+		Texts_Elem e;
+	} Texts_CopyMsg;
+
+typedef
+	struct Texts_RunDesc {
+		INT32 _prvt0;
+		char _prvt1[15];
+	} Texts_RunDesc;
+
+typedef
+	void (*Texts_Handler)(Texts_Elem, Texts_ElemMsg*, ADDRESS *);
+
+typedef
+	struct Texts_ElemDesc {
+		char _prvt0[20];
+		INT32 W, H;
+		Texts_Handler handle;
+		char _prvt1[4];
+	} Texts_ElemDesc;
+
+typedef
+	struct Texts_FileMsg { /* Texts_ElemMsg */
+		INT16 id;
+		INT32 pos;
+		Files_Rider r;
+	} Texts_FileMsg;
+
+typedef
+	struct Texts_FontDesc {
+		char _prvt0[32];
+	} Texts_FontDesc;
+
+typedef
+	Texts_FontDesc *Texts_FontsFont;
+
+typedef
+	struct Texts_IdentifyMsg { /* Texts_ElemMsg */
+		CHAR mod[32], proc[32];
+	} Texts_IdentifyMsg;
+
+typedef
+	struct Texts_TextDesc *Texts_Text;
+
+typedef
+	void (*Texts_Notifier)(Texts_Text, INT16, INT32, INT32);
+
+typedef
+	struct Texts_Reader {
+		BOOLEAN eot;
+		Texts_FontsFont fnt;
+		INT8 col, voff;
+		Texts_Elem elem;
+		char _prvt0[32];
+	} Texts_Reader;
+
+typedef
+	struct Texts_Scanner { /* Texts_Reader */
+		BOOLEAN eot;
+		Texts_FontsFont fnt;
+		INT8 col, voff;
+		Texts_Elem elem;
+		char _prvt0[32];
+		CHAR nextCh;
+		INT16 line, class;
+		INT32 i;
+		REAL x;
+		LONGREAL y;
+		CHAR c;
+		INT8 len;
+		CHAR s[64];
+	} Texts_Scanner;
+
+typedef
+	struct Texts_TextDesc {
+		INT32 len;
+		Texts_Notifier notify;
+		char _prvt0[12];
+	} Texts_TextDesc;
+
+typedef
+	struct Texts_Writer {
+		Texts_Buffer buf;
+		Texts_FontsFont fnt;
+		INT8 col, voff;
+		char _prvt0[26];
+	} Texts_Writer;
+
+
+import Texts_Elem Texts_new;
+
+import ADDRESS *Texts_FontDesc__typ;
+import ADDRESS *Texts_RunDesc__typ;
+import ADDRESS *Texts_ElemMsg__typ;
+import ADDRESS *Texts_ElemDesc__typ;
+import ADDRESS *Texts_FileMsg__typ;
+import ADDRESS *Texts_CopyMsg__typ;
+import ADDRESS *Texts_IdentifyMsg__typ;
+import ADDRESS *Texts_BufDesc__typ;
+import ADDRESS *Texts_TextDesc__typ;
+import ADDRESS *Texts_Reader__typ;
+import ADDRESS *Texts_Scanner__typ;
+import ADDRESS *Texts_Writer__typ;
+
+import void Texts_Append (Texts_Text T, Texts_Buffer B);
+import void Texts_ChangeLooks (Texts_Text T, INT32 beg, INT32 end, UINT32 sel, Texts_FontsFont fnt, INT8 col, INT8 voff);
+import void Texts_Close (Texts_Text T, CHAR *name, ADDRESS name__len);
+import void Texts_Copy (Texts_Buffer SB, Texts_Buffer DB);
+import void Texts_CopyElem (Texts_Elem SE, Texts_Elem DE);
+import void Texts_Delete (Texts_Text T, INT32 beg, INT32 end);
+import Texts_Text Texts_ElemBase (Texts_Elem E);
+import INT32 Texts_ElemPos (Texts_Elem E);
+import void Texts_Insert (Texts_Text T, INT32 pos, Texts_Buffer B);
+import void Texts_Load (Files_Rider *r, ADDRESS *r__typ, Texts_Text T);
+import void Texts_Open (Texts_Text T, CHAR *name, ADDRESS name__len);
+import void Texts_OpenBuf (Texts_Buffer B);
+import void Texts_OpenReader (Texts_Reader *R, ADDRESS *R__typ, Texts_Text T, INT32 pos);
+import void Texts_OpenScanner (Texts_Scanner *S, ADDRESS *S__typ, Texts_Text T, INT32 pos);
+import void Texts_OpenWriter (Texts_Writer *W, ADDRESS *W__typ);
+import INT32 Texts_Pos (Texts_Reader *R, ADDRESS *R__typ);
+import void Texts_Read (Texts_Reader *R, ADDRESS *R__typ, CHAR *ch);
+import void Texts_ReadElem (Texts_Reader *R, ADDRESS *R__typ);
+import void Texts_ReadPrevElem (Texts_Reader *R, ADDRESS *R__typ);
+import void Texts_Recall (Texts_Buffer *B);
+import void Texts_Save (Texts_Text T, INT32 beg, INT32 end, Texts_Buffer B);
+import void Texts_Scan (Texts_Scanner *S, ADDRESS *S__typ);
+import void Texts_SetColor (Texts_Writer *W, ADDRESS *W__typ, INT8 col);
+import void Texts_SetFont (Texts_Writer *W, ADDRESS *W__typ, Texts_FontsFont fnt);
+import void Texts_SetOffset (Texts_Writer *W, ADDRESS *W__typ, INT8 voff);
+import void Texts_Store (Files_Rider *r, ADDRESS *r__typ, Texts_Text T);
+import void Texts_Write (Texts_Writer *W, ADDRESS *W__typ, CHAR ch);
+import void Texts_WriteDate (Texts_Writer *W, ADDRESS *W__typ, INT32 t, INT32 d);
+import void Texts_WriteElem (Texts_Writer *W, ADDRESS *W__typ, Texts_Elem e);
+import void Texts_WriteHex (Texts_Writer *W, ADDRESS *W__typ, INT32 x);
+import void Texts_WriteInt (Texts_Writer *W, ADDRESS *W__typ, INT64 x, INT64 n);
+import void Texts_WriteLn (Texts_Writer *W, ADDRESS *W__typ);
+import void Texts_WriteLongReal (Texts_Writer *W, ADDRESS *W__typ, LONGREAL x, INT16 n);
+import void Texts_WriteLongRealHex (Texts_Writer *W, ADDRESS *W__typ, LONGREAL x);
+import void Texts_WriteReal (Texts_Writer *W, ADDRESS *W__typ, REAL x, INT16 n);
+import void Texts_WriteRealFix (Texts_Writer *W, ADDRESS *W__typ, REAL x, INT16 n, INT16 k);
+import void Texts_WriteRealHex (Texts_Writer *W, ADDRESS *W__typ, REAL x);
+import void Texts_WriteString (Texts_Writer *W, ADDRESS *W__typ, CHAR *s, ADDRESS s__len);
+import void *Texts__init(void);
+
+
+#endif // Texts

bootstrap/unix-44/VT100.c

@@ -0,0 +1,275 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "Out.h"
+#include "Strings.h"
+
+
+export CHAR VT100_CSI[5];
+static CHAR VT100_tmpstr[32];
+
+
+export void VT100_CHA (INT16 n);
+export void VT100_CNL (INT16 n);
+export void VT100_CPL (INT16 n);
+export void VT100_CUB (INT16 n);
+export void VT100_CUD (INT16 n);
+export void VT100_CUF (INT16 n);
+export void VT100_CUP (INT16 n, INT16 m);
+export void VT100_CUU (INT16 n);
+export void VT100_DECTCEMh (void);
+export void VT100_DECTCEMl (void);
+export void VT100_DSR (INT16 n);
+export void VT100_ED (INT16 n);
+export void VT100_EL (INT16 n);
+static void VT100_EscSeq (INT16 n, CHAR *letter, ADDRESS letter__len);
+static void VT100_EscSeq0 (CHAR *letter, ADDRESS letter__len);
+static void VT100_EscSeq2 (INT16 n, INT16 m, CHAR *letter, ADDRESS letter__len);
+static void VT100_EscSeqSwapped (INT16 n, CHAR *letter, ADDRESS letter__len);
+export void VT100_HVP (INT16 n, INT16 m);
+export void VT100_IntToStr (INT32 int_, CHAR *str, ADDRESS str__len);
+export void VT100_RCP (void);
+export void VT100_Reset (void);
+static void VT100_Reverse0 (CHAR *str, ADDRESS str__len, INT16 start, INT16 end);
+export void VT100_SCP (void);
+export void VT100_SD (INT16 n);
+export void VT100_SGR (INT16 n);
+export void VT100_SGR2 (INT16 n, INT16 m);
+export void VT100_SU (INT16 n);
+export void VT100_SetAttr (CHAR *attr, ADDRESS attr__len);
+
+
+static void VT100_Reverse0 (CHAR *str, ADDRESS str__len, INT16 start, INT16 end)
+{
+	CHAR h;
+	while (start < end) {
+		h = str[__X(start, str__len)];
+		str[__X(start, str__len)] = str[__X(end, str__len)];
+		str[__X(end, str__len)] = h;
+		start += 1;
+		end -= 1;
+	}
+}
+
+void VT100_IntToStr (INT32 int_, CHAR *str, ADDRESS str__len)
+{
+	CHAR b[21];
+	INT16 s, e;
+	INT8 maxLength;
+	maxLength = 11;
+	if (int_ == (-2147483647-1)) {
+		__MOVE("-2147483648", b, 12);
+		e = 11;
+	} else {
+		if (int_ < 0) {
+			b[0] = '-';
+			int_ = -int_;
+			s = 1;
+		} else {
+			s = 0;
+		}
+		e = s;
+		do {
+			b[__X(e, 21)] = __CHR((int)__MOD(int_, 10) + 48);
+			int_ = __DIV(int_, 10);
+			e += 1;
+		} while (!(int_ == 0));
+		b[__X(e, 21)] = 0x00;
+		VT100_Reverse0((void*)b, 21, s, e - 1);
+	}
+	__COPY(b, str, str__len);
+}
+
+static void VT100_EscSeq0 (CHAR *letter, ADDRESS letter__len)
+{
+	CHAR cmd[9];
+	__DUP(letter, letter__len, CHAR);
+	__COPY(VT100_CSI, cmd, 9);
+	Strings_Append(letter, letter__len, (void*)cmd, 9);
+	Out_String(cmd, 9);
+	__DEL(letter);
+}
+
+static void VT100_EscSeq (INT16 n, CHAR *letter, ADDRESS letter__len)
+{
+	CHAR nstr[2];
+	CHAR cmd[7];
+	__DUP(letter, letter__len, CHAR);
+	VT100_IntToStr(n, (void*)nstr, 2);
+	__COPY(VT100_CSI, cmd, 7);
+	Strings_Append(nstr, 2, (void*)cmd, 7);
+	Strings_Append(letter, letter__len, (void*)cmd, 7);
+	Out_String(cmd, 7);
+	__DEL(letter);
+}
+
+static void VT100_EscSeqSwapped (INT16 n, CHAR *letter, ADDRESS letter__len)
+{
+	CHAR nstr[2];
+	CHAR cmd[7];
+	__DUP(letter, letter__len, CHAR);
+	VT100_IntToStr(n, (void*)nstr, 2);
+	__COPY(VT100_CSI, cmd, 7);
+	Strings_Append(letter, letter__len, (void*)cmd, 7);
+	Strings_Append(nstr, 2, (void*)cmd, 7);
+	Out_String(cmd, 7);
+	__DEL(letter);
+}
+
+static void VT100_EscSeq2 (INT16 n, INT16 m, CHAR *letter, ADDRESS letter__len)
+{
+	CHAR nstr[5], mstr[5];
+	CHAR cmd[12];
+	__DUP(letter, letter__len, CHAR);
+	VT100_IntToStr(n, (void*)nstr, 5);
+	VT100_IntToStr(m, (void*)mstr, 5);
+	__COPY(VT100_CSI, cmd, 12);
+	Strings_Append(nstr, 5, (void*)cmd, 12);
+	Strings_Append((CHAR*)";", 2, (void*)cmd, 12);
+	Strings_Append(mstr, 5, (void*)cmd, 12);
+	Strings_Append(letter, letter__len, (void*)cmd, 12);
+	Out_String(cmd, 12);
+	__DEL(letter);
+}
+
+void VT100_Reset (void)
+{
+	CHAR cmd[6];
+	__COPY("\033", cmd, 6);
+	Strings_Append((CHAR*)"c", 2, (void*)cmd, 6);
+	Out_String(cmd, 6);
+	Out_Ln();
+}
+
+void VT100_CUU (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"A", 2);
+}
+
+void VT100_CUD (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"B", 2);
+}
+
+void VT100_CUF (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"C", 2);
+}
+
+void VT100_CUB (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"D", 2);
+}
+
+void VT100_CNL (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"E", 2);
+}
+
+void VT100_CPL (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"F", 2);
+}
+
+void VT100_CHA (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"G", 2);
+}
+
+void VT100_CUP (INT16 n, INT16 m)
+{
+	VT100_EscSeq2(n, m, (CHAR*)"H", 2);
+}
+
+void VT100_ED (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"J", 2);
+}
+
+void VT100_EL (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"K", 2);
+}
+
+void VT100_SU (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"S", 2);
+}
+
+void VT100_SD (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"T", 2);
+}
+
+void VT100_HVP (INT16 n, INT16 m)
+{
+	VT100_EscSeq2(n, m, (CHAR*)"f", 2);
+}
+
+void VT100_SGR (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"m", 2);
+}
+
+void VT100_SGR2 (INT16 n, INT16 m)
+{
+	VT100_EscSeq2(n, m, (CHAR*)"m", 2);
+}
+
+void VT100_DSR (INT16 n)
+{
+	VT100_EscSeq(6, (CHAR*)"n", 2);
+}
+
+void VT100_SCP (void)
+{
+	VT100_EscSeq0((CHAR*)"s", 2);
+}
+
+void VT100_RCP (void)
+{
+	VT100_EscSeq0((CHAR*)"u", 2);
+}
+
+void VT100_DECTCEMl (void)
+{
+	VT100_EscSeq0((CHAR*)"\?25l", 5);
+}
+
+void VT100_DECTCEMh (void)
+{
+	VT100_EscSeq0((CHAR*)"\?25h", 5);
+}
+
+void VT100_SetAttr (CHAR *attr, ADDRESS attr__len)
+{
+	CHAR tmpstr[16];
+	__DUP(attr, attr__len, CHAR);
+	__COPY(VT100_CSI, tmpstr, 16);
+	Strings_Append(attr, attr__len, (void*)tmpstr, 16);
+	Out_String(tmpstr, 16);
+	__DEL(attr);
+}
+
+
+export void *VT100__init(void)
+{
+	__DEFMOD;
+	__MODULE_IMPORT(Out);
+	__MODULE_IMPORT(Strings);
+	__REGMOD("VT100", 0);
+	__REGCMD("DECTCEMh", VT100_DECTCEMh);
+	__REGCMD("DECTCEMl", VT100_DECTCEMl);
+	__REGCMD("RCP", VT100_RCP);
+	__REGCMD("Reset", VT100_Reset);
+	__REGCMD("SCP", VT100_SCP);
+/* BEGIN */
+	__COPY("\033", VT100_CSI, 5);
+	Strings_Append((CHAR*)"[", 2, (void*)VT100_CSI, 5);
+	__ENDMOD;
+}

bootstrap/unix-44/VT100.h

@@ -0,0 +1,38 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef VT100__h
+#define VT100__h
+
+#include "SYSTEM.h"
+
+
+import CHAR VT100_CSI[5];
+
+
+import void VT100_CHA (INT16 n);
+import void VT100_CNL (INT16 n);
+import void VT100_CPL (INT16 n);
+import void VT100_CUB (INT16 n);
+import void VT100_CUD (INT16 n);
+import void VT100_CUF (INT16 n);
+import void VT100_CUP (INT16 n, INT16 m);
+import void VT100_CUU (INT16 n);
+import void VT100_DECTCEMh (void);
+import void VT100_DECTCEMl (void);
+import void VT100_DSR (INT16 n);
+import void VT100_ED (INT16 n);
+import void VT100_EL (INT16 n);
+import void VT100_HVP (INT16 n, INT16 m);
+import void VT100_IntToStr (INT32 int_, CHAR *str, ADDRESS str__len);
+import void VT100_RCP (void);
+import void VT100_Reset (void);
+import void VT100_SCP (void);
+import void VT100_SD (INT16 n);
+import void VT100_SGR (INT16 n);
+import void VT100_SGR2 (INT16 n, INT16 m);
+import void VT100_SU (INT16 n);
+import void VT100_SetAttr (CHAR *attr, ADDRESS attr__len);
+import void *VT100__init(void);
+
+
+#endif // VT100

bootstrap/unix-44/extTools.c

@@ -0,0 +1,139 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "Configuration.h"
+#include "Heap.h"
+#include "Modules.h"
+#include "OPM.h"
+#include "Out.h"
+#include "Platform.h"
+#include "Strings.h"
+
+typedef
+	CHAR extTools_CommandString[4096];
+
+
+static extTools_CommandString extTools_CFLAGS;
+
+
+export void extTools_Assemble (CHAR *moduleName, ADDRESS moduleName__len);
+static void extTools_InitialiseCompilerCommand (CHAR *s, ADDRESS s__len, CHAR *additionalopts, ADDRESS additionalopts__len);
+export void extTools_LinkMain (CHAR *moduleName, ADDRESS moduleName__len, BOOLEAN statically, CHAR *additionalopts, ADDRESS additionalopts__len);
+static void extTools_execute (CHAR *title, ADDRESS title__len, CHAR *cmd, ADDRESS cmd__len);
+
+
+static void extTools_execute (CHAR *title, ADDRESS title__len, CHAR *cmd, ADDRESS cmd__len)
+{
+	INT16 r, status, exitcode;
+	extTools_CommandString fullcmd;
+	__DUP(title, title__len, CHAR);
+	__DUP(cmd, cmd__len, CHAR);
+	if (__IN(18, OPM_Options, 32)) {
+		Out_String((CHAR*)"  ", 3);
+		Out_String(cmd, cmd__len);
+		Out_Ln();
+	}
+	__COPY(cmd, fullcmd, 4096);
+	Heap_GC(0);
+	r = Platform_System(fullcmd, 4096);
+	status = __MASK(r, -128);
+	exitcode = __ASHR(r, 8);
+	if (exitcode > 127) {
+		exitcode = exitcode - 256;
+	}
+	if (r != 0) {
+		Out_String(title, title__len);
+		Out_String(cmd, cmd__len);
+		Out_Ln();
+		Out_String((CHAR*)"-- failed: status ", 19);
+		Out_Int(status, 1);
+		Out_String((CHAR*)", exitcode ", 12);
+		Out_Int(exitcode, 1);
+		Out_String((CHAR*)".", 2);
+		Out_Ln();
+		if ((status == 0 && exitcode == 127)) {
+			Out_String((CHAR*)"Is the C compiler in the current command path\?", 47);
+			Out_Ln();
+		}
+		if (status != 0) {
+			Modules_Halt(status);
+		} else {
+			Modules_Halt(exitcode);
+		}
+	}
+	__DEL(title);
+	__DEL(cmd);
+}
+
+static void extTools_InitialiseCompilerCommand (CHAR *s, ADDRESS s__len, CHAR *additionalopts, ADDRESS additionalopts__len)
+{
+	__DUP(additionalopts, additionalopts__len, CHAR);
+	__COPY("gcc -fPIC -g -Wno-stringop-overflow", s, s__len);
+	Strings_Append((CHAR*)" -I \"", 6, (void*)s, s__len);
+	Strings_Append(OPM_ResourceDir, 1024, (void*)s, s__len);
+	Strings_Append((CHAR*)"/include\" ", 11, (void*)s, s__len);
+	Strings_Append(additionalopts, additionalopts__len, (void*)s, s__len);
+	Strings_Append((CHAR*)" ", 2, (void*)s, s__len);
+	Platform_GetEnv((CHAR*)"CFLAGS", 7, (void*)extTools_CFLAGS, 4096);
+	Strings_Append(extTools_CFLAGS, 4096, (void*)s, s__len);
+	Strings_Append((CHAR*)" ", 2, (void*)s, s__len);
+	__DEL(additionalopts);
+}
+
+void extTools_Assemble (CHAR *moduleName, ADDRESS moduleName__len)
+{
+	extTools_CommandString cmd;
+	__DUP(moduleName, moduleName__len, CHAR);
+	extTools_InitialiseCompilerCommand((void*)cmd, 4096, (CHAR*)"", 1);
+	Strings_Append((CHAR*)"-c ", 4, (void*)cmd, 4096);
+	Strings_Append(moduleName, moduleName__len, (void*)cmd, 4096);
+	Strings_Append((CHAR*)".c", 3, (void*)cmd, 4096);
+	extTools_execute((CHAR*)"C compile: ", 12, cmd, 4096);
+	__DEL(moduleName);
+}
+
+void extTools_LinkMain (CHAR *moduleName, ADDRESS moduleName__len, BOOLEAN statically, CHAR *additionalopts, ADDRESS additionalopts__len)
+{
+	extTools_CommandString cmd;
+	__DUP(additionalopts, additionalopts__len, CHAR);
+	extTools_InitialiseCompilerCommand((void*)cmd, 4096, additionalopts, additionalopts__len);
+	Strings_Append(moduleName, moduleName__len, (void*)cmd, 4096);
+	Strings_Append((CHAR*)".c ", 4, (void*)cmd, 4096);
+	if (statically) {
+		Strings_Append((CHAR*)" -static", 9, (void*)cmd, 4096);
+	}
+	Strings_Append((CHAR*)" -o ", 5, (void*)cmd, 4096);
+	Strings_Append(moduleName, moduleName__len, (void*)cmd, 4096);
+	if (!statically || 1) {
+		Strings_Append((CHAR*)" -L\"", 5, (void*)cmd, 4096);
+		Strings_Append(OPM_InstallDir, 1024, (void*)cmd, 4096);
+		Strings_Append((CHAR*)"/lib\"", 6, (void*)cmd, 4096);
+		Strings_Append((CHAR*)" -lvoc", 7, (void*)cmd, 4096);
+		Strings_Append((CHAR*)"-O", 3, (void*)cmd, 4096);
+		Strings_Append(OPM_Model, 10, (void*)cmd, 4096);
+		Strings_Append((CHAR*)"", 1, (void*)cmd, 4096);
+	}
+	extTools_execute((CHAR*)"C compile and link: ", 21, cmd, 4096);
+	__DEL(additionalopts);
+}
+
+
+export void *extTools__init(void)
+{
+	__DEFMOD;
+	__MODULE_IMPORT(Configuration);
+	__MODULE_IMPORT(Heap);
+	__MODULE_IMPORT(Modules);
+	__MODULE_IMPORT(OPM);
+	__MODULE_IMPORT(Out);
+	__MODULE_IMPORT(Platform);
+	__MODULE_IMPORT(Strings);
+	__REGMOD("extTools", 0);
+/* BEGIN */
+	__ENDMOD;
+}

bootstrap/unix-44/extTools.h

@@ -0,0 +1,16 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef extTools__h
+#define extTools__h
+
+#include "SYSTEM.h"
+
+
+
+
+import void extTools_Assemble (CHAR *moduleName, ADDRESS moduleName__len);
+import void extTools_LinkMain (CHAR *moduleName, ADDRESS moduleName__len, BOOLEAN statically, CHAR *additionalopts, ADDRESS additionalopts__len);
+import void *extTools__init(void);
+
+
+#endif // extTools

bootstrap/unix-48/Compiler.c

@@ -0,0 +1,213 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspamS */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "Configuration.h"
+#include "Heap.h"
+#include "OPB.h"
+#include "OPC.h"
+#include "OPM.h"
+#include "OPP.h"
+#include "OPT.h"
+#include "OPV.h"
+#include "Platform.h"
+#include "Strings.h"
+#include "VT100.h"
+#include "extTools.h"
+
+
+
+
+static void Compiler_FindLocalObjectFiles (CHAR *objectnames, ADDRESS objectnames__len);
+export void Compiler_Module (BOOLEAN *done);
+static void Compiler_PropagateElementaryTypeSizes (void);
+export void Compiler_Translate (void);
+static void Compiler_Trap (INT32 sig);
+
+
+void Compiler_Module (BOOLEAN *done)
+{
+	BOOLEAN ext, new;
+	OPT_Node p = NIL;
+	OPP_Module(&p, OPM_Options);
+	if (OPM_noerr) {
+		OPV_Init();
+		OPT_InitRecno();
+		OPV_AdrAndSize(OPT_topScope);
+		OPT_Export(&ext, &new);
+		if (OPM_noerr) {
+			OPM_OpenFiles((void*)OPT_SelfName, 256);
+			OPM_DeleteObj((void*)OPT_SelfName, 256);
+			OPC_Init();
+			OPV_Module(p);
+			if (OPM_noerr) {
+				if ((__IN(10, OPM_Options, 32) && __STRCMP(OPM_modName, "SYSTEM") != 0)) {
+					OPM_DeleteSym((void*)OPT_SelfName, 256);
+					OPM_LogVT100((CHAR*)"32m", 4);
+					OPM_LogWStr((CHAR*)"  Main program.", 16);
+					OPM_LogVT100((CHAR*)"0m", 3);
+				} else {
+					if (new) {
+						OPM_LogVT100((CHAR*)"32m", 4);
+						OPM_LogWStr((CHAR*)"  New symbol file.", 19);
+						OPM_LogVT100((CHAR*)"0m", 3);
+						OPM_RegisterNewSym();
+					} else if (ext) {
+						OPM_LogWStr((CHAR*)"  Extended symbol file.", 24);
+						OPM_RegisterNewSym();
+					}
+				}
+			} else {
+				OPM_DeleteSym((void*)OPT_SelfName, 256);
+			}
+		}
+	}
+	OPM_CloseFiles();
+	OPT_Close();
+	OPM_LogWLn();
+	*done = OPM_noerr;
+}
+
+static void Compiler_PropagateElementaryTypeSizes (void)
+{
+	OPT_Struct adrinttyp = NIL;
+	OPT_sysptrtyp->size = OPM_AddressSize;
+	OPT_sysptrtyp->idfp = OPT_sysptrtyp->form;
+	OPM_FPrint(&OPT_sysptrtyp->idfp, OPT_sysptrtyp->size);
+	OPT_adrtyp->size = OPM_AddressSize;
+	OPT_adrtyp->idfp = OPT_adrtyp->form;
+	OPM_FPrint(&OPT_adrtyp->idfp, OPT_adrtyp->size);
+	adrinttyp = OPT_IntType(OPM_AddressSize);
+	OPT_adrtyp->strobj = adrinttyp->strobj;
+	OPT_sinttyp = OPT_IntType(OPM_ShortintSize);
+	OPT_inttyp = OPT_IntType(OPM_IntegerSize);
+	OPT_linttyp = OPT_IntType(OPM_LongintSize);
+	OPT_sintobj->typ = OPT_sinttyp;
+	OPT_intobj->typ = OPT_inttyp;
+	OPT_lintobj->typ = OPT_linttyp;
+	switch (OPM_SetSize) {
+		case 4: 
+			OPT_settyp = OPT_set32typ;
+			break;
+		default: 
+			OPT_settyp = OPT_set64typ;
+			break;
+	}
+	OPT_setobj->typ = OPT_settyp;
+	if (__STRCMP(OPM_Model, "C") == 0) {
+		OPT_cpbytetyp->strobj->name[4] = 0x00;
+	} else {
+		OPT_cpbytetyp->strobj->name[4] = '@';
+	}
+}
+
+static void Compiler_FindLocalObjectFiles (CHAR *objectnames, ADDRESS objectnames__len)
+{
+	OPT_Link l = NIL;
+	CHAR fn[64];
+	Platform_FileIdentity id;
+	objectnames[0] = 0x00;
+	l = OPT_Links;
+	while (l != NIL) {
+		__COPY(l->name, fn, 64);
+		Strings_Append((CHAR*)".sym", 5, (void*)fn, 64);
+		if (Platform_IdentifyByName(fn, 64, &id, Platform_FileIdentity__typ) == 0) {
+			__COPY(l->name, fn, 64);
+			Strings_Append((CHAR*)".o", 3, (void*)fn, 64);
+			if (Platform_IdentifyByName(fn, 64, &id, Platform_FileIdentity__typ) == 0) {
+				Strings_Append((CHAR*)" ", 2, (void*)objectnames, objectnames__len);
+				Strings_Append(fn, 64, (void*)objectnames, objectnames__len);
+			} else {
+				OPM_LogVT100((CHAR*)"91m", 4);
+				OPM_LogWStr((CHAR*)"Link warning: a local symbol file is present for module ", 57);
+				OPM_LogWStr(l->name, 256);
+				OPM_LogWStr((CHAR*)", but local object file '", 26);
+				OPM_LogWStr(fn, 64);
+				OPM_LogWStr((CHAR*)"' is missing.", 14);
+				OPM_LogVT100((CHAR*)"0m", 3);
+				OPM_LogWLn();
+			}
+		}
+		l = l->next;
+	}
+}
+
+void Compiler_Translate (void)
+{
+	BOOLEAN done;
+	CHAR linkfiles[2048];
+	if (OPM_OpenPar()) {
+		for (;;) {
+			OPM_Init(&done);
+			if (!done) {
+				return;
+			}
+			OPM_InitOptions();
+			Compiler_PropagateElementaryTypeSizes();
+			Heap_GC(0);
+			Compiler_Module(&done);
+			if (!done) {
+				OPM_LogWLn();
+				OPM_LogWStr((CHAR*)"Module compilation failed.", 27);
+				OPM_LogWLn();
+				Platform_Exit(1);
+			}
+			if (!__IN(13, OPM_Options, 32)) {
+				if (__IN(14, OPM_Options, 32)) {
+					extTools_Assemble(OPM_modName, 32);
+				} else {
+					if (!__IN(10, OPM_Options, 32)) {
+						extTools_Assemble(OPM_modName, 32);
+					} else {
+						Compiler_FindLocalObjectFiles((void*)linkfiles, 2048);
+						extTools_LinkMain((void*)OPM_modName, 32, __IN(15, OPM_Options, 32), linkfiles, 2048);
+					}
+				}
+			}
+		}
+	}
+}
+
+static void Compiler_Trap (INT32 sig)
+{
+	Heap_FINALL();
+	if (sig == 3) {
+		Platform_Exit(0);
+	} else {
+		if (sig == 4) {
+			OPM_LogWStr((CHAR*)" --- Oberon compiler internal error", 36);
+			OPM_LogWLn();
+		}
+		Platform_Exit(2);
+	}
+}
+
+
+export int main(int argc, char **argv)
+{
+	__INIT(argc, argv);
+	__MODULE_IMPORT(Configuration);
+	__MODULE_IMPORT(Heap);
+	__MODULE_IMPORT(OPB);
+	__MODULE_IMPORT(OPC);
+	__MODULE_IMPORT(OPM);
+	__MODULE_IMPORT(OPP);
+	__MODULE_IMPORT(OPT);
+	__MODULE_IMPORT(OPV);
+	__MODULE_IMPORT(Platform);
+	__MODULE_IMPORT(Strings);
+	__MODULE_IMPORT(VT100);
+	__MODULE_IMPORT(extTools);
+	__REGMAIN("Compiler", 0);
+	__REGCMD("Translate", Compiler_Translate);
+/* BEGIN */
+	Platform_SetInterruptHandler(Compiler_Trap);
+	Platform_SetQuitHandler(Compiler_Trap);
+	Platform_SetBadInstructionHandler(Compiler_Trap);
+	Compiler_Translate();
+	__FINI;
+}

bootstrap/unix-48/Configuration.c

@@ -0,0 +1,24 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+
+
+export CHAR Configuration_versionLong[76];
+
+
+
+
+
+export void *Configuration__init(void)
+{
+	__DEFMOD;
+	__REGMOD("Configuration", 0);
+/* BEGIN */
+	__MOVE("2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8.", Configuration_versionLong, 76);
+	__ENDMOD;
+}

bootstrap/unix-48/Configuration.h

@@ -0,0 +1,15 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Configuration__h
+#define Configuration__h
+
+#include "SYSTEM.h"
+
+
+import CHAR Configuration_versionLong[76];
+
+
+import void *Configuration__init(void);
+
+
+#endif // Configuration

bootstrap/unix-48/Files.h

@@ -0,0 +1,70 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Files__h
+#define Files__h
+
+#include "SYSTEM.h"
+
+typedef
+	struct Files_FileDesc *Files_File;
+
+typedef
+	struct Files_FileDesc {
+		INT32 _prvt0;
+		char _prvt1[560];
+	} Files_FileDesc;
+
+typedef
+	struct Files_Rider {
+		INT32 res;
+		BOOLEAN eof;
+		char _prvt0[15];
+	} Files_Rider;
+
+
+import INT16 Files_MaxPathLength, Files_MaxNameLength;
+
+import ADDRESS *Files_FileDesc__typ;
+import ADDRESS *Files_Rider__typ;
+
+import Files_File Files_Base (Files_Rider *r, ADDRESS *r__typ);
+import void Files_ChangeDirectory (CHAR *path, ADDRESS path__len, INT16 *res);
+import void Files_Close (Files_File f);
+import void Files_Delete (CHAR *name, ADDRESS name__len, INT16 *res);
+import void Files_GetDate (Files_File f, INT32 *t, INT32 *d);
+import void Files_GetName (Files_File f, CHAR *name, ADDRESS name__len);
+import INT32 Files_Length (Files_File f);
+import Files_File Files_New (CHAR *name, ADDRESS name__len);
+import Files_File Files_Old (CHAR *name, ADDRESS name__len);
+import INT32 Files_Pos (Files_Rider *r, ADDRESS *r__typ);
+import void Files_Purge (Files_File f);
+import void Files_Read (Files_Rider *r, ADDRESS *r__typ, SYSTEM_BYTE *x);
+import void Files_ReadBool (Files_Rider *R, ADDRESS *R__typ, BOOLEAN *x);
+import void Files_ReadByte (Files_Rider *r, ADDRESS *r__typ, SYSTEM_BYTE *x);
+import void Files_ReadBytes (Files_Rider *r, ADDRESS *r__typ, SYSTEM_BYTE *x, ADDRESS x__len, INT32 n);
+import void Files_ReadInt (Files_Rider *R, ADDRESS *R__typ, INT16 *x);
+import void Files_ReadLInt (Files_Rider *R, ADDRESS *R__typ, INT32 *x);
+import void Files_ReadLReal (Files_Rider *R, ADDRESS *R__typ, LONGREAL *x);
+import void Files_ReadLine (Files_Rider *R, ADDRESS *R__typ, CHAR *x, ADDRESS x__len);
+import void Files_ReadNum (Files_Rider *R, ADDRESS *R__typ, SYSTEM_BYTE *x, ADDRESS x__len);
+import void Files_ReadReal (Files_Rider *R, ADDRESS *R__typ, REAL *x);
+import void Files_ReadSet (Files_Rider *R, ADDRESS *R__typ, UINT32 *x);
+import void Files_ReadString (Files_Rider *R, ADDRESS *R__typ, CHAR *x, ADDRESS x__len);
+import void Files_Register (Files_File f);
+import void Files_Rename (CHAR *old, ADDRESS old__len, CHAR *new, ADDRESS new__len, INT16 *res);
+import void Files_Set (Files_Rider *r, ADDRESS *r__typ, Files_File f, INT32 pos);
+import void Files_SetSearchPath (CHAR *path, ADDRESS path__len);
+import void Files_Write (Files_Rider *r, ADDRESS *r__typ, SYSTEM_BYTE x);
+import void Files_WriteBool (Files_Rider *R, ADDRESS *R__typ, BOOLEAN x);
+import void Files_WriteBytes (Files_Rider *r, ADDRESS *r__typ, SYSTEM_BYTE *x, ADDRESS x__len, INT32 n);
+import void Files_WriteInt (Files_Rider *R, ADDRESS *R__typ, INT16 x);
+import void Files_WriteLInt (Files_Rider *R, ADDRESS *R__typ, INT32 x);
+import void Files_WriteLReal (Files_Rider *R, ADDRESS *R__typ, LONGREAL x);
+import void Files_WriteNum (Files_Rider *R, ADDRESS *R__typ, INT64 x);
+import void Files_WriteReal (Files_Rider *R, ADDRESS *R__typ, REAL x);
+import void Files_WriteSet (Files_Rider *R, ADDRESS *R__typ, UINT32 x);
+import void Files_WriteString (Files_Rider *R, ADDRESS *R__typ, CHAR *x, ADDRESS x__len);
+import void *Files__init(void);
+
+
+#endif // Files

bootstrap/unix-48/Heap.c

@@ -0,0 +1,799 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. rtsSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+
+struct Heap__1 {
+	CHAR ch;
+	SYSTEM_PTR p;
+};
+
+typedef
+	struct Heap_CmdDesc *Heap_Cmd;
+
+typedef
+	CHAR Heap_CmdName[24];
+
+typedef
+	void (*Heap_Command)(void);
+
+typedef
+	struct Heap_CmdDesc {
+		Heap_Cmd next;
+		Heap_CmdName name;
+		Heap_Command cmd;
+	} Heap_CmdDesc;
+
+typedef
+	void (*Heap_EnumProc)(void(*)(SYSTEM_PTR));
+
+typedef
+	struct Heap_FinDesc *Heap_FinNode;
+
+typedef
+	void (*Heap_Finalizer)(SYSTEM_PTR);
+
+typedef
+	struct Heap_FinDesc {
+		Heap_FinNode next;
+		INT32 obj;
+		BOOLEAN marked;
+		Heap_Finalizer finalize;
+	} Heap_FinDesc;
+
+typedef
+	struct Heap_ModuleDesc *Heap_Module;
+
+typedef
+	CHAR Heap_ModuleName[20];
+
+typedef
+	struct Heap_ModuleDesc {
+		Heap_Module next;
+		Heap_ModuleName name;
+		INT32 refcnt;
+		Heap_Cmd cmds;
+		INT32 types;
+		Heap_EnumProc enumPtrs;
+		INT32 reserved1, reserved2;
+	} Heap_ModuleDesc;
+
+
+export SYSTEM_PTR Heap_modules;
+static INT32 Heap_freeList[10];
+static INT32 Heap_bigBlocks;
+export INT32 Heap_allocated;
+static BOOLEAN Heap_firstTry;
+static INT16 Heap_ldUnit;
+export INT32 Heap_heap;
+static INT32 Heap_heapMin, Heap_heapMax;
+export INT32 Heap_heapsize, Heap_heapMinExpand;
+static Heap_FinNode Heap_fin;
+static INT16 Heap_lockdepth;
+static BOOLEAN Heap_interrupted;
+export INT16 Heap_FileCount;
+
+export ADDRESS *Heap_ModuleDesc__typ;
+export ADDRESS *Heap_CmdDesc__typ;
+export ADDRESS *Heap_FinDesc__typ;
+export ADDRESS *Heap__1__typ;
+
+static void Heap_CheckFin (void);
+static void Heap_ExtendHeap (INT32 blksz);
+export void Heap_FINALL (void);
+static void Heap_Finalize (void);
+export INT32 Heap_FreeModule (CHAR *name, ADDRESS name__len);
+export void Heap_GC (BOOLEAN markStack);
+static void Heap_HeapSort (INT32 n, INT32 *a, ADDRESS a__len);
+export void Heap_INCREF (Heap_Module m);
+export void Heap_InitHeap (void);
+export void Heap_Lock (void);
+static void Heap_Mark (INT32 q);
+static void Heap_MarkCandidates (INT32 n, INT32 *cand, ADDRESS cand__len);
+static void Heap_MarkP (SYSTEM_PTR p);
+static void Heap_MarkStack (INT32 n, INT32 *cand, ADDRESS cand__len);
+export SYSTEM_PTR Heap_NEWBLK (INT32 size);
+export SYSTEM_PTR Heap_NEWREC (INT32 tag);
+static INT32 Heap_NewChunk (INT32 blksz);
+export void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd);
+export SYSTEM_PTR Heap_REGMOD (Heap_ModuleName name, Heap_EnumProc enumPtrs);
+export void Heap_REGTYP (Heap_Module m, INT32 typ);
+export void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize);
+static void Heap_Scan (void);
+static void Heap_Sift (INT32 l, INT32 r, INT32 *a, ADDRESS a__len);
+export void Heap_Unlock (void);
+
+extern void *Heap__init();
+extern ADDRESS Modules_MainStackFrame;
+extern ADDRESS Platform_OSAllocate(ADDRESS size);
+#define Heap_HeapModuleInit()	Heap__init()
+#define Heap_ModulesHalt(code)	Modules_Halt(code)
+#define Heap_ModulesMainStackFrame()	Modules_MainStackFrame
+#define Heap_OSAllocate(size)	Platform_OSAllocate(size)
+#define Heap_uLE(x, y)	((size_t)x <= (size_t)y)
+#define Heap_uLT(x, y)	((size_t)x <  (size_t)y)
+
+void Heap_Lock (void)
+{
+	Heap_lockdepth += 1;
+}
+
+void Heap_Unlock (void)
+{
+	Heap_lockdepth -= 1;
+	if ((Heap_interrupted && Heap_lockdepth == 0)) {
+		Heap_ModulesHalt(-9);
+	}
+}
+
+SYSTEM_PTR Heap_REGMOD (Heap_ModuleName name, Heap_EnumProc enumPtrs)
+{
+	Heap_Module m;
+	if (__STRCMP(name, "Heap") == 0) {
+		__SYSNEW(m, 48);
+	} else {
+		__NEW(m, Heap_ModuleDesc);
+	}
+	m->types = 0;
+	m->cmds = NIL;
+	__COPY(name, m->name, 20);
+	m->refcnt = 0;
+	m->enumPtrs = enumPtrs;
+	m->next = (Heap_Module)(ADDRESS)Heap_modules;
+	Heap_modules = (SYSTEM_PTR)m;
+	return (void*)m;
+}
+
+INT32 Heap_FreeModule (CHAR *name, ADDRESS name__len)
+{
+	Heap_Module m, p;
+	__DUP(name, name__len, CHAR);
+	m = (Heap_Module)(ADDRESS)Heap_modules;
+	while ((m != NIL && __STRCMP(m->name, name) != 0)) {
+		p = m;
+		m = m->next;
+	}
+	if ((m != NIL && m->refcnt == 0)) {
+		if (m == (Heap_Module)(ADDRESS)Heap_modules) {
+			Heap_modules = (SYSTEM_PTR)m->next;
+		} else {
+			p->next = m->next;
+		}
+		__DEL(name);
+		return 0;
+	} else {
+		if (m == NIL) {
+			__DEL(name);
+			return -1;
+		} else {
+			__DEL(name);
+			return m->refcnt;
+		}
+	}
+	__RETCHK;
+}
+
+void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd)
+{
+	Heap_Cmd c;
+	if (__STRCMP(m->name, "Heap") == 0) {
+		__SYSNEW(c, 32);
+	} else {
+		__NEW(c, Heap_CmdDesc);
+	}
+	__COPY(name, c->name, 24);
+	c->cmd = cmd;
+	c->next = m->cmds;
+	m->cmds = c;
+}
+
+void Heap_REGTYP (Heap_Module m, INT32 typ)
+{
+	__PUT(typ, m->types, INT32);
+	m->types = typ;
+}
+
+void Heap_INCREF (Heap_Module m)
+{
+	m->refcnt += 1;
+}
+
+static INT32 Heap_NewChunk (INT32 blksz)
+{
+	INT32 chnk, blk, end;
+	chnk = Heap_OSAllocate(blksz + 12);
+	if (chnk != 0) {
+		blk = chnk + 12;
+		end = blk + blksz;
+		__PUT(chnk + 4, end, INT32);
+		__PUT(blk, blk + 4, INT32);
+		__PUT(blk + 4, blksz, INT32);
+		__PUT(blk + 8, -4, INT32);
+		__PUT(blk + 12, Heap_bigBlocks, INT32);
+		Heap_bigBlocks = blk;
+		Heap_heapsize += blksz;
+		if (Heap_uLT(blk + 4, Heap_heapMin)) {
+			Heap_heapMin = blk + 4;
+		}
+		if (Heap_uLT(Heap_heapMax, end)) {
+			Heap_heapMax = end;
+		}
+	}
+	return chnk;
+}
+
+static void Heap_ExtendHeap (INT32 blksz)
+{
+	INT32 size, chnk, j, next;
+		if (Heap_uLT(Heap_heapMinExpand, blksz)) {
+		size = blksz;
+	} else {
+		size = Heap_heapMinExpand;
+	}
+	chnk = Heap_NewChunk(size);
+	if (chnk != 0) {
+		if (Heap_uLT(chnk, Heap_heap)) {
+			__PUT(chnk, Heap_heap, INT32);
+			Heap_heap = chnk;
+		} else {
+			j = Heap_heap;
+			__GET(j, next, INT32);
+			while ((next != 0 && Heap_uLT(next, chnk))) {
+				j = next;
+				__GET(j, next, INT32);
+			}
+			__PUT(chnk, next, INT32);
+			__PUT(j, chnk, INT32);
+		}
+	} else if (!Heap_firstTry) {
+		Heap_heapMinExpand = 16;
+	}
+}
+
+SYSTEM_PTR Heap_NEWREC (INT32 tag)
+{
+	INT32 i, i0, di, blksz, restsize, t, adr, end, next, prev;
+	SYSTEM_PTR new;
+	Heap_Lock();
+	__GET(tag, blksz, INT32);
+		i0 = __LSH(blksz, -Heap_ldUnit, 32);
+	i = i0;
+	if (i < 9) {
+		adr = Heap_freeList[i];
+		while (adr == 0) {
+			i += 1;
+			adr = Heap_freeList[i];
+		}
+	}
+	if (i < 9) {
+		__GET(adr + 12, next, INT32);
+		Heap_freeList[i] = next;
+		if (i != i0) {
+			di = i - i0;
+			restsize = __ASHL(di, 4);
+			end = adr + restsize;
+			__PUT(end + 4, blksz, INT32);
+			__PUT(end + 8, -4, INT32);
+			__PUT(end, end + 4, INT32);
+			__PUT(adr + 4, restsize, INT32);
+			__PUT(adr + 12, Heap_freeList[di], INT32);
+			Heap_freeList[di] = adr;
+			adr += restsize;
+		}
+	} else {
+		adr = Heap_bigBlocks;
+		prev = 0;
+		for (;;) {
+			if (adr == 0) {
+				if (Heap_firstTry) {
+					Heap_GC(1);
+					blksz += 16;
+					t = __LSH(Heap_allocated + blksz, -(2 + Heap_ldUnit), 32) * 80;
+					if (Heap_uLT(Heap_heapsize, t)) {
+						Heap_ExtendHeap(t - Heap_heapsize);
+					}
+					Heap_firstTry = 0;
+					new = Heap_NEWREC(tag);
+					if (new == NIL) {
+						Heap_ExtendHeap(blksz);
+						new = Heap_NEWREC(tag);
+					}
+					Heap_firstTry = 1;
+					Heap_Unlock();
+					return new;
+				} else {
+					Heap_Unlock();
+					return NIL;
+				}
+			}
+			__GET(adr + 4, t, INT32);
+			if (Heap_uLE(blksz, t)) {
+				break;
+			}
+			prev = adr;
+			__GET(adr + 12, adr, INT32);
+		}
+		restsize = t - blksz;
+		end = adr + restsize;
+		__PUT(end + 4, blksz, INT32);
+		__PUT(end + 8, -4, INT32);
+		__PUT(end, end + 4, INT32);
+		if (Heap_uLT(144, restsize)) {
+			__PUT(adr + 4, restsize, INT32);
+		} else {
+			__GET(adr + 12, next, INT32);
+			if (prev == 0) {
+				Heap_bigBlocks = next;
+			} else {
+				__PUT(prev + 12, next, INT32);
+			}
+			if (restsize != 0) {
+				di = __ASHR(restsize, 4);
+				__PUT(adr + 4, restsize, INT32);
+				__PUT(adr + 12, Heap_freeList[di], INT32);
+				Heap_freeList[di] = adr;
+			}
+		}
+		adr += restsize;
+	}
+	i = adr + 16;
+	end = adr + blksz;
+	while (Heap_uLT(i, end)) {
+		__PUT(i, 0, INT32);
+		__PUT(i + 4, 0, INT32);
+		__PUT(i + 8, 0, INT32);
+		__PUT(i + 12, 0, INT32);
+		i += 16;
+	}
+	__PUT(adr + 12, 0, INT32);
+	__PUT(adr, tag, INT32);
+	__PUT(adr + 4, 0, INT32);
+	__PUT(adr + 8, 0, INT32);
+	Heap_allocated += blksz;
+	Heap_Unlock();
+	return (SYSTEM_PTR)(ADDRESS)(adr + 4);
+}
+
+SYSTEM_PTR Heap_NEWBLK (INT32 size)
+{
+	INT32 blksz, tag;
+	SYSTEM_PTR new;
+	Heap_Lock();
+	blksz = __ASHL(__ASHR(size + 31, 4), 4);
+	new = Heap_NEWREC((ADDRESS)&blksz);
+	tag = ((INT32)(ADDRESS)new + blksz) - 12;
+	__PUT(tag - 4, 0, INT32);
+	__PUT(tag, blksz, INT32);
+	__PUT(tag + 4, -4, INT32);
+	__PUT((INT32)(ADDRESS)new - 4, tag, INT32);
+	Heap_Unlock();
+	return new;
+}
+
+static void Heap_Mark (INT32 q)
+{
+	INT32 p, tag, offset, fld, n, tagbits;
+	if (q != 0) {
+		__GET(q - 4, tagbits, INT32);
+		if (!__ODD(tagbits)) {
+			__PUT(q - 4, tagbits + 1, INT32);
+			p = 0;
+			tag = tagbits + 4;
+			for (;;) {
+				__GET(tag, offset, INT32);
+				if (offset < 0) {
+					__PUT(q - 4, (tag + offset) + 1, INT32);
+					if (p == 0) {
+						break;
+					}
+					n = q;
+					q = p;
+					__GET(q - 4, tag, INT32);
+					tag -= 1;
+					__GET(tag, offset, INT32);
+					fld = q + offset;
+					__GET(fld, p, INT32);
+					__PUT(fld, (SYSTEM_PTR)(ADDRESS)n, SYSTEM_PTR);
+				} else {
+					fld = q + offset;
+					__GET(fld, n, INT32);
+					if (n != 0) {
+						__GET(n - 4, tagbits, INT32);
+						if (!__ODD(tagbits)) {
+							__PUT(n - 4, tagbits + 1, INT32);
+							__PUT(q - 4, tag + 1, INT32);
+							__PUT(fld, (SYSTEM_PTR)(ADDRESS)p, SYSTEM_PTR);
+							p = q;
+							q = n;
+							tag = tagbits;
+						}
+					}
+				}
+				tag += 4;
+			}
+		}
+	}
+}
+
+static void Heap_MarkP (SYSTEM_PTR p)
+{
+	Heap_Mark((INT32)(ADDRESS)p);
+}
+
+static void Heap_Scan (void)
+{
+	INT32 chnk, adr, end, start, tag, i, size, freesize;
+	Heap_bigBlocks = 0;
+	i = 1;
+	while (i < 9) {
+		Heap_freeList[i] = 0;
+		i += 1;
+	}
+	freesize = 0;
+	Heap_allocated = 0;
+	chnk = Heap_heap;
+	while (chnk != 0) {
+		adr = chnk + 12;
+		__GET(chnk + 4, end, INT32);
+		while (Heap_uLT(adr, end)) {
+			__GET(adr, tag, INT32);
+			if (__ODD(tag)) {
+				if (freesize != 0) {
+					start = adr - freesize;
+					__PUT(start, start + 4, INT32);
+					__PUT(start + 4, freesize, INT32);
+					__PUT(start + 8, -4, INT32);
+					i = __LSH(freesize, -Heap_ldUnit, 32);
+					freesize = 0;
+					if (Heap_uLT(i, 9)) {
+						__PUT(start + 12, Heap_freeList[i], INT32);
+						Heap_freeList[i] = start;
+					} else {
+						__PUT(start + 12, Heap_bigBlocks, INT32);
+						Heap_bigBlocks = start;
+					}
+				}
+				tag -= 1;
+				__PUT(adr, tag, INT32);
+				__GET(tag, size, INT32);
+				Heap_allocated += size;
+				adr += size;
+			} else {
+				__GET(tag, size, INT32);
+				freesize += size;
+				adr += size;
+			}
+		}
+		if (freesize != 0) {
+			start = adr - freesize;
+			__PUT(start, start + 4, INT32);
+			__PUT(start + 4, freesize, INT32);
+			__PUT(start + 8, -4, INT32);
+			i = __LSH(freesize, -Heap_ldUnit, 32);
+			freesize = 0;
+			if (Heap_uLT(i, 9)) {
+				__PUT(start + 12, Heap_freeList[i], INT32);
+				Heap_freeList[i] = start;
+			} else {
+				__PUT(start + 12, Heap_bigBlocks, INT32);
+				Heap_bigBlocks = start;
+			}
+		}
+		__GET(chnk, chnk, INT32);
+	}
+}
+
+static void Heap_Sift (INT32 l, INT32 r, INT32 *a, ADDRESS a__len)
+{
+	INT32 i, j;
+	INT32 x;
+	j = l;
+	x = a[j];
+	for (;;) {
+		i = j;
+		j = __ASHL(j, 1) + 1;
+		if ((j < r && Heap_uLT(a[j], a[j + 1]))) {
+			j += 1;
+		}
+		if (j > r || Heap_uLE(a[j], x)) {
+			break;
+		}
+		a[i] = a[j];
+	}
+	a[i] = x;
+}
+
+static void Heap_HeapSort (INT32 n, INT32 *a, ADDRESS a__len)
+{
+	INT32 l, r;
+	INT32 x;
+	l = __ASHR(n, 1);
+	r = n - 1;
+	while (l > 0) {
+		l -= 1;
+		Heap_Sift(l, r, (void*)a, a__len);
+	}
+	while (r > 0) {
+		x = a[0];
+		a[0] = a[r];
+		a[r] = x;
+		r -= 1;
+		Heap_Sift(l, r, (void*)a, a__len);
+	}
+}
+
+static void Heap_MarkCandidates (INT32 n, INT32 *cand, ADDRESS cand__len)
+{
+	INT32 chnk, end, adr, tag, next, i, ptr, size;
+		chnk = Heap_heap;
+	i = 0;
+	while (chnk != 0) {
+		__GET(chnk + 4, end, INT32);
+		adr = chnk + 12;
+		while (Heap_uLT(adr, end)) {
+			__GET(adr, tag, INT32);
+			if (__ODD(tag)) {
+				__GET(tag - 1, size, INT32);
+				adr += size;
+				ptr = adr + 4;
+				while (Heap_uLT(cand[i], ptr)) {
+					i += 1;
+					if (i == n) {
+						return;
+					}
+				}
+			} else {
+				__GET(tag, size, INT32);
+				ptr = adr + 4;
+				adr += size;
+				while (Heap_uLT(cand[i], ptr)) {
+					i += 1;
+					if (i == n) {
+						return;
+					}
+				}
+				if (Heap_uLT(cand[i], adr)) {
+					Heap_Mark(ptr);
+				}
+			}
+			if (Heap_uLE(end, cand[i])) {
+				adr = end;
+			}
+		}
+		__GET(chnk, chnk, INT32);
+	}
+}
+
+static void Heap_CheckFin (void)
+{
+	Heap_FinNode n;
+	INT32 tag;
+	n = Heap_fin;
+	while (n != NIL) {
+		__GET(n->obj - 4, tag, INT32);
+		if (!__ODD(tag)) {
+			n->marked = 0;
+			Heap_Mark(n->obj);
+		} else {
+			n->marked = 1;
+		}
+		n = n->next;
+	}
+}
+
+static void Heap_Finalize (void)
+{
+	Heap_FinNode n, prev;
+	n = Heap_fin;
+	prev = NIL;
+	while (n != NIL) {
+		if (!n->marked) {
+			if (n == Heap_fin) {
+				Heap_fin = Heap_fin->next;
+			} else {
+				prev->next = n->next;
+			}
+			(*n->finalize)((SYSTEM_PTR)(ADDRESS)n->obj);
+			if (prev == NIL) {
+				n = Heap_fin;
+			} else {
+				n = n->next;
+			}
+		} else {
+			prev = n;
+			n = n->next;
+		}
+	}
+}
+
+void Heap_FINALL (void)
+{
+	Heap_FinNode n;
+	while (Heap_fin != NIL) {
+		n = Heap_fin;
+		Heap_fin = Heap_fin->next;
+		(*n->finalize)((SYSTEM_PTR)(ADDRESS)n->obj);
+	}
+}
+
+static void Heap_MarkStack (INT32 n, INT32 *cand, ADDRESS cand__len)
+{
+	SYSTEM_PTR frame;
+	INT32 nofcand;
+	INT32 inc, sp, p, stack0;
+	struct Heap__1 align;
+	if (n > 0) {
+		Heap_MarkStack(n - 1, cand, cand__len);
+		if (n > 100) {
+			return;
+		}
+	}
+	if (n == 0) {
+		nofcand = 0;
+		sp = (ADDRESS)&frame;
+		stack0 = Heap_ModulesMainStackFrame();
+		inc = (ADDRESS)&align.p - (ADDRESS)&align;
+		if (Heap_uLT(stack0, sp)) {
+			inc = -inc;
+		}
+		while (sp != stack0) {
+			__GET(sp, p, INT32);
+			if ((Heap_uLE(Heap_heapMin, p) && Heap_uLT(p, Heap_heapMax))) {
+				if (nofcand == cand__len) {
+					Heap_HeapSort(nofcand, (void*)cand, cand__len);
+					Heap_MarkCandidates(nofcand, (void*)cand, cand__len);
+					nofcand = 0;
+				}
+				cand[nofcand] = p;
+				nofcand += 1;
+			}
+			sp += inc;
+		}
+		if (nofcand > 0) {
+			Heap_HeapSort(nofcand, (void*)cand, cand__len);
+			Heap_MarkCandidates(nofcand, (void*)cand, cand__len);
+		}
+	}
+}
+
+void Heap_GC (BOOLEAN markStack)
+{
+	Heap_Module m;
+	INT32 i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23;
+	INT32 cand[10000];
+	Heap_Lock();
+	m = (Heap_Module)(ADDRESS)Heap_modules;
+	while (m != NIL) {
+		if (m->enumPtrs != NIL) {
+			(*m->enumPtrs)(Heap_MarkP);
+		}
+		m = m->next;
+	}
+	if (markStack) {
+		i0 = -100;
+		i1 = -101;
+		i2 = -102;
+		i3 = -103;
+		i4 = -104;
+		i5 = -105;
+		i6 = -106;
+		i7 = -107;
+		i8 = 1;
+		i9 = 2;
+		i10 = 3;
+		i11 = 4;
+		i12 = 5;
+		i13 = 6;
+		i14 = 7;
+		i15 = 8;
+		i16 = 9;
+		i17 = 10;
+		i18 = 11;
+		i19 = 12;
+		i20 = 13;
+		i21 = 14;
+		i22 = 15;
+		i23 = 16;
+		for (;;) {
+			i0 += 1;
+			i1 += 2;
+			i2 += 3;
+			i3 += 4;
+			i4 += 5;
+			i5 += 6;
+			i6 += 7;
+			i7 += 8;
+			i8 += 9;
+			i9 += 10;
+			i10 += 11;
+			i11 += 12;
+			i12 += 13;
+			i13 += 14;
+			i14 += 15;
+			i15 += 16;
+			i16 += 17;
+			i17 += 18;
+			i18 += 19;
+			i19 += 20;
+			i20 += 21;
+			i21 += 22;
+			i22 += 23;
+			i23 += 24;
+			if ((i0 == -99 && i15 == 24)) {
+				Heap_MarkStack(32, (void*)cand, 10000);
+				break;
+			}
+		}
+		if (((((((((((((((((((((((i0 + i1) + i2) + i3) + i4) + i5) + i6) + i7) + i8) + i9) + i10) + i11) + i12) + i13) + i14) + i15) + i16) + i17) + i18) + i19) + i20) + i21) + i22) + i23 > 10000) {
+			return;
+		}
+	}
+	Heap_CheckFin();
+	Heap_Scan();
+	Heap_Finalize();
+	Heap_Unlock();
+}
+
+void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize)
+{
+	Heap_FinNode f;
+	__NEW(f, Heap_FinDesc);
+	f->obj = (INT32)(ADDRESS)obj;
+	f->finalize = finalize;
+	f->marked = 1;
+	f->next = Heap_fin;
+	Heap_fin = f;
+}
+
+void Heap_InitHeap (void)
+{
+	Heap_heap = 0;
+	Heap_heapsize = 0;
+	Heap_allocated = 0;
+	Heap_lockdepth = 0;
+	Heap_heapMin = -1;
+	Heap_heapMax = 0;
+	Heap_bigBlocks = 0;
+	Heap_heapMinExpand = 128000;
+	Heap_ldUnit = 4;
+	Heap_heap = Heap_NewChunk(128000);
+	__PUT(Heap_heap, 0, INT32);
+	Heap_firstTry = 1;
+	Heap_freeList[9] = 1;
+	Heap_FileCount = 0;
+	Heap_modules = NIL;
+	Heap_fin = NIL;
+	Heap_interrupted = 0;
+	Heap_HeapModuleInit();
+}
+
+static void EnumPtrs(void (*P)(void*))
+{
+	P(Heap_modules);
+	P(Heap_fin);
+}
+
+__TDESC(Heap_ModuleDesc, 1, 2) = {__TDFLDS("ModuleDesc", 48), {0, 28, -12}};
+__TDESC(Heap_CmdDesc, 1, 1) = {__TDFLDS("CmdDesc", 32), {0, -8}};
+__TDESC(Heap_FinDesc, 1, 1) = {__TDFLDS("FinDesc", 16), {0, -8}};
+__TDESC(Heap__1, 1, 1) = {__TDFLDS("", 8), {4, -8}};
+
+export void *Heap__init(void)
+{
+	__DEFMOD;
+	__REGMOD("Heap", EnumPtrs);
+	__REGCMD("FINALL", Heap_FINALL);
+	__REGCMD("InitHeap", Heap_InitHeap);
+	__REGCMD("Lock", Heap_Lock);
+	__REGCMD("Unlock", Heap_Unlock);
+	__INITYP(Heap_ModuleDesc, Heap_ModuleDesc, 0);
+	__INITYP(Heap_CmdDesc, Heap_CmdDesc, 0);
+	__INITYP(Heap_FinDesc, Heap_FinDesc, 0);
+	__INITYP(Heap__1, Heap__1, 0);
+/* BEGIN */
+	__ENDMOD;
+}

bootstrap/unix-48/Heap.h

@@ -0,0 +1,73 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. rtsSF */
+
+#ifndef Heap__h
+#define Heap__h
+
+#include "SYSTEM.h"
+
+typedef
+	struct Heap_CmdDesc *Heap_Cmd;
+
+typedef
+	CHAR Heap_CmdName[24];
+
+typedef
+	void (*Heap_Command)(void);
+
+typedef
+	struct Heap_CmdDesc {
+		Heap_Cmd next;
+		Heap_CmdName name;
+		Heap_Command cmd;
+	} Heap_CmdDesc;
+
+typedef
+	void (*Heap_EnumProc)(void(*)(SYSTEM_PTR));
+
+typedef
+	void (*Heap_Finalizer)(SYSTEM_PTR);
+
+typedef
+	struct Heap_ModuleDesc *Heap_Module;
+
+typedef
+	CHAR Heap_ModuleName[20];
+
+typedef
+	struct Heap_ModuleDesc {
+		Heap_Module next;
+		Heap_ModuleName name;
+		INT32 refcnt;
+		Heap_Cmd cmds;
+		INT32 types;
+		Heap_EnumProc enumPtrs;
+		char _prvt0[8];
+	} Heap_ModuleDesc;
+
+
+import SYSTEM_PTR Heap_modules;
+import INT32 Heap_allocated;
+import INT32 Heap_heap;
+import INT32 Heap_heapsize, Heap_heapMinExpand;
+import INT16 Heap_FileCount;
+
+import ADDRESS *Heap_ModuleDesc__typ;
+import ADDRESS *Heap_CmdDesc__typ;
+
+import void Heap_FINALL (void);
+import INT32 Heap_FreeModule (CHAR *name, ADDRESS name__len);
+import void Heap_GC (BOOLEAN markStack);
+import void Heap_INCREF (Heap_Module m);
+import void Heap_InitHeap (void);
+import void Heap_Lock (void);
+import SYSTEM_PTR Heap_NEWBLK (INT32 size);
+import SYSTEM_PTR Heap_NEWREC (INT32 tag);
+import void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd);
+import SYSTEM_PTR Heap_REGMOD (Heap_ModuleName name, Heap_EnumProc enumPtrs);
+import void Heap_REGTYP (Heap_Module m, INT32 typ);
+import void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize);
+import void Heap_Unlock (void);
+import void *Heap__init(void);
+
+
+#endif // Heap

bootstrap/unix-48/Modules.c

@@ -0,0 +1,506 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "Heap.h"
+#include "Platform.h"
+
+
+export INT16 Modules_res;
+export CHAR Modules_resMsg[256];
+export Heap_ModuleName Modules_imported, Modules_importing;
+export INT32 Modules_MainStackFrame;
+export INT16 Modules_ArgCount;
+export INT32 Modules_ArgVector;
+export CHAR Modules_BinaryDir[1024];
+
+
+static void Modules_Append (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len);
+static void Modules_AppendPart (CHAR c, CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len);
+export INT16 Modules_ArgPos (CHAR *s, ADDRESS s__len);
+export void Modules_AssertFail (INT32 code);
+static void Modules_Canonify (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len);
+static INT16 Modules_CharCount (CHAR *s, ADDRESS s__len);
+static void Modules_DisplayHaltCode (INT32 code);
+static void Modules_ExtractPart (CHAR *s, ADDRESS s__len, INT16 *i, CHAR *p, ADDRESS p__len, CHAR *d, ADDRESS d__len);
+static void Modules_FindBinaryDir (CHAR *binarydir, ADDRESS binarydir__len);
+export void Modules_Free (CHAR *name, ADDRESS name__len, BOOLEAN all);
+export void Modules_GetArg (INT16 n, CHAR *val, ADDRESS val__len);
+export void Modules_GetIntArg (INT16 n, INT32 *val);
+export void Modules_Halt (INT32 code);
+export void Modules_Init (INT32 argc, INT32 argvadr);
+static BOOLEAN Modules_IsAbsolute (CHAR *d, ADDRESS d__len);
+static BOOLEAN Modules_IsFilePresent (CHAR *s, ADDRESS s__len);
+static BOOLEAN Modules_IsOneOf (CHAR c, CHAR *s, ADDRESS s__len);
+export Heap_Command Modules_ThisCommand (Heap_Module mod, CHAR *name, ADDRESS name__len);
+export Heap_Module Modules_ThisMod (CHAR *name, ADDRESS name__len);
+static void Modules_Trim (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len);
+static void Modules_errch (CHAR c);
+static void Modules_errint (INT32 l);
+static void Modules_errstring (CHAR *s, ADDRESS s__len);
+
+extern void Heap_InitHeap();
+extern void *Modules__init(void);
+#define Modules_InitHeap()	Heap_InitHeap()
+#define Modules_ModulesInit()	Modules__init()
+#define Modules_modules()	(Heap_Module)Heap_modules
+
+void Modules_Init (INT32 argc, INT32 argvadr)
+{
+	Modules_MainStackFrame = argvadr;
+	Modules_ArgCount = __VAL(INT16, argc);
+	__GET(argvadr, Modules_ArgVector, INT32);
+	Modules_InitHeap();
+	Modules_ModulesInit();
+}
+
+typedef
+	CHAR (*argptr__15)[1024];
+
+void Modules_GetArg (INT16 n, CHAR *val, ADDRESS val__len)
+{
+	argptr__15 arg = NIL;
+	if (n < Modules_ArgCount) {
+		__GET(Modules_ArgVector + __ASHL(n, 2), arg, argptr__15);
+		__COPY(*arg, val, val__len);
+	}
+}
+
+void Modules_GetIntArg (INT16 n, INT32 *val)
+{
+	CHAR s[64];
+	INT32 k, d, i;
+	s[0] = 0x00;
+	Modules_GetArg(n, (void*)s, 64);
+	i = 0;
+	if (s[0] == '-') {
+		i = 1;
+	}
+	k = 0;
+	d = (INT16)s[__X(i, 64)] - 48;
+	while ((d >= 0 && d <= 9)) {
+		k = k * 10 + d;
+		i += 1;
+		d = (INT16)s[__X(i, 64)] - 48;
+	}
+	if (s[0] == '-') {
+		k = -k;
+		i -= 1;
+	}
+	if (i > 0) {
+		*val = k;
+	}
+}
+
+INT16 Modules_ArgPos (CHAR *s, ADDRESS s__len)
+{
+	INT16 i;
+	CHAR arg[256];
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	Modules_GetArg(i, (void*)arg, 256);
+	while ((i < Modules_ArgCount && __STRCMP(s, arg) != 0)) {
+		i += 1;
+		Modules_GetArg(i, (void*)arg, 256);
+	}
+	__DEL(s);
+	return i;
+}
+
+static INT16 Modules_CharCount (CHAR *s, ADDRESS s__len)
+{
+	INT16 i;
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	while ((i < s__len && s[__X(i, s__len)] != 0x00)) {
+		i += 1;
+	}
+	__DEL(s);
+	return i;
+}
+
+static void Modules_Append (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len)
+{
+	INT16 i, j;
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	j = Modules_CharCount(d, d__len);
+	while (s[__X(i, s__len)] != 0x00) {
+		d[__X(j, d__len)] = s[__X(i, s__len)];
+		i += 1;
+		j += 1;
+	}
+	d[__X(j, d__len)] = 0x00;
+	__DEL(s);
+}
+
+static void Modules_AppendPart (CHAR c, CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len)
+{
+	INT16 i, j;
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	j = Modules_CharCount(d, d__len);
+	if ((j > 0 && d[__X(j - 1, d__len)] != c)) {
+		d[__X(j, d__len)] = c;
+		j += 1;
+	}
+	while (s[__X(i, s__len)] != 0x00) {
+		d[__X(j, d__len)] = s[__X(i, s__len)];
+		i += 1;
+		j += 1;
+	}
+	d[__X(j, d__len)] = 0x00;
+	__DEL(s);
+}
+
+static BOOLEAN Modules_IsOneOf (CHAR c, CHAR *s, ADDRESS s__len)
+{
+	INT16 i;
+	__DUP(s, s__len, CHAR);
+	if (c == 0x00) {
+		__DEL(s);
+		return 0;
+	}
+	i = 0;
+	while ((s[__X(i, s__len)] != c && s[__X(i, s__len)] != 0x00)) {
+		i += 1;
+	}
+	__DEL(s);
+	return s[__X(i, s__len)] == c;
+}
+
+static BOOLEAN Modules_IsAbsolute (CHAR *d, ADDRESS d__len)
+{
+	__DUP(d, d__len, CHAR);
+	if (d[0] == 0x00) {
+		__DEL(d);
+		return 0;
+	}
+	if (Modules_IsOneOf(d[0], (CHAR*)"/\\", 3)) {
+		__DEL(d);
+		return 1;
+	}
+	if (d[__X(1, d__len)] == ':') {
+		__DEL(d);
+		return 1;
+	}
+	__DEL(d);
+	return 0;
+}
+
+static void Modules_Canonify (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len)
+{
+	__DUP(s, s__len, CHAR);
+	if (Modules_IsAbsolute(s, s__len)) {
+		__COPY(s, d, d__len);
+	} else {
+		__COPY(Platform_CWD, d, d__len);
+		Modules_AppendPart('/', s, s__len, (void*)d, d__len);
+	}
+	__DEL(s);
+}
+
+static BOOLEAN Modules_IsFilePresent (CHAR *s, ADDRESS s__len)
+{
+	Platform_FileIdentity identity;
+	__DUP(s, s__len, CHAR);
+	__DEL(s);
+	return Platform_IdentifyByName(s, s__len, &identity, Platform_FileIdentity__typ) == 0;
+}
+
+static void Modules_ExtractPart (CHAR *s, ADDRESS s__len, INT16 *i, CHAR *p, ADDRESS p__len, CHAR *d, ADDRESS d__len)
+{
+	INT16 j;
+	__DUP(s, s__len, CHAR);
+	__DUP(p, p__len, CHAR);
+	j = 0;
+	while ((s[__X(*i, s__len)] != 0x00 && !Modules_IsOneOf(s[__X(*i, s__len)], p, p__len))) {
+		d[__X(j, d__len)] = s[__X(*i, s__len)];
+		*i += 1;
+		j += 1;
+	}
+	d[__X(j, d__len)] = 0x00;
+	while (Modules_IsOneOf(s[__X(*i, s__len)], p, p__len)) {
+		*i += 1;
+	}
+	__DEL(s);
+	__DEL(p);
+}
+
+static void Modules_Trim (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len)
+{
+	INT16 i, j;
+	CHAR part[1024];
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	j = 0;
+	while ((i < 2 && Modules_IsOneOf(s[__X(i, s__len)], (CHAR*)"/\\", 3))) {
+		i += 1;
+		d[__X(j, d__len)] = '/';
+		j += 1;
+	}
+	d[__X(j, d__len)] = 0x00;
+	while (s[__X(i, s__len)] != 0x00) {
+		Modules_ExtractPart(s, s__len, &i, (CHAR*)"/\\", 3, (void*)part, 1024);
+		if ((part[0] != 0x00 && __STRCMP(part, ".") != 0)) {
+			Modules_AppendPart('/', part, 1024, (void*)d, d__len);
+		}
+	}
+	__DEL(s);
+}
+
+typedef
+	CHAR pathstring__12[4096];
+
+static void Modules_FindBinaryDir (CHAR *binarydir, ADDRESS binarydir__len)
+{
+	pathstring__12 arg0, pathlist, pathdir, tempstr;
+	INT16 i, j, k;
+	BOOLEAN present;
+	if (Modules_ArgCount < 1) {
+		binarydir[0] = 0x00;
+		return;
+	}
+	Modules_GetArg(0, (void*)arg0, 4096);
+	i = 0;
+	while ((((arg0[__X(i, 4096)] != 0x00 && arg0[__X(i, 4096)] != '/')) && arg0[__X(i, 4096)] != '\\')) {
+		i += 1;
+	}
+	if (arg0[__X(i, 4096)] == '/' || arg0[__X(i, 4096)] == '\\') {
+		Modules_Trim(arg0, 4096, (void*)tempstr, 4096);
+		Modules_Canonify(tempstr, 4096, (void*)binarydir, binarydir__len);
+		present = Modules_IsFilePresent(binarydir, binarydir__len);
+	} else {
+		Platform_GetEnv((CHAR*)"PATH", 5, (void*)pathlist, 4096);
+		i = 0;
+		present = 0;
+		while ((!present && pathlist[__X(i, 4096)] != 0x00)) {
+			Modules_ExtractPart(pathlist, 4096, &i, (CHAR*)":;", 3, (void*)pathdir, 4096);
+			Modules_AppendPart('/', arg0, 4096, (void*)pathdir, 4096);
+			Modules_Trim(pathdir, 4096, (void*)tempstr, 4096);
+			Modules_Canonify(tempstr, 4096, (void*)binarydir, binarydir__len);
+			present = Modules_IsFilePresent(binarydir, binarydir__len);
+		}
+	}
+	if (present) {
+		k = Modules_CharCount(binarydir, binarydir__len);
+		while ((k > 0 && !Modules_IsOneOf(binarydir[__X(k - 1, binarydir__len)], (CHAR*)"/\\", 3))) {
+			k -= 1;
+		}
+		if (k == 0) {
+			binarydir[__X(k, binarydir__len)] = 0x00;
+		} else {
+			binarydir[__X(k - 1, binarydir__len)] = 0x00;
+		}
+	} else {
+		binarydir[0] = 0x00;
+	}
+}
+
+Heap_Module Modules_ThisMod (CHAR *name, ADDRESS name__len)
+{
+	Heap_Module m = NIL;
+	CHAR bodyname[64];
+	Heap_Command body;
+	__DUP(name, name__len, CHAR);
+	m = Modules_modules();
+	while ((m != NIL && __STRCMP(m->name, name) != 0)) {
+		m = m->next;
+	}
+	if (m != NIL) {
+		Modules_res = 0;
+		Modules_resMsg[0] = 0x00;
+	} else {
+		Modules_res = 1;
+		__COPY(name, Modules_importing, 20);
+		__MOVE(" module \"", Modules_resMsg, 10);
+		Modules_Append(name, name__len, (void*)Modules_resMsg, 256);
+		Modules_Append((CHAR*)"\" not found", 12, (void*)Modules_resMsg, 256);
+	}
+	__DEL(name);
+	return m;
+}
+
+Heap_Command Modules_ThisCommand (Heap_Module mod, CHAR *name, ADDRESS name__len)
+{
+	Heap_Cmd c = NIL;
+	__DUP(name, name__len, CHAR);
+	c = mod->cmds;
+	while ((c != NIL && __STRCMP(c->name, name) != 0)) {
+		c = c->next;
+	}
+	if (c != NIL) {
+		Modules_res = 0;
+		Modules_resMsg[0] = 0x00;
+		__DEL(name);
+		return c->cmd;
+	} else {
+		Modules_res = 2;
+		__MOVE(" command \"", Modules_resMsg, 11);
+		__COPY(name, Modules_importing, 20);
+		Modules_Append(mod->name, 20, (void*)Modules_resMsg, 256);
+		Modules_Append((CHAR*)".", 2, (void*)Modules_resMsg, 256);
+		Modules_Append(name, name__len, (void*)Modules_resMsg, 256);
+		Modules_Append((CHAR*)"\" not found", 12, (void*)Modules_resMsg, 256);
+		__DEL(name);
+		return NIL;
+	}
+	__RETCHK;
+}
+
+void Modules_Free (CHAR *name, ADDRESS name__len, BOOLEAN all)
+{
+	Heap_Module m = NIL, p = NIL;
+	INT32 refcount;
+	__DUP(name, name__len, CHAR);
+	m = Modules_modules();
+	if (all) {
+		Modules_res = 1;
+		__MOVE("unloading \"all\" not yet supported", Modules_resMsg, 34);
+	} else {
+		refcount = Heap_FreeModule(name, name__len);
+		if (refcount == 0) {
+			Modules_res = 0;
+		} else {
+			if (refcount < 0) {
+				__MOVE("module not found", Modules_resMsg, 17);
+			} else {
+				__MOVE("clients of this module exist", Modules_resMsg, 29);
+			}
+			Modules_res = 1;
+		}
+	}
+	__DEL(name);
+}
+
+static void Modules_errch (CHAR c)
+{
+	INT16 e;
+	e = Platform_Write(1, (ADDRESS)&c, 1);
+}
+
+static void Modules_errstring (CHAR *s, ADDRESS s__len)
+{
+	INT32 i;
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	while ((i < s__len && s[__X(i, s__len)] != 0x00)) {
+		Modules_errch(s[__X(i, s__len)]);
+		i += 1;
+	}
+	__DEL(s);
+}
+
+static void Modules_errint (INT32 l)
+{
+	if (l < 0) {
+		Modules_errch('-');
+		l = -l;
+	}
+	if (l >= 10) {
+		Modules_errint(__DIV(l, 10));
+	}
+	Modules_errch(__CHR((int)__MOD(l, 10) + 48));
+}
+
+static void Modules_DisplayHaltCode (INT32 code)
+{
+	switch (code) {
+		case -1: 
+			Modules_errstring((CHAR*)"Assertion failure.", 19);
+			break;
+		case -2: 
+			Modules_errstring((CHAR*)"Index out of range.", 20);
+			break;
+		case -3: 
+			Modules_errstring((CHAR*)"Reached end of function without reaching RETURN.", 49);
+			break;
+		case -4: 
+			Modules_errstring((CHAR*)"CASE statement: no matching label and no ELSE.", 47);
+			break;
+		case -5: 
+			Modules_errstring((CHAR*)"Type guard failed.", 19);
+			break;
+		case -6: 
+			Modules_errstring((CHAR*)"Implicit type guard in record assignment failed.", 49);
+			break;
+		case -7: 
+			Modules_errstring((CHAR*)"Invalid case in WITH statement.", 32);
+			break;
+		case -8: 
+			Modules_errstring((CHAR*)"Value out of range.", 20);
+			break;
+		case -9: 
+			Modules_errstring((CHAR*)"Heap interrupted while locked, but lockdepth = 0 at unlock.", 60);
+			break;
+		case -10: 
+			Modules_errstring((CHAR*)"NIL access.", 12);
+			break;
+		case -11: 
+			Modules_errstring((CHAR*)"Alignment error.", 17);
+			break;
+		case -12: 
+			Modules_errstring((CHAR*)"Divide by zero.", 16);
+			break;
+		case -13: 
+			Modules_errstring((CHAR*)"Arithmetic overflow/underflow.", 31);
+			break;
+		case -14: 
+			Modules_errstring((CHAR*)"Invalid function argument.", 27);
+			break;
+		case -15: 
+			Modules_errstring((CHAR*)"Internal error, e.g. Type descriptor size mismatch.", 52);
+			break;
+		case -20: 
+			Modules_errstring((CHAR*)"Too many, or negative number of, elements in dynamic array.", 60);
+			break;
+		default: 
+			break;
+	}
+}
+
+void Modules_Halt (INT32 code)
+{
+	Heap_FINALL();
+	Modules_errstring((CHAR*)"Terminated by Halt(", 20);
+	Modules_errint(code);
+	Modules_errstring((CHAR*)"). ", 4);
+	if (code < 0) {
+		Modules_DisplayHaltCode(code);
+	}
+	Modules_errstring(Platform_NL, 3);
+	Platform_Exit(code);
+}
+
+void Modules_AssertFail (INT32 code)
+{
+	Heap_FINALL();
+	Modules_errstring((CHAR*)"Assertion failure.", 19);
+	if (code != 0) {
+		Modules_errstring((CHAR*)" ASSERT code ", 14);
+		Modules_errint(code);
+		Modules_errstring((CHAR*)".", 2);
+	}
+	Modules_errstring(Platform_NL, 3);
+	if (code > 0) {
+		Platform_Exit(code);
+	} else {
+		Platform_Exit(-1);
+	}
+}
+
+
+export void *Modules__init(void)
+{
+	__DEFMOD;
+	__MODULE_IMPORT(Heap);
+	__MODULE_IMPORT(Platform);
+	__REGMOD("Modules", 0);
+/* BEGIN */
+	Modules_FindBinaryDir((void*)Modules_BinaryDir, 1024);
+	__ENDMOD;
+}

bootstrap/unix-48/Modules.h

@@ -0,0 +1,31 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Modules__h
+#define Modules__h
+
+#include "SYSTEM.h"
+#include "Heap.h"
+
+
+import INT16 Modules_res;
+import CHAR Modules_resMsg[256];
+import Heap_ModuleName Modules_imported, Modules_importing;
+import INT32 Modules_MainStackFrame;
+import INT16 Modules_ArgCount;
+import INT32 Modules_ArgVector;
+import CHAR Modules_BinaryDir[1024];
+
+
+import INT16 Modules_ArgPos (CHAR *s, ADDRESS s__len);
+import void Modules_AssertFail (INT32 code);
+import void Modules_Free (CHAR *name, ADDRESS name__len, BOOLEAN all);
+import void Modules_GetArg (INT16 n, CHAR *val, ADDRESS val__len);
+import void Modules_GetIntArg (INT16 n, INT32 *val);
+import void Modules_Halt (INT32 code);
+import void Modules_Init (INT32 argc, INT32 argvadr);
+import Heap_Command Modules_ThisCommand (Heap_Module mod, CHAR *name, ADDRESS name__len);
+import Heap_Module Modules_ThisMod (CHAR *name, ADDRESS name__len);
+import void *Modules__init(void);
+
+
+#endif // Modules

bootstrap/unix-48/OPB.h

@@ -0,0 +1,48 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPB__h
+#define OPB__h
+
+#include "SYSTEM.h"
+#include "OPS.h"
+#include "OPT.h"
+
+
+
+
+import void OPB_Assign (OPT_Node *x, OPT_Node y);
+import void OPB_Call (OPT_Node *x, OPT_Node apar, OPT_Object fp);
+import void OPB_CheckParameters (OPT_Object fp, OPT_Object ap, BOOLEAN checkNames);
+import void OPB_Construct (INT8 class, OPT_Node *x, OPT_Node y);
+import void OPB_DeRef (OPT_Node *x);
+import OPT_Node OPB_EmptySet (void);
+import void OPB_Enter (OPT_Node *procdec, OPT_Node stat, OPT_Object proc);
+import void OPB_Field (OPT_Node *x, OPT_Object y);
+import void OPB_In (OPT_Node *x, OPT_Node y);
+import void OPB_Index (OPT_Node *x, OPT_Node y);
+import void OPB_Inittd (OPT_Node *inittd, OPT_Node *last, OPT_Struct typ);
+import void OPB_Link (OPT_Node *x, OPT_Node *last, OPT_Node y);
+import void OPB_MOp (INT8 op, OPT_Node *x);
+import OPT_Node OPB_NewBoolConst (BOOLEAN boolval);
+import OPT_Node OPB_NewIntConst (INT64 intval);
+import OPT_Node OPB_NewLeaf (OPT_Object obj);
+import OPT_Node OPB_NewRealConst (LONGREAL realval, OPT_Struct typ);
+import OPT_Node OPB_NewString (OPS_String str, INT64 len);
+import OPT_Node OPB_Nil (void);
+import void OPB_Op (INT8 op, OPT_Node *x, OPT_Node y);
+import void OPB_OptIf (OPT_Node *x);
+import void OPB_Param (OPT_Node ap, OPT_Object fp);
+import void OPB_PrepCall (OPT_Node *x, OPT_Object *fpar);
+import void OPB_Return (OPT_Node *x, OPT_Object proc);
+import void OPB_SetElem (OPT_Node *x);
+import void OPB_SetRange (OPT_Node *x, OPT_Node y);
+import void OPB_StFct (OPT_Node *par0, INT8 fctno, INT16 parno);
+import void OPB_StPar0 (OPT_Node *par0, INT16 fctno);
+import void OPB_StPar1 (OPT_Node *par0, OPT_Node x, INT8 fctno);
+import void OPB_StParN (OPT_Node *par0, OPT_Node x, INT16 fctno, INT16 n);
+import void OPB_StaticLink (INT8 dlev);
+import void OPB_TypTest (OPT_Node *x, OPT_Object obj, BOOLEAN guard);
+import void *OPB__init(void);
+
+
+#endif // OPB

bootstrap/unix-48/OPC.h

@@ -0,0 +1,49 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPC__h
+#define OPC__h
+
+#include "SYSTEM.h"
+#include "OPT.h"
+
+
+
+
+import void OPC_Andent (OPT_Struct typ);
+import OPT_Object OPC_BaseTProc (OPT_Object obj);
+import void OPC_BegBlk (void);
+import void OPC_BegStat (void);
+import void OPC_Case (INT64 caseVal, INT16 form);
+import void OPC_Cmp (INT16 rel);
+import void OPC_CompleteIdent (OPT_Object obj);
+import void OPC_Constant (OPT_Const con, INT16 form);
+import void OPC_DefineInter (OPT_Object proc);
+import void OPC_EndBlk (void);
+import void OPC_EndBlk0 (void);
+import void OPC_EndStat (void);
+import void OPC_EnterBody (void);
+import void OPC_EnterProc (OPT_Object proc);
+import void OPC_ExitBody (void);
+import void OPC_ExitProc (OPT_Object proc, BOOLEAN eoBlock, BOOLEAN implicitRet);
+import void OPC_GenBdy (OPT_Node n);
+import void OPC_GenEnumPtrs (OPT_Object var);
+import void OPC_GenHdr (OPT_Node n);
+import void OPC_GenHdrIncludes (void);
+import void OPC_Halt (INT32 n);
+import void OPC_Ident (OPT_Object obj);
+import void OPC_Increment (BOOLEAN decrement);
+import void OPC_Indent (INT16 count);
+import void OPC_Init (void);
+import void OPC_InitTDesc (OPT_Struct typ);
+import void OPC_IntLiteral (INT64 n, INT32 size);
+import void OPC_Len (OPT_Object obj, OPT_Struct array, INT64 dim);
+import BOOLEAN OPC_NeedsRetval (OPT_Object proc);
+import INT32 OPC_NofPtrs (OPT_Struct typ);
+import void OPC_SetInclude (BOOLEAN exclude);
+import void OPC_TDescDecl (OPT_Struct typ);
+import void OPC_TypeDefs (OPT_Object obj, INT16 vis);
+import void OPC_TypeOf (OPT_Object ap);
+import void *OPC__init(void);
+
+
+#endif // OPC

bootstrap/unix-48/OPM.h

@@ -0,0 +1,76 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPM__h
+#define OPM__h
+
+#include "SYSTEM.h"
+
+
+import CHAR OPM_Model[10];
+import INT16 OPM_AddressSize, OPM_Alignment;
+import UINT32 OPM_GlobalOptions, OPM_Options;
+import INT16 OPM_ShortintSize, OPM_IntegerSize, OPM_LongintSize, OPM_SetSize;
+import INT64 OPM_MaxIndex;
+import LONGREAL OPM_MinReal, OPM_MaxReal, OPM_MinLReal, OPM_MaxLReal;
+import BOOLEAN OPM_noerr;
+import INT32 OPM_curpos, OPM_errpos, OPM_breakpc;
+import INT16 OPM_currFile, OPM_level, OPM_pc, OPM_entno;
+import CHAR OPM_modName[32];
+import CHAR OPM_objname[64];
+import CHAR OPM_InstallDir[1024];
+import CHAR OPM_ResourceDir[1024];
+
+
+import void OPM_CloseFiles (void);
+import void OPM_CloseOldSym (void);
+import void OPM_DeleteObj (CHAR *modulename, ADDRESS modulename__len);
+import void OPM_DeleteSym (CHAR *modulename, ADDRESS modulename__len);
+import void OPM_FPrint (INT32 *fp, INT64 val);
+import void OPM_FPrintLReal (INT32 *fp, LONGREAL val);
+import void OPM_FPrintReal (INT32 *fp, REAL val);
+import void OPM_FPrintSet (INT32 *fp, UINT64 val);
+import void OPM_Get (CHAR *ch);
+import void OPM_GetComment (CHAR *text, ADDRESS text__len);
+import void OPM_Init (BOOLEAN *done);
+import void OPM_InitOptions (void);
+import INT16 OPM_Integer (INT64 n);
+import void OPM_LogCompiling (CHAR *modname, ADDRESS modname__len);
+import void OPM_LogVT100 (CHAR *vt100code, ADDRESS vt100code__len);
+import void OPM_LogW (CHAR ch);
+import void OPM_LogWLn (void);
+import void OPM_LogWNum (INT64 i, INT64 len);
+import void OPM_LogWStr (CHAR *s, ADDRESS s__len);
+import INT32 OPM_Longint (INT64 n);
+import void OPM_Mark (INT16 n, INT32 pos);
+import void OPM_NewSym (CHAR *modName, ADDRESS modName__len);
+import void OPM_OldSym (CHAR *modName, ADDRESS modName__len, BOOLEAN *done);
+import void OPM_OpenFiles (CHAR *moduleName, ADDRESS moduleName__len);
+import BOOLEAN OPM_OpenPar (void);
+import void OPM_RegisterNewSym (void);
+import INT64 OPM_SignedMaximum (INT32 bytecount);
+import INT64 OPM_SignedMinimum (INT32 bytecount);
+import void OPM_StoreComment (CHAR *text, ADDRESS text__len);
+import void OPM_SymRCh (CHAR *ch);
+import INT32 OPM_SymRInt (void);
+import INT64 OPM_SymRInt64 (void);
+import void OPM_SymRLReal (LONGREAL *lr);
+import void OPM_SymRReal (REAL *r);
+import void OPM_SymRSet (UINT64 *s);
+import void OPM_SymWCh (CHAR ch);
+import void OPM_SymWInt (INT64 i);
+import void OPM_SymWLReal (LONGREAL lr);
+import void OPM_SymWReal (REAL r);
+import void OPM_SymWSet (UINT64 s);
+import void OPM_Write (CHAR ch);
+import void OPM_WriteHex (INT64 i);
+import void OPM_WriteInt (INT64 i);
+import void OPM_WriteLn (void);
+import void OPM_WriteReal (LONGREAL r, CHAR suffx);
+import void OPM_WriteString (CHAR *s, ADDRESS s__len);
+import void OPM_WriteStringVar (CHAR *s, ADDRESS s__len);
+import BOOLEAN OPM_eofSF (void);
+import void OPM_err (INT16 n);
+import void *OPM__init(void);
+
+
+#endif // OPM

bootstrap/unix-48/OPP.h

@@ -0,0 +1,16 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPP__h
+#define OPP__h
+
+#include "SYSTEM.h"
+#include "OPT.h"
+
+
+
+
+import void OPP_Module (OPT_Node *prog, UINT32 opt);
+import void *OPP__init(void);
+
+
+#endif // OPP

bootstrap/unix-48/OPS.c

@@ -0,0 +1,666 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "OPM.h"
+
+typedef
+	CHAR OPS_Name[256];
+
+typedef
+	CHAR OPS_String[256];
+
+
+export OPS_Name OPS_name;
+export OPS_String OPS_str;
+export INT16 OPS_numtyp;
+export INT64 OPS_intval;
+export REAL OPS_realval;
+export LONGREAL OPS_lrlval;
+static CHAR OPS_ch;
+
+
+export void OPS_Get (INT8 *sym);
+static void OPS_Identifier (INT8 *sym);
+export void OPS_Init (void);
+static void OPS_Number (void);
+static void OPS_Str (INT8 *sym);
+static void OPS_err (INT16 n);
+
+
+static void OPS_err (INT16 n)
+{
+	OPM_err(n);
+}
+
+static void OPS_Str (INT8 *sym)
+{
+	INT16 i;
+	CHAR och;
+	i = 0;
+	och = OPS_ch;
+	for (;;) {
+		OPM_Get(&OPS_ch);
+		if (OPS_ch == och) {
+			break;
+		}
+		if (OPS_ch < ' ') {
+			OPS_err(3);
+			break;
+		}
+		if (i == 255) {
+			OPS_err(241);
+			break;
+		}
+		OPS_str[__X(i, 256)] = OPS_ch;
+		i += 1;
+	}
+	OPM_Get(&OPS_ch);
+	OPS_str[__X(i, 256)] = 0x00;
+	OPS_intval = i + 1;
+	if (OPS_intval == 2) {
+		*sym = 35;
+		OPS_numtyp = 1;
+		OPS_intval = (INT16)OPS_str[0];
+	} else {
+		*sym = 37;
+	}
+}
+
+static void OPS_Identifier (INT8 *sym)
+{
+	INT16 i;
+	i = 0;
+	do {
+		OPS_name[__X(i, 256)] = OPS_ch;
+		i += 1;
+		OPM_Get(&OPS_ch);
+	} while (!(((OPS_ch < '0' || ('9' < OPS_ch && __CAP(OPS_ch) < 'A')) || 'Z' < __CAP(OPS_ch)) || i == 256));
+	if (i == 256) {
+		OPS_err(240);
+		i -= 1;
+	}
+	OPS_name[__X(i, 256)] = 0x00;
+	*sym = 38;
+}
+
+static struct Number__6 {
+	struct Number__6 *lnk;
+} *Number__6_s;
+
+static INT16 Ord__7 (CHAR ch, BOOLEAN hex);
+static LONGREAL Ten__9 (INT16 e);
+
+static LONGREAL Ten__9 (INT16 e)
+{
+	LONGREAL x, p;
+	x = (LONGREAL)1;
+	p = (LONGREAL)10;
+	while (e > 0) {
+		if (__ODD(e)) {
+			x = x * p;
+		}
+		e = __ASHR(e, 1);
+		if (e > 0) {
+			p = p * p;
+		}
+	}
+	return x;
+}
+
+static INT16 Ord__7 (CHAR ch, BOOLEAN hex)
+{
+	if (ch <= '9') {
+		return (INT16)ch - 48;
+	} else if (hex) {
+		return ((INT16)ch - 65) + 10;
+	} else {
+		OPS_err(2);
+		return 0;
+	}
+	__RETCHK;
+}
+
+static void OPS_Number (void)
+{
+	INT16 i, m, n, d, e;
+	CHAR dig[24];
+	LONGREAL f;
+	CHAR expCh;
+	BOOLEAN neg;
+	struct Number__6 _s;
+	_s.lnk = Number__6_s;
+	Number__6_s = &_s;
+	i = 0;
+	m = 0;
+	n = 0;
+	d = 0;
+	for (;;) {
+		if (('0' <= OPS_ch && OPS_ch <= '9') || (((d == 0 && 'A' <= OPS_ch)) && OPS_ch <= 'F')) {
+			if (m > 0 || OPS_ch != '0') {
+				if (n < 24) {
+					dig[__X(n, 24)] = OPS_ch;
+					n += 1;
+				}
+				m += 1;
+			}
+			OPM_Get(&OPS_ch);
+			i += 1;
+		} else if (OPS_ch == '.') {
+			OPM_Get(&OPS_ch);
+			if (OPS_ch == '.') {
+				OPS_ch = 0x7f;
+				break;
+			} else if (d == 0) {
+				d = i;
+			} else {
+				OPS_err(2);
+			}
+		} else {
+			break;
+		}
+	}
+	if (d == 0) {
+		if (n == m) {
+			OPS_intval = 0;
+			i = 0;
+			if (OPS_ch == 'X') {
+				OPM_Get(&OPS_ch);
+				OPS_numtyp = 1;
+				if (n <= 2) {
+					while (i < n) {
+						OPS_intval = __ASHL(OPS_intval, 4) + (INT64)Ord__7(dig[__X(i, 24)], 1);
+						i += 1;
+					}
+				} else {
+					OPS_err(203);
+				}
+			} else if (OPS_ch == 'H') {
+				OPM_Get(&OPS_ch);
+				OPS_numtyp = 2;
+				if (n <= 16) {
+					if ((n == 16 && dig[0] > '7')) {
+						OPS_intval = -1;
+					}
+					while (i < n) {
+						OPS_intval = __ASHL(OPS_intval, 4) + (INT64)Ord__7(dig[__X(i, 24)], 1);
+						i += 1;
+					}
+				} else {
+					OPS_err(203);
+				}
+			} else {
+				OPS_numtyp = 2;
+				while (i < n) {
+					d = Ord__7(dig[__X(i, 24)], 0);
+					i += 1;
+					if (OPS_intval <= __DIV(9223372036854775807LL - (INT64)d, 10)) {
+						OPS_intval = OPS_intval * 10 + (INT64)d;
+					} else {
+						OPS_err(203);
+					}
+				}
+			}
+		} else {
+			OPS_err(203);
+		}
+	} else {
+		f = (LONGREAL)0;
+		e = 0;
+		expCh = 'E';
+		while (n > 0) {
+			n -= 1;
+			f = (Ord__7(dig[__X(n, 24)], 0) + f) / (LONGREAL)(LONGREAL)10;
+		}
+		if (OPS_ch == 'E' || OPS_ch == 'D') {
+			expCh = OPS_ch;
+			OPM_Get(&OPS_ch);
+			neg = 0;
+			if (OPS_ch == '-') {
+				neg = 1;
+				OPM_Get(&OPS_ch);
+			} else if (OPS_ch == '+') {
+				OPM_Get(&OPS_ch);
+			}
+			if (('0' <= OPS_ch && OPS_ch <= '9')) {
+				do {
+					n = Ord__7(OPS_ch, 0);
+					OPM_Get(&OPS_ch);
+					if (e <= __DIV(32767 - n, 10)) {
+						e = e * 10 + n;
+					} else {
+						OPS_err(203);
+					}
+				} while (!(OPS_ch < '0' || '9' < OPS_ch));
+				if (neg) {
+					e = -e;
+				}
+			} else {
+				OPS_err(2);
+			}
+		}
+		e -= (i - d) - m;
+		if (expCh == 'E') {
+			OPS_numtyp = 3;
+			if ((-37 < e && e <= 38)) {
+				if (e < 0) {
+					OPS_realval = (f / (LONGREAL)Ten__9(-e));
+				} else {
+					OPS_realval = (f * Ten__9(e));
+				}
+			} else {
+				OPS_err(203);
+			}
+		} else {
+			OPS_numtyp = 4;
+			if ((-307 < e && e <= 308)) {
+				if (e < 0) {
+					OPS_lrlval = f / (LONGREAL)Ten__9(-e);
+				} else {
+					OPS_lrlval = f * Ten__9(e);
+				}
+			} else {
+				OPS_err(203);
+			}
+		}
+	}
+	Number__6_s = _s.lnk;
+}
+
+static struct Get__1 {
+	struct Get__1 *lnk;
+} *Get__1_s;
+
+static void Comment__2 (void);
+
+static void Comment__2 (void)
+{
+	BOOLEAN isExported;
+	CHAR commentText[256];
+	INT16 i, nestLevel;
+	CHAR prevCh, nextCh;
+	i = 0;
+	while (i <= 255) {
+		commentText[__X(i, 256)] = 0x00;
+		i += 1;
+	}
+	isExported = 0;
+	i = 0;
+	nestLevel = 1;
+	prevCh = 0x00;
+	OPM_Get(&OPS_ch);
+	if (OPS_ch == '*') {
+		isExported = 1;
+		OPM_Get(&OPS_ch);
+		if (OPS_ch == ')') {
+			commentText[0] = 0x00;
+			OPM_StoreComment(commentText, 256);
+			OPM_Get(&OPS_ch);
+			return;
+		}
+	}
+	while ((nestLevel > 0 && OPS_ch != 0x00)) {
+		if ((prevCh == '(' && OPS_ch == '*')) {
+			nestLevel += 1;
+			prevCh = 0x00;
+		} else if ((prevCh == '*' && OPS_ch == ')')) {
+			nestLevel -= 1;
+			if (nestLevel == 0) {
+				OPM_Get(&OPS_ch);
+			} else {
+				prevCh = 0x00;
+			}
+		} else {
+			if ((((isExported && nestLevel == 1)) && prevCh != 0x00)) {
+				if (i < 255) {
+					commentText[__X(i, 256)] = prevCh;
+					i += 1;
+				}
+			}
+			prevCh = OPS_ch;
+		}
+		if (nestLevel > 0) {
+			OPM_Get(&OPS_ch);
+		}
+	}
+	if (OPS_ch == 0x00) {
+		OPS_err(5);
+	}
+	if ((((((isExported && nestLevel == 0)) && prevCh != 0x00)) && prevCh != '*')) {
+		if (i < 255) {
+			commentText[__X(i, 256)] = prevCh;
+			i += 1;
+		} else {
+			OPM_LogWStr((CHAR*)"Truncating final comment character", 35);
+			OPM_LogWLn();
+		}
+	}
+	if (isExported) {
+		if (i >= 256) {
+			OPM_LogWStr((CHAR*)"Warning: commentText overflow", 30);
+			OPM_LogWLn();
+			i = 255;
+		}
+		commentText[__X(i, 256)] = 0x00;
+		OPM_StoreComment(commentText, 256);
+	}
+}
+
+void OPS_Get (INT8 *sym)
+{
+	INT8 s;
+	struct Get__1 _s;
+	_s.lnk = Get__1_s;
+	Get__1_s = &_s;
+	OPM_errpos = OPM_curpos - 1;
+	while (OPS_ch <= ' ') {
+		if (OPS_ch == 0x00) {
+			*sym = 64;
+			Get__1_s = _s.lnk;
+			return;
+		} else {
+			OPM_Get(&OPS_ch);
+		}
+	}
+	switch (OPS_ch) {
+		case '"': case '\'': 
+			OPS_Str(&s);
+			break;
+		case '#': 
+			s = 10;
+			OPM_Get(&OPS_ch);
+			break;
+		case '&': 
+			s = 5;
+			OPM_Get(&OPS_ch);
+			break;
+		case '(': 
+			OPM_Get(&OPS_ch);
+			if (OPS_ch == '*') {
+				Comment__2();
+				OPS_Get(&s);
+			} else {
+				s = 30;
+			}
+			break;
+		case ')': 
+			s = 22;
+			OPM_Get(&OPS_ch);
+			break;
+		case '*': 
+			s = 1;
+			OPM_Get(&OPS_ch);
+			break;
+		case '+': 
+			s = 6;
+			OPM_Get(&OPS_ch);
+			break;
+		case ',': 
+			s = 19;
+			OPM_Get(&OPS_ch);
+			break;
+		case '-': 
+			s = 7;
+			OPM_Get(&OPS_ch);
+			break;
+		case '.': 
+			OPM_Get(&OPS_ch);
+			if (OPS_ch == '.') {
+				OPM_Get(&OPS_ch);
+				s = 21;
+			} else {
+				s = 18;
+			}
+			break;
+		case '/': 
+			s = 2;
+			OPM_Get(&OPS_ch);
+			break;
+		case '0': case '1': case '2': case '3': case '4': 
+		case '5': case '6': case '7': case '8': case '9': 
+			OPS_Number();
+			s = 35;
+			break;
+		case ':': 
+			OPM_Get(&OPS_ch);
+			if (OPS_ch == '=') {
+				OPM_Get(&OPS_ch);
+				s = 34;
+			} else {
+				s = 20;
+			}
+			break;
+		case ';': 
+			s = 39;
+			OPM_Get(&OPS_ch);
+			break;
+		case '<': 
+			OPM_Get(&OPS_ch);
+			if (OPS_ch == '=') {
+				OPM_Get(&OPS_ch);
+				s = 12;
+			} else {
+				s = 11;
+			}
+			break;
+		case '=': 
+			s = 9;
+			OPM_Get(&OPS_ch);
+			break;
+		case '>': 
+			OPM_Get(&OPS_ch);
+			if (OPS_ch == '=') {
+				OPM_Get(&OPS_ch);
+				s = 14;
+			} else {
+				s = 13;
+			}
+			break;
+		case 'A': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "ARRAY") == 0) {
+				s = 54;
+			}
+			break;
+		case 'B': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "BEGIN") == 0) {
+				s = 57;
+			} else if (__STRCMP(OPS_name, "BY") == 0) {
+				s = 29;
+			}
+			break;
+		case 'C': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "CASE") == 0) {
+				s = 46;
+			} else if (__STRCMP(OPS_name, "CONST") == 0) {
+				s = 58;
+			}
+			break;
+		case 'D': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "DO") == 0) {
+				s = 27;
+			} else if (__STRCMP(OPS_name, "DIV") == 0) {
+				s = 3;
+			}
+			break;
+		case 'E': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "END") == 0) {
+				s = 41;
+			} else if (__STRCMP(OPS_name, "ELSE") == 0) {
+				s = 42;
+			} else if (__STRCMP(OPS_name, "ELSIF") == 0) {
+				s = 43;
+			} else if (__STRCMP(OPS_name, "EXIT") == 0) {
+				s = 52;
+			}
+			break;
+		case 'F': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "FOR") == 0) {
+				s = 49;
+			}
+			break;
+		case 'I': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "IF") == 0) {
+				s = 45;
+			} else if (__STRCMP(OPS_name, "IN") == 0) {
+				s = 15;
+			} else if (__STRCMP(OPS_name, "IS") == 0) {
+				s = 16;
+			} else if (__STRCMP(OPS_name, "IMPORT") == 0) {
+				s = 62;
+			}
+			break;
+		case 'L': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "LOOP") == 0) {
+				s = 50;
+			}
+			break;
+		case 'M': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "MOD") == 0) {
+				s = 4;
+			} else if (__STRCMP(OPS_name, "MODULE") == 0) {
+				s = 63;
+			}
+			break;
+		case 'N': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "NIL") == 0) {
+				s = 36;
+			}
+			break;
+		case 'O': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "OR") == 0) {
+				s = 8;
+			} else if (__STRCMP(OPS_name, "OF") == 0) {
+				s = 25;
+			}
+			break;
+		case 'P': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "PROCEDURE") == 0) {
+				s = 61;
+			} else if (__STRCMP(OPS_name, "POINTER") == 0) {
+				s = 56;
+			}
+			break;
+		case 'R': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "RECORD") == 0) {
+				s = 55;
+			} else if (__STRCMP(OPS_name, "REPEAT") == 0) {
+				s = 48;
+			} else if (__STRCMP(OPS_name, "RETURN") == 0) {
+				s = 53;
+			}
+			break;
+		case 'T': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "THEN") == 0) {
+				s = 26;
+			} else if (__STRCMP(OPS_name, "TO") == 0) {
+				s = 28;
+			} else if (__STRCMP(OPS_name, "TYPE") == 0) {
+				s = 59;
+			}
+			break;
+		case 'U': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "UNTIL") == 0) {
+				s = 44;
+			}
+			break;
+		case 'V': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "VAR") == 0) {
+				s = 60;
+			}
+			break;
+		case 'W': 
+			OPS_Identifier(&s);
+			if (__STRCMP(OPS_name, "WHILE") == 0) {
+				s = 47;
+			} else if (__STRCMP(OPS_name, "WITH") == 0) {
+				s = 51;
+			}
+			break;
+		case 'G': case 'H': case 'J': case 'K': case 'Q': 
+		case 'S': case 'X': case 'Y': case 'Z': 
+			OPS_Identifier(&s);
+			break;
+		case '[': 
+			s = 31;
+			OPM_Get(&OPS_ch);
+			break;
+		case ']': 
+			s = 23;
+			OPM_Get(&OPS_ch);
+			break;
+		case '^': 
+			s = 17;
+			OPM_Get(&OPS_ch);
+			break;
+		case 'a': case 'b': case 'c': case 'd': case 'e': 
+		case 'f': case 'g': case 'h': case 'i': case 'j': 
+		case 'k': case 'l': case 'm': case 'n': case 'o': 
+		case 'p': case 'q': case 'r': case 's': case 't': 
+		case 'u': case 'v': case 'w': case 'x': case 'y': 
+		case 'z': 
+			OPS_Identifier(&s);
+			break;
+		case '{': 
+			s = 32;
+			OPM_Get(&OPS_ch);
+			break;
+		case '|': 
+			s = 40;
+			OPM_Get(&OPS_ch);
+			break;
+		case '}': 
+			s = 24;
+			OPM_Get(&OPS_ch);
+			break;
+		case '~': 
+			s = 33;
+			OPM_Get(&OPS_ch);
+			break;
+		case 0x7f: 
+			s = 21;
+			OPM_Get(&OPS_ch);
+			break;
+		default: 
+			s = 0;
+			OPM_Get(&OPS_ch);
+			break;
+	}
+	*sym = s;
+	Get__1_s = _s.lnk;
+}
+
+void OPS_Init (void)
+{
+	OPS_ch = ' ';
+}
+
+
+export void *OPS__init(void)
+{
+	__DEFMOD;
+	__MODULE_IMPORT(OPM);
+	__REGMOD("OPS", 0);
+	__REGCMD("Init", OPS_Init);
+/* BEGIN */
+	__ENDMOD;
+}

bootstrap/unix-48/OPS.h

@@ -0,0 +1,28 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPS__h
+#define OPS__h
+
+#include "SYSTEM.h"
+
+typedef
+	CHAR OPS_Name[256];
+
+typedef
+	CHAR OPS_String[256];
+
+
+import OPS_Name OPS_name;
+import OPS_String OPS_str;
+import INT16 OPS_numtyp;
+import INT64 OPS_intval;
+import REAL OPS_realval;
+import LONGREAL OPS_lrlval;
+
+
+import void OPS_Get (INT8 *sym);
+import void OPS_Init (void);
+import void *OPS__init(void);
+
+
+#endif // OPS

bootstrap/unix-48/OPT.h

@@ -0,0 +1,128 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPT__h
+#define OPT__h
+
+#include "SYSTEM.h"
+#include "OPS.h"
+
+typedef
+	struct OPT_ConstDesc *OPT_Const;
+
+typedef
+	OPS_String *OPT_ConstExt;
+
+typedef
+	struct OPT_ConstDesc {
+		OPT_ConstExt ext;
+		INT64 intval;
+		INT32 intval2;
+		UINT64 setval;
+		LONGREAL realval;
+	} OPT_ConstDesc;
+
+typedef
+	struct OPT_LinkDesc *OPT_Link;
+
+typedef
+	struct OPT_LinkDesc {
+		OPS_Name name;
+		OPT_Link next;
+	} OPT_LinkDesc;
+
+typedef
+	struct OPT_NodeDesc *OPT_Node;
+
+typedef
+	struct OPT_StrDesc *OPT_Struct;
+
+typedef
+	struct OPT_ObjDesc *OPT_Object;
+
+typedef
+	struct OPT_NodeDesc {
+		OPT_Node left, right, link;
+		INT8 class, subcl;
+		BOOLEAN readonly;
+		OPT_Struct typ;
+		OPT_Object obj;
+		OPT_Const conval;
+	} OPT_NodeDesc;
+
+typedef
+	struct OPT_ObjDesc {
+		OPT_Object left, right, link, scope;
+		OPS_Name name;
+		BOOLEAN leaf;
+		INT8 mode, mnolev, vis, history;
+		BOOLEAN used, fpdone;
+		INT32 fprint;
+		OPT_Struct typ;
+		OPT_Const conval;
+		INT32 adr, linkadr;
+		INT16 x;
+		OPT_ConstExt comment;
+	} OPT_ObjDesc;
+
+typedef
+	struct OPT_StrDesc {
+		INT8 form, comp, mno, extlev;
+		INT16 ref, sysflag;
+		INT32 n, size, align, txtpos;
+		BOOLEAN allocated, pbused, pvused;
+		char _prvt0[4];
+		INT32 idfp;
+		char _prvt1[8];
+		OPT_Struct BaseTyp;
+		OPT_Object link, strobj;
+	} OPT_StrDesc;
+
+
+import OPT_Object OPT_topScope;
+import OPT_Struct OPT_undftyp, OPT_niltyp, OPT_notyp, OPT_bytetyp, OPT_cpbytetyp, OPT_booltyp, OPT_chartyp, OPT_sinttyp, OPT_inttyp, OPT_linttyp, OPT_hinttyp, OPT_int8typ, OPT_int16typ, OPT_int32typ, OPT_int64typ, OPT_settyp, OPT_set32typ, OPT_set64typ, OPT_realtyp, OPT_lrltyp, OPT_stringtyp, OPT_adrtyp, OPT_sysptrtyp;
+import OPT_Object OPT_sintobj, OPT_intobj, OPT_lintobj, OPT_setobj;
+import INT8 OPT_nofGmod;
+import OPT_Object OPT_GlbMod[64];
+import OPS_Name OPT_SelfName;
+import BOOLEAN OPT_SYSimported;
+import OPT_Link OPT_Links;
+
+import ADDRESS *OPT_ConstDesc__typ;
+import ADDRESS *OPT_ObjDesc__typ;
+import ADDRESS *OPT_StrDesc__typ;
+import ADDRESS *OPT_NodeDesc__typ;
+import ADDRESS *OPT_LinkDesc__typ;
+
+import void OPT_Align (INT32 *adr, INT32 base);
+import INT32 OPT_BaseAlignment (OPT_Struct typ);
+import void OPT_Close (void);
+import void OPT_CloseScope (void);
+import void OPT_Export (BOOLEAN *ext, BOOLEAN *new);
+import void OPT_FPrintErr (OPT_Object obj, INT16 errcode);
+import void OPT_FPrintObj (OPT_Object obj);
+import void OPT_FPrintStr (OPT_Struct typ);
+import void OPT_Find (OPT_Object *res);
+import void OPT_FindField (OPS_Name name, OPT_Struct typ, OPT_Object *res);
+import void OPT_FindImport (OPT_Object mod, OPT_Object *res);
+import void OPT_IdFPrint (OPT_Struct typ);
+import void OPT_Import (OPS_Name aliasName, OPS_Name name, BOOLEAN *done);
+import void OPT_Init (OPS_Name name, UINT32 opt);
+import void OPT_InitRecno (void);
+import void OPT_Insert (OPS_Name name, OPT_Object *obj);
+import void OPT_InsertImport (OPT_Object obj, OPT_Object *root, OPT_Object *old);
+import INT16 OPT_IntSize (INT64 n);
+import OPT_Struct OPT_IntType (INT32 size);
+import OPT_Const OPT_NewConst (void);
+import OPT_ConstExt OPT_NewExt (void);
+import OPT_Node OPT_NewNode (INT8 class);
+import OPT_Object OPT_NewObj (void);
+import OPT_Struct OPT_NewStr (INT8 form, INT8 comp);
+import void OPT_OpenScope (INT8 level, OPT_Object owner);
+import OPT_Struct OPT_SetType (INT32 size);
+import OPT_Struct OPT_ShorterOrLongerType (OPT_Struct x, INT16 dir);
+import INT32 OPT_SizeAlignment (INT32 size);
+import void OPT_TypSize (OPT_Struct typ);
+import void *OPT__init(void);
+
+
+#endif // OPT

bootstrap/unix-48/OPV.h

@@ -0,0 +1,18 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPV__h
+#define OPV__h
+
+#include "SYSTEM.h"
+#include "OPT.h"
+
+
+
+
+import void OPV_AdrAndSize (OPT_Object topScope);
+import void OPV_Init (void);
+import void OPV_Module (OPT_Node prog);
+import void *OPV__init(void);
+
+
+#endif // OPV

bootstrap/unix-48/Out.c

@@ -0,0 +1,345 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "Heap.h"
+#include "Platform.h"
+
+
+export BOOLEAN Out_IsConsole;
+static CHAR Out_buf[128];
+static INT16 Out_in;
+
+
+export void Out_Char (CHAR ch);
+export void Out_Flush (void);
+export void Out_Hex (INT64 x, INT64 n);
+export void Out_Int (INT64 x, INT64 n);
+static INT32 Out_Length (CHAR *s, ADDRESS s__len);
+export void Out_Ln (void);
+export void Out_LongReal (LONGREAL x, INT16 n);
+export void Out_Open (void);
+export void Out_Real (REAL x, INT16 n);
+static void Out_RealP (LONGREAL x, INT16 n, BOOLEAN long_);
+export void Out_String (CHAR *str, ADDRESS str__len);
+export LONGREAL Out_Ten (INT16 e);
+static void Out_digit (INT64 n, CHAR *s, ADDRESS s__len, INT16 *i);
+static void Out_prepend (CHAR *t, ADDRESS t__len, CHAR *s, ADDRESS s__len, INT16 *i);
+
+#define Out_Entier64(x)	(INT64)(x)
+
+void Out_Flush (void)
+{
+	INT16 error;
+	if (Out_in > 0) {
+		error = Platform_Write(1, (ADDRESS)Out_buf, Out_in);
+	}
+	Out_in = 0;
+}
+
+void Out_Open (void)
+{
+}
+
+void Out_Char (CHAR ch)
+{
+	if (Out_in >= 128) {
+		Out_Flush();
+	}
+	Out_buf[__X(Out_in, 128)] = ch;
+	Out_in += 1;
+	if (ch == 0x0a) {
+		Out_Flush();
+	}
+}
+
+static INT32 Out_Length (CHAR *s, ADDRESS s__len)
+{
+	INT32 l;
+	l = 0;
+	while ((l < s__len && s[__X(l, s__len)] != 0x00)) {
+		l += 1;
+	}
+	return l;
+}
+
+void Out_String (CHAR *str, ADDRESS str__len)
+{
+	INT32 l;
+	INT16 error;
+	__DUP(str, str__len, CHAR);
+	l = Out_Length((void*)str, str__len);
+	if (Out_in + l > 128) {
+		Out_Flush();
+	}
+	if (l > 128) {
+		error = Platform_Write(1, (ADDRESS)str, l);
+	} else {
+		__MOVE((ADDRESS)str, (ADDRESS)&Out_buf[__X(Out_in, 128)], l);
+		Out_in += __SHORT(l, 32768);
+	}
+	__DEL(str);
+}
+
+void Out_Int (INT64 x, INT64 n)
+{
+	CHAR s[22];
+	INT16 i;
+	BOOLEAN negative;
+	negative = x < 0;
+	if (x == (-9223372036854775807LL-1)) {
+		__MOVE("8085774586302733229", s, 20);
+		i = 19;
+	} else {
+		if (x < 0) {
+			x = -x;
+		}
+		s[0] = __CHR(48 + __MOD(x, 10));
+		x = __DIV(x, 10);
+		i = 1;
+		while (x != 0) {
+			s[__X(i, 22)] = __CHR(48 + __MOD(x, 10));
+			x = __DIV(x, 10);
+			i += 1;
+		}
+	}
+	if (negative) {
+		s[__X(i, 22)] = '-';
+		i += 1;
+	}
+	while (n > (INT64)i) {
+		Out_Char(' ');
+		n -= 1;
+	}
+	while (i > 0) {
+		i -= 1;
+		Out_Char(s[__X(i, 22)]);
+	}
+}
+
+void Out_Hex (INT64 x, INT64 n)
+{
+	if (n < 1) {
+		n = 1;
+	} else if (n > 16) {
+		n = 16;
+	}
+	if (x >= 0) {
+		while ((n < 16 && __LSH(x, -__ASHL(n, 2), 64) != 0)) {
+			n += 1;
+		}
+	}
+	x = __ROT(x, __ASHL(16 - n, 2), 64);
+	while (n > 0) {
+		x = __ROTL(x, 4, 64);
+		n -= 1;
+		if (__MASK(x, -16) < 10) {
+			Out_Char(__CHR(__MASK(x, -16) + 48));
+		} else {
+			Out_Char(__CHR((__MASK(x, -16) - 10) + 65));
+		}
+	}
+}
+
+void Out_Ln (void)
+{
+	Out_String(Platform_NL, 3);
+	Out_Flush();
+}
+
+static void Out_digit (INT64 n, CHAR *s, ADDRESS s__len, INT16 *i)
+{
+	*i -= 1;
+	s[__X(*i, s__len)] = __CHR(__MOD(n, 10) + 48);
+}
+
+static void Out_prepend (CHAR *t, ADDRESS t__len, CHAR *s, ADDRESS s__len, INT16 *i)
+{
+	INT16 j;
+	INT32 l;
+	__DUP(t, t__len, CHAR);
+	l = Out_Length((void*)t, t__len);
+	if (l > *i) {
+		l = *i;
+	}
+	*i -= __SHORT(l, 32768);
+	j = 0;
+	while (j < l) {
+		s[__X(*i + j, s__len)] = t[__X(j, t__len)];
+		j += 1;
+	}
+	__DEL(t);
+}
+
+LONGREAL Out_Ten (INT16 e)
+{
+	LONGREAL r, power;
+	r = (LONGREAL)1;
+	power = (LONGREAL)10;
+	while (e > 0) {
+		if (__ODD(e)) {
+			r = r * power;
+		}
+		power = power * power;
+		e = __ASHR(e, 1);
+	}
+	return r;
+}
+
+static void Out_RealP (LONGREAL x, INT16 n, BOOLEAN long_)
+{
+	INT16 e;
+	INT64 f;
+	CHAR s[30];
+	INT16 i, el;
+	LONGREAL x0;
+	BOOLEAN nn, en;
+	INT64 m;
+	INT16 d, dr;
+	e = (INT16)__MASK(__ASHR((__VAL(INT64, x)), 52), -2048);
+	f = __MASK((__VAL(INT64, x)), -4503599627370496LL);
+	nn = (__VAL(INT64, x) < 0 && !((e == 2047 && f != 0)));
+	if (nn) {
+		n -= 1;
+	}
+	i = 30;
+	if (e == 2047) {
+		if (f == 0) {
+			Out_prepend((CHAR*)"Infinity", 9, (void*)s, 30, &i);
+		} else {
+			Out_prepend((CHAR*)"NaN", 4, (void*)s, 30, &i);
+		}
+	} else {
+		if (long_) {
+			el = 3;
+			dr = n - 6;
+			if (dr > 17) {
+				dr = 17;
+			}
+			d = dr;
+			if (d < 15) {
+				d = 15;
+			}
+		} else {
+			el = 2;
+			dr = n - 5;
+			if (dr > 9) {
+				dr = 9;
+			}
+			d = dr;
+			if (d < 6) {
+				d = 6;
+			}
+		}
+		if (e == 0) {
+			while (el > 0) {
+				i -= 1;
+				s[__X(i, 30)] = '0';
+				el -= 1;
+			}
+			i -= 1;
+			s[__X(i, 30)] = '+';
+			m = 0;
+		} else {
+			if (nn) {
+				x = -x;
+			}
+			e = __SHORT(__ASHR((e - 1023) * 77, 8), 32768);
+			if (e >= 0) {
+				x = x / (LONGREAL)Out_Ten(e);
+			} else {
+				x = Out_Ten(-e) * x;
+			}
+			if (x >= (LONGREAL)10) {
+				x =   1.00000000000000e-001 * x;
+				e += 1;
+			}
+			en = e < 0;
+			if (en) {
+				e = -e;
+			}
+			while (el > 0) {
+				Out_digit(e, (void*)s, 30, &i);
+				e = __DIV(e, 10);
+				el -= 1;
+			}
+			i -= 1;
+			if (en) {
+				s[__X(i, 30)] = '-';
+			} else {
+				s[__X(i, 30)] = '+';
+			}
+			x0 = Out_Ten(d - 1);
+			x = x0 * x;
+			x = x +   5.00000000000000e-001;
+			if (x >= (LONGREAL)10 * x0) {
+				x =   1.00000000000000e-001 * x;
+				e += 1;
+			}
+			m = Out_Entier64(x);
+		}
+		i -= 1;
+		if (long_) {
+			s[__X(i, 30)] = 'D';
+		} else {
+			s[__X(i, 30)] = 'E';
+		}
+		if (dr < 2) {
+			dr = 2;
+		}
+		while ((d > dr && __MOD(m, 10) == 0)) {
+			m = __DIV(m, 10);
+			d -= 1;
+		}
+		while (d > 1) {
+			Out_digit(m, (void*)s, 30, &i);
+			m = __DIV(m, 10);
+			d -= 1;
+		}
+		i -= 1;
+		s[__X(i, 30)] = '.';
+		Out_digit(m, (void*)s, 30, &i);
+	}
+	n -= 30 - i;
+	while (n > 0) {
+		Out_Char(' ');
+		n -= 1;
+	}
+	if (nn) {
+		Out_Char('-');
+	}
+	while (i < 30) {
+		Out_Char(s[__X(i, 30)]);
+		i += 1;
+	}
+}
+
+void Out_Real (REAL x, INT16 n)
+{
+	Out_RealP(x, n, 0);
+}
+
+void Out_LongReal (LONGREAL x, INT16 n)
+{
+	Out_RealP(x, n, 1);
+}
+
+
+export void *Out__init(void)
+{
+	__DEFMOD;
+	__MODULE_IMPORT(Heap);
+	__MODULE_IMPORT(Platform);
+	__REGMOD("Out", 0);
+	__REGCMD("Flush", Out_Flush);
+	__REGCMD("Ln", Out_Ln);
+	__REGCMD("Open", Out_Open);
+/* BEGIN */
+	Out_IsConsole = Platform_IsConsole(1);
+	Out_in = 0;
+	__ENDMOD;
+}

bootstrap/unix-48/Out.h

@@ -0,0 +1,25 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Out__h
+#define Out__h
+
+#include "SYSTEM.h"
+
+
+import BOOLEAN Out_IsConsole;
+
+
+import void Out_Char (CHAR ch);
+import void Out_Flush (void);
+import void Out_Hex (INT64 x, INT64 n);
+import void Out_Int (INT64 x, INT64 n);
+import void Out_Ln (void);
+import void Out_LongReal (LONGREAL x, INT16 n);
+import void Out_Open (void);
+import void Out_Real (REAL x, INT16 n);
+import void Out_String (CHAR *str, ADDRESS str__len);
+import LONGREAL Out_Ten (INT16 e);
+import void *Out__init(void);
+
+
+#endif // Out

bootstrap/unix-48/Platform.c

@@ -0,0 +1,535 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+
+typedef
+	struct Platform_FileIdentity {
+		INT32 volume, index, mtime;
+	} Platform_FileIdentity;
+
+typedef
+	void (*Platform_SignalHandler)(INT32);
+
+
+export BOOLEAN Platform_LittleEndian;
+export INT16 Platform_PID;
+export CHAR Platform_CWD[256];
+static INT32 Platform_TimeStart;
+export INT16 Platform_SeekSet, Platform_SeekCur, Platform_SeekEnd;
+export CHAR Platform_NL[3];
+
+export ADDRESS *Platform_FileIdentity__typ;
+
+export BOOLEAN Platform_Absent (INT16 e);
+export INT16 Platform_Chdir (CHAR *n, ADDRESS n__len);
+export INT16 Platform_Close (INT32 h);
+export BOOLEAN Platform_ConnectionFailed (INT16 e);
+export void Platform_Delay (INT32 ms);
+export BOOLEAN Platform_DifferentFilesystems (INT16 e);
+export INT16 Platform_Error (void);
+export void Platform_Exit (INT32 code);
+export void Platform_GetClock (INT32 *t, INT32 *d);
+export void Platform_GetEnv (CHAR *var, ADDRESS var__len, CHAR *val, ADDRESS val__len);
+export void Platform_GetTimeOfDay (INT32 *sec, INT32 *usec);
+export INT16 Platform_Identify (INT32 h, Platform_FileIdentity *identity, ADDRESS *identity__typ);
+export INT16 Platform_IdentifyByName (CHAR *n, ADDRESS n__len, Platform_FileIdentity *identity, ADDRESS *identity__typ);
+export BOOLEAN Platform_Inaccessible (INT16 e);
+export BOOLEAN Platform_Interrupted (INT16 e);
+export BOOLEAN Platform_IsConsole (INT32 h);
+export void Platform_MTimeAsClock (Platform_FileIdentity i, INT32 *t, INT32 *d);
+export INT16 Platform_MaxNameLength (void);
+export INT16 Platform_MaxPathLength (void);
+export INT16 Platform_New (CHAR *n, ADDRESS n__len, INT32 *h);
+export BOOLEAN Platform_NoSuchDirectory (INT16 e);
+export INT32 Platform_OSAllocate (INT32 size);
+export void Platform_OSFree (INT32 address);
+export INT16 Platform_OldRO (CHAR *n, ADDRESS n__len, INT32 *h);
+export INT16 Platform_OldRW (CHAR *n, ADDRESS n__len, INT32 *h);
+export INT16 Platform_Read (INT32 h, INT32 p, INT32 l, INT32 *n);
+export INT16 Platform_ReadBuf (INT32 h, SYSTEM_BYTE *b, ADDRESS b__len, INT32 *n);
+export INT16 Platform_Rename (CHAR *o, ADDRESS o__len, CHAR *n, ADDRESS n__len);
+export BOOLEAN Platform_SameFile (Platform_FileIdentity i1, Platform_FileIdentity i2);
+export BOOLEAN Platform_SameFileTime (Platform_FileIdentity i1, Platform_FileIdentity i2);
+export INT16 Platform_Seek (INT32 h, INT32 offset, INT16 whence);
+export void Platform_SetBadInstructionHandler (Platform_SignalHandler handler);
+export void Platform_SetInterruptHandler (Platform_SignalHandler handler);
+export void Platform_SetMTime (Platform_FileIdentity *target, ADDRESS *target__typ, Platform_FileIdentity source);
+export void Platform_SetQuitHandler (Platform_SignalHandler handler);
+export INT16 Platform_Size (INT32 h, INT32 *l);
+export INT16 Platform_Sync (INT32 h);
+export INT16 Platform_System (CHAR *cmd, ADDRESS cmd__len);
+static void Platform_TestLittleEndian (void);
+export INT32 Platform_Time (void);
+export BOOLEAN Platform_TimedOut (INT16 e);
+export BOOLEAN Platform_TooManyFiles (INT16 e);
+export INT16 Platform_Truncate (INT32 h, INT32 l);
+export INT16 Platform_Unlink (CHAR *n, ADDRESS n__len);
+export INT16 Platform_Write (INT32 h, INT32 p, INT32 l);
+static void Platform_YMDHMStoClock (INT32 ye, INT32 mo, INT32 da, INT32 ho, INT32 mi, INT32 se, INT32 *t, INT32 *d);
+export BOOLEAN Platform_getEnv (CHAR *var, ADDRESS var__len, CHAR *val, ADDRESS val__len);
+
+#include <errno.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#define Platform_EACCES()	EACCES
+#define Platform_EAGAIN()	EAGAIN
+#define Platform_ECONNABORTED()	ECONNABORTED
+#define Platform_ECONNREFUSED()	ECONNREFUSED
+#define Platform_EHOSTUNREACH()	EHOSTUNREACH
+#define Platform_EINTR()	EINTR
+#define Platform_EMFILE()	EMFILE
+#define Platform_ENETUNREACH()	ENETUNREACH
+#define Platform_ENFILE()	ENFILE
+#define Platform_ENOENT()	ENOENT
+#define Platform_EROFS()	EROFS
+#define Platform_ETIMEDOUT()	ETIMEDOUT
+#define Platform_EXDEV()	EXDEV
+#define Platform_NAMEMAX()	NAME_MAX
+#define Platform_PATHMAX()	PATH_MAX
+#define Platform_allocate(size)	(ADDRESS)((void*)malloc((size_t)size))
+#define Platform_chdir(n, n__len)	chdir((char*)n)
+#define Platform_closefile(fd)	close(fd)
+#define Platform_err()	errno
+#define Platform_exit(code)	exit((int)code)
+#define Platform_free(address)	free((void*)address)
+#define Platform_fstat(fd)	fstat(fd, &s)
+#define Platform_fsync(fd)	fsync(fd)
+#define Platform_ftruncate(fd, l)	ftruncate(fd, l)
+#define Platform_getcwd(cwd, cwd__len)	getcwd((char*)cwd, cwd__len)
+#define Platform_getenv(var, var__len)	getenv((char*)var)
+#define Platform_getpid()	(INTEGER)getpid()
+#define Platform_gettimeval()	struct timeval tv; gettimeofday(&tv,0)
+#define Platform_isatty(fd)	isatty(fd)
+#define Platform_lseek(fd, o, w)	lseek(fd, o, w)
+#define Platform_nanosleep(s, ns)	struct timespec req, rem; req.tv_sec = s; req.tv_nsec = ns; nanosleep(&req, &rem)
+#define Platform_opennew(n, n__len)	open((char*)n, O_CREAT | O_TRUNC | O_RDWR, 0664)
+#define Platform_openro(n, n__len)	open((char*)n, O_RDONLY)
+#define Platform_openrw(n, n__len)	open((char*)n, O_RDWR)
+#define Platform_readfile(fd, p, l)	(LONGINT)read(fd, (void*)(ADDRESS)(p), l)
+#define Platform_rename(o, o__len, n, n__len)	rename((char*)o, (char*)n)
+#define Platform_sectotm(s)	struct tm *time = localtime((time_t*)&s)
+#define Platform_seekcur()	SEEK_CUR
+#define Platform_seekend()	SEEK_END
+#define Platform_seekset()	SEEK_SET
+#define Platform_sethandler(s, h)	SystemSetHandler(s, (ADDRESS)h)
+#define Platform_stat(n, n__len)	stat((char*)n, &s)
+#define Platform_statdev()	(LONGINT)s.st_dev
+#define Platform_statino()	(LONGINT)s.st_ino
+#define Platform_statmtime()	(LONGINT)s.st_mtime
+#define Platform_statsize()	(ADDRESS)s.st_size
+#define Platform_structstats()	struct stat s
+#define Platform_system(str, str__len)	system((char*)str)
+#define Platform_tmhour()	(LONGINT)time->tm_hour
+#define Platform_tmmday()	(LONGINT)time->tm_mday
+#define Platform_tmmin()	(LONGINT)time->tm_min
+#define Platform_tmmon()	(LONGINT)time->tm_mon
+#define Platform_tmsec()	(LONGINT)time->tm_sec
+#define Platform_tmyear()	(LONGINT)time->tm_year
+#define Platform_tvsec()	tv.tv_sec
+#define Platform_tvusec()	tv.tv_usec
+#define Platform_unlink(n, n__len)	unlink((char*)n)
+#define Platform_writefile(fd, p, l)	write(fd, (void*)(ADDRESS)(p), l)
+
+BOOLEAN Platform_TooManyFiles (INT16 e)
+{
+	return e == Platform_EMFILE() || e == Platform_ENFILE();
+}
+
+BOOLEAN Platform_NoSuchDirectory (INT16 e)
+{
+	return e == Platform_ENOENT();
+}
+
+BOOLEAN Platform_DifferentFilesystems (INT16 e)
+{
+	return e == Platform_EXDEV();
+}
+
+BOOLEAN Platform_Inaccessible (INT16 e)
+{
+	return (e == Platform_EACCES() || e == Platform_EROFS()) || e == Platform_EAGAIN();
+}
+
+BOOLEAN Platform_Absent (INT16 e)
+{
+	return e == Platform_ENOENT();
+}
+
+BOOLEAN Platform_TimedOut (INT16 e)
+{
+	return e == Platform_ETIMEDOUT();
+}
+
+BOOLEAN Platform_ConnectionFailed (INT16 e)
+{
+	return ((e == Platform_ECONNREFUSED() || e == Platform_ECONNABORTED()) || e == Platform_ENETUNREACH()) || e == Platform_EHOSTUNREACH();
+}
+
+BOOLEAN Platform_Interrupted (INT16 e)
+{
+	return e == Platform_EINTR();
+}
+
+INT16 Platform_MaxNameLength (void)
+{
+	return Platform_NAMEMAX();
+}
+
+INT16 Platform_MaxPathLength (void)
+{
+	return Platform_PATHMAX();
+}
+
+INT32 Platform_OSAllocate (INT32 size)
+{
+	return Platform_allocate(size);
+}
+
+void Platform_OSFree (INT32 address)
+{
+	Platform_free(address);
+}
+
+typedef
+	CHAR (*EnvPtr__83)[1024];
+
+BOOLEAN Platform_getEnv (CHAR *var, ADDRESS var__len, CHAR *val, ADDRESS val__len)
+{
+	EnvPtr__83 p = NIL;
+	__DUP(var, var__len, CHAR);
+	p = (EnvPtr__83)(ADDRESS)Platform_getenv(var, var__len);
+	if (p != NIL) {
+		__COPY(*p, val, val__len);
+	}
+	__DEL(var);
+	return p != NIL;
+}
+
+void Platform_GetEnv (CHAR *var, ADDRESS var__len, CHAR *val, ADDRESS val__len)
+{
+	__DUP(var, var__len, CHAR);
+	if (!Platform_getEnv(var, var__len, (void*)val, val__len)) {
+		val[0] = 0x00;
+	}
+	__DEL(var);
+}
+
+void Platform_SetInterruptHandler (Platform_SignalHandler handler)
+{
+	Platform_sethandler(2, handler);
+}
+
+void Platform_SetQuitHandler (Platform_SignalHandler handler)
+{
+	Platform_sethandler(3, handler);
+}
+
+void Platform_SetBadInstructionHandler (Platform_SignalHandler handler)
+{
+	Platform_sethandler(4, handler);
+}
+
+static void Platform_YMDHMStoClock (INT32 ye, INT32 mo, INT32 da, INT32 ho, INT32 mi, INT32 se, INT32 *t, INT32 *d)
+{
+	*d = (__ASHL((int)__MOD(ye, 100), 9) + __ASHL(mo + 1, 5)) + da;
+	*t = (__ASHL(ho, 12) + __ASHL(mi, 6)) + se;
+}
+
+void Platform_GetClock (INT32 *t, INT32 *d)
+{
+	Platform_gettimeval();
+	Platform_sectotm(Platform_tvsec());
+	Platform_YMDHMStoClock(Platform_tmyear(), Platform_tmmon(), Platform_tmmday(), Platform_tmhour(), Platform_tmmin(), Platform_tmsec(), &*t, &*d);
+}
+
+void Platform_GetTimeOfDay (INT32 *sec, INT32 *usec)
+{
+	Platform_gettimeval();
+	*sec = Platform_tvsec();
+	*usec = Platform_tvusec();
+}
+
+INT32 Platform_Time (void)
+{
+	INT32 ms;
+	Platform_gettimeval();
+	ms = (int)__DIVF(Platform_tvusec(), 1000) + Platform_tvsec() * 1000;
+	return (int)__MOD(ms - Platform_TimeStart, 2147483647);
+}
+
+void Platform_Delay (INT32 ms)
+{
+	INT32 s, ns;
+	s = __DIV(ms, 1000);
+	ns = (int)__MOD(ms, 1000) * 1000000;
+	Platform_nanosleep(s, ns);
+}
+
+INT16 Platform_System (CHAR *cmd, ADDRESS cmd__len)
+{
+	__DUP(cmd, cmd__len, CHAR);
+	__DEL(cmd);
+	return Platform_system(cmd, cmd__len);
+}
+
+INT16 Platform_Error (void)
+{
+	return Platform_err();
+}
+
+INT16 Platform_OldRO (CHAR *n, ADDRESS n__len, INT32 *h)
+{
+	INT16 fd;
+	fd = Platform_openro(n, n__len);
+	if (fd < 0) {
+		return Platform_err();
+	} else {
+		*h = fd;
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_OldRW (CHAR *n, ADDRESS n__len, INT32 *h)
+{
+	INT16 fd;
+	fd = Platform_openrw(n, n__len);
+	if (fd < 0) {
+		return Platform_err();
+	} else {
+		*h = fd;
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_New (CHAR *n, ADDRESS n__len, INT32 *h)
+{
+	INT16 fd;
+	fd = Platform_opennew(n, n__len);
+	if (fd < 0) {
+		return Platform_err();
+	} else {
+		*h = fd;
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Close (INT32 h)
+{
+	if (Platform_closefile(h) < 0) {
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+BOOLEAN Platform_IsConsole (INT32 h)
+{
+	return Platform_isatty(h) != 0;
+}
+
+INT16 Platform_Identify (INT32 h, Platform_FileIdentity *identity, ADDRESS *identity__typ)
+{
+	Platform_structstats();
+	if (Platform_fstat(h) < 0) {
+		return Platform_err();
+	}
+	(*identity).volume = Platform_statdev();
+	(*identity).index = Platform_statino();
+	(*identity).mtime = Platform_statmtime();
+	return 0;
+}
+
+INT16 Platform_IdentifyByName (CHAR *n, ADDRESS n__len, Platform_FileIdentity *identity, ADDRESS *identity__typ)
+{
+	__DUP(n, n__len, CHAR);
+	Platform_structstats();
+	if (Platform_stat(n, n__len) < 0) {
+		__DEL(n);
+		return Platform_err();
+	}
+	(*identity).volume = Platform_statdev();
+	(*identity).index = Platform_statino();
+	(*identity).mtime = Platform_statmtime();
+	__DEL(n);
+	return 0;
+}
+
+BOOLEAN Platform_SameFile (Platform_FileIdentity i1, Platform_FileIdentity i2)
+{
+	return (i1.index == i2.index && i1.volume == i2.volume);
+}
+
+BOOLEAN Platform_SameFileTime (Platform_FileIdentity i1, Platform_FileIdentity i2)
+{
+	return i1.mtime == i2.mtime;
+}
+
+void Platform_SetMTime (Platform_FileIdentity *target, ADDRESS *target__typ, Platform_FileIdentity source)
+{
+	(*target).mtime = source.mtime;
+}
+
+void Platform_MTimeAsClock (Platform_FileIdentity i, INT32 *t, INT32 *d)
+{
+	Platform_sectotm(i.mtime);
+	Platform_YMDHMStoClock(Platform_tmyear(), Platform_tmmon(), Platform_tmmday(), Platform_tmhour(), Platform_tmmin(), Platform_tmsec(), &*t, &*d);
+}
+
+INT16 Platform_Size (INT32 h, INT32 *l)
+{
+	Platform_structstats();
+	if (Platform_fstat(h) < 0) {
+		return Platform_err();
+	}
+	*l = Platform_statsize();
+	return 0;
+}
+
+INT16 Platform_Read (INT32 h, INT32 p, INT32 l, INT32 *n)
+{
+	*n = Platform_readfile(h, p, l);
+	if (*n < 0) {
+		*n = 0;
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_ReadBuf (INT32 h, SYSTEM_BYTE *b, ADDRESS b__len, INT32 *n)
+{
+	*n = Platform_readfile(h, (ADDRESS)b, b__len);
+	if (*n < 0) {
+		*n = 0;
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Write (INT32 h, INT32 p, INT32 l)
+{
+	INT32 written;
+	written = Platform_writefile(h, p, l);
+	if (written < 0) {
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Sync (INT32 h)
+{
+	if (Platform_fsync(h) < 0) {
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Seek (INT32 h, INT32 offset, INT16 whence)
+{
+	if (Platform_lseek(h, offset, whence) < 0) {
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Truncate (INT32 h, INT32 l)
+{
+	if (Platform_ftruncate(h, l) < 0) {
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Unlink (CHAR *n, ADDRESS n__len)
+{
+	if (Platform_unlink(n, n__len) < 0) {
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Chdir (CHAR *n, ADDRESS n__len)
+{
+	INT16 r;
+	if ((Platform_chdir(n, n__len) >= 0 && Platform_getcwd((void*)Platform_CWD, 256) != NIL)) {
+		return 0;
+	} else {
+		return Platform_err();
+	}
+	__RETCHK;
+}
+
+INT16 Platform_Rename (CHAR *o, ADDRESS o__len, CHAR *n, ADDRESS n__len)
+{
+	if (Platform_rename(o, o__len, n, n__len) < 0) {
+		return Platform_err();
+	} else {
+		return 0;
+	}
+	__RETCHK;
+}
+
+void Platform_Exit (INT32 code)
+{
+	Platform_exit(code);
+}
+
+static void Platform_TestLittleEndian (void)
+{
+	INT16 i;
+	i = 1;
+	__GET((ADDRESS)&i, Platform_LittleEndian, BOOLEAN);
+}
+
+__TDESC(Platform_FileIdentity, 1, 0) = {__TDFLDS("FileIdentity", 12), {-4}};
+
+export void *Platform__init(void)
+{
+	__DEFMOD;
+	__REGMOD("Platform", 0);
+	__INITYP(Platform_FileIdentity, Platform_FileIdentity, 0);
+/* BEGIN */
+	Platform_TestLittleEndian();
+	Platform_TimeStart = 0;
+	Platform_TimeStart = Platform_Time();
+	Platform_PID = Platform_getpid();
+	if (Platform_getcwd((void*)Platform_CWD, 256) == NIL) {
+		Platform_CWD[0] = 0x00;
+	}
+	Platform_SeekSet = Platform_seekset();
+	Platform_SeekCur = Platform_seekcur();
+	Platform_SeekEnd = Platform_seekend();
+	Platform_NL[0] = 0x0a;
+	Platform_NL[1] = 0x00;
+	__ENDMOD;
+}

bootstrap/unix-48/Platform.h

@@ -0,0 +1,74 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Platform__h
+#define Platform__h
+
+#include "SYSTEM.h"
+
+typedef
+	struct Platform_FileIdentity {
+		INT32 _prvt0;
+		char _prvt1[8];
+	} Platform_FileIdentity;
+
+typedef
+	void (*Platform_SignalHandler)(INT32);
+
+
+import BOOLEAN Platform_LittleEndian;
+import INT16 Platform_PID;
+import CHAR Platform_CWD[256];
+import INT16 Platform_SeekSet, Platform_SeekCur, Platform_SeekEnd;
+import CHAR Platform_NL[3];
+
+import ADDRESS *Platform_FileIdentity__typ;
+
+import BOOLEAN Platform_Absent (INT16 e);
+import INT16 Platform_Chdir (CHAR *n, ADDRESS n__len);
+import INT16 Platform_Close (INT32 h);
+import BOOLEAN Platform_ConnectionFailed (INT16 e);
+import void Platform_Delay (INT32 ms);
+import BOOLEAN Platform_DifferentFilesystems (INT16 e);
+import INT16 Platform_Error (void);
+import void Platform_Exit (INT32 code);
+import void Platform_GetClock (INT32 *t, INT32 *d);
+import void Platform_GetEnv (CHAR *var, ADDRESS var__len, CHAR *val, ADDRESS val__len);
+import void Platform_GetTimeOfDay (INT32 *sec, INT32 *usec);
+import INT16 Platform_Identify (INT32 h, Platform_FileIdentity *identity, ADDRESS *identity__typ);
+import INT16 Platform_IdentifyByName (CHAR *n, ADDRESS n__len, Platform_FileIdentity *identity, ADDRESS *identity__typ);
+import BOOLEAN Platform_Inaccessible (INT16 e);
+import BOOLEAN Platform_Interrupted (INT16 e);
+import BOOLEAN Platform_IsConsole (INT32 h);
+import void Platform_MTimeAsClock (Platform_FileIdentity i, INT32 *t, INT32 *d);
+import INT16 Platform_MaxNameLength (void);
+import INT16 Platform_MaxPathLength (void);
+import INT16 Platform_New (CHAR *n, ADDRESS n__len, INT32 *h);
+import BOOLEAN Platform_NoSuchDirectory (INT16 e);
+import INT32 Platform_OSAllocate (INT32 size);
+import void Platform_OSFree (INT32 address);
+import INT16 Platform_OldRO (CHAR *n, ADDRESS n__len, INT32 *h);
+import INT16 Platform_OldRW (CHAR *n, ADDRESS n__len, INT32 *h);
+import INT16 Platform_Read (INT32 h, INT32 p, INT32 l, INT32 *n);
+import INT16 Platform_ReadBuf (INT32 h, SYSTEM_BYTE *b, ADDRESS b__len, INT32 *n);
+import INT16 Platform_Rename (CHAR *o, ADDRESS o__len, CHAR *n, ADDRESS n__len);
+import BOOLEAN Platform_SameFile (Platform_FileIdentity i1, Platform_FileIdentity i2);
+import BOOLEAN Platform_SameFileTime (Platform_FileIdentity i1, Platform_FileIdentity i2);
+import INT16 Platform_Seek (INT32 h, INT32 offset, INT16 whence);
+import void Platform_SetBadInstructionHandler (Platform_SignalHandler handler);
+import void Platform_SetInterruptHandler (Platform_SignalHandler handler);
+import void Platform_SetMTime (Platform_FileIdentity *target, ADDRESS *target__typ, Platform_FileIdentity source);
+import void Platform_SetQuitHandler (Platform_SignalHandler handler);
+import INT16 Platform_Size (INT32 h, INT32 *l);
+import INT16 Platform_Sync (INT32 h);
+import INT16 Platform_System (CHAR *cmd, ADDRESS cmd__len);
+import INT32 Platform_Time (void);
+import BOOLEAN Platform_TimedOut (INT16 e);
+import BOOLEAN Platform_TooManyFiles (INT16 e);
+import INT16 Platform_Truncate (INT32 h, INT32 l);
+import INT16 Platform_Unlink (CHAR *n, ADDRESS n__len);
+import INT16 Platform_Write (INT32 h, INT32 p, INT32 l);
+import BOOLEAN Platform_getEnv (CHAR *var, ADDRESS var__len, CHAR *val, ADDRESS val__len);
+import void *Platform__init(void);
+
+
+#endif // Platform

bootstrap/unix-48/Reals.c

@@ -0,0 +1,157 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+
+
+
+
+static void Reals_BytesToHex (SYSTEM_BYTE *b, ADDRESS b__len, SYSTEM_BYTE *d, ADDRESS d__len);
+export void Reals_Convert (REAL x, INT16 n, CHAR *d, ADDRESS d__len);
+export void Reals_ConvertH (REAL y, CHAR *d, ADDRESS d__len);
+export void Reals_ConvertHL (LONGREAL x, CHAR *d, ADDRESS d__len);
+export void Reals_ConvertL (LONGREAL x, INT16 n, CHAR *d, ADDRESS d__len);
+export INT16 Reals_Expo (REAL x);
+export INT16 Reals_ExpoL (LONGREAL x);
+export void Reals_SetExpo (REAL *x, INT16 ex);
+export REAL Reals_Ten (INT16 e);
+export LONGREAL Reals_TenL (INT16 e);
+static CHAR Reals_ToHex (INT16 i);
+
+
+REAL Reals_Ten (INT16 e)
+{
+	LONGREAL r, power;
+	r = (LONGREAL)1;
+	power = (LONGREAL)10;
+	while (e > 0) {
+		if (__ODD(e)) {
+			r = r * power;
+		}
+		power = power * power;
+		e = __ASHR(e, 1);
+	}
+	return r;
+}
+
+LONGREAL Reals_TenL (INT16 e)
+{
+	LONGREAL r, power;
+	r = (LONGREAL)1;
+	power = (LONGREAL)10;
+	for (;;) {
+		if (__ODD(e)) {
+			r = r * power;
+		}
+		e = __ASHR(e, 1);
+		if (e <= 0) {
+			return r;
+		}
+		power = power * power;
+	}
+	__RETCHK;
+}
+
+INT16 Reals_Expo (REAL x)
+{
+	INT16 i;
+	__GET((ADDRESS)&x + 2, i, INT16);
+	return __MASK(__ASHR(i, 7), -256);
+}
+
+void Reals_SetExpo (REAL *x, INT16 ex)
+{
+	CHAR c;
+	__GET((ADDRESS)x + 3, c, CHAR);
+	__PUT((ADDRESS)x + 3, __CHR(__ASHL(__ASHR((INT16)c, 7), 7) + __MASK(__ASHR(ex, 1), -128)), CHAR);
+	__GET((ADDRESS)x + 2, c, CHAR);
+	__PUT((ADDRESS)x + 2, __CHR(__MASK((INT16)c, -128) + __ASHL(__MASK(ex, -2), 7)), CHAR);
+}
+
+INT16 Reals_ExpoL (LONGREAL x)
+{
+	INT16 i;
+	__GET((ADDRESS)&x + 6, i, INT16);
+	return __MASK(__ASHR(i, 4), -2048);
+}
+
+void Reals_ConvertL (LONGREAL x, INT16 n, CHAR *d, ADDRESS d__len)
+{
+	INT32 i, j, k;
+	if (x < (LONGREAL)0) {
+		x = -x;
+	}
+	k = 0;
+	if (n > 9) {
+		i = __SHORT(__ENTIER(x / (LONGREAL)(LONGREAL)1000000000), 2147483648LL);
+		j = __SHORT(__ENTIER(x - i * (LONGREAL)1000000000), 2147483648LL);
+		if (j < 0) {
+			j = 0;
+		}
+		while (k < 9) {
+			d[__X(k, d__len)] = __CHR((int)__MOD(j, 10) + 48);
+			j = __DIV(j, 10);
+			k += 1;
+		}
+	} else {
+		i = __SHORT(__ENTIER(x), 2147483648LL);
+	}
+	while (k < n) {
+		d[__X(k, d__len)] = __CHR((int)__MOD(i, 10) + 48);
+		i = __DIV(i, 10);
+		k += 1;
+	}
+}
+
+void Reals_Convert (REAL x, INT16 n, CHAR *d, ADDRESS d__len)
+{
+	Reals_ConvertL(x, n, (void*)d, d__len);
+}
+
+static CHAR Reals_ToHex (INT16 i)
+{
+	if (i < 10) {
+		return __CHR(i + 48);
+	} else {
+		return __CHR(i + 55);
+	}
+	__RETCHK;
+}
+
+static void Reals_BytesToHex (SYSTEM_BYTE *b, ADDRESS b__len, SYSTEM_BYTE *d, ADDRESS d__len)
+{
+	INT16 i;
+	INT32 l;
+	CHAR by;
+	i = 0;
+	l = b__len;
+	while (i < l) {
+		by = __VAL(CHAR, b[__X(i, b__len)]);
+		d[__X(__ASHL(i, 1), d__len)] = Reals_ToHex(__ASHR((INT16)by, 4));
+		d[__X(__ASHL(i, 1) + 1, d__len)] = Reals_ToHex(__MASK((INT16)by, -16));
+		i += 1;
+	}
+}
+
+void Reals_ConvertH (REAL y, CHAR *d, ADDRESS d__len)
+{
+	Reals_BytesToHex((void*)&y, 4, (void*)d, d__len * 1);
+}
+
+void Reals_ConvertHL (LONGREAL x, CHAR *d, ADDRESS d__len)
+{
+	Reals_BytesToHex((void*)&x, 8, (void*)d, d__len * 1);
+}
+
+
+export void *Reals__init(void)
+{
+	__DEFMOD;
+	__REGMOD("Reals", 0);
+/* BEGIN */
+	__ENDMOD;
+}

bootstrap/unix-48/Reals.h

@@ -0,0 +1,23 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Reals__h
+#define Reals__h
+
+#include "SYSTEM.h"
+
+
+
+
+import void Reals_Convert (REAL x, INT16 n, CHAR *d, ADDRESS d__len);
+import void Reals_ConvertH (REAL y, CHAR *d, ADDRESS d__len);
+import void Reals_ConvertHL (LONGREAL x, CHAR *d, ADDRESS d__len);
+import void Reals_ConvertL (LONGREAL x, INT16 n, CHAR *d, ADDRESS d__len);
+import INT16 Reals_Expo (REAL x);
+import INT16 Reals_ExpoL (LONGREAL x);
+import void Reals_SetExpo (REAL *x, INT16 ex);
+import REAL Reals_Ten (INT16 e);
+import LONGREAL Reals_TenL (INT16 e);
+import void *Reals__init(void);
+
+
+#endif // Reals

bootstrap/unix-48/Strings.c

@@ -0,0 +1,374 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "Reals.h"
+
+
+
+
+export void Strings_Append (CHAR *extra, ADDRESS extra__len, CHAR *dest, ADDRESS dest__len);
+export void Strings_Cap (CHAR *s, ADDRESS s__len);
+export void Strings_Delete (CHAR *s, ADDRESS s__len, INT16 pos, INT16 n);
+export void Strings_Extract (CHAR *source, ADDRESS source__len, INT16 pos, INT16 n, CHAR *dest, ADDRESS dest__len);
+export void Strings_Insert (CHAR *source, ADDRESS source__len, INT16 pos, CHAR *dest, ADDRESS dest__len);
+export INT16 Strings_Length (CHAR *s, ADDRESS s__len);
+export BOOLEAN Strings_Match (CHAR *string, ADDRESS string__len, CHAR *pattern, ADDRESS pattern__len);
+export INT16 Strings_Pos (CHAR *pattern, ADDRESS pattern__len, CHAR *s, ADDRESS s__len, INT16 pos);
+export void Strings_Replace (CHAR *source, ADDRESS source__len, INT16 pos, CHAR *dest, ADDRESS dest__len);
+export void Strings_StrToLongReal (CHAR *s, ADDRESS s__len, LONGREAL *r);
+export void Strings_StrToReal (CHAR *s, ADDRESS s__len, REAL *r);
+
+
+INT16 Strings_Length (CHAR *s, ADDRESS s__len)
+{
+	INT32 i;
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	while ((i < s__len && s[__X(i, s__len)] != 0x00)) {
+		i += 1;
+	}
+	if (i <= 32767) {
+		__DEL(s);
+		return __SHORT(i, 32768);
+	} else {
+		__DEL(s);
+		return 32767;
+	}
+	__RETCHK;
+}
+
+void Strings_Append (CHAR *extra, ADDRESS extra__len, CHAR *dest, ADDRESS dest__len)
+{
+	INT16 n1, n2, i;
+	__DUP(extra, extra__len, CHAR);
+	n1 = Strings_Length(dest, dest__len);
+	n2 = Strings_Length(extra, extra__len);
+	i = 0;
+	while ((i < n2 && (i + n1) < dest__len)) {
+		dest[__X(i + n1, dest__len)] = extra[__X(i, extra__len)];
+		i += 1;
+	}
+	if ((i + n1) < dest__len) {
+		dest[__X(i + n1, dest__len)] = 0x00;
+	}
+	__DEL(extra);
+}
+
+void Strings_Insert (CHAR *source, ADDRESS source__len, INT16 pos, CHAR *dest, ADDRESS dest__len)
+{
+	INT16 n1, n2, i;
+	__DUP(source, source__len, CHAR);
+	n1 = Strings_Length(dest, dest__len);
+	n2 = Strings_Length(source, source__len);
+	if (pos < 0) {
+		pos = 0;
+	}
+	if (pos > n1) {
+		Strings_Append(dest, dest__len, (void*)source, source__len);
+		__DEL(source);
+		return;
+	}
+	if ((pos + n2) < dest__len) {
+		i = n1;
+		while (i >= pos) {
+			if ((i + n2) < dest__len) {
+				dest[__X(i + n2, dest__len)] = dest[__X(i, dest__len)];
+			}
+			i -= 1;
+		}
+	}
+	i = 0;
+	while (i < n2) {
+		dest[__X(pos + i, dest__len)] = source[__X(i, source__len)];
+		i += 1;
+	}
+	__DEL(source);
+}
+
+void Strings_Delete (CHAR *s, ADDRESS s__len, INT16 pos, INT16 n)
+{
+	INT16 len, i;
+	len = Strings_Length(s, s__len);
+	if (pos < 0) {
+		pos = 0;
+	} else if (pos >= len) {
+		return;
+	}
+	if (pos + n < len) {
+		i = pos + n;
+		while (i < len) {
+			s[__X(i - n, s__len)] = s[__X(i, s__len)];
+			i += 1;
+		}
+		if ((i - n) < s__len) {
+			s[__X(i - n, s__len)] = 0x00;
+		}
+	} else {
+		s[__X(pos, s__len)] = 0x00;
+	}
+}
+
+void Strings_Replace (CHAR *source, ADDRESS source__len, INT16 pos, CHAR *dest, ADDRESS dest__len)
+{
+	__DUP(source, source__len, CHAR);
+	Strings_Delete((void*)dest, dest__len, pos, pos + Strings_Length(source, source__len));
+	Strings_Insert(source, source__len, pos, (void*)dest, dest__len);
+	__DEL(source);
+}
+
+void Strings_Extract (CHAR *source, ADDRESS source__len, INT16 pos, INT16 n, CHAR *dest, ADDRESS dest__len)
+{
+	INT16 len, destLen, i;
+	__DUP(source, source__len, CHAR);
+	len = Strings_Length(source, source__len);
+	destLen = __SHORT(dest__len, 32768) - 1;
+	if (pos < 0) {
+		pos = 0;
+	}
+	if (pos >= len) {
+		dest[0] = 0x00;
+		__DEL(source);
+		return;
+	}
+	i = 0;
+	while (((((pos + i) <= source__len && source[__X(pos + i, source__len)] != 0x00)) && i < n)) {
+		if (i < destLen) {
+			dest[__X(i, dest__len)] = source[__X(pos + i, source__len)];
+		}
+		i += 1;
+	}
+	dest[__X(i, dest__len)] = 0x00;
+	__DEL(source);
+}
+
+INT16 Strings_Pos (CHAR *pattern, ADDRESS pattern__len, CHAR *s, ADDRESS s__len, INT16 pos)
+{
+	INT16 n1, n2, i, j;
+	__DUP(pattern, pattern__len, CHAR);
+	__DUP(s, s__len, CHAR);
+	n1 = Strings_Length(s, s__len);
+	n2 = Strings_Length(pattern, pattern__len);
+	if (n2 == 0) {
+		__DEL(pattern);
+		__DEL(s);
+		return 0;
+	}
+	i = pos;
+	while (i <= n1 - n2) {
+		if (s[__X(i, s__len)] == pattern[0]) {
+			j = 1;
+			while ((j < n2 && s[__X(i + j, s__len)] == pattern[__X(j, pattern__len)])) {
+				j += 1;
+			}
+			if (j == n2) {
+				__DEL(pattern);
+				__DEL(s);
+				return i;
+			}
+		}
+		i += 1;
+	}
+	__DEL(pattern);
+	__DEL(s);
+	return -1;
+}
+
+void Strings_Cap (CHAR *s, ADDRESS s__len)
+{
+	INT16 i;
+	i = 0;
+	while (s[__X(i, s__len)] != 0x00) {
+		if (('a' <= s[__X(i, s__len)] && s[__X(i, s__len)] <= 'z')) {
+			s[__X(i, s__len)] = __CAP(s[__X(i, s__len)]);
+		}
+		i += 1;
+	}
+}
+
+static struct Match__7 {
+	struct Match__7 *lnk;
+} *Match__7_s;
+
+static BOOLEAN M__8 (CHAR *name, ADDRESS name__len, CHAR *mask, ADDRESS mask__len, INT16 n, INT16 m);
+
+static BOOLEAN M__8 (CHAR *name, ADDRESS name__len, CHAR *mask, ADDRESS mask__len, INT16 n, INT16 m)
+{
+	while ((((n >= 0 && m >= 0)) && mask[__X(m, mask__len)] != '*')) {
+		if (name[__X(n, name__len)] != mask[__X(m, mask__len)]) {
+			return 0;
+		}
+		n -= 1;
+		m -= 1;
+	}
+	if (m < 0) {
+		return n < 0;
+	}
+	while ((m >= 0 && mask[__X(m, mask__len)] == '*')) {
+		m -= 1;
+	}
+	if (m < 0) {
+		return 1;
+	}
+	while (n >= 0) {
+		if (M__8(name, name__len, mask, mask__len, n, m)) {
+			return 1;
+		}
+		n -= 1;
+	}
+	return 0;
+}
+
+BOOLEAN Strings_Match (CHAR *string, ADDRESS string__len, CHAR *pattern, ADDRESS pattern__len)
+{
+	struct Match__7 _s;
+	BOOLEAN __retval;
+	__DUP(string, string__len, CHAR);
+	__DUP(pattern, pattern__len, CHAR);
+	_s.lnk = Match__7_s;
+	Match__7_s = &_s;
+	__retval = M__8((void*)string, string__len, (void*)pattern, pattern__len, Strings_Length(string, string__len) - 1, Strings_Length(pattern, pattern__len) - 1);
+	Match__7_s = _s.lnk;
+	__DEL(string);
+	__DEL(pattern);
+	;
+	return __retval;
+}
+
+void Strings_StrToReal (CHAR *s, ADDRESS s__len, REAL *r)
+{
+	INT16 p, e;
+	REAL y, g;
+	BOOLEAN neg, negE;
+	__DUP(s, s__len, CHAR);
+	p = 0;
+	while (s[__X(p, s__len)] == ' ' || s[__X(p, s__len)] == '0') {
+		p += 1;
+	}
+	if (s[__X(p, s__len)] == '-') {
+		neg = 1;
+		p += 1;
+	} else {
+		neg = 0;
+	}
+	while (s[__X(p, s__len)] == ' ' || s[__X(p, s__len)] == '0') {
+		p += 1;
+	}
+	y = (REAL)0;
+	while (('0' <= s[__X(p, s__len)] && s[__X(p, s__len)] <= '9')) {
+		y = y * (REAL)10 + ((INT16)s[__X(p, s__len)] - 48);
+		p += 1;
+	}
+	if (s[__X(p, s__len)] == '.') {
+		p += 1;
+		g = (REAL)1;
+		while (('0' <= s[__X(p, s__len)] && s[__X(p, s__len)] <= '9')) {
+			g = g / (REAL)(REAL)10;
+			y = y + g * ((INT16)s[__X(p, s__len)] - 48);
+			p += 1;
+		}
+	}
+	if (s[__X(p, s__len)] == 'D' || s[__X(p, s__len)] == 'E') {
+		p += 1;
+		e = 0;
+		if (s[__X(p, s__len)] == '-') {
+			negE = 1;
+			p += 1;
+		} else {
+			negE = 0;
+		}
+		while (s[__X(p, s__len)] == '0') {
+			p += 1;
+		}
+		while (('0' <= s[__X(p, s__len)] && s[__X(p, s__len)] <= '9')) {
+			e = e * 10 + ((INT16)s[__X(p, s__len)] - 48);
+			p += 1;
+		}
+		if (negE) {
+			y = y / (REAL)Reals_Ten(e);
+		} else {
+			y = y * Reals_Ten(e);
+		}
+	}
+	if (neg) {
+		y = -y;
+	}
+	*r = y;
+	__DEL(s);
+}
+
+void Strings_StrToLongReal (CHAR *s, ADDRESS s__len, LONGREAL *r)
+{
+	INT16 p, e;
+	LONGREAL y, g;
+	BOOLEAN neg, negE;
+	__DUP(s, s__len, CHAR);
+	p = 0;
+	while (s[__X(p, s__len)] == ' ' || s[__X(p, s__len)] == '0') {
+		p += 1;
+	}
+	if (s[__X(p, s__len)] == '-') {
+		neg = 1;
+		p += 1;
+	} else {
+		neg = 0;
+	}
+	while (s[__X(p, s__len)] == ' ' || s[__X(p, s__len)] == '0') {
+		p += 1;
+	}
+	y = (LONGREAL)0;
+	while (('0' <= s[__X(p, s__len)] && s[__X(p, s__len)] <= '9')) {
+		y = y * (LONGREAL)10 + ((INT16)s[__X(p, s__len)] - 48);
+		p += 1;
+	}
+	if (s[__X(p, s__len)] == '.') {
+		p += 1;
+		g = (LONGREAL)1;
+		while (('0' <= s[__X(p, s__len)] && s[__X(p, s__len)] <= '9')) {
+			g = g / (LONGREAL)(LONGREAL)10;
+			y = y + g * ((INT16)s[__X(p, s__len)] - 48);
+			p += 1;
+		}
+	}
+	if (s[__X(p, s__len)] == 'D' || s[__X(p, s__len)] == 'E') {
+		p += 1;
+		e = 0;
+		if (s[__X(p, s__len)] == '-') {
+			negE = 1;
+			p += 1;
+		} else {
+			negE = 0;
+		}
+		while (s[__X(p, s__len)] == '0') {
+			p += 1;
+		}
+		while (('0' <= s[__X(p, s__len)] && s[__X(p, s__len)] <= '9')) {
+			e = e * 10 + ((INT16)s[__X(p, s__len)] - 48);
+			p += 1;
+		}
+		if (negE) {
+			y = y / (LONGREAL)Reals_Ten(e);
+		} else {
+			y = y * Reals_Ten(e);
+		}
+	}
+	if (neg) {
+		y = -y;
+	}
+	*r = y;
+	__DEL(s);
+}
+
+
+export void *Strings__init(void)
+{
+	__DEFMOD;
+	__MODULE_IMPORT(Reals);
+	__REGMOD("Strings", 0);
+/* BEGIN */
+	__ENDMOD;
+}

bootstrap/unix-48/Strings.h

@@ -0,0 +1,25 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Strings__h
+#define Strings__h
+
+#include "SYSTEM.h"
+
+
+
+
+import void Strings_Append (CHAR *extra, ADDRESS extra__len, CHAR *dest, ADDRESS dest__len);
+import void Strings_Cap (CHAR *s, ADDRESS s__len);
+import void Strings_Delete (CHAR *s, ADDRESS s__len, INT16 pos, INT16 n);
+import void Strings_Extract (CHAR *source, ADDRESS source__len, INT16 pos, INT16 n, CHAR *dest, ADDRESS dest__len);
+import void Strings_Insert (CHAR *source, ADDRESS source__len, INT16 pos, CHAR *dest, ADDRESS dest__len);
+import INT16 Strings_Length (CHAR *s, ADDRESS s__len);
+import BOOLEAN Strings_Match (CHAR *string, ADDRESS string__len, CHAR *pattern, ADDRESS pattern__len);
+import INT16 Strings_Pos (CHAR *pattern, ADDRESS pattern__len, CHAR *s, ADDRESS s__len, INT16 pos);
+import void Strings_Replace (CHAR *source, ADDRESS source__len, INT16 pos, CHAR *dest, ADDRESS dest__len);
+import void Strings_StrToLongReal (CHAR *s, ADDRESS s__len, LONGREAL *r);
+import void Strings_StrToReal (CHAR *s, ADDRESS s__len, REAL *r);
+import void *Strings__init(void);
+
+
+#endif // Strings

bootstrap/unix-48/Texts.h

@@ -0,0 +1,173 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Texts__h
+#define Texts__h
+
+#include "SYSTEM.h"
+#include "Files.h"
+
+typedef
+	struct Texts_BufDesc {
+		INT32 len;
+		char _prvt0[4];
+	} Texts_BufDesc;
+
+typedef
+	Texts_BufDesc *Texts_Buffer;
+
+typedef
+	struct Texts_ElemMsg {
+		char _prvt0[1];
+	} Texts_ElemMsg;
+
+typedef
+	struct Texts_ElemDesc *Texts_Elem;
+
+typedef
+	struct Texts_CopyMsg { /* Texts_ElemMsg */
+		Texts_Elem e;
+	} Texts_CopyMsg;
+
+typedef
+	struct Texts_RunDesc {
+		INT32 _prvt0;
+		char _prvt1[15];
+	} Texts_RunDesc;
+
+typedef
+	void (*Texts_Handler)(Texts_Elem, Texts_ElemMsg*, ADDRESS *);
+
+typedef
+	struct Texts_ElemDesc {
+		char _prvt0[20];
+		INT32 W, H;
+		Texts_Handler handle;
+		char _prvt1[4];
+	} Texts_ElemDesc;
+
+typedef
+	struct Texts_FileMsg { /* Texts_ElemMsg */
+		INT16 id;
+		INT32 pos;
+		Files_Rider r;
+	} Texts_FileMsg;
+
+typedef
+	struct Texts_FontDesc {
+		char _prvt0[32];
+	} Texts_FontDesc;
+
+typedef
+	Texts_FontDesc *Texts_FontsFont;
+
+typedef
+	struct Texts_IdentifyMsg { /* Texts_ElemMsg */
+		CHAR mod[32], proc[32];
+	} Texts_IdentifyMsg;
+
+typedef
+	struct Texts_TextDesc *Texts_Text;
+
+typedef
+	void (*Texts_Notifier)(Texts_Text, INT16, INT32, INT32);
+
+typedef
+	struct Texts_Reader {
+		BOOLEAN eot;
+		Texts_FontsFont fnt;
+		INT8 col, voff;
+		Texts_Elem elem;
+		char _prvt0[32];
+	} Texts_Reader;
+
+typedef
+	struct Texts_Scanner { /* Texts_Reader */
+		BOOLEAN eot;
+		Texts_FontsFont fnt;
+		INT8 col, voff;
+		Texts_Elem elem;
+		INT64 _prvt0;
+		char _prvt1[24];
+		CHAR nextCh;
+		INT16 line, class;
+		INT32 i;
+		REAL x;
+		LONGREAL y;
+		CHAR c;
+		INT8 len;
+		CHAR s[64];
+	} Texts_Scanner;
+
+typedef
+	struct Texts_TextDesc {
+		INT32 len;
+		Texts_Notifier notify;
+		char _prvt0[12];
+	} Texts_TextDesc;
+
+typedef
+	struct Texts_Writer {
+		Texts_Buffer buf;
+		Texts_FontsFont fnt;
+		INT8 col, voff;
+		char _prvt0[26];
+	} Texts_Writer;
+
+
+import Texts_Elem Texts_new;
+
+import ADDRESS *Texts_FontDesc__typ;
+import ADDRESS *Texts_RunDesc__typ;
+import ADDRESS *Texts_ElemMsg__typ;
+import ADDRESS *Texts_ElemDesc__typ;
+import ADDRESS *Texts_FileMsg__typ;
+import ADDRESS *Texts_CopyMsg__typ;
+import ADDRESS *Texts_IdentifyMsg__typ;
+import ADDRESS *Texts_BufDesc__typ;
+import ADDRESS *Texts_TextDesc__typ;
+import ADDRESS *Texts_Reader__typ;
+import ADDRESS *Texts_Scanner__typ;
+import ADDRESS *Texts_Writer__typ;
+
+import void Texts_Append (Texts_Text T, Texts_Buffer B);
+import void Texts_ChangeLooks (Texts_Text T, INT32 beg, INT32 end, UINT32 sel, Texts_FontsFont fnt, INT8 col, INT8 voff);
+import void Texts_Close (Texts_Text T, CHAR *name, ADDRESS name__len);
+import void Texts_Copy (Texts_Buffer SB, Texts_Buffer DB);
+import void Texts_CopyElem (Texts_Elem SE, Texts_Elem DE);
+import void Texts_Delete (Texts_Text T, INT32 beg, INT32 end);
+import Texts_Text Texts_ElemBase (Texts_Elem E);
+import INT32 Texts_ElemPos (Texts_Elem E);
+import void Texts_Insert (Texts_Text T, INT32 pos, Texts_Buffer B);
+import void Texts_Load (Files_Rider *r, ADDRESS *r__typ, Texts_Text T);
+import void Texts_Open (Texts_Text T, CHAR *name, ADDRESS name__len);
+import void Texts_OpenBuf (Texts_Buffer B);
+import void Texts_OpenReader (Texts_Reader *R, ADDRESS *R__typ, Texts_Text T, INT32 pos);
+import void Texts_OpenScanner (Texts_Scanner *S, ADDRESS *S__typ, Texts_Text T, INT32 pos);
+import void Texts_OpenWriter (Texts_Writer *W, ADDRESS *W__typ);
+import INT32 Texts_Pos (Texts_Reader *R, ADDRESS *R__typ);
+import void Texts_Read (Texts_Reader *R, ADDRESS *R__typ, CHAR *ch);
+import void Texts_ReadElem (Texts_Reader *R, ADDRESS *R__typ);
+import void Texts_ReadPrevElem (Texts_Reader *R, ADDRESS *R__typ);
+import void Texts_Recall (Texts_Buffer *B);
+import void Texts_Save (Texts_Text T, INT32 beg, INT32 end, Texts_Buffer B);
+import void Texts_Scan (Texts_Scanner *S, ADDRESS *S__typ);
+import void Texts_SetColor (Texts_Writer *W, ADDRESS *W__typ, INT8 col);
+import void Texts_SetFont (Texts_Writer *W, ADDRESS *W__typ, Texts_FontsFont fnt);
+import void Texts_SetOffset (Texts_Writer *W, ADDRESS *W__typ, INT8 voff);
+import void Texts_Store (Files_Rider *r, ADDRESS *r__typ, Texts_Text T);
+import void Texts_Write (Texts_Writer *W, ADDRESS *W__typ, CHAR ch);
+import void Texts_WriteDate (Texts_Writer *W, ADDRESS *W__typ, INT32 t, INT32 d);
+import void Texts_WriteElem (Texts_Writer *W, ADDRESS *W__typ, Texts_Elem e);
+import void Texts_WriteHex (Texts_Writer *W, ADDRESS *W__typ, INT32 x);
+import void Texts_WriteInt (Texts_Writer *W, ADDRESS *W__typ, INT64 x, INT64 n);
+import void Texts_WriteLn (Texts_Writer *W, ADDRESS *W__typ);
+import void Texts_WriteLongReal (Texts_Writer *W, ADDRESS *W__typ, LONGREAL x, INT16 n);
+import void Texts_WriteLongRealHex (Texts_Writer *W, ADDRESS *W__typ, LONGREAL x);
+import void Texts_WriteReal (Texts_Writer *W, ADDRESS *W__typ, REAL x, INT16 n);
+import void Texts_WriteRealFix (Texts_Writer *W, ADDRESS *W__typ, REAL x, INT16 n, INT16 k);
+import void Texts_WriteRealHex (Texts_Writer *W, ADDRESS *W__typ, REAL x);
+import void Texts_WriteString (Texts_Writer *W, ADDRESS *W__typ, CHAR *s, ADDRESS s__len);
+import void *Texts__init(void);
+
+
+#endif // Texts

bootstrap/unix-48/VT100.c

@@ -0,0 +1,275 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "Out.h"
+#include "Strings.h"
+
+
+export CHAR VT100_CSI[5];
+static CHAR VT100_tmpstr[32];
+
+
+export void VT100_CHA (INT16 n);
+export void VT100_CNL (INT16 n);
+export void VT100_CPL (INT16 n);
+export void VT100_CUB (INT16 n);
+export void VT100_CUD (INT16 n);
+export void VT100_CUF (INT16 n);
+export void VT100_CUP (INT16 n, INT16 m);
+export void VT100_CUU (INT16 n);
+export void VT100_DECTCEMh (void);
+export void VT100_DECTCEMl (void);
+export void VT100_DSR (INT16 n);
+export void VT100_ED (INT16 n);
+export void VT100_EL (INT16 n);
+static void VT100_EscSeq (INT16 n, CHAR *letter, ADDRESS letter__len);
+static void VT100_EscSeq0 (CHAR *letter, ADDRESS letter__len);
+static void VT100_EscSeq2 (INT16 n, INT16 m, CHAR *letter, ADDRESS letter__len);
+static void VT100_EscSeqSwapped (INT16 n, CHAR *letter, ADDRESS letter__len);
+export void VT100_HVP (INT16 n, INT16 m);
+export void VT100_IntToStr (INT32 int_, CHAR *str, ADDRESS str__len);
+export void VT100_RCP (void);
+export void VT100_Reset (void);
+static void VT100_Reverse0 (CHAR *str, ADDRESS str__len, INT16 start, INT16 end);
+export void VT100_SCP (void);
+export void VT100_SD (INT16 n);
+export void VT100_SGR (INT16 n);
+export void VT100_SGR2 (INT16 n, INT16 m);
+export void VT100_SU (INT16 n);
+export void VT100_SetAttr (CHAR *attr, ADDRESS attr__len);
+
+
+static void VT100_Reverse0 (CHAR *str, ADDRESS str__len, INT16 start, INT16 end)
+{
+	CHAR h;
+	while (start < end) {
+		h = str[__X(start, str__len)];
+		str[__X(start, str__len)] = str[__X(end, str__len)];
+		str[__X(end, str__len)] = h;
+		start += 1;
+		end -= 1;
+	}
+}
+
+void VT100_IntToStr (INT32 int_, CHAR *str, ADDRESS str__len)
+{
+	CHAR b[21];
+	INT16 s, e;
+	INT8 maxLength;
+	maxLength = 11;
+	if (int_ == (-2147483647-1)) {
+		__MOVE("-2147483648", b, 12);
+		e = 11;
+	} else {
+		if (int_ < 0) {
+			b[0] = '-';
+			int_ = -int_;
+			s = 1;
+		} else {
+			s = 0;
+		}
+		e = s;
+		do {
+			b[__X(e, 21)] = __CHR((int)__MOD(int_, 10) + 48);
+			int_ = __DIV(int_, 10);
+			e += 1;
+		} while (!(int_ == 0));
+		b[__X(e, 21)] = 0x00;
+		VT100_Reverse0((void*)b, 21, s, e - 1);
+	}
+	__COPY(b, str, str__len);
+}
+
+static void VT100_EscSeq0 (CHAR *letter, ADDRESS letter__len)
+{
+	CHAR cmd[9];
+	__DUP(letter, letter__len, CHAR);
+	__COPY(VT100_CSI, cmd, 9);
+	Strings_Append(letter, letter__len, (void*)cmd, 9);
+	Out_String(cmd, 9);
+	__DEL(letter);
+}
+
+static void VT100_EscSeq (INT16 n, CHAR *letter, ADDRESS letter__len)
+{
+	CHAR nstr[2];
+	CHAR cmd[7];
+	__DUP(letter, letter__len, CHAR);
+	VT100_IntToStr(n, (void*)nstr, 2);
+	__COPY(VT100_CSI, cmd, 7);
+	Strings_Append(nstr, 2, (void*)cmd, 7);
+	Strings_Append(letter, letter__len, (void*)cmd, 7);
+	Out_String(cmd, 7);
+	__DEL(letter);
+}
+
+static void VT100_EscSeqSwapped (INT16 n, CHAR *letter, ADDRESS letter__len)
+{
+	CHAR nstr[2];
+	CHAR cmd[7];
+	__DUP(letter, letter__len, CHAR);
+	VT100_IntToStr(n, (void*)nstr, 2);
+	__COPY(VT100_CSI, cmd, 7);
+	Strings_Append(letter, letter__len, (void*)cmd, 7);
+	Strings_Append(nstr, 2, (void*)cmd, 7);
+	Out_String(cmd, 7);
+	__DEL(letter);
+}
+
+static void VT100_EscSeq2 (INT16 n, INT16 m, CHAR *letter, ADDRESS letter__len)
+{
+	CHAR nstr[5], mstr[5];
+	CHAR cmd[12];
+	__DUP(letter, letter__len, CHAR);
+	VT100_IntToStr(n, (void*)nstr, 5);
+	VT100_IntToStr(m, (void*)mstr, 5);
+	__COPY(VT100_CSI, cmd, 12);
+	Strings_Append(nstr, 5, (void*)cmd, 12);
+	Strings_Append((CHAR*)";", 2, (void*)cmd, 12);
+	Strings_Append(mstr, 5, (void*)cmd, 12);
+	Strings_Append(letter, letter__len, (void*)cmd, 12);
+	Out_String(cmd, 12);
+	__DEL(letter);
+}
+
+void VT100_Reset (void)
+{
+	CHAR cmd[6];
+	__COPY("\033", cmd, 6);
+	Strings_Append((CHAR*)"c", 2, (void*)cmd, 6);
+	Out_String(cmd, 6);
+	Out_Ln();
+}
+
+void VT100_CUU (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"A", 2);
+}
+
+void VT100_CUD (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"B", 2);
+}
+
+void VT100_CUF (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"C", 2);
+}
+
+void VT100_CUB (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"D", 2);
+}
+
+void VT100_CNL (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"E", 2);
+}
+
+void VT100_CPL (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"F", 2);
+}
+
+void VT100_CHA (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"G", 2);
+}
+
+void VT100_CUP (INT16 n, INT16 m)
+{
+	VT100_EscSeq2(n, m, (CHAR*)"H", 2);
+}
+
+void VT100_ED (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"J", 2);
+}
+
+void VT100_EL (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"K", 2);
+}
+
+void VT100_SU (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"S", 2);
+}
+
+void VT100_SD (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"T", 2);
+}
+
+void VT100_HVP (INT16 n, INT16 m)
+{
+	VT100_EscSeq2(n, m, (CHAR*)"f", 2);
+}
+
+void VT100_SGR (INT16 n)
+{
+	VT100_EscSeq(n, (CHAR*)"m", 2);
+}
+
+void VT100_SGR2 (INT16 n, INT16 m)
+{
+	VT100_EscSeq2(n, m, (CHAR*)"m", 2);
+}
+
+void VT100_DSR (INT16 n)
+{
+	VT100_EscSeq(6, (CHAR*)"n", 2);
+}
+
+void VT100_SCP (void)
+{
+	VT100_EscSeq0((CHAR*)"s", 2);
+}
+
+void VT100_RCP (void)
+{
+	VT100_EscSeq0((CHAR*)"u", 2);
+}
+
+void VT100_DECTCEMl (void)
+{
+	VT100_EscSeq0((CHAR*)"\?25l", 5);
+}
+
+void VT100_DECTCEMh (void)
+{
+	VT100_EscSeq0((CHAR*)"\?25h", 5);
+}
+
+void VT100_SetAttr (CHAR *attr, ADDRESS attr__len)
+{
+	CHAR tmpstr[16];
+	__DUP(attr, attr__len, CHAR);
+	__COPY(VT100_CSI, tmpstr, 16);
+	Strings_Append(attr, attr__len, (void*)tmpstr, 16);
+	Out_String(tmpstr, 16);
+	__DEL(attr);
+}
+
+
+export void *VT100__init(void)
+{
+	__DEFMOD;
+	__MODULE_IMPORT(Out);
+	__MODULE_IMPORT(Strings);
+	__REGMOD("VT100", 0);
+	__REGCMD("DECTCEMh", VT100_DECTCEMh);
+	__REGCMD("DECTCEMl", VT100_DECTCEMl);
+	__REGCMD("RCP", VT100_RCP);
+	__REGCMD("Reset", VT100_Reset);
+	__REGCMD("SCP", VT100_SCP);
+/* BEGIN */
+	__COPY("\033", VT100_CSI, 5);
+	Strings_Append((CHAR*)"[", 2, (void*)VT100_CSI, 5);
+	__ENDMOD;
+}

bootstrap/unix-48/VT100.h

@@ -0,0 +1,38 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef VT100__h
+#define VT100__h
+
+#include "SYSTEM.h"
+
+
+import CHAR VT100_CSI[5];
+
+
+import void VT100_CHA (INT16 n);
+import void VT100_CNL (INT16 n);
+import void VT100_CPL (INT16 n);
+import void VT100_CUB (INT16 n);
+import void VT100_CUD (INT16 n);
+import void VT100_CUF (INT16 n);
+import void VT100_CUP (INT16 n, INT16 m);
+import void VT100_CUU (INT16 n);
+import void VT100_DECTCEMh (void);
+import void VT100_DECTCEMl (void);
+import void VT100_DSR (INT16 n);
+import void VT100_ED (INT16 n);
+import void VT100_EL (INT16 n);
+import void VT100_HVP (INT16 n, INT16 m);
+import void VT100_IntToStr (INT32 int_, CHAR *str, ADDRESS str__len);
+import void VT100_RCP (void);
+import void VT100_Reset (void);
+import void VT100_SCP (void);
+import void VT100_SD (INT16 n);
+import void VT100_SGR (INT16 n);
+import void VT100_SGR2 (INT16 n, INT16 m);
+import void VT100_SU (INT16 n);
+import void VT100_SetAttr (CHAR *attr, ADDRESS attr__len);
+import void *VT100__init(void);
+
+
+#endif // VT100

bootstrap/unix-48/extTools.c

@@ -0,0 +1,139 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "Configuration.h"
+#include "Heap.h"
+#include "Modules.h"
+#include "OPM.h"
+#include "Out.h"
+#include "Platform.h"
+#include "Strings.h"
+
+typedef
+	CHAR extTools_CommandString[4096];
+
+
+static extTools_CommandString extTools_CFLAGS;
+
+
+export void extTools_Assemble (CHAR *moduleName, ADDRESS moduleName__len);
+static void extTools_InitialiseCompilerCommand (CHAR *s, ADDRESS s__len, CHAR *additionalopts, ADDRESS additionalopts__len);
+export void extTools_LinkMain (CHAR *moduleName, ADDRESS moduleName__len, BOOLEAN statically, CHAR *additionalopts, ADDRESS additionalopts__len);
+static void extTools_execute (CHAR *title, ADDRESS title__len, CHAR *cmd, ADDRESS cmd__len);
+
+
+static void extTools_execute (CHAR *title, ADDRESS title__len, CHAR *cmd, ADDRESS cmd__len)
+{
+	INT16 r, status, exitcode;
+	extTools_CommandString fullcmd;
+	__DUP(title, title__len, CHAR);
+	__DUP(cmd, cmd__len, CHAR);
+	if (__IN(18, OPM_Options, 32)) {
+		Out_String((CHAR*)"  ", 3);
+		Out_String(cmd, cmd__len);
+		Out_Ln();
+	}
+	__COPY(cmd, fullcmd, 4096);
+	Heap_GC(0);
+	r = Platform_System(fullcmd, 4096);
+	status = __MASK(r, -128);
+	exitcode = __ASHR(r, 8);
+	if (exitcode > 127) {
+		exitcode = exitcode - 256;
+	}
+	if (r != 0) {
+		Out_String(title, title__len);
+		Out_String(cmd, cmd__len);
+		Out_Ln();
+		Out_String((CHAR*)"-- failed: status ", 19);
+		Out_Int(status, 1);
+		Out_String((CHAR*)", exitcode ", 12);
+		Out_Int(exitcode, 1);
+		Out_String((CHAR*)".", 2);
+		Out_Ln();
+		if ((status == 0 && exitcode == 127)) {
+			Out_String((CHAR*)"Is the C compiler in the current command path\?", 47);
+			Out_Ln();
+		}
+		if (status != 0) {
+			Modules_Halt(status);
+		} else {
+			Modules_Halt(exitcode);
+		}
+	}
+	__DEL(title);
+	__DEL(cmd);
+}
+
+static void extTools_InitialiseCompilerCommand (CHAR *s, ADDRESS s__len, CHAR *additionalopts, ADDRESS additionalopts__len)
+{
+	__DUP(additionalopts, additionalopts__len, CHAR);
+	__COPY("gcc -fPIC -g -Wno-stringop-overflow", s, s__len);
+	Strings_Append((CHAR*)" -I \"", 6, (void*)s, s__len);
+	Strings_Append(OPM_ResourceDir, 1024, (void*)s, s__len);
+	Strings_Append((CHAR*)"/include\" ", 11, (void*)s, s__len);
+	Strings_Append(additionalopts, additionalopts__len, (void*)s, s__len);
+	Strings_Append((CHAR*)" ", 2, (void*)s, s__len);
+	Platform_GetEnv((CHAR*)"CFLAGS", 7, (void*)extTools_CFLAGS, 4096);
+	Strings_Append(extTools_CFLAGS, 4096, (void*)s, s__len);
+	Strings_Append((CHAR*)" ", 2, (void*)s, s__len);
+	__DEL(additionalopts);
+}
+
+void extTools_Assemble (CHAR *moduleName, ADDRESS moduleName__len)
+{
+	extTools_CommandString cmd;
+	__DUP(moduleName, moduleName__len, CHAR);
+	extTools_InitialiseCompilerCommand((void*)cmd, 4096, (CHAR*)"", 1);
+	Strings_Append((CHAR*)"-c ", 4, (void*)cmd, 4096);
+	Strings_Append(moduleName, moduleName__len, (void*)cmd, 4096);
+	Strings_Append((CHAR*)".c", 3, (void*)cmd, 4096);
+	extTools_execute((CHAR*)"C compile: ", 12, cmd, 4096);
+	__DEL(moduleName);
+}
+
+void extTools_LinkMain (CHAR *moduleName, ADDRESS moduleName__len, BOOLEAN statically, CHAR *additionalopts, ADDRESS additionalopts__len)
+{
+	extTools_CommandString cmd;
+	__DUP(additionalopts, additionalopts__len, CHAR);
+	extTools_InitialiseCompilerCommand((void*)cmd, 4096, additionalopts, additionalopts__len);
+	Strings_Append(moduleName, moduleName__len, (void*)cmd, 4096);
+	Strings_Append((CHAR*)".c ", 4, (void*)cmd, 4096);
+	if (statically) {
+		Strings_Append((CHAR*)" -static", 9, (void*)cmd, 4096);
+	}
+	Strings_Append((CHAR*)" -o ", 5, (void*)cmd, 4096);
+	Strings_Append(moduleName, moduleName__len, (void*)cmd, 4096);
+	if (!statically || 1) {
+		Strings_Append((CHAR*)" -L\"", 5, (void*)cmd, 4096);
+		Strings_Append(OPM_InstallDir, 1024, (void*)cmd, 4096);
+		Strings_Append((CHAR*)"/lib\"", 6, (void*)cmd, 4096);
+		Strings_Append((CHAR*)" -lvoc", 7, (void*)cmd, 4096);
+		Strings_Append((CHAR*)"-O", 3, (void*)cmd, 4096);
+		Strings_Append(OPM_Model, 10, (void*)cmd, 4096);
+		Strings_Append((CHAR*)"", 1, (void*)cmd, 4096);
+	}
+	extTools_execute((CHAR*)"C compile and link: ", 21, cmd, 4096);
+	__DEL(additionalopts);
+}
+
+
+export void *extTools__init(void)
+{
+	__DEFMOD;
+	__MODULE_IMPORT(Configuration);
+	__MODULE_IMPORT(Heap);
+	__MODULE_IMPORT(Modules);
+	__MODULE_IMPORT(OPM);
+	__MODULE_IMPORT(Out);
+	__MODULE_IMPORT(Platform);
+	__MODULE_IMPORT(Strings);
+	__REGMOD("extTools", 0);
+/* BEGIN */
+	__ENDMOD;
+}

bootstrap/unix-48/extTools.h

@@ -0,0 +1,16 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef extTools__h
+#define extTools__h
+
+#include "SYSTEM.h"
+
+
+
+
+import void extTools_Assemble (CHAR *moduleName, ADDRESS moduleName__len);
+import void extTools_LinkMain (CHAR *moduleName, ADDRESS moduleName__len, BOOLEAN statically, CHAR *additionalopts, ADDRESS additionalopts__len);
+import void *extTools__init(void);
+
+
+#endif // extTools

bootstrap/unix-88/Compiler.c

@@ -0,0 +1,213 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspamS */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "Configuration.h"
+#include "Heap.h"
+#include "OPB.h"
+#include "OPC.h"
+#include "OPM.h"
+#include "OPP.h"
+#include "OPT.h"
+#include "OPV.h"
+#include "Platform.h"
+#include "Strings.h"
+#include "VT100.h"
+#include "extTools.h"
+
+
+
+
+static void Compiler_FindLocalObjectFiles (CHAR *objectnames, ADDRESS objectnames__len);
+export void Compiler_Module (BOOLEAN *done);
+static void Compiler_PropagateElementaryTypeSizes (void);
+export void Compiler_Translate (void);
+static void Compiler_Trap (INT32 sig);
+
+
+void Compiler_Module (BOOLEAN *done)
+{
+	BOOLEAN ext, new;
+	OPT_Node p = NIL;
+	OPP_Module(&p, OPM_Options);
+	if (OPM_noerr) {
+		OPV_Init();
+		OPT_InitRecno();
+		OPV_AdrAndSize(OPT_topScope);
+		OPT_Export(&ext, &new);
+		if (OPM_noerr) {
+			OPM_OpenFiles((void*)OPT_SelfName, 256);
+			OPM_DeleteObj((void*)OPT_SelfName, 256);
+			OPC_Init();
+			OPV_Module(p);
+			if (OPM_noerr) {
+				if ((__IN(10, OPM_Options, 32) && __STRCMP(OPM_modName, "SYSTEM") != 0)) {
+					OPM_DeleteSym((void*)OPT_SelfName, 256);
+					OPM_LogVT100((CHAR*)"32m", 4);
+					OPM_LogWStr((CHAR*)"  Main program.", 16);
+					OPM_LogVT100((CHAR*)"0m", 3);
+				} else {
+					if (new) {
+						OPM_LogVT100((CHAR*)"32m", 4);
+						OPM_LogWStr((CHAR*)"  New symbol file.", 19);
+						OPM_LogVT100((CHAR*)"0m", 3);
+						OPM_RegisterNewSym();
+					} else if (ext) {
+						OPM_LogWStr((CHAR*)"  Extended symbol file.", 24);
+						OPM_RegisterNewSym();
+					}
+				}
+			} else {
+				OPM_DeleteSym((void*)OPT_SelfName, 256);
+			}
+		}
+	}
+	OPM_CloseFiles();
+	OPT_Close();
+	OPM_LogWLn();
+	*done = OPM_noerr;
+}
+
+static void Compiler_PropagateElementaryTypeSizes (void)
+{
+	OPT_Struct adrinttyp = NIL;
+	OPT_sysptrtyp->size = OPM_AddressSize;
+	OPT_sysptrtyp->idfp = OPT_sysptrtyp->form;
+	OPM_FPrint(&OPT_sysptrtyp->idfp, OPT_sysptrtyp->size);
+	OPT_adrtyp->size = OPM_AddressSize;
+	OPT_adrtyp->idfp = OPT_adrtyp->form;
+	OPM_FPrint(&OPT_adrtyp->idfp, OPT_adrtyp->size);
+	adrinttyp = OPT_IntType(OPM_AddressSize);
+	OPT_adrtyp->strobj = adrinttyp->strobj;
+	OPT_sinttyp = OPT_IntType(OPM_ShortintSize);
+	OPT_inttyp = OPT_IntType(OPM_IntegerSize);
+	OPT_linttyp = OPT_IntType(OPM_LongintSize);
+	OPT_sintobj->typ = OPT_sinttyp;
+	OPT_intobj->typ = OPT_inttyp;
+	OPT_lintobj->typ = OPT_linttyp;
+	switch (OPM_SetSize) {
+		case 4: 
+			OPT_settyp = OPT_set32typ;
+			break;
+		default: 
+			OPT_settyp = OPT_set64typ;
+			break;
+	}
+	OPT_setobj->typ = OPT_settyp;
+	if (__STRCMP(OPM_Model, "C") == 0) {
+		OPT_cpbytetyp->strobj->name[4] = 0x00;
+	} else {
+		OPT_cpbytetyp->strobj->name[4] = '@';
+	}
+}
+
+static void Compiler_FindLocalObjectFiles (CHAR *objectnames, ADDRESS objectnames__len)
+{
+	OPT_Link l = NIL;
+	CHAR fn[64];
+	Platform_FileIdentity id;
+	objectnames[0] = 0x00;
+	l = OPT_Links;
+	while (l != NIL) {
+		__COPY(l->name, fn, 64);
+		Strings_Append((CHAR*)".sym", 5, (void*)fn, 64);
+		if (Platform_IdentifyByName(fn, 64, &id, Platform_FileIdentity__typ) == 0) {
+			__COPY(l->name, fn, 64);
+			Strings_Append((CHAR*)".o", 3, (void*)fn, 64);
+			if (Platform_IdentifyByName(fn, 64, &id, Platform_FileIdentity__typ) == 0) {
+				Strings_Append((CHAR*)" ", 2, (void*)objectnames, objectnames__len);
+				Strings_Append(fn, 64, (void*)objectnames, objectnames__len);
+			} else {
+				OPM_LogVT100((CHAR*)"91m", 4);
+				OPM_LogWStr((CHAR*)"Link warning: a local symbol file is present for module ", 57);
+				OPM_LogWStr(l->name, 256);
+				OPM_LogWStr((CHAR*)", but local object file '", 26);
+				OPM_LogWStr(fn, 64);
+				OPM_LogWStr((CHAR*)"' is missing.", 14);
+				OPM_LogVT100((CHAR*)"0m", 3);
+				OPM_LogWLn();
+			}
+		}
+		l = l->next;
+	}
+}
+
+void Compiler_Translate (void)
+{
+	BOOLEAN done;
+	CHAR linkfiles[2048];
+	if (OPM_OpenPar()) {
+		for (;;) {
+			OPM_Init(&done);
+			if (!done) {
+				return;
+			}
+			OPM_InitOptions();
+			Compiler_PropagateElementaryTypeSizes();
+			Heap_GC(0);
+			Compiler_Module(&done);
+			if (!done) {
+				OPM_LogWLn();
+				OPM_LogWStr((CHAR*)"Module compilation failed.", 27);
+				OPM_LogWLn();
+				Platform_Exit(1);
+			}
+			if (!__IN(13, OPM_Options, 32)) {
+				if (__IN(14, OPM_Options, 32)) {
+					extTools_Assemble(OPM_modName, 32);
+				} else {
+					if (!__IN(10, OPM_Options, 32)) {
+						extTools_Assemble(OPM_modName, 32);
+					} else {
+						Compiler_FindLocalObjectFiles((void*)linkfiles, 2048);
+						extTools_LinkMain((void*)OPM_modName, 32, __IN(15, OPM_Options, 32), linkfiles, 2048);
+					}
+				}
+			}
+		}
+	}
+}
+
+static void Compiler_Trap (INT32 sig)
+{
+	Heap_FINALL();
+	if (sig == 3) {
+		Platform_Exit(0);
+	} else {
+		if (sig == 4) {
+			OPM_LogWStr((CHAR*)" --- Oberon compiler internal error", 36);
+			OPM_LogWLn();
+		}
+		Platform_Exit(2);
+	}
+}
+
+
+export int main(int argc, char **argv)
+{
+	__INIT(argc, argv);
+	__MODULE_IMPORT(Configuration);
+	__MODULE_IMPORT(Heap);
+	__MODULE_IMPORT(OPB);
+	__MODULE_IMPORT(OPC);
+	__MODULE_IMPORT(OPM);
+	__MODULE_IMPORT(OPP);
+	__MODULE_IMPORT(OPT);
+	__MODULE_IMPORT(OPV);
+	__MODULE_IMPORT(Platform);
+	__MODULE_IMPORT(Strings);
+	__MODULE_IMPORT(VT100);
+	__MODULE_IMPORT(extTools);
+	__REGMAIN("Compiler", 0);
+	__REGCMD("Translate", Compiler_Translate);
+/* BEGIN */
+	Platform_SetInterruptHandler(Compiler_Trap);
+	Platform_SetQuitHandler(Compiler_Trap);
+	Platform_SetBadInstructionHandler(Compiler_Trap);
+	Compiler_Translate();
+	__FINI;
+}

bootstrap/unix-88/Configuration.c

@@ -0,0 +1,24 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+
+
+export CHAR Configuration_versionLong[76];
+
+
+
+
+
+export void *Configuration__init(void)
+{
+	__DEFMOD;
+	__REGMOD("Configuration", 0);
+/* BEGIN */
+	__MOVE("2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8.", Configuration_versionLong, 76);
+	__ENDMOD;
+}

bootstrap/unix-88/Configuration.h

@@ -0,0 +1,15 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Configuration__h
+#define Configuration__h
+
+#include "SYSTEM.h"
+
+
+import CHAR Configuration_versionLong[76];
+
+
+import void *Configuration__init(void);
+
+
+#endif // Configuration

bootstrap/unix-88/Files.h

@@ -0,0 +1,71 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Files__h
+#define Files__h
+
+#include "SYSTEM.h"
+
+typedef
+	struct Files_FileDesc *Files_File;
+
+typedef
+	struct Files_FileDesc {
+		INT64 _prvt0;
+		char _prvt1[584];
+	} Files_FileDesc;
+
+typedef
+	struct Files_Rider {
+		INT32 res;
+		BOOLEAN eof;
+		INT64 _prvt0;
+		char _prvt1[8];
+	} Files_Rider;
+
+
+import INT16 Files_MaxPathLength, Files_MaxNameLength;
+
+import ADDRESS *Files_FileDesc__typ;
+import ADDRESS *Files_Rider__typ;
+
+import Files_File Files_Base (Files_Rider *r, ADDRESS *r__typ);
+import void Files_ChangeDirectory (CHAR *path, ADDRESS path__len, INT16 *res);
+import void Files_Close (Files_File f);
+import void Files_Delete (CHAR *name, ADDRESS name__len, INT16 *res);
+import void Files_GetDate (Files_File f, INT32 *t, INT32 *d);
+import void Files_GetName (Files_File f, CHAR *name, ADDRESS name__len);
+import INT32 Files_Length (Files_File f);
+import Files_File Files_New (CHAR *name, ADDRESS name__len);
+import Files_File Files_Old (CHAR *name, ADDRESS name__len);
+import INT32 Files_Pos (Files_Rider *r, ADDRESS *r__typ);
+import void Files_Purge (Files_File f);
+import void Files_Read (Files_Rider *r, ADDRESS *r__typ, SYSTEM_BYTE *x);
+import void Files_ReadBool (Files_Rider *R, ADDRESS *R__typ, BOOLEAN *x);
+import void Files_ReadByte (Files_Rider *r, ADDRESS *r__typ, SYSTEM_BYTE *x);
+import void Files_ReadBytes (Files_Rider *r, ADDRESS *r__typ, SYSTEM_BYTE *x, ADDRESS x__len, INT32 n);
+import void Files_ReadInt (Files_Rider *R, ADDRESS *R__typ, INT16 *x);
+import void Files_ReadLInt (Files_Rider *R, ADDRESS *R__typ, INT32 *x);
+import void Files_ReadLReal (Files_Rider *R, ADDRESS *R__typ, LONGREAL *x);
+import void Files_ReadLine (Files_Rider *R, ADDRESS *R__typ, CHAR *x, ADDRESS x__len);
+import void Files_ReadNum (Files_Rider *R, ADDRESS *R__typ, SYSTEM_BYTE *x, ADDRESS x__len);
+import void Files_ReadReal (Files_Rider *R, ADDRESS *R__typ, REAL *x);
+import void Files_ReadSet (Files_Rider *R, ADDRESS *R__typ, UINT32 *x);
+import void Files_ReadString (Files_Rider *R, ADDRESS *R__typ, CHAR *x, ADDRESS x__len);
+import void Files_Register (Files_File f);
+import void Files_Rename (CHAR *old, ADDRESS old__len, CHAR *new, ADDRESS new__len, INT16 *res);
+import void Files_Set (Files_Rider *r, ADDRESS *r__typ, Files_File f, INT32 pos);
+import void Files_SetSearchPath (CHAR *path, ADDRESS path__len);
+import void Files_Write (Files_Rider *r, ADDRESS *r__typ, SYSTEM_BYTE x);
+import void Files_WriteBool (Files_Rider *R, ADDRESS *R__typ, BOOLEAN x);
+import void Files_WriteBytes (Files_Rider *r, ADDRESS *r__typ, SYSTEM_BYTE *x, ADDRESS x__len, INT32 n);
+import void Files_WriteInt (Files_Rider *R, ADDRESS *R__typ, INT16 x);
+import void Files_WriteLInt (Files_Rider *R, ADDRESS *R__typ, INT32 x);
+import void Files_WriteLReal (Files_Rider *R, ADDRESS *R__typ, LONGREAL x);
+import void Files_WriteNum (Files_Rider *R, ADDRESS *R__typ, INT64 x);
+import void Files_WriteReal (Files_Rider *R, ADDRESS *R__typ, REAL x);
+import void Files_WriteSet (Files_Rider *R, ADDRESS *R__typ, UINT32 x);
+import void Files_WriteString (Files_Rider *R, ADDRESS *R__typ, CHAR *x, ADDRESS x__len);
+import void *Files__init(void);
+
+
+#endif // Files

bootstrap/unix-88/Heap.c

@@ -0,0 +1,799 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. rtsSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+
+struct Heap__1 {
+	CHAR ch;
+	SYSTEM_PTR p;
+};
+
+typedef
+	struct Heap_CmdDesc *Heap_Cmd;
+
+typedef
+	CHAR Heap_CmdName[24];
+
+typedef
+	void (*Heap_Command)(void);
+
+typedef
+	struct Heap_CmdDesc {
+		Heap_Cmd next;
+		Heap_CmdName name;
+		Heap_Command cmd;
+	} Heap_CmdDesc;
+
+typedef
+	void (*Heap_EnumProc)(void(*)(SYSTEM_PTR));
+
+typedef
+	struct Heap_FinDesc *Heap_FinNode;
+
+typedef
+	void (*Heap_Finalizer)(SYSTEM_PTR);
+
+typedef
+	struct Heap_FinDesc {
+		Heap_FinNode next;
+		INT64 obj;
+		BOOLEAN marked;
+		Heap_Finalizer finalize;
+	} Heap_FinDesc;
+
+typedef
+	struct Heap_ModuleDesc *Heap_Module;
+
+typedef
+	CHAR Heap_ModuleName[20];
+
+typedef
+	struct Heap_ModuleDesc {
+		Heap_Module next;
+		Heap_ModuleName name;
+		INT32 refcnt;
+		Heap_Cmd cmds;
+		INT64 types;
+		Heap_EnumProc enumPtrs;
+		INT32 reserved1, reserved2;
+	} Heap_ModuleDesc;
+
+
+export SYSTEM_PTR Heap_modules;
+static INT64 Heap_freeList[10];
+static INT64 Heap_bigBlocks;
+export INT64 Heap_allocated;
+static BOOLEAN Heap_firstTry;
+static INT16 Heap_ldUnit;
+export INT64 Heap_heap;
+static INT64 Heap_heapMin, Heap_heapMax;
+export INT64 Heap_heapsize, Heap_heapMinExpand;
+static Heap_FinNode Heap_fin;
+static INT16 Heap_lockdepth;
+static BOOLEAN Heap_interrupted;
+export INT16 Heap_FileCount;
+
+export ADDRESS *Heap_ModuleDesc__typ;
+export ADDRESS *Heap_CmdDesc__typ;
+export ADDRESS *Heap_FinDesc__typ;
+export ADDRESS *Heap__1__typ;
+
+static void Heap_CheckFin (void);
+static void Heap_ExtendHeap (INT64 blksz);
+export void Heap_FINALL (void);
+static void Heap_Finalize (void);
+export INT32 Heap_FreeModule (CHAR *name, ADDRESS name__len);
+export void Heap_GC (BOOLEAN markStack);
+static void Heap_HeapSort (INT32 n, INT64 *a, ADDRESS a__len);
+export void Heap_INCREF (Heap_Module m);
+export void Heap_InitHeap (void);
+export void Heap_Lock (void);
+static void Heap_Mark (INT64 q);
+static void Heap_MarkCandidates (INT32 n, INT64 *cand, ADDRESS cand__len);
+static void Heap_MarkP (SYSTEM_PTR p);
+static void Heap_MarkStack (INT64 n, INT64 *cand, ADDRESS cand__len);
+export SYSTEM_PTR Heap_NEWBLK (INT64 size);
+export SYSTEM_PTR Heap_NEWREC (INT64 tag);
+static INT64 Heap_NewChunk (INT64 blksz);
+export void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd);
+export SYSTEM_PTR Heap_REGMOD (Heap_ModuleName name, Heap_EnumProc enumPtrs);
+export void Heap_REGTYP (Heap_Module m, INT64 typ);
+export void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize);
+static void Heap_Scan (void);
+static void Heap_Sift (INT32 l, INT32 r, INT64 *a, ADDRESS a__len);
+export void Heap_Unlock (void);
+
+extern void *Heap__init();
+extern ADDRESS Modules_MainStackFrame;
+extern ADDRESS Platform_OSAllocate(ADDRESS size);
+#define Heap_HeapModuleInit()	Heap__init()
+#define Heap_ModulesHalt(code)	Modules_Halt(code)
+#define Heap_ModulesMainStackFrame()	Modules_MainStackFrame
+#define Heap_OSAllocate(size)	Platform_OSAllocate(size)
+#define Heap_uLE(x, y)	((size_t)x <= (size_t)y)
+#define Heap_uLT(x, y)	((size_t)x <  (size_t)y)
+
+void Heap_Lock (void)
+{
+	Heap_lockdepth += 1;
+}
+
+void Heap_Unlock (void)
+{
+	Heap_lockdepth -= 1;
+	if ((Heap_interrupted && Heap_lockdepth == 0)) {
+		Heap_ModulesHalt(-9);
+	}
+}
+
+SYSTEM_PTR Heap_REGMOD (Heap_ModuleName name, Heap_EnumProc enumPtrs)
+{
+	Heap_Module m;
+	if (__STRCMP(name, "Heap") == 0) {
+		__SYSNEW(m, 64);
+	} else {
+		__NEW(m, Heap_ModuleDesc);
+	}
+	m->types = 0;
+	m->cmds = NIL;
+	__COPY(name, m->name, 20);
+	m->refcnt = 0;
+	m->enumPtrs = enumPtrs;
+	m->next = (Heap_Module)(ADDRESS)Heap_modules;
+	Heap_modules = (SYSTEM_PTR)m;
+	return (void*)m;
+}
+
+INT32 Heap_FreeModule (CHAR *name, ADDRESS name__len)
+{
+	Heap_Module m, p;
+	__DUP(name, name__len, CHAR);
+	m = (Heap_Module)(ADDRESS)Heap_modules;
+	while ((m != NIL && __STRCMP(m->name, name) != 0)) {
+		p = m;
+		m = m->next;
+	}
+	if ((m != NIL && m->refcnt == 0)) {
+		if (m == (Heap_Module)(ADDRESS)Heap_modules) {
+			Heap_modules = (SYSTEM_PTR)m->next;
+		} else {
+			p->next = m->next;
+		}
+		__DEL(name);
+		return 0;
+	} else {
+		if (m == NIL) {
+			__DEL(name);
+			return -1;
+		} else {
+			__DEL(name);
+			return m->refcnt;
+		}
+	}
+	__RETCHK;
+}
+
+void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd)
+{
+	Heap_Cmd c;
+	if (__STRCMP(m->name, "Heap") == 0) {
+		__SYSNEW(c, 40);
+	} else {
+		__NEW(c, Heap_CmdDesc);
+	}
+	__COPY(name, c->name, 24);
+	c->cmd = cmd;
+	c->next = m->cmds;
+	m->cmds = c;
+}
+
+void Heap_REGTYP (Heap_Module m, INT64 typ)
+{
+	__PUT(typ, m->types, INT64);
+	m->types = typ;
+}
+
+void Heap_INCREF (Heap_Module m)
+{
+	m->refcnt += 1;
+}
+
+static INT64 Heap_NewChunk (INT64 blksz)
+{
+	INT64 chnk, blk, end;
+	chnk = Heap_OSAllocate(blksz + 24);
+	if (chnk != 0) {
+		blk = chnk + 24;
+		end = blk + blksz;
+		__PUT(chnk + 8, end, INT64);
+		__PUT(blk, blk + 8, INT64);
+		__PUT(blk + 8, blksz, INT64);
+		__PUT(blk + 16, -8, INT64);
+		__PUT(blk + 24, Heap_bigBlocks, INT64);
+		Heap_bigBlocks = blk;
+		Heap_heapsize += blksz;
+		if (Heap_uLT(blk + 8, Heap_heapMin)) {
+			Heap_heapMin = blk + 8;
+		}
+		if (Heap_uLT(Heap_heapMax, end)) {
+			Heap_heapMax = end;
+		}
+	}
+	return chnk;
+}
+
+static void Heap_ExtendHeap (INT64 blksz)
+{
+	INT64 size, chnk, j, next;
+		if (Heap_uLT(Heap_heapMinExpand, blksz)) {
+		size = blksz;
+	} else {
+		size = Heap_heapMinExpand;
+	}
+	chnk = Heap_NewChunk(size);
+	if (chnk != 0) {
+		if (Heap_uLT(chnk, Heap_heap)) {
+			__PUT(chnk, Heap_heap, INT64);
+			Heap_heap = chnk;
+		} else {
+			j = Heap_heap;
+			__GET(j, next, INT64);
+			while ((next != 0 && Heap_uLT(next, chnk))) {
+				j = next;
+				__GET(j, next, INT64);
+			}
+			__PUT(chnk, next, INT64);
+			__PUT(j, chnk, INT64);
+		}
+	} else if (!Heap_firstTry) {
+		Heap_heapMinExpand = 32;
+	}
+}
+
+SYSTEM_PTR Heap_NEWREC (INT64 tag)
+{
+	INT64 i, i0, di, blksz, restsize, t, adr, end, next, prev;
+	SYSTEM_PTR new;
+	Heap_Lock();
+	__GET(tag, blksz, INT64);
+		i0 = __LSH(blksz, -Heap_ldUnit, 64);
+	i = i0;
+	if (i < 9) {
+		adr = Heap_freeList[i];
+		while (adr == 0) {
+			i += 1;
+			adr = Heap_freeList[i];
+		}
+	}
+	if (i < 9) {
+		__GET(adr + 24, next, INT64);
+		Heap_freeList[i] = next;
+		if (i != i0) {
+			di = i - i0;
+			restsize = __ASHL(di, 5);
+			end = adr + restsize;
+			__PUT(end + 8, blksz, INT64);
+			__PUT(end + 16, -8, INT64);
+			__PUT(end, end + 8, INT64);
+			__PUT(adr + 8, restsize, INT64);
+			__PUT(adr + 24, Heap_freeList[di], INT64);
+			Heap_freeList[di] = adr;
+			adr += restsize;
+		}
+	} else {
+		adr = Heap_bigBlocks;
+		prev = 0;
+		for (;;) {
+			if (adr == 0) {
+				if (Heap_firstTry) {
+					Heap_GC(1);
+					blksz += 32;
+					t = __LSH(Heap_allocated + blksz, -(2 + Heap_ldUnit), 64) * 160;
+					if (Heap_uLT(Heap_heapsize, t)) {
+						Heap_ExtendHeap(t - Heap_heapsize);
+					}
+					Heap_firstTry = 0;
+					new = Heap_NEWREC(tag);
+					if (new == NIL) {
+						Heap_ExtendHeap(blksz);
+						new = Heap_NEWREC(tag);
+					}
+					Heap_firstTry = 1;
+					Heap_Unlock();
+					return new;
+				} else {
+					Heap_Unlock();
+					return NIL;
+				}
+			}
+			__GET(adr + 8, t, INT64);
+			if (Heap_uLE(blksz, t)) {
+				break;
+			}
+			prev = adr;
+			__GET(adr + 24, adr, INT64);
+		}
+		restsize = t - blksz;
+		end = adr + restsize;
+		__PUT(end + 8, blksz, INT64);
+		__PUT(end + 16, -8, INT64);
+		__PUT(end, end + 8, INT64);
+		if (Heap_uLT(288, restsize)) {
+			__PUT(adr + 8, restsize, INT64);
+		} else {
+			__GET(adr + 24, next, INT64);
+			if (prev == 0) {
+				Heap_bigBlocks = next;
+			} else {
+				__PUT(prev + 24, next, INT64);
+			}
+			if (restsize != 0) {
+				di = __ASHR(restsize, 5);
+				__PUT(adr + 8, restsize, INT64);
+				__PUT(adr + 24, Heap_freeList[di], INT64);
+				Heap_freeList[di] = adr;
+			}
+		}
+		adr += restsize;
+	}
+	i = adr + 32;
+	end = adr + blksz;
+	while (Heap_uLT(i, end)) {
+		__PUT(i, 0, INT64);
+		__PUT(i + 8, 0, INT64);
+		__PUT(i + 16, 0, INT64);
+		__PUT(i + 24, 0, INT64);
+		i += 32;
+	}
+	__PUT(adr + 24, 0, INT64);
+	__PUT(adr, tag, INT64);
+	__PUT(adr + 8, 0, INT64);
+	__PUT(adr + 16, 0, INT64);
+	Heap_allocated += blksz;
+	Heap_Unlock();
+	return (SYSTEM_PTR)(ADDRESS)(adr + 8);
+}
+
+SYSTEM_PTR Heap_NEWBLK (INT64 size)
+{
+	INT64 blksz, tag;
+	SYSTEM_PTR new;
+	Heap_Lock();
+	blksz = __ASHL(__ASHR(size + 63, 5), 5);
+	new = Heap_NEWREC((ADDRESS)&blksz);
+	tag = ((INT64)(ADDRESS)new + blksz) - 24;
+	__PUT(tag - 8, 0, INT64);
+	__PUT(tag, blksz, INT64);
+	__PUT(tag + 8, -8, INT64);
+	__PUT((INT64)(ADDRESS)new - 8, tag, INT64);
+	Heap_Unlock();
+	return new;
+}
+
+static void Heap_Mark (INT64 q)
+{
+	INT64 p, tag, offset, fld, n, tagbits;
+	if (q != 0) {
+		__GET(q - 8, tagbits, INT64);
+		if (!__ODD(tagbits)) {
+			__PUT(q - 8, tagbits + 1, INT64);
+			p = 0;
+			tag = tagbits + 8;
+			for (;;) {
+				__GET(tag, offset, INT64);
+				if (offset < 0) {
+					__PUT(q - 8, (tag + offset) + 1, INT64);
+					if (p == 0) {
+						break;
+					}
+					n = q;
+					q = p;
+					__GET(q - 8, tag, INT64);
+					tag -= 1;
+					__GET(tag, offset, INT64);
+					fld = q + offset;
+					__GET(fld, p, INT64);
+					__PUT(fld, (SYSTEM_PTR)(ADDRESS)n, SYSTEM_PTR);
+				} else {
+					fld = q + offset;
+					__GET(fld, n, INT64);
+					if (n != 0) {
+						__GET(n - 8, tagbits, INT64);
+						if (!__ODD(tagbits)) {
+							__PUT(n - 8, tagbits + 1, INT64);
+							__PUT(q - 8, tag + 1, INT64);
+							__PUT(fld, (SYSTEM_PTR)(ADDRESS)p, SYSTEM_PTR);
+							p = q;
+							q = n;
+							tag = tagbits;
+						}
+					}
+				}
+				tag += 8;
+			}
+		}
+	}
+}
+
+static void Heap_MarkP (SYSTEM_PTR p)
+{
+	Heap_Mark((INT64)(ADDRESS)p);
+}
+
+static void Heap_Scan (void)
+{
+	INT64 chnk, adr, end, start, tag, i, size, freesize;
+	Heap_bigBlocks = 0;
+	i = 1;
+	while (i < 9) {
+		Heap_freeList[i] = 0;
+		i += 1;
+	}
+	freesize = 0;
+	Heap_allocated = 0;
+	chnk = Heap_heap;
+	while (chnk != 0) {
+		adr = chnk + 24;
+		__GET(chnk + 8, end, INT64);
+		while (Heap_uLT(adr, end)) {
+			__GET(adr, tag, INT64);
+			if (__ODD(tag)) {
+				if (freesize != 0) {
+					start = adr - freesize;
+					__PUT(start, start + 8, INT64);
+					__PUT(start + 8, freesize, INT64);
+					__PUT(start + 16, -8, INT64);
+					i = __LSH(freesize, -Heap_ldUnit, 64);
+					freesize = 0;
+					if (Heap_uLT(i, 9)) {
+						__PUT(start + 24, Heap_freeList[i], INT64);
+						Heap_freeList[i] = start;
+					} else {
+						__PUT(start + 24, Heap_bigBlocks, INT64);
+						Heap_bigBlocks = start;
+					}
+				}
+				tag -= 1;
+				__PUT(adr, tag, INT64);
+				__GET(tag, size, INT64);
+				Heap_allocated += size;
+				adr += size;
+			} else {
+				__GET(tag, size, INT64);
+				freesize += size;
+				adr += size;
+			}
+		}
+		if (freesize != 0) {
+			start = adr - freesize;
+			__PUT(start, start + 8, INT64);
+			__PUT(start + 8, freesize, INT64);
+			__PUT(start + 16, -8, INT64);
+			i = __LSH(freesize, -Heap_ldUnit, 64);
+			freesize = 0;
+			if (Heap_uLT(i, 9)) {
+				__PUT(start + 24, Heap_freeList[i], INT64);
+				Heap_freeList[i] = start;
+			} else {
+				__PUT(start + 24, Heap_bigBlocks, INT64);
+				Heap_bigBlocks = start;
+			}
+		}
+		__GET(chnk, chnk, INT64);
+	}
+}
+
+static void Heap_Sift (INT32 l, INT32 r, INT64 *a, ADDRESS a__len)
+{
+	INT32 i, j;
+	INT64 x;
+	j = l;
+	x = a[j];
+	for (;;) {
+		i = j;
+		j = __ASHL(j, 1) + 1;
+		if ((j < r && Heap_uLT(a[j], a[j + 1]))) {
+			j += 1;
+		}
+		if (j > r || Heap_uLE(a[j], x)) {
+			break;
+		}
+		a[i] = a[j];
+	}
+	a[i] = x;
+}
+
+static void Heap_HeapSort (INT32 n, INT64 *a, ADDRESS a__len)
+{
+	INT32 l, r;
+	INT64 x;
+	l = __ASHR(n, 1);
+	r = n - 1;
+	while (l > 0) {
+		l -= 1;
+		Heap_Sift(l, r, (void*)a, a__len);
+	}
+	while (r > 0) {
+		x = a[0];
+		a[0] = a[r];
+		a[r] = x;
+		r -= 1;
+		Heap_Sift(l, r, (void*)a, a__len);
+	}
+}
+
+static void Heap_MarkCandidates (INT32 n, INT64 *cand, ADDRESS cand__len)
+{
+	INT64 chnk, end, adr, tag, next, i, ptr, size;
+		chnk = Heap_heap;
+	i = 0;
+	while (chnk != 0) {
+		__GET(chnk + 8, end, INT64);
+		adr = chnk + 24;
+		while (Heap_uLT(adr, end)) {
+			__GET(adr, tag, INT64);
+			if (__ODD(tag)) {
+				__GET(tag - 1, size, INT64);
+				adr += size;
+				ptr = adr + 8;
+				while (Heap_uLT(cand[i], ptr)) {
+					i += 1;
+					if (i == (INT64)n) {
+						return;
+					}
+				}
+			} else {
+				__GET(tag, size, INT64);
+				ptr = adr + 8;
+				adr += size;
+				while (Heap_uLT(cand[i], ptr)) {
+					i += 1;
+					if (i == (INT64)n) {
+						return;
+					}
+				}
+				if (Heap_uLT(cand[i], adr)) {
+					Heap_Mark(ptr);
+				}
+			}
+			if (Heap_uLE(end, cand[i])) {
+				adr = end;
+			}
+		}
+		__GET(chnk, chnk, INT64);
+	}
+}
+
+static void Heap_CheckFin (void)
+{
+	Heap_FinNode n;
+	INT64 tag;
+	n = Heap_fin;
+	while (n != NIL) {
+		__GET(n->obj - 8, tag, INT64);
+		if (!__ODD(tag)) {
+			n->marked = 0;
+			Heap_Mark(n->obj);
+		} else {
+			n->marked = 1;
+		}
+		n = n->next;
+	}
+}
+
+static void Heap_Finalize (void)
+{
+	Heap_FinNode n, prev;
+	n = Heap_fin;
+	prev = NIL;
+	while (n != NIL) {
+		if (!n->marked) {
+			if (n == Heap_fin) {
+				Heap_fin = Heap_fin->next;
+			} else {
+				prev->next = n->next;
+			}
+			(*n->finalize)((SYSTEM_PTR)(ADDRESS)n->obj);
+			if (prev == NIL) {
+				n = Heap_fin;
+			} else {
+				n = n->next;
+			}
+		} else {
+			prev = n;
+			n = n->next;
+		}
+	}
+}
+
+void Heap_FINALL (void)
+{
+	Heap_FinNode n;
+	while (Heap_fin != NIL) {
+		n = Heap_fin;
+		Heap_fin = Heap_fin->next;
+		(*n->finalize)((SYSTEM_PTR)(ADDRESS)n->obj);
+	}
+}
+
+static void Heap_MarkStack (INT64 n, INT64 *cand, ADDRESS cand__len)
+{
+	SYSTEM_PTR frame;
+	INT32 nofcand;
+	INT64 inc, sp, p, stack0;
+	struct Heap__1 align;
+	if (n > 0) {
+		Heap_MarkStack(n - 1, cand, cand__len);
+		if (n > 100) {
+			return;
+		}
+	}
+	if (n == 0) {
+		nofcand = 0;
+		sp = (ADDRESS)&frame;
+		stack0 = Heap_ModulesMainStackFrame();
+		inc = (ADDRESS)&align.p - (ADDRESS)&align;
+		if (Heap_uLT(stack0, sp)) {
+			inc = -inc;
+		}
+		while (sp != stack0) {
+			__GET(sp, p, INT64);
+			if ((Heap_uLE(Heap_heapMin, p) && Heap_uLT(p, Heap_heapMax))) {
+				if (nofcand == cand__len) {
+					Heap_HeapSort(nofcand, (void*)cand, cand__len);
+					Heap_MarkCandidates(nofcand, (void*)cand, cand__len);
+					nofcand = 0;
+				}
+				cand[nofcand] = p;
+				nofcand += 1;
+			}
+			sp += inc;
+		}
+		if (nofcand > 0) {
+			Heap_HeapSort(nofcand, (void*)cand, cand__len);
+			Heap_MarkCandidates(nofcand, (void*)cand, cand__len);
+		}
+	}
+}
+
+void Heap_GC (BOOLEAN markStack)
+{
+	Heap_Module m;
+	INT64 i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14, i15, i16, i17, i18, i19, i20, i21, i22, i23;
+	INT64 cand[10000];
+	Heap_Lock();
+	m = (Heap_Module)(ADDRESS)Heap_modules;
+	while (m != NIL) {
+		if (m->enumPtrs != NIL) {
+			(*m->enumPtrs)(Heap_MarkP);
+		}
+		m = m->next;
+	}
+	if (markStack) {
+		i0 = -100;
+		i1 = -101;
+		i2 = -102;
+		i3 = -103;
+		i4 = -104;
+		i5 = -105;
+		i6 = -106;
+		i7 = -107;
+		i8 = 1;
+		i9 = 2;
+		i10 = 3;
+		i11 = 4;
+		i12 = 5;
+		i13 = 6;
+		i14 = 7;
+		i15 = 8;
+		i16 = 9;
+		i17 = 10;
+		i18 = 11;
+		i19 = 12;
+		i20 = 13;
+		i21 = 14;
+		i22 = 15;
+		i23 = 16;
+		for (;;) {
+			i0 += 1;
+			i1 += 2;
+			i2 += 3;
+			i3 += 4;
+			i4 += 5;
+			i5 += 6;
+			i6 += 7;
+			i7 += 8;
+			i8 += 9;
+			i9 += 10;
+			i10 += 11;
+			i11 += 12;
+			i12 += 13;
+			i13 += 14;
+			i14 += 15;
+			i15 += 16;
+			i16 += 17;
+			i17 += 18;
+			i18 += 19;
+			i19 += 20;
+			i20 += 21;
+			i21 += 22;
+			i22 += 23;
+			i23 += 24;
+			if ((i0 == -99 && i15 == 24)) {
+				Heap_MarkStack(32, (void*)cand, 10000);
+				break;
+			}
+		}
+		if (((((((((((((((((((((((i0 + i1) + i2) + i3) + i4) + i5) + i6) + i7) + i8) + i9) + i10) + i11) + i12) + i13) + i14) + i15) + i16) + i17) + i18) + i19) + i20) + i21) + i22) + i23 > 10000) {
+			return;
+		}
+	}
+	Heap_CheckFin();
+	Heap_Scan();
+	Heap_Finalize();
+	Heap_Unlock();
+}
+
+void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize)
+{
+	Heap_FinNode f;
+	__NEW(f, Heap_FinDesc);
+	f->obj = (INT64)(ADDRESS)obj;
+	f->finalize = finalize;
+	f->marked = 1;
+	f->next = Heap_fin;
+	Heap_fin = f;
+}
+
+void Heap_InitHeap (void)
+{
+	Heap_heap = 0;
+	Heap_heapsize = 0;
+	Heap_allocated = 0;
+	Heap_lockdepth = 0;
+	Heap_heapMin = -1;
+	Heap_heapMax = 0;
+	Heap_bigBlocks = 0;
+	Heap_heapMinExpand = 256000;
+	Heap_ldUnit = 5;
+	Heap_heap = Heap_NewChunk(256000);
+	__PUT(Heap_heap, 0, INT64);
+	Heap_firstTry = 1;
+	Heap_freeList[9] = 1;
+	Heap_FileCount = 0;
+	Heap_modules = NIL;
+	Heap_fin = NIL;
+	Heap_interrupted = 0;
+	Heap_HeapModuleInit();
+}
+
+static void EnumPtrs(void (*P)(void*))
+{
+	P(Heap_modules);
+	P(Heap_fin);
+}
+
+__TDESC(Heap_ModuleDesc, 1, 2) = {__TDFLDS("ModuleDesc", 64), {0, 32, -24}};
+__TDESC(Heap_CmdDesc, 1, 1) = {__TDFLDS("CmdDesc", 40), {0, -16}};
+__TDESC(Heap_FinDesc, 1, 1) = {__TDFLDS("FinDesc", 32), {0, -16}};
+__TDESC(Heap__1, 1, 1) = {__TDFLDS("", 16), {8, -16}};
+
+export void *Heap__init(void)
+{
+	__DEFMOD;
+	__REGMOD("Heap", EnumPtrs);
+	__REGCMD("FINALL", Heap_FINALL);
+	__REGCMD("InitHeap", Heap_InitHeap);
+	__REGCMD("Lock", Heap_Lock);
+	__REGCMD("Unlock", Heap_Unlock);
+	__INITYP(Heap_ModuleDesc, Heap_ModuleDesc, 0);
+	__INITYP(Heap_CmdDesc, Heap_CmdDesc, 0);
+	__INITYP(Heap_FinDesc, Heap_FinDesc, 0);
+	__INITYP(Heap__1, Heap__1, 0);
+/* BEGIN */
+	__ENDMOD;
+}

bootstrap/unix-88/Heap.h

@@ -0,0 +1,73 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. rtsSF */
+
+#ifndef Heap__h
+#define Heap__h
+
+#include "SYSTEM.h"
+
+typedef
+	struct Heap_CmdDesc *Heap_Cmd;
+
+typedef
+	CHAR Heap_CmdName[24];
+
+typedef
+	void (*Heap_Command)(void);
+
+typedef
+	struct Heap_CmdDesc {
+		Heap_Cmd next;
+		Heap_CmdName name;
+		Heap_Command cmd;
+	} Heap_CmdDesc;
+
+typedef
+	void (*Heap_EnumProc)(void(*)(SYSTEM_PTR));
+
+typedef
+	void (*Heap_Finalizer)(SYSTEM_PTR);
+
+typedef
+	struct Heap_ModuleDesc *Heap_Module;
+
+typedef
+	CHAR Heap_ModuleName[20];
+
+typedef
+	struct Heap_ModuleDesc {
+		Heap_Module next;
+		Heap_ModuleName name;
+		INT32 refcnt;
+		Heap_Cmd cmds;
+		INT64 types;
+		Heap_EnumProc enumPtrs;
+		char _prvt0[8];
+	} Heap_ModuleDesc;
+
+
+import SYSTEM_PTR Heap_modules;
+import INT64 Heap_allocated;
+import INT64 Heap_heap;
+import INT64 Heap_heapsize, Heap_heapMinExpand;
+import INT16 Heap_FileCount;
+
+import ADDRESS *Heap_ModuleDesc__typ;
+import ADDRESS *Heap_CmdDesc__typ;
+
+import void Heap_FINALL (void);
+import INT32 Heap_FreeModule (CHAR *name, ADDRESS name__len);
+import void Heap_GC (BOOLEAN markStack);
+import void Heap_INCREF (Heap_Module m);
+import void Heap_InitHeap (void);
+import void Heap_Lock (void);
+import SYSTEM_PTR Heap_NEWBLK (INT64 size);
+import SYSTEM_PTR Heap_NEWREC (INT64 tag);
+import void Heap_REGCMD (Heap_Module m, Heap_CmdName name, Heap_Command cmd);
+import SYSTEM_PTR Heap_REGMOD (Heap_ModuleName name, Heap_EnumProc enumPtrs);
+import void Heap_REGTYP (Heap_Module m, INT64 typ);
+import void Heap_RegisterFinalizer (SYSTEM_PTR obj, Heap_Finalizer finalize);
+import void Heap_Unlock (void);
+import void *Heap__init(void);
+
+
+#endif // Heap

bootstrap/unix-88/Modules.c

@@ -0,0 +1,506 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#define SHORTINT INT8
+#define INTEGER  INT16
+#define LONGINT  INT32
+#define SET      UINT32
+
+#include "SYSTEM.h"
+#include "Heap.h"
+#include "Platform.h"
+
+
+export INT16 Modules_res;
+export CHAR Modules_resMsg[256];
+export Heap_ModuleName Modules_imported, Modules_importing;
+export INT64 Modules_MainStackFrame;
+export INT16 Modules_ArgCount;
+export INT64 Modules_ArgVector;
+export CHAR Modules_BinaryDir[1024];
+
+
+static void Modules_Append (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len);
+static void Modules_AppendPart (CHAR c, CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len);
+export INT16 Modules_ArgPos (CHAR *s, ADDRESS s__len);
+export void Modules_AssertFail (INT32 code);
+static void Modules_Canonify (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len);
+static INT16 Modules_CharCount (CHAR *s, ADDRESS s__len);
+static void Modules_DisplayHaltCode (INT32 code);
+static void Modules_ExtractPart (CHAR *s, ADDRESS s__len, INT16 *i, CHAR *p, ADDRESS p__len, CHAR *d, ADDRESS d__len);
+static void Modules_FindBinaryDir (CHAR *binarydir, ADDRESS binarydir__len);
+export void Modules_Free (CHAR *name, ADDRESS name__len, BOOLEAN all);
+export void Modules_GetArg (INT16 n, CHAR *val, ADDRESS val__len);
+export void Modules_GetIntArg (INT16 n, INT32 *val);
+export void Modules_Halt (INT32 code);
+export void Modules_Init (INT32 argc, INT64 argvadr);
+static BOOLEAN Modules_IsAbsolute (CHAR *d, ADDRESS d__len);
+static BOOLEAN Modules_IsFilePresent (CHAR *s, ADDRESS s__len);
+static BOOLEAN Modules_IsOneOf (CHAR c, CHAR *s, ADDRESS s__len);
+export Heap_Command Modules_ThisCommand (Heap_Module mod, CHAR *name, ADDRESS name__len);
+export Heap_Module Modules_ThisMod (CHAR *name, ADDRESS name__len);
+static void Modules_Trim (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len);
+static void Modules_errch (CHAR c);
+static void Modules_errint (INT32 l);
+static void Modules_errstring (CHAR *s, ADDRESS s__len);
+
+extern void Heap_InitHeap();
+extern void *Modules__init(void);
+#define Modules_InitHeap()	Heap_InitHeap()
+#define Modules_ModulesInit()	Modules__init()
+#define Modules_modules()	(Heap_Module)Heap_modules
+
+void Modules_Init (INT32 argc, INT64 argvadr)
+{
+	Modules_MainStackFrame = argvadr;
+	Modules_ArgCount = __VAL(INT16, argc);
+	__GET(argvadr, Modules_ArgVector, INT64);
+	Modules_InitHeap();
+	Modules_ModulesInit();
+}
+
+typedef
+	CHAR (*argptr__15)[1024];
+
+void Modules_GetArg (INT16 n, CHAR *val, ADDRESS val__len)
+{
+	argptr__15 arg = NIL;
+	if (n < Modules_ArgCount) {
+		__GET(Modules_ArgVector + (INT64)__ASHL(n, 3), arg, argptr__15);
+		__COPY(*arg, val, val__len);
+	}
+}
+
+void Modules_GetIntArg (INT16 n, INT32 *val)
+{
+	CHAR s[64];
+	INT32 k, d, i;
+	s[0] = 0x00;
+	Modules_GetArg(n, (void*)s, 64);
+	i = 0;
+	if (s[0] == '-') {
+		i = 1;
+	}
+	k = 0;
+	d = (INT16)s[__X(i, 64)] - 48;
+	while ((d >= 0 && d <= 9)) {
+		k = k * 10 + d;
+		i += 1;
+		d = (INT16)s[__X(i, 64)] - 48;
+	}
+	if (s[0] == '-') {
+		k = -k;
+		i -= 1;
+	}
+	if (i > 0) {
+		*val = k;
+	}
+}
+
+INT16 Modules_ArgPos (CHAR *s, ADDRESS s__len)
+{
+	INT16 i;
+	CHAR arg[256];
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	Modules_GetArg(i, (void*)arg, 256);
+	while ((i < Modules_ArgCount && __STRCMP(s, arg) != 0)) {
+		i += 1;
+		Modules_GetArg(i, (void*)arg, 256);
+	}
+	__DEL(s);
+	return i;
+}
+
+static INT16 Modules_CharCount (CHAR *s, ADDRESS s__len)
+{
+	INT16 i;
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	while ((i < s__len && s[__X(i, s__len)] != 0x00)) {
+		i += 1;
+	}
+	__DEL(s);
+	return i;
+}
+
+static void Modules_Append (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len)
+{
+	INT16 i, j;
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	j = Modules_CharCount(d, d__len);
+	while (s[__X(i, s__len)] != 0x00) {
+		d[__X(j, d__len)] = s[__X(i, s__len)];
+		i += 1;
+		j += 1;
+	}
+	d[__X(j, d__len)] = 0x00;
+	__DEL(s);
+}
+
+static void Modules_AppendPart (CHAR c, CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len)
+{
+	INT16 i, j;
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	j = Modules_CharCount(d, d__len);
+	if ((j > 0 && d[__X(j - 1, d__len)] != c)) {
+		d[__X(j, d__len)] = c;
+		j += 1;
+	}
+	while (s[__X(i, s__len)] != 0x00) {
+		d[__X(j, d__len)] = s[__X(i, s__len)];
+		i += 1;
+		j += 1;
+	}
+	d[__X(j, d__len)] = 0x00;
+	__DEL(s);
+}
+
+static BOOLEAN Modules_IsOneOf (CHAR c, CHAR *s, ADDRESS s__len)
+{
+	INT16 i;
+	__DUP(s, s__len, CHAR);
+	if (c == 0x00) {
+		__DEL(s);
+		return 0;
+	}
+	i = 0;
+	while ((s[__X(i, s__len)] != c && s[__X(i, s__len)] != 0x00)) {
+		i += 1;
+	}
+	__DEL(s);
+	return s[__X(i, s__len)] == c;
+}
+
+static BOOLEAN Modules_IsAbsolute (CHAR *d, ADDRESS d__len)
+{
+	__DUP(d, d__len, CHAR);
+	if (d[0] == 0x00) {
+		__DEL(d);
+		return 0;
+	}
+	if (Modules_IsOneOf(d[0], (CHAR*)"/\\", 3)) {
+		__DEL(d);
+		return 1;
+	}
+	if (d[__X(1, d__len)] == ':') {
+		__DEL(d);
+		return 1;
+	}
+	__DEL(d);
+	return 0;
+}
+
+static void Modules_Canonify (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len)
+{
+	__DUP(s, s__len, CHAR);
+	if (Modules_IsAbsolute(s, s__len)) {
+		__COPY(s, d, d__len);
+	} else {
+		__COPY(Platform_CWD, d, d__len);
+		Modules_AppendPart('/', s, s__len, (void*)d, d__len);
+	}
+	__DEL(s);
+}
+
+static BOOLEAN Modules_IsFilePresent (CHAR *s, ADDRESS s__len)
+{
+	Platform_FileIdentity identity;
+	__DUP(s, s__len, CHAR);
+	__DEL(s);
+	return Platform_IdentifyByName(s, s__len, &identity, Platform_FileIdentity__typ) == 0;
+}
+
+static void Modules_ExtractPart (CHAR *s, ADDRESS s__len, INT16 *i, CHAR *p, ADDRESS p__len, CHAR *d, ADDRESS d__len)
+{
+	INT16 j;
+	__DUP(s, s__len, CHAR);
+	__DUP(p, p__len, CHAR);
+	j = 0;
+	while ((s[__X(*i, s__len)] != 0x00 && !Modules_IsOneOf(s[__X(*i, s__len)], p, p__len))) {
+		d[__X(j, d__len)] = s[__X(*i, s__len)];
+		*i += 1;
+		j += 1;
+	}
+	d[__X(j, d__len)] = 0x00;
+	while (Modules_IsOneOf(s[__X(*i, s__len)], p, p__len)) {
+		*i += 1;
+	}
+	__DEL(s);
+	__DEL(p);
+}
+
+static void Modules_Trim (CHAR *s, ADDRESS s__len, CHAR *d, ADDRESS d__len)
+{
+	INT16 i, j;
+	CHAR part[1024];
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	j = 0;
+	while ((i < 2 && Modules_IsOneOf(s[__X(i, s__len)], (CHAR*)"/\\", 3))) {
+		i += 1;
+		d[__X(j, d__len)] = '/';
+		j += 1;
+	}
+	d[__X(j, d__len)] = 0x00;
+	while (s[__X(i, s__len)] != 0x00) {
+		Modules_ExtractPart(s, s__len, &i, (CHAR*)"/\\", 3, (void*)part, 1024);
+		if ((part[0] != 0x00 && __STRCMP(part, ".") != 0)) {
+			Modules_AppendPart('/', part, 1024, (void*)d, d__len);
+		}
+	}
+	__DEL(s);
+}
+
+typedef
+	CHAR pathstring__12[4096];
+
+static void Modules_FindBinaryDir (CHAR *binarydir, ADDRESS binarydir__len)
+{
+	pathstring__12 arg0, pathlist, pathdir, tempstr;
+	INT16 i, j, k;
+	BOOLEAN present;
+	if (Modules_ArgCount < 1) {
+		binarydir[0] = 0x00;
+		return;
+	}
+	Modules_GetArg(0, (void*)arg0, 4096);
+	i = 0;
+	while ((((arg0[__X(i, 4096)] != 0x00 && arg0[__X(i, 4096)] != '/')) && arg0[__X(i, 4096)] != '\\')) {
+		i += 1;
+	}
+	if (arg0[__X(i, 4096)] == '/' || arg0[__X(i, 4096)] == '\\') {
+		Modules_Trim(arg0, 4096, (void*)tempstr, 4096);
+		Modules_Canonify(tempstr, 4096, (void*)binarydir, binarydir__len);
+		present = Modules_IsFilePresent(binarydir, binarydir__len);
+	} else {
+		Platform_GetEnv((CHAR*)"PATH", 5, (void*)pathlist, 4096);
+		i = 0;
+		present = 0;
+		while ((!present && pathlist[__X(i, 4096)] != 0x00)) {
+			Modules_ExtractPart(pathlist, 4096, &i, (CHAR*)":;", 3, (void*)pathdir, 4096);
+			Modules_AppendPart('/', arg0, 4096, (void*)pathdir, 4096);
+			Modules_Trim(pathdir, 4096, (void*)tempstr, 4096);
+			Modules_Canonify(tempstr, 4096, (void*)binarydir, binarydir__len);
+			present = Modules_IsFilePresent(binarydir, binarydir__len);
+		}
+	}
+	if (present) {
+		k = Modules_CharCount(binarydir, binarydir__len);
+		while ((k > 0 && !Modules_IsOneOf(binarydir[__X(k - 1, binarydir__len)], (CHAR*)"/\\", 3))) {
+			k -= 1;
+		}
+		if (k == 0) {
+			binarydir[__X(k, binarydir__len)] = 0x00;
+		} else {
+			binarydir[__X(k - 1, binarydir__len)] = 0x00;
+		}
+	} else {
+		binarydir[0] = 0x00;
+	}
+}
+
+Heap_Module Modules_ThisMod (CHAR *name, ADDRESS name__len)
+{
+	Heap_Module m = NIL;
+	CHAR bodyname[64];
+	Heap_Command body;
+	__DUP(name, name__len, CHAR);
+	m = Modules_modules();
+	while ((m != NIL && __STRCMP(m->name, name) != 0)) {
+		m = m->next;
+	}
+	if (m != NIL) {
+		Modules_res = 0;
+		Modules_resMsg[0] = 0x00;
+	} else {
+		Modules_res = 1;
+		__COPY(name, Modules_importing, 20);
+		__MOVE(" module \"", Modules_resMsg, 10);
+		Modules_Append(name, name__len, (void*)Modules_resMsg, 256);
+		Modules_Append((CHAR*)"\" not found", 12, (void*)Modules_resMsg, 256);
+	}
+	__DEL(name);
+	return m;
+}
+
+Heap_Command Modules_ThisCommand (Heap_Module mod, CHAR *name, ADDRESS name__len)
+{
+	Heap_Cmd c = NIL;
+	__DUP(name, name__len, CHAR);
+	c = mod->cmds;
+	while ((c != NIL && __STRCMP(c->name, name) != 0)) {
+		c = c->next;
+	}
+	if (c != NIL) {
+		Modules_res = 0;
+		Modules_resMsg[0] = 0x00;
+		__DEL(name);
+		return c->cmd;
+	} else {
+		Modules_res = 2;
+		__MOVE(" command \"", Modules_resMsg, 11);
+		__COPY(name, Modules_importing, 20);
+		Modules_Append(mod->name, 20, (void*)Modules_resMsg, 256);
+		Modules_Append((CHAR*)".", 2, (void*)Modules_resMsg, 256);
+		Modules_Append(name, name__len, (void*)Modules_resMsg, 256);
+		Modules_Append((CHAR*)"\" not found", 12, (void*)Modules_resMsg, 256);
+		__DEL(name);
+		return NIL;
+	}
+	__RETCHK;
+}
+
+void Modules_Free (CHAR *name, ADDRESS name__len, BOOLEAN all)
+{
+	Heap_Module m = NIL, p = NIL;
+	INT32 refcount;
+	__DUP(name, name__len, CHAR);
+	m = Modules_modules();
+	if (all) {
+		Modules_res = 1;
+		__MOVE("unloading \"all\" not yet supported", Modules_resMsg, 34);
+	} else {
+		refcount = Heap_FreeModule(name, name__len);
+		if (refcount == 0) {
+			Modules_res = 0;
+		} else {
+			if (refcount < 0) {
+				__MOVE("module not found", Modules_resMsg, 17);
+			} else {
+				__MOVE("clients of this module exist", Modules_resMsg, 29);
+			}
+			Modules_res = 1;
+		}
+	}
+	__DEL(name);
+}
+
+static void Modules_errch (CHAR c)
+{
+	INT16 e;
+	e = Platform_Write(1, (ADDRESS)&c, 1);
+}
+
+static void Modules_errstring (CHAR *s, ADDRESS s__len)
+{
+	INT32 i;
+	__DUP(s, s__len, CHAR);
+	i = 0;
+	while ((i < s__len && s[__X(i, s__len)] != 0x00)) {
+		Modules_errch(s[__X(i, s__len)]);
+		i += 1;
+	}
+	__DEL(s);
+}
+
+static void Modules_errint (INT32 l)
+{
+	if (l < 0) {
+		Modules_errch('-');
+		l = -l;
+	}
+	if (l >= 10) {
+		Modules_errint(__DIV(l, 10));
+	}
+	Modules_errch(__CHR((int)__MOD(l, 10) + 48));
+}
+
+static void Modules_DisplayHaltCode (INT32 code)
+{
+	switch (code) {
+		case -1: 
+			Modules_errstring((CHAR*)"Assertion failure.", 19);
+			break;
+		case -2: 
+			Modules_errstring((CHAR*)"Index out of range.", 20);
+			break;
+		case -3: 
+			Modules_errstring((CHAR*)"Reached end of function without reaching RETURN.", 49);
+			break;
+		case -4: 
+			Modules_errstring((CHAR*)"CASE statement: no matching label and no ELSE.", 47);
+			break;
+		case -5: 
+			Modules_errstring((CHAR*)"Type guard failed.", 19);
+			break;
+		case -6: 
+			Modules_errstring((CHAR*)"Implicit type guard in record assignment failed.", 49);
+			break;
+		case -7: 
+			Modules_errstring((CHAR*)"Invalid case in WITH statement.", 32);
+			break;
+		case -8: 
+			Modules_errstring((CHAR*)"Value out of range.", 20);
+			break;
+		case -9: 
+			Modules_errstring((CHAR*)"Heap interrupted while locked, but lockdepth = 0 at unlock.", 60);
+			break;
+		case -10: 
+			Modules_errstring((CHAR*)"NIL access.", 12);
+			break;
+		case -11: 
+			Modules_errstring((CHAR*)"Alignment error.", 17);
+			break;
+		case -12: 
+			Modules_errstring((CHAR*)"Divide by zero.", 16);
+			break;
+		case -13: 
+			Modules_errstring((CHAR*)"Arithmetic overflow/underflow.", 31);
+			break;
+		case -14: 
+			Modules_errstring((CHAR*)"Invalid function argument.", 27);
+			break;
+		case -15: 
+			Modules_errstring((CHAR*)"Internal error, e.g. Type descriptor size mismatch.", 52);
+			break;
+		case -20: 
+			Modules_errstring((CHAR*)"Too many, or negative number of, elements in dynamic array.", 60);
+			break;
+		default: 
+			break;
+	}
+}
+
+void Modules_Halt (INT32 code)
+{
+	Heap_FINALL();
+	Modules_errstring((CHAR*)"Terminated by Halt(", 20);
+	Modules_errint(code);
+	Modules_errstring((CHAR*)"). ", 4);
+	if (code < 0) {
+		Modules_DisplayHaltCode(code);
+	}
+	Modules_errstring(Platform_NL, 3);
+	Platform_Exit(code);
+}
+
+void Modules_AssertFail (INT32 code)
+{
+	Heap_FINALL();
+	Modules_errstring((CHAR*)"Assertion failure.", 19);
+	if (code != 0) {
+		Modules_errstring((CHAR*)" ASSERT code ", 14);
+		Modules_errint(code);
+		Modules_errstring((CHAR*)".", 2);
+	}
+	Modules_errstring(Platform_NL, 3);
+	if (code > 0) {
+		Platform_Exit(code);
+	} else {
+		Platform_Exit(-1);
+	}
+}
+
+
+export void *Modules__init(void)
+{
+	__DEFMOD;
+	__MODULE_IMPORT(Heap);
+	__MODULE_IMPORT(Platform);
+	__REGMOD("Modules", 0);
+/* BEGIN */
+	Modules_FindBinaryDir((void*)Modules_BinaryDir, 1024);
+	__ENDMOD;
+}

bootstrap/unix-88/Modules.h

@@ -0,0 +1,31 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef Modules__h
+#define Modules__h
+
+#include "SYSTEM.h"
+#include "Heap.h"
+
+
+import INT16 Modules_res;
+import CHAR Modules_resMsg[256];
+import Heap_ModuleName Modules_imported, Modules_importing;
+import INT64 Modules_MainStackFrame;
+import INT16 Modules_ArgCount;
+import INT64 Modules_ArgVector;
+import CHAR Modules_BinaryDir[1024];
+
+
+import INT16 Modules_ArgPos (CHAR *s, ADDRESS s__len);
+import void Modules_AssertFail (INT32 code);
+import void Modules_Free (CHAR *name, ADDRESS name__len, BOOLEAN all);
+import void Modules_GetArg (INT16 n, CHAR *val, ADDRESS val__len);
+import void Modules_GetIntArg (INT16 n, INT32 *val);
+import void Modules_Halt (INT32 code);
+import void Modules_Init (INT32 argc, INT64 argvadr);
+import Heap_Command Modules_ThisCommand (Heap_Module mod, CHAR *name, ADDRESS name__len);
+import Heap_Module Modules_ThisMod (CHAR *name, ADDRESS name__len);
+import void *Modules__init(void);
+
+
+#endif // Modules

bootstrap/unix-88/OPB.h

@@ -0,0 +1,48 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPB__h
+#define OPB__h
+
+#include "SYSTEM.h"
+#include "OPS.h"
+#include "OPT.h"
+
+
+
+
+import void OPB_Assign (OPT_Node *x, OPT_Node y);
+import void OPB_Call (OPT_Node *x, OPT_Node apar, OPT_Object fp);
+import void OPB_CheckParameters (OPT_Object fp, OPT_Object ap, BOOLEAN checkNames);
+import void OPB_Construct (INT8 class, OPT_Node *x, OPT_Node y);
+import void OPB_DeRef (OPT_Node *x);
+import OPT_Node OPB_EmptySet (void);
+import void OPB_Enter (OPT_Node *procdec, OPT_Node stat, OPT_Object proc);
+import void OPB_Field (OPT_Node *x, OPT_Object y);
+import void OPB_In (OPT_Node *x, OPT_Node y);
+import void OPB_Index (OPT_Node *x, OPT_Node y);
+import void OPB_Inittd (OPT_Node *inittd, OPT_Node *last, OPT_Struct typ);
+import void OPB_Link (OPT_Node *x, OPT_Node *last, OPT_Node y);
+import void OPB_MOp (INT8 op, OPT_Node *x);
+import OPT_Node OPB_NewBoolConst (BOOLEAN boolval);
+import OPT_Node OPB_NewIntConst (INT64 intval);
+import OPT_Node OPB_NewLeaf (OPT_Object obj);
+import OPT_Node OPB_NewRealConst (LONGREAL realval, OPT_Struct typ);
+import OPT_Node OPB_NewString (OPS_String str, INT64 len);
+import OPT_Node OPB_Nil (void);
+import void OPB_Op (INT8 op, OPT_Node *x, OPT_Node y);
+import void OPB_OptIf (OPT_Node *x);
+import void OPB_Param (OPT_Node ap, OPT_Object fp);
+import void OPB_PrepCall (OPT_Node *x, OPT_Object *fpar);
+import void OPB_Return (OPT_Node *x, OPT_Object proc);
+import void OPB_SetElem (OPT_Node *x);
+import void OPB_SetRange (OPT_Node *x, OPT_Node y);
+import void OPB_StFct (OPT_Node *par0, INT8 fctno, INT16 parno);
+import void OPB_StPar0 (OPT_Node *par0, INT16 fctno);
+import void OPB_StPar1 (OPT_Node *par0, OPT_Node x, INT8 fctno);
+import void OPB_StParN (OPT_Node *par0, OPT_Node x, INT16 fctno, INT16 n);
+import void OPB_StaticLink (INT8 dlev);
+import void OPB_TypTest (OPT_Node *x, OPT_Object obj, BOOLEAN guard);
+import void *OPB__init(void);
+
+
+#endif // OPB

bootstrap/unix-88/OPC.h

@@ -0,0 +1,49 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPC__h
+#define OPC__h
+
+#include "SYSTEM.h"
+#include "OPT.h"
+
+
+
+
+import void OPC_Andent (OPT_Struct typ);
+import OPT_Object OPC_BaseTProc (OPT_Object obj);
+import void OPC_BegBlk (void);
+import void OPC_BegStat (void);
+import void OPC_Case (INT64 caseVal, INT16 form);
+import void OPC_Cmp (INT16 rel);
+import void OPC_CompleteIdent (OPT_Object obj);
+import void OPC_Constant (OPT_Const con, INT16 form);
+import void OPC_DefineInter (OPT_Object proc);
+import void OPC_EndBlk (void);
+import void OPC_EndBlk0 (void);
+import void OPC_EndStat (void);
+import void OPC_EnterBody (void);
+import void OPC_EnterProc (OPT_Object proc);
+import void OPC_ExitBody (void);
+import void OPC_ExitProc (OPT_Object proc, BOOLEAN eoBlock, BOOLEAN implicitRet);
+import void OPC_GenBdy (OPT_Node n);
+import void OPC_GenEnumPtrs (OPT_Object var);
+import void OPC_GenHdr (OPT_Node n);
+import void OPC_GenHdrIncludes (void);
+import void OPC_Halt (INT32 n);
+import void OPC_Ident (OPT_Object obj);
+import void OPC_Increment (BOOLEAN decrement);
+import void OPC_Indent (INT16 count);
+import void OPC_Init (void);
+import void OPC_InitTDesc (OPT_Struct typ);
+import void OPC_IntLiteral (INT64 n, INT32 size);
+import void OPC_Len (OPT_Object obj, OPT_Struct array, INT64 dim);
+import BOOLEAN OPC_NeedsRetval (OPT_Object proc);
+import INT32 OPC_NofPtrs (OPT_Struct typ);
+import void OPC_SetInclude (BOOLEAN exclude);
+import void OPC_TDescDecl (OPT_Struct typ);
+import void OPC_TypeDefs (OPT_Object obj, INT16 vis);
+import void OPC_TypeOf (OPT_Object ap);
+import void *OPC__init(void);
+
+
+#endif // OPC

bootstrap/unix-88/OPM.h

@@ -0,0 +1,76 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPM__h
+#define OPM__h
+
+#include "SYSTEM.h"
+
+
+import CHAR OPM_Model[10];
+import INT16 OPM_AddressSize, OPM_Alignment;
+import UINT32 OPM_GlobalOptions, OPM_Options;
+import INT16 OPM_ShortintSize, OPM_IntegerSize, OPM_LongintSize, OPM_SetSize;
+import INT64 OPM_MaxIndex;
+import LONGREAL OPM_MinReal, OPM_MaxReal, OPM_MinLReal, OPM_MaxLReal;
+import BOOLEAN OPM_noerr;
+import INT32 OPM_curpos, OPM_errpos, OPM_breakpc;
+import INT16 OPM_currFile, OPM_level, OPM_pc, OPM_entno;
+import CHAR OPM_modName[32];
+import CHAR OPM_objname[64];
+import CHAR OPM_InstallDir[1024];
+import CHAR OPM_ResourceDir[1024];
+
+
+import void OPM_CloseFiles (void);
+import void OPM_CloseOldSym (void);
+import void OPM_DeleteObj (CHAR *modulename, ADDRESS modulename__len);
+import void OPM_DeleteSym (CHAR *modulename, ADDRESS modulename__len);
+import void OPM_FPrint (INT32 *fp, INT64 val);
+import void OPM_FPrintLReal (INT32 *fp, LONGREAL val);
+import void OPM_FPrintReal (INT32 *fp, REAL val);
+import void OPM_FPrintSet (INT32 *fp, UINT64 val);
+import void OPM_Get (CHAR *ch);
+import void OPM_GetComment (CHAR *text, ADDRESS text__len);
+import void OPM_Init (BOOLEAN *done);
+import void OPM_InitOptions (void);
+import INT16 OPM_Integer (INT64 n);
+import void OPM_LogCompiling (CHAR *modname, ADDRESS modname__len);
+import void OPM_LogVT100 (CHAR *vt100code, ADDRESS vt100code__len);
+import void OPM_LogW (CHAR ch);
+import void OPM_LogWLn (void);
+import void OPM_LogWNum (INT64 i, INT64 len);
+import void OPM_LogWStr (CHAR *s, ADDRESS s__len);
+import INT32 OPM_Longint (INT64 n);
+import void OPM_Mark (INT16 n, INT32 pos);
+import void OPM_NewSym (CHAR *modName, ADDRESS modName__len);
+import void OPM_OldSym (CHAR *modName, ADDRESS modName__len, BOOLEAN *done);
+import void OPM_OpenFiles (CHAR *moduleName, ADDRESS moduleName__len);
+import BOOLEAN OPM_OpenPar (void);
+import void OPM_RegisterNewSym (void);
+import INT64 OPM_SignedMaximum (INT32 bytecount);
+import INT64 OPM_SignedMinimum (INT32 bytecount);
+import void OPM_StoreComment (CHAR *text, ADDRESS text__len);
+import void OPM_SymRCh (CHAR *ch);
+import INT32 OPM_SymRInt (void);
+import INT64 OPM_SymRInt64 (void);
+import void OPM_SymRLReal (LONGREAL *lr);
+import void OPM_SymRReal (REAL *r);
+import void OPM_SymRSet (UINT64 *s);
+import void OPM_SymWCh (CHAR ch);
+import void OPM_SymWInt (INT64 i);
+import void OPM_SymWLReal (LONGREAL lr);
+import void OPM_SymWReal (REAL r);
+import void OPM_SymWSet (UINT64 s);
+import void OPM_Write (CHAR ch);
+import void OPM_WriteHex (INT64 i);
+import void OPM_WriteInt (INT64 i);
+import void OPM_WriteLn (void);
+import void OPM_WriteReal (LONGREAL r, CHAR suffx);
+import void OPM_WriteString (CHAR *s, ADDRESS s__len);
+import void OPM_WriteStringVar (CHAR *s, ADDRESS s__len);
+import BOOLEAN OPM_eofSF (void);
+import void OPM_err (INT16 n);
+import void *OPM__init(void);
+
+
+#endif // OPM

bootstrap/unix-88/OPP.h

@@ -0,0 +1,16 @@
+/* voc 2.1.0 [2025/06/24]. Bootstrapping compiler for address size 8, alignment 8. xrtspaSF */
+
+#ifndef OPP__h
+#define OPP__h
+
+#include "SYSTEM.h"
+#include "OPT.h"
+
+
+
+
+import void OPP_Module (OPT_Node *prog, UINT32 opt);
+import void *OPP__init(void);
+
+
+#endif // OPP