0.6.3 Release version.

* Added mutex tests. Add errorcheck in safe mode for Posix threads. Make non-recursive locks fail when used recursively on Windows. Fix thread pool tests. Simple locking count.

---------

Co-authored-by: Christoffer Lerno <christoffer@aegik.com>

.editorconfig

@@ -0,0 +1,28 @@
+# EditorConfig is awesome: https://editorconfig.org
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+
+[CMakeLists.txt]
+indent_style = space
+indent_size = 4
+
+[*.{c,cc,h}]
+indent_style = space
+indent_size = 4
+
+[*.{c3}]
+indent_style = space
+indent_size = 4
+
+[*.{json,toml,yml,gyp}]
+indent_style = space
+indent_size = 2
+
+[*.{py,pyi}]
+indent_style = space
+indent_size = 2
+

.gitattributes

@@ -1,4 +1,2 @@
 $ cat .gitattributes
 * text=auto
-*.c3 linguist-language=C
-*.c3t linguist-language=C

.github/workflows/main.yml

@@ -8,8 +8,10 @@ on:
 
 env:
   LLVM_RELEASE_VERSION_WINDOWS: 18
-  LLVM_RELEASE_VERSION_MAC: 18
-  LLVM_RELEASE_VERSION_LINUX: 18
+  LLVM_RELEASE_VERSION_MAC: 17
+  LLVM_RELEASE_VERSION_LINUX: 17
+  LLVM_RELEASE_VERSION_UBUNTU20: 17
+  LLVM_DEV_VERSION: 20
 jobs:
 
   build-msvc:
@@ -34,14 +36,15 @@ jobs:
       - name: Compile and run some examples
         run: |
           cd resources
-          ..\build\${{ matrix.build_type }}\c3c.exe compile-run --print-linking examples\hello_world_many.c3
+          ..\build\${{ matrix.build_type }}\c3c.exe compile-run -L C:\ --print-linking examples\hello_world_many.c3
           ..\build\${{ matrix.build_type }}\c3c.exe compile-run --print-linking examples\time.c3
           ..\build\${{ matrix.build_type }}\c3c.exe compile-run --print-linking examples\fannkuch-redux.c3
           ..\build\${{ matrix.build_type }}\c3c.exe compile-run examples\contextfree\boolerr.c3
           ..\build\${{ matrix.build_type }}\c3c.exe compile-run examples\ls.c3
           ..\build\${{ matrix.build_type }}\c3c.exe compile-run examples\load_world.c3
           ..\build\${{ matrix.build_type }}\c3c.exe compile-run examples\process.c3
-          ..\build\${{ matrix.build_type }}\c3c.exe compile --test -g -O0 --threads 1 --target macos-x64 examples\constants.c3                  
+          ..\build\${{ matrix.build_type }}\c3c.exe compile-run examples\args.c3 -- foo -bar "baz baz"
+          ..\build\${{ matrix.build_type }}\c3c.exe compile --no-entry --test -g -O0 --threads 1 --target macos-x64 examples\constants.c3
           ..\build\${{ matrix.build_type }}\c3c.exe compile-run msvc_stack.c3
 
       - name: Build testproject
@@ -52,7 +55,7 @@ jobs:
           dir build\llvm_ir
           ..\..\build\${{ matrix.build_type }}\c3c.exe clean
           dir build\llvm_ir
-          
+
 
       - name: Build testproject lib
         run: |
@@ -62,15 +65,15 @@ jobs:
 
       - name: Vendor-fetch
         run: |
-          build\${{ matrix.build_type }}\c3c.exe vendor-fetch raylib
+          build\${{ matrix.build_type }}\c3c.exe vendor-fetch raylib5
 
-      - name: Try raylib
+      - name: Try raylib5
         run: |
           cd resources
-          ..\build\${{ matrix.build_type }}\c3c.exe vendor-fetch raylib          
-          ..\build\${{ matrix.build_type }}\c3c.exe compile --lib raylib --wincrt=none examples\raylib\raylib_arkanoid.c3
-          ..\build\${{ matrix.build_type }}\c3c.exe compile --lib raylib --wincrt=none examples\raylib\raylib_snake.c3
-          ..\build\${{ matrix.build_type }}\c3c.exe compile --lib raylib --wincrt=none examples\raylib\raylib_tetris.c3
+          ..\build\${{ matrix.build_type }}\c3c.exe vendor-fetch raylib5
+          ..\build\${{ matrix.build_type }}\c3c.exe compile --lib raylib5 --print-linking examples\raylib\raylib_arkanoid.c3
+          ..\build\${{ matrix.build_type }}\c3c.exe compile --lib raylib5 --print-linking examples\raylib\raylib_snake.c3
+          ..\build\${{ matrix.build_type }}\c3c.exe compile --lib raylib5 --print-linking examples\raylib\raylib_tetris.c3
 
       - name: run compiler tests
         run: |
@@ -88,10 +91,12 @@ jobs:
           dir msvc_sdk
 
       - name: upload artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: c3-windows-${{ matrix.build_type }}
-          path: build\${{ matrix.build_type }}\c3c.exe
+          path: |
+            build\${{ matrix.build_type }}\c3c.exe
+            build\${{ matrix.build_type }}\c3c_rt
 
   build-msys2-mingw:
     runs-on: windows-latest
@@ -130,7 +135,8 @@ jobs:
           ../build/c3c compile-run --print-linking examples/fannkuch-redux.c3
           ../build/c3c compile-run --print-linking examples/contextfree/boolerr.c3
           ../build/c3c compile-run --print-linking examples/load_world.c3
-          ../build/c3c compile --test -g -O0 --threads 1 --target macos-x64 examples/constants.c3
+          ../build/c3c compile-run --print-linking examples/args.c3 -- foo -bar "baz baz"
+          ../build/c3c compile --no-entry --test -g -O0 --threads 1 --target macos-x64 examples/constants.c3
 
       - name: Build testproject
         run: |
@@ -139,7 +145,7 @@ jobs:
 
       - name: Vendor-fetch
         run: |
-          ./build/c3c vendor-fetch raylib
+          ./build/c3c vendor-fetch raylib5
 
       - name: Build testproject lib
         run: |
@@ -186,7 +192,8 @@ jobs:
           ../build/c3c compile-run examples/fannkuch-redux.c3
           ../build/c3c compile-run examples/contextfree/boolerr.c3
           ../build/c3c compile-run examples/load_world.c3
-          ../build/c3c compile --test -g -O0 --threads 1 --target macos-x64 examples/constants.c3
+          ../build/c3c compile-run examples/args.c3 -- foo -bar "baz baz"
+          ../build/c3c compile --no-entry --test -g -O0 --threads 1 --target macos-x64 examples/constants.c3
       - name: Build testproject
         run: |
           cd resources/testproject
@@ -209,7 +216,7 @@ jobs:
       fail-fast: false
       matrix:
         build_type: [Release, Debug]
-        llvm_version: [15, 16, 17, 18, 19]
+        llvm_version: [17, 18, 19]
 
     steps:
       - uses: actions/checkout@v4
@@ -220,9 +227,6 @@ jobs:
       - name: Install Clang ${{matrix.llvm_version}}
         run: |
           wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          if [[ "${{matrix.llvm_version}}" < 16 ]]; then
-            sudo apt remove libllvm15
-          fi
           if [[ "${{matrix.llvm_version}}" < 18 ]]; then
             sudo add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${{matrix.llvm_version}} main"
             sudo apt-get update
@@ -231,21 +235,21 @@ jobs:
               lld-${{matrix.llvm_version}} liblld-${{matrix.llvm_version}}-dev libmlir-${{matrix.llvm_version}} \
               libmlir-${{matrix.llvm_version}}-dev mlir-${{matrix.llvm_version}}-tools
           else
-            if [[ "${{matrix.llvm_version}}" < 19 ]]; then
+            if [[ "${{matrix.llvm_version}}" < "${{env.LLVM_DEV_VERSION}}" ]]; then
               sudo add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${{matrix.llvm_version}} main"
               sudo apt-get update
               sudo apt-get install -y -t llvm-toolchain-focal-${{matrix.llvm_version}} libpolly-${{matrix.llvm_version}}-dev \
                 clang-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}}-dev \
-                lld-${{matrix.llvm_version}} liblld-${{matrix.llvm_version}}-dev 
+                lld-${{matrix.llvm_version}} liblld-${{matrix.llvm_version}}-dev
             else
               sudo add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal main"
               sudo apt-get install -y -t llvm-toolchain-focal libpolly-${{matrix.llvm_version}}-dev \
                 clang-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}}-dev \
-                lld-${{matrix.llvm_version}} liblld-${{matrix.llvm_version}}-dev                  
+                lld-${{matrix.llvm_version}} liblld-${{matrix.llvm_version}}-dev
             fi
           fi
       - name: CMake
-        if: matrix.llvm_version != 18
+        if: matrix.llvm_version < 18 || matrix.llvm_version == env.LLVM_DEV_VERSION
         run: |
           cmake -B build \
                 -G Ninja \
@@ -259,7 +263,7 @@ jobs:
                 -DC3_LLVM_VERSION=${{matrix.llvm_version}}
           cmake --build build
       - name: CMake18
-        if: matrix.llvm_version == 18
+        if: matrix.llvm_version >= 18 && matrix.llvm_version != env.LLVM_DEV_VERSION
         run: |
           cmake -B build \
                 -G Ninja \
@@ -270,12 +274,12 @@ jobs:
                 -DCMAKE_OBJCOPY=llvm-objcopy-${{matrix.llvm_version}} \
                 -DCMAKE_STRIP=llvm-strip-${{matrix.llvm_version}} \
                 -DCMAKE_DLLTOOL=llvm-dlltool-${{matrix.llvm_version}} \
-                -DC3_LLVM_VERSION=18.1
+                -DC3_LLVM_VERSION=${{matrix.llvm_version}}.1
           cmake --build build
 
       - name: Compile and run some examples
         run: |
-          cd resources            
+          cd resources
           ../build/c3c compile examples/base64.c3
           ../build/c3c compile examples/binarydigits.c3
           ../build/c3c compile examples/brainfk.c3
@@ -283,9 +287,9 @@ jobs:
           ../build/c3c compile examples/fasta.c3
           ../build/c3c compile examples/gameoflife.c3
           ../build/c3c compile examples/hash.c3
-          ../build/c3c compile examples/levenshtein.c3
+          ../build/c3c compile-only examples/levenshtein.c3
           ../build/c3c compile examples/load_world.c3
-          ../build/c3c compile examples/map.c3
+          ../build/c3c compile-only examples/map.c3
           ../build/c3c compile examples/mandelbrot.c3
           ../build/c3c compile examples/plus_minus.c3
           ../build/c3c compile examples/nbodies.c3
@@ -294,8 +298,8 @@ jobs:
           ../build/c3c compile examples/contextfree/boolerr.c3
           ../build/c3c compile examples/contextfree/dynscope.c3
           ../build/c3c compile examples/contextfree/guess_number.c3
-          ../build/c3c compile examples/contextfree/multi.c3          
-          ../build/c3c compile examples/contextfree/cleanup.c3  
+          ../build/c3c compile examples/contextfree/multi.c3
+          ../build/c3c compile examples/contextfree/cleanup.c3
           ../build/c3c compile-run examples/hello_world_many.c3
           ../build/c3c compile-run examples/time.c3
           ../build/c3c compile-run examples/fannkuch-redux.c3
@@ -305,6 +309,7 @@ jobs:
           ../build/c3c compile-run examples/ls.c3
           ../build/c3c compile-run --linker=builtin linux_stack.c3
           ../build/c3c compile-run linux_stack.c3
+          ../build/c3c compile-run examples/args.c3 -- foo -bar "baz baz"
 
       - name: Compile run unit tests
         run: |
@@ -316,11 +321,32 @@ jobs:
           cd resources/testproject
           ../../build/c3c run --debug-log
 
+      - name: Test WASM
+        run: |
+          cd resources/testfragments
+          ../../build/c3c compile --target wasm32 -g0 --no-entry -Os wasm4.c3
+
+      - name: Install QEMU and Risc-V toolchain
+        run: |
+          sudo apt-get install opensbi qemu-system-misc u-boot-qemu gcc-riscv64-unknown-elf
+
+      - name: Compile and run Baremetal Risc-V Example
+        run: |
+          cd resources/examples/embedded/riscv-qemu
+          make C3C_PATH=../../../../build/ run
+
       - name: Build testproject direct linker
         run: |
           cd resources/testproject
           ../../build/c3c run --debug-log --linker=builtin
 
+      - name: Init a library & a project
+        run: |
+          ./build/c3c init-lib mylib
+          ls mylib.c3l
+          ./build/c3c init myproject
+          ls myproject
+
       - name: run compiler tests
         run: |
           cd test
@@ -329,15 +355,15 @@ jobs:
       - name: bundle_output
         if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_LINUX
         run: |
-          mkdir linux
-          cp -r lib linux
-          cp msvc_build_libraries.py linux
-          cp build/c3c linux
-          tar czf c3-linux-${{matrix.build_type}}.tar.gz linux
+          mkdir c3
+          cp -r lib c3
+          cp msvc_build_libraries.py c3
+          cp build/c3c c3
+          tar czf c3-linux-${{matrix.build_type}}.tar.gz c3
 
       - name: upload artifacts
         if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_LINUX
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: c3-linux-${{matrix.build_type}}
           path: c3-linux-${{matrix.build_type}}.tar.gz
@@ -349,8 +375,7 @@ jobs:
       fail-fast: false
       matrix:
         build_type: [Release, Debug]
-        llvm_version: [16]
-
+        llvm_version: [17, 18, 19]
     steps:
       - uses: actions/checkout@v4
       - name: Install common deps
@@ -360,16 +385,17 @@ jobs:
       - name: Install Clang ${{matrix.llvm_version}}
         run: |
           wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
-          if [[ "${{matrix.llvm_version}}" < 17 ]]; then
+          if [[ "${{matrix.llvm_version}}" < "${{env.LLVM_DEV_VERSION}}" ]]; then
             sudo add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${{matrix.llvm_version}} main"
           else
             sudo add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal main"
           fi
-          sudo apt-get update      
+          sudo apt-get update
           sudo apt-get install -y clang-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}} llvm-${{matrix.llvm_version}}-dev lld-${{matrix.llvm_version}} liblld-${{matrix.llvm_version}}-dev
-          sudo apt-get install -y libmlir-${{matrix.llvm_version}} libmlir-${{matrix.llvm_version}}-dev mlir-${{matrix.llvm_version}}-tools 
+          sudo apt-get install -y libmlir-${{matrix.llvm_version}} libmlir-${{matrix.llvm_version}}-dev mlir-${{matrix.llvm_version}}-tools
           sudo apt-get install -y libpolly-${{matrix.llvm_version}}-dev
-      - name: CMake
+      - name: CMake Old
+        if: matrix.llvm_version < 18 || matrix.llvm_version == env.LLVM_DEV_VERSION
         run: |
           cmake -B build \
                 -G Ninja \
@@ -382,13 +408,26 @@ jobs:
                 -DCMAKE_DLLTOOL=llvm-dlltool-${{matrix.llvm_version}} \
                 -DC3_LLVM_VERSION=${{matrix.llvm_version}}
           cmake --build build
-
+      - name: CMake
+        if: matrix.llvm_version >= 18 && matrix.llvm_version != env.LLVM_DEV_VERSION
+        run: |
+          cmake -B build \
+                -G Ninja \
+                -DCMAKE_BUILD_TYPE=${{matrix.build_type}} \
+                -DCMAKE_C_COMPILER=clang-${{matrix.llvm_version}} \
+                -DCMAKE_CXX_COMPILER=clang++-${{matrix.llvm_version}} \
+                -DCMAKE_LINKER=lld-link-${{matrix.llvm_version}} \
+                -DCMAKE_OBJCOPY=llvm-objcopy-${{matrix.llvm_version}} \
+                -DCMAKE_STRIP=llvm-strip-${{matrix.llvm_version}} \
+                -DCMAKE_DLLTOOL=llvm-dlltool-${{matrix.llvm_version}} \
+                -DC3_LLVM_VERSION=${{matrix.llvm_version}}.1
+          cmake --build build
       - name: Compile and run some examples
         run: |
           cd resources
           ../build/c3c compile examples/gameoflife.c3
-          ../build/c3c compile examples/levenshtein.c3
-          ../build/c3c compile examples/map.c3
+          ../build/c3c compile-only examples/levenshtein.c3
+          ../build/c3c compile-only examples/map.c3
           ../build/c3c compile examples/mandelbrot.c3
           ../build/c3c compile examples/plus_minus.c3
           ../build/c3c compile examples/spectralnorm.c3
@@ -398,8 +437,8 @@ jobs:
           ../build/c3c compile-run examples/nbodies.c3
           ../build/c3c compile-run examples/contextfree/boolerr.c3
           ../build/c3c compile-run examples/contextfree/dynscope.c3
-          ../build/c3c compile-run examples/contextfree/multi.c3          
-          ../build/c3c compile-run examples/contextfree/cleanup.c3          
+          ../build/c3c compile-run examples/contextfree/multi.c3
+          ../build/c3c compile-run examples/contextfree/cleanup.c3
           ../build/c3c compile-run examples/hello_world_many.c3
           ../build/c3c compile-run examples/time.c3
           ../build/c3c compile-run examples/fannkuch-redux.c3
@@ -412,6 +451,7 @@ jobs:
           ../build/c3c compile-run examples/process.c3
           ../build/c3c compile-run --linker=builtin linux_stack.c3
           ../build/c3c compile-run linux_stack.c3
+          ../build/c3c compile-run examples/args.c3 -- foo -bar "baz baz"
 
       - name: Compile run unit tests
         run: |
@@ -434,20 +474,108 @@ jobs:
           python3 src/tester.py ../build/c3c test_suite/
 
       - name: bundle_output
-        if: matrix.llvm_version == 16
+        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_UBUNTU20
         run: |
-          mkdir linux
-          cp -r lib linux
-          cp msvc_build_libraries.py linux
-          cp build/c3c linux
-          tar czf c3-ubuntu-20-${{matrix.build_type}}.tar.gz linux
+          mkdir c3
+          cp -r lib c3
+          cp msvc_build_libraries.py c3
+          cp build/c3c c3
+          tar czf c3-ubuntu-20-${{matrix.build_type}}.tar.gz c3
 
       - name: upload artifacts
-        if: matrix.llvm_version == 16
-        uses: actions/upload-artifact@v3
+        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_UBUNTU20
+        uses: actions/upload-artifact@v4
         with:
           name: c3-ubuntu-20-${{matrix.build_type}}
           path: c3-ubuntu-20-${{matrix.build_type}}.tar.gz
+  
+  build-with-docker:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ubuntu_version: [20.04, 22.04]
+        build_type: [Release, Debug]
+        llvm_version: [17, 18, 19]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Make script executable
+        run: chmod +x ./build-with-docker.sh
+
+      - name: Run build
+        run: |
+          LLVM_VERSION=${{ matrix.llvm_version }} UBUNTU_VERSION=${{ matrix.ubuntu_version }} CMAKE_BUILD_TYPE=${{ matrix.build_type }} ./build-with-docker.sh
+      
+      - name: Compile and run some examples
+        run: |
+          cd resources
+          ../build/c3c compile examples/base64.c3
+          ../build/c3c compile examples/binarydigits.c3
+          ../build/c3c compile examples/brainfk.c3
+          ../build/c3c compile examples/factorial_macro.c3
+          ../build/c3c compile examples/fasta.c3
+          ../build/c3c compile examples/gameoflife.c3
+          ../build/c3c compile examples/hash.c3
+          ../build/c3c compile-only examples/levenshtein.c3
+          ../build/c3c compile examples/load_world.c3
+          ../build/c3c compile-only examples/map.c3
+          ../build/c3c compile examples/mandelbrot.c3
+          ../build/c3c compile examples/plus_minus.c3
+          ../build/c3c compile examples/nbodies.c3
+          ../build/c3c compile examples/spectralnorm.c3
+          ../build/c3c compile examples/swap.c3
+          ../build/c3c compile examples/contextfree/boolerr.c3
+          ../build/c3c compile examples/contextfree/dynscope.c3
+          ../build/c3c compile examples/contextfree/guess_number.c3
+          ../build/c3c compile examples/contextfree/multi.c3
+          ../build/c3c compile examples/contextfree/cleanup.c3
+          ../build/c3c compile-run examples/hello_world_many.c3
+          ../build/c3c compile-run examples/time.c3
+          ../build/c3c compile-run examples/fannkuch-redux.c3
+          ../build/c3c compile-run examples/contextfree/boolerr.c3
+          ../build/c3c compile-run examples/load_world.c3
+          ../build/c3c compile-run examples/process.c3
+          ../build/c3c compile-run examples/ls.c3
+          ../build/c3c compile-run --linker=builtin linux_stack.c3
+          ../build/c3c compile-run linux_stack.c3
+          ../build/c3c compile-run examples/args.c3 -- foo -bar "baz baz"
+
+      - name: Compile run unit tests
+        run: |
+          cd test
+          ../build/c3c compile-test unit
+
+      - name: Build testproject
+        run: |
+          cd resources/testproject
+          ../../build/c3c run --debug-log
+
+      - name: Test WASM
+        run: |
+          cd resources/testfragments
+          ../../build/c3c compile --reloc=none --target wasm32 -g0 --no-entry -Os wasm4.c3
+
+      - name: Build testproject direct linker
+        run: |
+          cd resources/testproject
+          ../../build/c3c run --debug-log --linker=builtin
+
+      - name: Init a library & a project
+        run: |
+          ./build/c3c init-lib mylib
+          ls mylib.c3l
+          ./build/c3c init myproject
+          ls myproject
+
+      - name: run compiler tests
+        run: |
+          cd test
+          python3 src/tester.py ../build/c3c test_suite/
 
   build-mac:
     runs-on: macos-latest
@@ -456,30 +584,30 @@ jobs:
       fail-fast: false
       matrix:
         build_type: [Release, Debug]
-        llvm_version: [15, 16, 17, 18]
+        llvm_version: [17, 18]
     steps:
       - uses: actions/checkout@v4
       - name: Download LLVM
         run: |
           brew install llvm@${{ matrix.llvm_version }} ninja curl
-          echo "/opt/homebrew/opt/llvm@${{ matrix.llvm_version }}/bin" >> $GITHUB_PATH  
+          echo "/opt/homebrew/opt/llvm@${{ matrix.llvm_version }}/bin" >> $GITHUB_PATH
           TMP_PATH=$(xcrun --show-sdk-path)/user/include
           echo "CPATH=$TMP_PATH" >> $GITHUB_ENV
 
       - name: CMake
-        if: matrix.llvm_version != 18
+        if: matrix.llvm_version < 18
         run: |
           cmake -B build -G Ninja -DC3_LLVM_VERSION=${{matrix.llvm_version}} -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
           cmake --build build
       - name: CMake18
-        if: matrix.llvm_version == 18
+        if: matrix.llvm_version >= 18
         run: |
           cmake -B build -G Ninja -DC3_LLVM_VERSION=${{matrix.llvm_version}}.1 -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
           cmake --build build
 
       - name: Vendor-fetch
         run: |
-          ./build/c3c vendor-fetch raylib
+          ./build/c3c vendor-fetch raylib5
 
       - name: Compile and run some examples
         run: |
@@ -491,6 +619,7 @@ jobs:
           ../build/c3c compile-run examples/process.c3
           ../build/c3c compile-run examples/load_world.c3
           ../build/c3c compile-run -O5 examples/load_world.c3
+          ../build/c3c compile-run examples/args.c3 -- foo -bar "baz baz"
 
       - name: Compile run unit tests
         run: |
@@ -528,7 +657,7 @@ jobs:
 
       - name: upload artifacts
         if: matrix.llvm_version == env.LLVM_RELEASE_VERSION_MAC
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: c3-macos-${{matrix.build_type}}
           path: c3-macos-${{matrix.build_type}}.zip
@@ -536,7 +665,7 @@ jobs:
 
   release:
     runs-on: ubuntu-latest
-    needs: [build-msvc, build-linux, build-mac]
+    needs: [build-msvc, build-linux, build-mac, build-linux-ubuntu20]
     if: github.ref == 'refs/heads/master'
 
     steps:
@@ -563,16 +692,22 @@ jobs:
               sha: context.sha
             })
 
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
       - run: cp -r lib c3-windows-Release
       - run: cp -r lib c3-windows-Debug
       - run: cp msvc_build_libraries.py c3-windows-Release
       - run: cp msvc_build_libraries.py c3-windows-Debug
-      - run: zip -r c3-windows-Release.zip c3-windows-Release
-      - run: zip -r c3-windows-Debug.zip c3-windows-Debug
+      - run: zip -r c3-windows.zip c3-windows-Release
+      - run: zip -r c3-windows-debug.zip c3-windows-Debug
+      - run: mv c3-linux-Release/c3-linux-Release.tar.gz c3-linux-Release/c3-linux.tar.gz
+      - run: mv c3-linux-Debug/c3-linux-Debug.tar.gz c3-linux-Debug/c3-linux-debug.tar.gz
+      - run: mv c3-ubuntu-20-Release/c3-ubuntu-20-Release.tar.gz c3-ubuntu-20-Release/c3-ubuntu-20.tar.gz
+      - run: mv c3-ubuntu-20-Debug/c3-ubuntu-20-Debug.tar.gz c3-ubuntu-20-Debug/c3-ubuntu-20-debug.tar.gz
+      - run: mv c3-macos-Release/c3-macos-Release.zip c3-macos-Release/c3-macos.zip
+      - run: mv c3-macos-Debug/c3-macos-Debug.zip c3-macos-Debug/c3-macos-debug.zip
 
       - id: create_release
-        uses: actions/create-release@v1
+        uses: softprops/action-gh-release@v2
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
@@ -580,84 +715,12 @@ jobs:
           release_name: latest
           draft: false
           prerelease: true
-
-      - name: upload windows
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: c3-windows-Release.zip
-          asset_name: c3-windows.zip
-          asset_content_type: application/zip
-
-      - name: upload windows debug
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: c3-windows-Debug.zip
-          asset_name: c3-windows-debug.zip
-          asset_content_type: application/zip
-
-      - name: upload linux
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: c3-linux-Release/c3-linux-Release.tar.gz
-          asset_name: c3-linux.tar.gz
-          asset_content_type: application/gzip
-
-      - name: upload linux debug
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: c3-linux-Debug/c3-linux-Debug.tar.gz
-          asset_name: c3-linux-debug.tar.gz
-          asset_content_type: application/gzip
-
-      - name: upload ubuntu 20
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-
-          asset_path: c3-ubuntu-20-Release/c3-ubuntu-20-Release.tar.gz
-          asset_name: c3-ubuntu-20.tar.gz
-          asset_content_type: application/gzip
-
-      - name: upload ubuntu 20 debug
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: c3-ubuntu-20-Debug/c3-ubuntu-20-Debug.tar.gz
-          asset_name: c3-ubuntu-20-debug.tar.gz
-          asset_content_type: application/gzip
-
-      - name: upload macos
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: c3-macos-Release/c3-macos-Release.zip
-          asset_name: c3-macos.zip
-          asset_content_type: application/zip
-
-      - name: upload macos debug
-        uses: actions/upload-release-asset@v1
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          upload_url: ${{ steps.create_release.outputs.upload_url }}
-          asset_path: c3-macos-Debug/c3-macos-Debug.zip
-          asset_name: c3-macos-debug.zip
-          asset_content_type: application/zip
+          files: |
+            c3-windows.zip
+            c3-windows-debug.zip
+            c3-linux-Release/c3-linux.tar.gz
+            c3-linux-Debug/c3-linux-debug.tar.gz
+            c3-ubuntu-20-Release/c3-ubuntu-20.tar.gz
+            c3-ubuntu-20-Debug/c3-ubuntu-20-debug.tar.gz
+            c3-macos-Release/c3-macos.zip
+            c3-macos-Debug/c3-macos-debug.zip

.gitignore

@@ -67,3 +67,11 @@ out/
 
 /cmake-build-debug/
 /cmake-build-release/
+
+# Emacs files
+TAGS
+
+# Clangd LSP files
+/.cache/
+/compile_commands.json
+

CMakeLists.txt

@@ -63,6 +63,7 @@ set(C3_LLVM_VERSION "auto" CACHE STRING "Use LLVM version [default: auto]")
 option(C3_USE_MIMALLOC "Use built-in mimalloc" OFF)
 option(C3_USE_TB "Use TB" OFF)
 set(C3_MIMALLOC_TAG "v1.7.3" CACHE STRING "Used version of mimalloc")
+option(C3_WITH_LLVM "Build with LLVM" ON)
 
 set(C3_USE_MIMALLOC OFF)
 if(C3_USE_MIMALLOC)
@@ -80,9 +81,11 @@ endif()
 if (NOT WIN32)
     find_package(CURL)
 endif()
-if (NOT C3_LLVM_VERSION STREQUAL "auto")
-    if (${C3_LLVM_VERSION} VERSION_LESS 15 OR ${C3_LLVM_VERSION} VERSION_GREATER 19)
-        message(FATAL_ERROR "LLVM ${C3_LLVM_VERSION} is not supported!")
+if(C3_WITH_LLVM)
+    if (NOT C3_LLVM_VERSION STREQUAL "auto")
+        if (${C3_LLVM_VERSION} VERSION_LESS 17 OR ${C3_LLVM_VERSION} VERSION_GREATER 20)
+            message(FATAL_ERROR "LLVM ${C3_LLVM_VERSION} is not supported!")
+        endif()
     endif()
 endif()
 
@@ -101,108 +104,126 @@ if(C3_USE_TB AND GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
     endif()
 endif()
 
-if(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
-    if (C3_LLVM_VERSION STREQUAL "auto")
-        set(C3_LLVM_VERSION "18")
-    endif()
-    FetchContent_Declare(
-            LLVM_Windows
-            URL https://github.com/c3lang/win-llvm/releases/download/llvm_18_1_8_with_rt/llvm-18.1.8-windows-amd64-msvc17-libcmt.7z
+# Clangd LSP support
+option(C3_ENABLE_CLANGD_LSP "Enable/Disable output of compile commands during generation." OFF)
+if(C3_ENABLE_CLANGD_LSP)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+    execute_process(
+        COMMAND ${CMAKE_COMMAND} -E create_symlink
+            ${CMAKE_BINARY_DIR}/compile_commands.json
+            ${CMAKE_SOURCE_DIR}/compile_commands.json
     )
-    FetchContent_Declare(
-            LLVM_Windows_debug
-            URL https://github.com/c3lang/win-llvm/releases/download/llvm_18_1_8_with_rt/llvm-18.1.8-windows-amd64-msvc17-libcmt-dbg.7z
-    )
-    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
-        message("Loading Windows LLVM debug libraries, this may take a while...")
-        FetchContent_MakeAvailable(LLVM_Windows_debug)
-        set(CMAKE_SYSTEM_PREFIX_PATH ${llvm_windows_debug_SOURCE_DIR} ${CMAKE_SYSTEM_PREFIX_PATH})
-    else()
-        message("Loading Windows LLVM libraries, this may take a while...")
-        FetchContent_MakeAvailable(LLVM_Windows)
-        set(CMAKE_SYSTEM_PREFIX_PATH ${llvm_windows_SOURCE_DIR} ${CMAKE_SYSTEM_PREFIX_PATH})
-    endif()
-    find_package(LLVM REQUIRED CONFIG)
-    find_package(LLD REQUIRED CONFIG)
-else()
-    if (NOT C3_LLVM_VERSION STREQUAL "auto")
-        find_package(LLVM ${C3_LLVM_VERSION} REQUIRED CONFIG)
-    else()
+endif(C3_ENABLE_CLANGD_LSP)
+
+if(C3_WITH_LLVM)
+    if(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
+        if (C3_LLVM_VERSION STREQUAL "auto")
+            set(C3_LLVM_VERSION "18")
+        endif()
+        FetchContent_Declare(
+                LLVM_Windows
+                URL https://github.com/c3lang/win-llvm/releases/download/llvm_18_1_8_with_rt/llvm-18.1.8-windows-amd64-msvc17-libcmt.7z
+        )
+        FetchContent_Declare(
+                LLVM_Windows_debug
+                URL https://github.com/c3lang/win-llvm/releases/download/llvm_18_1_8_with_rt/llvm-18.1.8-windows-amd64-msvc17-libcmt-dbg.7z
+        )
+        if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+            message("Loading Windows LLVM debug libraries, this may take a while...")
+            FetchContent_MakeAvailable(LLVM_Windows_debug)
+            set(llvm_dir ${llvm_windows_debug_SOURCE_DIR})
+        else()
+            message("Loading Windows LLVM libraries, this may take a while...")
+            FetchContent_MakeAvailable(LLVM_Windows)
+            set(llvm_dir ${llvm_windows_SOURCE_DIR})
+        endif()
+        set(CMAKE_SYSTEM_PREFIX_PATH ${llvm_dir} ${CMAKE_SYSTEM_PREFIX_PATH})
+
         find_package(LLVM REQUIRED CONFIG)
+        find_package(LLD REQUIRED CONFIG)
+    else()
+        if (NOT C3_LLVM_VERSION STREQUAL "auto")
+            find_package(LLVM ${C3_LLVM_VERSION} REQUIRED CONFIG)
+        else()
+            find_package(LLVM REQUIRED CONFIG)
+        endif()
     endif()
-endif()
 
-message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
-message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
-message(STATUS "Libraries located in: ${LLVM_LIBRARY_DIRS}")
+    message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
+    message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
+    message(STATUS "Libraries located in: ${LLVM_LIBRARY_DIRS}")
 
-if (NOT LLVM_PACKAGE_VERSION VERSION_GREATER_EQUAL 15.0)
-    message(FATAL_ERROR "LLVM version 15.0 or later is required.")
-endif()
+    if (NOT LLVM_PACKAGE_VERSION VERSION_GREATER_EQUAL 15.0)
+        message(FATAL_ERROR "LLVM version 15.0 or later is required.")
+    endif()
 
-if(LLVM_ENABLE_RTTI)
-    message(STATUS "LLVM was built with RTTI")
-else()
-    message(STATUS "LLVM was not built with RTTI")
-endif()
+    if(LLVM_ENABLE_RTTI)
+        message(STATUS "LLVM was built with RTTI")
+    else()
+        message(STATUS "LLVM was not built with RTTI")
+    endif()
 
-include_directories(${LLVM_INCLUDE_DIRS})
-link_directories(${LLVM_LIBRARY_DIRS})
-add_definitions(${LLVM_DEFINITIONS})
+    string(REPLACE "." ";" VERSION_LIST ${LLVM_PACKAGE_VERSION})
+    list(GET VERSION_LIST 0 LLVM_MAJOR_VERSION)
 
-if(NOT C3_LINK_DYNAMIC)
-    set(LLVM_LINK_COMPONENTS
-	    AllTargetsAsmParsers
-	    AllTargetsCodeGens
-	    AllTargetsDescs
-	    AllTargetsDisassemblers
-	    AllTargetsInfos
-	    Analysis
-	    AsmPrinter
-	    BitReader
-	    Core
-	    DebugInfoPDB
-	    InstCombine
-	    IrReader
-	    LibDriver
-	    Linker
-	    LTO
-	    MC
-	    MCDisassembler
-	    native
-	    nativecodegen
-	    Object
-	    Option
-	    ScalarOpts
-	    Support
-	    Target
-	    TransformUtils
-	    WindowsManifest
-	    WindowsDriver
-    )
+    include_directories(${LLVM_INCLUDE_DIRS})
+    link_directories(${LLVM_LIBRARY_DIRS})
+    add_definitions(${LLVM_DEFINITIONS})
 
-    llvm_map_components_to_libnames(llvm_libs ${LLVM_LINK_COMPONENTS})
+    if(NOT C3_LINK_DYNAMIC)
+        set(LLVM_LINK_COMPONENTS
+            AllTargetsAsmParsers
+            AllTargetsCodeGens
+            AllTargetsDescs
+            AllTargetsDisassemblers
+            AllTargetsInfos
+            Analysis
+            AsmPrinter
+            BitReader
+            Core
+            DebugInfoPDB
+            InstCombine
+            IrReader
+            LibDriver
+            Linker
+            LTO
+            MC
+            MCDisassembler
+            native
+            nativecodegen
+            Object
+            Option
+            ScalarOpts
+            Support
+            Target
+            TransformUtils
+            WindowsManifest
+            WindowsDriver
+        )
 
-    # These don't seem to be reliable on windows.
-    message(STATUS "using find_library")
-    find_library(LLD_COFF NAMES lldCOFF.lib lldCOFF.a liblldCOFF.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-    find_library(LLD_COMMON NAMES lldCommon.lib lldCommon.a liblldCommon.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-    find_library(LLD_ELF NAMES lldELF.lib lldELF.a liblldELF.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-    find_library(LLD_MACHO NAMES lldMachO.lib lldMachO.a liblldMachO.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-    find_library(LLD_MINGW NAMES lldMinGW.lib lldMinGW.a liblldMinGW.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-    find_library(LLD_WASM NAMES lldWasm.lib lldWasm.a liblldWasm.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-else()
-    find_library(LLVM NAMES libLLVM.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-    set(llvm_libs ${LLVM})
+        llvm_map_components_to_libnames(llvm_libs ${LLVM_LINK_COMPONENTS})
 
-    # These don't seem to be reliable on windows.
-    message(STATUS "using find_library")
-    find_library(LLD_COFF NAMES liblldCOFF.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-    find_library(LLD_COMMON NAMES liblldCommon.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-    find_library(LLD_ELF NAMES liblldELF.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-    find_library(LLD_MACHO NAMES liblldMachO.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-    find_library(LLD_MINGW NAMES liblldMinGW.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
-    find_library(LLD_WASM NAMES liblldWasm.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        # These don't seem to be reliable on windows.
+        message(STATUS "using find_library")
+        find_library(LLD_COFF NAMES lldCOFF.lib lldCOFF.a liblldCOFF.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        find_library(LLD_COMMON NAMES lldCommon.lib lldCommon.a liblldCommon.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        find_library(LLD_ELF NAMES lldELF.lib lldELF.a liblldELF.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        find_library(LLD_MACHO NAMES lldMachO.lib lldMachO.a liblldMachO.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        find_library(LLD_MINGW NAMES lldMinGW.lib lldMinGW.a liblldMinGW.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        find_library(LLD_WASM NAMES lldWasm.lib lldWasm.a liblldWasm.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+    else()
+        find_library(LLVM NAMES libLLVM.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        set(llvm_libs ${LLVM})
+
+        # These don't seem to be reliable on windows.
+        message(STATUS "using find_library")
+        find_library(LLD_COFF NAMES liblldCOFF.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        find_library(LLD_COMMON NAMES liblldCommon.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        find_library(LLD_ELF NAMES liblldELF.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        find_library(LLD_MACHO NAMES liblldMachO.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        find_library(LLD_MINGW NAMES liblldMinGW.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+        find_library(LLD_WASM NAMES liblldWasm.so PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
+    endif()
 endif()
 
 if (NOT(${CMAKE_BINARY_DIR} EQUAL ${CMAKE_SOURCE_DIR}))
@@ -210,7 +231,7 @@ if (NOT(${CMAKE_BINARY_DIR} EQUAL ${CMAKE_SOURCE_DIR}))
     file(COPY ${CMAKE_SOURCE_DIR}/lib DESTINATION ${CMAKE_BINARY_DIR})
 endif()
 
-if (${LLVM_PACKAGE_VERSION} VERSION_GREATER_EQUAL 16)
+if(C3_WITH_LLVM)
     find_library(LLD_LOONG NAMES libLLVMLoongArchCodeGen.lib libLLVMLoongArchAsmParser.lib libLLVMLoongArchCodeGen.a libLLVMLoongArchAsmParser.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
     set(lld_libs
         ${LLD_COFF}
@@ -220,38 +241,41 @@ if (${LLVM_PACKAGE_VERSION} VERSION_GREATER_EQUAL 16)
         ${LLD_ELF}
         ${LLD_MACHO}
         )
-else()
-    set(lld_libs
-        ${LLD_COFF}
-        ${LLD_COMMON}
-        ${LLD_WASM}
-        ${LLD_MINGW}
-        ${LLD_ELF}
-        ${LLD_MACHO}
-        )
+
+    if (APPLE)
+        set(lld_libs ${lld_libs} xar)
+        find_file(RT_ASAN_DYNAMIC NAMES libclang_rt.asan_osx_dynamic.dylib PATHS "${LLVM_LIBRARY_DIRS}/clang/${LLVM_MAJOR_VERSION}/lib/darwin")
+        find_file(RT_TSAN_DYNAMIC NAMES libclang_rt.tsan_osx_dynamic.dylib PATHS "${LLVM_LIBRARY_DIRS}/clang/${LLVM_MAJOR_VERSION}/lib/darwin")
+        find_file(RT_UBSAN_DYNAMIC NAMES libclang_rt.ubsan_osx_dynamic.dylib PATHS "${LLVM_LIBRARY_DIRS}/clang/${LLVM_MAJOR_VERSION}/lib/darwin")
+        find_file(RT_LSAN_DYNAMIC NAMES libclang_rt.lsan_osx_dynamic.dylib PATHS "${LLVM_LIBRARY_DIRS}/clang/${LLVM_MAJOR_VERSION}/lib/darwin")
+        set(sanitizer_runtime_libraries
+                ${RT_ASAN_DYNAMIC}
+                ${RT_TSAN_DYNAMIC}
+                # Unused
+                # ${RT_UBSAN_DYNAMIC}
+                # ${RT_LSAN_DYNAMIC}
+            )
+    endif()
+
+    message(STATUS "linking to llvm libs ${lld_libs}")
+    message(STATUS "Found lld libs ${lld_libs}")
 endif()
 
-if (APPLE)
-    set(lld_libs ${lld_libs} xar)
-endif ()
-
-message(STATUS "linking to llvm libs ${lld_libs}")
-message(STATUS "Found lld libs ${lld_libs}")
-
-
-add_library(c3c_wrappers STATIC wrapper/src/wrapper.cpp)
 add_library(miniz STATIC dependencies/miniz/miniz.c)
 
 add_executable(c3c
         src/build/builder.c
         src/build/build_options.c
         src/build/project_creation.c
+        src/build/project_manipulation.c
         src/build/libraries.c
         src/compiler/ast.c
         src/compiler/bigint.c
         src/compiler/codegen_general.c
         src/compiler/compiler.c
         src/compiler/compiler.h
+        src/compiler/subprocess.c
+        src/compiler/subprocess.h
         src/compiler/context.c
         src/compiler/copying.c
         src/compiler/diagnostics.c
@@ -260,7 +284,6 @@ add_executable(c3c
         src/compiler/json_output.c
         src/compiler/lexer.c
         src/compiler/linker.c
-        src/compiler/llvm_codegen.c
         src/compiler/abi/c_abi_aarch64.c
         src/compiler/abi/c_abi.c
         src/compiler/abi/c_abi_riscv.c
@@ -268,14 +291,6 @@ add_executable(c3c
         src/compiler/abi/c_abi_win64.c
         src/compiler/abi/c_abi_x64.c
         src/compiler/abi/c_abi_x86.c
-        src/compiler/llvm_codegen_debug_info.c
-        src/compiler/llvm_codegen_expr.c
-        src/compiler/llvm_codegen_function.c
-        src/compiler/llvm_codegen_instr.c
-        src/compiler/llvm_codegen_module.c
-        src/compiler/llvm_codegen_stmt.c
-        src/compiler/llvm_codegen_type.c
-        src/compiler/llvm_codegen_value.c
         src/compiler/module.c
         src/compiler/number.c
         src/compiler/parse_expr.c
@@ -318,18 +333,59 @@ add_executable(c3c
         src/utils/cpus.c
         src/utils/unzipper.c
         src/compiler/decltable.c
-        src/compiler/mac_support.c
-        src/compiler/llvm_codegen_storeload.c
+        src/compiler/mac_support.c 
         src/compiler/windows_support.c
         src/compiler/codegen_asm.c
-        src/compiler/asm_target.c
-        src/compiler/llvm_codegen_builtins.c
+        src/compiler/asm_target.c 
         src/compiler/expr.c
         src/utils/time.c
         src/utils/http.c
         src/compiler/sema_liveness.c
-        src/build/common_build.c)
+        src/build/common_build.c
+        src/compiler/sema_const.c
+        ${CMAKE_BINARY_DIR}/git_hash.h
+        )
 
+if(GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
+    # We are inside of a git repository so rebuilding the hash every time something changes.
+    add_custom_command(
+            OUTPUT ${CMAKE_BINARY_DIR}/git_hash.h
+            COMMAND ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_LIST_DIR}/git_hash.cmake"
+            DEPENDS "${CMAKE_CURRENT_LIST_DIR}/.git")
+else()
+    # We are NOT inside of a git repository. Building the has only once.
+    add_custom_command(
+            OUTPUT ${CMAKE_BINARY_DIR}/git_hash.h
+            COMMAND ${CMAKE_COMMAND} -P "${CMAKE_CURRENT_LIST_DIR}/git_hash.cmake")
+endif()
+
+if(C3_WITH_LLVM)
+    target_sources(c3c PRIVATE 
+        src/compiler/llvm_codegen.c
+        src/compiler/llvm_codegen_debug_info.c
+        src/compiler/llvm_codegen_expr.c
+        src/compiler/llvm_codegen_function.c
+        src/compiler/llvm_codegen_instr.c
+        src/compiler/llvm_codegen_module.c
+        src/compiler/llvm_codegen_stmt.c
+        src/compiler/llvm_codegen_type.c
+        src/compiler/llvm_codegen_value.c
+        src/compiler/llvm_codegen_storeload.c
+        src/compiler/llvm_codegen_builtins.c)
+
+    target_compile_definitions(c3c PUBLIC LLVM_AVAILABLE=1)
+    add_library(c3c_wrappers STATIC wrapper/src/wrapper.cpp)
+else()
+    target_sources(c3c PRIVATE src/utils/hostinfo.c)
+    target_compile_definitions(c3c PUBLIC LLVM_AVAILABLE=0)
+endif()
+
+target_include_directories(c3c PRIVATE
+        "${CMAKE_SOURCE_DIR}/src/"
+        "${CMAKE_BINARY_DIR}")
+
+target_include_directories(miniz PUBLIC
+        "${CMAKE_SOURCE_DIR}/dependencies/miniz/")
 
 if (C3_USE_TB)
     file(GLOB tilde-sources
@@ -363,23 +419,29 @@ if (C3_USE_TB)
 
     target_include_directories(c3c PRIVATE
             "${CMAKE_SOURCE_DIR}/tilde-backend/include/")
+
 else()
+
     target_compile_definitions(c3c PUBLIC TB_AVAILABLE=0)
+
 endif()
 
+if(C3_WITH_LLVM)
+    target_link_libraries(c3c ${llvm_libs} miniz c3c_wrappers ${lld_libs})
 
-target_include_directories(c3c PRIVATE
-        "${CMAKE_SOURCE_DIR}/src/")
+    target_include_directories(c3c PRIVATE
+            "${CMAKE_SOURCE_DIR}/wrapper/include/")
 
+    target_include_directories(c3c_wrappers PRIVATE
+            "${CMAKE_SOURCE_DIR}/wrapper/include/")
 
-target_include_directories(c3c_wrappers PRIVATE
-        "${CMAKE_SOURCE_DIR}/wrapper/src/")
+    target_link_libraries(c3c_wrappers ${llvm_libs} ${lld_libs})
 
-target_include_directories(miniz PUBLIC
-        "${CMAKE_SOURCE_DIR}/dependencies/miniz/")
+else() 
 
-target_link_libraries(c3c_wrappers ${llvm_libs} ${lld_libs})
-target_link_libraries(c3c ${llvm_libs} miniz c3c_wrappers ${lld_libs})
+    target_link_libraries(c3c ${llvm_libs} miniz ${lld_libs})
+
+endif()
 
 if(C3_USE_MIMALLOC)
     target_link_libraries(c3c mimalloc-static)
@@ -389,6 +451,11 @@ if (WIN32)
     target_link_libraries(c3c Winhttp.lib)
 endif()
 
+if(MINGW)
+    message("Increase stack for msys")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--stack,8388608")
+endif ()
+
 if (CURL_FOUND)
     target_link_libraries(c3c ${CURL_LIBRARIES})
     target_include_directories(c3c PRIVATE ${CURL_INCLUDES})
@@ -397,36 +464,73 @@ else()
     target_compile_definitions(c3c PUBLIC CURL_FOUND=0)
 endif()
 
+
 if(MSVC)
     message("Adding MSVC options")
     target_compile_options(c3c PRIVATE /wd4068 /wd4090 /WX /Wv:18)
-    target_compile_options(c3c_wrappers PUBLIC /wd4624 /wd4267 /wd4244 /WX /Wv:18)
-    target_link_options(c3c_wrappers PUBLIC /ignore:4099)
+    if(C3_WITH_LLVM)
+        target_compile_options(c3c_wrappers PUBLIC /wd4624 /wd4267 /wd4244 /WX /Wv:18)
+        if(NOT LLVM_ENABLE_RTTI)
+            target_compile_options(c3c_wrappers PUBLIC /GR-)
+        endif()
+        target_link_options(c3c_wrappers PUBLIC /ignore:4099)
+    endif()
     if(CMAKE_BUILD_TYPE STREQUAL "Debug")
         target_compile_options(c3c PUBLIC /MTd)
-        target_compile_options(c3c_wrappers PUBLIC /MTd)
+        if (C3_WITH_LLVM)
+            target_compile_options(c3c_wrappers PUBLIC /MTd)
+        endif()
         target_compile_options(miniz PUBLIC /MTd)
         if (C3_USE_TB)
             target_compile_options(tilde-backend PUBLIC /MTd)
         endif()
     else()
         target_compile_options(c3c PUBLIC /MT)
-        target_compile_options(c3c_wrappers PUBLIC /MT)
+        if (C3_WITH_LLVM)
+            target_compile_options(c3c_wrappers PUBLIC /MT)
+        endif()
         target_compile_options(miniz PUBLIC /MT)
         if (C3_USE_TB)
             target_compile_options(tilde-backend PUBLIC /MT)
         endif()
     endif()
-
+    if(C3_WITH_LLVM)
+        set(clang_lib_dir ${llvm_dir}/lib/clang/${C3_LLVM_VERSION}/lib/windows)
+        set(sanitizer_runtime_libraries
+            ${clang_lib_dir}/clang_rt.asan-x86_64.lib
+            ${clang_lib_dir}/clang_rt.asan_dynamic-x86_64.lib
+            ${clang_lib_dir}/clang_rt.asan_dynamic-x86_64.dll
+            ${clang_lib_dir}/clang_rt.asan_dynamic_runtime_thunk-x86_64.lib)
+    endif()
 else()
     message(STATUS "using gcc/clang warning switches")
     target_link_options(c3c PRIVATE -pthread)
+    if (C3_WITH_LLVM AND NOT LLVM_ENABLE_RTTI)
+        target_compile_options(c3c_wrappers PRIVATE -fno-rtti)
+    endif()
     target_compile_options(c3c PRIVATE -pthread -Wall -Werror -Wno-unknown-pragmas -Wno-unused-result
             -Wno-unused-function -Wno-unused-variable -Wno-unused-parameter)
 endif()
 
-
 install(TARGETS c3c DESTINATION bin)
 install(DIRECTORY lib/ DESTINATION lib/c3)
 
+if (C3_WITH_LLVM AND DEFINED sanitizer_runtime_libraries)
+    add_custom_command(TARGET c3c POST_BUILD
+        COMMAND "${CMAKE_COMMAND}" -E rm -rf -- $<TARGET_FILE_DIR:c3c>/c3c_rt
+        COMMAND "${CMAKE_COMMAND}" -E make_directory $<TARGET_FILE_DIR:c3c>/c3c_rt
+        COMMAND "${CMAKE_COMMAND}" -E copy ${sanitizer_runtime_libraries} $<TARGET_FILE_DIR:c3c>/c3c_rt
+        VERBATIM
+        COMMENT "Copying sanitizer runtime libraries to output directory")
+
+    if (APPLE)
+        # Change LC_ID_DYLIB to be rpath-based instead of having an absolute path
+        add_custom_command(TARGET c3c POST_BUILD
+            COMMAND find $<TARGET_FILE_DIR:c3c>/c3c_rt -type f -name "*.dylib" -execdir ${LLVM_TOOLS_BINARY_DIR}/llvm-install-name-tool -id @rpath/{} {} $<SEMICOLON>
+            VERBATIM)
+    endif()
+
+    install(DIRECTORY $<TARGET_FILE_DIR:c3c>/c3c_rt/ DESTINATION bin/c3c_rt)
+endif()
+
 feature_summary(WHAT ALL)

README.md

@@ -10,7 +10,8 @@ Precompiled binaries for the following operating systems are available:
  
 - Windows x64 [download](https://github.com/c3lang/c3c/releases/download/latest/c3-windows.zip), [install instructions](#installing-on-windows-with-precompiled-binaries).
 - Debian x64 [download](https://github.com/c3lang/c3c/releases/download/latest/c3-linux.tar.gz), [install instructions](#installing-on-debian-with-precompiled-binaries).
-- MacOS x64 [download](https://github.com/c3lang/c3c/releases/download/latest/c3-macos.zip), [install instructions](#installing-on-mac-with-precompiled-binaries).
+- Ubuntu x86 [download](https://github.com/c3lang/c3c/releases/download/latest/c3-ubuntu-20.tar.gz), [install instructions](#installing-on-ubuntu-with-precompiled-binaries).
+- MacOS Arm64 [download](https://github.com/c3lang/c3c/releases/download/latest/c3-macos.zip), [install instructions](#installing-on-mac-with-precompiled-binaries).
 
 The manual for C3 can be found at [www.c3-lang.org](http://www.c3-lang.org).
 
@@ -34,7 +35,7 @@ whole new language.
 
 The following code shows [generic modules](https://c3-lang.org/references/docs/generics/) (more examples can be found at https://c3-lang.org/references/docs/examples/). 
 
-```c++
+```cpp
 module stack (<Type>);
 // Above: the parameterized type is applied to the entire module.
 
@@ -137,9 +138,9 @@ fn void main()
 
 ### Current status
 
-The current stable version of the compiler is **version 0.5**.
+The current stable version of the compiler is **version 0.6.2**.
 
-The upcoming 0.6 release will focus on expanding the standard library.
+The upcoming 0.6.x releases will focus on expanding the standard library.
 Follow the issues [here](https://github.com/c3lang/c3c/issues).
 
 If you have suggestions on how to improve the language, either [file an issue](https://github.com/c3lang/c3c/issues) 
@@ -205,19 +206,32 @@ More platforms will be supported in the future.
 2. Unpack executable and standard lib.
 3. Run `./c3c`.
 
-#### Installing on Mac with precompiled binaries
+#### Installing on Ubuntu with precompiled binaries
+1. Download tar file: [https://github.com/c3lang/c3c/releases/download/latest/c3-ubuntu-20.tar.gz](https://github.com/c3lang/c3c/releases/download/latest/c3-ubuntu-20.tar.gz)
+   (debug version [here](https://github.com/c3lang/c3c/releases/download/latest/c3-ubuntu-20-debug.tar.gz))
+2. Unpack executable and standard lib.
+3. Run `./c3c`.
+
+#### Installing on MacOS with precompiled binaries
 1. Make sure you have XCode with command line tools installed.
 2. Download the zip file: [https://github.com/c3lang/c3c/releases/download/latest/c3-macos.zip](https://github.com/c3lang/c3c/releases/download/latest/c3-macos.zip)
    (debug version [here](https://github.com/c3lang/c3c/releases/download/latest/c3-macos-debug.zip))
 3. Unzip executable and standard lib.
 4. Run `./c3c`.
 
-(*Note that there is a known issue with debug symbol generation on MacOS 13, see issue #1086)
+(*Note that there is a known issue with debug symbol generation on MacOS 13, see [issue #1086](https://github.com/c3lang/c3c/issues/1086))
 
 #### Installing on Arch Linux
-There is an AUR package for the c3c compiler : [c3c-git](https://aur.archlinux.org/packages/c3c-git).
+Arch includes c3c in the official 'extra' repo. It can be easily installed the usual way:
 
-Due to some issues with the LLVM packaged for Arch Linux, the AUR package will download and use LLVM 16 for Ubuntu-23.04 to compile the c3c compiler.
+```sh
+sudo pacman -S c3c
+# or paru -S c3c
+# or yay -S c3c
+# or aura -A c3c
+```
+
+There is also an AUR package for the c3c compiler : [c3c-git](https://aur.archlinux.org/packages/c3c-git).
 
 You can use your AUR package manager:
 ```sh
@@ -253,7 +267,7 @@ A `c3c` executable will be found under `bin/`.
 #### Installing on OS X using Homebrew
 
 2. Install CMake: `brew install cmake`
-3. Install LLVM 15: `brew install llvm`
+3. Install LLVM 17+: `brew install llvm`
 4. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
 5. Enter the C3C directory `cd c3c`.
 6. Create a build directory `mkdir build`
@@ -304,17 +318,16 @@ You can try it out by running some sample code: `c3c.exe compile ../resources/ex
 *Note that if you run into linking issues when building, make sure that you are using the latest version of VS17.*
 
 
-#### Compiling on Ubuntu 20.10
+#### Compiling on Ubuntu 24.04 LTS
 
 1. Make sure you have a C compiler that handles C11 and a C++ compiler, such as GCC or Clang. Git also needs to be installed.
-2. Install CMake: `sudo apt install cmake`
-3. Install LLVM 15 (or greater: C3C supports LLVM 15-17): `sudo apt-get install clang-15 zlib1g zlib1g-dev libllvm15 llvm-15 llvm-15-dev llvm-15-runtime liblld-15-dev liblld-15`
-4. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
-5. Enter the C3C directory `cd c3c`.
-6. Create a build directory `mkdir build`
-7. Change directory to the build directory `cd build`
-8. Set up CMake build: `cmake ..`
-9. Build: `cmake --build .`
+2. Install LLVM 18 `sudo apt-get install cmake git clang zlib1g zlib1g-dev libllvm18 llvm llvm-dev llvm-runtime liblld-dev liblld-18 libpolly-18-dev`
+3. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
+4. Enter the C3C directory `cd c3c`.
+5. Create a build directory `mkdir build`
+6. Change directory to the build directory `cd build`
+7. Set up CMake build: `cmake ..`
+8. Build: `cmake --build .`
 
 You should now have a `c3c` executable.
 
@@ -323,7 +336,7 @@ You can try it out by running some sample code: `./c3c compile ../resources/exam
 
 #### Compiling on Void Linux
 
-1. As root, ensure that all project dependencies are installed: `xbps-install git cmake llvm15 lld-devel libcurl-devel ncurses-devel zlib-devel libzstd-devel libxml2-devel`
+1. As root, ensure that all project dependencies are installed: `xbps-install git cmake llvm17 llvm17-devel lld17-devel libcurl-devel ncurses-devel zlib-devel libzstd-devel libxml2-devel`
 2. Clone the C3C repository: `git clone https://github.com/c3lang/c3c.git`
     - If you only need the latest commit, you may want to make a shallow clone instead: `git clone https://github.com/c3lang/c3c.git --depth=1`
 3. Enter the directory: `cd c3c`
@@ -339,7 +352,7 @@ For a sytem-wide installation, run the following as root: `cmake --install .`
 #### Compiling on other Linux / Unix variants
 
 1. Install CMake.
-2. Install or compile LLVM and LLD *libraries* (version 15+ or higher)
+2. Install or compile LLVM and LLD *libraries* (version 17+ or higher)
 3. Clone the C3C github repository: `git clone https://github.com/c3lang/c3c.git`
 4. Enter the C3C directory `cd c3c`.
 5. Create a build directory `mkdir build`
@@ -369,3 +382,9 @@ Editor plugins can be found at https://github.com/c3lang/editor-plugins.
 3. Run tests and see that they pass. (Recommended settings: `c3c compile-test -O0 test/unit`.
    - in this example `test/unit/` is the relative path to the test directory, so adjust as required)
 4. Make a pull request for the new tests.
+
+## Thank yous
+
+A huge "thank you" goes out to all contributors and sponsors.
+
+A special thank you to sponsor [Caleb-o](https://github.com/Caleb-o) for going the extra mile.

build-with-docker.sh

@@ -1,43 +1,44 @@
 #!/bin/bash
-## build-with-docker.sh
-## @author gdm85
-## @modified by Kenta
-##
-## Script to build c3c for Ubuntu 22
-##
-#
 
-read -p "Select Build Type: Debug/Release: " config
+: ${DOCKER:=docker}
+: ${IMAGE:="c3c-builder"}
+: ${CMAKE_BUILD_TYPE:=Release}
+: ${LLVM_VERSION:=18}
+: ${UBUNTU_VERSION:="22.04"}
+: ${CMAKE_VERSION:="3.20.0"}
 
-set -e
+cd docker || exit 1  # Exit if the 'docker' directory doesn't exist
 
-DOCKER=docker
-DOCKER_RUN=""
-IMAGE="c3c-builder"
-if type podman 2>/dev/null >/dev/null; then
-    DOCKER=podman
-    DOCKER_RUN="--userns=keep-id"
-    IMAGE="localhost/$IMAGE"
+$DOCKER build \
+    --build-arg LLVM_VERSION=$LLVM_VERSION \
+    --build-arg CMAKE_VERSION=$CMAKE_VERSION \
+    --build-arg UBUNTU_VERSION=$UBUNTU_VERSION \
+    -t $IMAGE .
+
+if [ $? -ne 0 ]; then
+    echo "Docker image build failed. Exiting."
+    exit 1
 fi
 
-if [ $config == "Debug" ]; then
-    CMAKE_BUILD_TYPE=Debug
-else
-    CMAKE_BUILD_TYPE="$config"
-fi
-
-UBUNTU_VERSION="22.10"
-LLVM_VERSION="15"
-
-IMAGE="$IMAGE:22"
-
-cd docker && $DOCKER build -t $IMAGE\
-    --build-arg DEPS="llvm-$LLVM_VERSION-dev liblld-$LLVM_VERSION-dev clang-$LLVM_VERSION libllvm$LLVM_VERSION llvm-$LLVM_VERSION-runtime" \
-    --build-arg UBUNTU_VERSION="$UBUNTU_VERSION" .
 cd ..
 
 rm -rf build bin
 mkdir -p build bin
 
-exec $DOCKER run -ti --rm --tmpfs=/tmp $DOCKER_RUN -v "$PWD":/home/c3c/source -w /home/c3c/source $IMAGE bash -c \
-    "cd build && cmake -DCMAKE_BUILD_TYPE=$CMAKE_BUILD_TYPE -DC3_LLVM_VERSION=$LLVM_VERSION .. && cmake --build . && mv c3c lib ../bin/"
+chmod -R 777 build bin
+
+exec $DOCKER run -i --rm \
+    -v "$PWD":/home/c3c/source \
+    -w /home/c3c/source $IMAGE bash -c \
+    "cmake -S . -B build \
+            -G Ninja \
+            -DCMAKE_BUILD_TYPE=$CMAKE_BUILD_TYPE \
+            -DCMAKE_C_COMPILER=clang-$LLVM_VERSION \
+            -DCMAKE_CXX_COMPILER=clang++-$LLVM_VERSION \
+            -DCMAKE_LINKER=lld-$LLVM_VERSION \
+            -DCMAKE_OBJCOPY=llvm-objcopy-$LLVM_VERSION \
+            -DCMAKE_STRIP=llvm-strip-$LLVM_VERSION \
+            -DCMAKE_DLLTOOL=llvm-dlltool-$LLVM_VERSION \
+            -DC3_LLVM_VERSION=auto && \
+    cmake --build build && \
+    cp -r build/c3c build/lib bin"

docker/Dockerfile

@@ -1,16 +1,49 @@
+ARG UBUNTU_VERSION=22.04
+FROM ubuntu:${UBUNTU_VERSION}
 
-ARG UBUNTU_VERSION
-FROM ubuntu:$UBUNTU_VERSION
+ARG LLVM_VERSION=18
+ENV LLVM_DEV_VERSION=20
 
-ARG DEPS
+ARG CMAKE_VERSION=3.20
 
-RUN export DEBIAN_FRONTEND=noninteractive && export TERM=xterm && apt-get update && apt-get install -y build-essential cmake zlib1g zlib1g-dev  \
-        $DEPS && \
-	rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y wget gnupg software-properties-common zlib1g zlib1g-dev python3 ninja-build curl g++ && \
+    wget https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-$CMAKE_VERSION-linux-x86_64.sh && \
+    mkdir -p /opt/cmake && \
+    sh cmake-${CMAKE_VERSION}-linux-x86_64.sh --prefix=/opt/cmake --skip-license && \
+    rm cmake-${CMAKE_VERSION}-linux-x86_64.sh && \
+    ln -s /opt/cmake/bin/cmake /usr/local/bin/cmake
 
-ARG GID=1000
-ARG UID=1000
+RUN wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add - && \
+    if [ "${LLVM_VERSION}" -lt 18 ]; then \
+        add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${LLVM_VERSION} main" && \
+        apt-get update && \
+        apt-get install -y -t llvm-toolchain-focal-${LLVM_VERSION} \
+          libpolly-${LLVM_VERSION}-dev \
+          clang-${LLVM_VERSION} llvm-${LLVM_VERSION} llvm-${LLVM_VERSION}-dev \
+          lld-${LLVM_VERSION} liblld-${LLVM_VERSION}-dev libmlir-${LLVM_VERSION} \
+          libmlir-${LLVM_VERSION}-dev mlir-${LLVM_VERSION}-tools; \
+    elif [ "${LLVM_VERSION}" -lt "${LLVM_DEV_VERSION}" ]; then \
+        add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal-${LLVM_VERSION} main" && \
+        apt-get update && \
+        apt-get install -y -t llvm-toolchain-focal-${LLVM_VERSION} \
+          libpolly-${LLVM_VERSION}-dev \
+          clang-${LLVM_VERSION} clang++-${LLVM_VERSION} llvm-${LLVM_VERSION} llvm-${LLVM_VERSION}-dev \
+          lld-${LLVM_VERSION} liblld-${LLVM_VERSION}-dev; \
+    else \
+        add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal main" && \
+        apt-get update && \
+        apt-get install -y -t llvm-toolchain-focal \
+          libpolly-${LLVM_VERSION}-dev \
+          clang-${LLVM_VERSION} llvm-${LLVM_VERSION} llvm-${LLVM_VERSION}-dev \
+          lld-${LLVM_VERSION} liblld-${LLVM_VERSION}-dev; \
+    fi && \
+    rm -rf /var/lib/apt/lists/*
 
-RUN groupadd -o --gid=$GID c3c && useradd --gid=$GID --uid=$GID --create-home --shell /bin/bash c3c
+RUN groupadd -g 1337 c3c && \
+    useradd -m -u 1337 -g c3c c3c
 
+# Add cmake to PATH for user c3c
 USER c3c
+ENV PATH="/opt/cmake/bin:${PATH}"
+
+WORKDIR /home/c3c

git_hash.cmake

@@ -0,0 +1,14 @@
+find_package(Git QUIET)
+
+set(GIT_HASH "unknown")
+
+if(GIT_FOUND AND EXISTS "${CMAKE_CURRENT_LIST_DIR}/.git")
+    execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse HEAD
+                    OUTPUT_VARIABLE GIT_HASH
+                    OUTPUT_STRIP_TRAILING_WHITESPACE
+                    COMMAND_ERROR_IS_FATAL ANY)
+endif()
+
+message("Git Hash: ${GIT_HASH}")
+
+file(WRITE ${CMAKE_BINARY_DIR}/git_hash.h "#pragma once\n#define GIT_HASH \"${GIT_HASH}\"\n")

lib/std/collections/anylist.c3

@@ -18,9 +18,18 @@ struct AnyList (Printable)
 
 /**
  * @param initial_capacity "The initial capacity to reserve"
- * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
+ * Use `init` for to use a custom allocator.
  **/
-fn AnyList* AnyList.new_init(&self, usz initial_capacity = 16, Allocator allocator = allocator::heap())
+fn AnyList* AnyList.new_init(&self, usz initial_capacity = 16, Allocator allocator = null)
+{
+	return self.init(allocator ?: allocator::heap(), initial_capacity) @inline;
+}
+
+/**
+ * @param [&inout] allocator "The allocator to use"
+ * @param initial_capacity "The initial capacity to reserve"
+ **/
+fn AnyList* AnyList.init(&self, Allocator allocator, usz initial_capacity = 16)
 {
 	self.allocator = allocator;
 	self.size = 0;
@@ -44,7 +53,7 @@ fn AnyList* AnyList.new_init(&self, usz initial_capacity = 16, Allocator allocat
  **/
 fn AnyList* AnyList.temp_init(&self, usz initial_capacity = 16)
 {
-	return self.new_init(initial_capacity, allocator::temp()) @inline;
+	return self.init(allocator::temp(), initial_capacity) @inline;
 }
 
 fn usz! AnyList.to_format(&self, Formatter* formatter) @dynamic
@@ -67,16 +76,19 @@ fn usz! AnyList.to_format(&self, Formatter* formatter) @dynamic
 	}
 }
 
-fn String AnyList.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
+fn String AnyList.to_new_string(&self, Allocator allocator = null) @dynamic
 {
-	return string::new_format("%s", *self, .allocator = allocator);
+	return string::format("%s", *self, allocator: allocator ?: allocator::heap());
 }
 
-fn String AnyList.to_tstring(&self)
+
+fn String AnyList.to_string(&self, Allocator allocator) @dynamic
 {
-	return string::tformat("%s", *self);
+	return string::format("%s", *self, allocator: allocator);
 }
 
+fn String AnyList.to_tstring(&self) => string::tformat("%s", *self);
+
 /**
  * Push an element on the list by cloning it.
  **/
@@ -117,18 +129,35 @@ macro AnyList.pop(&self, $Type)
  * Pop the last value and allocate the copy using the given allocator.
  * @return! IteratorResult.NO_MORE_ELEMENT
  **/
-fn any! AnyList.new_pop(&self, Allocator allocator = allocator::heap())
+fn any! AnyList.copy_pop(&self, Allocator allocator = allocator::heap())
 {
 	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
 	defer self.free_element(self.entries[self.size]);
 	return allocator::clone_any(allocator, self.entries[--self.size]);
 }
 
+/**
+ * Pop the last value and allocate the copy using the given allocator.
+ * @return! IteratorResult.NO_MORE_ELEMENT
+ * @deprecated `use copy_pop`
+ **/
+fn any! AnyList.new_pop(&self, Allocator allocator = allocator::heap())
+{
+	return self.copy_pop(allocator);
+}
+
+/**
+ * Pop the last value and allocate the copy using the temp allocator
+ * @return! IteratorResult.NO_MORE_ELEMENT
+ * @deprecated `use tcopy_pop`
+ **/
+fn any! AnyList.temp_pop(&self) => self.copy_pop(allocator::temp());
+
 /**
  * Pop the last value and allocate the copy using the temp allocator
  * @return! IteratorResult.NO_MORE_ELEMENT
  **/
-fn any! AnyList.temp_pop(&self) => self.new_pop(allocator::temp());
+fn any! AnyList.tcopy_pop(&self) => self.copy_pop(allocator::temp());
 
 /**
  * Pop the last value. It must later be released using list.free_element()
@@ -171,8 +200,17 @@ fn any! AnyList.pop_first_retained(&self)
 
 /**
  * Same as new_pop() but pops the first value instead.
+ * @deprecated `use copy_pop_first`
  **/
 fn any! AnyList.new_pop_first(&self, Allocator allocator = allocator::heap())
+{
+	return self.copy_pop_first(allocator) @inline;
+}
+
+/**
+ * Same as new_pop() but pops the first value instead.
+ **/
+fn any! AnyList.copy_pop_first(&self, Allocator allocator = allocator::heap())
 {
 	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
 	defer self.free_element(self.entries[self.size]);
@@ -183,6 +221,12 @@ fn any! AnyList.new_pop_first(&self, Allocator allocator = allocator::heap())
 /**
  * Same as temp_pop() but pops the first value instead.
  **/
+fn any! AnyList.tcopy_pop_first(&self) => self.copy_pop_first(allocator::temp());
+
+/**
+ * Same as temp_pop() but pops the first value instead.
+ * @deprecated `use tcopy_pop_first`
+ **/
 fn any! AnyList.temp_pop_first(&self) => self.new_pop_first(allocator::temp());
 
 /**

lib/std/collections/elastic_array.c3

@@ -0,0 +1,455 @@
+// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// Use of self source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+/**
+ * @require MAX_SIZE >= 1 `The size must be at least 1 element big.`
+ **/
+module std::collections::elastic_array(<Type, MAX_SIZE>);
+import std::io, std::math, std::collections::list_common;
+
+def ElementPredicate = fn bool(Type *type);
+def ElementTest = fn bool(Type *type, any context);
+const ELEMENT_IS_EQUATABLE = types::is_equatable_type(Type);
+const ELEMENT_IS_POINTER = Type.kindof == POINTER;
+macro type_is_overaligned() => Type.alignof > mem::DEFAULT_MEM_ALIGNMENT;
+
+struct ElasticArray (Printable)
+{
+	usz size;
+	Type[MAX_SIZE] entries;
+}
+
+fn usz! ElasticArray.to_format(&self, Formatter* formatter) @dynamic
+{
+	switch (self.size)
+	{
+		case 0:
+			return formatter.print("[]")!;
+		case 1:
+			return formatter.printf("[%s]", self.entries[0])!;
+		default:
+			usz n = formatter.print("[")!;
+			foreach (i, element : self.entries[:self.size])
+			{
+				if (i != 0) formatter.print(", ")!;
+				n += formatter.printf("%s", element)!;
+			}
+			n += formatter.print("]")!;
+			return n;
+	}
+}
+
+fn String ElasticArray.to_string(&self, Allocator allocator) @dynamic
+{
+	return string::format("%s", *self, allocator: allocator);
+}
+
+fn String ElasticArray.to_new_string(&self, Allocator allocator = nul) @dynamic
+{
+	return string::format("%s", *self, allocator: allocator ?: allocator::heap());
+}
+
+fn String ElasticArray.to_tstring(&self)
+{
+	return string::tformat("%s", *self);
+}
+
+fn void! ElasticArray.push_try(&self, Type element) @inline
+{
+	if (self.size == MAX_SIZE) return AllocationFailure.OUT_OF_MEMORY?;
+	self.entries[self.size++] = element;
+}
+
+/**
+ * @require self.size < MAX_SIZE `Tried to exceed the max size`
+ **/
+fn void ElasticArray.push(&self, Type element) @inline
+{
+	self.entries[self.size++] = element;
+}
+
+fn Type! ElasticArray.pop(&self)
+{
+	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	return self.entries[--self.size];
+}
+
+fn void ElasticArray.clear(&self)
+{
+	self.size = 0;
+}
+
+/**
+ * @require self.size > 0
+ **/
+fn Type! ElasticArray.pop_first(&self)
+{
+	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	defer self.remove_at(0);
+	return self.entries[0];
+}
+
+/**
+ * @require index < self.size
+ **/
+fn void ElasticArray.remove_at(&self, usz index)
+{
+	if (!--self.size || index == self.size) return;
+	self.entries[index .. self.size - 1] = self.entries[index + 1 .. self.size];
+}
+
+/**
+ * @require other_list.size + self.size <= MAX_SIZE
+ **/
+fn void ElasticArray.add_all(&self, ElasticArray* other_list)
+{
+	if (!other_list.size) return;
+	foreach (&value : other_list)
+	{
+		self.entries[self.size++] = *value;
+	}
+}
+
+/**
+ * Add as many elements as possible to the new array,
+ * returning the number of elements that didn't fit.
+ **/
+fn usz ElasticArray.add_all_to_limit(&self, ElasticArray* other_list)
+{
+	if (!other_list.size) return 0;
+	foreach (i, &value : other_list)
+	{
+		if (self.size == MAX_SIZE) return other_list.size - i;
+		self.entries[self.size++] = *value;
+	}
+	return 0;
+}
+
+/**
+ * Add as many values from this array as possible, returning the
+ * number of elements that didn't fit.
+ *
+ * @param [in] array
+ **/
+fn usz ElasticArray.add_array_to_limit(&self, Type[] array)
+{
+	if (!array.len) return 0;
+	foreach (i, &value : array)
+	{
+		if (self.size == MAX_SIZE) return array.len - i;
+		self.entries[self.size++] = *value;
+	}
+	return 0;
+}
+
+/**
+ * Add the values of an array to this list.
+ *
+ * @param [in] array
+ * @require array.len + self.size <= MAX_SIZE `Size would exceed max.`
+ * @ensure self.size >= array.len
+ **/
+fn void ElasticArray.add_array(&self, Type[] array)
+{
+	if (!array.len) return;
+	foreach (&value : array)
+	{
+		self.entries[self.size++] = *value;
+	}
+}
+
+
+
+/**
+ * IMPORTANT The returned array must be freed using free_aligned.
+ **/
+fn Type[] ElasticArray.to_new_aligned_array(&self)
+{
+	return list_common::list_to_new_aligned_array(Type, self, allocator::heap());
+}
+
+/**
+ * IMPORTANT The returned array must be freed using free_aligned.
+ **/
+fn Type[] ElasticArray.to_aligned_array(&self, Allocator allocator)
+{
+	return list_common::list_to_new_aligned_array(Type, self, allocator);
+}
+
+/**
+ * @require !type_is_overaligned() : "This function is not available on overaligned types"
+ **/
+macro Type[] ElasticArray.to_new_array(&self)
+{
+	return list_common::list_to_array(Type, self, allocator::heap());
+}
+
+/**
+ * @require !type_is_overaligned() : "This function is not available on overaligned types"
+ **/
+macro Type[] ElasticArray.to_array(&self, Allocator allocator)
+{
+	return list_common::list_to_new_array(Type, self, allocator);
+}
+
+fn Type[] ElasticArray.to_tarray(&self)
+{
+	$if type_is_overaligned():
+	return self.to_aligned_array(allocator::temp());
+	$else
+	return self.to_array(allocator::temp());
+	$endif;
+}
+
+/**
+ * Reverse the elements in a list.
+ **/
+fn void ElasticArray.reverse(&self)
+{
+	list_common::list_reverse(self);
+}
+
+fn Type[] ElasticArray.array_view(&self)
+{
+	return self.entries[:self.size];
+}
+
+/**
+ * @require self.size < MAX_SIZE `List would exceed max size`
+ **/
+fn void ElasticArray.push_front(&self, Type type) @inline
+{
+	self.insert_at(0, type);
+}
+
+/**
+ * @require self.size < MAX_SIZE `List would exceed max size`
+ **/
+fn void! ElasticArray.push_front_try(&self, Type type) @inline
+{
+	return self.insert_at_try(0, type);
+}
+
+/**
+ * @require index <= self.size
+ **/
+fn void! ElasticArray.insert_at_try(&self, usz index, Type value)
+{
+	if (self.size == MAX_SIZE) return AllocationFailure.OUT_OF_MEMORY?;
+	self.insert_at(index, value);
+}
+
+/**
+ * @require self.size < MAX_SIZE `List would exceed max size`
+ * @require index <= self.size
+ **/
+fn void ElasticArray.insert_at(&self, usz index, Type type)
+{
+	for (usz i = self.size; i > index; i--)
+	{
+		self.entries[i] = self.entries[i - 1];
+	}
+	self.size++;
+	self.entries[index] = type;
+}
+
+/**
+ * @require index < self.size
+ **/
+fn void ElasticArray.set_at(&self, usz index, Type type)
+{
+	self.entries[index] = type;
+}
+
+fn void! ElasticArray.remove_last(&self) @maydiscard
+{
+	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	self.size--;
+}
+
+fn void! ElasticArray.remove_first(&self) @maydiscard
+{
+	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	self.remove_at(0);
+}
+
+fn Type! ElasticArray.first(&self)
+{
+	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	return self.entries[0];
+}
+
+fn Type! ElasticArray.last(&self)
+{
+	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
+	return self.entries[self.size - 1];
+}
+
+fn bool ElasticArray.is_empty(&self) @inline
+{
+	return !self.size;
+}
+
+fn usz ElasticArray.byte_size(&self) @inline
+{
+	return Type.sizeof * self.size;
+}
+
+fn usz ElasticArray.len(&self) @operator(len) @inline
+{
+	return self.size;
+}
+
+fn Type ElasticArray.get(&self, usz index) @inline
+{
+	return self.entries[index];
+}
+
+fn void ElasticArray.swap(&self, usz i, usz j)
+{
+	@swap(self.entries[i], self.entries[j]);
+}
+
+/**
+ * @param filter "The function to determine if it should be removed or not"
+ * @return "the number of deleted elements"
+ **/
+fn usz ElasticArray.remove_if(&self, ElementPredicate filter)
+{
+	return list_common::list_remove_if(self, filter, false);
+}
+
+/**
+ * @param selection "The function to determine if it should be kept or not"
+ * @return "the number of deleted elements"
+ **/
+fn usz ElasticArray.retain_if(&self, ElementPredicate selection)
+{
+	return list_common::list_remove_if(self, selection, true);
+}
+
+fn usz ElasticArray.remove_using_test(&self, ElementTest filter, any context)
+{
+	return list_common::list_remove_using_test(self, filter, false, context);
+}
+
+fn usz ElasticArray.retain_using_test(&self, ElementTest filter, any context)
+{
+	return list_common::list_remove_using_test(self, filter, true, context);
+}
+
+
+macro Type ElasticArray.@item_at(&self, usz index) @operator([])
+{
+	return self.entries[index];
+}
+
+fn Type* ElasticArray.get_ref(&self, usz index) @operator(&[]) @inline
+{
+	return &self.entries[index];
+}
+
+fn void ElasticArray.set(&self, usz index, Type value) @operator([]=)
+{
+	self.entries[index] = value;
+}
+
+
+// Functions for equatable types
+fn usz! ElasticArray.index_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
+{
+	foreach (i, v : self)
+	{
+		if (equals(v, type)) return i;
+	}
+	return SearchResult.MISSING?;
+}
+
+fn usz! ElasticArray.rindex_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
+{
+	foreach_r (i, v : self)
+	{
+		if (equals(v, type)) return i;
+	}
+	return SearchResult.MISSING?;
+}
+
+fn bool ElasticArray.equals(&self, ElasticArray other_list) @if(ELEMENT_IS_EQUATABLE)
+{
+	if (self.size != other_list.size) return false;
+	foreach (i, v : self)
+	{
+		if (!equals(v, other_list.entries[i])) return false;
+	}
+	return true;
+}
+
+/**
+ * Check for presence of a value in a list.
+ *
+ * @param [&in] self "the list to find elements in"
+ * @param value "The value to search for"
+ * @return "True if the value is found, false otherwise"
+ **/
+fn bool ElasticArray.contains(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
+{
+	foreach (i, v : self)
+	{
+		if (equals(v, value)) return true;
+	}
+	return false;
+}
+
+/**
+ * @param [&inout] self "The list to remove elements from"
+ * @param value "The value to remove"
+ * @return "true if the value was found"
+ **/
+fn bool ElasticArray.remove_last_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
+{
+	return @ok(self.remove_at(self.rindex_of(value)));
+}
+
+/**
+ * @param [&inout] self "The list to remove elements from"
+ * @param value "The value to remove"
+ * @return "true if the value was found"
+ **/
+fn bool ElasticArray.remove_first_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
+{
+	return @ok(self.remove_at(self.index_of(value)));
+}
+
+/**
+ * @param [&inout] self "The list to remove elements from"
+ * @param value "The value to remove"
+ * @return "the number of deleted elements."
+ **/
+fn usz ElasticArray.remove_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
+{
+	return list_common::list_remove_item(self, value);
+}
+
+
+
+fn void ElasticArray.remove_all_from(&self, ElasticArray* other_list) @if(ELEMENT_IS_EQUATABLE)
+{
+	if (!other_list.size) return;
+	foreach (v : other_list) self.remove_item(v);
+}
+
+/**
+ * @param [&in] self
+ * @return "The number non-null values in the list"
+ **/
+fn usz ElasticArray.compact_count(&self) @if(ELEMENT_IS_POINTER)
+{
+	usz vals = 0;
+	foreach (v : self) if (v) vals++;
+	return vals;
+}
+
+fn usz ElasticArray.compact(&self) @if(ELEMENT_IS_POINTER)
+{
+	return list_common::list_compact(self);
+}

lib/std/collections/enummap.c3

@@ -1,3 +1,6 @@
+/**
+ * @require Enum.kindof == TypeKind.ENUM : "Only enums may be used with an enummap"
+ **/
 module std::collections::enummap(<Enum, ValueType>);
 import std::io;
 struct EnumMap (Printable)
@@ -25,9 +28,14 @@ fn usz! EnumMap.to_format(&self, Formatter* formatter) @dynamic
 	return n;
 }
 
-fn String EnumMap.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
+fn String EnumMap.to_string(&self, Allocator allocator) @dynamic
 {
-	return string::new_format("%s", *self, .allocator = allocator);
+	return string::format("%s", *self, allocator: allocator);
+}
+
+fn String EnumMap.to_new_string(&self, Allocator allocator = null) @dynamic
+{
+	return string::format("%s", *self, allocator: allocator ?: allocator::heap());
 }
 
 fn String EnumMap.to_tstring(&self) @dynamic

lib/std/collections/enumset.c3

@@ -3,7 +3,7 @@
 // a copy of which can be found in the LICENSE_STDLIB file.
 
 /**
- * @require Enum.kindof == TypeKind.ENUM : "Only enums maybe be used with an enumset"
+ * @require Enum.kindof == TypeKind.ENUM : "Only enums may be used with an enumset"
  **/
 module std::collections::enumset(<Enum>);
 import std::io;
@@ -143,7 +143,12 @@ fn usz! EnumSet.to_format(&set, Formatter* formatter) @dynamic
 
 fn String EnumSet.to_new_string(&set, Allocator allocator = allocator::heap()) @dynamic
 {
-	return string::new_format("%s", *set, .allocator = allocator);
+	return string::format("%s", *set, allocator: allocator);
+}
+
+fn String EnumSet.to_string(&set, Allocator allocator) @dynamic
+{
+	return string::format("%s", *set, allocator: allocator);
 }
 
 fn String EnumSet.to_tstring(&set) @dynamic

lib/std/collections/hashmap.c3

@@ -0,0 +1,523 @@
+// Copyright (c) 2023 Christoffer Lerno. All rights reserved.
+// Use of this source code is governed by the MIT license
+// a copy of which can be found in the LICENSE_STDLIB file.
+module std::collections::map(<Key, Value>);
+import std::math;
+
+struct HashMap
+{
+	Entry*[] table;
+	Allocator allocator;
+	uint count; // Number of elements
+	uint threshold; // Resize limit
+	float load_factor;
+}
+
+/**
+ * @param [&inout] allocator "The allocator to use"
+ * @require capacity > 0 "The capacity must be 1 or higher"
+ * @require load_factor > 0.0 "The load factor must be higher than 0"
+ * @require !self.allocator "Map was already initialized"
+ * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ **/
+fn HashMap* HashMap.new_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = null)
+{
+	return self.init(allocator ?: allocator::heap(), capacity, load_factor);
+}
+
+/**
+ * @param [&inout] allocator "The allocator to use"
+ * @require capacity > 0 "The capacity must be 1 or higher"
+ * @require load_factor > 0.0 "The load factor must be higher than 0"
+ * @require !self.allocator "Map was already initialized"
+ * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ **/
+fn HashMap* HashMap.init(&self, Allocator allocator, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	capacity = math::next_power_of_2(capacity);
+	self.allocator = allocator;
+	self.load_factor = load_factor;
+	self.threshold = (uint)(capacity * load_factor);
+	self.table = allocator::new_array(allocator, Entry*, capacity);
+	return self;
+}
+
+/**
+ * @require capacity > 0 "The capacity must be 1 or higher"
+ * @require load_factor > 0.0 "The load factor must be higher than 0"
+ * @require !self.allocator "Map was already initialized"
+ * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ **/
+fn HashMap* HashMap.temp_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	return self.init(allocator::temp(), capacity, load_factor) @inline;
+}
+
+/**
+ * @param [&inout] allocator "The allocator to use"
+ * @require $vacount % 2 == 0 "There must be an even number of arguments provided for keys and values"
+ * @require capacity > 0 "The capacity must be 1 or higher"
+ * @require load_factor > 0.0 "The load factor must be higher than 0"
+ * @require !self.allocator "Map was already initialized"
+ * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ **/
+macro HashMap* HashMap.new_init_with_key_values(&self, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
+{
+	self.new_init(capacity, load_factor, allocator);
+	$for (var $i = 0; $i < $vacount; $i += 2)
+		self.set($vaarg[$i], $vaarg[$i+1]);
+	$endfor
+	return self;
+}
+
+/**
+ * @param [in] keys "The keys for the HashMap entries"
+ * @param [in] values "The values for the HashMap entries"
+ * @param [&inout] allocator "The allocator to use"
+ * @require keys.len == values.len "Both keys and values arrays must be the same length"
+ * @require capacity > 0 "The capacity must be 1 or higher"
+ * @require load_factor > 0.0 "The load factor must be higher than 0"
+ * @require !self.allocator "Map was already initialized"
+ * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ **/
+fn HashMap* HashMap.new_init_from_keys_and_values(&self, Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
+{
+	assert(keys.len == values.len);
+	self.new_init(capacity, load_factor, allocator);
+	for (usz i = 0; i < keys.len; i++)
+	{
+		self.set(keys[i], values[i]);
+	}
+	return self;
+}
+
+/**
+ * @require $vacount % 2 == 0 "There must be an even number of arguments provided for keys and values"
+ * @require capacity > 0 "The capacity must be 1 or higher"
+ * @require load_factor > 0.0 "The load factor must be higher than 0"
+ * @require !self.allocator "Map was already initialized"
+ * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ **/
+macro HashMap* HashMap.temp_init_with_key_values(&self, ..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	self.temp_init(capacity, load_factor);
+	$for (var $i = 0; $i < $vacount; $i += 2)
+		self.set($vaarg[$i], $vaarg[$i+1]);
+	$endfor
+	return self;
+}
+
+/**
+ * @param [in] keys "The keys for the HashMap entries"
+ * @param [in] values "The values for the HashMap entries"
+ * @param [&inout] allocator "The allocator to use"
+ * @require keys.len == values.len "Both keys and values arrays must be the same length"
+ * @require capacity > 0 "The capacity must be 1 or higher"
+ * @require load_factor > 0.0 "The load factor must be higher than 0"
+ * @require !self.allocator "Map was already initialized"
+ * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ **/
+fn HashMap* HashMap.temp_init_from_keys_and_values(&self, Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
+{
+	assert(keys.len == values.len);
+	self.temp_init(capacity, load_factor);
+	for (usz i = 0; i < keys.len; i++)
+	{
+		self.set(keys[i], values[i]);
+	}
+	return self;
+}
+
+/**
+ * Has this hash map been initialized yet?
+ *
+ * @param [&in] map "The hash map we are testing"
+ * @return "Returns true if it has been initialized, false otherwise"
+ **/
+fn bool HashMap.is_initialized(&map)
+{
+	return (bool)map.allocator;
+}
+
+/**
+ * @param [&in] other_map "The map to copy from."
+ **/
+fn HashMap* HashMap.new_init_from_map(&self, HashMap* other_map)
+{
+	return self.init_from_map(other_map, allocator::heap()) @inline;
+}
+
+/**
+ * @param [&inout] allocator "The allocator to use"
+ * @param [&in] other_map "The map to copy from."
+ **/
+fn HashMap* HashMap.init_from_map(&self, HashMap* other_map, Allocator allocator)
+{
+	self.new_init(other_map.table.len, other_map.load_factor, allocator);
+	self.put_all_for_create(other_map);
+	return self;
+}
+
+/**
+ * @param [&in] other_map "The map to copy from."
+ **/
+fn HashMap* HashMap.temp_init_from_map(&map, HashMap* other_map)
+{
+	return map.init_from_map(other_map, allocator::temp()) @inline;
+}
+
+fn bool HashMap.is_empty(&map) @inline
+{
+	return !map.count;
+}
+
+fn usz HashMap.len(&map) @inline
+{
+	return map.count;
+}
+
+fn Value*! HashMap.get_ref(&map, Key key)
+{
+	if (!map.count) return SearchResult.MISSING?;
+	uint hash = rehash(key.hash());
+	for (Entry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key)) return &e.value;
+	}
+	return SearchResult.MISSING?;
+}
+
+fn Entry*! HashMap.get_entry(&map, Key key)
+{
+	if (!map.count) return SearchResult.MISSING?;
+	uint hash = rehash(key.hash());
+	for (Entry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key)) return e;
+	}
+	return SearchResult.MISSING?;
+}
+
+/**
+ * Get the value or update and
+ * @require $assignable(#expr, Value)
+ **/
+macro Value HashMap.@get_or_set(&map, Key key, Value #expr)
+{
+	if (!map.count)
+	{
+		Value val = #expr;
+		map.set(key, val);
+		return val;
+	}
+	uint hash = rehash(key.hash());
+	uint index = index_for(hash, map.table.len);
+	for (Entry *e = map.table[index]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key)) return e.value;
+	}
+	Value val = #expr;
+	map.add_entry(hash, key, val, index);
+	return val;
+}
+
+fn Value! HashMap.get(&map, Key key) @operator([])
+{
+	return *map.get_ref(key) @inline;
+}
+
+fn bool HashMap.has_key(&map, Key key)
+{
+	return @ok(map.get_ref(key));
+}
+
+fn bool HashMap.set(&map, Key key, Value value) @operator([]=)
+{
+	// If the map isn't initialized, use the defaults to initialize it.
+	if (!map.allocator)
+	{
+		map.new_init();
+	}
+	uint hash = rehash(key.hash());
+	uint index = index_for(hash, map.table.len);
+	for (Entry *e = map.table[index]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key))
+		{
+			e.value = value;
+			return true;
+		}
+	}
+	map.add_entry(hash, key, value, index);
+	return false;
+}
+
+fn void! HashMap.remove(&map, Key key) @maydiscard
+{
+	if (!map.remove_entry_for_key(key)) return SearchResult.MISSING?;
+}
+
+fn void HashMap.clear(&map)
+{
+	if (!map.count) return;
+	foreach (Entry** &entry_ref : map.table)
+	{
+		Entry* entry = *entry_ref;
+		if (!entry) continue;
+		Entry *next = entry.next;
+		while (next)
+		{
+			Entry *to_delete = next;
+			next = next.next;
+			map.free_entry(to_delete);
+		}
+		map.free_entry(entry);
+		*entry_ref = null;
+	}
+	map.count = 0;
+}
+
+fn void HashMap.free(&map)
+{
+	if (!map.allocator) return;
+	map.clear();
+	map.free_internal(map.table.ptr);
+	map.table = {};
+}
+
+fn Key[] HashMap.tcopy_keys(&map)
+{
+	return map.copy_keys(allocator::temp()) @inline;
+}
+
+fn Key[] HashMap.key_tlist(&map) @deprecated("Use 'tcopy_keys'")
+{
+	return map.copy_keys(allocator::temp()) @inline;
+}
+
+/**
+ * @deprecated "use copy_keys"
+ **/
+fn Key[] HashMap.key_new_list(&map, Allocator allocator = allocator::heap())
+{
+	return map.copy_keys() @inline;
+}
+
+fn Key[] HashMap.copy_keys(&map, Allocator allocator = allocator::heap())
+{
+	if (!map.count) return {};
+
+	Key[] list = allocator::alloc_array(allocator, Key, map.count);
+	usz index = 0;
+	foreach (Entry* entry : map.table)
+	{
+		while (entry)
+		{
+			list[index++] = entry.key;
+			entry = entry.next;
+		}
+	}
+	return list;
+}
+
+macro HashMap.@each(map; @body(key, value))
+{
+	map.@each_entry(; Entry* entry) {
+		@body(entry.key, entry.value);
+	};
+}
+
+macro HashMap.@each_entry(map; @body(entry))
+{
+	if (map.count)
+	{
+		foreach (Entry* entry : map.table)
+		{
+			while (entry)
+			{
+				@body(entry);
+				entry = entry.next;
+			}
+		}
+	}
+}
+
+/**
+ * @deprecated `use tcopy_values`
+ **/
+fn Value[] HashMap.value_tlist(&map)
+{
+	return map.copy_values(allocator::temp()) @inline;
+}
+
+fn Value[] HashMap.tcopy_values(&map)
+{
+	return map.copy_values(allocator::temp()) @inline;
+}
+
+/**
+ * @deprecated `use copy_values`
+ **/
+fn Value[] HashMap.value_new_list(&map, Allocator allocator = allocator::heap())
+{
+	return map.copy_values(allocator);
+}
+
+fn Value[] HashMap.copy_values(&map, Allocator allocator = allocator::heap())
+{
+	if (!map.count) return {};
+	Value[] list = allocator::alloc_array(allocator, Value, map.count);
+	usz index = 0;
+	foreach (Entry* entry : map.table)
+	{
+		while (entry)
+		{
+			list[index++] = entry.value;
+			entry = entry.next;
+		}
+	}
+	return list;
+}
+
+fn bool HashMap.has_value(&map, Value v) @if(VALUE_IS_EQUATABLE)
+{
+	if (!map.count) return false;
+	foreach (Entry* entry : map.table)
+	{
+		while (entry)
+		{
+			if (equals(v, entry.value)) return true;
+			entry = entry.next;
+		}
+	}
+	return false;
+}
+
+// --- private methods
+
+fn void HashMap.add_entry(&map, uint hash, Key key, Value value, uint bucket_index) @private
+{
+	$if COPY_KEYS:
+	key = key.copy(map.allocator);
+	$endif
+	Entry* entry = allocator::new(map.allocator, Entry, { .hash = hash, .key = key, .value = value, .next = map.table[bucket_index] });
+	map.table[bucket_index] = entry;
+	if (map.count++ >= map.threshold)
+	{
+		map.resize(map.table.len * 2);
+	}
+}
+
+fn void HashMap.resize(&map, uint new_capacity) @private
+{
+	Entry*[] old_table = map.table;
+	uint old_capacity = old_table.len;
+	if (old_capacity == MAXIMUM_CAPACITY)
+	{
+		map.threshold = uint.max;
+		return;
+	}
+	Entry*[] new_table = allocator::new_array(map.allocator, Entry*, new_capacity);
+	map.transfer(new_table);
+	map.table = new_table;
+	map.free_internal(old_table.ptr);
+	map.threshold = (uint)(new_capacity * map.load_factor);
+}
+
+fn void HashMap.transfer(&map, Entry*[] new_table) @private
+{
+	Entry*[] src = map.table;
+	uint new_capacity = new_table.len;
+	foreach (uint j, Entry *e : src)
+	{
+		if (!e) continue;
+		do
+		{
+			Entry* next = e.next;
+			uint i = index_for(e.hash, new_capacity);
+			e.next = new_table[i];
+			new_table[i] = e;
+			e = next;
+		}
+		while (e);
+	}
+}
+
+fn void HashMap.put_all_for_create(&map, HashMap* other_map) @private
+{
+	if (!other_map.count) return;
+	foreach (Entry *e : other_map.table)
+	{
+		if (!e) continue;
+		map.put_for_create(e.key, e.value);
+	}
+}
+
+fn void HashMap.put_for_create(&map, Key key, Value value) @private
+{
+	uint hash = rehash(key.hash());
+	uint i = index_for(hash, map.table.len);
+	for (Entry *e = map.table[i]; e != null; e = e.next)
+	{
+		if (e.hash == hash && equals(key, e.key))
+		{
+			e.value = value;
+			return;
+		}
+	}
+	map.create_entry(hash, key, value, i);
+}
+
+fn void HashMap.free_internal(&map, void* ptr) @inline @private
+{
+	allocator::free(map.allocator, ptr);
+}
+
+fn bool HashMap.remove_entry_for_key(&map, Key key) @private
+{
+	uint hash = rehash(key.hash());
+	uint i = index_for(hash, map.table.len);
+	Entry* prev = map.table[i];
+	Entry* e = prev;
+	while (e)
+	{
+		Entry *next = e.next;
+		if (e.hash == hash && equals(key, e.key))
+		{
+			map.count--;
+			if (prev == e)
+			{
+				map.table[i] = next;
+			}
+			else
+			{
+				prev.next = next;
+			}
+			map.free_entry(e);
+			return true;
+		}
+		prev = e;
+		e = next;
+	}
+	return false;
+}
+
+fn void HashMap.create_entry(&map, uint hash, Key key, Value value, int bucket_index) @private
+{
+	Entry *e = map.table[bucket_index];
+	$if COPY_KEYS:
+	key = key.copy(map.allocator);
+	$endif
+	Entry* entry = allocator::new(map.allocator, Entry, { .hash = hash, .key = key, .value = value, .next = map.table[bucket_index] });
+	map.table[bucket_index] = entry;
+	map.count++;
+}
+
+fn void HashMap.free_entry(&self, Entry *entry) @local
+{
+	$if COPY_KEYS:
+	allocator::free(self.allocator, entry.key);
+	$endif
+	self.free_internal(entry);
+}
+

lib/std/collections/linkedlist.c3

@@ -24,16 +24,24 @@ struct LinkedList
  * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
  * @return "the initialized list"
  **/
-fn LinkedList* LinkedList.new_init(&self, Allocator allocator = allocator::heap())
+fn LinkedList* LinkedList.init(&self, Allocator allocator)
 {
 	*self = { .allocator = allocator };
 	return self;
 }
 
+/**
+ * @return "the initialized list"
+ **/
+fn LinkedList* LinkedList.new_init(&self)
+{
+	return self.init(allocator::heap()) @inline;
+}
+
 
 fn LinkedList* LinkedList.temp_init(&self)
 {
-	return self.new_init(allocator::temp()) @inline;
+	return self.init(allocator::temp()) @inline;
 }
 
 /**

lib/std/collections/list.c3

@@ -2,7 +2,7 @@
 // Use of self source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::collections::list(<Type>);
-import std::io,std::math;
+import std::io, std::math, std::collections::list_common;
 
 def ElementPredicate = fn bool(Type *type);
 def ElementTest = fn bool(Type *type, any context);
@@ -27,20 +27,9 @@ fn List* List.new_init(&self, usz initial_capacity = 16, Allocator allocator = a
 {
 	self.allocator = allocator;
 	self.size = 0;
-	if (initial_capacity > 0)
-	{
-		initial_capacity = math::next_power_of_2(initial_capacity);
-		$if type_is_overaligned():
-		self.entries = allocator::malloc_aligned(allocator, Type.sizeof * initial_capacity, .alignment = Type[1].alignof)!!;
-		$else
-		self.entries = allocator::malloc(allocator, Type.sizeof * initial_capacity);
-		$endif
-	}
-	else
-	{
-		self.entries = null;
-	}
-	self.capacity = initial_capacity;
+	self.capacity = 0;
+	self.entries = null;
+	self.reserve(initial_capacity);
 	return self;
 }
 
@@ -81,14 +70,14 @@ fn List* List.temp_init_with_array(&self, Type[] values)
 }
 
 /**
- * @require self.size == 0 "The List must be empty"
+ * @require self.capacity == 0 "The List must not be allocated"
  **/
 fn void List.init_wrapping_array(&self, Type[] types, Allocator allocator = allocator::heap())
 {
 	self.allocator = allocator;
-	self.size = types.len;
 	self.capacity = types.len;
 	self.entries = types.ptr;
+	self.set_size(types.len);
 }
 
 fn usz! List.to_format(&self, Formatter* formatter) @dynamic
@@ -113,7 +102,7 @@ fn usz! List.to_format(&self, Formatter* formatter) @dynamic
 
 fn String List.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
 {
-	return string::new_format("%s", *self, .allocator = allocator);
+	return string::format("%s", *self, allocator: allocator);
 }
 
 fn String List.to_tstring(&self)
@@ -123,19 +112,20 @@ fn String List.to_tstring(&self)
 
 fn void List.push(&self, Type element) @inline
 {
-	self.ensure_capacity();
-	self.entries[self.size++] = element;
+	self.reserve(1);
+	self.entries[self.set_size(self.size + 1)] = element;
 }
 
 fn Type! List.pop(&self)
 {
 	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	return self.entries[--self.size];
+	defer self.set_size(self.size - 1);
+	return self.entries[self.size - 1];
 }
 
 fn void List.clear(&self)
 {
-	self.size = 0;
+	self.set_size(0);
 }
 
 /**
@@ -153,7 +143,8 @@ fn Type! List.pop_first(&self)
  **/
 fn void List.remove_at(&self, usz index)
 {
-	if (!--self.size || index == self.size) return;
+	self.set_size(self.size - 1);
+	if (!self.size || index == self.size) return;
 	self.entries[index .. self.size - 1] = self.entries[index + 1 .. self.size];
 }
 
@@ -161,9 +152,10 @@ fn void List.add_all(&self, List* other_list)
 {
 	if (!other_list.size) return;
 	self.reserve(other_list.size);
+	usz index = self.set_size(self.size + other_list.size);
 	foreach (&value : other_list)
 	{
-		self.entries[self.size++] = *value;
+		self.entries[index++] = *value;
 	}
 }
 
@@ -173,10 +165,7 @@ fn void List.add_all(&self, List* other_list)
  **/
 fn Type[] List.to_new_aligned_array(&self, Allocator allocator = allocator::heap())
 {
-	if (!self.size) return Type[] {};
-	Type[] result = allocator::alloc_array_aligned(allocator, Type, self.size);
-	result[..] = self.entries[:self.size];
-	return result;
+	return list_common::list_to_new_aligned_array(Type, self, allocator);
 }
 
 /**
@@ -184,10 +173,7 @@ fn Type[] List.to_new_aligned_array(&self, Allocator allocator = allocator::heap
  **/
 macro Type[] List.to_new_array(&self, Allocator allocator = allocator::heap())
 {
-	if (!self.size) return Type[] {};
-	Type[] result = allocator::alloc_array(allocator, Type, self.size);
-	result[..] = self.entries[:self.size];
-	return result;
+	return list_common::list_to_new_array(Type, self, allocator);
 }
 
 fn Type[] List.to_tarray(&self)
@@ -204,13 +190,7 @@ fn Type[] List.to_tarray(&self)
  **/
 fn void List.reverse(&self)
 {
-	if (self.size < 2) return;
-	usz half = self.size / 2U;
-	usz end = self.size - 1;
-	for (usz i = 0; i < half; i++)
-	{
-		@swap(self.entries[i], self.entries[end - i]);
-	}
+	list_common::list_reverse(self);
 }
 
 fn Type[] List.array_view(&self)
@@ -228,10 +208,8 @@ fn void List.add_array(&self, Type[] array)
 {
 	if (!array.len) return;
 	self.reserve(array.len);
-	foreach (&value : array)
-	{
-		self.entries[self.size++] = *value;
-	}
+	usz index = self.set_size(self.size + array.len);
+	self.entries[index : array.len] = array[..];
 }
 
 fn void List.push_front(&self, Type type) @inline
@@ -240,16 +218,16 @@ fn void List.push_front(&self, Type type) @inline
 }
 
 /**
- * @require index < self.size
+ * @require index <= self.size
  **/
 fn void List.insert_at(&self, usz index, Type type)
 {
-	self.ensure_capacity();
+	self.reserve(1);
 	for (usz i = self.size; i > index; i--)
 	{
 		self.entries[i] = self.entries[i - 1];
 	}
-	self.size++;
+	self.set_size(self.size + 1);
 	self.entries[index] = type;
 }
 
@@ -264,7 +242,7 @@ fn void List.set_at(&self, usz index, Type type)
 fn void! List.remove_last(&self) @maydiscard
 {
 	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	self.size--;
+	self.set_size(self.size - 1);
 }
 
 fn void! List.remove_first(&self) @maydiscard
@@ -307,11 +285,14 @@ fn Type List.get(&self, usz index) @inline
 
 fn void List.free(&self)
 {
-	if (!self.allocator) return;
+	if (!self.allocator || !self.capacity) return;
+
+	self.pre_free(); // Remove sanitizer annotation
+
 	$if type_is_overaligned():
-	allocator::free_aligned(self.allocator, self.entries);
+		allocator::free_aligned(self.allocator, self.entries);
 	$else
-	allocator::free(self.allocator, self.entries);
+		allocator::free(self.allocator, self.entries);
 	$endif;
 	self.capacity = 0;
 	self.size = 0;
@@ -329,7 +310,7 @@ fn void List.swap(&self, usz i, usz j)
  **/
 fn usz List.remove_if(&self, ElementPredicate filter)
 {
-	return self._remove_if(filter, false);
+	return list_common::list_remove_if(self, filter, false);
 }
 
 /**
@@ -338,84 +319,46 @@ fn usz List.remove_if(&self, ElementPredicate filter)
  **/
 fn usz List.retain_if(&self, ElementPredicate selection)
 {
-	return self._remove_if(selection, true);
-}
-
-macro usz List._remove_if(&self, ElementPredicate filter, bool $invert) @local
-{
-	usz size = self.size;
-	for (usz i = size, usz k = size; k > 0; k = i)
-	{
-		// Find last index of item to be deleted.
-		$if $invert:
-			while (i > 0 && !filter(&self.entries[i - 1])) i--;
-		$else
-			while (i > 0 && filter(&self.entries[i - 1])) i--;
-		$endif
-		// Remove the items from this index up to the one not to be deleted.
-		usz n = self.size - k;
-		self.entries[i:n] = self.entries[k:n];
-		self.size -= k - i;
-		// Find last index of item not to be deleted.
-		$if $invert:
-			while (i > 0 && filter(&self.entries[i - 1])) i--;
-		$else
-			while (i > 0 && !filter(&self.entries[i - 1])) i--;
-		$endif
-	}
-	return size - self.size;
+	return list_common::list_remove_if(self, selection, true);
 }
 
 fn usz List.remove_using_test(&self, ElementTest filter, any context)
 {
-	return self._remove_using_test(filter, false, context);
+	usz old_size = self.size;
+	defer {
+		if (old_size != self.size) self._update_size_change(old_size, self.size);
+	}
+	return list_common::list_remove_using_test(self, filter, false, context);
 }
 
+
+
 fn usz List.retain_using_test(&self, ElementTest filter, any context)
 {
-	return self._remove_using_test(filter, true, context);
-}
-
-macro usz List._remove_using_test(&self, ElementTest filter, bool $invert, ctx) @local
-{
-	usz size = self.size;
-	for (usz i = size, usz k = size; k > 0; k = i)
-	{
-		// Find last index of item to be deleted.
-		$if $invert:
-			while (i > 0 && !filter(&self.entries[i - 1], ctx)) i--;
-		$else
-			while (i > 0 && filter(&self.entries[i - 1], ctx)) i--;
-		$endif
-		// Remove the items from this index up to the one not to be deleted.
-		usz n = self.size - k;
-		self.entries[i:n] = self.entries[k:n];
-		self.size -= k - i;
-		// Find last index of item not to be deleted.
-		$if $invert:
-			while (i > 0 && filter(&self.entries[i - 1], ctx)) i--;
-		$else
-			while (i > 0 && !filter(&self.entries[i - 1], ctx)) i--;
-		$endif
+	usz old_size = self.size;
+	defer {
+		if (old_size != self.size) self._update_size_change(old_size, self.size);
 	}
-	return size - self.size;
+	return list_common::list_remove_using_test(self, filter, true, context);
 }
 
-/**
- * Reserve at least min_capacity
- **/
-fn void List.reserve(&self, usz min_capacity)
+fn void List.ensure_capacity(&self, usz min_capacity) @local
 {
 	if (!min_capacity) return;
 	if (self.capacity >= min_capacity) return;
 	if (!self.allocator) self.allocator = allocator::heap();
+
+	self.pre_free(); // Remove sanitizer annotation
+
 	min_capacity = math::next_power_of_2(min_capacity);
 	$if type_is_overaligned():
-	self.entries = allocator::realloc_aligned(self.allocator, self.entries, Type.sizeof * min_capacity, .alignment = Type[1].alignof)!!;
+		self.entries = allocator::realloc_aligned(self.allocator, self.entries, Type.sizeof * min_capacity, alignment: Type[1].alignof)!!;
 	$else
-	self.entries = allocator::realloc(self.allocator, self.entries, Type.sizeof * min_capacity);
+		self.entries = allocator::realloc(self.allocator, self.entries, Type.sizeof * min_capacity);
 	$endif;
 	self.capacity = min_capacity;
+
+	self.post_alloc(); // Add sanitizer annotation
 }
 
 macro Type List.@item_at(&self, usz index) @operator([])
@@ -433,7 +376,7 @@ fn void List.set(&self, usz index, Type value) @operator([]=)
 	self.entries[index] = value;
 }
 
-fn void List.ensure_capacity(&self, usz added = 1) @inline @private
+fn void List.reserve(&self, usz added)
 {
 	usz new_size = self.size + added;
 	if (self.capacity >= new_size) return;
@@ -441,7 +384,40 @@ fn void List.ensure_capacity(&self, usz added = 1) @inline @private
 	assert(new_size < usz.max / 2U);
 	usz new_capacity = self.capacity ? 2U * self.capacity : 16U;
 	while (new_capacity < new_size) new_capacity *= 2U;
-	self.reserve(new_capacity);
+	self.ensure_capacity(new_capacity);
+}
+
+fn void List._update_size_change(&self,usz old_size, usz new_size)
+{
+	if (old_size == new_size) return;
+	sanitizer::annotate_contiguous_container(self.entries,
+	                                         &self.entries[self.capacity],
+	                                         &self.entries[old_size],
+	                                         &self.entries[new_size]);
+}
+/**
+ * @require new_size == 0 || self.capacity != 0
+ **/
+fn usz List.set_size(&self, usz new_size) @inline @private
+{
+	usz old_size = self.size;
+	self._update_size_change(old_size, new_size);
+	self.size = new_size;
+	return old_size;
+}
+
+macro void List.pre_free(&self) @private
+{
+	if (!self.capacity) return;
+	self._update_size_change(self.size, self.capacity);
+}
+
+/**
+ * @require self.capacity
+ **/
+macro void List.post_alloc(&self) @private
+{
+	self._update_size_change(self.capacity, self.size);
 }
 
 // Functions for equatable types
@@ -510,7 +486,6 @@ fn bool List.remove_first_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
 {
 	return @ok(self.remove_at(self.index_of(value)));
 }
-
 /**
  * @param [&inout] self "The list to remove elements from"
  * @param value "The value to remove"
@@ -518,17 +493,11 @@ fn bool List.remove_first_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
  **/
 fn usz List.remove_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
 {
-	usz size = self.size;
-	for (usz i = size; i > 0; i--)
-	{
-		if (!equals(self.entries[i - 1], value)) continue;
-		for (usz j = i; j < self.size; j++)
-		{
-			self.entries[j - 1] = self.entries[j];
-		}
-		self.size--;
+	usz old_size = self.size;
+	defer {
+		if (old_size != self.size) self._update_size_change(old_size, self.size);
 	}
-	return size - self.size;
+	return list_common::list_remove_item(self, value);
 }
 
 
@@ -536,6 +505,10 @@ fn usz List.remove_item(&self, Type value) @if(ELEMENT_IS_EQUATABLE)
 fn void List.remove_all_from(&self, List* other_list) @if(ELEMENT_IS_EQUATABLE)
 {
 	if (!other_list.size) return;
+	usz old_size = self.size;
+	defer {
+		if (old_size != self.size) self._update_size_change(old_size, self.size);
+	}
 	foreach (v : other_list) self.remove_item(v);
 }
 
@@ -552,17 +525,11 @@ fn usz List.compact_count(&self) @if(ELEMENT_IS_POINTER)
 
 fn usz List.compact(&self) @if(ELEMENT_IS_POINTER)
 {
-	usz size = self.size;
-	for (usz i = size; i > 0; i--)
-	{
-		if (self.entries[i - 1]) continue;
-		for (usz j = i; j < size; j++)
-		{
-			self.entries[j - 1] = self.entries[j];
-		}
-		self.size--;
+	usz old_size = self.size;
+	defer {
+		if (old_size != self.size) self._update_size_change(old_size, self.size);
 	}
-	return size - self.size;
+	return list_common::list_compact(self);
 }
 
 // --> Deprecated

lib/std/collections/list_common.c3

@@ -0,0 +1,112 @@
+module std::collections::list_common;
+
+/**
+ * IMPORTANT The returned array must be freed using free_aligned.
+ **/
+macro list_to_new_aligned_array($Type, self, Allocator allocator)
+{
+	if (!self.size) return $Type[] {};
+	$Type[] result = allocator::alloc_array_aligned(allocator, $Type, self.size);
+	result[..] = self.entries[:self.size];
+	return result;
+}
+
+macro list_to_new_array($Type, self, Allocator allocator)
+{
+	if (!self.size) return $Type[] {};
+	$Type[] result = allocator::alloc_array(allocator, $Type, self.size);
+	result[..] = self.entries[:self.size];
+	return result;
+}
+
+macro void list_reverse(self)
+{
+	if (self.size < 2) return;
+	usz half = self.size / 2U;
+	usz end = self.size - 1;
+	for (usz i = 0; i < half; i++)
+	{
+		@swap(self.entries[i], self.entries[end - i]);
+	}
+}
+
+macro usz list_remove_using_test(self, filter, bool $invert, ctx)
+{
+	usz size = self.size;
+	for (usz i = size, usz k = size; k > 0; k = i)
+	{
+		// Find last index of item to be deleted.
+		$if $invert:
+			while (i > 0 && !filter(&self.entries[i - 1], ctx)) i--;
+		$else
+			while (i > 0 && filter(&self.entries[i - 1], ctx)) i--;
+		$endif
+		// Remove the items from this index up to the one not to be deleted.
+		usz n = self.size - k;
+		self.entries[i:n] = self.entries[k:n];
+		self.size -= k - i;
+		// Find last index of item not to be deleted.
+		$if $invert:
+			while (i > 0 && filter(&self.entries[i - 1], ctx)) i--;
+		$else
+			while (i > 0 && !filter(&self.entries[i - 1], ctx)) i--;
+		$endif
+	}
+	return size - self.size;
+}
+
+macro usz list_compact(self)
+{
+	usz size = self.size;
+	for (usz i = size; i > 0; i--)
+	{
+		if (self.entries[i - 1]) continue;
+		for (usz j = i; j < size; j++)
+		{
+			self.entries[j - 1] = self.entries[j];
+		}
+		self.size--;
+	}
+	return size - self.size;
+}
+
+macro usz list_remove_item(self, value)
+{
+	usz size = self.size;
+	for (usz i = size; i > 0; i--)
+	{
+		if (!equals(self.entries[i - 1], value)) continue;
+		for (usz j = i; j < self.size; j++)
+		{
+			self.entries[j - 1] = self.entries[j];
+		}
+		self.size--;
+	}
+	return size - self.size;
+}
+
+
+macro usz list_remove_if(self, filter, bool $invert)
+{
+	usz size = self.size;
+	for (usz i = size, usz k = size; k > 0; k = i)
+	{
+		// Find last index of item to be deleted.
+		$if $invert:
+			while (i > 0 && !filter(&self.entries[i - 1])) i--;
+		$else
+			while (i > 0 && filter(&self.entries[i - 1])) i--;
+		$endif
+		// Remove the items from this index up to the one not to be deleted.
+		usz n = self.size - k;
+		self.entries[i:n] = self.entries[k:n];
+		self.size -= k - i;
+		// Find last index of item not to be deleted.
+		$if $invert:
+			while (i > 0 && filter(&self.entries[i - 1])) i--;
+		$else
+			while (i > 0 && !filter(&self.entries[i - 1])) i--;
+		$endif
+	}
+	return size - self.size;
+}

lib/std/collections/map.c3

@@ -10,7 +10,9 @@ const float DEFAULT_LOAD_FACTOR = 0.75;
 const VALUE_IS_EQUATABLE = Value.is_eq;
 const bool COPY_KEYS = types::implements_copy(Key);
 
-struct HashMap
+distinct Map = void*;
+
+struct MapImpl
 {
 	Entry*[] table;
 	Allocator allocator;
@@ -20,77 +22,143 @@ struct HashMap
 }
 
 /**
- * @param [&inout] allocator "The allocator to use"
  * @require capacity > 0 "The capacity must be 1 or higher"
  * @require load_factor > 0.0 "The load factor must be higher than 0"
- * @require !self.allocator "Map was already initialized"
  * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
  **/
-fn HashMap* HashMap.new_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
+fn Map new(uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
 {
-	capacity = math::next_power_of_2(capacity);
-	self.allocator = allocator;
-	self.load_factor = load_factor;
-	self.threshold = (uint)(capacity * load_factor);
-	self.table = allocator::new_array(allocator, Entry*, capacity);
-	return self;
+	MapImpl* map = allocator::alloc(allocator, MapImpl);
+	_init(map, capacity, load_factor, allocator);
+	return (Map)map;
 }
 
 /**
  * @require capacity > 0 "The capacity must be 1 or higher"
  * @require load_factor > 0.0 "The load factor must be higher than 0"
- * @require !self.allocator "Map was already initialized"
  * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
  **/
-fn HashMap* HashMap.temp_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+fn Map temp(uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
 {
-	return self.new_init(capacity, load_factor, allocator::temp()) @inline;
-}
-
-
-/**
- * Has this hash map been initialized yet?
- *
- * @param [&in] map "The hash map we are testing"
- * @return "Returns true if it has been initialized, false otherwise"
- **/
-fn bool HashMap.is_initialized(&map)
-{
-	return (bool)map.allocator;
+	MapImpl* map = mem::temp_alloc(MapImpl);
+	_init(map, capacity, load_factor, allocator::temp());
+	return (Map)map;
 }
 
 /**
  * @param [&inout] allocator "The allocator to use"
- * @param [&in] other_map "The map to copy from."
+ * @require $vacount % 2 == 0 "There must be an even number of arguments provided for keys and values"
+ * @require capacity > 0 "The capacity must be 1 or higher"
+ * @require load_factor > 0.0 "The load factor must be higher than 0"
+ * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
  **/
-fn HashMap* HashMap.new_init_from_map(&self, HashMap* other_map, Allocator allocator = allocator::heap())
+macro Map new_init_with_key_values(..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
 {
-	self.new_init(other_map.table.len, other_map.load_factor, allocator);
-	self.put_all_for_create(other_map);
-	return self;
+	Map map = new(capacity, load_factor, allocator);
+	$for (var $i = 0; $i < $vacount; $i += 2)
+		map.set($vaarg[$i], $vaarg[$i+1]);
+	$endfor
+	return map;
+}
+
+/**
+ * @param [in] keys "Array of keys for the Map entries"
+ * @param [in] values "Array of values for the Map entries"
+ * @param [&inout] allocator "The allocator to use"
+ * @require keys.len == values.len "Both keys and values arrays must be the same length"
+ * @require capacity > 0 "The capacity must be 1 or higher"
+ * @require load_factor > 0.0 "The load factor must be higher than 0"
+ * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ **/
+fn Map new_init_from_keys_and_values(Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
+{
+	assert(keys.len == values.len);
+	Map map = new(capacity, load_factor, allocator);
+	for (usz i = 0; i < keys.len; i++)
+	{
+		map.set(keys[i], values[i]);
+	}
+	return map;
+}
+
+/**
+ * @require $vacount % 2 == 0 "There must be an even number of arguments provided for keys and values"
+ * @require capacity > 0 "The capacity must be 1 or higher"
+ * @require load_factor > 0.0 "The load factor must be higher than 0"
+ * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ **/
+macro Map temp_new_with_key_values(..., uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
+{
+	Map map = temp(capacity, load_factor);
+	$for (var $i = 0; $i < $vacount; $i += 2)
+		map.set($vaarg[$i], $vaarg[$i+1]);
+	$endfor
+	return map;
+}
+
+/**
+ * @param [in] keys "The keys for the HashMap entries"
+ * @param [in] values "The values for the HashMap entries"
+ * @param [&inout] allocator "The allocator to use"
+ * @require keys.len == values.len "Both keys and values arrays must be the same length"
+ * @require capacity > 0 "The capacity must be 1 or higher"
+ * @require load_factor > 0.0 "The load factor must be higher than 0"
+ * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ **/
+fn Map temp_init_from_keys_and_values(Key[] keys, Value[] values, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator allocator = allocator::heap())
+{
+	assert(keys.len == values.len);
+	Map map = temp(capacity, load_factor);
+	for (usz i = 0; i < keys.len; i++)
+	{
+		map.set(keys[i], values[i]);
+	}
+	return map;
 }
 
 /**
  * @param [&in] other_map "The map to copy from."
  **/
-fn HashMap* HashMap.temp_init_from_map(&map, HashMap* other_map)
+fn Map new_from_map(Map other_map, Allocator allocator = null)
 {
-	return map.new_init_from_map(other_map, allocator::temp()) @inline;
+	MapImpl* other_map_impl = (MapImpl*)other_map;
+	if (!other_map_impl)
+	{
+		if (allocator) return new(allocator: allocator);
+		return null;
+	}
+	MapImpl* map = (MapImpl*)new(other_map_impl.table.len, other_map_impl.load_factor, allocator ?: allocator::heap());
+	if (!other_map_impl.count) return (Map)map;
+	foreach (Entry *e : other_map_impl.table)
+    {
+    	if (!e) continue;
+    	map._put_for_create(e.key, e.value);
+    }
+	return (Map)map;
 }
 
-fn bool HashMap.is_empty(&map) @inline
+/**
+ * @param [&in] other_map "The map to copy from."
+ **/
+fn Map temp_from_map(Map other_map)
 {
-	return !map.count;
+	return new_from_map(other_map, allocator::temp());
 }
 
-fn usz HashMap.len(&map) @inline
+fn bool Map.is_empty(map) @inline
 {
-	return map.count;
+	return !map || !((MapImpl*)map).count;
 }
 
-fn Value*! HashMap.get_ref(&map, Key key)
+fn usz Map.len(map) @inline
 {
-	if (!map.count) return SearchResult.MISSING?;
+	return map ? ((MapImpl*)map).count : 0;
+}
+
+fn Value*! Map.get_ref(self, Key key)
+{
+	MapImpl *map = (MapImpl*)self;
+	if (!map || !map.count) return SearchResult.MISSING?;
 	uint hash = rehash(key.hash());
 	for (Entry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
 	{
@@ -99,11 +167,12 @@ fn Value*! HashMap.get_ref(&map, Key key)
 	return SearchResult.MISSING?;
 }
 
-fn Entry*! HashMap.get_entry(&map, Key key)
+fn Entry*! Map.get_entry(map, Key key)
 {
-	if (!map.count) return SearchResult.MISSING?;
+	MapImpl *map_impl = (MapImpl*)map;
+	if (!map_impl || !map_impl.count) return SearchResult.MISSING?;
 	uint hash = rehash(key.hash());
-	for (Entry *e = map.table[index_for(hash, map.table.len)]; e != null; e = e.next)
+	for (Entry *e = map_impl.table[index_for(hash, map_impl.table.len)]; e != null; e = e.next)
 	{
 		if (e.hash == hash && equals(key, e.key)) return e;
 	}
@@ -114,9 +183,10 @@ fn Entry*! HashMap.get_entry(&map, Key key)
  * Get the value or update and
  * @require $assignable(#expr, Value)
  **/
-macro Value HashMap.@get_or_set(&map, Key key, Value #expr)
+macro Value Map.@get_or_set(&self, Key key, Value #expr)
 {
-	if (!map.count)
+	MapImpl *map = (MapImpl*)*self;
+	if (!map || !map.count)
 	{
 		Value val = #expr;
 		map.set(key, val);
@@ -133,23 +203,27 @@ macro Value HashMap.@get_or_set(&map, Key key, Value #expr)
 	return val;
 }
 
-fn Value! HashMap.get(&map, Key key) @operator([])
+fn Value! Map.get(map, Key key) @operator([])
 {
 	return *map.get_ref(key) @inline;
 }
 
-fn bool HashMap.has_key(&map, Key key)
+fn bool Map.has_key(map, Key key)
 {
 	return @ok(map.get_ref(key));
 }
 
-fn bool HashMap.set(&map, Key key, Value value) @operator([]=)
+macro Value Map.set_value_return(&map, Key key, Value value) @operator([]=)
+{
+	map.set(key, value);
+	return value;
+}
+
+fn bool Map.set(&self, Key key, Value value)
 {
 	// If the map isn't initialized, use the defaults to initialize it.
-	if (!map.allocator)
-	{
-		map.new_init();
-	}
+	if (!*self) *self = new();
+	MapImpl* map = (MapImpl*)*self;
 	uint hash = rehash(key.hash());
 	uint index = index_for(hash, map.table.len);
 	for (Entry *e = map.table[index]; e != null; e = e.next)
@@ -160,18 +234,19 @@ fn bool HashMap.set(&map, Key key, Value value) @operator([]=)
 			return true;
 		}
 	}
-	map.add_entry(hash, key, value, index);
+	map._add_entry(hash, key, value, index);
 	return false;
 }
 
-fn void! HashMap.remove(&map, Key key) @maydiscard
+fn void! Map.remove(map, Key key) @maydiscard
 {
-	if (!map.remove_entry_for_key(key)) return SearchResult.MISSING?;
+	if (!map || !((MapImpl*)map)._remove_entry_for_key(key)) return SearchResult.MISSING?;
 }
 
-fn void HashMap.clear(&map)
+fn void Map.clear(self)
 {
-	if (!map.count) return;
+	MapImpl* map = (MapImpl*)self;
+	if (!map || !map.count) return;
 	foreach (Entry** &entry_ref : map.table)
 	{
 		Entry* entry = *entry_ref;
@@ -181,30 +256,33 @@ fn void HashMap.clear(&map)
 		{
 			Entry *to_delete = next;
 			next = next.next;
-			map.free_entry(to_delete);
+			map._free_entry(to_delete);
 		}
-		map.free_entry(entry);
+		map._free_entry(entry);
 		*entry_ref = null;
 	}
 	map.count = 0;
 }
 
-fn void HashMap.free(&map)
+fn void Map.free(self)
 {
-	if (!map.allocator) return;
-	map.clear();
-	map.free_internal(map.table.ptr);
+	if (!self) return;
+	MapImpl* map = (MapImpl*)self;
+	self.clear();
+	map._free_internal(map.table.ptr);
 	map.table = {};
+	allocator::free(map.allocator, map);
 }
 
-fn Key[] HashMap.key_tlist(&map)
+fn Key[] Map.temp_keys_list(map)
 {
-	return map.key_new_list(allocator::temp()) @inline;
+	return map.new_keys_list(allocator::temp()) @inline;
 }
 
-fn Key[] HashMap.key_new_list(&map, Allocator allocator = allocator::heap())
+fn Key[] Map.new_keys_list(self, Allocator allocator = allocator::heap())
 {
-	if (!map.count) return {};
+	MapImpl* map = (MapImpl*)self;
+	if (!map || !map.count) return {};
 
 	Key[] list = allocator::alloc_array(allocator, Key, map.count);
 	usz index = 0;
@@ -219,36 +297,36 @@ fn Key[] HashMap.key_new_list(&map, Allocator allocator = allocator::heap())
 	return list;
 }
 
-macro HashMap.@each(map; @body(key, value))
+macro Map.@each(map; @body(key, value))
 {
 	map.@each_entry(; Entry* entry) {
 		@body(entry.key, entry.value);
 	};
 }
 
-macro HashMap.@each_entry(map; @body(entry))
+macro Map.@each_entry(self; @body(entry))
 {
-	if (map.count)
+	MapImpl *map = (MapImpl*)self;
+	if (!map || !map.count) return;
+	foreach (Entry* entry : map.table)
 	{
-		foreach (Entry* entry : map.table)
+		while (entry)
 		{
-			while (entry)
-			{
-				@body(entry);
-				entry = entry.next;
-			}
+			@body(entry);
+			entry = entry.next;
 		}
 	}
 }
 
-fn Value[] HashMap.value_tlist(&map)
+fn Value[] Map.temp_values_list(map)
 {
-	return map.value_new_list(allocator::temp()) @inline;
+	return map.new_values_list(allocator::temp()) @inline;
 }
 
-fn Value[] HashMap.value_new_list(&map, Allocator allocator = allocator::heap())
+fn Value[] Map.new_values_list(self, Allocator allocator = allocator::heap())
 {
-	if (!map.count) return {};
+	MapImpl* map = (MapImpl*)self;
+	if (!map || !map.count) return {};
 	Value[] list = allocator::alloc_array(allocator, Value, map.count);
 	usz index = 0;
 	foreach (Entry* entry : map.table)
@@ -262,9 +340,10 @@ fn Value[] HashMap.value_new_list(&map, Allocator allocator = allocator::heap())
 	return list;
 }
 
-fn bool HashMap.has_value(&map, Value v) @if(VALUE_IS_EQUATABLE)
+fn bool Map.has_value(self, Value v) @if(VALUE_IS_EQUATABLE)
 {
-	if (!map.count) return false;
+	MapImpl* map = (MapImpl*)self;
+	if (!map || !map.count) return false;
 	foreach (Entry* entry : map.table)
 	{
 		while (entry)
@@ -278,7 +357,7 @@ fn bool HashMap.has_value(&map, Value v) @if(VALUE_IS_EQUATABLE)
 
 // --- private methods
 
-fn void HashMap.add_entry(&map, uint hash, Key key, Value value, uint bucket_index) @private
+fn void MapImpl._add_entry(&map, uint hash, Key key, Value value, uint bucket_index) @private
 {
 	$if COPY_KEYS:
 	key = key.copy(map.allocator);
@@ -287,11 +366,11 @@ fn void HashMap.add_entry(&map, uint hash, Key key, Value value, uint bucket_ind
 	map.table[bucket_index] = entry;
 	if (map.count++ >= map.threshold)
 	{
-		map.resize(map.table.len * 2);
+		map._resize(map.table.len * 2);
 	}
 }
 
-fn void HashMap.resize(&map, uint new_capacity) @private
+fn void MapImpl._resize(&map, uint new_capacity) @private
 {
 	Entry*[] old_table = map.table;
 	uint old_capacity = old_table.len;
@@ -301,9 +380,9 @@ fn void HashMap.resize(&map, uint new_capacity) @private
 		return;
 	}
 	Entry*[] new_table = allocator::new_array(map.allocator, Entry*, new_capacity);
-	map.transfer(new_table);
+	map._transfer(new_table);
 	map.table = new_table;
-	map.free_internal(old_table.ptr);
+	map._free_internal(old_table.ptr);
 	map.threshold = (uint)(new_capacity * map.load_factor);
 }
 
@@ -318,7 +397,7 @@ macro uint index_for(uint hash, uint capacity) @private
 	return hash & (capacity - 1);
 }
 
-fn void HashMap.transfer(&map, Entry*[] new_table) @private
+fn void MapImpl._transfer(&map, Entry*[] new_table) @private
 {
 	Entry*[] src = map.table;
 	uint new_capacity = new_table.len;
@@ -337,17 +416,18 @@ fn void HashMap.transfer(&map, Entry*[] new_table) @private
 	}
 }
 
-fn void HashMap.put_all_for_create(&map, HashMap* other_map) @private
+fn void _init(MapImpl* impl, uint capacity, float load_factor, Allocator allocator) @private
 {
-	if (!other_map.count) return;
-	foreach (Entry *e : other_map.table)
-	{
-		if (!e) continue;
-		map.put_for_create(e.key, e.value);
-	}
+	capacity = math::next_power_of_2(capacity);
+	*impl = {
+		.allocator = allocator,
+    	.load_factor = load_factor,
+    	.threshold = (uint)(capacity * load_factor),
+    	.table = allocator::new_array(allocator, Entry*, capacity)
+	};
 }
 
-fn void HashMap.put_for_create(&map, Key key, Value value) @private
+fn void MapImpl._put_for_create(&map, Key key, Value value) @private
 {
 	uint hash = rehash(key.hash());
 	uint i = index_for(hash, map.table.len);
@@ -359,16 +439,17 @@ fn void HashMap.put_for_create(&map, Key key, Value value) @private
 			return;
 		}
 	}
-	map.create_entry(hash, key, value, i);
+	map._create_entry(hash, key, value, i);
 }
 
-fn void HashMap.free_internal(&map, void* ptr) @inline @private
+fn void MapImpl._free_internal(&map, void* ptr) @inline @private
 {
 	allocator::free(map.allocator, ptr);
 }
 
-fn bool HashMap.remove_entry_for_key(&map, Key key) @private
+fn bool MapImpl._remove_entry_for_key(&map, Key key) @private
 {
+	if (!map.count) return false;
 	uint hash = rehash(key.hash());
 	uint i = index_for(hash, map.table.len);
 	Entry* prev = map.table[i];
@@ -387,7 +468,7 @@ fn bool HashMap.remove_entry_for_key(&map, Key key) @private
 			{
 				prev.next = next;
 			}
-			map.free_entry(e);
+			map._free_entry(e);
 			return true;
 		}
 		prev = e;
@@ -396,7 +477,7 @@ fn bool HashMap.remove_entry_for_key(&map, Key key) @private
 	return false;
 }
 
-fn void HashMap.create_entry(&map, uint hash, Key key, Value value, int bucket_index) @private
+fn void MapImpl._create_entry(&map, uint hash, Key key, Value value, int bucket_index) @private
 {
 	Entry *e = map.table[bucket_index];
 	$if COPY_KEYS:
@@ -407,12 +488,12 @@ fn void HashMap.create_entry(&map, uint hash, Key key, Value value, int bucket_i
 	map.count++;
 }
 
-fn void HashMap.free_entry(&self, Entry *entry) @local
+fn void MapImpl._free_entry(&self, Entry *entry) @local
 {
 	$if COPY_KEYS:
 	allocator::free(self.allocator, entry.key);
 	$endif
-	self.free_internal(entry);
+	self._free_internal(entry);
 }
 
 struct Entry
@@ -421,4 +502,4 @@ struct Entry
 	Key key;
 	Value value;
 	Entry* next;
-}
+}

lib/std/collections/maybe.c3

@@ -1,6 +1,6 @@
 module std::collections::maybe(<Type>);
 
-struct Maybe
+struct Maybe @adhoc
 {
 	Type value;
 	bool has_value;

lib/std/collections/object.c3

@@ -48,9 +48,9 @@ fn usz! Object.to_format(&self, Formatter* formatter) @dynamic
 			return n;
 		case ObjectInternalMap:
 			usz n = formatter.printf("{")!;
-			@pool()
+			@stack_mem(1024; Allocator mem)
 			{
-				foreach (i, key : self.map.key_tlist())
+				foreach (i, key : self.map.key_new_list(mem))
 				{
 					if (i > 0) n += formatter.printf(",")!;
 					n += formatter.printf(`"%s":`, key)!;
@@ -128,9 +128,9 @@ fn void Object.free(&self)
 			self.array.free();
 		case ObjectInternalMap:
 			self.map.@each_entry(; ObjectInternalMapEntry* entry) {
-				allocator::free(self.allocator, entry.key);
 				entry.value.free();
 			};
+			self.map.free();
 		default:
 			break;
 	}
@@ -156,7 +156,7 @@ fn void Object.init_map_if_needed(&self) @private
 	if (self.is_empty())
 	{
 		self.type = ObjectInternalMap.typeid;
-		self.map.new_init(.allocator = self.allocator);
+		self.map.new_init(allocator: self.allocator);
 	}
 }
 
@@ -168,7 +168,7 @@ fn void Object.init_array_if_needed(&self) @private
 	if (self.is_empty())
 	{
 		self.type = ObjectInternalList.typeid;
-		self.array.new_init(.allocator = self.allocator);
+		self.array.new_init(allocator: self.allocator);
 	}
 }
 
@@ -181,16 +181,14 @@ fn void Object.set_object(&self, String key, Object* new_object) @private
 	ObjectInternalMapEntry*! entry = self.map.get_entry(key);
 	defer
 	{
-		(void)allocator::free(self.allocator, entry.key);
 		(void)entry.value.free();
 	}
-	self.map.set(key.copy(self.map.allocator), new_object);
+	self.map.set(key, new_object);
 }
 
 macro Object* Object.object_from_value(&self, value) @private
 {
 	var $Type = $typeof(value);
-
 	$switch
 		$case types::is_int($Type):
 			return new_int(value, self.allocator);

lib/std/collections/range.c3

@@ -29,14 +29,19 @@ fn Type Range.get(&self, usz index) @operator([])
 	return (Type)(self.start + (usz)index);
 }
 
-fn String Range.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
+fn String Range.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic @deprecated
 {
-	return string::new_format("[%s..%s]", self.start, self.end, .allocator = allocator);
+	return string::format("[%s..%s]", self.start, self.end, allocator: allocator);
+}
+
+fn String Range.to_string(&self, Allocator allocator) @dynamic
+{
+	return string::format("[%s..%s]", self.start, self.end, allocator: allocator);
 }
 
 fn String Range.to_tstring(&self)
 {
-	return self.to_new_string(allocator::temp());
+	return self.to_string(allocator::temp());
 }
 
 fn usz! Range.to_format(&self, Formatter* formatter) @dynamic
@@ -66,9 +71,14 @@ fn usz! ExclusiveRange.to_format(&self, Formatter* formatter) @dynamic
 	return formatter.printf("[%s..<%s]", self.start, self.end)!;
 }
 
-fn String ExclusiveRange.to_new_string(&self, Allocator allocator = allocator::heap()) @dynamic
+fn String ExclusiveRange.to_new_string(&self, Allocator allocator = null) @dynamic
 {
-	return string::new_format("[%s..<%s]", self.start, self.end, .allocator = allocator);
+	return self.to_string(allocator ?: allocator::heap());
+}
+
+fn String ExclusiveRange.to_string(&self, Allocator allocator) @dynamic
+{
+	return string::format("[%s..<%s]", self.start, self.end, allocator: allocator);
 }
 
 fn String ExclusiveRange.to_tstring(&self)

lib/std/collections/tuple.c3

@@ -1,6 +1,6 @@
 module std::collections::tuple(<Type1, Type2>);
 
-struct Tuple
+struct Tuple @adhoc
 {
 	Type1 first;
 	Type2 second;
@@ -8,7 +8,7 @@ struct Tuple
 
 module std::collections::triple(<Type1, Type2, Type3>);
 
-struct Triple
+struct Triple @adhoc
 {
 	Type1 first;
 	Type2 second;

lib/std/compression/qoi.c3

@@ -0,0 +1,476 @@
+module std::compression::qoi;
+
+const uint PIXELS_MAX = 400000000;
+
+/**
+ * Colorspace.
+ * Purely informative. It will be saved to the file header,
+ * but does not affect how chunks are en-/decoded.
+ */
+enum QOIColorspace : char (char id)
+{
+    SRGB = 0, 	// sRGB with linear alpha
+    LINEAR = 1 	// all channels linear
+}
+
+/**
+ * Channels.
+ * The channels used in an image.
+ * AUTO can be used when decoding to automatically determine
+ * the channels from the file's header.
+ */
+enum QOIChannels : char (char id)
+{
+	AUTO = 0,
+    RGB = 3,
+    RGBA = 4
+}
+
+/**
+ * Descriptor.
+ * Contains information about an image.
+ */
+struct QOIDesc
+{
+	uint width;
+	uint height;
+	QOIChannels channels;
+	QOIColorspace colorspace;
+}
+
+/**
+ * QOI Errors.
+ * These are all the possible bad outcomes.
+ */
+fault QOIError
+{
+	INVALID_PARAMETERS,
+	FILE_OPEN_FAILED,
+	FILE_WRITE_FAILED,
+	INVALID_DATA,
+	TOO_MANY_PIXELS
+}
+
+
+// Let the user decide if they want to use std::io
+module std::compression::qoi @if(!$feature(QOI_NO_STDIO));
+import std::io;
+
+/**
+ * Encode raw RGB or RGBA pixels into a QOI image and write it to the
+ * file system.
+ * 
+ * The desc struct must be filled with the image width, height, the
+ * used channels (QOIChannels.RGB or RGBA) and the colorspace
+ * (QOIColorspace.SRGB or LINEAR).
+ * 
+ * The function returns an optional, which can either be a QOIError
+ * or the number of bytes written on success.
+ * 
+ * @param [in] filename `The file's name to write the image to`
+ * @param [in] input `The raw RGB or RGBA pixels to encode`
+ * @param [&in] desc `The descriptor of the image`
+ */
+fn usz! write(String filename, char[] input, QOIDesc* desc)
+{
+	@pool() {
+		// encode data
+		char[] output = encode(input, desc)!;
+
+		// open file
+		File! f = file::open(filename, "wb");
+		if (catch f) { return QOIError.FILE_OPEN_FAILED?; }
+
+		// write data to file and close it
+		usz! written = f.write(output);
+		if (catch written) { return QOIError.FILE_WRITE_FAILED?; }
+		if (catch f.close()) { return QOIError.FILE_WRITE_FAILED?; }
+
+		return written;
+	};
+}
+
+
+/**
+ * Read and decode a QOI image from the file system.
+ * 
+ * If channels is set to QOIChannels.AUTO, the function will
+ * automatically determine the channels from the file's header.
+ * However, if channels is RGB or RGBA, the output format will be
+ * forced into this number of channels.
+ * 
+ * The desc struct will be filled with the width, height,
+ * channels and colorspace of the image.
+ * 
+ * The function returns an optional, which can either be a QOIError
+ * or a char[] pointing to the decoded pixels on success.
+ * 
+ * The returned pixel data should be free()d after use, or the decoding
+ * and use of the data should be wrapped in a @pool() { ... }; block.
+ * 
+ * @param [in] filename `The file's name to read the image from`
+ * @param [&out] desc `The descriptor to fill with the image's info`
+ * @param channels `The channels to be used`
+ */
+fn char[]! read(String filename, QOIDesc* desc, QOIChannels channels = AUTO, Allocator allocator = allocator::heap())
+{
+	// read file
+	char[]! data = file::load_new(filename);
+	if (catch data) return QOIError.FILE_OPEN_FAILED?;
+	defer mem::free(data);
+
+	// pass data to decode function
+	return decode(data, desc, channels, allocator);
+}
+
+
+// Back to basic non-stdio mode
+module std::compression::qoi;
+import std::bits;
+
+/**
+ * Encode raw RGB or RGBA pixels into a QOI image in memory.
+ * 
+ * The function returns an optional, which can either be a QOIError
+ * or a char[] pointing to the encoded data on success.
+ * 
+ * The returned qoi data should be free()d after use, or the encoding
+ * and use of the data should be wrapped in a @pool() { ... }; block.
+ * See the write() function for an example.
+ * 
+ * @param [in] input `The raw RGB or RGBA pixels to encode`
+ * @param [&in] desc `The descriptor of the image`
+ */
+fn char[]! encode(char[] input, QOIDesc* desc, Allocator allocator = allocator::heap())
+{
+	// check info in desc
+	if (desc.width == 0 || desc.height == 0) return QOIError.INVALID_PARAMETERS?;
+	if (desc.channels == AUTO) return QOIError.INVALID_PARAMETERS?;
+	uint pixels = desc.width * desc.height;
+	if (pixels > PIXELS_MAX) return QOIError.TOO_MANY_PIXELS?;
+	
+	// check input data size
+	uint image_size = pixels * desc.channels.id;
+	if (image_size != input.len) return QOIError.INVALID_DATA?;
+
+	// allocate memory for encoded data (output)
+	// header + chunk tag and RGB(A) data for each pixel + end of stream
+	uint max_size = Header.sizeof + pixels + image_size + END_OF_STREAM.len;
+	char[] output = allocator::alloc_array(allocator, char, max_size); // no need to init
+	defer catch allocator::free(allocator, output);
+
+	// write header
+	*(Header*)output.ptr = {
+		.be_magic = bswap('qoif'),
+		.be_width = bswap(desc.width),
+		.be_height = bswap(desc.height),
+		.channels = desc.channels.id,
+		.colorspace = desc.colorspace.id
+	};
+
+	uint pos = Header.sizeof; 	// Current position in output
+	uint loc;					// Current position in image (top-left corner)
+	uint loc_end = image_size - desc.channels.id; // End of image data
+	char run_length = 0; 		// Length of the current run
+	
+	Pixel[64] palette; // Zero-initialized by default
+	Pixel prev = { 0, 0, 0, 255 };
+	Pixel p = { 0, 0, 0, 255 };
+
+	ichar[<3>] diff; // pre-allocate for diff
+	ichar[<3>] luma; // ...and luma
+
+	// write chunks
+	for (loc = 0; loc < image_size; loc += desc.channels.id)
+	{
+		// set previous pixel
+		prev = p;
+
+		// get current pixel
+		p[:3] = input[loc:3]; // cutesy slices :3
+		if (desc.channels == RGBA) p.a = input[loc + 3];
+
+		// check if we can run the previous pixel
+		if (prev == p) {
+			run_length++;
+			if (run_length == 62 || loc == loc_end) {
+				*@extract(OpRun, output, &pos) = { OP_RUN, run_length - 1 };
+				run_length = 0;
+			}
+		} else {
+			// end last run if there was one
+			if (run_length > 0) {
+				*@extract(OpRun, output, &pos) = { OP_RUN, run_length - 1 };
+				run_length = 0;
+			}
+
+			switch {
+				// check if we can index the palette
+				case (palette[p.hash()] == p):
+					*@extract(OpIndex, output, &pos) = {
+						OP_INDEX,
+						p.hash()
+					};
+
+				// check if we can use diff or luma
+				case (prev != p && prev.a == p.a):
+					// diff the pixels
+					diff = p.rgb - prev.rgb;
+					if (
+						diff.r > -3 && diff.r < 2 &&
+						diff.g > -3 && diff.g < 2 &&
+						diff.b > -3 && diff.b < 2
+					) {
+						*@extract(OpDiff, output, &pos) = {
+							OP_DIFF,
+							(char)diff.r + 2,
+							(char)diff.g + 2,
+							(char)diff.b + 2
+						};
+						palette[p.hash()] = p;
+					} else {
+						// check luma eligibility
+						luma = { diff.r - diff.g, diff.g, diff.b - diff.g };
+						if (
+							luma.r >= -8 && luma.r <= 7 &&
+							luma.g >= -32 && luma.g <= 31 &&
+							luma.b >= -8 && luma.b <= 7
+						) {
+							*@extract(OpLuma, output, &pos) = {
+								OP_LUMA,
+								(char)luma.g + 32,
+								(char)luma.r + 8,
+								(char)luma.b + 8
+							};
+							palette[p.hash()] = p;
+						} else { nextcase; }
+					}
+
+				// worst case scenario: just encode the raw pixel
+				default:
+					if (prev.a != p.a) {
+						*@extract(OpRGBA, output, &pos) = { OP_RGBA, p.r, p.g, p.b, p.a };
+					} else {
+						*@extract(OpRGB, output, &pos) = { OP_RGB, p.r, p.g, p.b };
+					}
+					palette[p.hash()] = p;
+			}
+		}
+	}
+
+	// write end of stream
+	output[pos:END_OF_STREAM.len] = END_OF_STREAM;
+	pos += END_OF_STREAM.len;
+	
+	return output[:pos];
+}
+
+
+/**
+ * Decode a QOI image from memory.
+ * 
+ * If channels is set to QOIChannels.AUTO, the function will
+ * automatically determine the channels from the file's header.
+ * However, if channels is RGB or RGBA, the output format will be
+ * forced into this number of channels.
+ * 
+ * The desc struct will be filled with the width, height,
+ * channels and colorspace of the image.
+ * 
+ * The function returns an optional, which can either be a QOIError
+ * or a char[] pointing to the decoded pixels on success.
+ * 
+ * The returned pixel data should be free()d after use, or the decoding
+ * and use of the data should be wrapped in a @pool() { ... }; block.
+ * 
+ * @param [in] data `The QOI image data to decode`
+ * @param [&out] desc `The descriptor to fill with the image's info`
+ * @param channels `The channels to be used`
+ */
+fn char[]! decode(char[] data, QOIDesc* desc, QOIChannels channels = AUTO, Allocator allocator = allocator::heap())
+{
+	// check input data
+	if (data.len < Header.sizeof + END_OF_STREAM.len) return QOIError.INVALID_DATA?;
+
+	// get header
+	Header* header = (Header*)data.ptr;
+
+	// check magic bytes (FourCC)
+	if (bswap(header.be_magic) != 'qoif') return QOIError.INVALID_DATA?;
+
+	// copy header data to desc
+	desc.width = bswap(header.be_width);
+	desc.height = bswap(header.be_height);
+	desc.channels = @enumcast(QOIChannels, header.channels)!; 			// Rethrow if invalid
+	desc.colorspace = @enumcast(QOIColorspace, header.colorspace)!;	// Rethrow if invalid
+	if (desc.channels == AUTO) return QOIError.INVALID_DATA?; // Channels must be specified in the header
+
+	// check width and height
+	if (desc.width == 0 || desc.height == 0) return QOIError.INVALID_DATA?;
+
+	// check pixel count
+	ulong pixels = (ulong)desc.width * (ulong)desc.height;
+	if (pixels > PIXELS_MAX) return QOIError.TOO_MANY_PIXELS?;
+
+	uint pos = Header.sizeof; 	// Current position in data
+	uint loc;					// Current position in image (top-left corner)
+	char run_length = 0; 		// Length of the current run
+	char tag;					// Current chunk tag
+
+	Pixel[64] palette; // Zero-initialized by default
+	Pixel p = { 0, 0, 0, 255 };
+
+	if (channels == AUTO) channels = desc.channels;
+	
+	// allocate memory for image data
+	usz image_size = (usz)pixels * channels.id;
+	char[] image = allocator::alloc_array(allocator, char, image_size);
+	defer catch allocator::free(allocator, image);
+
+	for (loc = 0; loc < image_size; loc += channels.id)
+	{
+		// get chunk tag
+		tag = data[pos];
+
+		// check for chunk type
+		switch
+		{
+			case run_length > 0:
+				run_length--;
+
+			case tag == OP_RGB:
+				OpRGB* op = @extract(OpRGB, data, &pos);
+				p = { op.red, op.green, op.blue, p.a };
+				palette[p.hash()] = p;
+
+			case tag == OP_RGBA:
+				OpRGBA* op = @extract(OpRGBA, data, &pos);
+				p = { op.red, op.green, op.blue, op.alpha };
+				palette[p.hash()] = p;
+				
+			case tag >> 6 == OP_INDEX:
+				OpIndex* op = @extract(OpIndex, data, &pos);
+				p = palette[op.index];
+
+			case tag >> 6 == OP_DIFF:
+				OpDiff* op = @extract(OpDiff, data, &pos);
+				p.r += op.diff_red - 2;
+				p.g += op.diff_green - 2;
+				p.b += op.diff_blue - 2;
+				palette[p.hash()] = p;
+
+			case tag >> 6 == OP_LUMA:
+				OpLuma* op = @extract(OpLuma, data, &pos);
+				int diff_green = op.diff_green - 32;
+				p.r += (char)(op.diff_red_minus_green - 8 + diff_green);
+				p.g += (char)(diff_green);
+				p.b += (char)(op.diff_blue_minus_green - 8 + diff_green);
+				palette[p.hash()] = p;
+
+			case tag >> 6 == OP_RUN:
+				OpRun* op = @extract(OpRun, data, &pos);
+				run_length = op.run;
+		}
+
+		// draw the pixel
+		if (channels == RGBA) { image[loc:4] = p.rgba; } else { image[loc:3] = p.rgb; }
+	}
+	
+	return image;
+}
+
+
+
+// ***************************************************************************
+// ***                                                                     ***
+// ***    Main functions are at the top to make the file more readable.    ***
+// ***        From here on, helper functions and types are defined.        ***
+// ***                                                                     ***
+// ***************************************************************************
+module std::compression::qoi @private;
+
+// 8-bit opcodes
+const OP_RGB = 0b11111110;
+const OP_RGBA = 0b11111111;
+// 2-bit opcodes
+const OP_INDEX = 0b00;
+const OP_DIFF = 0b01;
+const OP_LUMA = 0b10;
+const OP_RUN = 0b11;
+
+struct Header @packed
+{
+	uint be_magic;	// magic bytes "qoif"
+	uint be_width;	// image width in pixels (BE)
+	uint be_height;	// image height in pixels (BE)
+
+	// informative fields
+	char channels;	// 3 = RGB, 4 = RGB
+	char colorspace;	// 0 = sRGB with linear alpha, 1 = all channels linear
+}
+
+const char[*] END_OF_STREAM = {0, 0, 0, 0, 0, 0, 0, 1};
+
+// inefficient, but it's only run once at a time
+macro @enumcast($Type, raw)
+{
+	foreach (value : $Type.values) {
+		if (value.id == raw) return value;
+	}
+	return QOIError.INVALID_DATA?;
+}
+
+distinct Pixel = inline char[<4>];
+macro char Pixel.hash(Pixel p) {
+	return (p.r * 3 + p.g * 5 + p.b * 7 + p.a * 11) % 64;
+}
+
+struct OpRGB // No need to use @packed here, the alignment is 1 anyways.
+{
+	char tag;
+	char red;
+	char green;
+	char blue;
+}
+struct OpRGBA @packed
+{
+	char tag;
+	char red;
+	char green;
+	char blue;
+	char alpha;
+}
+bitstruct OpIndex : char
+{
+	char tag : 6..7;
+	char index : 0..5;
+}
+bitstruct OpDiff : char
+{
+	char tag : 6..7;
+	char diff_red : 4..5;
+	char diff_green : 2..3;
+	char diff_blue : 0..1;
+}
+bitstruct OpLuma : ushort
+{
+	char tag : 6..7;
+	char diff_green : 0..5;
+	char diff_red_minus_green : 12..15;
+	char diff_blue_minus_green : 8..11;
+}
+bitstruct OpRun : char
+{
+	char tag : 6..7;
+	char run : 0..5;
+}
+
+// Macro used to locate chunks in data buffers.
+// Can be used both for reading and writing.
+macro @extract($Type, char[] data, uint* pos)
+{
+	// slice data, then double cast
+	$Type* chunk = ($Type*)data[*pos : $Type.sizeof].ptr;
+	*pos += $Type.sizeof;
+	return chunk;
+}

lib/std/core/allocators/dynamic_arena.c3

@@ -30,6 +30,7 @@ fn void DynamicArenaAllocator.free(&self)
 	while (page)
 	{
 		DynamicArenaPage* next_page = page.prev_arena;
+		allocator::free(self.backing_allocator, page.memory);
 		allocator::free(self.backing_allocator, page);
 		page = next_page;
 	}
@@ -37,6 +38,7 @@ fn void DynamicArenaAllocator.free(&self)
 	while (page)
 	{
 		DynamicArenaPage* next_page = page.prev_arena;
+		allocator::free(self.backing_allocator, page.memory);
 		allocator::free(self.backing_allocator, page);
 		page = next_page;
 	}
@@ -131,8 +133,8 @@ fn void DynamicArenaAllocator.reset(&self, usz mark = 0) @dynamic
 fn void*! DynamicArenaAllocator._alloc_new(&self, usz size, usz alignment) @local
 {
 	// First, make sure that we can align it, extending the page size if needed.
-	usz page_size = max(self.page_size, mem::aligned_offset(size + DynamicArenaChunk.sizeof, alignment));
-
+	usz page_size = max(self.page_size, mem::aligned_offset(size + DynamicArenaChunk.sizeof + alignment, alignment));
+	assert(page_size > size + DynamicArenaChunk.sizeof);
 	// Grab the page without alignment (we do it ourselves)
 	void* mem = allocator::malloc_try(self.backing_allocator, page_size)!;
 	DynamicArenaPage*! page = allocator::new_try(self.backing_allocator, DynamicArenaPage);

lib/std/core/allocators/libc_allocator.c3

@@ -2,16 +2,21 @@
 // Use of this source code is governed by the MIT license
 // a copy of which can be found in the LICENSE_STDLIB file.
 
-module std::core::mem::allocator;
+module std::core::mem::allocator @if(env::LIBC);
+import std::io;
 import libc;
 
 const LibcAllocator LIBC_ALLOCATOR = {};
-distinct LibcAllocator (Allocator) = uptr;
+distinct LibcAllocator (Allocator, Printable) = uptr;
+
+fn String LibcAllocator.to_string(&self, Allocator allocator) @dynamic => "Libc allocator".copy(allocator);
+fn usz! LibcAllocator.to_format(&self, Formatter *format) @dynamic => format.print("Libc allocator");
 
 module std::core::mem::allocator @if(env::POSIX);
 import std::os;
 import libc;
 
+
 fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
 {
 	if (init_type == ZERO)
@@ -79,7 +84,7 @@ fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz a
 	{
 		if (alignment > 0)
 		{
-			return win32::_aligned_recalloc(null, bytes, alignment) ?: AllocationFailure.OUT_OF_MEMORY?;
+			return win32::_aligned_recalloc(null, 1, bytes, alignment) ?: AllocationFailure.OUT_OF_MEMORY?;
 		}
 		return libc::calloc(1, bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
 	}
@@ -110,7 +115,7 @@ fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
 	libc::free(old_ptr);
 }
 
-module std::core::mem::allocator @if(!env::WIN32 && !env::POSIX);
+module std::core::mem::allocator @if(!env::WIN32 && !env::POSIX && env::LIBC);
 import libc;
 
 fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic

lib/std/core/allocators/temp_allocator.c3

@@ -45,6 +45,13 @@ fn TempAllocator*! new_temp_allocator(usz size, Allocator allocator)
 	return temp;
 }
 
+fn void TempAllocator.destroy(&self)
+{
+	self.reset(0);
+	if (self.last_page) (void)self._free_page(self.last_page);
+	allocator::free(self.backing_allocator, self);
+}
+
 fn usz TempAllocator.mark(&self) @dynamic => self.used;
 
 fn void TempAllocator.release(&self, void* old_pointer, bool) @dynamic
@@ -53,6 +60,7 @@ fn void TempAllocator.release(&self, void* old_pointer, bool) @dynamic
 	if (old_pointer + old_size == &self.data[self.used])
 	{
 		self.used -= old_size;
+		asan::poison_memory_region(&self.data[self.used], old_size);
 	}
 }
 fn void TempAllocator.reset(&self, usz mark) @dynamic
@@ -60,11 +68,25 @@ fn void TempAllocator.reset(&self, usz mark) @dynamic
 	TempAllocatorPage *last_page = self.last_page;
 	while (last_page && last_page.mark > mark)
 	{
+		self.used = last_page.mark;
 		TempAllocatorPage *to_free = last_page;
 		last_page = last_page.prev_page;
 		self._free_page(to_free)!!;
 	}
 	self.last_page = last_page;
+	$if env::COMPILER_SAFE_MODE || env::ADDRESS_SANITIZER:
+		if (!last_page)
+		{
+			usz cleaned = self.used - mark;
+			if (cleaned > 0)
+			{
+				$if env::COMPILER_SAFE_MODE:
+					self.data[mark : cleaned] = 0xAA;
+				$endif
+				asan::poison_memory_region(&self.data[mark], cleaned);
+			}
+		}
+	$endif
 	self.used = mark;
 }
 
@@ -130,9 +152,10 @@ fn void*! TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz al
 	}
 	usz new_usage = (usz)(mem - start_mem) + size;
 
-	// Arena alignment, simple!
+	// Arena allocation, simple!
 	if (new_usage <= self.capacity)
 	{
+		asan::unpoison_memory_region(starting_ptr, new_usage - self.used);
 		TempAllocatorChunk* chunk_start = mem - TempAllocatorChunk.sizeof;
 		chunk_start.size = size;
 		self.used = new_usage;

lib/std/core/allocators/tracking_allocator.c3

@@ -34,7 +34,7 @@ struct TrackingAllocator (Allocator)
 fn void TrackingAllocator.init(&self, Allocator allocator)
 {
 	*self = { .inner_allocator = allocator };
-	self.map.new_init(.allocator = allocator);
+	self.map.new_init(allocator: allocator);
 }
 
 /**
@@ -87,7 +87,6 @@ fn void*! TrackingAllocator.acquire(&self, usz size, AllocInitType init_type, us
 	backtrace::capture_current(&bt);
 	self.map.set((uptr)data, { data, size, bt });
     self.mem_total += size;
-	self.allocs_total++;
 	return data;
 }
 

lib/std/core/array.c3

@@ -55,7 +55,7 @@ macro rindex_of(array, element)
  * @require @typeis(arr1[0], $typeof(arr2[0])) "Arrays must have the same type"
  * @ensure result.len == arr1.len + arr2.len
  **/
-macro concat_new(arr1, arr2, Allocator allocator = allocator::heap())
+macro concat(arr1, arr2, Allocator allocator) @nodiscard
 {
 	var $Type = $typeof(arr1[0]);
 	$Type[] result = allocator::alloc_array(allocator, $Type, arr1.len + arr2.len);
@@ -69,6 +69,21 @@ macro concat_new(arr1, arr2, Allocator allocator = allocator::heap())
 	}
 	return result;
 }
+/**
+ * Concatenate two arrays or slices, returning a slice containing the concatenation of them.
+ *
+ * @param [in] arr1
+ * @param [in] arr2
+ * @param [&inout] allocator "The allocator to use, default is the heap allocator"
+ * @require @typekind(arr1) == SLICE || @typekind(arr1) == ARRAY
+ * @require @typekind(arr2) == SLICE || @typekind(arr2) == ARRAY
+ * @require @typeis(arr1[0], $typeof(arr2[0])) "Arrays must have the same type"
+ * @ensure result.len == arr1.len + arr2.len
+ **/
+macro concat_new(arr1, arr2, Allocator allocator = allocator::heap()) @nodiscard
+{
+	return concat(arr1, arr2, allocator);
+}
 
 /**
  * Concatenate two arrays or slices, returning a slice containing the concatenation of them,
@@ -81,7 +96,7 @@ macro concat_new(arr1, arr2, Allocator allocator = allocator::heap())
  * @require @typeis(arr1[0], $typeof(arr2[0])) "Arrays must have the same type"
  * @ensure result.len == arr1.len + arr2.len
  **/
-macro tconcat(arr1, arr2) => concat(arr1, arr2, allocator::temp());
+macro tconcat(arr1, arr2) @nodiscard => concat(arr1, arr2, allocator::temp());
 
 module std::core::array::slice(<Type>);
 

lib/std/core/builtin.c3

@@ -7,26 +7,19 @@ import libc, std::hash, std::io, std::os::backtrace;
 /**
  * Use `IteratorResult` when reading the end of an iterator, or accessing a result out of bounds.
  **/
-fault IteratorResult
-{
-	NO_MORE_ELEMENT
-}
+fault IteratorResult { NO_MORE_ELEMENT }
 
 /**
  * Use `SearchResult` when trying to return a value from some collection but the element is missing.
  **/
-fault SearchResult
-{
-	MISSING
-}
+fault SearchResult { MISSING }
 
 /**
  * Use `CastResult` when an attempt at conversion fails.
  **/
-fault CastResult
-{
-	TYPE_MISMATCH
-}
+fault CastResult { TYPE_MISMATCH }
+
+def VoidFn = fn void();
 
 /**
  * Stores a variable on the stack, then restores it at the end of the
@@ -111,13 +104,29 @@ fn void default_panic(String message, String file, String function, uint line) @
 	$$trap();
 
 }
+
+macro void abort(String string = "Unrecoverable error reached", ...) @builtin @noreturn
+{
+	panicf(string, $$FILE, $$FUNC, $$LINE, $vasplat);
+	$$trap();
+}
+
+bool in_panic @local = false;
+
 fn void default_panic(String message, String file, String function, uint line) @if(!env::NATIVE_STACKTRACE)
 {
+	if (in_panic)
+	{
+		io::eprintn("Panic inside of panic.");
+		return;
+	}
+	in_panic = true;
 	$if $defined(io::stderr):
 	io::eprint("\nERROR: '");
 	io::eprint(message);
 	io::eprintfn("', in %s (%s:%d)", function, file, line);
 	$endif
+	in_panic = false;
 	$$trap();
 }
 
@@ -127,11 +136,19 @@ PanicFn panic = &default_panic;
 
 fn void panicf(String fmt, String file, String function, uint line, args...)
 {
+	if (in_panic)
+	{
+		io::eprint("Panic inside of panic: ");
+		io::eprintn(fmt);
+		return;
+	}
+	in_panic = true;
 	@stack_mem(512; Allocator allocator)
 	{
 		DString s;
-		s.new_init(.allocator = allocator);
+		s.new_init(allocator: allocator);
 		s.appendf(fmt, ...args);
+		in_panic = false;
 		panic(s.str_view(), file, function, line);
 	};
 }
@@ -144,7 +161,7 @@ fn void panicf(String fmt, String file, String function, uint line, args...)
 macro void unreachable(String string = "Unreachable statement reached.", ...) @builtin @noreturn
 {
 	$if env::COMPILER_SAFE_MODE:
-	panicf(string, $$FILE, $$FUNC, $$LINE, $vasplat());
+	panicf(string, $$FILE, $$FUNC, $$LINE, $vasplat);
 	$endif;
 	$$unreachable();
 }
@@ -155,7 +172,7 @@ macro void unreachable(String string = "Unreachable statement reached.", ...) @b
  **/
 macro void unsupported(String string = "Unsupported function invoked") @builtin @noreturn
 {
-	panicf(string, $$FILE, $$FUNC, $$LINE, $vasplat());
+	panicf(string, $$FILE, $$FUNC, $$LINE, $vasplat);
 	$$unreachable();
 }
 
@@ -300,12 +317,12 @@ macro @prefetch(void* ptr, PrefetchLocality $locality = VERY_NEAR, bool $write =
 
 macro swizzle(v, ...) @builtin
 {
-	return $$swizzle(v, $vasplat());
+	return $$swizzle(v, $vasplat);
 }
 
 macro swizzle2(v, v2, ...) @builtin
 {
-	return $$swizzle2(v, v2, $vasplat());
+	return $$swizzle2(v, v2, $vasplat);
 }
 
 macro anyfault @catch(#expr) @builtin
@@ -683,7 +700,7 @@ fn void install_signal_handler(CInt signal, SignalFunction func) @local
 }
 
 // Clean this up
-fn void install_signal_handlers() @init(101) @local
+fn void install_signal_handlers() @init(101) @local @if(env::BACKTRACE)
 {
 	install_signal_handler(libc::SIGBUS, &sig_bus_error);
 	install_signal_handler(libc::SIGSEGV, &sig_segmentation_fault);

lib/std/core/builtin_comparison.c3

@@ -4,7 +4,7 @@
 module std::core::builtin;
 
 /**
- * @require types::is_comparable_value(a) && types::is_comparable_value(b)
+ * @require types::@comparable_value(a) && types::@comparable_value(b)
  **/
 macro less(a, b) @builtin
 {
@@ -19,7 +19,7 @@ macro less(a, b) @builtin
 }
 
 /**
- * @require types::is_comparable_value(a) && types::is_comparable_value(b)
+ * @require types::@comparable_value(a) && types::@comparable_value(b)
  **/
 macro less_eq(a, b) @builtin
 {
@@ -34,7 +34,7 @@ macro less_eq(a, b) @builtin
 }
 
 /**
- * @require types::is_comparable_value(a) && types::is_comparable_value(b)
+ * @require types::@comparable_value(a) && types::@comparable_value(b)
  **/
 macro greater(a, b) @builtin
 {
@@ -49,7 +49,7 @@ macro greater(a, b) @builtin
 }
 
 /**
- * @require types::is_comparable_value(a) && types::is_comparable_value(b)
+ * @require types::@comparable_value(a) && types::@comparable_value(b)
  **/
 macro int compare_to(a, b) @builtin
 {
@@ -63,7 +63,7 @@ macro int compare_to(a, b) @builtin
 	$endswitch
 }
 /**
- * @require types::is_comparable_value(a) && types::is_comparable_value(b)
+ * @require types::@comparable_value(a) && types::@comparable_value(b)
  **/
 macro greater_eq(a, b) @builtin
 {
@@ -78,7 +78,7 @@ macro greater_eq(a, b) @builtin
 }
 
 /**
- * @require types::is_equatable_value(a) && types::is_equatable_value(b) `values must be equatable`
+ * @require types::@equatable_value(a) && types::@equatable_value(b) `values must be equatable`
  **/
 macro bool equals(a, b) @builtin
 {
@@ -97,13 +97,13 @@ macro bool equals(a, b) @builtin
 macro min(x, ...) @builtin
 {
 	$if $vacount == 1:
-		return less(x, $vaarg(0)) ? x : $vaarg(0);
+		return less(x, $vaarg[0]) ? x : $vaarg[0];
 	$else
 		var result = x;
 		$for (var $i = 0; $i < $vacount; $i++)
-			if (less($vaarg($i), result))
+			if (less($vaarg[$i], result))
 			{
-				 result = $vaarg($i);
+				 result = $vaarg[$i];
 			}
 		$endfor
 		return result;
@@ -113,13 +113,13 @@ macro min(x, ...) @builtin
 macro max(x, ...) @builtin
 {
 	$if $vacount == 1:
-		return greater(x, $vaarg(0)) ? x : $vaarg(0);
+		return greater(x, $vaarg[0]) ? x : $vaarg[0];
 	$else
 		var result = x;
 		$for (var $i = 0; $i < $vacount; $i++)
-			if (greater($vaarg($i), result))
+			if (greater($vaarg[$i], result))
 			{
-				 result = $vaarg($i);
+				 result = $vaarg[$i];
 			}
 		$endfor
 		return result;

lib/std/core/dstring.c3

@@ -48,6 +48,56 @@ fn DString new(String c = "", Allocator allocator = allocator::heap())
 
 fn DString temp_new(String s = "") => new(s, allocator::temp()) @inline;
 
+
+fn void DString.replace_char(self, char ch, char replacement)
+{
+	StringData* data = self.data();
+	foreach (&c : data.chars[:data.len])
+	{
+		if (*c == ch) *c = replacement;
+	}
+}
+
+fn void DString.replace(&self, String needle, String replacement)
+{
+	StringData* data = self.data();
+	usz needle_len = needle.len;
+	if (!data || data.len < needle_len) return;
+	usz replace_len = replacement.len;
+	if (needle_len == 1 && replace_len == 1)
+	{
+		self.replace_char(needle[0], replacement[0]);
+		return;
+	}
+	@pool(data.allocator) {
+		String str = self.tcopy_str();
+		self.clear();
+		usz len = str.len;
+		usz match = 0;
+		foreach (i, c : str)
+		{
+			if (c == needle[match])
+    	    {
+    	        match++;
+    		    if (match == needle_len)
+    		    {
+    			    self.append_chars(replacement);
+    			    match = 0;
+    			    continue;
+    		    }
+    		    continue;
+    		}
+    		if (match > 0)
+    		{
+    		    self.append_chars(str[i - match:match]);
+    		    match = 0;
+    		}
+    		self.append_char(c);
+    	}
+    	if (match > 0) self.append_chars(str[^match:match]);
+	};
+}
+
 fn DString DString.new_concat(self, DString b, Allocator allocator = allocator::heap())
 {
 	DString string;
@@ -104,13 +154,15 @@ fn String DString.str_view(self)
 	return (String)data.chars[:data.len];
 }
 
-fn void DString.append_utf32(&self, Char32[] chars)
+fn usz DString.append_utf32(&self, Char32[] chars)
 {
 	self.reserve(chars.len);
+	usz end = self.len();
 	foreach (Char32 c : chars)
 	{
 		self.append_char32(c);
 	}
+	return self.data().len - end;
 }
 
 /**
@@ -135,7 +187,7 @@ fn void DString.append_repeat(&self, char c, usz times)
 /**
  * @require c <= 0x10ffff
  */
-fn void DString.append_char32(&self, Char32 c)
+fn usz DString.append_char32(&self, Char32 c)
 {
 	char[4] buffer @noinit;
 	char* p = &buffer;
@@ -144,6 +196,7 @@ fn void DString.append_char32(&self, Char32 c)
 	StringData* data = self.data();
 	data.chars[data.len:n] = buffer[:n];
 	data.len += n;
+	return n;
 }
 
 fn DString DString.tcopy(&self) => self.copy(allocator::temp());
@@ -242,7 +295,7 @@ fn void DString.append_chars(&self, String str)
 
 fn Char32[] DString.copy_utf32(&self, Allocator allocator = allocator::heap())
 {
-	return self.str_view().to_new_utf32(allocator) @inline!!;
+	return self.str_view().to_utf32(allocator) @inline!!;
 }
 
 fn void DString.append_string(&self, DString str)
@@ -337,7 +390,10 @@ macro void DString.append(&self, value)
 	$endswitch
 }
 
-fn void DString.insert_at(&self, usz index, String s)
+/**
+ * @require index <= self.len()
+ **/
+fn void DString.insert_chars_at(&self, usz index, String s)
 {
 	if (s.len == 0) return;
 	self.reserve(s.len);
@@ -369,20 +425,125 @@ fn void DString.insert_at(&self, usz index, String s)
 	}
 }
 
+/**
+ * @require index <= self.len()
+ **/
+fn void DString.insert_string_at(&self, usz index, DString str)
+{
+	StringData* other = str.data();
+	if (!other) return;
+	self.insert_at(index, str.str_view());
+}
+
+/**
+ * @require index <= self.len()
+ **/
+fn void DString.insert_char_at(&self, usz index, char c)
+{
+	self.reserve(1);
+	StringData* data = self.data();
+
+	char* start = &data.chars[index];
+	mem::move(start + 1, start, self.len() - index);
+	data.chars[index] = c;
+	data.len++;
+}
+
+/**
+ * @require index <= self.len()
+ **/
+fn usz DString.insert_char32_at(&self, usz index, Char32 c)
+{
+	char[4] buffer @noinit;
+	char* p = &buffer;
+	usz n = conv::char32_to_utf8_unsafe(c, &p);
+
+	self.reserve(n);
+	StringData* data = self.data();
+
+	char* start = &data.chars[index];
+	mem::move(start + n, start, self.len() - index);
+	data.chars[index:n] = buffer[:n];
+	data.len += n;
+
+	return n;
+}
+
+/**
+ * @require index <= self.len()
+ **/
+fn usz DString.insert_utf32_at(&self, usz index, Char32[] chars)
+{
+	usz n = conv::utf8len_for_utf32(chars);
+	
+	self.reserve(n);
+	StringData* data = self.data();
+
+	char* start = &data.chars[index];
+	mem::move(start + n, start, self.len() - index);
+
+	char[4] buffer @noinit;
+
+	foreach(c : chars)
+	{
+		char* p = &buffer;
+		usz m = conv::char32_to_utf8_unsafe(c, &p);
+		data.chars[index:m] = buffer[:m];
+		index += m;
+	}
+
+	data.len += n;
+
+	return n;
+}
+
+macro void DString.insert_at(&self, usz index, value)
+{
+	var $Type = $typeof(value);
+	$switch ($Type)
+		$case char:
+		$case ichar:
+			self.insert_char_at(index, value);
+		$case DString:
+			self.insert_string_at(index, value);
+		$case String:
+			self.insert_chars_at(index, value);
+		$case Char32:
+			self.insert_char32_at(index, value);
+		$default:
+			$switch
+				$case $defined((Char32)value):
+					self.insert_char32_at(index, (Char32)value);
+				$case $defined((String)value):
+					self.insert_chars_at(index, (String)value);
+				$default:
+					$error "Unsupported type for insert";
+			$endswitch
+	$endswitch
+}
+
 fn usz! DString.appendf(&self, String format, args...) @maydiscard
 {
-	Formatter formatter;
-	formatter.init(&out_string_append_fn, self);
-	return formatter.vprintf(format, args);
+	if (!self.data()) self.new_init(format.len + 20);
+	@pool(self.data().allocator)
+	{
+		Formatter formatter;
+		formatter.init(&out_string_append_fn, self);
+		return formatter.vprintf(format, args);
+	};
 }
 
 fn usz! DString.appendfn(&self, String format, args...) @maydiscard
 {
-	Formatter formatter;
-	formatter.init(&out_string_append_fn, self);
-	usz len = formatter.vprintf(format, args)!;
-	self.append('\n');
-	return len + 1;
+	if (!self.data()) self.new_init(format.len + 20);
+	@pool(self.data().allocator)
+	{
+		Formatter formatter;
+		formatter.init(&out_string_append_fn, self);
+		usz len = formatter.vprintf(format, args)!;
+		self.append('\n');
+		return len + 1;
+	};
 }
 
 fn DString new_join(String[] s, String joiner, Allocator allocator = allocator::heap())
@@ -409,6 +570,19 @@ fn void! out_string_append_fn(void* data, char c) @private
 	s.append_char(c);
 }
 
+fn void DString.reverse(self)
+{
+	StringData *data = self.data();
+	if (!data) return;
+	isz mid = data.len / 2;
+	for (isz i = 0; i < mid; i++)
+	{
+		char temp = data.chars[i];
+		isz reverse_index = data.len - 1 - i;
+		data.chars[i] = data.chars[reverse_index];
+		data.chars[reverse_index] = temp;
+	}
+}
 
 fn StringData* DString.data(self) @inline @private
 {

lib/std/core/env.c3

@@ -112,8 +112,11 @@ enum ArchType
 	WASM64,       // WebAssembly with 64-bit pointers
 	RSCRIPT32,    // 32-bit RenderScript
 	RSCRIPT64,    // 64-bit RenderScript
+	XTENSA,       // Xtensa
 }
 
+const String COMPILER_BUILD_HASH = $$BUILD_HASH;
+const String COMPILER_BUILD_DATE = $$BUILD_DATE;
 const OsType OS_TYPE = (OsType)$$OS_TYPE;
 const ArchType ARCH_TYPE = (ArchType)$$ARCH_TYPE;
 const bool ARCH_32_BIT = $$REGISTER_SIZE == 32;
@@ -128,6 +131,7 @@ const bool F128_SUPPORT = $$PLATFORM_F128_SUPPORTED;
 const REGISTER_SIZE = $$REGISTER_SIZE;
 const bool COMPILER_SAFE_MODE = $$COMPILER_SAFE_MODE;
 const bool DEBUG_SYMBOLS = $$DEBUG_SYMBOLS;
+const bool BACKTRACE = $$BACKTRACE;
 const usz LLVM_VERSION = $$LLVM_VERSION;
 const bool BENCHMARKING = $$BENCHMARKING;
 const bool TESTING = $$TESTING;
@@ -144,10 +148,15 @@ const bool POSIX = LIBC && os_is_posix();
 const bool OPENBSD = LIBC && OS_TYPE == OPENBSD;
 const bool FREEBSD = LIBC && OS_TYPE == FREEBSD;
 const bool NETBSD = LIBC && OS_TYPE == NETBSD;
+const bool BSD_FAMILY = env::FREEBSD || env::OPENBSD || env::NETBSD;
 const bool WASI = LIBC && OS_TYPE == WASI;
 const bool WASM_NOLIBC @builtin = !LIBC && ARCH_TYPE == ArchType.WASM32 || ARCH_TYPE == ArchType.WASM64;
+const bool ADDRESS_SANITIZER = $$ADDRESS_SANITIZER;
+const bool MEMORY_SANITIZER = $$MEMORY_SANITIZER;
+const bool THREAD_SANITIZER = $$THREAD_SANITIZER;
+const bool ANY_SANITIZER = ADDRESS_SANITIZER || MEMORY_SANITIZER || THREAD_SANITIZER;
 
-macro bool os_is_darwin()
+macro bool os_is_darwin() @const
 {
 	$switch (OS_TYPE)
 	$case IOS:
@@ -160,7 +169,7 @@ macro bool os_is_darwin()
 	$endswitch
 }
 
-macro bool os_is_posix()
+macro bool os_is_posix() @const
 {
 	$switch (OS_TYPE)
 	$case IOS:

lib/std/core/mem.c3

@@ -8,7 +8,7 @@ import std::math;
 const MAX_MEMORY_ALIGNMENT = 0x1000_0000;
 const DEFAULT_MEM_ALIGNMENT = (void*.alignof) * 2;
 
-macro bool @constant_is_power_of_2($x) @private
+macro bool @constant_is_power_of_2($x) @const @private
 {
 	return $x != 0 && ($x & ($x - 1)) == 0;
 }
@@ -281,6 +281,11 @@ fn bool ptr_is_aligned(void* ptr, usz alignment) @inline
 	return (uptr)ptr & ((uptr)alignment - 1) == 0;
 }
 
+macro void zero_volatile(char[] data)
+{
+	$$memset(data.ptr, (char)0, data.len, true, (usz)1);
+}
+
 macro void clear(void* dst, usz len, usz $dst_align = 0, bool $is_volatile = false, bool $inlined = false)
 {
 	$$memset(dst, (char)0, len, $is_volatile, $dst_align);
@@ -528,26 +533,24 @@ macro void @pool(TempAllocator* #other_temp = null; @body) @builtin
 	@body();
 }
 
-
-
-
 import libc;
 
 
 module std::core::mem @if(WASM_NOLIBC);
-
+import std::core::mem::allocator @public;
 SimpleHeapAllocator wasm_allocator @private;
 extern int __heap_base;
 
-fn void initialize_wasm_mem() @init(1) @private
+fn void initialize_wasm_mem() @init(1024) @private
 {
 	allocator::wasm_memory.allocate_block(mem::DEFAULT_MEM_ALIGNMENT)!!; // Give us a valid null.
 	// Check if we need to move the heap.
 	uptr start = (uptr)&__heap_base;
 	if (start > mem::DEFAULT_MEM_ALIGNMENT) allocator::wasm_memory.use = start;
 	wasm_allocator.init(fn (x) => allocator::wasm_memory.allocate_block(x));
-	temp_base_allocator = &wasm_allocator;
 	allocator::thread_allocator = &wasm_allocator;
+	allocator::temp_base_allocator = &wasm_allocator;
+	allocator::init_default_temp_allocators();
 }
 
 module std::core::mem;
@@ -594,7 +597,7 @@ fn void* tmalloc(usz size, usz alignment = 0) @builtin @inline @nodiscard
 
 /**
  * @require $vacount < 2 : "Too many arguments."
- * @require $or($vacount == 0, $assignable($vaexpr(0), $Type)) : "The second argument must be an initializer for the type"
+ * @require $vacount == 0 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
  * @require $Type.alignof <= DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_aligned' instead"
  **/
 macro new($Type, ...) @nodiscard
@@ -603,7 +606,7 @@ macro new($Type, ...) @nodiscard
 		return ($Type*)calloc($Type.sizeof);
 	$else
 		$Type* val = malloc($Type.sizeof);
-		*val = $vaexpr(0);
+		*val = $vaexpr[0];
 		return val;
 	$endif
 }
@@ -612,7 +615,7 @@ macro new($Type, ...) @nodiscard
  * Allocate using an aligned allocation. This is necessary for types with a default memory alignment
  * exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
  * @require $vacount < 2 : "Too many arguments."
- * @require $or($vacount == 0, $assignable($vaexpr(0), $Type)) : "The second argument must be an initializer for the type"
+ * @require $vacount == 0 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
  **/
 macro new_aligned($Type, ...) @nodiscard
 {
@@ -620,7 +623,7 @@ macro new_aligned($Type, ...) @nodiscard
 		return ($Type*)calloc_aligned($Type.sizeof, $Type.alignof);
 	$else
 		$Type* val = malloc_aligned($Type.sizeof, $Type.alignof);
-		*val = $vaexpr(0);
+		*val = $vaexpr[0];
 		return val;
 	$endif
 }
@@ -644,7 +647,7 @@ macro alloc_aligned($Type) @nodiscard
 
 /**
  * @require $vacount < 2 : "Too many arguments."
- * @require $or($vacount == 0, $assignable($vaexpr(0), $Type)) : "The second argument must be an initializer for the type"
+ * @require $vacount == 0 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
  **/
 macro temp_new($Type, ...) @nodiscard
 {
@@ -652,7 +655,7 @@ macro temp_new($Type, ...) @nodiscard
 		return ($Type*)tcalloc($Type.sizeof) @inline;
 	$else
 		$Type* val = tmalloc($Type.sizeof) @inline;
-		*val = $vaexpr(0);
+		*val = $vaexpr[0];
 		return val;
 	$endif
 }

lib/std/core/mem_allocator.c3

@@ -143,13 +143,13 @@ macro void free_aligned(Allocator allocator, void* ptr)
 	$if env::TESTING:
 	((char*)ptr)[0] = 0xBA;
 	$endif
-	allocator.release(ptr, .aligned = true);
+	allocator.release(ptr, aligned: true);
 }
 
 /**
  * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_aligned' instead"
  * @require $vacount < 2 : "Too many arguments."
- * @require $or($vacount == 0, $assignable($vaexpr(0), $Type)) : "The second argument must be an initializer for the type"
+ * @require $vacount == 0 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
  **/
 macro new(Allocator allocator, $Type, ...) @nodiscard
 {
@@ -157,7 +157,7 @@ macro new(Allocator allocator, $Type, ...) @nodiscard
 		return ($Type*)calloc(allocator, $Type.sizeof);
 	$else
 		$Type* val = malloc(allocator, $Type.sizeof);
-		*val = $vaexpr(0);
+		*val = $vaexpr[0];
 		return val;
 	$endif
 }
@@ -165,7 +165,7 @@ macro new(Allocator allocator, $Type, ...) @nodiscard
 /**
  * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_aligned' instead"
  * @require $vacount < 2 : "Too many arguments."
- * @require $or($vacount == 0, $assignable($vaexpr(0), $Type)) : "The second argument must be an initializer for the type"
+ * @require $vacount == 0 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
  **/
 macro new_try(Allocator allocator, $Type, ...) @nodiscard
 {
@@ -173,7 +173,7 @@ macro new_try(Allocator allocator, $Type, ...) @nodiscard
 		return ($Type*)calloc_try(allocator, $Type.sizeof);
 	$else
 		$Type* val = malloc_try(allocator, $Type.sizeof)!;
-		*val = $vaexpr(0);
+		*val = $vaexpr[0];
 		return val;
 	$endif
 }
@@ -182,7 +182,7 @@ macro new_try(Allocator allocator, $Type, ...) @nodiscard
  * Allocate using an aligned allocation. This is necessary for types with a default memory alignment
  * exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
  * @require $vacount < 2 : "Too many arguments."
- * @require $or($vacount == 0, $assignable($vaexpr(0), $Type)) : "The second argument must be an initializer for the type"
+ * @require $vacount == 0 ||| $assignable($vaexpr[0], $Type) : "The second argument must be an initializer for the type"
  **/
 macro new_aligned($Type, ...) @nodiscard
 {
@@ -190,7 +190,7 @@ macro new_aligned($Type, ...) @nodiscard
 		return ($Type*)calloc_aligned(allocator, $Type.sizeof, $Type.alignof);
 	$else
 		$Type* val = malloc_aligned(allocator, $Type.sizeof, $Type.alignof);
-		*val = $vaexpr(0);
+		*val = $vaexpr[0];
 		return val;
 	$endif
 }
@@ -358,10 +358,22 @@ macro void*! @aligned_realloc(#calloc_fn, #free_fn, void* old_pointer, usz bytes
 
 
 // All allocators
-tlocal Allocator thread_allocator @private = &allocator::LIBC_ALLOCATOR;
+
+
+tlocal Allocator thread_allocator @private = base_allocator();
+Allocator temp_base_allocator @private = base_allocator();
+
 tlocal TempAllocator* thread_temp_allocator @private = null;
 tlocal TempAllocator*[2] temp_allocator_pair @private;
-Allocator temp_base_allocator @private = &allocator::LIBC_ALLOCATOR;
+
+macro Allocator base_allocator() @private
+{
+	$if env::LIBC:
+		return &allocator::LIBC_ALLOCATOR;
+	$else
+		return &allocator::NULL_ALLOCATOR;
+	$endif
+}
 
 macro TempAllocator* create_default_sized_temp_allocator(Allocator allocator) @local
 {
@@ -395,6 +407,23 @@ fn void init_default_temp_allocators() @private
 	thread_temp_allocator = temp_allocator_pair[0];
 }
 
+fn void destroy_temp_allocators_after_exit() @finalizer(65535) @local @if(env::LIBC)
+{
+	destroy_temp_allocators();
+}
+
+/**
+ * Call this to destroy any memory used by the temp allocators. This will invalidate all temp memory.
+ **/
+fn void destroy_temp_allocators()
+{
+	if (!thread_temp_allocator) return;
+	temp_allocator_pair[0].destroy();
+	temp_allocator_pair[1].destroy();
+	temp_allocator_pair[..] = null;
+	thread_temp_allocator = null;
+}
+
 fn TempAllocator* temp_allocator_next() @private
 {
 	if (!thread_temp_allocator)
@@ -405,3 +434,21 @@ fn TempAllocator* temp_allocator_next() @private
 	usz index = thread_temp_allocator == temp_allocator_pair[0] ? 1 : 0;
 	return thread_temp_allocator = temp_allocator_pair[index];
 }
+
+const NullAllocator NULL_ALLOCATOR = {};
+distinct NullAllocator (Allocator) = uptr;
+
+fn void*! NullAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+{
+	return AllocationFailure.OUT_OF_MEMORY?;
+}
+
+fn void*! NullAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+{
+	return AllocationFailure.OUT_OF_MEMORY?;
+}
+
+fn void NullAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
+{
+}
+

lib/std/core/private/cpu_detect.c3

@@ -30,6 +30,7 @@ enum X86Feature
 	AMX_FP16,
 	AMX_INT8,
 	AMX_TILE,
+	APXF,
 	AVX,
 	AVX10_1_256,
 	AVX10_1_512,
@@ -156,6 +157,7 @@ fn void x86_initialize_cpu_features()
 	add_feature_if_bit(AMX_FP16, leaf7s1.eax, 21);
 	add_feature_if_bit(AMX_INT8, leaf7.edx, 25);
 	add_feature_if_bit(AMX_TILE, leaf7.edx, 24);
+	add_feature_if_bit(APXF, leaf7s1.edx, 21);
 	add_feature_if_bit(AVX, feat.ecx, 28);
 	add_feature_if_bit(AVX10_1_256, leaf7s1.edx, 19);
 	add_feature_if_bit(AVX10_1_512, leaf_24.ebx, 18);
@@ -255,4 +257,4 @@ fn void x86_initialize_cpu_features()
 	add_feature_if_bit(XSAVEOPT, leaf_d.eax, 0);
 	add_feature_if_bit(XSAVES, leaf_d.eax, 3);
 
-}
+}

lib/std/core/private/main_stub.c3

@@ -84,19 +84,19 @@ macro void release_wargs(String[] list) @private
 	free(list.ptr);
 }
 
-macro int @win_to_err_main_noargs(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_err_main_noargs(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	if (catch #m()) return 1;
 	return 0;
 }
-macro int @win_to_int_main_noargs(#m, void* handle, Char16* cmd_line, int show_cmd) => #m();
-macro int @win_to_void_main_noargs(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_int_main_noargs(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd) => #m();
+macro int @win_to_void_main_noargs(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	#m();
 	return 0;
 }
 
-macro int @win_to_err_main_args(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_err_main_args(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
@@ -104,14 +104,14 @@ macro int @win_to_err_main_args(#m, void* handle, Char16* cmd_line, int show_cmd
 	return 0;
 }
 
-macro int @win_to_int_main_args(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_int_main_args(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
 	return #m(args);
 }
 
-macro int @win_to_void_main_args(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_void_main_args(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
@@ -119,26 +119,26 @@ macro int @win_to_void_main_args(#m, void* handle, Char16* cmd_line, int show_cm
 	return 0;
 }
 
-macro int @win_to_err_main(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_err_main(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
-	if (catch #m(handle, args, show_cmd)) return 1;
+	if (catch #m(handle, prev_handle, args, show_cmd)) return 1;
 	return 0;
 }
 
-macro int @win_to_int_main(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_int_main(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
-	return #m(handle, args, show_cmd);
+	return #m(handle, prev_handle, args, show_cmd);
 }
 
-macro int @win_to_void_main(#m, void* handle, Char16* cmd_line, int show_cmd)
+macro int @win_to_void_main(#m, void* handle, void* prev_handle, Char16* cmd_line, int show_cmd)
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
-	#m(handle, args, show_cmd);
+	#m(handle, prev_handle, args, show_cmd);
 	return 0;
 }
 

lib/std/core/runtime.c3

@@ -4,6 +4,12 @@
 module std::core::runtime;
 import libc, std::time, std::io, std::sort;
 
+struct ReflectedParam @if(!$defined(ReflectedParam))
+{
+	String name;
+	typeid type;
+}
+
 struct AnyRaw
 {
 	void* ptr;
@@ -215,6 +221,7 @@ fn bool run_tests(TestUnit[] tests)
 		name.appendf("Testing %s ", unit.name);
 		name.append_repeat('.', max_name - unit.name.len + 2);
 		io::printf("%s ", name.str_view());
+		(void)io::stdout().flush();
 		if (libc::setjmp(&context.buf) == 0)
 		{
 			if (catch err = unit.func())

lib/std/core/sanitizer/asan.c3

@@ -0,0 +1,127 @@
+// Add this to your code to suppress leak detection or set other default options
+// fn ZString __asan_default_options() @export("__asan_default_options") @if(env::ADDRESS_SANITIZER)
+// {
+//   return "detect_leaks=0";
+// }
+
+// Add this to break on error
+// asan::set_error_report_callback(fn (ZString err)
+// {
+//   breakpoint();
+// });
+
+module std::core::sanitizer::asan;
+
+def ErrorCallback = fn void (ZString);
+
+/**
+ * Marks a memory region ([addr, addr+size)) as unaddressable.
+ *
+ * This memory must be previously allocated by your program. Instrumented
+ * code is forbidden from accessing addresses in this region until it is
+ * unpoisoned. This function is not guaranteed to poison the entire region -
+ * it could poison only a subregion of [addr, addr+size) due to ASan
+ * alignment restrictions.
+ *
+ * NOTE This function is not thread-safe because no two threads can poison or
+ * unpoison memory in the same memory region simultaneously.
+ *
+ * @param addr "Start of memory region."
+ * @param size "Size of memory region."
+ **/
+macro poison_memory_region(void* addr, usz size)
+{
+	$if env::ADDRESS_SANITIZER: 
+		__asan_poison_memory_region(addr, size);
+	$endif 
+}
+
+/**
+ * Marks a memory region ([addr, addr+size)) as addressable.
+ *
+ * This memory must be previously allocated by your program. Accessing
+ * addresses in this region is allowed until this region is poisoned again.
+ * This function could unpoison a super-region of [addr, addr+size) due
+ * to ASan alignment restrictions.
+ *
+ * NOTE This function is not thread-safe because no two threads can
+ * poison or unpoison memory in the same memory region simultaneously.
+ *
+ * @param addr "Start of memory region."
+ * @param size "Size of memory region."
+ **/
+macro unpoison_memory_region(void* addr, usz size)
+{
+	$if env::ADDRESS_SANITIZER: 
+		__asan_unpoison_memory_region(addr, size);
+	$endif 
+}
+
+/**
+ * Checks if an address is poisoned.
+ * @return "True if 'addr' is poisoned (that is, 1-byte read/write access to this address would result in an error report from ASan). Otherwise returns false."
+ * @param addr "Address to check."
+ **/
+macro bool address_is_poisoned(void* addr)
+{
+	$if env::ADDRESS_SANITIZER:
+		return (bool)__asan_address_is_poisoned(addr);
+	$else
+		return false;
+	$endif
+}
+
+/**
+ * Checks if a region is poisoned.
+ *
+ * If at least one byte in [beg, beg+size) is poisoned, returns the
+ * address of the first such byte. Otherwise returns 0.
+ *
+ * @param beg "Start of memory region."
+ * @param size "Start of memory region."
+ * @return "Address of first poisoned byte."
+ **/
+macro void* region_is_poisoned(void* beg, usz size)
+{
+	$if env::ADDRESS_SANITIZER:
+		return __asan_region_is_poisoned(addr);
+	$else
+		return null;
+	$endif
+}
+
+/**
+ * Sets the callback function to be called during ASan error reporting.
+ **/
+fn void set_error_report_callback(ErrorCallback callback)
+{
+	$if env::ADDRESS_SANITIZER:
+		__asan_set_error_report_callback(callback);
+	$endif
+}
+
+module std::core::sanitizer::asan @if(env::ADDRESS_SANITIZER);
+
+extern fn void __asan_poison_memory_region(void* addr, usz size);
+extern fn void __asan_unpoison_memory_region(void* addr, usz size);
+extern fn CInt __asan_address_is_poisoned(void* addr);
+extern fn void* __asan_region_is_poisoned(void* beg, usz size);
+extern fn void __asan_describe_address(void* addr);
+extern fn CInt __asan_report_present();
+extern fn void* __asan_get_report_pc();
+extern fn void* __asan_get_report_bp();
+extern fn void* __asan_get_report_sp();
+extern fn void* __asan_get_report_address();
+extern fn CInt __asan_get_report_access_type();
+extern fn usz __asan_get_report_access_size();
+extern fn ZString __asan_get_report_description();
+extern fn ZString __asan_locate_address(void* addr, char* name, usz name_size, void** region_address, usz* region_size);
+extern fn usz __asan_get_alloc_stack(void* addr, void** trace, usz size, CInt* thread_id);
+extern fn usz __asan_get_free_stack(void* addr, void** trace, usz size, CInt* thread_id);
+extern fn void __asan_get_shadow_mapping(usz* shadow_scale, usz* shadow_offset);
+extern fn void __asan_set_error_report_callback(ErrorCallback callback);
+extern fn void __asan_print_accumulated_stats();
+extern fn void* __asan_get_current_fake_stack();
+extern fn void* __asan_addr_is_in_fake_stack(void* fake_stack, void* addr, void** beg, void** end);
+extern fn void __asan_handle_no_return();
+extern fn CInt __asan_update_allocation_context(void* addr);

lib/std/core/sanitizer/sanitizer.c3

@@ -0,0 +1,80 @@
+module std::core::sanitizer;
+
+macro void annotate_contiguous_container(void* beg, void* end, void* old_mid, void* new_mid)
+{
+	$if env::ADDRESS_SANITIZER:
+		__sanitizer_annotate_contiguous_container(beg, end, old_mid, new_mid);
+	$endif
+}
+
+macro void annotate_double_ended_contiguous_container(void* storage_beg, void* storage_end, void* old_container_beg, void* old_container_end, void* new_container_beg, void* new_container_end)
+{
+	$if env::ADDRESS_SANITIZER:
+		__sanitizer_annotate_double_ended_contiguous_container(storage_beg, storage_end, old_container_beg, old_container_end, new_container_beg, new_container_end);
+	$endif
+}
+
+macro void print_stack_trace()
+{
+	$if env::ADDRESS_SANITIZER:
+		__sanitizer_print_stack_trace();
+	$endif
+}
+
+fn void set_death_callback(VoidFn callback)
+{
+	$if env::ANY_SANITIZER:
+		__sanitizer_set_death_callback(callback);
+	$endif
+}
+
+module std::core::sanitizer @if (env::ANY_SANITIZER);
+
+struct __Sanitizer_sandbox_arguments
+{
+	CInt coverage_sandboxed;
+	iptr coverage_fd;
+	CUInt coverage_max_block_size;
+}
+
+extern fn void __sanitizer_set_report_path(ZString path);
+extern fn void __sanitizer_set_report_fd(void* fd);
+extern fn ZString __sanitizer_get_report_path();
+extern fn void __sanitizer_sandbox_on_notify(__Sanitizer_sandbox_arguments* args);
+extern fn void __sanitizer_report_error_summary(ZString error_summary);
+extern fn ushort __sanitizer_unaligned_load16(void* p);
+extern fn uint __sanitizer_unaligned_load32(void* p);
+extern fn ulong __sanitizer_unaligned_load64(void* p);
+extern fn void __sanitizer_unaligned_store16(void* p, ushort x);
+extern fn void __sanitizer_unaligned_store32(void* p, uint x);
+extern fn void __sanitizer_unaligned_store64(void* p, ulong x);
+extern fn CInt __sanitizer_acquire_crash_state();
+extern fn void __sanitizer_annotate_contiguous_container(void* beg, void* end, void* old_mid, void* new_mid);
+extern fn void __sanitizer_annotate_double_ended_contiguous_container(void* storage_beg, void* storage_end,
+	void* old_container_beg, void* old_container_end,
+	void* new_container_beg, void* new_container_end);
+extern fn CInt __sanitizer_verify_contiguous_container(void* beg, void* mid, void* end);
+extern fn CInt __sanitizer_verify_double_ended_contiguous_container(
+	void* storage_beg, void* container_beg,
+	void* container_end, void* storage_end);
+extern fn void* __sanitizer_contiguous_container_find_bad_address(void* beg, void* mid, void* end);
+extern fn void* __sanitizer_double_ended_contiguous_container_find_bad_address(
+	void* storage_beg, void* container_beg,
+	void* container_end, void* storage_end);
+
+extern fn void __sanitizer_print_stack_trace();
+extern fn void __sanitizer_symbolize_pc(void* pc, ZString fmt, char* out_buf, usz out_buf_size);
+extern fn void __sanitizer_symbolize_global(void* data_ptr, ZString fmt, char* out_buf, usz out_buf_size);
+extern fn void __sanitizer_set_death_callback(VoidFn callback);
+extern fn void __sanitizer_weak_hook_memcmp(void* called_pc, void* s1, void* s2, usz n, CInt result);
+extern fn void __sanitizer_weak_hook_strncmp(void* called_pc, ZString s1, ZString s2, usz n, CInt result);
+extern fn void __sanitizer_weak_hook_strncasecmp(void* called_pc, ZString s1, ZString s2, usz n, CInt result);
+extern fn void __sanitizer_weak_hook_strcmp(void* called_pc, ZString s1, ZString s2, CInt result);
+extern fn void __sanitizer_weak_hook_strcasecmp(void* called_pc, ZString s1, ZString s2, CInt result);
+extern fn void __sanitizer_weak_hook_strstr(void* called_pc, ZString s1, ZString s2, char* result);
+extern fn void __sanitizer_weak_hook_strcasestr(void* called_pc, ZString s1, ZString s2, char* result);
+extern fn void __sanitizer_weak_hook_memmem(void* called_pc, void* s1, usz len1, void* s2, usz len2, void* result);
+extern fn void __sanitizer_print_memory_profile(usz top_percent, usz max_number_of_contexts);
+extern fn void __sanitizer_start_switch_fiber(void** fake_stack_save, void* bottom, usz size);
+extern fn void __sanitizer_finish_switch_fiber(void* fake_stack_save, void** bottom_old, usz* size_old);
+extern fn CInt __sanitizer_get_module_and_offset_for_pc(void* pc, char* module_path, usz module_path_len, void** pc_offset);

lib/std/core/sanitizer/tsan.c3

@@ -0,0 +1,39 @@
+module std::core::sanitizer::tsan;
+
+distinct MutexFlags = inline CUInt;
+
+const MutexFlags MUTEX_LINKER_INIT      = 1 << 0;
+const MutexFlags MUTEX_WRITE_REENTRANT  = 1 << 1;
+const MutexFlags MUTEX_READ_REENTRANT   = 1 << 2;
+const MutexFlags MUTEX_NOT_STATIC       = 1 << 8;
+const MutexFlags MUTEX_READ_LOCK        = 1 << 3;
+const MutexFlags MUTEX_TRY_LOCK         = 1 << 4;
+const MutexFlags MUTEX_TRY_LOCK_FAILED  = 1 << 5;
+const MutexFlags MUTEX_RECURSIVE_LOCK   = 1 << 6;
+const MutexFlags MUTEX_RECURSIVE_UNLOCK = 1 << 7;
+const MutexFlags MUTEX_TRY_READ_LOCK = MUTEX_READ_LOCK | MUTEX_TRY_LOCK;
+const MutexFlags MUTEX_TRY_READ_LOCK_FAILED = MUTEX_TRY_READ_LOCK | MUTEX_TRY_LOCK_FAILED;
+
+macro void mutex_create(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_create(addr, flags); $endif }
+macro void mutex_destroy(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_destroy(addr, flags); $endif }
+macro void mutex_pre_lock(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_pre_lock(addr, flags); $endif }
+macro void mutex_post_lock(void* addr, MutexFlags flags, CInt recursion) { $if env::THREAD_SANITIZER: __tsan_mutex_post_lock(addr, flags, recursion); $endif }
+macro CInt mutex_pre_unlock(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: return __tsan_mutex_pre_unlock(addr, flags); $else return 0; $endif }
+macro void mutex_post_unlock(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_post_unlock(addr, flags); $endif }
+macro void mutex_pre_signal(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_pre_signal(addr, flags); $endif }
+macro void mutex_post_signal(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_post_signal(addr, flags); $endif }
+macro void mutex_pre_divert(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_pre_divert(addr, flags); $endif }
+macro void mutex_post_divert(void* addr, MutexFlags flags) { $if env::THREAD_SANITIZER: __tsan_mutex_post_divert(addr, flags); $endif }
+
+module std::core::sanitizer::tsan @if(env::THREAD_SANITIZER) @private;
+
+extern fn void __tsan_mutex_create(void* addr, CUInt flags);
+extern fn void __tsan_mutex_destroy(void* addr, CUInt flags);
+extern fn void __tsan_mutex_pre_lock(void* addr, CUInt flags);
+extern fn void __tsan_mutex_post_lock(void* addr, CUInt flags, CInt recursion);
+extern fn CInt __tsan_mutex_pre_unlock(void* addr, CUInt flags);
+extern fn void __tsan_mutex_post_unlock(void* addr, CUInt flags);
+extern fn void __tsan_mutex_pre_signal(void* addr, CUInt flags);
+extern fn void __tsan_mutex_post_signal(void* addr, CUInt flags);
+extern fn void __tsan_mutex_pre_divert(void* addr, CUInt flags);
+extern fn void __tsan_mutex_post_divert(void* addr, CUInt flags);

lib/std/core/string.c3

@@ -1,6 +1,7 @@
 module std::core::string;
 import std::ascii;
 
+distinct String @if(!$defined(String)) = inline char[];
 distinct ZString = inline char*;
 distinct WString = inline Char16*;
 def Char32 = uint;
@@ -31,58 +32,66 @@ fault NumberConversion
 	FLOAT_OUT_OF_RANGE,
 }
 
-/**
- * Return a temporary String created using the formatting function.
- *
- * @param [in] fmt `The formatting string`
- **/
-macro String tformat(String fmt, ...)
-{
-	DString str = dstring::temp_with_capacity(fmt.len + $vacount * 8);
-	str.appendf(fmt, $vasplat());
-	return str.str_view();
-}
 
 /**
  * Return a temporary ZString created using the formatting function.
  *
  * @param [in] fmt `The formatting string`
  **/
-macro ZString tformat_zstr(String fmt, ...)
+fn ZString tformat_zstr(String fmt, args...)
 {
-	DString str = dstring::temp_with_capacity(fmt.len + $vacount * 8);
-	str.appendf(fmt, $vasplat());
+	DString str = dstring::temp_with_capacity(fmt.len + args.len * 8);
+	str.appendf(fmt, ...args);
 	return str.zstr_view();
 }
 
 /**
  * Return a new String created using the formatting function.
  *
- * @param [in] fmt `The formatting string`
  * @param [inout] allocator `The allocator to use`
+ * @param [in] fmt `The formatting string`
  **/
-macro String new_format(String fmt, ..., Allocator allocator = allocator::heap())
+fn String format(String fmt, args..., Allocator allocator)
 {
 	@pool(allocator)
 	{
-		DString str = dstring::temp_with_capacity(fmt.len + $vacount * 8);
-		str.appendf(fmt, $vasplat());
+		DString str = dstring::temp_with_capacity(fmt.len + args.len * 8);
+		str.appendf(fmt, ...args);
 		return str.copy_str(allocator);
 	};
 }
 
+/**
+ * Return a heap allocated String created using the formatting function.
+ *
+ * @param [in] fmt `The formatting string`
+ **/
+fn String new_format(String fmt, args..., Allocator allocator = null) => format(fmt, ...args, allocator: allocator ?: allocator::heap());
+
+/**
+ * Return a temporary String created using the formatting function.
+ *
+ * @param [in] fmt `The formatting string`
+ **/
+fn String tformat(String fmt, args...)
+{
+	DString str = dstring::temp_with_capacity(fmt.len + args.len * 8);
+	str.appendf(fmt, ...args);
+	return str.str_view();
+}
+
 /**
  * Return a new ZString created using the formatting function.
  *
  * @param [in] fmt `The formatting string`
  * @param [inout] allocator `The allocator to use`
  **/
-macro ZString new_format_zstr(String fmt, ..., Allocator allocator = allocator::heap())
+fn ZString new_format_zstr(String fmt, args..., Allocator allocator = allocator::heap())
 {
 	@pool(allocator)
 	{
-		DString str = dstring::temp_with_capacity(fmt.len + $vacount * 8);
-		str.appendf(fmt, $vasplat());
+		DString str = dstring::temp_with_capacity(fmt.len + args.len * 8);
+		str.appendf(fmt, ...args);
 		return str.copy_zstr(allocator);
 	};
 }
@@ -204,13 +213,12 @@ fn String String.strip_end(string, String needle)
 	return string[:(string.len - needle.len)];
 }
 
-
 /**
  * Split a string into parts, e.g "a|b|c" split with "|" yields { "a", "b", "c" }
  *
  * @param [in] s
  * @param [in] needle
- * @param [&inout] allocator "The allocator, defaults to the heap allocator"
+ * @param [&inout] allocator "The allocator to use for the String[]"
  * @param max "Max number of elements, 0 means no limit, defaults to 0"
  * @require needle.len > 0 "The needle must be at least 1 character long"
  * @ensure return.len > 0
@@ -245,6 +253,18 @@ fn String[] String.split(s, String needle, usz max = 0, Allocator allocator = al
 	return holder[:i];
 }
 
+/**
+ * Split a string into parts, e.g "a|b|c" split with "|" yields { "a", "b", "c" }, using the heap allocator
+ * to store the parts.
+ *
+ * @param [in] s
+ * @param [in] needle
+ * @param max "Max number of elements, 0 means no limit, defaults to 0"
+ * @require needle.len > 0 "The needle must be at least 1 character long"
+ * @ensure return.len > 0
+ **/
+fn String[] String.new_split(s, String needle, usz max = 0) => s.split(needle, max, allocator::heap()) @inline;
+
 /**
  * This function is identical to String.split, but implicitly uses the
  * temporary allocator.
@@ -253,10 +273,7 @@ fn String[] String.split(s, String needle, usz max = 0, Allocator allocator = al
  * @param [in] needle
  * @param max "Max number of elements, 0 means no limit, defaults to 0"
  **/
-fn String[] String.tsplit(s, String needle, usz max = 0)
-{
-	return s.split(needle, max, allocator::temp()) @inline;
-}
+fn String[] String.tsplit(s, String needle, usz max = 0) => s.split(needle, max, allocator::temp()) @inline;
 
 /**
  * Check if a substring is found in the string.
@@ -485,17 +502,15 @@ fn Char16[]! String.to_temp_utf16(s)
 	return s.to_new_utf16(allocator::temp());
 }
 
-fn WString! String.to_new_wstring(s, Allocator allocator = allocator::heap())
+fn WString! String.to_wstring(s, Allocator allocator)
 {
 	return (WString)s.to_new_utf16(allocator).ptr;
 }
 
-fn WString! String.to_temp_wstring(s)
-{
-	return (WString)s.to_temp_utf16().ptr;
-}
+fn WString! String.to_temp_wstring(s) => s.to_wstring(allocator::temp());
+fn WString! String.to_new_wstring(s) => s.to_wstring(allocator::heap());
 
-fn Char32[]! String.to_new_utf32(s, Allocator allocator = allocator::heap())
+fn Char32[]! String.to_utf32(s, Allocator allocator)
 {
 	usz codepoints = conv::utf8_codepoints(s);
 	Char32* data = allocator::alloc_array_try(allocator, Char32, codepoints + 1)!;
@@ -504,10 +519,8 @@ fn Char32[]! String.to_new_utf32(s, Allocator allocator = allocator::heap())
 	return data[:codepoints];
 }
 
-fn Char32[]! String.to_temp_utf32(s)
-{
-	return s.to_new_utf32(allocator::temp());
-}
+fn Char32[]! String.to_new_utf32(s) => s.to_utf32(allocator::heap()) @inline;
+fn Char32[]! String.to_temp_utf32(s) => s.to_utf32(allocator::temp()) @inline;
 
 /**
  * Convert a string to ASCII lower case.
@@ -527,7 +540,7 @@ fn String String.new_ascii_to_lower(s, Allocator allocator = allocator::heap())
 	return copy;
 }
 
-fn String String.temp_ascii_to_lower(s, Allocator allocator = allocator::heap())
+fn String String.temp_ascii_to_lower(s)
 {
 	return s.new_ascii_to_lower(allocator::temp());
 }

lib/std/core/string_iterator.c3

@@ -13,11 +13,37 @@ fn void StringIterator.reset(&self)
 
 fn Char32! StringIterator.next(&self)
 {
-	usz len = self.utf8.len;
-	usz current = self.current;
-	if (current >= len) return IteratorResult.NO_MORE_ELEMENT?;
-	usz read = (len - current < 4 ? len - current : 4);
-	Char32 res = conv::utf8_to_char32(&self.utf8[current], &read)!;
-	self.current += read;
-	return res;
+    usz len = self.utf8.len;
+    usz current = self.current;
+    if (current >= len) return IteratorResult.NO_MORE_ELEMENT?;
+    usz read = (len - current < 4 ? len - current : 4);
+    Char32 res = conv::utf8_to_char32(&self.utf8[current], &read)!;
+    self.current += read;
+    return res;
+}
+
+fn Char32! StringIterator.peek(&self)
+{
+    usz len = self.utf8.len;
+    usz current = self.current;
+    if (current >= len) return IteratorResult.NO_MORE_ELEMENT?;
+    usz read = (len - current < 4 ? len - current : 4);
+    Char32 res = conv::utf8_to_char32(&self.utf8[current], &read)!;
+    return res;
+}
+
+fn bool StringIterator.has_next(&self)
+{
+    return self.current < self.utf8.len;
+}
+
+fn Char32! StringIterator.get(&self)
+{
+    usz len = self.utf8.len;
+    usz current = self.current;
+    usz read = (len - current < 4 ? len - current : 4);
+    usz index = current > read ? current - read : 0;
+    if (index >= len) return IteratorResult.NO_MORE_ELEMENT?;
+    Char32 res = conv::utf8_to_char32(&self.utf8[index], &read)!;
+    return res;
 }

lib/std/core/types.c3

@@ -120,20 +120,51 @@ macro bool is_slice_convertable($Type)
 	$endswitch
 }
 
-macro bool is_bool($Type) => $Type.kindof == TypeKind.BOOL;
-macro bool is_int($Type) => $Type.kindof == TypeKind.SIGNED_INT || $Type.kindof == TypeKind.UNSIGNED_INT;
+macro bool is_bool($Type) @const => $Type.kindof == TypeKind.BOOL;
+macro bool is_int($Type) @const  => $Type.kindof == TypeKind.SIGNED_INT || $Type.kindof == TypeKind.UNSIGNED_INT;
 
-macro bool is_indexable($Type)
+/**
+ * @require is_numerical($Type) "Expected a numerical type"
+ **/
+macro bool is_signed($Type) @const
+{
+	$switch (inner_kind($Type))
+		$case SIGNED_INT:
+		$case FLOAT:
+			return true;
+		$case VECTOR:
+			return is_signed($typefrom($Type.inner));
+		$default:
+			return false;
+	$endswitch
+}
+
+/**
+ * @require is_numerical($Type) "Expected a numerical type"
+ **/
+macro bool is_unsigned($Type) @const
+{
+	$switch (inner_kind($Type))
+		$case UNSIGNED_INT:
+			return true;
+		$case VECTOR:
+			return is_unsigned($typefrom($Type.inner));
+		$default:
+			return false;
+	$endswitch
+}
+
+macro bool is_indexable($Type) @const
 {
 	return $defined($Type{}[0]);
 }
 
-macro bool is_ref_indexable($Type)
+macro bool is_ref_indexable($Type) @const
 {
 	return $defined(&$Type{}[0]);
 }
 
-macro bool is_intlike($Type)
+macro bool is_intlike($Type) @const
 {
 	$switch ($Type.kindof)
 		$case SIGNED_INT:
@@ -146,7 +177,7 @@ macro bool is_intlike($Type)
 	$endswitch
 }
 
-macro bool is_underlying_int($Type)
+macro bool is_underlying_int($Type) @const
 {
 	$switch ($Type.kindof)
 		$case SIGNED_INT:
@@ -159,9 +190,9 @@ macro bool is_underlying_int($Type)
 	$endswitch
 }
 
-macro bool is_float($Type) => $Type.kindof == TypeKind.FLOAT;
+macro bool is_float($Type) @const  => $Type.kindof == TypeKind.FLOAT;
 
-macro bool is_floatlike($Type)
+macro bool is_floatlike($Type) @const
 {
 	$switch ($Type.kindof)
 		$case FLOAT:
@@ -173,40 +204,45 @@ macro bool is_floatlike($Type)
 	$endswitch
 }
 
-macro bool is_vector($Type)
+macro bool is_vector($Type) @const
 {
 	return $Type.kindof == TypeKind.VECTOR;
 }
 
-macro TypeKind inner_kind($Type)
+macro typeid inner_type($Type) @const
 {
 	$if $Type.kindof == TypeKind.DISTINCT:
-		return inner_kind($typefrom($Type.inner));
+		return inner_type($typefrom($Type.inner));
 	$else
-		return $Type.kindof;
+		return $Type.typeid;
 	$endif
 }
 
-macro bool is_same($TypeA, $TypeB)
+macro TypeKind inner_kind($Type) @const
+{
+	return inner_type($Type).kindof;
+}
+
+macro bool is_same($TypeA, $TypeB) @const
 {
 	return $TypeA.typeid == $TypeB.typeid;
 }
 
-macro bool @has_same(#a, #b, ...)
+macro bool @has_same(#a, #b, ...) @const
 {
 	var $type_a = @typeid(#a);
 	$if $type_a != @typeid(#b):
 		return false;
 	$endif
 	$for (var $i = 0; $i < $vacount; $i++)
-		$if @typeid($vaexpr($i)) != $type_a:
+		$if @typeid($vaexpr[$i]) != $type_a:
 			return false;
 		$endif
 	$endfor
 	return true;
 }
 
-macro bool may_load_atomic($Type)
+macro bool may_load_atomic($Type) @const
 {
 	$switch ($Type.kindof)
 	$case SIGNED_INT:
@@ -221,7 +257,7 @@ macro bool may_load_atomic($Type)
 	$endswitch
 }
 
-macro lower_to_atomic_compatible_type($Type) 
+macro lower_to_atomic_compatible_type($Type) @const
 {
 	$switch ($Type.kindof)
     $case SIGNED_INT:
@@ -247,10 +283,10 @@ macro lower_to_atomic_compatible_type($Type)
   $endswitch
 }
 
-macro bool is_promotable_to_floatlike($Type) => types::is_floatlike($Type) || types::is_int($Type);
-macro bool is_promotable_to_float($Type) => types::is_float($Type) || types::is_int($Type);
+macro bool is_promotable_to_floatlike($Type) @const  => types::is_floatlike($Type) || types::is_int($Type);
+macro bool is_promotable_to_float($Type) @const  => types::is_float($Type) || types::is_int($Type);
 
-macro bool is_same_vector_type($Type1, $Type2)
+macro bool is_same_vector_type($Type1, $Type2) @const
 {
 	$if $Type1.kindof != TypeKind.VECTOR:
 		return $Type2.kindof != TypeKind.VECTOR;
@@ -259,7 +295,7 @@ macro bool is_same_vector_type($Type1, $Type2)
 	$endif
 }
 
-macro bool is_equatable_type($Type)
+macro bool is_equatable_type($Type) @const
 {
 	$if $defined($Type.less) || $defined($Type.compare_to) || $defined($Type.equals):
 		return true;
@@ -271,17 +307,31 @@ macro bool is_equatable_type($Type)
 /**
  * Checks if a type implements the copy protocol.
  **/
-macro bool implements_copy($Type)
+macro bool implements_copy($Type) @const
 {
 	return $defined($Type.copy) && $defined($Type.free);
 }
 
-macro bool is_equatable_value(value)
+macro bool is_equatable_value(value) @deprecated
 {
 	return is_equatable_type($typeof(value));
 }
 
-macro bool is_comparable_value(value)
+macro bool @equatable_value(#value) @const
+{
+	return is_equatable_type($typeof(#value));
+}
+
+macro bool @comparable_value(#value) @const
+{
+	$if $defined(#value.less) || $defined(#value.compare_to):
+		return true;
+	$else
+		return $typeof(#value).is_ordered;
+	$endif
+}
+
+macro bool is_comparable_value(value) @deprecated
 {
 	$if $defined(value.less) || $defined(value.compare_to):
 		return true;

lib/std/core/values.c3

@@ -1,21 +1,21 @@
 module std::core::values;
 
-macro typeid @typeid(#value) @builtin => $typeof(#value).typeid;
-macro TypeKind @typekind(#value) @builtin => $typeof(#value).kindof;
-macro bool @typeis(#value, $Type) @builtin => $typeof(#value).typeid == $Type.typeid;
+macro typeid @typeid(#value) @const @builtin => $typeof(#value).typeid;
+macro TypeKind @typekind(#value) @const @builtin => $typeof(#value).kindof;
+macro bool @typeis(#value, $Type) @const @builtin => $typeof(#value).typeid == $Type.typeid;
 /**
  * Return true if two values have the same type before any conversions.
  **/
-macro bool @is_same_type(#value1, #value2) => $typeof(#value1).typeid == $typeof(#value2).typeid;
-macro bool @is_bool(#value) => types::is_bool($typeof(#value));
-macro bool @is_int(#value) => types::is_int($typeof(#value));
-macro bool @is_floatlike(#value) => types::is_floatlike($typeof(#value));
-macro bool @is_float(#value) => types::is_float($typeof(#value));
-macro bool @is_promotable_to_floatlike(#value) => types::is_promotable_to_floatlike($typeof(#value));
-macro bool @is_promotable_to_float(#value) => types::is_promotable_to_float($typeof(#value));
-macro bool @is_vector(#value) => types::is_vector($typeof(#value));
-macro bool @is_same_vector_type(#value1, #value2) => types::is_same_vector_type($typeof(#value1), $typeof(#value2));
-macro bool @assign_to(#value1, #value2) => $assignable(#value1, $typeof(#value2));
+macro bool @is_same_type(#value1, #value2) @const => $typeof(#value1).typeid == $typeof(#value2).typeid;
+macro bool @is_bool(#value) @const => types::is_bool($typeof(#value));
+macro bool @is_int(#value) @const => types::is_int($typeof(#value));
+macro bool @is_floatlike(#value) @const => types::is_floatlike($typeof(#value));
+macro bool @is_float(#value) @const => types::is_float($typeof(#value));
+macro bool @is_promotable_to_floatlike(#value) @const => types::is_promotable_to_floatlike($typeof(#value));
+macro bool @is_promotable_to_float(#value) @const => types::is_promotable_to_float($typeof(#value));
+macro bool @is_vector(#value) @const => types::is_vector($typeof(#value));
+macro bool @is_same_vector_type(#value1, #value2) @const => types::is_same_vector_type($typeof(#value1), $typeof(#value2));
+macro bool @assign_to(#value1, #value2) @const => $assignable(#value1, $typeof(#value2));
 
 macro promote_int(x)
 {
@@ -30,7 +30,7 @@ macro promote_int_same(x, y)
 {
 	$if @is_int(x):
 		$switch
-		$case $and(@is_vector(y), $typeof(y).inner == float.typeid):
+		$case @is_vector(y) &&& $typeof(y).inner == float.typeid:
 			return (float)x;
 		$case $typeof(y).typeid == float.typeid:
 			return (float)x;
@@ -42,5 +42,5 @@ macro promote_int_same(x, y)
 	$endif
 }
 
-macro TypeKind @inner_kind(#value) => types::inner_kind($typeof(#value));
+macro TypeKind @inner_kind(#value) @const => types::inner_kind($typeof(#value));
 

lib/std/crypto/crypto.c3

@@ -1,2 +1,12 @@
 module std::crypto;
 
+fn bool safe_compare(void* data1, void* data2, usz len)
+{
+	char match = 0;
+	for (usz i = 0; i < len; i++)
+	{
+		match = match | (mem::@volatile_load(((char*)data1)[i]) ^ mem::@volatile_load(((char*)data2)[i]));
+	}
+	return match == 0;
+}
+

lib/std/crypto/dh.c3

@@ -0,0 +1,12 @@
+module std::crypto::dh;
+import std::math::bigint;
+
+fn BigInt generate_secret(BigInt p, BigInt x, BigInt y)
+{
+	return y.mod_pow(x, p);
+}
+
+fn BigInt public_key(BigInt p, BigInt g, BigInt x)
+{
+	return g.mod_pow(x, p);
+}

lib/std/encoding/csv.c3

@@ -22,7 +22,7 @@ fn String[]! CsvReader.read_new_row_with_allocator(self, Allocator allocator = a
 {
 	@pool(allocator)
 	{
-		return io::treadline(self.stream).split(self.separator, .allocator = allocator);
+		return io::treadline(self.stream).split(self.separator, allocator: allocator);
 	};
 }
 
@@ -56,7 +56,7 @@ macro CsvReader.@each_row(self, int rows = int.max; @body(String[] row))
 					if (err == IoError.EOF) return;
 					return err?;
 				}
-				parts = s.split(sep, .allocator = mem);
+				parts = s.split(sep, allocator: mem);
 			};
 			@body(parts);
 		};

lib/std/encoding/json.c3

@@ -15,11 +15,31 @@ fault JsonParsingError
 	INVALID_NUMBER,
 }
 
+fn Object*! parse_string(String s, Allocator allocator = allocator::heap())
+{
+	return parse(ByteReader{}.init(s), allocator);
+}
+
+fn Object*! temp_parse_string(String s)
+{
+	return parse(ByteReader{}.init(s), allocator::temp());
+}
+
 fn Object*! parse(InStream s, Allocator allocator = allocator::heap())
 {
-	JsonContext context = { .last_string = dstring::new_with_capacity(64, allocator), .stream = s, .allocator = allocator };
-	defer context.last_string.free();
-	return parse_any(&context);
+	@stack_mem(512; Allocator mem)
+	{
+		JsonContext context = { .last_string = dstring::new_with_capacity(64, mem), .stream = s, .allocator = allocator };
+		@pool(allocator)
+		{
+			return parse_any(&context);
+		};
+	};
+}
+
+fn Object*! temp_parse(InStream s)
+{
+	return parse(s, allocator::temp());
 }
 
 // -- Implementation follows --
@@ -84,9 +104,9 @@ fn Object*! parse_any(JsonContext* context) @local
 
 fn JsonTokenType! lex_number(JsonContext *context, char c) @local
 {
-	@pool()
+	@stack_mem(256; Allocator mem)
 	{
-		DString t = dstring::temp_with_capacity(32);
+		DString t = dstring::new_with_capacity(32, allocator: mem);
 		bool negate = c == '-';
 		if (negate)
 		{
@@ -134,32 +154,34 @@ fn JsonTokenType! lex_number(JsonContext *context, char c) @local
 fn Object*! parse_map(JsonContext* context) @local
 {
 	Object* map = object::new_obj(context.allocator);
-	JsonTokenType token = advance(context)!;
 	defer catch map.free();
+	JsonTokenType token = advance(context)!;
 
-	DString temp_key = dstring::new_with_capacity(32, context.allocator);
-	defer temp_key.free();
-	while (token != JsonTokenType.RBRACE)
+	@stack_mem(256; Allocator mem)
 	{
-		if (token != JsonTokenType.STRING) return JsonParsingError.UNEXPECTED_CHARACTER?;
-		DString string = context.last_string;
-		if (map.has_key(string.str_view())) return JsonParsingError.DUPLICATE_MEMBERS?;
-		// Copy the key to our temp holder. We do this to work around the issue
-		// if the temp allocator should be used as the default allocator.
-		temp_key.clear();
-		temp_key.append(string);
-		parse_expected(context, COLON)!;
-		Object* element = parse_any(context)!;
-		map.set(temp_key.str_view(), element);
-		token = advance(context)!;
-		if (token == JsonTokenType.COMMA)
+		DString temp_key = dstring::new_with_capacity(32, mem);
+		while (token != JsonTokenType.RBRACE)
 		{
+			if (token != JsonTokenType.STRING) return JsonParsingError.UNEXPECTED_CHARACTER?;
+			DString string = context.last_string;
+			if (map.has_key(string.str_view())) return JsonParsingError.DUPLICATE_MEMBERS?;
+			// Copy the key to our temp holder, since our
+			// last_string may be used in parse_any
+			temp_key.clear();
+			temp_key.append(string);
+			parse_expected(context, COLON)!;
+			Object* element = parse_any(context)!;
+			map.set(temp_key.str_view(), element);
 			token = advance(context)!;
-			continue;
+			if (token == JsonTokenType.COMMA)
+			{
+				token = advance(context)!;
+				continue;
+			}
+			if (token != JsonTokenType.RBRACE) return JsonParsingError.UNEXPECTED_CHARACTER?;
 		}
-		if (token != JsonTokenType.RBRACE) return JsonParsingError.UNEXPECTED_CHARACTER?;
-	}
-	return map;
+		return map;
+	};
 }
 
 fn Object*! parse_array(JsonContext* context) @local
@@ -364,6 +386,7 @@ fn JsonTokenType! lex_string(JsonContext* context)
 			default:
 				 return JsonParsingError.INVALID_ESCAPE_SEQUENCE?;
 		}
+		context.last_string.append(c);
 	}
 	return STRING;
 }

lib/std/hash/hmac.c3

@@ -0,0 +1,107 @@
+module std::hash::hmac(<HashAlg, HASH_BYTES, BLOCK_BYTES>);
+import std::crypto;
+
+struct Hmac
+{
+	HashAlg a, b;
+}
+
+fn char[HASH_BYTES] hash(char[] key, char[] message)
+{
+	Hmac hmac @noinit;
+	hmac.init(key);
+	hmac.update(message);
+	return hmac.final();
+}
+
+/**
+ * @require output.len > 0 "Output must be greater than zero"
+ * @require output.len < int.max / HASH_BYTES "Output is too large"
+ **/
+fn void pbkdf2(char[] pw, char[] salt, uint iterations, char[] output)
+{
+	usz l = output.len / HASH_BYTES;
+	usz r = output.len % HASH_BYTES;
+
+	Hmac hmac;
+	hmac.init(pw);
+
+	char[] dst_curr = output;
+	for (usz i = 1; i <= l; i++)
+	{
+		@derive(&hmac, salt, iterations, i, dst_curr[:HASH_BYTES]);
+		dst_curr = dst_curr[HASH_BYTES..];
+	}
+
+	if (r > 0)
+	{
+		char[HASH_BYTES] tmp;
+		@derive(&hmac, salt, iterations, l + 1, &tmp);
+		dst_curr[..] = tmp[:dst_curr.len];
+		mem::zero_volatile(&tmp);
+	}
+}
+
+fn void Hmac.init(&self, char[] key)
+{
+	char[BLOCK_BYTES] buffer;
+	if (key.len > BLOCK_BYTES)
+	{
+		self.a.init();
+		self.a.update(key);
+		buffer[:HASH_BYTES] = self.a.final()[..];
+	}
+	else
+	{
+		buffer[:key.len] = key[..];
+	}
+
+	foreach (&b : buffer) *b ^= IPAD;
+
+	self.a.init();
+	self.a.update(&buffer);
+
+	foreach (&b : buffer) *b ^= IPAD ^ OPAD;
+
+	self.b.init();
+	self.b.update(&buffer);
+
+	mem::zero_volatile(&buffer);
+}
+
+fn void Hmac.update(&self, char[] data)
+{
+	self.a.update(data);
+}
+
+fn char[HASH_BYTES] Hmac.final(&self)
+{
+	self.b.update(&&self.a.final());
+	return self.b.final();
+}
+
+const IPAD @private = 0x36;
+const OPAD @private = 0x5C;
+
+macro @derive(Hmac *hmac_start, char[] salt, uint iterations, usz index, char[] out)
+{
+	assert(out.len == HASH_BYTES);
+	char[HASH_BYTES] tmp @noinit;
+	defer mem::zero_volatile(&tmp);
+	Hmac hmac  = *hmac_start;
+	hmac.update(salt);
+	UIntBE be = { (uint)index };
+	hmac.update(&&bitcast(be, char[4]));
+	tmp = hmac.final();
+	out[..] = tmp;
+	for (int it = 1; it < iterations; it++)
+	{
+		hmac = *hmac_start;
+		hmac.update(&tmp);
+		tmp = hmac.final();
+		foreach (i, v : tmp)
+		{
+			out[i] ^= v;
+		}
+	}
+}

lib/std/hash/md5.c3

@@ -0,0 +1,225 @@
+module std::hash::md5;
+import std::hash::hmac;
+import std::bits;
+
+const BLOCK_BYTES = 64;
+const HASH_BYTES = 16;
+
+struct Md5
+{
+	uint lo, hi;
+	uint a, b, c, d;
+	char[64] buffer;
+	uint[16] block;
+}
+
+def HmacMd5 = Hmac(<Md5, HASH_BYTES, BLOCK_BYTES>);
+def hmac = hmac::hash(<Md5, HASH_BYTES, BLOCK_BYTES>);
+def pbkdf2 = hmac::pbkdf2(<Md5, HASH_BYTES, BLOCK_BYTES>);
+
+fn char[HASH_BYTES] hash(char[] data)
+{
+	Md5 md5;
+	md5.init();
+	md5.update(data);
+	return md5.final();
+}
+
+fn void Md5.init(&self)
+{
+	self.a = 0x67452301;
+	self.b = 0xefcdab89;
+	self.c = 0x98badcfe;
+	self.d = 0x10325476;
+
+	self.lo = 0;
+	self.hi = 0;
+}
+
+
+fn void Md5.update(&ctx, char[] data)
+{
+	uint saved_lo = ctx.lo;
+	if ((ctx.lo = (saved_lo + data.len) & 0x1fffffff) < saved_lo) ctx.hi++;
+	ctx.hi += data.len >> 29;
+
+	usz used = (usz)saved_lo & 0x3f;
+
+	if (used)
+	{
+		usz available = 64 - used;
+
+		if (data.len < available)
+		{
+			ctx.buffer[used:data.len] = data[..];
+			return;
+		}
+		ctx.buffer[used:available] = data[:available];
+		data = data[available..];
+		body(ctx, &ctx.buffer, 64);
+	}
+
+	if (data.len >= 64)
+	{
+		data = body(ctx, data, data.len & ~(usz)0x3f)[:data.len & 0x3f];
+	}
+	ctx.buffer[:data.len] = data[..];
+}
+
+fn char[HASH_BYTES] Md5.final(&ctx)
+{
+	usz used = (usz)ctx.lo & 0x3f;
+	ctx.buffer[used++] = 0x80;
+
+	usz available = 64 - used;
+
+	if (available < 8)
+	{
+		ctx.buffer[used:available] = 0;
+		body(ctx, &ctx.buffer, 64);
+		used = 0;
+		available = 64;
+	}
+	ctx.buffer[used:available - 8] = 0;
+
+	ctx.lo <<= 3;
+	ctx.buffer[56:4] = bitcast(ctx.lo, char[4])[..];
+	ctx.buffer[60:4] = bitcast(ctx.hi, char[4])[..];
+
+	body(ctx, &ctx.buffer, 64);
+
+	char[16] res @noinit;
+	res[0:4] = bitcast(ctx.a, char[4]);
+	res[4:4] = bitcast(ctx.b, char[4]);
+	res[8:4] = bitcast(ctx.c, char[4]);
+	res[12:4] = bitcast(ctx.d, char[4]);
+	*ctx = {};
+	return res;
+}
+
+module std::hash::md5 @private;
+
+// Implementation
+macro @f(x, y, z) => z ^ (x & (y ^ z));
+macro @g(x, y, z) => y ^ (z & (x ^ y));
+macro @h(x, y, z) => (x ^ y) ^ z;
+macro @h2(x, y, z) => x ^ (y ^ z);
+macro @i(x, y, z) => y ^ (x | ~z);
+
+macro @step(#f, &a, b, c, d, ptr, n, t, s)
+{
+	*a += #f(b, c, d) + *(uint *)&ptr[n * 4] + t;
+	*a = (*a << s) | ((*a & 0xffffffff) >> (32 - s));
+	*a += b;
+}
+
+
+fn char* body(Md5* ctx, void* data, usz size)
+{
+	char* ptr;
+	uint a, b, c, d;
+	uint saved_a, saved_b, saved_c, saved_d;
+    ptr = data;
+	a = ctx.a;
+	b = ctx.b;
+	c = ctx.c;
+	d = ctx.d;
+
+	do
+	{
+		saved_a = a;
+		saved_b = b;
+		saved_c = c;
+		saved_d = d;
+
+/* Round 1 */
+		@step(@f, a, b, c, d, ptr, 0, 0xd76aa478, 7)  ;
+		@step(@f, d, a, b, c, ptr, 1, 0xe8c7b756, 12) ;
+		@step(@f, c, d, a, b, ptr, 2, 0x242070db, 17) ;
+		@step(@f, b, c, d, a, ptr, 3, 0xc1bdceee, 22) ;
+		@step(@f, a, b, c, d, ptr, 4, 0xf57c0faf, 7)  ;
+		@step(@f, d, a, b, c, ptr, 5, 0x4787c62a, 12) ;
+		@step(@f, c, d, a, b, ptr, 6, 0xa8304613, 17) ;
+		@step(@f, b, c, d, a, ptr, 7, 0xfd469501, 22) ;
+		@step(@f, a, b, c, d, ptr, 8, 0x698098d8, 7)  ;
+		@step(@f, d, a, b, c, ptr, 9, 0x8b44f7af, 12) ;
+		@step(@f, c, d, a, b, ptr, 10, 0xffff5bb1, 17);
+		@step(@f, b, c, d, a, ptr, 11, 0x895cd7be, 22);
+		@step(@f, a, b, c, d, ptr, 12, 0x6b901122, 7) ;
+		@step(@f, d, a, b, c, ptr, 13, 0xfd987193, 12);
+		@step(@f, c, d, a, b, ptr, 14, 0xa679438e, 17);
+		@step(@f, b, c, d, a, ptr, 15, 0x49b40821, 22);
+
+/* Round 2 */
+		@step(@g, a, b, c, d, ptr, 1, 0xf61e2562, 5)  ;
+		@step(@g, d, a, b, c, ptr, 6, 0xc040b340, 9)  ;
+		@step(@g, c, d, a, b, ptr, 11, 0x265e5a51, 14);
+		@step(@g, b, c, d, a, ptr, 0, 0xe9b6c7aa, 20) ;
+		@step(@g, a, b, c, d, ptr, 5, 0xd62f105d, 5)  ;
+		@step(@g, d, a, b, c, ptr, 10, 0x02441453, 9) ;
+		@step(@g, c, d, a, b, ptr, 15, 0xd8a1e681, 14);
+		@step(@g, b, c, d, a, ptr, 4, 0xe7d3fbc8, 20) ;
+		@step(@g, a, b, c, d, ptr, 9, 0x21e1cde6, 5)  ;
+		@step(@g, d, a, b, c, ptr, 14, 0xc33707d6, 9) ;
+		@step(@g, c, d, a, b, ptr, 3, 0xf4d50d87, 14) ;
+		@step(@g, b, c, d, a, ptr, 8, 0x455a14ed, 20) ;
+		@step(@g, a, b, c, d, ptr, 13, 0xa9e3e905, 5) ;
+		@step(@g, d, a, b, c, ptr, 2, 0xfcefa3f8, 9)  ;
+		@step(@g, c, d, a, b, ptr, 7, 0x676f02d9, 14) ;
+		@step(@g, b, c, d, a, ptr, 12, 0x8d2a4c8a, 20);
+
+/* Round 3 */
+		@step(@h, a, b, c, d, ptr, 5, 0xfffa3942, 4);
+		@step(@h2, d, a, b, c, ptr, 8, 0x8771f681, 11);
+		@step(@h, c, d, a, b, ptr, 11, 0x6d9d6122, 16);
+		@step(@h2, b, c, d, a, ptr, 14, 0xfde5380c, 23);
+		@step(@h, a, b, c, d, ptr, 1, 0xa4beea44, 4);
+		@step(@h2, d, a, b, c, ptr, 4, 0x4bdecfa9, 11);
+		@step(@h, c, d, a, b, ptr, 7, 0xf6bb4b60, 16);
+		@step(@h2, b, c, d, a, ptr, 10, 0xbebfbc70, 23);
+		@step(@h, a, b, c, d, ptr, 13, 0x289b7ec6, 4)   ;
+		@step(@h2, d, a, b, c, ptr, 0, 0xeaa127fa, 11)  ;
+		@step(@h, c, d, a, b, ptr, 3, 0xd4ef3085, 16)   ;
+		@step(@h2, b, c, d, a, ptr, 6, 0x04881d05, 23)  ;
+		@step(@h, a, b, c, d, ptr, 9, 0xd9d4d039, 4)   ;
+		@step(@h2, d, a, b, c, ptr, 12, 0xe6db99e5, 11) ;
+		@step(@h, c, d, a, b, ptr, 15, 0x1fa27cf8, 16)  ;
+		@step(@h2, b, c, d, a, ptr, 2, 0xc4ac5665, 23)  ;
+
+/* Round 4 */
+		@step(@i, a, b, c, d, ptr, 0, 0xf4292244, 6)   ;
+		@step(@i, d, a, b, c, ptr, 7, 0x432aff97, 10)  ;
+		@step(@i, c, d, a, b, ptr, 14, 0xab9423a7, 15) ;
+		@step(@i, b, c, d, a, ptr, 5, 0xfc93a039, 21)  ;
+		@step(@i, a, b, c, d, ptr, 12, 0x655b59c3, 6)  ;
+		@step(@i, d, a, b, c, ptr, 3, 0x8f0ccc92, 10)  ;
+		@step(@i, c, d, a, b, ptr, 10, 0xffeff47d, 15) ;
+		@step(@i, b, c, d, a, ptr, 1, 0x85845dd1, 21)  ;
+		@step(@i, a, b, c, d, ptr, 8, 0x6fa87e4f, 6)   ;
+		@step(@i, d, a, b, c, ptr, 15, 0xfe2ce6e0, 10) ;
+		@step(@i, c, d, a, b, ptr, 6, 0xa3014314, 15)  ;
+		@step(@i, b, c, d, a, ptr, 13, 0x4e0811a1, 21) ;
+		@step(@i, a, b, c, d, ptr, 4, 0xf7537e82, 6)   ;
+		@step(@i, d, a, b, c, ptr, 11, 0xbd3af235, 10) ;
+		@step(@i, c, d, a, b, ptr, 2, 0x2ad7d2bb, 15)  ;
+		@step(@i, b, c, d, a, ptr, 9, 0xeb86d391, 21)  ;
+
+		a += saved_a;
+		b += saved_b;
+		c += saved_c;
+		d += saved_d;
+
+		ptr += 64;
+
+	} while (size -= 64);
+
+	ctx.a = a;
+	ctx.b = b;
+	ctx.c = c;
+	ctx.d = d;
+
+	return ptr;
+}
+
+
+

lib/std/hash/sha1.c3

@@ -5,13 +5,29 @@
 // Implementation was off Steve Reid's SHA-1 C implementation
 
 module std::hash::sha1;
+import std::hash::hmac;
 import std::bits;
 
+const BLOCK_BYTES = 64;
+const HASH_BYTES = 20;
+
 struct Sha1
 {
 	uint[5] state;
 	uint[2] count;
-	char[64] buffer;
+	char[BLOCK_BYTES] buffer;
+}
+
+def HmacSha1 = Hmac(<Sha1, HASH_BYTES, BLOCK_BYTES>);
+def hmac = hmac::hash(<Sha1, HASH_BYTES, BLOCK_BYTES>);
+def pbkdf2 = hmac::pbkdf2(<Sha1, HASH_BYTES, BLOCK_BYTES>);
+
+fn char[HASH_BYTES] hash(char[] data)
+{
+	Sha1 sha1 @noinit;
+	sha1.init();
+	sha1.update(data);
+	return sha1.final();
 }
 
 fn void Sha1.init(&self)
@@ -55,7 +71,7 @@ fn void Sha1.update(&self, char[] data)
 }
 
 
-fn char[20] Sha1.final(&self)
+fn char[HASH_BYTES] Sha1.final(&self)
 {
 	char[8] finalcount;
 	for (uint i = 0; i < 8; i++)
@@ -69,21 +85,21 @@ fn char[20] Sha1.final(&self)
 	}
 
 	self.update(&finalcount);
-	char[20] digest;
-	for (uint i = 0; i < 20; i++)
+	char[HASH_BYTES] digest;
+	for (uint i = 0; i < HASH_BYTES; i++)
 	{
 		digest[i] = (char)((self.state[i >> 2] >> ((3 - (i & 3)) * 8)) & 0xFF);
 	}
 
 	// Clear mem
-	mem::clear(self, Sha1.sizeof);
+	*self = {};
 	finalcount = {};
 	return digest;
 }
 
 union Long16 @local
 {
-	char[64] c;
+	char[BLOCK_BYTES] c;
 	uint[16] l;
 }
 

lib/std/hash/sha256.c3

@@ -0,0 +1,176 @@
+module std::hash::sha256;
+
+import std::hash::hmac;
+
+const BLOCK_SIZE = 64;
+const HASH_SIZE = 32;
+
+const uint[64] K @local = {
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+};
+
+// Right rotate function
+macro uint @rotr(uint x, uint n) @local => (((x) >> (n)) | ((x) << (32 - (n))));
+
+// SHA-256 functions
+macro uint @ch(uint x, uint y, uint z) @local => (x & y) ^ (~x & z);
+macro uint @maj(uint x, uint y, uint z) @local => (x & y) ^ (x & z) ^ (y & z);
+macro uint @_sigma0(uint x) @local => @rotr(x, 2) ^ @rotr(x, 13) ^ @rotr(x, 22);
+macro uint @_sigma1(uint x) @local => @rotr(x, 6) ^ @rotr(x, 11) ^ @rotr(x, 25);
+macro uint @sigma0(uint x) @local => @rotr(x, 7) ^ @rotr(x, 18) ^ (x >> 3);
+macro uint @sigma1(uint x) @local => @rotr(x, 17) ^ @rotr(x, 19) ^ (x >> 10);
+
+struct Sha256
+{
+    uint[8] state;
+    ulong bitcount;
+    char[BLOCK_SIZE] buffer;
+}
+
+def HmacSha256 = Hmac(<Sha256, HASH_SIZE, BLOCK_SIZE>);
+def hmac = hmac::hash(<Sha256, HASH_SIZE, BLOCK_SIZE>);
+def pbkdf2 = hmac::pbkdf2(<Sha256, HASH_SIZE, BLOCK_SIZE>);
+
+fn char[HASH_SIZE] hash(char[] data)
+{
+    Sha256 sha256 @noinit;
+    sha256.init();
+    sha256.update(data);
+    return sha256.final();
+}
+
+fn void Sha256.init(&self)
+{
+    // Sha256 initialization constants
+    *self = {
+        .state = {
+            0x6A09E667,
+            0xBB67AE85,
+            0x3C6EF372,
+            0xA54FF53A,
+            0x510E527F,
+            0x9B05688C,
+            0x1F83D9AB,
+            0x5BE0CD19
+        }
+    };
+}
+
+/**
+ * @param [in] data
+ * @require data.len <= uint.max
+ **/
+fn void Sha256.update(&self, char[] data) {
+    uint i = 0;
+    uint len = data.len;
+    uint buffer_pos = (uint)(self.bitcount / 8) % BLOCK_SIZE;
+    self.bitcount += (ulong)(len * 8);
+
+    while (len--) {
+        self.buffer[buffer_pos++] = data[i++];
+        if (buffer_pos == BLOCK_SIZE) {
+            sha256_transform(&self.state, &self.buffer);
+            buffer_pos = 0;  // Reset buffer position
+        }
+    }
+}
+
+fn char[HASH_SIZE] Sha256.final(&self) {
+    char[HASH_SIZE] hash;
+    ulong i = (self.bitcount / 8) % BLOCK_SIZE;
+
+    // Append 0x80 to the buffer
+    self.buffer[i++] = 0x80;
+
+    // Pad the buffer with zeros
+    if (i > BLOCK_SIZE - 8) {
+        while (i < BLOCK_SIZE) {
+            self.buffer[i++] = 0x00;
+        }
+        sha256_transform(&self.state, &self.buffer);
+        i = 0;  // Reset buffer index after transformation
+    }
+    
+    while (i < BLOCK_SIZE - 8) {
+        self.buffer[i++] = 0x00;
+    }
+
+    // Append the bitcount in big-endian format
+    for (int j = 0; j < 8; ++j) {
+        self.buffer[BLOCK_SIZE - 8 + j] = (char)((self.bitcount >> (56 - j * 8)) & 0xFF);
+    }
+
+    sha256_transform(&self.state, &self.buffer);
+
+    // Convert state to the final hash
+    for (i = 0; i < 8; ++i) {
+        hash[i * 4] = (char)((self.state[i] >> 24) & 0xFF);
+        hash[i * 4 + 1] = (char)((self.state[i] >> 16) & 0xFF);
+        hash[i * 4 + 2] = (char)((self.state[i] >> 8) & 0xFF);
+        hash[i * 4 + 3] = (char)(self.state[i] & 0xFF);
+    }
+    
+    return hash;
+}
+
+/**
+ * @param [&inout] state
+ * @param [&in] buffer
+ **/
+fn void sha256_transform(uint* state, char* buffer) @local {
+    uint a, b, c, d, e, f, g, h, t1, t2;
+    uint[64] m;
+    int i;
+
+    // Prepare the message schedule
+    for (i = 0; i < 16; ++i) {
+     m[i] = ((uint)buffer[i * 4] << 24) | ((uint)buffer[i * 4 + 1] << 16) |
+       ((uint)buffer[i * 4 + 2] << 8) | ((uint)buffer[i * 4 + 3]);  // Ensure values are cast to uint for correct shifts
+    }
+    for (i = 16; i < 64; ++i) {
+        m[i] = @sigma1(m[i - 2]) + m[i - 7] + @sigma0(m[i - 15]) + m[i - 16];
+    }
+
+    // Initialize working variables
+    a = state[0];
+    b = state[1];
+    c = state[2];
+    d = state[3];
+    e = state[4];
+    f = state[5];
+    g = state[6];
+    h = state[7];
+
+    // Perform the main SHA-256 compression function
+    for (i = 0; i < 64; ++i) {
+        t1 = h + @_sigma1(e) + @ch(e, f, g) + K[i] + m[i];
+        t2 = @_sigma0(a) + @maj(a, b, c);
+        h = g;
+        g = f;
+        f = e;
+        e = d + t1;
+        d = c;
+        c = b;
+        b = a;
+        a = t1 + t2;
+    }
+
+    // Update the state
+    state[0] += a;
+    state[1] += b;
+    state[2] += c;
+    state[3] += d;
+    state[4] += e;
+    state[5] += f;
+    state[6] += g;
+    state[7] += h;
+    a = b = c = d = e = f = g = h = t1 = t2 = i = 0;
+    m[:64] = buffer[:64] = 0;
+}

lib/std/io/file.c3

@@ -76,7 +76,7 @@ fn void! File.memopen(File* file, char[] data, String mode)
  */
 fn void! File.write_byte(&self, char c) @dynamic
 {
-	if (!libc::fputc(c, self.file)) return IoError.EOF?;
+	return os::native_fputc(c, self.file);
 }
 
 /**

lib/std/io/formatter.c3

@@ -6,7 +6,8 @@ const int PRINTF_NTOA_BUFFER_SIZE = 256;
 
 interface Printable
 {
-	fn String to_new_string(Allocator allocator) @optional;
+	fn String to_string(Allocator allocator) @optional;
+	fn String to_new_string(Allocator allocator) @optional @deprecated("Use to_string");
 	fn usz! to_format(Formatter* formatter) @optional;
 }
 
@@ -14,24 +15,14 @@ fault PrintFault
 {
 	BUFFER_EXCEEDED,
 	INTERNAL_BUFFER_EXCEEDED,
-	INVALID_FORMAT_STRING,
-	MISSING_ARG,
-	INVALID_ARGUMENT_TYPE,
-}
-
-fault FormattingFault
-{
-	UNTERMINATED_FORMAT,
-	MISSING_ARG,
-	INVALID_WIDTH_ARG,
-	INVALID_FORMAT_TYPE,
+	INVALID_FORMAT,
+	NOT_ENOUGH_ARGUMENTS,
+	INVALID_ARGUMENT,
 }
 
 def OutputFn = fn void!(void* buffer, char c);
 def FloatType = double;
 
-
-
 fn usz! Formatter.printf(&self, String format, args...)
 {
 	return self.vprintf(format, args) @inline;
@@ -47,6 +38,7 @@ struct Formatter
 		uint width;
 		uint prec;
 		usz idx;
+		anyfault first_fault;
 	}
 }
 
@@ -68,7 +60,12 @@ fn void Formatter.init(&self, OutputFn out_fn, void* data = null)
 
 fn usz! Formatter.out(&self, char c) @private
 {
-	self.out_fn(self.data, c)!;
+	if (catch err = self.out_fn(self.data, c))
+	{
+		if (self.first_fault) return self.first_fault?;
+		self.first_fault = err;
+		return err?;
+	}
 	return 1;
 }
 
@@ -85,9 +82,10 @@ fn usz! Formatter.print_with_function(&self, Printable arg)
 			self.width = old_width;
 			self.prec = old_prec;
 		}
+		if (!arg) return self.out_substr("(null)");
 		return arg.to_format(self);
 	}
-	if (&arg.to_new_string)
+	if (&arg.to_string)
 	{
 		PrintFlags old = self.flags;
 		uint old_width = self.width;
@@ -98,9 +96,10 @@ fn usz! Formatter.print_with_function(&self, Printable arg)
 			self.width = old_width;
 			self.prec = old_prec;
 		}
+		if (!arg) return self.out_substr("(null)");
 		@stack_mem(1024; Allocator mem)
 		{
-			return self.out_substr(arg.to_new_string(mem));
+			return self.out_substr(arg.to_string(mem));
 		};
 	}
 	return SearchResult.MISSING?;
@@ -118,6 +117,7 @@ fn usz! Formatter.out_str(&self, any arg) @private
 		case ANYFAULT:
 		case FAULT:
 			return self.out_substr((*(anyfault*)arg.ptr).nameof);
+		case INTERFACE:
 		case ANY:
 			return self.out_str(*(any*)arg);
 		case OPTIONAL:
@@ -133,7 +133,7 @@ fn usz! Formatter.out_str(&self, any arg) @private
 			}
 			self.flags = {};
 			self.width = 0;
-			return self.ntoa_any(arg, 10);
+			return self.ntoa_any(arg, 10) ?? self.out_substr("<INVALID>");
 		case FLOAT:
 			PrintFlags flags = self.flags;
 			uint width = self.width;
@@ -144,23 +144,14 @@ fn usz! Formatter.out_str(&self, any arg) @private
 			}
 			self.flags = {};
 			self.width = 0;
-			return self.ftoa(float_from_any(arg)!!);
+			return self.ftoa(float_from_any(arg)) ?? self.out_substr("ERR");
 		case BOOL:
 			return self.out_substr(*(bool*)arg.ptr ? "true" : "false");
 		default:
 	}
 	usz! n = self.print_with_function((Printable)arg);
-	if (catch err = n)
-	{
-		case SearchResult.MISSING:
-			break;
-		default:
-			return err?;
-	}
-	else
-	{
-		return n;
-	}
+	if (try n) return n;
+	if (@catch(n) != SearchResult.MISSING) n!;
 	switch (arg.type.kindof)
 	{
 		case ENUM:
@@ -168,6 +159,12 @@ fn usz! Formatter.out_str(&self, any arg) @private
 			assert(i < arg.type.names.len, "Illegal enum value found, numerical value was %d.", i);
 			return self.out_substr(arg.type.names[i]);
 		case STRUCT:
+			if (arg.type == ReflectedParam.typeid)
+			{
+				ReflectedParam* param = arg.ptr;
+				return self.out_substr("[Parameter '")
+					+  self.out_substr(param.name) + self.out_substr("']");
+			}
 			return self.out_substr("<struct>");
 		case UNION:
 			return self.out_substr("<union>");
@@ -186,9 +183,14 @@ fn usz! Formatter.out_str(&self, any arg) @private
 			}
 			return self.out_str(arg.as_inner());
 		case POINTER:
-			if (*(void**)arg == null)
+			typeid inner = arg.type.inner;
+			void** pointer = arg.ptr;
+			if (arg.type.inner != void.typeid)
 			{
-				return self.out_substr("(null)");
+				any deref = any_make(*pointer, inner);
+				n = self.print_with_function((Printable)deref);
+				if (try n) return n;
+				if (@catch(n) != SearchResult.MISSING) n!;
 			}
 			PrintFlags flags = self.flags;
 			uint width = self.width;
@@ -197,8 +199,8 @@ fn usz! Formatter.out_str(&self, any arg) @private
 				self.flags = flags;
 				self.width = width;
 			}
-			self.flags = {};
 			self.width = 0;
+			self.out_substr("0x")!;
 			return self.ntoa_any(arg, 16);
 		case ARRAY:
 			// this is SomeType[*] so grab the "SomeType"
@@ -281,6 +283,9 @@ fn usz! Formatter.out_str(&self, any arg) @private
 			}
 			len += self.out(']')!;
 			return len;
+		case ANY:
+		case INTERFACE:
+			unreachable("Already handled");
 		default:
 	}
 	return self.out_substr("Invalid type");
@@ -293,10 +298,31 @@ fn void! out_null_fn(void* data @unused, char c @unused) @private
 {
 }
 
+macro usz! @report_fault(Formatter* f, $fault)
+{
+	(void)f.out_substr($fault);
+	return PrintFault.INVALID_FORMAT?;
+}
 
+macro usz! @wrap_bad(Formatter* f, #action)
+{
+	usz! len = #action;
+	if (catch err = len)
+	{
+		case PrintFault.BUFFER_EXCEEDED:
+        case PrintFault.INTERNAL_BUFFER_EXCEEDED:
+            return f.first_err(err)?;
+        default:
+            err = f.first_err(PrintFault.INVALID_ARGUMENT);
+            f.out_substr("<INVALID>")!;
+            return err?;
+	}
+	return len;
+}
 
 fn usz! Formatter.vprintf(&self, String format, any[] anys)
 {
+	self.first_fault = {};
 	if (!self.out_fn)
 	{
 		// use null output function
@@ -316,7 +342,7 @@ fn usz! Formatter.vprintf(&self, String format, any[] anys)
 			continue;
 		}
 		i++;
-		if (i >= format_len) return PrintFault.INVALID_FORMAT_STRING?;
+		if (i >= format_len) return @report_fault(self, "%ERR");
 		c = format[i];
 		if (c == '%')
 		{
@@ -336,11 +362,12 @@ fn usz! Formatter.vprintf(&self, String format, any[] anys)
 				case '#': self.flags.hash = true;
 				default: break FLAG_EVAL;
 			}
-			if (++i >= format_len) return PrintFault.INVALID_FORMAT_STRING?;
+			if (++i >= format_len) return @report_fault(self, "%ERR");
 			c = format[i];
 		}
 		// evaluate width field
-		int w = printf_parse_format_field(anys.ptr, anys.len, &variant_index, format.ptr, format.len, &i)!;
+		int! w = printf_parse_format_field(anys.ptr, anys.len, &variant_index, format.ptr, format.len, &i);
+		if (catch w) return @report_fault(self, "%ERR");
 		c = format[i];
 		if (w < 0)
 		{
@@ -353,15 +380,21 @@ fn usz! Formatter.vprintf(&self, String format, any[] anys)
 		if (c == '.')
 		{
 			self.flags.precision = true;
-			if (++i >= format_len) return PrintFault.INVALID_FORMAT_STRING?;
-			int prec = printf_parse_format_field(anys.ptr, anys.len, &variant_index, format.ptr, format.len, &i)!;
+			if (++i >= format_len) return @report_fault(self, "<BAD FORMAT>");
+			int! prec = printf_parse_format_field(anys.ptr, anys.len, &variant_index, format.ptr, format.len, &i);
+			if (catch prec) return @report_fault(self, "<BAD FORMAT>");
 			self.prec = prec < 0 ? 0 : prec;
 			c = format[i];
 		}
 
 		// evaluate specifier
 		uint base = 0;
-		if (variant_index >= anys.len) return PrintFault.MISSING_ARG?;
+		if (variant_index >= anys.len)
+		{
+			self.first_err(PrintFault.NOT_ENOUGH_ARGUMENTS);
+			total_len += self.out_substr("<MISSING>")!;
+			continue;
+		}
 		any current = anys[variant_index++];
 		switch (c)
 		{
@@ -387,25 +420,25 @@ fn usz! Formatter.vprintf(&self, String format, any[] anys)
 				self.flags.uppercase = true;
 				nextcase;
 			case 'a':
-				total_len += self.atoa(float_from_any(current)!!)!;
+				total_len += @wrap_bad(self, self.atoa(float_from_any(current)))!;
 				continue;
 			case 'F' :
 				self.flags.uppercase = true;
 				nextcase;
 			case 'f':
-				total_len += self.ftoa(float_from_any(current)!!)!;
+				total_len += @wrap_bad(self, self.ftoa(float_from_any(current)))!;
 				continue;
 			case 'E':
 				self.flags.uppercase = true;
 				nextcase;
 			case 'e':
-				total_len += self.etoa(float_from_any(current)!!)!;
+				total_len += @wrap_bad(self, self.etoa(float_from_any(current)))!;
 				continue;
 			case 'G':
 				self.flags.uppercase = true;
 				nextcase;
 			case 'g':
-				total_len += self.gtoa(float_from_any(current)!!)!;
+				total_len += @wrap_bad(self, self.gtoa(float_from_any(current)))!;
 				continue;
 			case 'c':
 				total_len += self.out_char(current)!;
@@ -430,7 +463,9 @@ fn usz! Formatter.vprintf(&self, String format, any[] anys)
 				self.flags.hash = true;
 				base = 16;
 			default:
-				return PrintFault.INVALID_FORMAT_STRING?;
+				self.first_err(PrintFault.INVALID_FORMAT);
+				total_len += self.out_substr("<BAD FORMAT>")!;
+				continue;
 		}
 		if (base != 10)
 		{
@@ -441,14 +476,13 @@ fn usz! Formatter.vprintf(&self, String format, any[] anys)
 		if (self.flags.precision) self.flags.zeropad = false;
 
 		bool is_neg;
-		uint128 v = int_from_any(current, &is_neg)!!;
-
-		total_len += self.ntoa(v, is_neg, base)!;
+		total_len += @wrap_bad(self, self.ntoa(int_from_any(current, &is_neg), is_neg, base))!;
 	}
 	// termination
 	//	out((char)0, buffer, idx < maxlen ? idx : maxlen - 1U, maxlen);
 
 	// return written chars without terminating \0
+	if (self.first_fault) return self.first_fault?;
 	return total_len;
 }
 

lib/std/io/formatter_private.c3

@@ -4,6 +4,18 @@ import std::math;
 const char[16] XDIGITS_H = "0123456789ABCDEF";
 const char[16] XDIGITS_L = "0123456789abcdef";
 
+fault FormattingFault
+{
+	BAD_FORMAT
+}
+
+macro Formatter.first_err(&self, anyfault f)
+{
+	if (self.first_fault) return self.first_fault;
+	self.first_fault = f;
+	return f;
+}
+
 fn usz! Formatter.adjust(&self, usz len) @local
 {
 	if (!self.flags.left) return 0;
@@ -21,6 +33,7 @@ fn uint128! int_from_any(any arg, bool *is_neg) @private
 		case TypeKind.ENUM:
 			return int_from_any(arg.as_inner(), is_neg);
 		default:
+			break;
 	}
 	*is_neg = false;
 	switch (arg)
@@ -59,7 +72,7 @@ fn uint128! int_from_any(any arg, bool *is_neg) @private
 			double d = *arg;
 			return (uint128)((*is_neg = d < 0) ? -d : d);
 		default:
-			return PrintFault.INVALID_ARGUMENT_TYPE?;
+			return FormattingFault.BAD_FORMAT?;
 	}
 }
 
@@ -101,7 +114,7 @@ fn FloatType! float_from_any(any arg) @private
 		case double:
 			return (FloatType)*arg;
 		default:
-			return PrintFault.INVALID_ARGUMENT_TYPE?;
+			return FormattingFault.BAD_FORMAT?;
 	}
 }
 
@@ -588,8 +601,7 @@ fn usz! Formatter.ntoa_format(&self, String buf, usz len, bool negative, uint ba
 fn usz! Formatter.ntoa_any(&self, any arg, uint base) @private
 {
 	bool is_neg;
-	uint128 val = int_from_any(arg, &is_neg)!!;
-	return self.ntoa(val, is_neg, base) @inline;
+	return self.ntoa(int_from_any(arg, &is_neg)!!, is_neg, base) @inline;
 }
 
 fn usz! Formatter.out_char(&self, any arg) @private
@@ -628,29 +640,18 @@ fn usz! Formatter.out_reverse(&self, char[] buf) @private
 	usz buffer_start_idx = self.idx;
 	usz len = buf.len;
 	// pad spaces up to given width
-	if (!self.flags.zeropad)
+	if (!self.flags.zeropad && !self.flags.left)
 	{
-		n += self.adjust(len)!;
+    	n += self.pad(' ', self.width, len)!;
 	}
 	// reverse string
 	while (len) n += self.out(buf[--len])!;
 
 	// append pad spaces up to given width
-	n += self.adjust(self.idx - buffer_start_idx)!;
+	n += self.adjust(n)!;
 	return n;
 }
 
-fn void! printf_advance_format(usz format_len, usz *index_ptr) @inline @private
-{
-	usz val = ++(*index_ptr);
-	if (val >= format_len) return FormattingFault.UNTERMINATED_FORMAT?;
-}
-
-fn any! next_any(any* args_ptr, usz args_len, usz* arg_index_ptr) @inline @private
-{
-	if (*arg_index_ptr >= args_len) return FormattingFault.MISSING_ARG?;
-	return args_ptr[(*arg_index_ptr)++];
-}
 
 fn int! printf_parse_format_field(
 	any* args_ptr, usz args_len, usz* args_index_ptr,
@@ -659,9 +660,11 @@ fn int! printf_parse_format_field(
 	char c = format_ptr[*index_ptr];
 	if (c.is_digit()) return simple_atoi(format_ptr, format_len, index_ptr);
 	if (c != '*') return 0;
-	printf_advance_format(format_len, index_ptr)!;
-	any val = next_any(args_ptr, args_len, args_index_ptr)!;
-	if (!val.type.kindof.is_int()) return FormattingFault.INVALID_WIDTH_ARG?;
+	usz len = ++(*index_ptr);
+    if (len >= format_len) return FormattingFault.BAD_FORMAT?;
+	if (*args_index_ptr >= args_len) return FormattingFault.BAD_FORMAT?;
+	any val = args_ptr[(*args_index_ptr)++];
+	if (!val.type.kindof.is_int()) return FormattingFault.BAD_FORMAT?;
 	uint! intval = types::any_to_int(val, int);
-	return intval ?? FormattingFault.INVALID_WIDTH_ARG?;
+	return intval ?? FormattingFault.BAD_FORMAT?;
 }

lib/std/io/io.c3

@@ -256,7 +256,7 @@ fn usz! printfn(String format, args...) @maydiscard
 {
 	Formatter formatter;
 	formatter.init(&out_putchar_fn);
-	usz len = formatter.vprintf(format, args)!;
+	usz! len = formatter.vprintf(format, args);
 	putchar('\n');
 	io::stdout().flush()!;
 	return len + 1;
@@ -290,10 +290,10 @@ fn usz! eprintfn(String format, args...) @maydiscard
 	Formatter formatter;
 	OutStream stream = stderr();
 	formatter.init(&out_putstream_fn, &stream);
-	usz len = formatter.vprintf(format, args)! + 1;
+	usz! len = formatter.vprintf(format, args);
 	stderr().write_byte('\n')!;
 	stderr().flush()!;
-	return len;
+	return len + 1;
 }
 
 /**
@@ -401,3 +401,11 @@ fn File* stdin()
 {
 	return &stdin_file;
 }
+
+/**
+ * Wrap bytes for reading using io functions.
+ **/
+fn ByteReader wrap_bytes(char[] bytes)
+{
+	return { bytes, 0 };
+}

lib/std/io/os/file_libc.c3

@@ -75,6 +75,11 @@ fn usz! native_fwrite(CFile file, char[] buffer) @inline
 	return libc::fwrite(buffer.ptr, 1, buffer.len, file);
 }
 
+fn void! native_fputc(CInt c, CFile stream) @inline
+{
+	if (!libc::fputc(c, stream)) return IoError.EOF?;
+}
+
 fn usz! native_fread(CFile file, char[] buffer) @inline
 {
 	return libc::fread(buffer.ptr, 1, buffer.len, file);

lib/std/io/os/file_nolibc.c3

@@ -9,6 +9,7 @@ def FtellFn = fn usz!(void*);
 def FwriteFn = fn usz!(void*, char[] buffer);
 def FreadFn = fn usz!(void*, char[] buffer);
 def RemoveFn = fn void!(String);
+def FputcFn = fn void!(int, void*);
 
 FopenFn native_fopen_fn @weak @if(!$defined(native_fopen_fn));
 FcloseFn native_fclose_fn @weak @if(!$defined(native_fclose_fn));
@@ -18,6 +19,7 @@ FtellFn native_ftell_fn @weak @if(!$defined(native_ftell_fn));
 FwriteFn native_fwrite_fn @weak @if(!$defined(native_fwrite_fn));
 FreadFn native_fread_fn @weak @if(!$defined(native_fread_fn));
 RemoveFn native_remove_fn @weak @if(!$defined(native_remove_fn));
+FputcFn native_fputc_fn @weak @if(!$defined(native_fputc_fn));
 
 /**
  * @require mode.len > 0
@@ -73,3 +75,9 @@ fn usz! native_fread(CFile file, char[] buffer) @inline
 	if (native_fread_fn) return native_fread_fn(file, buffer);
 	return IoError.UNSUPPORTED_OPERATION?;
 }
+
+fn void! native_fputc(CInt c, CFile stream) @inline
+{
+	if (native_fputc_fn) return native_fputc_fn(c, stream);
+	return IoError.UNSUPPORTED_OPERATION?;
+}

lib/std/io/os/fileinfo.c3

@@ -1,11 +1,11 @@
 module std::io::os;
 import libc, std::os, std::io;
 
-fn void! native_stat(Stat* stat, String path) @if(env::DARWIN || env::LINUX)
+fn void! native_stat(Stat* stat, String path) @if(env::DARWIN || env::LINUX || env::BSD_FAMILY)
 {
 	@pool()
 	{
-		$if env::DARWIN || env::LINUX:
+		$if env::DARWIN || env::LINUX || env::BSD_FAMILY:
 			int res = libc::stat(path.zstr_tcopy(), stat);
 		$else
 			unreachable("Stat unimplemented");
@@ -71,6 +71,9 @@ fn bool native_file_or_dir_exists(String path)
 {
 	$switch
 		$case env::DARWIN:
+		$case env::FREEBSD:
+		$case env::NETBSD:
+		$case env::OPENBSD:
 		$case env::LINUX:
 			Stat stat;
 			return @ok(native_stat(&stat, path));
@@ -93,6 +96,9 @@ fn bool native_is_file(String path)
 {
 	$switch
 		$case env::DARWIN:
+		$case env::FREEBSD:
+		$case env::NETBSD:
+		$case env::OPENBSD:
 		$case env::LINUX:
 			Stat stat;
 			return @ok(native_stat(&stat, path)) && libc_S_ISTYPE(stat.st_mode, libc::S_IFREG);
@@ -105,7 +111,7 @@ fn bool native_is_file(String path)
 
 fn bool native_is_dir(String path)
 {
-	$if env::DARWIN || env::LINUX:
+	$if env::DARWIN || env::LINUX || env::BSD_FAMILY:
 		Stat stat;
 		return @ok(native_stat(&stat, path)) && libc_S_ISTYPE(stat.st_mode, libc::S_IFDIR);
 	$else

lib/std/io/os/ls.c3

@@ -4,7 +4,7 @@ import std::io, std::os;
 fn PathList! native_ls(Path dir, bool no_dirs, bool no_symlinks, String mask, Allocator allocator)
 {
 	PathList list;
-	list.new_init(.allocator = allocator);
+	list.new_init(allocator: allocator);
 	DIRPtr directory = posix::opendir(dir.str_view() ? dir.as_zstr() : (ZString)".");
 	defer if (directory) posix::closedir(directory);
 	if (!directory) return (path::is_dir(dir) ? IoError.CANNOT_READ_DIR : IoError.FILE_NOT_DIR)?;
@@ -27,7 +27,7 @@ import std::time, std::os, std::io;
 fn PathList! native_ls(Path dir, bool no_dirs, bool no_symlinks, String mask, Allocator allocator)
 {
 	PathList list;
-	list.new_init(.allocator = allocator);
+	list.new_init(allocator: allocator);
 
 	@pool(allocator)
 	{

lib/std/io/os/rmtree.c3

@@ -16,7 +16,7 @@ fn void! native_rmtree(Path dir)
 		{
 			String name = ((ZString)&entry.name).str_view();
 			if (!name || name == "." || name == "..") continue;
-			Path new_path = dir.tappend(name)!;
+			Path new_path = dir.temp_append(name)!;
 			if (entry.d_type == posix::DT_DIR)
 			{
 				native_rmtree(new_path)!;
@@ -49,7 +49,7 @@ fn void! native_rmtree(Path path)
 		{
 			String filename = string::new_from_wstring((WString)&find_data.cFileName, allocator::temp())!;
 			if (filename == "." || filename == "..") continue;
-			Path file_path = path.tappend(filename)!;
+			Path file_path = path.temp_append(filename)!;
 			if (find_data.dwFileAttributes & win32::FILE_ATTRIBUTE_DIRECTORY)
 			{
 				native_rmtree(file_path)!;

lib/std/io/path.c3

@@ -15,7 +15,9 @@ fault PathResult
 	NO_PARENT,
 }
 
-struct Path (Printable)
+def Path = PathImp;
+
+struct PathImp (Printable)
 {
 	String path_string;
 	PathEnv env;
@@ -27,7 +29,15 @@ enum PathEnv
 	POSIX
 }
 
-fn Path! getcwd(Allocator allocator = allocator::heap())
+fn Path! new_cwd(Allocator allocator = allocator::heap())
+{
+	@pool(allocator)
+	{
+		return new(os::getcwd(allocator::temp()), allocator);
+	};
+}
+
+fn Path! getcwd(Allocator allocator = allocator::heap()) @deprecated("Use new_cwd()")
 {
 	@pool(allocator)
 	{
@@ -39,7 +49,8 @@ fn bool is_dir(Path path) => os::native_is_dir(path.str_view());
 fn bool is_file(Path path) => os::native_is_file(path.str_view());
 fn usz! file_size(Path path) => os::native_file_size(path.str_view());
 fn bool exists(Path path) => os::native_file_or_dir_exists(path.str_view());
-fn Path! tgetcwd() => getcwd(allocator::temp()) @inline;
+fn Path! temp_cwd() => new_cwd(allocator::temp()) @inline;
+fn Path! tgetcwd() @deprecated("Use temp_cwd()") => new_cwd(allocator::temp()) @inline;
 fn void! chdir(Path path) => os::native_chdir(path) @inline;
 fn Path! temp_directory(Allocator allocator = allocator::heap()) => os::native_temp_directory(allocator);
 fn void! delete(Path path) => os::native_remove(path.str_view()) @inline;
@@ -59,7 +70,17 @@ macro bool is_win32_separator(char c)
 	return c == '/' || c == '\\';
 }
 
-fn PathList! ls(Path dir, bool no_dirs = false, bool no_symlinks = false, String mask = "", Allocator allocator = allocator::heap())
+fn PathList! ls(Path dir, bool no_dirs = false, bool no_symlinks = false, String mask = "", Allocator allocator = allocator::heap()) @deprecated("use new_ls")
+{
+	return new_ls(dir, no_dirs, no_symlinks, mask, allocator);
+
+}
+fn PathList! temp_ls(Path dir, bool no_dirs = false, bool no_symlinks = false, String mask = "")
+{
+	return new_ls(dir, no_dirs, no_symlinks, mask, allocator::temp()) @inline;
+}
+
+fn PathList! new_ls(Path dir, bool no_dirs = false, bool no_symlinks = false, String mask = "", Allocator allocator = allocator::heap())
 {
 	$if $defined(os::native_ls):
 		return os::native_ls(dir, no_dirs, no_symlinks, mask, allocator);
@@ -120,7 +141,7 @@ fn Path! new_win32_wstring(WString path, Allocator allocator = allocator::heap()
 {
 	@pool(allocator)
 	{
-		return path::new(string::temp_from_wstring(path)!, .allocator = allocator);
+		return path::new(string::temp_from_wstring(path)!, allocator: allocator);
 	};
 }
 
@@ -139,12 +160,17 @@ fn bool Path.equals(self, Path p2)
 	return self.env == p2.env && self.path_string == p2.path_string;
 }
 
+fn Path! Path.append(self, String filename, Allocator allocator = allocator::heap()) @deprecated("Use path.new_append(...)")
+{
+	return self.new_append(filename, allocator) @inline;
+}
+
 /**
  * Append the string to the current path.
  *
  * @param [in] filename
  **/
-fn Path! Path.append(self, String filename, Allocator allocator = allocator::heap())
+fn Path! Path.new_append(self, String filename, Allocator allocator = allocator::heap())
 {
 	if (!self.path_string.len) return new(filename, allocator, self.env)!;
 	assert(!is_separator(self.path_string[^1], self.env));
@@ -159,7 +185,9 @@ fn Path! Path.append(self, String filename, Allocator allocator = allocator::hea
 	};
 }
 
-fn Path! Path.tappend(self, String filename) => self.append(filename, allocator::temp());
+fn Path! Path.temp_append(self, String filename) => self.new_append(filename, allocator::temp());
+
+fn Path! Path.tappend(self, String filename) @deprecated("Use path.temp_append(...)") => self.new_append(filename, allocator::temp());
 
 fn usz Path.start_of_base_name(self) @local
 {
@@ -193,10 +221,15 @@ fn bool! Path.is_absolute(self)
 	return path_start < path_str.len && is_separator(path_str[path_start], self.env);
 }
 
+fn Path! Path.absolute(self, Allocator allocator = allocator::heap()) @deprecated("Use path.new_absolute()")
+{
+	return self.new_absolute(allocator) @inline;
+}
+
 /**
  * @require self.env == DEFAULT_PATH_ENV : "This method is only available on native paths"
  **/
-fn Path! Path.absolute(self, Allocator allocator = allocator::heap())
+fn Path! Path.new_absolute(self, Allocator allocator = allocator::heap())
 {
 	String path_str = self.str_view();
 	if (!path_str.len) return PathResult.INVALID_PATH?;
@@ -220,7 +253,7 @@ fn Path! Path.absolute(self, Allocator allocator = allocator::heap())
 		};
 	$else
 		String cwd = os::getcwd(allocator::temp())!;
-		return Path { cwd, self.env }.append(path_str, allocator)!;
+		return Path { cwd, self.env }.new_append(path_str, allocator)!;
 	$endif
 }
 
@@ -250,6 +283,22 @@ fn String Path.dirname(self)
 	return path_str[:basename_start - 1];
 }
 
+/**
+ * Test if the path has the given extension, so given the path /foo/bar.c3
+ * this would be true matching the extension "c3"
+ *
+ * @param [in] extension `The extension name (not including the leading '.')`
+ * @require extension.len > 0 : `The extension cannot be empty`
+ * @return `true if the extension matches`
+ **/
+fn bool Path.has_extension(self, String extension)
+{
+	String basename = self.basename();
+	if (basename.len <= extension.len) return false;
+	if (basename[^extension.len + 1] != '.') return false;
+	return basename[^extension.len..] == extension;
+}
+
 fn String! Path.extension(self)
 {
 	String basename = self.basename();
@@ -470,12 +519,12 @@ fn bool! Path.walk(self, PathWalker w, void* data)
 	const PATH_MAX = 512;
 	@stack_mem(PATH_MAX; Allocator allocator)
 	{
-		Path abs = self.absolute(allocator)!;
-		PathList files = ls(abs, .allocator = allocator)!;
+		Path abs = self.new_absolute(allocator)!;
+		PathList files = new_ls(abs, allocator: allocator)!;
 		foreach (f : files)
 		{
 			if (f.str_view() == "." || f.str_view() == "..") continue;
-			f = abs.append(f.str_view(), allocator)!;
+			f = abs.new_append(f.str_view(), allocator)!;
 			bool is_directory = is_dir(f);
 			if (w(f, is_directory, data)!) return true;
 			if (is_directory && f.walk(w, data)!) return true;

lib/std/io/stream.c3

@@ -77,6 +77,22 @@ macro usz! read_all(stream, char[] buffer)
 	return n;
 }
 
+/**
+ * @require @is_instream(stream)
+ */
+macro char[]! read_new_fully(stream, Allocator allocator = allocator::heap())
+{
+	usz len = available(stream)!;
+	char* data = allocator::malloc_try(allocator, len)!;
+	defer catch allocator::free(allocator, data);
+	usz read = 0;
+	while (read < len)
+	{
+		read += stream.read(data[read:len - read])!;
+	}
+	return data[:len];
+}
+
 /**
  * @require @is_outstream(stream)
  */
@@ -141,15 +157,9 @@ fn usz! copy_to(InStream in, OutStream dst, char[] buffer = {})
 	if (&dst.read_to) return dst.read_to(in);
 	$switch (env::MEMORY_ENV)
 		$case NORMAL:
-			@pool()
-			{
-				return copy_through_buffer(in, dst, mem::temp_alloc_array(char, 4096));
-			};
+			return copy_through_buffer(in, dst, &&char[4096]{});
 		$case SMALL:
-			@pool()
-			{
-				return copy_through_buffer(in, dst, mem::temp_alloc_array(char, 1024));
-			};
+			return copy_through_buffer(in, dst, &&char[1024]{});
 		$case TINY:
 		$case NONE:
 			return copy_through_buffer(in, dst, &&(char[256]{}));

lib/std/io/stream/bytebuffer.c3

@@ -131,7 +131,7 @@ fn usz! ByteBuffer.available(&self) @inline @dynamic
 fn void! ByteBuffer.grow(&self, usz n)
 {
 	n = math::next_power_of_2(n);
-	char* p = allocator::realloc_aligned(self.allocator, self.bytes, n, .alignment = char.alignof)!;
+	char* p = allocator::realloc_aligned(self.allocator, self.bytes, n, alignment: char.alignof)!;
 	self.bytes = p[:n];
 }
 

lib/std/io/stream/bytewriter.c3

@@ -11,7 +11,7 @@ struct ByteWriter (OutStream)
 /**
  * @param [&inout] self
  * @param [&inout] allocator
- * @require self.bytes.len == 0 "Init may not run on on already initialized data"
+ * @require self.bytes.len == 0 "Init may not run on already initialized data"
  * @ensure (bool)allocator, self.index == 0
  **/
 fn ByteWriter* ByteWriter.new_init(&self, Allocator allocator = allocator::heap())
@@ -22,7 +22,7 @@ fn ByteWriter* ByteWriter.new_init(&self, Allocator allocator = allocator::heap(
 
 /**
  * @param [&inout] self
- * @require self.bytes.len == 0 "Init may not run on on already initialized data"
+ * @require self.bytes.len == 0 "Init may not run on already initialized data"
  * @ensure self.index == 0
  **/
 fn ByteWriter* ByteWriter.temp_init(&self)

lib/std/libc/libc.c3

@@ -3,7 +3,6 @@
 // a copy of which can be found in the LICENSE_STDLIB file.
 module libc;
 
-
 // Constants need to be per os/arch
 const int EXIT_FAILURE = 1;
 const int EXIT_SUCCESS = 0;
@@ -59,7 +58,7 @@ const CInt SIGTSTP = BSD_FLAVOR_SIG ? 18 : 20;
 const CInt SIGCONT = BSD_FLAVOR_SIG ? 19 : 18;
 const CInt SIGCHLD = BSD_FLAVOR_SIG ? 20 : 17;
 
-const bool BSD_FLAVOR_SIG @local = env::OPENBSD || env::DARWIN || env::FREEBSD || env::NETBSD;
+const bool BSD_FLAVOR_SIG @local = env::DARWIN || env::BSD_FAMILY;
 
 def Time_t = $typefrom(env::WIN32 ? long.typeid : CLong.typeid);
 def Off_t = $typefrom(env::WIN32 ? int.typeid : usz.typeid);
@@ -119,7 +118,7 @@ extern fn CLong labs(CLong x);
 extern fn LongDivResult ldiv(CLong number, CLong denom);
 extern fn Tm* localtime(Time_t* timer);
 extern fn Tm* localtime_r(Time_t* timer, Tm* result) @if(!env::WIN32);
-extern fn void longjmp(JmpBuf* buffer, CInt value);
+extern fn void longjmp(JmpBuf* buffer, CInt value) @if(!env::NETBSD && !env::OPENBSD);
 extern fn void* malloc(usz size);
 extern fn void* memchr(void* str, CInt c, usz n);
 extern fn CInt memcmp(void* buf1, void* buf2, usz count);
@@ -143,7 +142,7 @@ extern fn void rewind(CFile stream);
 extern fn CInt scanf(ZString format, ...);
 extern fn void setbuf(CFile stream, char* buffer);
 extern fn int setenv(ZString name, ZString value, CInt overwrite);
-extern fn CInt setjmp(JmpBuf* buffer) @if(!env::WIN32);
+extern fn CInt setjmp(JmpBuf* buffer) @if(!env::WIN32 && !env::NETBSD && !env::OPENBSD);
 extern fn void setvbuf(CFile stream, char* buf, CInt type, usz size);
 extern fn SignalFunction signal(CInt sig, SignalFunction function);
 extern fn CInt snprintf(char* buffer, usz size, ZString format, ...);
@@ -203,23 +202,39 @@ macro CFile stdin() => __stdin;
 macro CFile stdout() => __stdout;
 macro CFile stderr() => __stderr;
 
-module libc @if(env::DARWIN);
+module libc @if(env::NETBSD || env::OPENBSD);
+extern fn int fcntl(CInt socket, int cmd, ...);
+extern fn int _setjmp(void*);
+macro int setjmp(void* ptr) => _setjmp(ptr);
+extern fn int _longjmp(void*, int);
+macro usz longjmp(void* ptr, CInt i) => _longjmp(ptr, i);
+extern fn usz malloc_size(void* ptr);
+extern fn void* aligned_alloc(usz align, usz size);
+macro CFile stdin() { return fdopen(0, "r"); }
+macro CFile stdout() { return fdopen(1, "w"); }
+macro CFile stderr() { return fdopen(2, "w"); }
+
+module libc @if(env::DARWIN || env::FREEBSD);
 extern CFile __stdinp;
 extern CFile __stdoutp;
 extern CFile __stderrp;
-extern fn usz malloc_size(void* ptr);
+extern fn usz malloc_size(void* ptr) @if(!env::FREEBSD);
 extern fn void* aligned_alloc(usz align, usz size);
 macro CFile stdin() => __stdinp;
 macro CFile stdout() => __stdoutp;
 macro CFile stderr() => __stderrp;
 
+module libc @if(env::FREEBSD);
+extern fn usz malloc_usable_size(void* ptr);
+macro usz malloc_size(void* ptr) => malloc_usable_size(ptr);
+
 module libc @if(env::WIN32);
 macro usz malloc_size(void* ptr) => _msize(ptr);
 macro CFile stdin() => __acrt_iob_func(STDIN_FD);
 macro CFile stdout() => __acrt_iob_func(STDOUT_FD);
 macro CFile stderr() => __acrt_iob_func(STDERR_FD);
 
-module libc @if(env::LIBC && !env::WIN32 && !env::LINUX && !env::DARWIN);
+module libc @if(env::LIBC && !env::WIN32 && !env::LINUX && !env::DARWIN && !env::BSD_FAMILY);
 macro CFile stdin() { return (CFile*)(uptr)STDIN_FD; }
 macro CFile stdout() { return (CFile*)(uptr)STDOUT_FD; }
 macro CFile stderr() { return (CFile*)(uptr)STDERR_FD; }

lib/std/libc/os/freebsd.c3

@@ -0,0 +1,62 @@
+module libc @if(env::FREEBSD);
+
+// Checked for x86_64, this is notoriously incorrect when comparing with Rust code etc
+
+def Blksize_t = $typefrom(env::X86_64 ? long.typeid : CInt.typeid);
+def Nlink_t = $typefrom(env::X86_64 ? ulong.typeid : CUInt.typeid);
+def Blkcnt_t = long;
+def Ino_t = ulong;
+def Dev_t = ulong;
+def Mode_t = uint;
+def Ino64_t = ulong;
+def Blkcnt64_t = long;
+
+struct Stat @if(env::X86_64)
+{
+	Dev_t st_dev;
+	Ino_t st_ino;
+	Nlink_t st_nlink;
+	Mode_t st_mode;
+	Uid_t st_uid;
+	Gid_t st_gid;
+	CInt __pad0;
+	Dev_t st_rdev;
+	Off_t st_size;
+	Blksize_t st_blksize;
+	Blkcnt_t st_blocks;
+	Time_t st_atime;
+	long st_atime_nsec;
+	Time_t st_mtime;
+	long st_mtime_nsec;
+	Time_t st_ctime;
+	long st_ctime_nsec;
+	long[3] __unused;
+}
+
+struct Stat @if(!env::X86_64)
+{
+	Dev_t st_dev;
+	Ino_t st_ino;
+	Mode_t st_mode;
+	Nlink_t st_nlink;
+	Uid_t st_uid;
+	Gid_t st_gid;
+	Dev_t st_rdev;
+	CInt __pad1;
+	Off_t st_size;
+	Blksize_t st_blksize;
+	CInt __pad2;
+	Blkcnt_t st_blocks;
+	Time_t st_atime;
+	long st_atime_nsec;
+	Time_t st_mtime;
+	long st_mtime_nsec;
+	Time_t st_ctime;
+	long st_ctime_nsec;
+	CInt[2] __unused;
+}
+
+extern fn CInt stat(ZString path, Stat* stat);
+
+extern fn CInt get_nprocs();
+extern fn CInt get_nprocs_conf();

lib/std/libc/os/posix.c3

@@ -1,5 +1,7 @@
 module libc @if(env::POSIX);
 
+extern fn isz recv(Fd socket, void *buffer, usz length, CInt flags);
+extern fn isz send(Fd socket, void *buffer, usz length, CInt flags);
 
 extern fn void* dlopen(ZString path, int flags);
 extern fn CInt dlclose(void*);
@@ -30,9 +32,9 @@ struct Sigaction
     	SignalFunction      sa_handler;
     	SigActionFunction   sa_sigaction;
     }
-	CInt                    sa_flags @if(env::FREEBSD);
+	CInt                    sa_flags @if(env::BSD_FAMILY);
 	Sigset_t                sa_mask; // 128
-	CInt                    sa_flags @if(!env::FREEBSD);
+	CInt                    sa_flags @if(!env::BSD_FAMILY);
 	void*                   sa_restorer @if(env::LINUX);
 }
 
@@ -53,3 +55,139 @@ struct Stack_t
 
 extern fn CInt sigaltstack(Stack_t* ss, Stack_t* old_ss);
 extern fn CInt sigaction(CInt signum, Sigaction *action, Sigaction *oldaction);
+
+module libc::termios @if(env::LIBC &&& env::POSIX);
+
+distinct Cc = char;
+distinct Speed = CUInt;
+distinct Tcflags = CUInt;
+
+const Tcflags TCOOFF = 0;
+const Tcflags TCOON = 1;
+const Tcflags TCIOFF = 2;
+const Tcflags TCION = 3;
+const Tcflags TCIFLUSH = 0;
+const Tcflags TCOFLUSH = 1;
+const Tcflags TCIOFLUSH = 2;
+const Tcflags TCSANOW = 0;
+const Tcflags TCSADRAIN = 1;
+const Tcflags TCSAFLUSH = 2;
+const Speed B0 = 0000000;
+const Speed B50 = 0000001;
+const Speed B75 = 0000002;
+const Speed B110 = 0000003;
+const Speed B134 = 0000004;
+const Speed B150 = 0000005;
+const Speed B200 = 0000006;
+const Speed B300 = 0000007;
+const Speed B600 = 0000010;
+const Speed B1200 = 0000011;
+const Speed B1800 = 0000012;
+const Speed B2400 = 0000013;
+const Speed B4800 = 0000014;
+const Speed B9600 = 0000015;
+const Speed B19200 = 0000016;
+const Speed B38400 = 0000017;
+const Speed B57600 = 0010001;
+const Speed B115200 = 0010002;
+const Speed B230400 = 0010003;
+const Speed B460800 = 0010004;
+const Speed B500000 = 0010005;
+const Speed B576000 = 0010006;
+const Speed B921600 = 0010007;
+const Speed B1000000 = 0010010;
+const Speed B1152000 = 0010011;
+const Speed B1500000 = 0010012;
+const Speed B2000000 = 0010013;
+const Speed B2500000 = 0010014;
+const Speed B3000000 = 0010015;
+const Speed B3500000 = 0010016;
+const Speed B4000000 = 0010017;
+const Speed MAX_BAUD = B4000000;
+const CInt VINTR = 0;
+const CInt VQUIT = 1;
+const CInt VERASE = 2;
+const CInt VKILL = 3;
+const CInt VEOF = 4;
+const CInt VTIME = 5;
+const CInt VMIN = 6;
+const CInt VSWTC = 7;
+const CInt VSTART = 8;
+const CInt VSTOP = 9;
+const CInt VSUSP = 10;
+const CInt VEOL = 11;
+const CInt VREPRINT = 12;
+const CInt VDISCARD = 13;
+const CInt VWERASE = 14;
+const CInt VLNEXT = 15;
+const CInt VEOL2 = 16;
+const CInt ISIG = 0000001;
+const CInt ICANON = 0000002;
+const CInt ECHO = 0000010;
+const CInt ECHOE = 0000020;
+const CInt ECHOK = 0000040;
+const CInt ECHONL = 0000100;
+const CInt NOFLSH = 0000200;
+const CInt TOSTOP = 0000400;
+const CInt IEXTEN = 0100000;
+const CInt CSIZE = 0000060;
+const CInt CS5 = 0000000;
+const CInt CS6 = 0000020;
+const CInt CS7 = 0000040;
+const CInt CS8 = 0000060;
+const CInt CSTOPB = 0000100;
+const CInt CREAD = 0000200;
+const CInt PARENB = 0000400;
+const CInt PARODD = 0001000;
+const CInt HUPCL = 0002000;
+const CInt CLOCAL = 0004000;
+const CInt OPOST = 0000001;
+const CInt OLCUC = 0000002;
+const CInt ONLCR = 0000004;
+const CInt OCRNL = 0000010;
+const CInt ONOCR = 0000020;
+const CInt ONLRET = 0000040;
+const CInt OFILL = 0000100;
+const CInt OFDEL = 0000200;
+const CInt VTDLY = 0040000;
+const CInt VT0 = 0000000;
+const CInt VT1 = 0040000;
+const CInt IGNBRK = 0000001;
+const CInt BRKINT = 0000002;
+const CInt IGNPAR = 0000004;
+const CInt PARMRK = 0000010;
+const CInt INPCK = 0000020;
+const CInt ISTRIP = 0000040;
+const CInt INLCR = 0000100;
+const CInt IGNCR = 0000200;
+const CInt ICRNL = 0000400;
+const CInt IUCLC = 0001000;
+const CInt IXON = 0002000;
+const CInt IXANY = 0004000;
+const CInt IXOFF = 0010000;
+const CInt IMAXBEL = 0020000;
+const CInt IUTF8 = 0040000;
+
+extern fn CInt tcgetattr(Fd fd, Termios* self);
+extern fn CInt tcsetattr(Fd fd, CInt optional_actions, Termios* self);
+extern fn CInt tcsendbreak(Fd fd, CInt duration);
+extern fn CInt tcdrain(Fd fd);
+extern fn CInt tcflush(Fd fd, CInt queue_selector);
+extern fn CInt tcflow(Fd fd, CInt action);
+extern fn Speed cfgetospeed(Termios* self);
+extern fn Speed cfgetispeed(Termios* self);
+extern fn CInt cfsetospeed(Termios* self, Speed speed);
+extern fn CInt cfsetispeed(Termios* self, Speed speed);
+
+const CInt NCCS = 32;
+struct Termios {
+        Tcflags c_iflag;
+        Tcflags c_oflag;
+        Tcflags c_cflag;
+        Tcflags c_lflag;
+        Cc c_line;
+        Cc[NCCS] c_cc;
+        Speed c_ispeed;
+        Speed c_ospeed;
+} 
+

lib/std/libc/os/win32.c3

@@ -1,5 +1,5 @@
 module libc @if(env::WIN32);
-
+import std::os::win32;
 
 extern fn CFile __acrt_iob_func(CInt c);
 extern fn CInt _close(Fd fd); def close = _close;
@@ -15,11 +15,13 @@ extern fn Time_t _mkgmtime64(Tm* timeptr); def timegm = _mkgmtime64;
 extern fn Time_t _mktime64(Tm *timeptr); def mktime = _mktime64;
 extern fn usz _msize(void* ptr);
 extern fn CInt _read(Fd fd, void* buffer, CUInt buffer_size);
-extern fn CInt _setjmp(void* frameptr, JmpBuf* buffer) @if(env::WIN32);
+extern fn CInt _setjmp(JmpBuf* buffer, void* frameptr);
 extern fn CFile _wfopen(WString, WString);
 extern fn CFile _wfreopen(WString, WString, CFile);
 extern fn CInt _write(Fd fd, void* buffer, CUInt count);
 extern fn CInt _wremove(WString);
+extern fn int recv(Win32_SOCKET s, void* buf, int len, int flags);
+extern fn int send(Win32_SOCKET s, void* buf, int len, int flags);
 
 struct SystemInfo
 {
@@ -45,7 +47,7 @@ extern fn CInt get_system_info(SystemInfo*) @extern("GetSystemInfo");
 
 // Aliases to simplify libc use
 macro Tm* localtime_r(Time_t* timer, Tm* buf) => _localtime64_s(buf, timer);
-macro CInt setjmp(JmpBuf* buffer) => _setjmp($$frameaddress(0), buffer);
+macro CInt setjmp(JmpBuf* buffer) => _setjmp(buffer, null);
 macro Tm* gmtime_r(Time_t* timer, Tm* buf) => _gmtime64_s(buf, timer);
 macro isz read(Fd fd, void* buffer, usz buffer_size) => _read(fd, buffer, (CUInt)buffer_size);
 macro isz write(Fd fd, void* buffer, usz count) => _write(fd, buffer, (CUInt)count);

lib/std/libc/termios.c3

@@ -0,0 +1,122 @@
+module libc::termios @if(env::LIBC &&& env::POSIX);
+
+fn int sendBreak(Fd fd, int duration) => tcsendbreak(fd, duration);
+fn int drain(Fd fd) => tcdrain(fd);
+fn int flush(Fd fd, int queue_selector) => tcflush(fd, queue_selector);
+fn int flow(Fd fd, int action) => tcflow(fd, action);
+fn Speed Termios.getOSpeed(Termios* self) => cfgetospeed(self);
+fn Speed Termios.getISpeed(Termios* self) => cfgetispeed(self);
+fn int Termios.setOSpeed(Termios* self, Speed speed) => cfsetospeed(self, speed);
+fn int Termios.setISpeed(Termios* self, Speed speed) => cfsetispeed(self, speed);
+fn int Termios.getAttr(Termios* self, Fd fd) => tcgetattr(fd, self);
+fn int Termios.setAttr(Termios* self, Fd fd, int optional_actions) => tcsetattr(fd, optional_actions, self);
+
+module libc::termios @if(!env::LIBC ||| !env::POSIX);
+
+distinct Cc = char;
+distinct Speed = CUInt;
+distinct Tcflags = CUInt;
+struct Termios {
+        void* dummy;
+}
+
+fn CInt tcgetattr(Fd fd, Termios* self)
+{
+        unreachable("tcgetattr unavailable");
+}
+
+fn CInt tcsetattr(Fd fd, CInt optional_actions, Termios* self)
+{
+        unreachable("tcsetattr unavailable");
+}
+
+fn CInt tcsendbreak(Fd fd, CInt duration)
+{
+        unreachable("tcsendbreak unavailable");
+}
+
+fn CInt tcdrain(Fd fd)
+{
+        unreachable("tcdrain unavailable");
+}
+
+fn CInt tcflush(Fd fd, CInt queue_selector)
+{
+        unreachable("tcflush unavailable");
+}
+
+fn CInt tcflow(Fd fd, CInt action)
+{
+        unreachable("tcflow unavailable");
+}
+
+fn Speed cfgetospeed(Termios* self)
+{
+        unreachable("cfgetospeed unavailable");
+}
+
+fn Speed cfgetispeed(Termios* self)
+{
+        unreachable("cfgetispeed unavailable");
+}
+
+fn CInt cfsetospeed(Termios* self, Speed speed)
+{
+        unreachable("cfsetospeed unavailable");
+}
+
+fn CInt cfsetispeed(Termios* self, Speed speed)
+{
+        unreachable("cfsetispeed unavailable");
+}
+
+fn int sendBreak(Fd fd, int duration)
+{
+        unreachable("sendBreak unavailable");
+}
+
+fn int drain(Fd fd)
+{
+        unreachable("drain unavailable");
+}
+
+fn int flush(Fd fd, int queue_selector)
+{
+        unreachable("flush unavailable");
+}
+
+fn int flow(Fd fd, int action)
+{
+        unreachable("flow unavailable");
+}
+
+fn Speed Termios.getOSpeed(Termios* self)
+{
+        unreachable("Termios.getOSpeed unavailable");
+}
+
+fn Speed Termios.getISpeed(Termios* self)
+{
+        unreachable("Termios.getISpeed unavailable");
+}
+
+fn int Termios.setOSpeed(Termios* self, Speed speed)
+{
+        unreachable("Termios.setOSpeed unavailable");
+}
+
+fn int Termios.setISpeed(Termios* self, Speed speed)
+{
+        unreachable("Termios.setISpeed unavailable");
+}
+
+fn int Termios.getAttr(Termios* self, Fd fd)
+{
+        unreachable("Termios.getAttr unavailable");
+}
+
+fn int Termios.setAttr(Termios* self, Fd fd, int optional_actions)
+{
+        unreachable("Termios.setAttr unavailable");
+}
+

lib/std/math/math.c3

@@ -159,7 +159,7 @@ macro atan2(x, y)
 
 /**
  * @require values::@is_int(x) || values::@is_float(x) "Expected an integer or floating point value"
- * @require $and(@typekind(y) == ARRAY || @typekind(y) == VECTOR, y.len == 2)
+ * @require (@typekind(y) == ARRAY || @typekind(y) == VECTOR) &&& y.len == 2
  * @require $assignable(x, $typeof(y[0]))
  **/
 macro sincos(x, y)
@@ -365,7 +365,7 @@ macro max(x, y, ...)
 	$else
 		var m = $$max(x, y);
 		$for (var $i = 0; $i < $vacount; $i++)
-			m = $$max(m, $vaarg($i));
+			m = $$max(m, $vaarg[$i]);
 		$endfor
 		return m;
 	$endif
@@ -382,7 +382,7 @@ macro min(x, y, ...)
 	$else
 		var m = $$min(x, y);
 		$for (var $i = 0; $i < $vacount; $i++)
-			m = $$min(m, $vaarg($i));
+			m = $$min(m, $vaarg[$i]);
 		$endfor
 		return m;
 	$endif
@@ -1096,3 +1096,70 @@ macro overflow_mul_helper(x, y) @local
 	if ($$overflow_mul(x, y, &res)) return MathError.OVERFLOW?;
 	return res;
 }
+
+macro mul_div_helper(val, mul, div) @private
+{
+	var $Type = $typeof(val);
+	return ($Type)(($Type)mul * (val / ($Type)div) + ($Type)mul * (val % ($Type)div) / ($Type)div);
+}
+macro char char.muldiv(self, char mul, char div) => mul_div_helper(self, mul, div);
+macro ichar ichar.muldiv(self, ichar mul, ichar div) => mul_div_helper(self, mul, div);
+macro short short.muldiv(self, short mul, short div) => mul_div_helper(self, mul, div);
+macro ushort ushort.muldiv(self, ushort mul, ushort div) => mul_div_helper(self, mul, div);
+macro int int.muldiv(self, int mul, int div) => mul_div_helper(self, mul, div);
+macro uint uint.muldiv(self, uint mul, uint div) => mul_div_helper(self, mul, div);
+macro long long.muldiv(self, long mul, long div) => mul_div_helper(self, mul, div);
+macro ulong ulong.muldiv(self, ulong mul, ulong div) => mul_div_helper(self, mul, div);
+
+macro bool @is_same_vector_or_scalar(#vector_value, #vector_or_scalar) @private
+{
+	return (values::@is_vector(#vector_or_scalar) &&& values::@is_same_vector_type(#vector_value, #vector_or_scalar)) ||| values::@is_int(#vector_or_scalar);
+}
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro char[<*>] char[<*>].muldiv(self, mul, div)  => mul_div_helper(self, mul, div);
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro ichar[<*>] ichar[<*>].muldiv(self, mul, div)  => mul_div_helper(self, mul, div);
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro short[<*>] short[<*>].muldiv(self, mul, div) => mul_div_helper(self, mul, div);
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro ushort[<*>] ushort[<*>].muldiv(self, mul, div) => mul_div_helper(self, mul, div);
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro int[<*>] int[<*>].muldiv(self, mul, div) => mul_div_helper(self, mul, div);
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro uint[<*>] uint[<*>].muldiv(self, mul, div) => mul_div_helper(self, mul, div);
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro long[<*>] long[<*>].muldiv(self, mul, div) => mul_div_helper(self, mul, div);
+
+/**
+ * @require @is_same_vector_or_scalar(self, mul) `mul must be a vector of the same type as self, or be an integer scalar`
+ * @require @is_same_vector_or_scalar(self, div) `div must be a vector of the same type as self, or be an integer scalar`
+ */
+macro ulong[<*>] ulong[<*>].muldiv(self, mul, div) => mul_div_helper(self, mul, div);

lib/std/math/math_i128.c3

@@ -10,54 +10,186 @@ fn int128 __divti3(int128 a, int128 b) @extern("__divti3") @weak @nostrip
 	return __udivti3(unsigned_a, unsigned_b) @inline ^ sign_a + (-sign_a);
 }
 
+macro uint128 @__udivmodti4(uint128 a, uint128 b, bool $return_rem)
+{
+	Int128bits n = { .all = a };
+	Int128bits d = { .all = b };
+	Int128bits q @noinit;
+	Int128bits r @noinit;
+	uint sr;
+	if (n.high == 0)
+	{
+		if (d.high == 0)
+		{
+			$if $return_rem:
+				return n.low % d.low;
+			$else
+				return n.low / d.low;
+			$endif
+		}
+		$if $return_rem:
+			return n.low;
+		$else
+			return 0;
+		$endif
+	}
+	if (d.low == 0)
+	{
+		if (d.high == 0)
+		{
+			$if $return_rem:
+				return n.high % d.low;
+			$else
+				return n.high / d.low;
+			$endif
+		}
+		if (n.low == 0)
+		{
+			$if $return_rem:
+				r.high = n.high % d.high;
+				r.low = 0;
+				return r.all;
+			$else
+				return n.high / d.high;
+			$endif
+		}
+		if (d.high & (d.high - 1) == 0) // d is pot
+		{
+			$if $return_rem:
+				r.low = n.low;
+				r.high = n.high & (d.high - 1);
+				return r.all;
+			$else
+				return (uint128)(n.high >> $$ctz(d.high));
+			$endif
+        }
+        sr = (uint)$$clz(d.high) - (uint)$$clz(n.high);
+        // 0 <= sr <= n_udword_bits - 2 or sr large
+        if (sr > 64 - 2)
+        {
+            $if $return_rem:
+                return n.all;
+            $else
+                return 0;
+            $endif
+        }
+        sr++;
+        // 1 <= sr <= n_udword_bits - 1
+        // q.all = n.all << (n_utword_bits - sr);
+        q.low = 0;
+        q.high = n.low << (64 - sr);
+        r.high = n.high >> sr;
+        r.low = (n.high << (64 - sr)) | (n.low >> sr);
+    }
+    else // d.s.low != 0
+    {
+        if (d.high == 0)
+        {
+            if (d.low & (d.low - 1) == 0) // if d is a power of 2
+            {
+                $if $return_rem:
+                    return (uint128)(n.low & (d.low - 1));
+                $else
+                    if (d.low == 1) return n.all;
+                    sr = (uint)$$ctz(d.low);
+                    q.high = n.high >> sr;
+                    q.low = (n.high << (64 - sr)) | (n.low >> sr);
+                    return q.all;
+               $endif
+            }
+            sr = 1 + 64 + (uint)$$clz(d.low) - (uint)$$clz(n.high);
+            // 2 <= sr <= n_utword_bits - 1
+            // q.all = n.all << (n_utword_bits - sr);
+            // r.all = n.all >> sr;
+            switch
+            {
+                case sr == 64:
+					q.low = 0;
+					q.high = n.low;
+					r.high = 0;
+					r.low = n.high;
+				case sr < 64:
+                    q.low = 0;
+                    q.high = n.low << (64 - sr);
+                    r.high = n.high >> sr;
+                    r.low = (n.high << (64 - sr)) | (n.low >> sr);
+                default: // n_udword_bits + 1 <= sr <= n_utword_bits - 1
+                    q.low = n.low << (128 - sr);
+                    q.high = (n.high << (128 - sr)) | (n.low >> (sr - 64));
+                    r.high = 0;
+                    r.low = n.high >> (sr - 64);
+            }
+        }
+        else
+        {
+			sr = (uint)$$clz(d.high) - (uint)$$clz(n.high);
+            // 0 <= sr <= n_udword_bits - 1 or sr large
+            if (sr > 64 - 1)
+            {
+                $if $return_rem:
+                    return n.all;
+                $else
+                    return 0;
+                $endif
+            }
+
+            sr++;
+			// 1 <= sr <= n_udword_bits
+			// q.all = n.all << (n_utword_bits - sr);
+			// r.all = n.all >> sr;
+			q.low = 0;
+            if (sr == 64)
+            {
+                q.high = n.low;
+                r.high = 0;
+                r.low = n.high;
+			}
+			else
+			{
+				r.high = n.high >> sr;
+				r.low = (n.high << (64 - sr)) | (n.low >> sr);
+				q.high = n.low << (64 - sr);
+            }
+        }
+    }
+    // Not a special case
+    // q and r are initialized with:
+    // q.all = n.all << (128 - sr);
+    // r.all = n.all >> sr;
+    // 1 <= sr <= n_utword_bits - 1
+    uint carry = 0;
+    for (; sr > 0; sr--)
+    {
+        // r:q = ((r:q)  << 1) | carry
+        r.high = (r.high << 1) | (r.low  >> (64 - 1));
+        r.low  = (r.low  << 1) | (q.high >> (64 - 1));
+        q.high = (q.high << 1) | (q.low  >> (64 - 1));
+        q.low  = (q.low  << 1) | carry;
+        // carry = 0;
+        // if (r.all >= d.all)
+        // {
+        //     r.all -= d.all;
+        //      carry = 1;
+        // }
+        int128 s = (int128)(d.all - r.all - 1) >> (128 - 1);
+        carry = (uint)(s & 1);
+        r.all -= d.all & s;
+    }
+    $if $return_rem:
+		return r.all;
+    $else
+		return (q.all << 1) | carry;
+    $endif
+}
+
 fn uint128 __umodti3(uint128 n, uint128 d) @extern("__umodti3") @weak @nostrip
 {
-	// Ignore d = 0
-	uint128 sr = (d ? $$clz(d) : 128) - (n ? $$clz(n) : 128);
-	// If n < d then sr is wrapping.
-	// which means we can just return n.
-	if (sr > 127) return n;
-	// If d == 1 and n = MAX
-	if (sr == 127) return 0;
-	sr++;
-	uint128 r = n >> sr;
-	// Follow known algorithm:
-	n <<= 128 - sr;
-	for (uint128 carry = 0; sr > 0; sr--)
-	{
-		r = (r << 1) | (n >> 127);
-		n = (n << 1) | carry;
-		int128 sign = (int128)(d - r - 1) >> 127;
-		carry = sign & 1;
-		r -= d & sign;
-	}
-	return r;
+	return @__udivmodti4(n, d, true);
 }
 
 fn uint128 __udivti3(uint128 n, uint128 d) @extern("__udivti3") @weak @nostrip
 {
-	// Ignore d = 0
-	uint128 sr = (d ? $$clz(d) : 128) - (n ? $$clz(n) : 128);
-	// If n < d then sr is wrapping.
-	// which means we can just return 0.
-	if (sr > 127) return 0;
-	// If d == 1 and n = MAX
-	if (sr == 127) return n;
-	sr++;
-	uint128 r = n >> sr;
-	// Follow known algorithm:
-	n <<= 128 - sr;
-	uint128 carry = 0;
-	for (; sr > 0; sr--)
-	{
-		r = (r << 1) | (n >> 127);
-		n = (n << 1) | carry;
-		int128 sign = (int128)(d - r - 1) >> 127;
-		carry = sign & 1;
-		r -= d & sign;
-	}
-	n = (n << 1) | carry;
-	return n;
+	return @__udivmodti4(n, d, false);
 }
 
 fn int128 __modti3(int128 a, int128 b) @extern("__modti3") @weak @nostrip
@@ -74,11 +206,8 @@ union Int128bits @private
 {
 	struct
 	{
-		ulong ulow, uhigh;
-	}
-	struct
-	{
-		long ilow, ihigh;
+		ulong low;
+		ulong high;
 	}
 	uint128 all;
 }
@@ -89,14 +218,14 @@ fn uint128 __lshrti3(uint128 a, uint b) @extern("__lshrti3") @weak @nostrip
 	result.all = a;
 	if (b >= 64)
 	{
-		result.ulow = result.uhigh >> (b - 64);
-		result.uhigh = 0;
+		result.low = result.high >> (b - 64);
+		result.high = 0;
 	}
 	else
 	{
 		if (b == 0) return a;
-		result.ulow = (result.uhigh << (64 - b)) | (result.ulow >> b);
-		result.uhigh  = result.uhigh >> b;
+		result.low = (result.high << (64 - b)) | (result.low >> b);
+		result.high  = result.high >> b;
 	}
 	return result.all;
 }
@@ -107,14 +236,14 @@ fn int128 __ashrti3(int128 a, uint b) @extern("__ashrti3") @weak @nostrip
 	result.all = a;
 	if (b >= 64)
 	{
-		result.ilow = result.ihigh >> (b - 64);
-		result.ihigh = result.ihigh >> 63;
+		result.low = result.high >> (b - 64);
+		result.high = result.high >> 63;
 	}
 	else
 	{
 		if (b == 0) return a;
-		result.ilow = result.ihigh << (64 - b) | (result.ilow >> b);
-		result.ihigh  = result.ihigh >> b;
+		result.low = result.high << (64 - b) | (result.low >> b);
+		result.high  = result.high >> b;
 	}
 	return result.all;
 }
@@ -125,14 +254,14 @@ fn int128 __ashlti3(int128 a, uint b) @extern("__ashlti3") @weak @nostrip
 	result.all = a;
 	if (b >= 64)
 	{
-		result.ulow = 0;
-		result.uhigh = result.ulow << (b - 64);
+		result.low = 0;
+		result.high = result.low << (b - 64);
 	}
 	else
 	{
 		if (b == 0) return a;
-		result.uhigh = (result.uhigh << b) | (result.ulow >> (64 - b));
-		result.ulow  = result.ulow << b;
+		result.high = (result.high << b) | (result.low >> (64 - b));
+		result.low  = result.low << b;
 	}
 	return result.all;
 }
@@ -143,18 +272,18 @@ fn int128 __mulddi3(ulong a, ulong b) @private
 {
 	Int128bits r;
 	const ulong LOWER_MASK = 0xffff_ffff;
-	r.ulow = (a & LOWER_MASK) * (b & LOWER_MASK);
-	ulong t = r.ulow >> 32;
-	r.ulow &= LOWER_MASK;
+	r.low = (a & LOWER_MASK) * (b & LOWER_MASK);
+	ulong t = r.low >> 32;
+	r.low &= LOWER_MASK;
 	t += (a >> 32) * (b & LOWER_MASK);
-	r.ulow += (t & LOWER_MASK) << 32;
-	r.uhigh = t >> 32;
-	t = r.ulow >> 32;
-	r.ulow &= LOWER_MASK;
+	r.low += (t & LOWER_MASK) << 32;
+	r.high = t >> 32;
+	t = r.low >> 32;
+	r.low &= LOWER_MASK;
 	t += (b >> 32) * (a & LOWER_MASK);
-	r.ulow += (t & LOWER_MASK) << 32;
-	r.uhigh += t >> 32;
-	r.uhigh += (a >> 32) * (b >> 32);
+	r.low += (t & LOWER_MASK) << 32;
+	r.high += t >> 32;
+	r.high += (a >> 32) * (b >> 32);
 	return r.all;
 }
 
@@ -162,8 +291,8 @@ fn int128 __multi3(int128 a, int128 b) @extern("__multi3") @weak @nostrip
 {
 	Int128bits x = { .all = a };
 	Int128bits y = { .all = b };
-	Int128bits r = { .all = __mulddi3(x.ulow, y.ulow) };
-	r.uhigh += x.uhigh * y.ulow + x.ulow * y.uhigh;
+	Int128bits r = { .all = __mulddi3(x.low, y.low) };
+	r.high += x.high * y.low + x.low * y.high;
 	return r.all;
 }
 

lib/std/math/math_matrix.c3

@@ -1,4 +1,5 @@
 module std::math::matrix(<Real>);
+import std::math::vector;
 
 struct Matrix2x2
 {
@@ -132,6 +133,7 @@ fn Matrix2x2 Matrix2x2.sub(&self, Matrix2x2 mat2) => matrix_sub(self, mat2);
 fn Matrix3x3 Matrix3x3.sub(&self, Matrix3x3 mat2) => matrix_sub(self, mat2);
 fn Matrix4x4 Matrix4x4.sub(&self, Matrix4x4 mat2) => matrix_sub(self, mat2);
 
+fn Matrix4x4 look_at(Real[<3>] eye, Real[<3>] target, Real[<3>] up) => matrix_look_at(Matrix4x4, eye, target, up);
 
 
 fn Matrix2x2 Matrix2x2.transpose(&self)
@@ -432,3 +434,17 @@ macro matrix_sub(mat, mat2) @private
 	var $Type = Real[<$typeof(mat.m).len>];
 	return $typeof(*mat) { .m = ($Type)mat.m - ($Type)mat2.m };
 }
+
+macro matrix_look_at($Type, eye, target, up) @private
+{
+	var vz = (eye - target).normalize();
+	var vx = up.cross(vz).normalize();
+	var vy = vz.cross(vx);
+
+	return $Type {
+		vx[0], vx[1], vx[2], - (Real)vx.dot(eye),
+		vy[0], vy[1], vy[2], - (Real)vy.dot(eye),
+		vz[0], vz[1], vz[2], - (Real)vz.dot(eye),
+		0.0, 0.0, 0.0, 1
+	};
+}

lib/std/math/math_nolibc/__fmod.c3

@@ -0,0 +1,78 @@
+module std::math::nolibc @if(env::NO_LIBC);
+
+union DoubleInternal
+{
+	double f;
+	ulong i;
+}
+
+// Based on the musl implementation
+fn double fmod(double x, double y) @extern("fmod") @weak @nostrip
+{
+	DoubleInternal ux = { .f = x };
+	DoubleInternal uy = { .f = y };
+	int ex = (int)((ux.i >> 52) & 0x7ff);
+	int ey = (int)((uy.i >> 52) & 0x7ff);
+	int sx = (int)(ux.i >> 63);
+	ulong uxi = ux.i;
+	if (uy.i << 1 == 0 || math::is_nan(y) || ex == 0x7ff) return (x * y)/(x * y);
+	if (uxi << 1 <= uy.i << 1)
+	{
+		if (uxi << 1 == uy.i << 1) return 0 * x;
+		return x;
+	}
+
+	if (!ex)
+	{
+		for (ulong i = uxi << 12; i >> 63 == 0; ex--, i <<= 1);
+		uxi <<= -ex + 1;
+	}
+	else
+	{
+		uxi &= -1UL >> 12;
+		uxi |= 1UL << 52;
+	}
+	if (!ey)
+	{
+		for (ulong i = uy.i << 12; i >> 63 == 0; ey--, i <<= 1);
+		uy.i <<= -ey + 1;
+	}
+	else
+	{
+		uy.i &= -1UL >> 12;
+		uy.i |= 1UL << 52;
+	}
+
+	/* x mod y */
+	for (; ex > ey; ex--)
+	{
+		ulong i = uxi - uy.i;
+		if (i >> 63 == 0)
+		{
+			if (i == 0) return 0 * x;
+			uxi = i;
+		}
+		uxi <<= 1;
+	}
+	ulong i = uxi - uy.i;
+	if (i >> 63 == 0)
+	{
+		if (i == 0) return 0*x;
+		uxi = i;
+	}
+	for (; uxi>>52 == 0; uxi <<= 1, ex--);
+
+	/* scale result */
+	if (ex > 0)
+	{
+		uxi -= 1UL << 52;
+		uxi |= (ulong)ex << 52;
+	}
+	else
+	{
+		uxi >>= -ex + 1;
+	}
+	uxi |= (ulong)sx << 63;
+	ux.i = uxi;
+	return ux.f;
+}

lib/std/math/math_random.c3

@@ -1,18 +1,15 @@
+/**
+ * Randoms:
+ * General usage -
+ * 1. Create a Random (see std/math/random for various alternatives), or pick DefaultRandom
+ * 2. Define it `DefaultRandom my_random;`
+ * 3. Seed it: `random::seed(&my_random, some_seed);` or `rand::seed_entropy(&my_random);`
+ * 4. Use it with the functions in random: `float random_float = random::next_float(&my_random);`
+ *
+ * For just a simple integer between 0 and n (not including n), you can use `rand(n)`.
+ **/
 module std::math::random;
 
-interface Random
-{
-	fn void set_seed(char[] input);
-	fn char next_byte();
-	fn ushort next_short();
-	fn uint next_int();
-	fn ulong next_long();
-	fn uint128 next_int128();
-	fn void next_bytes(char[] buffer);
-}
-
-macro bool is_random(random) => $assignable(random, Random*);
-
 /**
  * @require is_random(random)
  **/
@@ -21,39 +18,101 @@ macro void seed(random, seed)
 	random.set_seed(@as_char_view(seed));
 }
 
+/**
+ * Seed the random with some best effort entropy.
+ *
+ * @require is_random(random)
+ **/
 macro void seed_entropy(random)
 {
 	random.set_seed(&&entropy());
 }
 
 /**
+ * Get the next value between 0 and range (not including range).
+ *
  * @require is_random(random)
+ * @require range > 0
  **/
-macro int next(random, int max)
+macro int next(random, uint range)
 {
-	return (int)(next_double(random) * max);
+	if (range == 1) return 0;
+	uint mask = ~0U;
+	range--;
+    mask >>= range.clz();
+    uint x @noinit;
+	do
+	{
+		x = random.next_int() & mask;
+	}
+	while (x > range);
+	return x;
 }
 
-fn int rand(int max) @builtin
-{
-	tlocal Sfc64Random default_random;
-	tlocal bool initialized = false;
-	if (!initialized)
-	{
-		seed_entropy(&default_random);
-		initialized = true;
-	}
-	return next(&default_random, max);
-}
 /**
+ * Get a random in the range [min, max], both included.
+ *
+ * @require is_random(random)
+ * @require max >= min
+ **/
+macro int next_in_range(random, int min, int max)
+{
+	return next(random, max - min + 1) + min;
+}
+
+def DefaultRandom = Sfc64Random;
+
+tlocal Sfc64Random default_random @private;
+tlocal bool default_random_initialized @private = false;
+
+/**
+ * Seed the default random function.
+ */
+fn void srand(ulong seed) @builtin
+{
+	default_random.set_seed(@as_char_view(seed));
+	default_random_initialized = true;
+}
+
+/**
+ * Get a default random value between 0 and range (not including range)
+ **/
+fn int rand(int range) @builtin
+{
+	init_default_random();
+	return next(&default_random, range);
+}
+
+/**
+ * Get a random in the range, both included.
+ * @require max >= min
+ **/
+fn int rand_in_range(int min, int max) @builtin
+{
+	init_default_random();
+	return next_in_range(&default_random, min, max);
+}
+
+fn double rnd() @builtin
+{
+	init_default_random();
+	ulong val = default_random.next_long() & (1UL << 53 - 1);
+	return val * 0x1.0p-53;
+}
+
+/**
+ * Get 'true' or 'false'
+ *
  * @require is_random(random)
  **/
 macro bool next_bool(random)
 {
-	return random.next_byte() & 1;
+	return (bool)(random.next_byte() & 1);
 }
 
 /**
+ * Get a float between 0 and 1.0, not including 1.0.
+ *
  * @require is_random(random)
  **/
 macro float next_float(random)
@@ -63,6 +122,8 @@ macro float next_float(random)
 }
 
 /**
+ * Get a double between 0 and 1.0, not including 1.0.
+ *
  * @require is_random(random)
  **/
 macro double next_double(random)
@@ -71,6 +132,9 @@ macro double next_double(random)
 	return val * 0x1.0p-53;
 }
 
+// True if the value is a Random.
+macro bool is_random(random) => $assignable(random, Random);
+
 macro uint128 @long_to_int128(#function) => (uint128)#function << 64 + #function;
 macro ulong @int_to_long(#function) => (ulong)#function << 32 + #function;
 macro uint @short_to_int(#function) => (uint)#function << 16 + #function;
@@ -95,3 +159,26 @@ macro @random_value_to_bytes(#function, char[] bytes)
 	}
 	unreachable();
 }
+
+// This is the interface to implement for Random implementations, usually
+// it is not invoked directly.
+interface Random
+{
+	fn void set_seed(char[] input);
+	fn char next_byte();
+	fn ushort next_short();
+	fn uint next_int();
+	fn ulong next_long();
+	fn uint128 next_int128();
+	fn void next_bytes(char[] buffer);
+}
+
+
+macro init_default_random() @private
+{
+	if (!default_random_initialized)
+	{
+		seed_entropy(&default_random);
+		default_random_initialized = true;
+	}
+}

lib/std/math/math_vector.c3

@@ -25,11 +25,11 @@ macro Vec4.distance_sq(self, Vec4 v2) => (self - v2).length_sq();
 
 macro Vec2f.transform(self, Matrix4f mat) => transform2(self, mat);
 macro Vec2f.rotate(self, float angle) => rotate(self, angle);
-macro Vec2f.angle(self, Vec2f v2) => math::atan2(v2[1], v2[0]) - math::atan2(self[1], v2[0]);
+macro Vec2f.angle(self, Vec2f v2) => math::atan2(v2.y, v2.x) - math::atan2(self.y, self.x);
 
 macro Vec2.transform(self, Matrix4 mat) => transform2(self, mat);
 macro Vec2.rotate(self, double angle) => rotate(self, angle);
-macro Vec2.angle(self, Vec2 v2) => math::atan2(v2[1], v2[0]) - math::atan2(self[1], v2[0]);
+macro Vec2.angle(self, Vec2 v2) => math::atan2(v2.y, v2.x) - math::atan2(self.y, self.x);
 
 macro Vec2f.clamp_mag(self, float min, float max) => clamp_magnitude(self, min, max);
 macro Vec3f.clamp_mag(self, float min, float max) => clamp_magnitude(self, min, max);
@@ -66,8 +66,8 @@ fn Vec3 Vec3.refract(self, Vec3 n, double r) => refract3(self, n, r);
 fn void ortho_normalize(Vec3f* v1, Vec3f* v2) => ortho_normalize3(v1, v2);
 fn void ortho_normalized(Vec3* v1, Vec3* v2) => ortho_normalize3(v1, v2);
 
-fn Matrix4f matrix4f_look_at(Vec3f eye, Vec3f target, Vec3f up) => matrix_look_at(Matrix4f, eye, target, up);
-fn Matrix4 matrix4_look_at(Vec3 eye, Vec3 target, Vec3 up) => matrix_look_at(Matrix4, eye, target, up);
+fn Matrix4f matrix4f_look_at(Vec3f eye, Vec3f target, Vec3f up) @deprecated => matrix::look_at(<float>)(eye, target, up);
+fn Matrix4 matrix4_look_at(Vec3 eye, Vec3 target, Vec3 up) @deprecated => matrix::look_at(<double>)(eye, target, up);
 
 fn Vec3f Vec3f.rotate_quat(self, Quaternionf q) => rotate_by_quat3(self, q);
 fn Vec3 Vec3.rotate_quat(self, Quaternion q) => rotate_by_quat3(self, q);
@@ -190,26 +190,12 @@ macro rotate_axis_angle(v, axis, angle) @private
 	var w = axis * math::sin(angle);
 	var wv = w.cross(v);
 	var wwv = w.cross(wv);
-	wv *= math::cos(angle) * 2;
+	wv *= math::cos(($typeof(v))angle) * 2;
 	wwv *= 2;
 
 	return v + wv + wwv;
 }
 
-macro matrix_look_at($Type, eye, target, up) @private
-{
-	var vz = (eye - target).normalize();
-	var vx = up.cross(vz).normalize();
-	var vy = vz.cross(vx);
-
-	return $Type {
-		vx[0], vx[1], vx[2], - vx.dot(eye),
-		vy[0], vy[1], vy[2], - vy.dot(eye),
-		vz[0], vz[1], vz[2], - vz.dot(eye),
-		0.0, 0.0, 0.0, 1
-	};
-}
-
 macro unproject3(v, m1, m2) @private
 {
 return v;
@@ -256,4 +242,4 @@ macro refract3(v, n, r) @private
 	var d = 1 - r * r * (1 - dot * dot);
 
 	return d < 0 ? v : r * v - (r * dot + math::sqrt(d)) * n;
-}
+}

lib/std/math/random/math.seeder.c3

@@ -72,8 +72,9 @@ macro uint hash(value) @local
 	return fnv32a::encode(&&bitcast(value, char[$sizeof(value)]));
 }
 
-fn char[8 * 4] entropy()
+fn char[8 * 4] entropy() @if(!env::WASM_NOLIBC)
 {
+
 	void* addr = malloc(1);
 	free(addr);
 	static uint random_int;
@@ -89,4 +90,21 @@ fn char[8 * 4] entropy()
 		hash(allocator::heap())
     };
     return bitcast(entropy_data, char[8 * 4]);
+}
+
+fn char[8 * 4] entropy() @if(env::WASM_NOLIBC)
+{
+	static uint random_int;
+	random_int += 0xedf19156;
+	uint[8] entropy_data = {
+		hash($$TIME),
+		hash(&entropy),
+		random_int,
+		hash($$TIME),
+		hash(&entropy),
+		random_int,
+		hash($$TIME),
+		hash(&entropy),
+    };
+    return bitcast(entropy_data, char[8 * 4]);
 }

lib/std/math/uuid.c3

@@ -0,0 +1,41 @@
+module std::math::uuid;
+import std::math::random @public;
+import std::io;
+
+distinct Uuid (Printable) = char[16];
+
+/**
+ * Generate a version 4 UUID from the default random.
+ **/
+fn Uuid generate()
+{
+	random::init_default_random();
+	return generate_from_random(&random::default_random);
+}
+
+/**
+ * Generate a version 4 UUID from the given random.
+ **/
+fn Uuid generate_from_random(Random random)
+{
+	Uuid uuid;
+	random.next_bytes(&(char[16])uuid);
+	uuid[6] = (uuid[6] & 0b0000_1111) | 0b0100_0000;
+	uuid[8] = (uuid[8] & 0b0011_1111) | 0b1000_0000;
+	return uuid;
+}
+
+fn usz! Uuid.to_format(&self, Formatter* formatter) @dynamic
+{
+	return formatter.printf("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+		(*self)[0], (*self)[1], (*self)[2], (*self)[3],
+		(*self)[4], (*self)[5],
+		(*self)[6], (*self)[7],
+		(*self)[8], (*self)[9],
+		(*self)[10], (*self)[11], (*self)[12], (*self)[13], (*self)[14], (*self)[15]);
+}
+
+fn String Uuid.to_string(&self, Allocator allocator) @dynamic
+{
+	return string::new_format("%s", *self, allocator: allocator);
+}

lib/std/net/net.c3

@@ -27,6 +27,7 @@ fault NetError
 	ALREADY_CONNECTED,
 	NETWORK_UNREACHABLE,
 	OPERATION_NOT_SUPPORTED_ON_SOCKET,
+	CONNECTION_RESET,
 }
 
 fn uint! ipv4toint(String s)

lib/std/net/os/linux.c3

@@ -22,7 +22,7 @@ const int SO_ERROR                   = 4;
 const int SO_DONTROUTE               = 5; // just use interface addresses
 const int SO_BROADCAST               = 6; // permit sending of broadcast msgs
 const int SO_SNDBUF                  = 7; // Send buffer size
-const int SO_RCVBUF                  = 8; // Recieve buffer size
+const int SO_RCVBUF                  = 8; // Receive buffer size
 const int SO_KEEPALIVE               = 9; // keep connections alive
 const int SO_OOBINLINE	             = 10; // leave received OOB data in line
 const int SO_NO_CHECK                = 11;

lib/std/net/os/posix.c3

@@ -16,11 +16,11 @@ struct Posix_pollfd
 def Posix_nfds_t = CUInt;
 
 extern fn CInt connect(NativeSocket socket, SockAddrPtr address, Socklen_t address_len);
-extern fn NativeSocket socket(AIFamily af, AISockType type, AIProtocol ip_protocol) @extern("socket");
-extern fn int fcntl(NativeSocket socket, int cmd, ...) @extern("fcntl");
-extern fn CInt bind(NativeSocket socket, SockAddrPtr address, Socklen_t address_len) @extern("bind");
-extern fn CInt listen(NativeSocket socket, CInt backlog) @extern("listen");
-extern fn NativeSocket accept(NativeSocket socket, SockAddrPtr address, Socklen_t* address_len) @extern("accept");
+extern fn NativeSocket socket(AIFamily af, AISockType type, AIProtocol ip_protocol);
+extern fn int fcntl(NativeSocket socket, int cmd, ...);
+extern fn CInt bind(NativeSocket socket, SockAddrPtr address, Socklen_t address_len);
+extern fn CInt listen(NativeSocket socket, CInt backlog);
+extern fn NativeSocket accept(NativeSocket socket, SockAddrPtr address, Socklen_t* address_len);
 extern fn CInt poll(Posix_pollfd* fds, Posix_nfds_t nfds, CInt timeout);
 
 const CUShort POLLIN      = 0x0001;
@@ -39,6 +39,7 @@ fn anyfault convert_error(Errno error)
 		case errno::EALREADY: return NetError.CONNECTION_ALREADY_IN_PROGRESS;
 		case errno::EBADF: return NetError.BAD_SOCKET_DESCRIPTOR;
 		case errno::ECONNREFUSED: return NetError.CONNECTION_REFUSED;
+		case errno::ECONNRESET: return NetError.CONNECTION_RESET;
 		case errno::EISCONN: return NetError.ALREADY_CONNECTED;
 		case errno::ENETUNREACH: return NetError.NETWORK_UNREACHABLE;
 		case errno::ENOTSOCK: return NetError.NOT_A_SOCKET;
@@ -55,6 +56,11 @@ fn anyfault socket_error()
 	return convert_error(libc::errno());
 }
 
+macro bool NativeSocket.is_valid(self)
+{
+	return (iptr)self >= 0;
+}
+
 macro void! NativeSocket.close(self)
 {
 	if (libc::close(self))

lib/std/net/os/win32.c3

@@ -12,7 +12,7 @@ const int FIONREAD = 1074030207;
 const int FIONBIO = -2147195266;
 const int FIOASYNC = -2147195267;
 
-distinct NativeSocket = uptr;
+distinct NativeSocket = inline Win32_SOCKET;
 
 extern fn CInt ioctlsocket(NativeSocket, CLong cmd, CULong *argp);
 extern fn WSAError closesocket(NativeSocket);
@@ -22,6 +22,11 @@ extern fn int bind(NativeSocket, SockAddrPtr address, Socklen_t address_len);
 extern fn int listen(NativeSocket, int backlog);
 extern fn NativeSocket accept(NativeSocket, SockAddrPtr address, Socklen_t* address_len);
 
+macro bool NativeSocket.is_valid(self)
+{
+	return self != (NativeSocket)(uptr)-1;
+}
+
 fn void! NativeSocket.set_non_blocking(self, bool non_blocking)
 {
 	if (ioctlsocket(self, win32::FIONBIO, &&(CULong)non_blocking))
@@ -76,6 +81,7 @@ fn anyfault convert_error(WSAError error)
         case wsa::ENOTSOCK: return NetError.NOT_A_SOCKET;
         case wsa::EOPNOTSUPP: return NetError.OPERATION_NOT_SUPPORTED_ON_SOCKET;
         case wsa::ETIMEDOUT: return NetError.CONNECTION_TIMED_OUT;
+        case wsa::ECONNRESET: return NetError.CONNECTION_RESET;
 		default: return IoError.GENERAL_ERROR;
 	}
 }

lib/std/net/socket.c3

@@ -15,7 +15,7 @@ macro void @loop_over_ai(AddrInfo* ai; @body(NativeSocket fd, AddrInfo* ai))
 	while (ai)
 	{
 		NativeSocket sockfd = os::socket(ai.ai_family, ai.ai_socktype, ai.ai_protocol);
-		if (sockfd > 0)
+		if (sockfd.is_valid())
 		{
 			@body(sockfd, ai);
 		}
@@ -120,8 +120,12 @@ fn bool! Socket.get_option(&self, SocketOption option)
 
 fn usz! Socket.read(&self, char[] bytes) @dynamic
 {
-	isz n = libc::read((Fd)self.sock, bytes.ptr, bytes.len);
-	if (n < 0) return NetError.READ_FAILED?;
+$if env::WIN32:
+	isz n = libc::recv(self.sock, bytes.ptr, (int)bytes.len, 0);
+$else
+	isz n = libc::recv(self.sock, bytes.ptr, bytes.len, 0);
+$endif
+	if (n < 0) return os::socket_error()?;
 	return (usz)n;
 }
 
@@ -129,8 +133,12 @@ fn char! Socket.read_byte(&self) @dynamic => io::@read_byte_using_read(self);
 
 fn usz! Socket.write(&self, char[] bytes) @dynamic
 {
-	isz n = libc::write((Fd)self.sock, bytes.ptr, bytes.len);
-	if (n < 0) return NetError.WRITE_FAILED?;
+$if env::WIN32:
+	isz n = libc::send(self.sock, bytes.ptr, (int)bytes.len, 0);
+$else
+	isz n = libc::send(self.sock, bytes.ptr, bytes.len, 0);
+$endif
+	if (n < 0) return os::socket_error()?;
 	return (usz)n;
 }
 

lib/std/net/tcp.c3

@@ -43,8 +43,9 @@ fn TcpServerSocket! listen(String host, uint port, uint backlog, SocketOption...
 fn TcpSocket! accept(TcpServerSocket* server_socket)
 {
 	TcpSocket socket;
+	socket.ai_addrlen = socket.ai_addr_storage.len;
 	socket.sock = os::accept(server_socket.sock, (SockAddrPtr)&socket.ai_addr_storage, &socket.ai_addrlen);
-	if (socket.sock < 0) return NetError.ACCEPT_FAILED?;
+	if (!socket.sock.is_valid()) return NetError.ACCEPT_FAILED?;
 	return socket;
 }
 

lib/std/os/env.c3

@@ -83,10 +83,15 @@ fn String! get_home_dir(Allocator using = allocator::heap())
 	return get_var(home, using);
 }
 
+fn Path! get_config_dir(Allocator allocator = allocator::heap()) @deprecated("use new_get_config_dir()")
+{
+	return new_get_config_dir(allocator) @inline;
+}
+
 /**
  * Returns the current user's config directory.
  **/
-fn Path! get_config_dir(Allocator allocator = allocator::heap())
+fn Path! new_get_config_dir(Allocator allocator = allocator::heap())
 {
 	@pool(allocator)
 	{
@@ -100,7 +105,7 @@ fn Path! get_config_dir(Allocator allocator = allocator::heap())
 			String s = get_var_temp("XDG_CONFIG_HOME") ?? get_var_temp("HOME")!;
 			const DIR = ".config";
 		$endif
-		return path::temp_new(s).append(DIR, .allocator = allocator);
+		return path::temp_new(s).new_append(DIR, allocator: allocator);
 	$endif
 	};
 }
@@ -126,11 +131,16 @@ fn bool clear_var(String name)
 	};
 }
 
-fn String! executable_path(Allocator allocator = allocator::heap())
+fn String! executable_path(Allocator allocator = allocator::heap()) @deprecated("use new_executable_path()")
+{
+	return new_executable_path(allocator) @inline;
+}
+
+fn String! new_executable_path(Allocator allocator = allocator::heap())
 {
 	$if env::DARWIN:
 		return darwin::executable_path(allocator);
 	$else
-		return "<Unsupported>";
+		return SearchResult.MISSING?;
 	$endif
 }

lib/std/os/macos/darwin.c3

@@ -80,7 +80,7 @@ fn uptr! load_address() @local
 {
 	Darwin_segment_command_64* cmd = darwin::getsegbyname("__TEXT");
 	if (!cmd) return BacktraceFault.SEGMENT_NOT_FOUND?;
-	String path = env::executable_path(allocator::temp()) ?? BacktraceFault.EXECUTABLE_PATH_NOT_FOUND?!;
+	String path = env::new_executable_path(allocator::temp()) ?? BacktraceFault.EXECUTABLE_PATH_NOT_FOUND?!;
     uint dyld_count = darwin::_dyld_image_count();
 	for (uint i = 0; i < dyld_count; i++)
 	{

lib/std/os/posix/files.c3

@@ -7,15 +7,22 @@ distinct DIRPtr = void*;
 struct Posix_dirent
 {
 	Ino_t d_fileno;
-	Off_t d_off;
+	Off_t d_off @if(!env::NETBSD);
 	ushort d_reclen;
-	ushort d_namelen @if(env::DARWIN);
+	ushort d_namelen @if(env::DARWIN || env::NETBSD);
 	char d_type;
-	char d_namelen @if(env::FREEBSD || env::OPENBSD);
-	uint d_pad0 @if(env::FREEBSD);
+
+	char d_namelen @if(env::OPENBSD);
 	char[4] d_pad0 @if(env::OPENBSD);
+
+	char d_pad0 @if(env::FREEBSD);
+	ushort d_namelen @if(env::FREEBSD);
+	ushort d_pad1 @if(env::FREEBSD);
+
+	char[255+1] name @if(env::FREEBSD || env::OPENBSD);
+	char[511+1] name @if(env::NETBSD);
 	char[1024] name @if(env::DARWIN);
-	char[*] name @if(!env::DARWIN);
+	char[*] name @if(!env::DARWIN && !env::BSD_FAMILY);
 }
 
 extern fn int rmdir(ZString);
@@ -41,4 +48,3 @@ const DT_WHT     = 14;
 
 const USE_DARWIN_INODE64 = env::DARWIN && env::X86_64;
 extern fn Posix_dirent* readdir(DIRPtr) @extern("readdir$INODE64") @if(USE_DARWIN_INODE64);
-

lib/std/os/posix/threads.c3

@@ -3,8 +3,8 @@ import std::thread;
 import libc;
 
 const PTHREAD_MUTEX_NORMAL = 0;
-const PTHREAD_MUTEX_ERRORCHECK = 1;
-const PTHREAD_MUTEX_RECURSIVE = 2;
+const PTHREAD_MUTEX_ERRORCHECK = env::LINUX ? 2 : 1;
+const PTHREAD_MUTEX_RECURSIVE = env::LINUX ? 1 : 2;
 
 def PosixThreadFn = fn void*(void*);
 distinct Pthread_t = void*;

lib/std/os/win32/heap.c3

@@ -2,10 +2,10 @@ module std::os::win32 @if(env::WIN32);
 
 extern fn void* _aligned_malloc(usz size, usz alignment);
 extern fn void* _aligned_realloc(void* memblock, usz size, usz alignment);
-extern fn void* _aligned_recalloc(void* memblock, usz size, usz alignment);
+extern fn void* _aligned_recalloc(void* memblock, usz num, usz size, usz alignment);
 extern fn void _aligned_free(void* memblock);
 extern fn void _aligned_msize(void* memblock, usz alignment, usz offset);
 extern fn void* _aligned_offset_malloc(usz size, usz alignment, usz offset);
 extern fn void* _aligned_offset_realloc(void* memblock, usz size, usz alignment, usz offset);
-extern fn void* _aligned_offset_recalloc(void* memblock, usz size, usz alignment, usz offset);
+extern fn void* _aligned_offset_recalloc(void* memblock, usz num, usz size, usz alignment, usz offset);
 extern fn usz _msize(void* memblock);

lib/std/os/win32/process.c3

@@ -193,10 +193,10 @@ fn Backtrace! resolve_backtrace(void* addr, Win32_HANDLE process, Allocator allo
 	ZString zname = (ZString)&name;
 	if (!symGetLineFromAddr64(process, (Win32_ULONG64)addr - 1, &offset, &line))
 	{
-		backtrace.init((uptr)addr, .function = zname.str_view(), .object_file = module_name.str_view(), .allocator = allocator);
+		backtrace.init((uptr)addr, zname.str_view(), module_name.str_view(), allocator: allocator);
 		return backtrace;
 	}
 	String filename = ((ZString)line.fileName).str_view();
-	backtrace.init((uptr)addr, .function = zname.str_view(), .object_file = module_name.str_view(), .file = filename, .line = line.lineNumber, .allocator = allocator);
+	backtrace.init((uptr)addr, zname.str_view(), module_name.str_view(), file: filename, line: line.lineNumber, allocator: allocator);
 	return backtrace;
 }

lib/std/os/win32/wsa.c3

@@ -32,6 +32,8 @@ extern fn CInt win32_WSAPoll(Win32_LPWSAPOLLFD fdArray, Win32_ULONG fds, Win32_I
 extern fn WSAError win32_WSAGetLastError() @extern("WSAGetLastError") @builtin;
 extern fn void win32_WSASetLastError(WSAError error) @extern("WSASetLastError") @builtin;
 extern fn CInt win32_WSAStartup(Win32_WORD, void*) @extern("WSAStartup") @builtin;
+extern fn CInt win32_WSACleanup() @extern("WSACleanup") @builtin;
+
 const int FIONBIO = -2147195266;
 const int FIONREAD = 1074030207;
 const int SIOCATMARK = 1074033415;

lib/std/sort/countingsort.c3

@@ -32,7 +32,7 @@ def Indexs = char[256] @private;
 def ElementType = $typeof(Type{}[0]);
 
 const bool NO_KEY_FN @private = types::is_same(KeyFn, EmptySlot);
-const bool KEY_BY_VALUE @private = $or(NO_KEY_FN, $assignable(Type{}[0], $typefrom(KeyFn.params[0])));
+const bool KEY_BY_VALUE @private = NO_KEY_FN ||| $assignable(Type{}[0], $typefrom(KeyFn.paramsof[0].type));
 const bool LIST_HAS_REF @private = $defined(&Type{}[0]);
 
 def KeyFnReturnType = $typefrom(KeyFn.returns) @if(!NO_KEY_FN);

lib/std/sort/insertionsort.c3

@@ -20,7 +20,7 @@ fn void isort(Type list, usz low, usz high, CmpFn comp, Context context)
 {
 	var $has_cmp = @is_valid_macro_slot(comp);
 	var $has_context = @is_valid_macro_slot(context);
-	var $cmp_by_value = $and($has_cmp, $assignable(list[0], $typefrom(CmpFn.params[0])));
+	var $cmp_by_value = $has_cmp &&& $assignable(list[0], $typefrom(CmpFn.paramsof[0].type));
 	var $has_get_ref =  $defined(&list[0]);
 	for (usz i = low; i < high; ++i)
 	{

lib/std/sort/quicksort.c3

@@ -31,7 +31,8 @@ fn void qsort(Type list, isz low, isz high, CmpFn cmp, Context context)
 {
 	var $has_cmp = @is_valid_macro_slot(cmp);
 	var $has_context = @is_valid_macro_slot(context);
-	var $cmp_by_value = $and($has_cmp, $assignable(list[0], $typefrom(CmpFn.params[0])));
+	var $cmp_by_value = $has_cmp &&& $assignable(list[0], $typefrom(CmpFn.paramsof[0].type));
+
 	if (low >= 0 && high >= 0 && low < high)
 	{
 		Stack stack;

lib/std/sort/sort.c3

@@ -16,11 +16,11 @@ macro bool @is_sortable(#list)
 			return false;
 		$case !$defined(#list.len):
 			return false;
-		$case $and($defined(&#list[0]) && !types::is_same($typeof(&#list[0]), $typeof(#list[0])*)):
+		$case $defined(&#list[0]) &&& !types::is_same($typeof(&#list[0]), $typeof(#list[0])*):
 			return false;
 		$default:
 			return true;
-	$endswitch;
+	$endswitch
 }
 
 macro bool @is_valid_context(#cmp, #context)
@@ -34,7 +34,7 @@ macro bool @is_valid_cmp_fn(#cmp, #list, #context)
 	var $no_context = @is_empty_macro_slot(#context);
 	$switch
 		$case @is_empty_macro_slot(#cmp): return true;
-	    $case $or($Type.kindof != FUNC, $Type.returns.kindof != SIGNED_INT): return false;
+	    $case $Type.kindof != FUNC ||| $Type.returns.kindof != SIGNED_INT: return false;
 		$case $defined(#cmp(#list[0], #list[0], #context)): return true;
 		$case $defined(#cmp(#list[0], #list[0])): return $no_context;
 		$case $defined(#cmp(&#list[0], &#list[0], #context)): return true;

lib/std/threads/fixed_pool.c3

@@ -0,0 +1,178 @@
+module std::thread::threadpool @if (env::POSIX || env::WIN32);
+import std::thread;
+
+// Please do not use this one in production.
+
+fault ThreadPoolResult
+{
+	QUEUE_FULL
+}
+
+def ThreadPoolFn = fn void(any[] args);
+
+struct FixedThreadPool @adhoc
+{
+	Mutex mu;
+	QueueItem[] queue;
+	usz qindex;
+	usz num_threads;
+	bitstruct : char {
+		bool initialized;
+		bool stop;
+		bool stop_now;
+	}
+	Thread[] pool;
+	ConditionVariable notify;
+}
+
+struct QueueItem @private
+{
+	ThreadPoolFn func;
+	any[] args;
+}
+
+/**
+ * @require !self.initialized "ThreadPool must not be already initialized"
+ * @require threads > 0 && threads < 0x1000 `Threads should be greater than 0 and less than 0x1000`
+ * @require queue_size < 0x10000 `Queue size must be less than 65536`
+ **/
+fn void! FixedThreadPool.init(&self, usz threads, usz queue_size = 0)
+{
+	if (queue_size == 0) queue_size = threads * 32;
+	defer catch @ok(self.destroy());
+	assert(queue_size > 0);
+	*self = {
+		.num_threads = threads,
+		.initialized = true,
+		.queue = mem::alloc_array(QueueItem, queue_size),
+		.pool = mem::new_array(Thread, threads)
+	};
+	self.mu.init()!;
+	self.notify.init()!;
+	foreach (&thread : self.pool)
+	{
+		thread.create(&process_work, self)!;
+		// The thread resources will be cleaned up when the thread exits.
+		thread.detach()!;
+	}
+}
+
+/*
+ * Stop all the threads and cleanup the pool.
+ * Any pending work will be dropped.
+ */
+fn void! FixedThreadPool.destroy(&self)
+{
+	return self.@shutdown(stop_now);
+}
+
+/*
+ * Stop all the threads and cleanup the pool.
+ * Any pending work will be processed.
+ */
+fn void! FixedThreadPool.stop_and_destroy(&self)
+{
+	return self.@shutdown(stop);
+}
+
+macro void! FixedThreadPool.@shutdown(&self, #stop) @private
+{
+	if (self.initialized)
+	{
+		self.mu.lock()!;
+		self.#stop = true;
+		self.notify.broadcast()!;
+		self.mu.unlock()!;
+		// Wait for all threads to shutdown.
+		while (true)
+		{
+			self.mu.lock()!;
+			defer self.mu.unlock()!!;
+			if (self.num_threads == 0)
+			{
+				break;
+			}
+			self.notify.signal()!;
+		}
+		self.mu.destroy()!;
+		self.initialized = false;
+		while (self.qindex)
+		{
+			free_qitem(self.queue[--self.qindex]);
+		}
+		free(self.queue);
+		self.queue = {};
+	}
+}
+
+/*
+ * Push a new job to the pool.
+ * Returns whether the queue is full, in which case the job is ignored.
+ */
+fn void! FixedThreadPool.push(&self, ThreadPoolFn func, args...)
+{
+	self.mu.lock()!;
+	defer self.mu.unlock()!!;
+	if (self.qindex == self.queue.len) return ThreadPoolResult.QUEUE_FULL?;
+	any[] data;
+	if (args.len)
+	{
+		data = mem::alloc_array(any, args.len);
+		foreach (i, arg : args) data[i] = allocator::clone_any(allocator::heap(), arg);
+	}
+	self.queue[self.qindex] = { .func = func, .args = data };
+	self.qindex++;
+	defer catch
+	{
+		free_qitem(self.queue[--self.qindex]);
+	}
+	// Notify the threads that work is available.
+	self.notify.broadcast()!;
+}
+
+fn int process_work(void* self_arg) @private
+{
+	FixedThreadPool* self = self_arg;
+	while (true)
+	{
+		self.mu.lock()!!;
+		if (self.stop_now)
+		{
+			// Shutdown requested.
+			self.num_threads--;
+			self.mu.unlock()!!;
+			return 0;
+		}
+		// Wait for work.
+		while (self.qindex == 0)
+		{
+			if (self.stop)
+			{
+				// Shutdown requested.
+				self.num_threads--;
+				self.mu.unlock()!!;
+				return 0;
+			}
+			self.notify.wait(&self.mu)!!;
+			if (self.stop_now)
+			{
+				// Shutdown requested.
+				self.num_threads--;
+				self.mu.unlock()!!;
+				return 0;
+			}
+		}
+		// Process the job.
+		self.qindex--;
+		QueueItem item = self.queue[self.qindex];
+		self.mu.unlock()!!;
+		defer free_qitem(item);
+		item.func(item.args);
+	}
+}
+
+fn void free_qitem(QueueItem item) @private
+{
+	foreach (arg : item.args) free(arg.ptr);
+	free(item.args);
+}

lib/std/threads/os/thread_posix.c3

@@ -24,6 +24,12 @@ fn void! NativeMutex.init(&self, MutexType type)
 	{
 		if (posix::pthread_mutexattr_settype(&attr, posix::PTHREAD_MUTEX_RECURSIVE)) return ThreadFault.INIT_FAILED?;
 	}
+	else
+	{
+		$if env::COMPILER_SAFE_MODE:
+			if (posix::pthread_mutexattr_settype(&attr, posix::PTHREAD_MUTEX_ERRORCHECK)) return ThreadFault.INIT_FAILED?;
+		$endif
+	}
 	if (posix::pthread_mutex_init(&self.mutex, &attr)) return ThreadFault.INIT_FAILED?;
 	self.initialized = true;
 }

lib/std/threads/os/thread_win32.c3

@@ -12,7 +12,7 @@ struct NativeMutex
 	}
 	// Size is less than a Win32_HANDLE so due to alignment
 	// there is no benefit to pack these into a bitstruct.
-	bool already_locked;
+	uint locks;
 	bool recursive;
 	bool timed;
 }
@@ -40,7 +40,7 @@ struct NativeConditionVariable
 
 fn void! NativeMutex.init(&mtx, MutexType type)
 {
-	mtx.already_locked = false;
+	mtx.locks = 0;
 	mtx.recursive = (bool)(type & thread::MUTEX_RECURSIVE);
 	mtx.timed = (bool)(type & thread::MUTEX_TIMED);
 	if (!mtx.timed)
@@ -53,6 +53,7 @@ fn void! NativeMutex.init(&mtx, MutexType type)
 
 fn void! NativeMutex.destroy(&mtx)
 {
+	mtx.locks = 0;
 	if (!mtx.timed)
 	{
 		win32::deleteCriticalSection(&mtx.critical_section);
@@ -79,11 +80,11 @@ fn void! NativeMutex.lock(&mtx)
 
 		}
 	}
-	if (!mtx.recursive)
+	if (!mtx.recursive && mtx.locks)
 	{
-		while (mtx.already_locked) win32::sleep(1);
+		return ThreadFault.LOCK_FAILED?;
 	}
-	mtx.already_locked = true;
+	mtx.locks++;
 }
 
 
@@ -103,20 +104,11 @@ fn void! NativeMutex.lock_timeout(&mtx, ulong ms)
 		default:
 			return ThreadFault.LOCK_FAILED?;
 	}
-	if (!mtx.recursive)
+	if (!mtx.recursive && mtx.locks)
 	{
-		usz left_timeout = ms - 1;
-		while (mtx.already_locked)
-		{
-			if (left_timeout-- == 0)
-			{
-				win32::releaseMutex(mtx.handle);
-				return ThreadFault.LOCK_TIMEOUT?;
-			}
-			win32::sleep(1);
-		}
-		mtx.already_locked = true;
+		return ThreadFault.LOCK_FAILED?;
 	}
+	mtx.locks++;
 }
 
 fn bool NativeMutex.try_lock(&mtx)
@@ -128,7 +120,7 @@ fn bool NativeMutex.try_lock(&mtx)
 	if (!success) return false;
 	if (!mtx.recursive)
 	{
-		if (mtx.already_locked)
+		if (mtx.locks)
 		{
 			if (mtx.timed)
 			{
@@ -140,14 +132,15 @@ fn bool NativeMutex.try_lock(&mtx)
 			}
 			return false;
 		}
-		mtx.already_locked = true;
 	}
+	mtx.locks++;
 	return true;
 }
 
 fn void! NativeMutex.unlock(&mtx)
 {
-	mtx.already_locked = false;
+	if (!mtx.locks) return ThreadFault.UNLOCK_FAILED?;
+	mtx.locks--;
 	if (!mtx.timed)
 	{
 		win32::leaveCriticalSection(&mtx.critical_section);

lib/std/threads/pool.c3

@@ -1,7 +1,7 @@
 module std::thread::pool(<SIZE>);
 import std::thread;
 
-struct ThreadPool
+struct ThreadPool @adhoc
 {
 	Mutex mu;
 	QueueItem[SIZE] queue;
@@ -17,7 +17,7 @@ struct ThreadPool
 	ConditionVariable notify;
 }
 
-struct QueueItem
+struct QueueItem @private
 {
 	ThreadFn func;
 	void* arg;