Updated grammar. Removal of elif. Removal of ':' ';' in some ct statements. Empty faults is now an error. Remove "define" for types. Remove "private". Better errors on incorrect bitstruct syntax. Introduction of wildcard type rather than optional wildcard. Removal of scaled vector type. '?' now has much higher precedence.

.github/FUNDING.yml

@@ -1,14 +0,0 @@
-# These are supported funding model platforms
-
-github: [c3lang]
-patreon: # Replace with a single Patreon username
-open_collective: # Replace with a single Open Collective username
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
-polar: # Replace with a single Polar username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/workflows/main.yml

@@ -7,7 +7,7 @@ on:
     branches: [ master ]
 
 env:
-  LLVM_RELEASE_VERSION: 16
+  LLVM_RELEASE_VERSION: 15
 
 jobs:
 
@@ -23,7 +23,7 @@ jobs:
       run:
         shell: cmd
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
 
       - name: CMake
         run: |
@@ -34,23 +34,15 @@ jobs:
         run: |
           cd resources
           ..\build\${{ matrix.build_type }}\c3c.exe compile-run examples\hello_world_many.c3
-          ..\build\${{ matrix.build_type }}\c3c.exe compile-run examples\time.c3
           ..\build\${{ matrix.build_type }}\c3c.exe compile-run 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 msvc_stack.c3
+          
 
       - name: Build testproject
         run: |
           cd resources/testproject
-          ..\..\build\${{ matrix.build_type }}\c3c.exe --debug-log --emit-llvm run hello_world_win32
-          dir build\llvm_ir
-          ..\..\build\${{ matrix.build_type }}\c3c.exe clean
-          dir build\llvm_ir
-          
+          ..\..\build\${{ matrix.build_type }}\c3c.exe --debug-log run hello_world_win32
 
       - name: Build testproject lib
         run: |
@@ -61,14 +53,6 @@ jobs:
         run: |
           build\${{ matrix.build_type }}\c3c.exe vendor-fetch raylib
 
-      - name: Try raylib
-        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
-
       - name: run compiler tests
         run: |
           cd test
@@ -77,12 +61,7 @@ jobs:
       - name: Compile run unit tests
         run: |
           cd test
-          ..\build\${{ matrix.build_type }}\c3c.exe compile-test unit -O1
-
-      - name: Test python script
-        run: |
-          py msvc_build_libraries.py --accept-license
-          dir msvc_sdk
+          ..\build\${{ matrix.build_type }}\c3c.exe compile-test unit -g1 --safe
 
       - name: upload artifacts
         uses: actions/upload-artifact@v3
@@ -92,7 +71,6 @@ jobs:
 
   build-msys2-mingw:
     runs-on: windows-latest
-    # if: ${{ false }}
     strategy:
       # Don't abort runners if a single one fails
       fail-fast: false
@@ -103,31 +81,29 @@ jobs:
       run:
         shell: msys2 {0}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
 
       - uses: msys2/setup-msys2@v2
         with:
           msystem: MINGW64
           update: true
-          install: git binutils mingw-w64-x86_64-clang mingw-w64-x86_64-ninja mingw-w64-x86_64-cmake mingw-w64-x86_64-toolchain mingw-w64-x86_64-python
+          install: git binutils mingw-w64-x86_64-ninja mingw-w64-x86_64-cmake mingw-w64-x86_64-toolchain mingw-w64-x86_64-python
       - shell: msys2 {0}
         run: |
-            pacman --noconfirm -U https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-llvm-18.1.1-3-any.pkg.tar.zst
-            pacman --noconfirm -U https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-lld-18.1.1-3-any.pkg.tar.zst
+            pacman --noconfirm -U https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-llvm-15.0.3-1-any.pkg.tar.zst
+            pacman --noconfirm -U https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-lld-15.0.3-1-any.pkg.tar.zst
       - name: CMake
         run: |
-          cmake -B build -G Ninja -DCMAKE_C_COMPILER=clang -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+          cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
           cmake --build build
 
       - name: Compile and run some examples
         run: |
           cd resources
           ../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 --test -g -O0 --threads 1 --target macos-x64 examples/constants.c3
 
       - name: Build testproject
         run: |
@@ -151,7 +127,7 @@ jobs:
 
   build-msys2-clang:
     runs-on: windows-latest
-    #if: ${{ false }}
+    if: ${{ false }}
     strategy:
       # Don't abort runners if a single one fails
       fail-fast: false
@@ -162,7 +138,7 @@ jobs:
       run:
         shell: msys2 {0}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
 
       - uses: msys2/setup-msys2@v2
         with:
@@ -179,11 +155,10 @@ jobs:
         run: |
           cd resources
           ../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 --test -g -O0 --threads 1 --target macos-x64 examples/constants.c3
+
       - name: Build testproject
         run: |
           cd resources/testproject
@@ -206,143 +181,10 @@ jobs:
       fail-fast: false
       matrix:
         build_type: [Release, Debug]
-        llvm_version: [15, 16, 17, 18, 19]
+        llvm_version: [15, 16, 17]
 
     steps:
-      - uses: actions/checkout@v4
-      - name: Install common deps
-        run: |
-          sudo apt-get install zlib1g zlib1g-dev python3 ninja-build curl
-
-      - 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}}" < 19 ]]; 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 libmlir-${{matrix.llvm_version}} \
-              libmlir-${{matrix.llvm_version}}-dev mlir-${{matrix.llvm_version}}-tools 
-          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 libmlir-${{matrix.llvm_version}} \
-              libmlir-${{matrix.llvm_version}}-dev mlir-${{matrix.llvm_version}}-tools 
-          fi
-      - name: CMake
-        if: matrix.llvm_version != 18
-        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}}
-          cmake --build build
-      - name: CMake18
-        if: matrix.llvm_version == 18
-        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=18.1
-          cmake --build build
-
-      - 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 examples/levenshtein.c3
-          ../build/c3c compile examples/load_world.c3
-          ../build/c3c compile 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 --system-linker=no linux_stack.c3
-          ../build/c3c compile-run linux_stack.c3
-
-      - 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: Build testproject direct linker
-        run: |
-          cd resources/testproject
-          ../../build/c3c run --debug-log --system-linker=no
-
-      - name: run compiler tests
-        run: |
-          cd test
-          python3 src/tester.py ../build/c3c test_suite/
-
-      - name: bundle_output
-        if: matrix.llvm_version == 16
-        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
-
-      - name: upload artifacts
-        if: matrix.llvm_version == 16
-        uses: actions/upload-artifact@v3
-        with:
-          name: c3-linux-${{matrix.build_type}}
-          path: c3-linux-${{matrix.build_type}}.tar.gz
-
-  build-linux-ubuntu20:
-    runs-on: ubuntu-20.04
-    strategy:
-      # Don't abort runners if a single one fails
-      fail-fast: false
-      matrix:
-        build_type: [Release, Debug]
-        llvm_version: [16]
-
-    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Install common deps
         run: |
           sudo apt-get install zlib1g zlib1g-dev python3 ninja-build curl
@@ -355,7 +197,7 @@ jobs:
           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 libpolly-${{matrix.llvm_version}}-dev
@@ -376,37 +218,15 @@ jobs:
       - 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 examples/mandelbrot.c3
-          ../build/c3c compile examples/plus_minus.c3
-          ../build/c3c compile examples/spectralnorm.c3
-          ../build/c3c compile examples/swap.c3
-          ../build/c3c compile examples/contextfree/guess_number.c3
-          ../build/c3c compile-run examples/hash.c3
-          ../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/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/base64.c3
-          ../build/c3c compile-run examples/binarydigits.c3
-          ../build/c3c compile-run examples/brainfk.c3
-          ../build/c3c compile-run examples/factorial_macro.c3
-          ../build/c3c compile-run examples/fasta.c3
-          ../build/c3c compile-run examples/process.c3
-          ../build/c3c compile-run --system-linker=no linux_stack.c3
-          ../build/c3c compile-run linux_stack.c3
 
       - name: Compile run unit tests
         run: |
           cd test
-          ../build/c3c compile-test unit
+          ../build/c3c compile-test unit -g1 --safe
 
       - name: Build testproject
         run: |
@@ -416,7 +236,7 @@ jobs:
       - name: Build testproject direct linker
         run: |
           cd resources/testproject
-          ../../build/c3c run --debug-log --system-linker=no
+          ../../build/c3c run --debug-log --forcelinker
 
       - name: run compiler tests
         run: |
@@ -424,20 +244,21 @@ 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
         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
+          tar czf c3-linux-${{matrix.build_type}}.tar.gz linux
 
       - name: upload artifacts
-        if: matrix.llvm_version == 16
+        if: matrix.llvm_version == env.LLVM_RELEASE_VERSION
         uses: actions/upload-artifact@v3
         with:
-          name: c3-ubuntu-20-${{matrix.build_type}}
-          path: c3-ubuntu-20-${{matrix.build_type}}.tar.gz
+          name: c3-linux-${{matrix.build_type}}
+          path: c3-linux-${{matrix.build_type}}.tar.gz
+
 
   build-mac:
     runs-on: macos-latest
@@ -446,11 +267,12 @@ jobs:
       fail-fast: false
       matrix:
         build_type: [Release, Debug]
-        llvm_version: [15, 16, 17]
+        llvm_version: [15]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: Download LLVM
         run: |
+          brew update 
           brew install llvm@${{ matrix.llvm_version }} ninja curl
           echo "/usr/local/opt/llvm@${{ matrix.llvm_version }}/bin" >> $GITHUB_PATH
           TMP_PATH=$(xcrun --show-sdk-path)/user/include
@@ -469,16 +291,14 @@ jobs:
         run: |
           cd resources
           ../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/process.c3
           ../build/c3c compile-run examples/load_world.c3
 
       - name: Compile run unit tests
         run: |
           cd test
-          ../build/c3c compile-test unit
+          ../build/c3c compile-test unit -g1 --safe
 
       - name: Build testproject
         run: |
@@ -488,7 +308,7 @@ jobs:
       - name: Build testproject direct linker
         run: |
           cd resources/testproject
-          ../../build/c3c run --debug-log --system-linker=no
+          ../../build/c3c run --debug-log --forcelinker
 
       - name: Build testproject lib
         run: |
@@ -523,7 +343,7 @@ jobs:
     if: github.ref == 'refs/heads/master'
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
       - name: delete tag
         continue-on-error: true
         uses: actions/github-script@v6
@@ -551,6 +371,8 @@ jobs:
       - 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: cp install_win_reqs.bat c3-windows-Release
+      - run: cp install_win_reqs.bat c3-windows-Debug
       - run: zip -r c3-windows-Release.zip c3-windows-Release
       - run: zip -r c3-windows-Debug.zip c3-windows-Debug
 
@@ -604,27 +426,6 @@ jobs:
           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:

CMakeLists.txt

@@ -10,20 +10,11 @@ endif()
 project(c3c VERSION ${CMAKE_MATCH_1})
 message("C3C version: ${CMAKE_PROJECT_VERSION}")
 
-if (NOT DEFINED CMAKE_INSTALL_LIBDIR)
-    if (MSVC)
-        set(CMAKE_INSTALL_LIBDIR "c:\\c3c\\lib")
-        set(CMAKE_INSTALL_BINDIR "c:\\c3c")
-    else ()
-        set(CMAKE_INSTALL_LIBDIR "/usr/local/lib/c3")
-        set(CMAKE_INSTALL_BINDIR "/usr/local/bin/c3c")
-    endif()
-endif ()
-
 # Enable fetching (for Windows)
 include(FetchContent)
 include(FeatureSummary)
 
+
 set(CMAKE_FIND_PACKAGE_SORT_ORDER NATURAL)
 set(CMAKE_FIND_PACKAGE_SORT_DIRECTION DEC)
 
@@ -34,24 +25,19 @@ set(CMAKE_CXX_STANDARD 17)
 if(MSVC)
     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /O2 /EHsc")
     set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /O2 /EHsc")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /Zi /EHa")
-    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Od /Zi /EHa")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Od /Zi /EHsc")
+    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Od /Zi /EHsc")
 else()
-    if (true)
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -fno-exceptions")
-        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -gdwarf-3 -fno-exceptions")
-        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -gdwarf-3 -O3 -fno-exceptions")
-        set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -gdwarf-3 -fno-exceptions")
-    else()
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -gdwarf-3 -O3 -fsanitize=undefined,address -fno-exceptions")
-        set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -gdwarf-3 -O1 -fsanitize=undefined,address -fno-exceptions")
-        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -gdwarf-3 -O3 -fsanitize=undefined,address -fno-exceptions")
-        set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -gdwarf-3 -O1 -fsanitize=undefined,address -fno-exceptions")
-        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=undefined,address -fno-exceptions")
-    endif()
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -fno-exceptions")
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -gdwarf-3 -fno-exceptions")
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -gdwarf-3 -O3 -fno-exceptions")
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -gdwarf-3 -fno-exceptions")
 endif()
-
-option(C3_LINK_DYNAMIC "link dynamically with LLVM/LLD libs")
+#set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O1 -fsanitize=undefined")
+#set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O1 -fsanitize=undefined")
+#set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -gdwarf-3 -O3 -fsanitize=undefined")
+#set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -gdwarf-3 -fsanitize=undefined")
+#set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=undefined")
 
 set(C3_LLVM_VERSION "auto" CACHE STRING "Use LLVM version [default: auto]")
 option(C3_USE_MIMALLOC "Use built-in mimalloc" OFF)
@@ -75,7 +61,7 @@ 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)
+    if (${C3_LLVM_VERSION} VERSION_LESS 15 OR ${C3_LLVM_VERSION} VERSION_GREATER 17)
         message(FATAL_ERROR "LLVM ${C3_LLVM_VERSION} is not supported!")
     endif()
 endif()
@@ -97,15 +83,15 @@ endif()
 
 if(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
     if (C3_LLVM_VERSION STREQUAL "auto")
-        set(C3_LLVM_VERSION "16")
+        set(C3_LLVM_VERSION "15")
     endif()
     FetchContent_Declare(
             LLVM_Windows
-            URL https://github.com/c3lang/win-llvm/releases/download/llvm_16_0_2/llvm-16.0.2-windows-amd64-msvc17-libcmt.7z
+            URL https://github.com/c3lang/win-llvm/releases/download/llvm_15_0_6/llvm-15.0.6-windows-amd64-msvc17-libcmt.7z
     )
     FetchContent_Declare(
             LLVM_Windows_debug
-            URL https://github.com/c3lang/win-llvm/releases/download/llvm_16_0_2/llvm-16.0.2-windows-amd64-msvc17-libcmt-dbg.7z
+            URL https://github.com/c3lang/win-llvm/releases/download/llvm_15_0_6/llvm-15.0.6-windows-amd64-msvc17-libcmt-dbg.7z
     )
     if(CMAKE_BUILD_TYPE STREQUAL "Debug")
         message("Loading Windows LLVM debug libraries, this may take a while...")
@@ -129,75 +115,54 @@ endif()
 message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
 message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
 message(STATUS "Libraries located in: ${LLVM_LIBRARY_DIRS}")
-
-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})
 
-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
-    )
-
-    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 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()
+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
+)
 
+llvm_map_components_to_libnames(llvm_libs ${LLVM_LINK_COMPONENTS})
 file(REMOVE_RECURSE ${CMAKE_BINARY_DIR}/lib)
 file(COPY ${CMAKE_SOURCE_DIR}/lib DESTINATION ${CMAKE_BINARY_DIR})
 
+
+# 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)
+
 if (${LLVM_PACKAGE_VERSION} VERSION_GREATER_EQUAL 16)
     find_library(LLD_LOONG NAMES libLLVMLoongArchCodeGen.lib libLLVMLoongArchAsmParser.lib libLLVMLoongArchCodeGen.a libLLVMLoongArchAsmParser.a PATHS ${LLVM_LIBRARY_DIRS} NO_DEFAULT_PATH)
     set(lld_libs
@@ -206,7 +171,12 @@ if (${LLVM_PACKAGE_VERSION} VERSION_GREATER_EQUAL 16)
         ${LLD_WASM}
         ${LLD_MINGW}
         ${LLD_ELF}
+        ${LLD_DRIVER}
+        ${LLD_READER_WRITER}
+        ${LLD_LOONG}
         ${LLD_MACHO}
+        ${LLD_YAML}
+        ${LLD_CORE}
         )
 else()
     set(lld_libs
@@ -215,7 +185,11 @@ else()
         ${LLD_WASM}
         ${LLD_MINGW}
         ${LLD_ELF}
+        ${LLD_DRIVER}
+        ${LLD_READER_WRITER}
         ${LLD_MACHO}
+        ${LLD_YAML}
+        ${LLD_CORE}
         )
 endif()
 
@@ -236,15 +210,17 @@ add_executable(c3c
         src/build/project_creation.c
         src/compiler/ast.c
         src/compiler/bigint.c
+        src/compiler/c_abi_internal.h
         src/compiler/codegen_general.c
         src/compiler/compiler.c
         src/compiler/compiler.h
         src/compiler/context.c
         src/compiler/copying.c
         src/compiler/diagnostics.c
+        src/compiler/dwarf.h
+        src/compiler/enums.h
         src/compiler/float.c
         src/compiler/headers.c
-        src/compiler/json_output.c
         src/compiler/lexer.c
         src/compiler/libraries.c
         src/compiler/linker.c
@@ -410,10 +386,12 @@ else()
     target_link_options(c3c PRIVATE -pthread)
     target_compile_options(c3c PRIVATE -pthread -Wall -Werror -Wno-unknown-pragmas -Wno-unused-result
             -Wno-unused-function -Wno-unused-variable -Wno-unused-parameter)
+    if (WIN32)
+        target_compile_definitions(c3c PRIVATE USE_PTHREAD=1)
+    endif()
 endif()
 
 
 install(TARGETS c3c DESTINATION bin)
-install(DIRECTORY lib/ DESTINATION lib/c3)
 
 feature_summary(WHAT ALL)

README.md

@@ -35,7 +35,7 @@ whole new language.
 The following code shows [generic modules](http://www.c3-lang.org/generics/) (more examples can be found at http://www.c3-lang.org/examples/). 
 
 ```c++
-module stack (<Type>);
+module stack <Type>;
 // Above: the parameterized type is applied to the entire module.
 
 struct Stack
@@ -54,8 +54,7 @@ fn void Stack.push(Stack* this, Type element)
     if (this.capacity == this.size)
     {
         this.capacity *= 2;
-		if (this.capacity < 16) this.capacity = 16;
-        this.elems = realloc(this.elems, Type.sizeof * this.capacity);
+        this.elems = mem::realloc(this.elems, Type.sizeof * this.capacity);
     }
     this.elems[this.size++] = element;
 }
@@ -79,20 +78,20 @@ import stack;
 
 // Define our new types, the first will implicitly create 
 // a complete copy of the entire Stack module with "Type" set to "int"
-def IntStack = Stack(<int>);
+define IntStack = Stack<int>;
 // The second creates another copy with "Type" set to "double"
-def DoubleStack = Stack(<double>);
+define DoubleStack = Stack<double>;
 
-// If we had added "define IntStack2 = Stack(<int>)"
+// If we had added "define IntStack2 = Stack<int>"
 // no additional copy would have been made (since we already
-// have an parameterization of Stack(<int>)) so it would
+// have an parameterization of Stack<int>) so it would
 // be same as declaring IntStack2 an alias of IntStack
 
 // Importing an external C function is straightforward
 // here is an example of importing libc's printf:
 extern fn int printf(char* format, ...);
 
-fn void main()
+fn void test()
 {
     IntStack stack;
     // Note that C3 uses zero initialization by default
@@ -112,12 +111,12 @@ fn void main()
     dstack.push(2.3);
     dstack.push(3.141);
     dstack.push(1.1235);
-    // Prints pop: 1.123500
+    // Prints pop: 1.1235
     printf("pop: %f\n", dstack.pop());
 }
 ```
 
-### In what ways does C3 differ from C?
+### In what ways do C3 differ from C?
 
 - No mandatory header files
 - New semantic macro system
@@ -131,15 +130,17 @@ fn void main()
 - Value methods
 - Associated enum data
 - No preprocessor
-- Less undefined behaviour and added runtime checks in "safe" mode
+- Less undefined behaviour and runtime checks in "safe" mode
 - Limited operator overloading to enable userland dynamic arrays
 - Optional pre and post conditions
 
 ### Current status
 
-The current stable version of the compiler is **version 0.5**.
+The current version of the compiler is alpha release 0.4.
 
-The upcoming 0.6 release will focus on expanding the standard library.
+Design work on C3 complete aside from fleshing out details, such as
+inline asm. As the standard library work progresses, changes and improvements
+to the language will happen continuously.
 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) 
@@ -147,38 +148,7 @@ or discuss C3 on its dedicated Discord: [https://discord.gg/qN76R87](https://dis
 
 The compiler is currently verified to compile on Linux, Windows and MacOS.
 
-**Support matrix**
 
-| Platform                 | Native C3 compiler available? | Target supported        | Stack trace | Threads  | Sockets  | Inline asm |
-|--------------------------|-------------------------------|-------------------------|-------------|----------|----------|------------|
-| Win32 x64                | Yes                           | Yes + cross compilation | Yes         | Yes      | Yes      | Yes*       |
-| Win32 Aarch64            | Untested                      | Untested                | Untested    | Untested | Untested | Yes*       |
-| MacOS x64                | Yes                           | Yes + cross compilation | Yes         | Yes      | Yes      | Yes*       |
-| MacOS Aarch64            | Yes                           | Yes + cross compilation | Yes         | Yes      | Yes      | Yes*       |
-| iOS Aarch64              | No                            | Untested                | Untested    | Yes      | Yes      | Yes*       |
-| Linux x86                | Yes                           | Yes                     | Yes         | Yes      | Yes      | Yes*       |
-| Linux x64                | Yes                           | Yes                     | Yes         | Yes      | Yes      | Yes*       |
-| Linux Aarch64            | Yes                           | Yes                     | Yes         | Yes      | Yes      | Yes*       |
-| Linux Riscv32            | Yes                           | Yes                     | Yes         | Yes      | Yes      | Untested   |
-| Linux Riscv64            | Yes                           | Yes                     | Yes         | Yes      | Yes      | Untested   |
-| ELF freestanding x86     | No                            | Untested                | No          | No       | No       | Yes*       |
-| ELF freestanding x64     | No                            | Untested                | No          | No       | No       | Yes*       |
-| ELF freestanding Aarch64 | No                            | Untested                | No          | No       | No       | Yes*       |
-| ELF freestanding Riscv64 | No                            | Untested                | No          | No       | No       | Untested   |
-| ELF freestanding Riscv32 | No                            | Untested                | No          | No       | No       | Untested   |
-| FreeBSD x86              | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
-| FreeBSD x64              | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
-| NetBSD x86               | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
-| NetBSD x64               | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
-| OpenBSD x86              | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
-| OpenBSD x64              | Untested                      | Untested                | No          | Yes      | Untested | Yes*       |
-| MCU x86                  | No                            | Untested                | No          | No       | No       | Yes*       |
-| Wasm32                   | No                            | Yes                     | No          | No       | No       | No         |
-| Wasm64                   | No                            | Untested                | No          | No       | No       | No         |
-
-*\* Inline asm is still a work in progress*
-
-More platforms will be supported in the future.
 
 #### What can you help with?
 
@@ -213,18 +183,8 @@ More platforms will be supported in the future.
 4. Run `./c3c`.
 
 #### Installing on Arch Linux
-There is an AUR package for the c3c compiler : [c3c-git](https://aur.archlinux.org/packages/c3c-git).
-
-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.
-
-You can use your AUR package manager:
-```sh
-paru -S c3c-git
-# or yay -S c3c-git
-# or aura -A c3c-git
-```
-
-Or clone it manually:
+There is an AUR package for the c3c compiler : [c3c-git](https://aur.archlinux.org/packages/c3c-git)  
+You can use your AUR package manager or clone it manually:
 ```sh
 git clone https://aur.archlinux.org/c3c-git.git
 cd c3c-git
@@ -319,21 +279,6 @@ You should now have a `c3c` executable.
 You can try it out by running some sample code: `./c3c compile ../resources/examples/hash.c3`
 
 
-#### 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`
-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`
-4. Create a build directory: `mkdir build`
-5. Enter the build directory: `cd build`
-6. Create the CMake build cache: `cmake ..`
-7. Build: `cmake --build .`
-
-Your c3c executable should have compiled properly. You may want to test it: `./c3c compile ../resources/examples/hash.c3`  
-For a sytem-wide installation, run the following as root: `cmake --install .`
-
-
 #### Compiling on other Linux / Unix variants
 
 1. Install CMake.
@@ -364,6 +309,6 @@ Editor plugins can be found at https://github.com/c3lang/editor-plugins.
 1. Write the test, either adding to existing test files in `/test/unit/` or add
    a new file. (If testing the standard library, put it in the `/test/unit/stdlib/` subdirectory).
 2. Make sure that the test functions have the `@test` attribute. 
-3. Run tests and see that they pass. (Recommended settings: `c3c compile-test -O0 test/unit`.
+3. Run tests and see that they pass. (Recommended settings: `c3c compile-test --safe -g1 -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.
+4. Make a pull request for the new tests.

build-with-docker.sh

@@ -21,6 +21,7 @@ if type podman 2>/dev/null >/dev/null; then
 fi
 
 if [ $config == "Debug" ]; then
+echo "debug???"
     CMAKE_BUILD_TYPE=Debug
 else
     CMAKE_BUILD_TYPE="$config"

install_win_reqs.bat

@@ -0,0 +1,17 @@
+@echo off
+
+set DOWNLOAD_URL=https://aka.ms/vs/17/release
+
+mkdir tmp 2> NUL
+
+if not exist "tmp\vs_buildtools.exe" (
+    bitsadmin /transfer /download /priority foreground %DOWNLOAD_URL%/vs_buildtools.exe %CD%\tmp\vs_buildtools.exe
+)
+
+echo Preparing Build Tools, please wait...
+tmp\vs_BuildTools.exe --quiet --wait --layout tmp\ --add Microsoft.VisualStudio.Component.Windows10SDK.19041
+
+echo Installing Build Tools, please wait...
+tmp\vs_BuildTools.exe --quiet --wait --noweb --add Microsoft.VisualStudio.Component.Windows10SDK.19041
+
+REM rmdir tmp /s /q

lib/std/ascii.c3

@@ -53,10 +53,6 @@ fn bool char.is_blank(char c) => is_blank_m(c);
 fn bool char.is_cntrl(char c) => is_cntrl_m(c);
 fn char char.to_lower(char c) => (char)to_lower_m(c);
 fn char char.to_upper(char c) => (char)to_upper_m(c);
-/**
- * @require c.is_xdigit()
- **/
-fn char char.from_hex(char c) => c.is_digit() ? c - '0' : 10 + (c | 0x20) - 'a';
 
 fn bool uint.in_range(uint c, uint start, uint len) => in_range_m(c, start, len);
 fn bool uint.is_lower(uint c) => is_lower_m(c);

lib/std/atomic.c3

@@ -1,520 +1,5 @@
-// Copyright (c) 2023 Eduardo José Gómez Hernández. All rights reserved.
+// Copyright (c) 2021 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::atomic::types(<Type>);
-
-struct Atomic
-{
-	Type data;
-}
-
-/**
- * Loads data atomically, by default this uses SEQ_CONSISTENT ordering.
- *
- * @param ordering "The ordering, cannot be release or acquire-release."
- * @require ordering != RELEASE && ordering != ACQUIRE_RELEASE : "Release and acquire-release are not valid for load"
- **/
-macro Type Atomic.load(&self, AtomicOrdering ordering = SEQ_CONSISTENT)
-{
-	Type* data = &self.data;
-	switch(ordering)
-	{
-		case NOT_ATOMIC: return $$atomic_load(data, false, AtomicOrdering.NOT_ATOMIC.ordinal);
-		case UNORDERED: return $$atomic_load(data, false, AtomicOrdering.UNORDERED.ordinal);
-		case RELAXED: return $$atomic_load(data, false, AtomicOrdering.RELAXED.ordinal);
-		case ACQUIRE: return $$atomic_load(data, false, AtomicOrdering.ACQUIRE.ordinal);
-		case SEQ_CONSISTENT: return $$atomic_load(data, false, AtomicOrdering.SEQ_CONSISTENT.ordinal);
-		case ACQUIRE_RELEASE:
-		case RELEASE: unreachable("Invalid ordering.");
-	}
-}
-/**
- * Stores data atomically, by default this uses SEQ_CONSISTENT ordering.
- *
- * @param ordering "The ordering, cannot be acquire or acquire-release."
- * @require ordering != ACQUIRE && ordering != ACQUIRE_RELEASE : "Acquire and acquire-release are not valid for store"
- **/
-macro void Atomic.store(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
-{
-	Type* data = &self.data;
-	switch(ordering) 
-	{
-		case NOT_ATOMIC: $$atomic_store(data, value, false, AtomicOrdering.NOT_ATOMIC.ordinal);
-		case UNORDERED: $$atomic_store(data, value, false, AtomicOrdering.UNORDERED.ordinal);
-		case RELAXED: $$atomic_store(data, value, false, AtomicOrdering.RELAXED.ordinal);
-		case RELEASE: $$atomic_store(data, value, false, AtomicOrdering.RELEASE.ordinal);
-		case SEQ_CONSISTENT: $$atomic_store(data, value, false, AtomicOrdering.SEQ_CONSISTENT.ordinal);
-		case ACQUIRE_RELEASE:
-		case ACQUIRE: unreachable("Invalid ordering.");
-	}
-}
-
-macro Type Atomic.add(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
-{
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_add, data, value, ordering);
-}
-
-macro Type Atomic.sub(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
-{
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_sub, data, value, ordering);
-}
-
-macro Type Atomic.mul(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
-{
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_mul, data, value, ordering);
-}
-
-macro Type Atomic.div(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
-{
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_div, data, value, ordering);
-}
-
-macro Type Atomic.max(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
-{
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_div, data, value, ordering);
-}
-
-macro Type Atomic.min(&self, Type value, AtomicOrdering ordering = SEQ_CONSISTENT)
-{
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_min, data, value, ordering);
-}
-
-macro Type Atomic.or(&self, uint value, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))
-{
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_or, data, value, ordering);
-}
-
-fn Type Atomic.xor(&self, uint value, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))
-{
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_xor, data, value, ordering);
-}
-
-macro Type Atomic.and(&self, uint value, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))
-{
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_and, data, value, ordering);
-}
-
-macro Type Atomic.shift_right(&self, uint amount, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))
-{
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_shift_right, data, amount, ordering);
-}
-
-macro Type Atomic.shift_left(&self, uint amount, AtomicOrdering ordering = SEQ_CONSISTENT) @if(!types::is_float(Type))
-{
-	Type* data = &self.data;
-	return @atomic_exec(atomic::fetch_shift_left, data, amount, ordering);
-}
-
-macro @atomic_exec(#func, data, value, ordering) @local
-{
-	switch(ordering) 
-	{
-		case RELAXED: return #func(data, value, RELAXED);
-		case ACQUIRE: return #func(data, value, ACQUIRE);
-		case RELEASE: return #func(data, value, RELEASE);
-		case ACQUIRE_RELEASE: return #func(data, value, ACQUIRE_RELEASE);
-		case SEQ_CONSISTENT: return #func(data, value, SEQ_CONSISTENT);
-		default: assert(false, "Ordering may not be non-atomic or unordered.");
-	}
-}
-
 module std::atomic;
-import std::math;
 
-/**
- * @param [&in] ptr "the variable or dereferenced pointer to the data."
- * @param [in] y "the value to be added to ptr."
- * @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
- * @return "returns the old value of ptr"
- *
- * @require !$alignment || math::is_power_of_2($alignment) "Alignment must be a power of two."
- * @require types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- * @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
- **/
-macro fetch_add(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
-{
-	$if $alignment == 0:
-		$alignment = $typeof(*ptr).sizeof;
-	$endif
-	return $$atomic_fetch_add(ptr, y, $volatile, $ordering.ordinal, $alignment);
-}
-
-/**
- * @param [&in] ptr "the variable or dereferenced pointer to the data."
- * @param [in] y "the value to be added to ptr."
- * @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
- * @return "returns the old value of ptr"
- * 
- * @require !$alignment || math::is_power_of_2($alignment) "Alignment must be a power of two."
- * @require types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- * @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
- **/
-macro fetch_sub(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
-{
-	$if $alignment == 0:
-		$alignment = $typeof(*ptr).sizeof;
-	$endif
-	return $$atomic_fetch_sub(ptr, y, $volatile, $ordering.ordinal, $alignment);
-}
-
-/**
- * @param [&in] ptr "the variable or dereferenced pointer to the data."
- * @param [in] y "the value to be added to ptr."
- * @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
- * @return "returns the old value of ptr"
- * 
- * @require types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- * @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
- **/
-macro fetch_mul(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
-{
-	var $load_ordering = $ordering;
-	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
-	$endif
-	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
-
-	$StorageType* storage_ptr = ($StorageType*)ptr;
-
-	$typeof(*ptr) old_value;
-	$typeof(*ptr) new_value;
-
-	$StorageType storage_old_value;
-	$StorageType storage_new_value;
-
-
-	do {
-		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
-		old_value = bitcast(storage_old_value, $typeof(*ptr));
-		new_value = old_value * y;
-		storage_new_value = bitcast(new_value, $StorageType);
-	} while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
-
-	return old_value;
-}
-
-/**
- * @param [&in] ptr "the variable or dereferenced pointer to the data."
- * @param [in] y "the value to be added to ptr."
- * @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
- * @return "returns the old value of ptr"
- * 
-* @require types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
-* @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
- **/
-macro fetch_div(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
-{
-	var $load_ordering = $ordering;
-	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
-	$endif
-	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
-
-	$StorageType* storage_ptr = ($StorageType*)ptr;
-
-	$typeof(*ptr) old_value;
-	$typeof(*ptr) new_value;
-
-	$StorageType storage_old_value;
-	$StorageType storage_new_value;
-	
-	do {
-		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
-		old_value = bitcast(storage_old_value, $typeof(*ptr));
-		new_value = old_value / y;
-		storage_new_value = bitcast(new_value, $StorageType);
-	} while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
-
-	return old_value;
-}
-
-/**
- * @param [&in] ptr "the variable or dereferenced pointer to the data."
- * @param [in] y "the value to be added to ptr."
- * @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
- * @return "returns the old value of ptr"
- * 
- * @require !$alignment || math::is_power_of_2($alignment) "Alignment must be a power of two."
- * @require types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- * @require types::is_int($typeof(y)) "The value for or must be an int"
- * @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
- **/
-macro fetch_or(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
-{
-	$if	types::is_int($typeof(*ptr)):
-		return $$atomic_fetch_or(ptr, y, $volatile, $ordering.ordinal, $alignment);
-	$endif
-
-	var $load_ordering = $ordering;
-	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
-	$endif
-	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
-
-	$StorageType* storage_ptr = ($StorageType*)ptr;
-
-	$typeof(*ptr) old_value;
-	$typeof(*ptr) new_value;
-
-	$StorageType storage_old_value;
-	$StorageType storage_new_value;
-	$StorageType storage_y = ($StorageType)y;
-	
-	do {
-		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
-		old_value = bitcast(storage_old_value, $typeof(*ptr));
-		new_value = storage_old_value | storage_y;
-		storage_new_value = bitcast(new_value, $StorageType);
-	} while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
-
-	return old_value;
-}
-
-/**
- * @param [&in] ptr "the variable or dereferenced pointer to the data."
- * @param [in] y "the value to be added to ptr."
- * @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
- * @return "returns the old value of ptr"
- * 
- * @require !$alignment || math::is_power_of_2($alignment) "Alignment must be a power of two."
- * @require types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- * @require types::is_int($typeof(y)) "The value for or must be an int"
- * @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
- **/
-macro fetch_xor(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
-{
-	$if	types::is_int($typeof(*ptr)):
-		return $$atomic_fetch_xor(ptr, y, $volatile, $ordering.ordinal, $alignment);
-	$endif
-
-	var $load_ordering = $ordering;
-	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
-	$endif
-	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
-
-	$StorageType* storage_ptr = ($StorageType*)ptr;
-
-	$typeof(*ptr) old_value;
-	$typeof(*ptr) new_value;
-
-	$StorageType storage_old_value;
-	$StorageType storage_new_value;
-	$StorageType storage_y = ($StorageType)y;
-	
-	do {
-		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
-		old_value = bitcast(storage_old_value, $typeof(*ptr));
-		new_value = storage_old_value ^ storage_y;
-		storage_new_value = bitcast(new_value, $StorageType);
-	} while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
-
-	return old_value;
-}
-
-/**
- * @param [&in] ptr "the variable or dereferenced pointer to the data."
- * @param [in] y "the value to be added to ptr."
- * @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
- * @return "returns the old value of ptr"
- * 
- * @require !$alignment || math::is_power_of_2($alignment) "Alignment must be a power of two."
- * @require types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- * @require types::is_int($typeof(y)) "The value for or must be an int"
- * @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
- **/
-macro fetch_and(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
-{
-	$if	types::is_int($typeof(*ptr)):
-		return $$atomic_fetch_and(ptr, y, $volatile, $ordering.ordinal, $alignment);
-	$endif
-
-	var $load_ordering = $ordering;
-	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
-	$endif
-	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
-
-	$StorageType* storage_ptr = ($StorageType*)ptr;
-
-	$typeof(*ptr) old_value;
-	$typeof(*ptr) new_value;
-
-	$StorageType storage_old_value;
-	$StorageType storage_new_value;
-	$StorageType storage_y = ($StorageType)y;
-	
-	do {
-		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
-		old_value = bitcast(storage_old_value, $typeof(*ptr));
-		new_value = storage_old_value & storage_y;
-		storage_new_value = bitcast(new_value, $StorageType);
-	} while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
-
-	return old_value;
-}
-
-/**
- * @param [&in] ptr "the variable or dereferenced pointer to the data."
- * @param [in] y "the value to be added to ptr."
- * @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
- * @return "returns the old value of ptr"
- * 
- * @require types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- * @require types::is_int($typeof(y)) "The value for or must be an int"
- * @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
- **/
-macro fetch_shift_right(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
-{
-	var $load_ordering = $ordering;
-	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
-	$endif
-	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
-
-	$StorageType* storage_ptr = ($StorageType*)ptr;
-
-	$typeof(*ptr) old_value;
-	$typeof(*ptr) new_value;
-
-	$StorageType storage_old_value;
-	$StorageType storage_new_value;
-	$StorageType storage_y = ($StorageType)y;
-	
-	do {
-		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
-		old_value = bitcast(storage_old_value, $typeof(*ptr));
-		new_value = storage_old_value >> storage_y;
-		storage_new_value = bitcast(new_value, $StorageType);
-	} while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
-
-	return old_value;
-}
-
-/**
- * @param [&in] ptr "the variable or dereferenced pointer to the data."
- * @param [in] y "the value to be added to ptr."
- * @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
- * @return "returns the old value of ptr"
- * 
- * @require types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- * @require types::is_int($typeof(y)) "The value for or must be an int"
- * @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
- **/
-macro fetch_shift_left(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT)
-{
-	var $load_ordering = $ordering;
-	$if $ordering == RELEASE || $ordering == ACQUIRE_RELEASE:
-	    $load_ordering = AtomicOrdering.SEQ_CONSISTENT;
-	$endif
-	
-	var $StorageType = $typefrom(types::lower_to_atomic_compatible_type($typeof(*ptr)));
-
-	$StorageType* storage_ptr = ($StorageType*)ptr;
-
-	$typeof(*ptr) old_value;
-	$typeof(*ptr) new_value;
-
-	$StorageType storage_old_value;
-	$StorageType storage_new_value;
-	$StorageType storage_y = ($StorageType)y;
-	
-	do {
-		storage_old_value = $$atomic_load(storage_ptr, false, $load_ordering.ordinal);
-		old_value = bitcast(storage_old_value, $typeof(*ptr));
-		new_value = storage_old_value << storage_y;
-		storage_new_value = bitcast(new_value, $StorageType);
-	} while (mem::compare_exchange(storage_ptr, storage_old_value, storage_new_value, $ordering, $load_ordering) != storage_old_value);
-
-	return old_value;
-}
-
-/**
- * @param [&in] ptr "the variable or dereferenced pointer to the data."
- * @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
- * @return "returns the old value of ptr"
- * 
- * @require types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- * @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
- **/
-macro flag_set(ptr, AtomicOrdering $ordering = SEQ_CONSISTENT)
-{
-	$typeof(*ptr) old_value;
-	$typeof(*ptr) new_value = true;
-
-	do {
-		old_value = $$atomic_load(ptr, false, $ordering.ordinal);
-	} while (mem::compare_exchange(ptr, old_value, new_value, $ordering, $load_ordering) != old_value);
-	
-	return old_value;
-}
-
-/**
- * @param [&in] ptr "the variable or dereferenced pointer to the data."
- * @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
- * @return "returns the old value of ptr"
- * 
- * @require types::is_int($typeof(*ptr)) "Only integer pointers may be used."
- * @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
- **/
-macro flag_clear(ptr, AtomicOrdering $ordering = SEQ_CONSISTENT)
-{
-	$typeof(*ptr) old_value;
-	$typeof(*ptr) new_value = false;
-
-	do {
-		old_value = $$atomic_load(ptr, false, $ordering.ordinal);
-	} while (mem::compare_exchange(ptr, old_value, new_value, $ordering, $load_ordering) != old_value);
-
-	return old_value;
-}
-
-/**
- * @param [&in] ptr "the variable or dereferenced pointer to the data."
- * @param [in] y "the value to be added to ptr."
- * @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
- * @return "returns the old value of ptr"
- * 
- * @require types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- * @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
- **/
-macro fetch_max(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
-{
-	$if $alignment == 0:
-		$alignment = $typeof(*ptr).sizeof;
-	$endif
-	return $$atomic_fetch_max(ptr, y, $volatile, $ordering.ordinal, $alignment);
-}
-
-/**
- * @param [&in] ptr "the variable or dereferenced pointer to the data."
- * @param [in] y "the value to be added to ptr."
- * @param $ordering "atomic ordering of the load, defaults to SEQ_CONSISTENT"
- * @return "returns the old value of ptr"
- * 
- * @require types::is_int($typeof(*ptr)) || types::is_float($typeof(*ptr)) "Only integer/float pointers may be used."
- * @require $ordering != AtomicOrdering.NOT_ATOMIC && $ordering != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
- **/
-macro fetch_min(ptr, y, AtomicOrdering $ordering = SEQ_CONSISTENT, bool $volatile = false, usz $alignment = 0)
-{
-	$if $alignment == 0:
-		$alignment = $typeof(*ptr).sizeof;
-	$endif
-	return $$atomic_fetch_min(ptr, y, $volatile, $ordering.ordinal, $alignment);
-}

lib/std/atomic_nolibc.c3

@@ -1,63 +0,0 @@
-// Copyright (c) 2023 Eduardo José Gómez Hernández. 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::atomic;
-
-macro @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, $success, failure, $alignment) {
-	switch(failure)
-	{
-		case AtomicOrdering.RELAXED.ordinal: return $$compare_exchange(ptr, expected, desired, false, false, $success, AtomicOrdering.RELAXED.ordinal, $alignment);
-		case AtomicOrdering.ACQUIRE.ordinal: return $$compare_exchange(ptr, expected, desired, false, false, $success, AtomicOrdering.ACQUIRE.ordinal, $alignment);
-		case AtomicOrdering.SEQ_CONSISTENT.ordinal: return $$compare_exchange(ptr, expected, desired, false, false, $success, AtomicOrdering.SEQ_CONSISTENT.ordinal, $alignment);
-		default: assert(false, "Unrecognized failure ordering");
-	}
-	return 0;
-}
-
-macro @__atomic_compare_exchange_ordering_success(ptr, expected, desired, success, failure, $alignment)
-{
-	switch(success)
-	{
-		case AtomicOrdering.RELAXED.ordinal: return @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, AtomicOrdering.RELAXED.ordinal, failure, $alignment);
-		case AtomicOrdering.ACQUIRE.ordinal: return @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, AtomicOrdering.ACQUIRE.ordinal, failure, $alignment);
-		case AtomicOrdering.RELEASE.ordinal: return @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, AtomicOrdering.RELEASE.ordinal, failure, $alignment);
-		case AtomicOrdering.ACQUIRE_RELEASE.ordinal: return @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, AtomicOrdering.ACQUIRE_RELEASE.ordinal, failure, $alignment);
-		case AtomicOrdering.SEQ_CONSISTENT.ordinal: return @__atomic_compare_exchange_ordering_failure(ptr, expected, desired, AtomicOrdering.SEQ_CONSISTENT.ordinal, failure, $alignment);
-		default: assert(false, "Unrecognized success ordering");
-	}
-	return 0;
-}
-
-fn CInt __atomic_compare_exchange(CInt size, any* ptr, any* expected, any* desired, CInt success, CInt failure) @extern("__atomic_compare_exchange") @export
-{
-	switch (size)
-	{
-		case 1:
-			char* pt = (char*)ptr;
-			char ex = *(char*)expected;
-			char de = *(char*)desired;
-			if (ex == @__atomic_compare_exchange_ordering_success(pt, ex, de, success, failure, 1)) return 1;
-		case 2:
-			short* pt = (short*)ptr;
-			short ex = *(short*)expected;
-			short de = *(short*)desired;
-			if (ex == @__atomic_compare_exchange_ordering_success(pt, ex, de, success, failure, 2)) return 1;
-		case 4:
-			int* pt = (int*)ptr;
-			int ex = *(int*)expected;
-			int de = *(int*)desired;
-			if (ex == @__atomic_compare_exchange_ordering_success(pt, ex, de, success, failure, 4)) return 1;
-		case 8:
-			$if iptr.sizeof >= 8:
-				long* pt = (long*)ptr;
-				long ex = *(long*)expected;
-				long de = *(long*)desired;
-				if (ex == @__atomic_compare_exchange_ordering_success(pt, ex, de, success, failure, 8)) return 1;
-			$else
-				nextcase;
-			$endif
-		default:
-			assert(false, "Unsuported size (%d) for atomic_compare_exchange", size);
-	}
-	return 0;
-}

lib/std/bits.c3

@@ -1,5 +1,6 @@
 module std::bits;
 
+
 /**
  * @require types::is_intlike($typeof(i)) `The input must be an integer or integer vector`
  **/
@@ -10,162 +11,163 @@ macro reverse(i) => $$bitreverse(i);
  **/
 macro bswap(i) @builtin => $$bswap(i);
 
-macro uint[<*>].popcount(self) => $$popcount(self);
-macro uint[<*>].ctz(self) => $$ctz(self);
-macro uint[<*>].clz(self) => $$clz(self);
-macro uint[<*>] uint[<*>].fshl(hi, uint[<*>] lo, uint[<*>] shift) => $$fshl(hi, lo, shift);
-macro uint[<*>] uint[<*>].fshr(hi, uint[<*>] lo, uint[<*>] shift) => $$fshr(hi, lo, shift);
-macro uint[<*>] uint[<*>].rotl(self, uint[<*>] shift) => $$fshl(self, self, shift);
-macro uint[<*>] uint[<*>].rotr(self, uint[<*>] shift) => $$fshr(self, self, shift);
 
-macro int[<*>].popcount(self) => $$popcount(self);
-macro int[<*>].ctz(self) => $$ctz(self);
-macro int[<*>].clz(self) => $$clz(self);
-macro int[<*>] int[<*>].fshl(hi, int[<*>] lo, int[<*>] shift) => $$fshl(hi, lo, shift);
-macro int[<*>] int[<*>].fshr(hi, int[<*>] lo, int[<*>] shift) => $$fshr(hi, lo, shift);
-macro int[<*>] int[<*>].rotl(self, int[<*>] shift) => $$fshl(self, self, shift);
-macro int[<*>] int[<*>].rotr(self, int[<*>] shift) => $$fshr(self, self, shift);
+macro uint[<*>].popcount(uint[<*>] i) => $$popcount(i);
+macro uint[<*>].ctz(uint[<*>] i) => $$ctz(i);
+macro uint[<*>].clz(uint[<*>] i) => $$clz(i);
+macro uint[<*>] uint[<*>].fshl(uint[<*>] hi, uint[<*>] lo, uint[<*>] shift) => $$fshl(hi, lo, shift);
+macro uint[<*>] uint[<*>].fshr(uint[<*>] hi, uint[<*>] lo, uint[<*>] shift) => $$fshr(hi, lo, shift);
+macro uint[<*>] uint[<*>].rotl(uint[<*>] i, uint[<*>] shift) => $$fshl(i, i, shift);
+macro uint[<*>] uint[<*>].rotr(uint[<*>] i, uint[<*>] shift) => $$fshr(i, i, shift);
 
-macro ushort[<*>].popcount(self) => $$popcount(self);
-macro ushort[<*>].ctz(self) => $$ctz(self);
-macro ushort[<*>].clz(self) => $$clz(self);
-macro ushort[<*>] ushort[<*>].fshl(hi, ushort[<*>] lo, ushort[<*>] shift) => $$fshl(hi, lo, shift);
-macro ushort[<*>] ushort[<*>].fshr(hi, ushort[<*>] lo, ushort[<*>] shift) => $$fshr(hi, lo, shift);
-macro ushort[<*>] ushort[<*>].rotl(self, ushort[<*>] shift) => $$fshl(self, self, shift);
-macro ushort[<*>] ushort[<*>].rotr(self, ushort[<*>] shift) => $$fshr(self, self, shift);
+macro int[<*>].popcount(int[<*>] i) => $$popcount(i);
+macro int[<*>].ctz(int[<*>] i) => $$ctz(i);
+macro int[<*>].clz(int[<*>] i) => $$clz(i);
+macro int[<*>] int[<*>].fshl(int[<*>] hi, int[<*>] lo, int[<*>] shift) => $$fshl(hi, lo, shift);
+macro int[<*>] int[<*>].fshr(int[<*>] hi, int[<*>] lo, int[<*>] shift) => $$fshr(hi, lo, shift);
+macro int[<*>] int[<*>].rotl(int[<*>] i, int[<*>] shift) => $$fshl(i, i, shift);
+macro int[<*>] int[<*>].rotr(int[<*>] i, int[<*>] shift) => $$fshr(i, i, shift);
 
-macro short[<*>].popcount(self) => $$popcount(self);
-macro short[<*>].ctz(self) => $$ctz(self);
-macro short[<*>].clz(self) => $$clz(self);
-macro short[<*>] short[<*>].fshl(hi, short[<*>] lo, short[<*>] shift) => $$fshl(hi, lo, shift);
-macro short[<*>] short[<*>].fshr(hi, short[<*>] lo, short[<*>] shift) => $$fshr(hi, lo, shift);
-macro short[<*>] short[<*>].rotl(self, short[<*>] shift) => $$fshl(self, self, shift);
-macro short[<*>] short[<*>].rotr(self, short[<*>] shift) => $$fshr(self, self, shift);
+macro ushort[<*>].popcount(ushort[<*>] i) => $$popcount(i);
+macro ushort[<*>].ctz(ushort[<*>] i) => $$ctz(i);
+macro ushort[<*>].clz(ushort[<*>] i) => $$clz(i);
+macro ushort[<*>] ushort[<*>].fshl(ushort[<*>] hi, ushort[<*>] lo, ushort[<*>] shift) => $$fshl(hi, lo, shift);
+macro ushort[<*>] ushort[<*>].fshr(ushort[<*>] hi, ushort[<*>] lo, ushort[<*>] shift) => $$fshr(hi, lo, shift);
+macro ushort[<*>] ushort[<*>].rotl(ushort[<*>] i, ushort[<*>] shift) => $$fshl(i, i, shift);
+macro ushort[<*>] ushort[<*>].rotr(ushort[<*>] i, ushort[<*>] shift) => $$fshr(i, i, shift);
 
-macro char[<*>].popcount(self) => $$popcount(self);
-macro char[<*>].ctz(self) => $$ctz(self);
-macro char[<*>].clz(self) => $$clz(self);
-macro char[<*>] char[<*>].fshl(hi, char[<*>] lo, char[<*>] shift) => $$fshl(hi, lo, shift);
-macro char[<*>] char[<*>].fshr(hi, char[<*>] lo, char[<*>] shift) => $$fshr(hi, lo, shift);
-macro char[<*>] char[<*>].rotl(self, char[<*>] shift) => $$fshl(self, self, shift);
-macro char[<*>] char[<*>].rotr(self, char[<*>] shift) => $$fshr(self, self, shift);
+macro short[<*>].popcount(short[<*>] i) => $$popcount(i);
+macro short[<*>].ctz(short[<*>] i) => $$ctz(i);
+macro short[<*>].clz(short[<*>] i) => $$clz(i);
+macro short[<*>] short[<*>].fshl(short[<*>] hi, short[<*>] lo, short[<*>] shift) => $$fshl(hi, lo, shift);
+macro short[<*>] short[<*>].fshr(short[<*>] hi, short[<*>] lo, short[<*>] shift) => $$fshr(hi, lo, shift);
+macro short[<*>] short[<*>].rotl(short[<*>] i, short[<*>] shift) => $$fshl(i, i, shift);
+macro short[<*>] short[<*>].rotr(short[<*>] i, short[<*>] shift) => $$fshr(i, i, shift);
 
-macro ichar[<*>].popcount(self) => $$popcount(self);
-macro ichar[<*>].ctz(self) => $$ctz(self);
-macro ichar[<*>].clz(self) => $$clz(self);
-macro ichar[<*>] ichar[<*>].fshl(hi, ichar[<*>] lo, ichar[<*>] shift) => $$fshl(hi, lo, shift);
-macro ichar[<*>] ichar[<*>].fshr(hi, ichar[<*>] lo, ichar[<*>] shift) => $$fshr(hi, lo, shift);
-macro ichar[<*>] ichar[<*>].rotl(self, ichar[<*>] shift) => $$fshl(self, self, shift);
-macro ichar[<*>] ichar[<*>].rotr(self, ichar[<*>] shift) => $$fshr(self, self, shift);
+macro char[<*>].popcount(char[<*>] i) => $$popcount(i);
+macro char[<*>].ctz(char[<*>] i) => $$ctz(i);
+macro char[<*>].clz(char[<*>] i) => $$clz(i);
+macro char[<*>] char[<*>].fshl(char[<*>] hi, char[<*>] lo, char[<*>] shift) => $$fshl(hi, lo, shift);
+macro char[<*>] char[<*>].fshr(char[<*>] hi, char[<*>] lo, char[<*>] shift) => $$fshr(hi, lo, shift);
+macro char[<*>] char[<*>].rotl(char[<*>] i, char[<*>] shift) => $$fshl(i, i, shift);
+macro char[<*>] char[<*>].rotr(char[<*>] i, char[<*>] shift) => $$fshr(i, i, shift);
 
-macro ulong[<*>].popcount(self) => $$popcount(self);
-macro ulong[<*>].ctz(self) => $$ctz(self);
-macro ulong[<*>].clz(self) => $$clz(self);
-macro ulong[<*>] ulong[<*>].fshl(hi, ulong[<*>] lo, ulong[<*>] shift) => $$fshl(hi, lo, shift);
-macro ulong[<*>] ulong[<*>].fshr(hi, ulong[<*>] lo, ulong[<*>] shift) => $$fshr(hi, lo, shift);
-macro ulong[<*>] ulong[<*>].rotl(self, ulong[<*>] shift) => $$fshl(self, self, shift);
-macro ulong[<*>] ulong[<*>].rotr(self, ulong[<*>] shift) => $$fshr(self, self, shift);
+macro ichar[<*>].popcount(ichar[<*>] i) => $$popcount(i);
+macro ichar[<*>].ctz(ichar[<*>] i) => $$ctz(i);
+macro ichar[<*>].clz(ichar[<*>] i) => $$clz(i);
+macro ichar[<*>] ichar[<*>].fshl(ichar[<*>] hi, ichar[<*>] lo, ichar[<*>] shift) => $$fshl(hi, lo, shift);
+macro ichar[<*>] ichar[<*>].fshr(ichar[<*>] hi, ichar[<*>] lo, ichar[<*>] shift) => $$fshr(hi, lo, shift);
+macro ichar[<*>] ichar[<*>].rotl(ichar[<*>] i, ichar[<*>] shift) => $$fshl(i, i, shift);
+macro ichar[<*>] ichar[<*>].rotr(ichar[<*>] i, ichar[<*>] shift) => $$fshr(i, i, shift);
 
-macro long[<*>].popcount(self) => $$popcount(self);
-macro long[<*>].ctz(self) => $$ctz(self);
-macro long[<*>].clz(self) => $$clz(self);
-macro long[<*>] long[<*>].fshl(hi, long[<*>] lo, long[<*>] shift) => $$fshl(hi, lo, shift);
-macro long[<*>] long[<*>].fshr(hi, long[<*>] lo, long[<*>] shift) => $$fshr(hi, lo, shift);
-macro long[<*>] long[<*>].rotl(self, long[<*>] shift) => $$fshl(self, self, shift);
-macro long[<*>] long[<*>].rotr(self, long[<*>] shift) => $$fshr(self, self, shift);
+macro ulong[<*>].popcount(ulong[<*>] i) => $$popcount(i);
+macro ulong[<*>].ctz(ulong[<*>] i) => $$ctz(i);
+macro ulong[<*>].clz(ulong[<*>] i) => $$clz(i);
+macro ulong[<*>] ulong[<*>].fshl(ulong[<*>] hi, ulong[<*>] lo, ulong[<*>] shift) => $$fshl(hi, lo, shift);
+macro ulong[<*>] ulong[<*>].fshr(ulong[<*>] hi, ulong[<*>] lo, ulong[<*>] shift) => $$fshr(hi, lo, shift);
+macro ulong[<*>] ulong[<*>].rotl(ulong[<*>] i, ulong[<*>] shift) => $$fshl(i, i, shift);
+macro ulong[<*>] ulong[<*>].rotr(ulong[<*>] i, ulong[<*>] shift) => $$fshr(i, i, shift);
 
-macro uint128[<*>].popcount(self) => $$popcount(self);
-macro uint128[<*>].ctz(self) => $$ctz(self);
-macro uint128[<*>].clz(self) => $$clz(self);
-macro uint128[<*>] uint128[<*>].fshl(hi, uint128[<*>] lo, uint128[<*>] shift) => $$fshl(hi, lo, shift);
-macro uint128[<*>] uint128[<*>].fshr(hi, uint128[<*>] lo, uint128[<*>] shift) => $$fshr(hi, lo, shift);
-macro uint128[<*>] uint128[<*>].rotl(self, uint128[<*>] shift) => $$fshl(self, self, shift);
-macro uint128[<*>] uint128[<*>].rotr(self, uint128[<*>] shift) => $$fshr(self, self, shift);
+macro long[<*>].popcount(long[<*>] i) => $$popcount(i);
+macro long[<*>].ctz(long[<*>] i) => $$ctz(i);
+macro long[<*>].clz(long[<*>] i) => $$clz(i);
+macro long[<*>] long[<*>].fshl(long[<*>] hi, long[<*>] lo, long[<*>] shift) => $$fshl(hi, lo, shift);
+macro long[<*>] long[<*>].fshr(long[<*>] hi, long[<*>] lo, long[<*>] shift) => $$fshr(hi, lo, shift);
+macro long[<*>] long[<*>].rotl(long[<*>] i, long[<*>] shift) => $$fshl(i, i, shift);
+macro long[<*>] long[<*>].rotr(long[<*>] i, long[<*>] shift) => $$fshr(i, i, shift);
 
-macro int128[<*>].popcount(self) => $$popcount(self);
-macro int128[<*>].ctz(self) => $$ctz(self);
-macro int128[<*>].clz(self) => $$clz(self);
-macro int128[<*>] int128[<*>].fshl(hi, int128[<*>] lo, int128[<*>] shift) => $$fshl(hi, lo, shift);
-macro int128[<*>] int128[<*>].fshr(hi, int128[<*>] lo, int128[<*>] shift) => $$fshr(hi, lo, shift);
-macro int128[<*>] int128[<*>].rotl(self, int128[<*>] shift) => $$fshl(self, self, shift);
-macro int128[<*>] int128[<*>].rotr(self, int128[<*>] shift) => $$fshr(self, self, shift);
+macro uint128[<*>].popcount(uint128[<*>] i) => $$popcount(i);
+macro uint128[<*>].ctz(uint128[<*>] i) => $$ctz(i);
+macro uint128[<*>].clz(uint128[<*>] i) => $$clz(i);
+macro uint128[<*>] uint128[<*>].fshl(uint128[<*>] hi, uint128[<*>] lo, uint128[<*>] shift) => $$fshl(hi, lo, shift);
+macro uint128[<*>] uint128[<*>].fshr(uint128[<*>] hi, uint128[<*>] lo, uint128[<*>] shift) => $$fshr(hi, lo, shift);
+macro uint128[<*>] uint128[<*>].rotl(uint128[<*>] i, uint128[<*>] shift) => $$fshl(i, i, shift);
+macro uint128[<*>] uint128[<*>].rotr(uint128[<*>] i, uint128[<*>] shift) => $$fshr(i, i, shift);
 
-macro uint.popcount(self) => $$popcount(self);
-macro uint.ctz(self) => $$ctz(self);
-macro uint.clz(self) => $$clz(self);
-macro uint uint.fshl(hi, uint lo, uint shift) => $$fshl(hi, lo, shift);
-macro uint uint.fshr(hi, uint lo, uint shift) => $$fshr(hi, lo, shift);
-macro uint uint.rotl(self, uint shift) => $$fshl(self, self, shift);
-macro uint uint.rotr(self, uint shift) => $$fshr(self, self, shift);
+macro int128[<*>].popcount(int128[<*>] i) => $$popcount(i);
+macro int128[<*>].ctz(int128[<*>] i) => $$ctz(i);
+macro int128[<*>].clz(int128[<*>] i) => $$clz(i);
+macro int128[<*>] int128[<*>].fshl(int128[<*>] hi, int128[<*>] lo, int128[<*>] shift) => $$fshl(hi, lo, shift);
+macro int128[<*>] int128[<*>].fshr(int128[<*>] hi, int128[<*>] lo, int128[<*>] shift) => $$fshr(hi, lo, shift);
+macro int128[<*>] int128[<*>].rotl(int128[<*>] i, int128[<*>] shift) => $$fshl(i, i, shift);
+macro int128[<*>] int128[<*>].rotr(int128[<*>] i, int128[<*>] shift) => $$fshr(i, i, shift);
 
-macro int.popcount(self) => $$popcount(self);
-macro int.ctz(self) => $$ctz(self);
-macro int.clz(self) => $$clz(self);
-macro int int.fshl(hi, int lo, int shift) => $$fshl(hi, lo, shift);
-macro int int.fshr(hi, int lo, int shift) => $$fshr(hi, lo, shift);
-macro int int.rotl(self, int shift) => $$fshl(self, self, shift);
-macro int int.rotr(self, int shift) => $$fshr(self, self, shift);
+macro uint.popcount(uint i) => $$popcount(i);
+macro uint.ctz(uint i) => $$ctz(i);
+macro uint.clz(uint i) => $$clz(i);
+macro uint uint.fshl(uint hi, uint lo, uint shift) => $$fshl(hi, lo, shift);
+macro uint uint.fshr(uint hi, uint lo, uint shift) => $$fshr(hi, lo, shift);
+macro uint uint.rotl(uint i, uint shift) => $$fshl(i, i, shift);
+macro uint uint.rotr(uint i, uint shift) => $$fshr(i, i, shift);
 
-macro ushort.popcount(self) => $$popcount(self);
-macro ushort.ctz(self) => $$ctz(self);
-macro ushort.clz(self) => $$clz(self);
-macro ushort ushort.fshl(hi, ushort lo, ushort shift) => $$fshl(hi, lo, shift);
-macro ushort ushort.fshr(hi, ushort lo, ushort shift) => $$fshr(hi, lo, shift);
-macro ushort ushort.rotl(self, ushort shift) => $$fshl(self, self, shift);
-macro ushort ushort.rotr(self, ushort shift) => $$fshr(self, self, shift);
+macro int.popcount(int i) => $$popcount(i);
+macro int.ctz(int i) => $$ctz(i);
+macro int.clz(int i) => $$clz(i);
+macro int int.fshl(int hi, int lo, int shift) => $$fshl(hi, lo, shift);
+macro int int.fshr(int hi, int lo, int shift) => $$fshr(hi, lo, shift);
+macro int int.rotl(int i, int shift) => $$fshl(i, i, shift);
+macro int int.rotr(int i, int shift) => $$fshr(i, i, shift);
 
-macro short.popcount(self) => $$popcount(self);
-macro short.ctz(self) => $$ctz(self);
-macro short.clz(self) => $$clz(self);
-macro short short.fshl(hi, short lo, short shift) => $$fshl(hi, lo, shift);
-macro short short.fshr(hi, short lo, short shift) => $$fshr(hi, lo, shift);
-macro short short.rotl(self, short shift) => $$fshl(self, self, shift);
-macro short short.rotr(self, short shift) => $$fshr(self, self, shift);
+macro ushort.popcount(ushort i) => $$popcount(i);
+macro ushort.ctz(ushort i) => $$ctz(i);
+macro ushort.clz(ushort i) => $$clz(i);
+macro ushort ushort.fshl(ushort hi, ushort lo, ushort shift) => $$fshl(hi, lo, shift);
+macro ushort ushort.fshr(ushort hi, ushort lo, ushort shift) => $$fshr(hi, lo, shift);
+macro ushort ushort.rotl(ushort i, ushort shift) => $$fshl(i, i, shift);
+macro ushort ushort.rotr(ushort i, ushort shift) => $$fshr(i, i, shift);
 
-macro char.popcount(self) => $$popcount(self);
-macro char.ctz(self) => $$ctz(self);
-macro char.clz(self) => $$clz(self);
-macro char char.fshl(hi, char lo, char shift) => $$fshl(hi, lo, shift);
-macro char char.fshr(hi, char lo, char shift) => $$fshr(hi, lo, shift);
-macro char char.rotl(self, char shift) => $$fshl(self, self, shift);
-macro char char.rotr(self, char shift) => $$fshr(self, self, shift);
+macro short.popcount(short i) => $$popcount(i);
+macro short.ctz(short i) => $$ctz(i);
+macro short.clz(short i) => $$clz(i);
+macro short short.fshl(short hi, short lo, short shift) => $$fshl(hi, lo, shift);
+macro short short.fshr(short hi, short lo, short shift) => $$fshr(hi, lo, shift);
+macro short short.rotl(short i, short shift) => $$fshl(i, i, shift);
+macro short short.rotr(short i, short shift) => $$fshr(i, i, shift);
 
-macro ichar.popcount(self) => $$popcount(self);
-macro ichar.ctz(self) => $$ctz(self);
-macro ichar.clz(self) => $$clz(self);
-macro ichar ichar.fshl(hi, ichar lo, ichar shift) => $$fshl(hi, lo, shift);
-macro ichar ichar.fshr(hi, ichar lo, ichar shift) => $$fshr(hi, lo, shift);
-macro ichar ichar.rotl(self, ichar shift) => $$fshl(self, self, shift);
-macro ichar ichar.rotr(self, ichar shift) => $$fshr(self, self, shift);
+macro char.popcount(char i) => $$popcount(i);
+macro char.ctz(char i) => $$ctz(i);
+macro char.clz(char i) => $$clz(i);
+macro char char.fshl(char hi, char lo, char shift) => $$fshl(hi, lo, shift);
+macro char char.fshr(char hi, char lo, char shift) => $$fshr(hi, lo, shift);
+macro char char.rotl(char i, char shift) => $$fshl(i, i, shift);
+macro char char.rotr(char i, char shift) => $$fshr(i, i, shift);
 
-macro ulong.popcount(self) => $$popcount(self);
-macro ulong.ctz(self) => $$ctz(self);
-macro ulong.clz(self) => $$clz(self);
-macro ulong ulong.fshl(hi, ulong lo, ulong shift) => $$fshl(hi, lo, shift);
-macro ulong ulong.fshr(hi, ulong lo, ulong shift) => $$fshr(hi, lo, shift);
-macro ulong ulong.rotl(self, ulong shift) => $$fshl(self, self, shift);
-macro ulong ulong.rotr(self, ulong shift) => $$fshr(self, self, shift);
+macro ichar.popcount(ichar i) => $$popcount(i);
+macro ichar.ctz(ichar i) => $$ctz(i);
+macro ichar.clz(ichar i) => $$clz(i);
+macro ichar ichar.fshl(ichar hi, ichar lo, ichar shift) => $$fshl(hi, lo, shift);
+macro ichar ichar.fshr(ichar hi, ichar lo, ichar shift) => $$fshr(hi, lo, shift);
+macro ichar ichar.rotl(ichar i, ichar shift) => $$fshl(i, i, shift);
+macro ichar ichar.rotr(ichar i, ichar shift) => $$fshr(i, i, shift);
 
-macro long.popcount(self) => $$popcount(self);
-macro long.ctz(self) => $$ctz(self);
-macro long.clz(self) => $$clz(self);
-macro long long.fshl(hi, long lo, long shift) => $$fshl(hi, lo, shift);
-macro long long.fshr(hi, long lo, long shift) => $$fshr(hi, lo, shift);
-macro long long.rotl(self, long shift) => $$fshl(self, self, shift);
-macro long long.rotr(self, long shift) => $$fshr(self, self, shift);
+macro ulong.popcount(ulong i) => $$popcount(i);
+macro ulong.ctz(ulong i) => $$ctz(i);
+macro ulong.clz(ulong i) => $$clz(i);
+macro ulong ulong.fshl(ulong hi, ulong lo, ulong shift) => $$fshl(hi, lo, shift);
+macro ulong ulong.fshr(ulong hi, ulong lo, ulong shift) => $$fshr(hi, lo, shift);
+macro ulong ulong.rotl(ulong i, ulong shift) => $$fshl(i, i, shift);
+macro ulong ulong.rotr(ulong i, ulong shift) => $$fshr(i, i, shift);
 
-macro uint128.popcount(self) => $$popcount(self);
-macro uint128.ctz(self) => $$ctz(self);
-macro uint128.clz(self) => $$clz(self);
-macro uint128 uint128.fshl(hi, uint128 lo, uint128 shift) => $$fshl(hi, lo, shift);
-macro uint128 uint128.fshr(hi, uint128 lo, uint128 shift) => $$fshr(hi, lo, shift);
-macro uint128 uint128.rotl(self, uint128 shift) => $$fshl(self, self, shift);
-macro uint128 uint128.rotr(self, uint128 shift) => $$fshr(self, self, shift);
+macro long.popcount(long i) => $$popcount(i);
+macro long.ctz(long i) => $$ctz(i);
+macro long.clz(long i) => $$clz(i);
+macro long long.fshl(long hi, long lo, long shift) => $$fshl(hi, lo, shift);
+macro long long.fshr(long hi, long lo, long shift) => $$fshr(hi, lo, shift);
+macro long long.rotl(long i, long shift) => $$fshl(i, i, shift);
+macro long long.rotr(long i, long shift) => $$fshr(i, i, shift);
 
-macro int128.popcount(self) => $$popcount(self);
-macro int128.ctz(self) => $$ctz(self);
-macro int128.clz(self) => $$clz(self);
-macro int128 int128.fshl(hi, int128 lo, int128 shift) => $$fshl(hi, lo, shift);
-macro int128 int128.fshr(hi, int128 lo, int128 shift) => $$fshr(hi, lo, shift);
-macro int128 int128.rotl(self, int128 shift) => $$fshl(self, self, shift);
-macro int128 int128.rotr(self, int128 shift) => $$fshr(self, self, shift);
+macro uint128.popcount(uint128 i) => $$popcount(i);
+macro uint128.ctz(uint128 i) => $$ctz(i);
+macro uint128.clz(uint128 i) => $$clz(i);
+macro uint128 uint128.fshl(uint128 hi, uint128 lo, uint128 shift) => $$fshl(hi, lo, shift);
+macro uint128 uint128.fshr(uint128 hi, uint128 lo, uint128 shift) => $$fshr(hi, lo, shift);
+macro uint128 uint128.rotl(uint128 i, uint128 shift) => $$fshl(i, i, shift);
+macro uint128 uint128.rotr(uint128 i, uint128 shift) => $$fshr(i, i, shift);
+
+macro int128.popcount(int128 i) => $$popcount(i);
+macro int128.ctz(int128 i) => $$ctz(i);
+macro int128.clz(int128 i) => $$clz(i);
+macro int128 int128.fshl(int128 hi, int128 lo, int128 shift) => $$fshl(hi, lo, shift);
+macro int128 int128.fshr(int128 hi, int128 lo, int128 shift) => $$fshr(hi, lo, shift);
+macro int128 int128.rotl(int128 i, int128 shift) => $$fshl(i, i, shift);
+macro int128 int128.rotr(int128 i, int128 shift) => $$fshr(i, i, shift);

lib/std/collections/bitset.c3

@@ -1,174 +0,0 @@
-/**
- * @require SIZE > 0
- **/
-module std::collections::bitset(<SIZE>);
-
-def Type = uint;
-
-const BITS = Type.sizeof * 8;
-const SZ = (SIZE + BITS - 1) / BITS;
-
-struct BitSet
-{
-	Type[SZ] data;
-}
-
-fn usz BitSet.cardinality(&self)
-{
-	usz n;
-	foreach (x : self.data)
-	{
-		n += x.popcount();
-	}
-	return n;
-}
-
-/**
- * @require i < SIZE
- **/
-fn void BitSet.set(&self, usz i)
-{
-	usz q = i / BITS;
-	usz r = i % BITS;
-	self.data[q] |= 1 << r;
-}
-
-/**
- * @require i < SIZE
- **/
-fn void BitSet.unset(&self, usz i)
-{
-	usz q = i / BITS;
-	usz r = i % BITS;
-	self.data[q] &= ~(1 << r);
-}
-
-/**
- * @require i < SIZE
- **/
-fn bool BitSet.get(&self, usz i) @operator([]) @inline
-{
-	usz q = i / BITS;
-	usz r = i % BITS;
-	return self.data[q] & (1 << r) != 0;
-}
-
-fn usz BitSet.len(&self) @operator(len) @inline
-{
-	return SZ * BITS;
-}
-
-/**
- * @require i < SIZE
- **/
-fn void BitSet.set_bool(&self, usz i, bool value) @operator([]=) @inline
-{
-	if (value) return self.set(i);
-	self.unset(i);
-}
-
-/**
- * @require Type.kindof == UNSIGNED_INT
- **/
-module std::collections::growablebitset(<Type>);
-import std::collections::list;
-
-const BITS = Type.sizeof * 8;
-
-def GrowableBitSetList = List(<Type>);
-
-struct GrowableBitSet
-{
-	GrowableBitSetList data;
-}
-
-/**
- * @param initial_capacity
- * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
- **/
-fn GrowableBitSet* GrowableBitSet.new_init(&self, usz initial_capacity = 1, Allocator* allocator = allocator::heap())
-{
-	self.data.new_init(initial_capacity, allocator);
-	return self;
-}
-
-/**
- * @param initial_capacity
- * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
- **/
-fn GrowableBitSet* GrowableBitSet.init_new(&self, usz initial_capacity = 1, Allocator* allocator = allocator::heap()) @deprecated("Replaced by new_init")
-{
-	return self.new_init(initial_capacity, allocator) @inline;
-}
-
-fn GrowableBitSet* GrowableBitSet.temp_init(&self, usz initial_capacity = 1)
-{
-	return self.new_init(initial_capacity, allocator::temp()) @inline;
-}
-
-fn GrowableBitSet* GrowableBitSet.init_temp(&self, usz initial_capacity = 1) @deprecated("Replaced by temp_init")
-{
-	return self.temp_init(initial_capacity);
-}
-
-fn void GrowableBitSet.free(&self)
-{
-	self.data.free();
-}
-
-fn usz GrowableBitSet.cardinality(&self)
-{
-	usz n;
-	foreach (x : self.data)
-	{
-		n += x.popcount();
-	}
-	return n;
-}
-
-fn void GrowableBitSet.set(&self, usz i)
-{
-	usz q = i / BITS;
-	usz r = i % BITS;
-	usz current_len = self.data.len();
-	if (q >= current_len)
-	{
-		usz n = q + 1;
-		self.data.reserve(n);
-		if (n - 1 >= current_len)
-		{
-			self.data.entries[current_len .. (n - 1)] = 0;
-		}
-		self.data.size = n;
-	}
-	self.data.set(q, self.data[q] | (1 << r));
-}
-
-fn void GrowableBitSet.unset(&self, usz i)
-{
-	usz q = i / BITS;
-	usz r = i % BITS;
-	if (q >= self.data.len()) return;
-	self.data.set(q, self.data[q] &~ (1 << r));
-}
-
-fn bool GrowableBitSet.get(&self, usz i) @operator([]) @inline
-{
-	usz q = i / BITS;
-	usz r = i % BITS;
-	if (q >= self.data.len()) return false;
-	return self.data[q] & (1 << r) != 0;
-}
-
-fn usz GrowableBitSet.len(&self) @operator(len)
-{
-	usz n = self.data.len() * BITS;
-	if (n > 0) n -= (usz)self.data[^1].clz();
-	return n;
-}
-
-fn void GrowableBitSet.set_bool(&self, usz i, bool value) @operator([]=) @inline
-{
-	if (value) return self.set(i);
-	self.unset(i);
-}

lib/std/collections/enummap.c3

@@ -1,63 +1,18 @@
-module std::collections::enummap(<Enum, ValueType>);
-import std::io;
-struct EnumMap (Printable)
+module std::collections::enummap<Enum, ValueType>;
+
+struct EnumMap
 {
-	ValueType[Enum.len] values;
+    ValueType[Enum.len] values;
 }
 
-fn void EnumMap.init(&self, ValueType init_value)
+fn void EnumMap.init(EnumMap* this, ValueType init_value)
 {
-	foreach (&a : self.values)
-	{
-		*a = init_value;
-	}
+    foreach(&a : this.values)
+    {
+        *a = init_value;
+    }
 }
 
-fn usz! EnumMap.to_format(&self, Formatter* formatter) @dynamic
-{
-	usz n = formatter.print("{ ")!;
-	foreach (i, &value : self.values)
-	{
-		if (i != 0) formatter.print(", ")!;
-		n += formatter.printf("%s: %s", (Enum)i, *value)!;
-	}
-	n += formatter.print(" }")!;
-	return n;
-}
-
-fn String EnumMap.to_new_string(&self, Allocator* allocator = allocator::heap()) @dynamic
-{
-	return string::new_format("%s", *self, .allocator = allocator);
-}
-
-fn String EnumMap.to_tstring(&self) @dynamic
-{
-	return string::tformat("%s", *self);
-}
-
-/**
- * @return "The total size of this map, which is the same as the number of enum values"
- * @pure
- **/
-fn usz EnumMap.len(&self) @operator(len) @inline
-{
-	return self.values.len;
-}
-
-/**
- * @return "Retrieve a value given the underlying enum, if there is no entry, then the zero value for the value is returned."
- **/
-fn ValueType EnumMap.get(&self, Enum key) @operator([]) @inline
-{
-	return self.values[key.ordinal];
-}
-
-fn ValueType* EnumMap.get_ref(&self, Enum key) @operator(&[]) @inline
-{
-	return &self.values[key.ordinal];
-}
-
-fn void EnumMap.set(&self, Enum key, ValueType value) @operator([]=) @inline
-{
-	self.values[key.ordinal] = value;
-}
+fn uint EnumMap.len(EnumMap* this) @operator(len) => this.values.len;
+fn ValueType EnumMap.get(EnumMap* this, Enum key) @operator([]) => this.values[key.ordinal];
+fn void EnumMap.set(EnumMap* this, Enum key, ValueType value) @operator([]=) => this.values[key.ordinal] = value;

lib/std/collections/enumset.c3

@@ -1,172 +1,145 @@
-// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
-// Use of self source code is governed by the MIT license
+// Copyright (c) 2021 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.
 
 /**
  * @require Enum.kindof == TypeKind.ENUM : "Only enums maybe be used with an enumset"
  **/
-module std::collections::enumset(<Enum>);
-import std::io;
+module std::collections::enumset<Enum>;
 
-def EnumSetType = $typefrom(private::type_for_enum_elements(Enum.elements)) @private;
 
-const IS_CHAR_ARRAY = Enum.elements > 128;
-distinct EnumSet (Printable) = EnumSetType;
+$switch
+$case (Enum.elements > 128):
+typedef EnumSetType @private = char[(Enum.elements + 7) / 8];
+const IS_CHAR_ARRAY = true;
+$case (Enum.elements > 64):
+typedef EnumSetType @private = uint128;
+const IS_CHAR_ARRAY = false;
+$case (Enum.elements > 32 || $$C_INT_SIZE > 32):
+typedef EnumSetType @private = ulong;
+const IS_CHAR_ARRAY = false;
+$case (Enum.elements > 16 || $$C_INT_SIZE > 16):
+typedef EnumSetType @private = uint;
+const IS_CHAR_ARRAY = false;
+$case (Enum.elements > 8 || $$C_INT_SIZE > 8):
+typedef EnumSetType @private = ushort;
+const IS_CHAR_ARRAY = false;
+$default:
+typedef EnumSetType @private = char;
+const IS_CHAR_ARRAY = false;
+$endswitch
 
-fn void EnumSet.add(&self, Enum v)
+typedef EnumSet = distinct EnumSetType;
+
+fn void EnumSet.add(EnumSet* this, Enum v)
 {
-	$if IS_CHAR_ARRAY:
-		(*self)[(usz)v / 8] |= (char)(1u << ((usz)v % 8));
-	$else
-		*self = (EnumSet)((EnumSetType)*self | 1u << (EnumSetType)v);
-	$endif
+$if (IS_CHAR_ARRAY)
+	(*this)[v / 8] |= (char)(1u << (v % 8));
+$else
+    *this = (EnumSet)((EnumSetType)*this | 1u << (EnumSetType)v);
+$endif
 }
 
-fn void EnumSet.clear(&self)
+fn void EnumSet.clear(EnumSet* this)
 {
-	$if IS_CHAR_ARRAY:
-		*self = {};
-	$else
-		*self = 0;
-	$endif
+$if (IS_CHAR_ARRAY)
+	*this = {};
+$else
+    *this = 0;
+$endif
 }
 
-fn bool EnumSet.remove(&self, Enum v)
+fn bool EnumSet.remove(EnumSet* this, Enum v)
 {
-	$if IS_CHAR_ARRAY:
-		if (!self.has(v) @inline) return false;
-		(*self)[(usz)v / 8] &= (char)~(1u << ((usz)v % 8));
-		return true;
-	$else
-		EnumSetType old = (EnumSetType)*self;
-		EnumSetType new = old & ~(1u << (EnumSetType)v);
-		*self = (EnumSet)new;
-		return old != new;
-	$endif
+$if (IS_CHAR_ARRAY)
+	if (!this.has(v) @inline) return false;
+	(*this)[v / 8] &= (char)~(1 << (v % 8));
+	return true;
+$else
+    EnumSetType old = (EnumSetType)*this;
+    EnumSetType new = old & ~(1u << (EnumSetType)v);
+    *this = (EnumSet)new;
+    return old != new;
+$endif
 }
 
-fn bool EnumSet.has(&self, Enum v)
+fn bool EnumSet.has(EnumSet* this, Enum v)
 {
-	$if IS_CHAR_ARRAY:
-		return (bool)(((*self)[(usz)v / 8] << ((usz)v % 8)) & 0x01);
-	$else
-		return ((EnumSetType)*self & (1u << (EnumSetType)v)) != 0;
-	$endif
+$if (IS_CHAR_ARRAY)
+	return (bool)(((*this)[v / 8] << (v % 8)) & 0x01);
+$else
+    return ((EnumSetType)*this & (1u << (EnumSetType)v)) != 0;
+$endif
 }
 
-fn void EnumSet.add_all(&self, EnumSet s)
+fn void EnumSet.add_all(EnumSet* this, EnumSet s)
 {
-	$if IS_CHAR_ARRAY:
-		foreach (i, c : s) (*self)[i] |= c;
-	$else
-		*self = (EnumSet)((EnumSetType)*self | (EnumSetType)s);
-	$endif
+$if (IS_CHAR_ARRAY)
+	foreach (i, c : s) (*this)[i] |= c;
+$else
+    *this = (EnumSet)((EnumSetType)*this | (EnumSetType)s);
+$endif
 }
 
-fn void EnumSet.retain_all(&self, EnumSet s)
+fn void EnumSet.retain_all(EnumSet* this, EnumSet s)
 {
-	$if IS_CHAR_ARRAY:
-		foreach (i, c : s) (*self)[i] &= c;
-	$else
-		*self = (EnumSet)((EnumSetType)*self & (EnumSetType)s);
-	$endif
+$if (IS_CHAR_ARRAY)
+	foreach (i, c : s) (*this)[i] &= c;
+$else
+    *this = (EnumSet)((EnumSetType)*this & (EnumSetType)s);
+$endif
 }
 
-fn void EnumSet.remove_all(&self, EnumSet s)
+fn void EnumSet.remove_all(EnumSet* this, EnumSet s)
 {
-	$if IS_CHAR_ARRAY:
-		foreach (i, c : s) (*self)[i] &= ~c;
-	$else
-		*self = (EnumSet)((EnumSetType)*self & ~(EnumSetType)s);
-	$endif
+$if (IS_CHAR_ARRAY)
+	foreach (i, c : s) (*this)[i] &= ~c;
+$else
+    *this = (EnumSet)((EnumSetType)*this & ~(EnumSetType)s);
+$endif
 }
 
-fn EnumSet EnumSet.and_of(&self, EnumSet s)
+fn EnumSet EnumSet.and_of(EnumSet* this, EnumSet s)
 {
-	$if IS_CHAR_ARRAY:
-		EnumSet copy = *self;
-		copy.retain_all(s);
-		return copy;
-	$else
-		return (EnumSet)((EnumSetType)*self & (EnumSetType)s);
-	$endif
+$if (IS_CHAR_ARRAY)
+	EnumSet copy = *this;
+	copy.retain_all(s);
+	return copy;
+$else
+    return (EnumSet)((EnumSetType)*this & (EnumSetType)s);
+$endif
 }
 
-fn EnumSet EnumSet.or_of(&self, EnumSet s)
+fn EnumSet EnumSet.or_of(EnumSet* this, EnumSet s)
 {
-	$if IS_CHAR_ARRAY:
-		EnumSet copy = *self;
-		copy.add_all(s);
-		return copy;
-	$else
-		return (EnumSet)((EnumSetType)*self | (EnumSetType)s);
-	$endif
+$if (IS_CHAR_ARRAY)
+	EnumSet copy = *this;
+	copy.add_all(s);
+	return copy;
+$else
+    return (EnumSet)((EnumSetType)*this | (EnumSetType)s);
+$endif
 }
 
 
-fn EnumSet EnumSet.diff_of(&self, EnumSet s)
+fn EnumSet EnumSet.diff_of(EnumSet* this, EnumSet s)
 {
-	$if IS_CHAR_ARRAY:
-		EnumSet copy = *self;
-		copy.remove_all(s);
-		return copy;
-	$else
-		return (EnumSet)((EnumSetType)*self & ~(EnumSetType)s);
-	$endif
+$if (IS_CHAR_ARRAY)
+	EnumSet copy = *this;
+	copy.remove_all(s);
+	return copy;
+$else
+    return (EnumSet)((EnumSetType)*this & ~(EnumSetType)s);
+$endif
 }
 
-fn EnumSet EnumSet.xor_of(&self, EnumSet s)
+fn EnumSet EnumSet.xor_of(EnumSet* this, EnumSet s)
 {
-	$if IS_CHAR_ARRAY:
-		EnumSet copy = *self;
-		foreach (i, c : s) copy[i] ^= c;
-		return copy;
-	$else
-		return (EnumSet)((EnumSetType)*self ^ (EnumSetType)s);
-	$endif
-}
-
-fn usz! EnumSet.to_format(&set, Formatter* formatter) @dynamic
-{
-	usz n = formatter.print("[")!;
-	bool found;
-	foreach (value : Enum.values)
-	{
-		if (!set.has(value)) continue;
-		if (found) n += formatter.print(", ")!;
-		found = true;
-		n += formatter.printf("%s", value)!;
-	}
-	n += formatter.print("]")!;
-	return n;
-}
-
-fn String EnumSet.to_new_string(&set, Allocator* allocator = allocator::heap()) @dynamic
-{
-	return string::new_format("%s", *set, .allocator = allocator);
-}
-
-fn String EnumSet.to_tstring(&set) @dynamic
-{
-	return string::tformat("%s", *set);
-}
-
-module std::collections::enumset::private;
-
-macro typeid type_for_enum_elements(usz $elements)
-{
-	$switch
-		$case ($elements > 128):
-			return char[($elements + 7) / 8].typeid;
-		$case ($elements > 64):
-			return uint128.typeid;
-		$case ($elements > 32 || $$C_INT_SIZE > 32):
-			return ulong.typeid;
-		$case ($elements > 16 || $$C_INT_SIZE > 16):
-			return uint.typeid;
-		$case ($elements > 8 || $$C_INT_SIZE > 8):
-			return ushort.typeid;
-		$default:
-			return char.typeid;
-	$endswitch
+$if (IS_CHAR_ARRAY)
+	EnumSet copy = *this;
+	foreach (i, c : s) copy[i] ^= c;
+	return copy;
+$else
+    return (EnumSet)((EnumSetType)*this ^ (EnumSetType)s);
+$endif
 }

lib/std/collections/generic_list.c3

@@ -1,467 +0,0 @@
-// Copyright (c) 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.
-module std::collections::generic_list;
-import std::io,std::math;
-
-def GenericPredicate = fn bool(any* value);
-def GenericTest = fn bool(any* type, any* context);
-
-struct GenericList (Printable)
-{
-	usz size;
-	usz capacity;
-	Allocator* allocator;
-	any** entries;
-}
-
-
-/**
- * @param initial_capacity "The initial capacity to reserve"
- * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
- **/
-fn GenericList* GenericList.new_init(&self, usz initial_capacity = 16, Allocator* allocator = allocator::heap())
-{
-	self.allocator = allocator;
-	self.size = 0;
-	if (initial_capacity > 0)
-	{
-		initial_capacity = math::next_power_of_2(initial_capacity);
-		self.entries = allocator::alloc_array(allocator, any*, initial_capacity);
-	}
-	else
-	{
-		self.entries = null;
-	}
-	self.capacity = initial_capacity;
-	return self;
-}
-
-/**
- * @param initial_capacity "The initial capacity to reserve"
- * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
- **/
-fn GenericList* GenericList.init_new(&self, usz initial_capacity = 16, Allocator* allocator = allocator::heap()) @deprecated("Replaced by new_init")
-{
-	return self.new_init(initial_capacity, allocator) @inline;
-}
-
-/**
- * Initialize the list using the temp allocator.
- *
- * @param initial_capacity "The initial capacity to reserve"
- **/
-fn GenericList* GenericList.temp_init(&self, usz initial_capacity = 16)
-{
-	return self.new_init(initial_capacity, allocator::temp()) @inline;
-}
-
-fn usz! GenericList.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 GenericList.to_new_string(&self, Allocator* allocator = allocator::heap()) @dynamic
-{
-	return string::new_format("%s", *self, .allocator = allocator);
-}
-
-fn String GenericList.to_tstring(&self)
-{
-	return string::tformat("%s", *self);
-}
-
-/**
- * Push an element on the list by cloning it.
- **/
-macro void GenericList.push(&self, element)
-{
-	if (!self.allocator) self.allocator = allocator::heap();
-	self.append_internal(allocator::clone(self.allocator, element));
-}
-
-fn void GenericList.append_internal(&self, any* element) @local
-{
-	self.ensure_capacity();
-	self.entries[self.size++] = element;
-}
-
-/**
- * Free a retained element removed using *_retained.
- **/
-fn void GenericList.free_element(&self, any* element) @inline
-{
-	allocator::free(self.allocator, element.ptr);
-}
-
-/**
- * Pop a value who's type is known. If the type is incorrect, this
- * will still pop the element.
- *
- * @return! CastResult.TYPE_MISMATCH, IteratorResult.NO_MORE_ELEMENT
- **/
-macro GenericList.pop(&self, $Type)
-{
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.free_element(self.entries[self.size]);
-	return *anycast(self.entries[--self.size], $Type);
-}
-
-/**
- * Pop the last value and allocate the copy using the given allocator.
- * @return! IteratorResult.NO_MORE_ELEMENT
- **/
-fn any*! GenericList.new_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 temp allocator
- * @return! IteratorResult.NO_MORE_ELEMENT
- **/
-fn any*! GenericList.temp_pop(&self) => self.new_pop(allocator::temp());
-
-/**
- * Pop the last value. It must later be released using list.free_element()
- * @return! IteratorResult.NO_MORE_ELEMENT
- **/
-fn any*! GenericList.pop_retained(&self)
-{
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	return self.entries[--self.size];
-}
-
-fn void GenericList.clear(&self)
-{
-	for (usz i = 0; i < self.size; i++)
-	{
-		self.free_element(self.entries[i]);
-	}
-	self.size = 0;
-}
-
-/**
- * Same as pop() but pops the first value instead.
- **/
-macro GenericList.pop_first(&self, $Type)
-{
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.remove_at(0);
-	return *anycast(self.entries[0], $Type);
-}
-
-/**
- * Same as pop_retained() but pops the first value instead.
- **/
-fn any*! GenericList.pop_first_retained(&self)
-{
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.remove_at(0);
-	return self.entries[0];
-}
-
-/**
- * Same as new_pop() but pops the first value instead.
- **/
-fn any*! GenericList.new_pop_first(&self, Allocator* allocator = allocator::heap())
-{
-	if (!self.size) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.free_element(self.entries[self.size]);
-	defer self.remove_at(0);
-	return allocator::clone_any(allocator, self.entries[0]);
-}
-
-/**
- * Same as temp_pop() but pops the first value instead.
- **/
-fn any*! GenericList.temp_pop_first(&self) => self.new_pop_first(allocator::temp());
-
-/**
- * @require index < self.size
- **/
-fn void GenericList.remove_at(&self, usz index)
-{
-	if (!--self.size || index == self.size) return;
-	self.free_element(self.entries[index]);
-	self.entries[index .. self.size - 1] = self.entries[index + 1 .. self.size];
-}
-
-fn void GenericList.add_all(&self, GenericList* other_list)
-{
-	if (!other_list.size) return;
-	self.reserve(other_list.size);
-	foreach (value : other_list)
-	{
-		self.entries[self.size++] = allocator::clone_any(self.allocator, value);
-	}
-}
-
-/**
- * Reverse the elements in a list.
- **/
-fn void GenericList.reverse(&self)
-{
-	if (self.size < 2) return;
-	usz half = self.size / 2U;
-	usz end = self.size - 1;
-	for (usz i = 0; i < half; i++)
-	{
-		self.swap(i, end - i);
-	}
-}
-
-fn any*[] GenericList.array_view(&self)
-{
-	return self.entries[:self.size];
-}
-
-/**
- * Push an element to the front of the list.
- **/
-macro void GenericList.push_front(&self, type)
-{
-	self.insert_at(0, type);
-}
-
-/**
- * @require index < self.size
- **/
-macro void GenericList.insert_at(&self, usz index, type) @local
-{
-	any* value = allocator::copy(self.allocator, type);
-	self.insert_at_internal(self, index, value);
-}
-
-/**
- * @require index < self.size
- **/
-fn void GenericList.insert_at_internal(&self, usz index, any* value) @local
-{
-	self.ensure_capacity();
-	for (usz i = self.size; i > index; i--)
-	{
-		self.entries[i] = self.entries[i - 1];
-	}
-	self.size++;
-	self.entries[index] = value;
-}
-
-
-/**
- * @require self.size > 0
- **/
-fn void GenericList.remove_last(&self)
-{
-	self.free_element(self.entries[--self.size]);
-}
-
-/**
- * @require self.size > 0
- **/
-fn void GenericList.remove_first(&self)
-{
-	self.remove_at(0);
-}
-
-macro GenericList.first(&self, $Type)
-{
-	return *anycast(self.first_any(), $Type);
-}
-
-fn any*! GenericList.first_any(&self) @inline
-{
-	return self.size ? self.entries[0] : IteratorResult.NO_MORE_ELEMENT?;
-}
-
-macro GenericList.last(&self, $Type)
-{
-	return *anycast(self.last_any(), $Type);
-}
-
-fn any*! GenericList.last_any(&self) @inline
-{
-	return self.size ? self.entries[self.size - 1] : IteratorResult.NO_MORE_ELEMENT?;
-}
-
-fn bool GenericList.is_empty(&self) @inline
-{
-	return !self.size;
-}
-
-fn usz GenericList.len(&self) @operator(len) @inline
-{
-	return self.size;
-}
-
-/**
- * @require index < self.size "Index out of range"
- **/
-macro GenericList.get(&self, usz index, $Type)
-{
-	return *anycast(self.entries[index], $Type);
-}
-
-/**
- * @require index < self.size "Index out of range"
- **/
-fn any* GenericList.get_any(&self, usz index) @inline
-{
-	return self.entries[index];
-}
-
-fn void GenericList.free(&self)
-{
-	if (!self.allocator) return;
-	self.clear();
-	allocator::free(self.allocator, self.entries);
-	self.capacity = 0;
-	self.entries = null;
-}
-
-fn void GenericList.swap(&self, usz i, usz j)
-{
-	any* temp = self.entries[i];
-	self.entries[i] = self.entries[j];
-	self.entries[j] = temp;
-}
-
-/**
- * @param filter "The function to determine if it should be removed or not"
- * @return "the number of deleted elements"
- **/
-fn usz GenericList.remove_if(&self, GenericPredicate filter)
-{
-	return self._remove_if(filter, false);
-}
-
-/**
- * @param selection "The function to determine if it should be kept or not"
- * @return "the number of deleted elements"
- **/
-fn usz GenericList.retain_if(&self, GenericPredicate selection)
-{
-	return self._remove_if(selection, true);
-}
-
-macro usz GenericList._remove_if(&self, GenericPredicate 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;
-		for (usz j = i; j < k; j++) self.free_element(self.entries[j]);
-		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;
-}
-
-fn usz GenericList.remove_using_test(&self, GenericTest filter, any* context)
-{
-	return self._remove_using_test(filter, false, context);
-}
-
-fn usz GenericList.retain_using_test(&self, GenericTest filter, any* context)
-{
-	return self._remove_using_test(filter, true, context);
-}
-
-macro usz GenericList._remove_using_test(&self, GenericTest 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;
-		for (usz j = i; j < k; j++) self.free_element(self.entries[j]);
-		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;
-}
-
-/**
- * Reserve at least min_capacity
- **/
-fn void GenericList.reserve(&self, usz min_capacity)
-{
-	if (!min_capacity) return;
-	if (self.capacity >= min_capacity) return;
-	if (!self.allocator) self.allocator = allocator::heap();
-	min_capacity = math::next_power_of_2(min_capacity);
-	self.entries = allocator::realloc(self.allocator, self.entries, any*.sizeof * min_capacity);
-	self.capacity = min_capacity;
-}
-
-macro any* GenericList.@item_at(&self, usz index) @operator([])
-{
-	return self.entries[index];
-}
-
-/**
- * @require index <= self.size "Index out of range"
- **/
-macro void GenericList.set(&self, usz index, value)
-{
-	if (index == self.size)
-	{
-		self.push(value);
-		return;
-	}
-	self.free_element(self.entries[index]);
-	self.entries[index] = allocator::copy(self.allocator, value);
-}
-
-fn void GenericList.ensure_capacity(&self, usz added = 1) @inline @private
-{
-	usz new_size = self.size + added;
-	if (self.capacity >= new_size) return;
-
-	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);
-}

lib/std/collections/linkedlist.c3

@@ -1,325 +1,312 @@
-// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
-// Use of self source code is governed by the MIT license
+// Copyright (c) 2021 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::linkedlist(<Type>);
+module std::collections::linkedlist<Type>;
 
 struct Node @private
 {
-	Node *next;
-	Node *prev;
-	Type value;
+    Node *next;
+    Node *prev;
+    Type value;
 }
 
 struct LinkedList
 {
-	Allocator *allocator;
-	usz size;
-	Node *_first;
-	Node *_last;
+    Allocator *allocator;
+    usz size;
+    Node *_first;
+    Node *_last;
 }
 
-fn void LinkedList.push(&self, Type value)
+fn void LinkedList.push(LinkedList* list, Type value)
 {
-	self.link_first(value);
+    list.link_first(value);
 }
 
-fn void LinkedList.push_last(&self, Type value)
+fn void LinkedList.push_last(LinkedList* list, Type value)
 {
-	self.link_last(value);
+	list.link_last(value);
 }
 
+fn void LinkedList.init(LinkedList* list, Allocator* using = mem::heap())
+{
+	*list = { .allocator = using };
+}
+
+fn void LinkedList.tinit(LinkedList* list) => list.init(mem::temp()) @inline;
+
 /**
- * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
- * @return "the initialized list"
+ * @require list.allocator
  **/
-fn LinkedList* LinkedList.new_init(&self, Allocator* allocator = allocator::heap())
+macro void LinkedList.@free_node(LinkedList &list, Node* node) @private
 {
-	*self = { .allocator = allocator };
-	return self;
+	list.allocator.free(node)!!;
 }
+macro Node* LinkedList.@alloc_node(LinkedList &list) @private
+{
+	if (!list.allocator) list.allocator = mem::heap();
+	return malloc(Node, .using = list.allocator);
+}
+
+fn void LinkedList.link_first(LinkedList* list, Type value) @private
+{
+    Node *first = list._first;
+    Node *new_node = list.@alloc_node();
+    *new_node = { .next = first, .value = value };
+    list._first = new_node;
+    if (!first)
+    {
+        list._last = new_node;
+    }
+    else
+    {
+        first.prev = new_node;
+    }
+    list.size++;
+}
+
+fn void LinkedList.link_last(LinkedList* list, Type value) @private
+{
+    Node *last = list._last;
+    Node *new_node = list.@alloc_node();
+    *new_node = { .prev = last, .value = value };
+    list._last = new_node;
+    if (!last)
+    {
+        list._first = new_node;
+    }
+    else
+    {
+        last.next = new_node;
+    }
+    list.size++;
+}
+
+fn Type! peek(LinkedList* list) => list.first() @inline;
+fn Type! peek_last(LinkedList* list) => list.last() @inline;
+
+fn Type! LinkedList.first(LinkedList *list)
+{
+	if (!list._first) return IteratorResult.NO_MORE_ELEMENT!;
+	return list._first.value;
+}
+
+fn Type! LinkedList.last(LinkedList* list)
+{
+	if (!list._last) return IteratorResult.NO_MORE_ELEMENT!;
+	return list._last.value;
+}
+
+fn void LinkedList.free(LinkedList* list) => list.clear() @inline;
+
+fn void LinkedList.clear(LinkedList* list)
+{
+    for (Node* node = list._first; node != null;)
+    {
+        Node* next = node.next;
+        list.@free_node(node);
+        node = next;
+    }
+    list._first = null;
+    list._last = null;
+    list.size = 0;
+}
+
+fn usz LinkedList.len(LinkedList* list) @inline => list.size;
 
 /**
- * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
- * @return "the initialized list"
+ * @require index < list.size
  **/
-fn LinkedList* LinkedList.init_new(&self, Allocator* allocator = allocator::heap()) @deprecated("Replaced by new_init")
+macro Node* LinkedList.node_at_index(LinkedList* list, usz index)
 {
-	return self.new_init(allocator);
-}
-
-fn LinkedList* LinkedList.temp_init(&self)
-{
-	return self.new_init(allocator::temp()) @inline;
-}
-
-fn LinkedList* LinkedList.init_temp(&self) @deprecated("Replaced by temp_init")
-{
-	return self.temp_init() @inline;
-}
-
-/**
- * @require self.allocator
- **/
-macro void LinkedList.free_node(&self, Node* node) @private
-{
-	allocator::free(self.allocator, node);
-}
-
-macro Node* LinkedList.alloc_node(&self) @private
-{
-	if (!self.allocator) self.allocator = allocator::heap();
-	return allocator::alloc(self.allocator, Node);
-}
-
-fn void LinkedList.link_first(&self, Type value) @private
-{
-	Node *first = self._first;
-	Node *new_node = self.alloc_node();
-	*new_node = { .next = first, .value = value };
-	self._first = new_node;
-	if (!first)
+	if (index * 2 >= list.size)
 	{
-		self._last = new_node;
+	    Node* node = list._last;
+	    index = list.size - index - 1;
+        while (index--) node = node.prev;
+        return node;
 	}
-	else
-	{
-		first.prev = new_node;
-	}
-	self.size++;
-}
-
-fn void LinkedList.link_last(&self, Type value) @private
-{
-	Node *last = self._last;
-	Node *new_node = self.alloc_node();
-	*new_node = { .prev = last, .value = value };
-	self._last = new_node;
-	if (!last)
-	{
-		self._first = new_node;
-	}
-	else
-	{
-		last.next = new_node;
-	}
-	self.size++;
-}
-
-fn Type! LinkedList.peek(&self) => self.first() @inline;
-fn Type! LinkedList.peek_last(&self) => self.last() @inline;
-
-fn Type! LinkedList.first(&self)
-{
-	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
-	return self._first.value;
-}
-
-fn Type! LinkedList.last(&self)
-{
-	if (!self._last) return IteratorResult.NO_MORE_ELEMENT?;
-	return self._last.value;
-}
-
-fn void LinkedList.free(&self) => self.clear() @inline;
-
-fn void LinkedList.clear(&self)
-{
-	for (Node* node = self._first; node != null;)
-	{
-		Node* next = node.next;
-		self.free_node(node);
-		node = next;
-	}
-	self._first = null;
-	self._last = null;
-	self.size = 0;
-}
-
-fn usz LinkedList.len(&self) @inline => self.size;
-
-/**
- * @require index < self.size
- **/
-macro Node* LinkedList.node_at_index(&self, usz index)
-{
-	if (index * 2 >= self.size)
-	{
-		Node* node = self._last;
-		index = self.size - index - 1;
-		while (index--) node = node.prev;
-		return node;
-	}
-	Node* node = self._first;
-	while (index--) node = node.next;
-	return node;
+    Node* node = list._first;
+    while (index--) node = node.next;
+    return node;
 }
 /**
- * @require index < self.size
+ * @require index < list.size
  **/
-fn Type LinkedList.get(&self, usz index)
+fn Type LinkedList.get(LinkedList* list, usz index)
 {
-	return self.node_at_index(index).value;
+	return list.node_at_index(index).value;
 }
 
 /**
- * @require index < self.size
+ * @require index < list.size
  **/
-fn void LinkedList.set(&self, usz index, Type element)
+fn void LinkedList.set(LinkedList* list, usz index, Type element)
 {
-	self.node_at_index(index).value = element;
+	list.node_at_index(index).value = element;
 }
 
 /**
- * @require index < self.size
+ * @require index < list.size
  **/
-fn void LinkedList.remove(&self, usz index)
+fn void LinkedList.remove(LinkedList* list, usz index)
 {
-	self.unlink(self.node_at_index(index));
+	list.unlink(list.node_at_index(index));
 }
 
 /**
- * @require index <= self.size
+ * @require index <= list.size
  **/
-fn void LinkedList.insert(&self, usz index, Type element)
+fn void LinkedList.insert(LinkedList* list, usz index, Type element)
 {
 	switch (index)
 	{
 		case 0:
-			self.push(element);
-		case self.size:
-			self.push_last(element);
+			list.push(element);
+		case list.size:
+			list.push_last(element);
 		default:
-			self.link_before(self.node_at_index(index), element);
+			list.link_before(list.node_at_index(index), element);
 	}
 }
 /**
  * @require succ != null
  **/
-fn void LinkedList.link_before(&self, Node *succ, Type value) @private
+fn void LinkedList.link_before(LinkedList *list, Node *succ, Type value) @private
 {
-	Node* pred = succ.prev;
-	Node* new_node = self.alloc_node();
-	*new_node = { .prev = pred, .next = succ, .value = value };
-	succ.prev = new_node;
-	if (!pred)
-	{
-		self._first = new_node;
-	}
-	else
-	{
-		pred.next = new_node;
-	}
-	self.size++;
+    Node* pred = succ.prev;
+    Node* new_node = malloc(Node);
+    *new_node = { .prev = pred, .next = succ, .value = value };
+    succ.prev = new_node;
+    if (!pred)
+    {
+        list._first = new_node;
+    }
+    else
+    {
+        pred.next = new_node;
+    }
+    list.size++;
 }
 
 /**
- * @require self._first
+ * @require list && list._first
  **/
-fn void LinkedList.unlink_first(&self) @private
+fn void LinkedList.unlink_first(LinkedList* list) @private
 {
-	Node* f = self._first;
-	Node* next = f.next;
-	self.free_node(f);
-	self._first = next;
-	if (!next)
-	{
-		self._last = null;
-	}
-	else
-	{
-		next.prev = null;
-	}
-	self.size--;
+	Node* f = list._first;
+    Node* next = f.next;
+    list.@free_node(f);
+    list._first = next;
+    if (!next)
+    {
+        list._last = null;
+    }
+    else
+    {
+        next.prev = null;
+    }
+    list.size--;
 }
 
-fn bool LinkedList.remove_value(&self, Type t)
+fn bool LinkedList.remove_value(LinkedList* list, Type t)
 {
-	for (Node* node = self._first; node != null; node = node.next)
-	{
-		if (node.value == t)
-		{
-			self.unlink(node);
-			return true;
-		}
-	}
-	return false;
+    for (Node* node = list._first; node != null; node = node.next)
+    {
+        if (node.value == t)
+        {
+            list.unlink(node);
+            return true;
+        }
+    }
+    return false;
 }
 
-fn bool LinkedList.remove_last_value(&self, Type t)
+fn bool LinkedList.remove_last_value(LinkedList* list, Type t)
 {
-	for (Node* node = self._last; node != null; node = node.prev)
-	{
-		if (node.value == t)
-		{
-			self.unlink(node);
-			return true;
-		}
-	}
-	return false;
-}
-
-fn Type! LinkedList.pop(&self)
-{
-	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
-	defer self.unlink_first();
-	return self._first.value;
-}
-
-fn void! LinkedList.remove_last(&self)
-{
-	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
-	self.unlink_last();
-}
-
-fn void! LinkedList.remove_first(&self)
-{
-	if (!self._first) return IteratorResult.NO_MORE_ELEMENT?;
-	self.unlink_first();
+    for (Node* node = list._last; node != null; node = node.prev)
+    {
+        if (node.value == t)
+        {
+            list.unlink(node);
+            return true;
+        }
+    }
+    return false;
 }
 
 /**
- * @require self._last
+ * @param [&inout] list
  **/
-fn void LinkedList.unlink_last(&self) @inline @private
+fn Type! LinkedList.pop(LinkedList* list)
 {
-	Node* l = self._last;
-	Node* prev = l.prev;
-	self._last = prev;
-	self.free_node(l);
-	if (!prev)
-	{
-		self._first = null;
-	}
-	else
-	{
-		prev.next = null;
-	}
-	self.size--;
+	if (!list._first) return IteratorResult.NO_MORE_ELEMENT!;
+	defer list.unlink_first();
+	return list._first.value;
 }
 
 /**
- * @require x != null
+ * @param [&inout] list
  **/
-fn void LinkedList.unlink(&self, Node* x) @private
+fn void! LinkedList.remove_last(LinkedList* list)
 {
-	Node* next = x.next;
-	Node* prev = x.prev;
-	if (!prev)
-	{
-		self._first = next;
-	}
-	else
-	{
-		prev.next = next;
-	}
-	if (!next)
-	{
-		self._last = prev;
-	}
-	else
-	{
-		next.prev = prev;
-	}
-	self.free_node(x);
-	self.size--;
+	if (!list._first) return IteratorResult.NO_MORE_ELEMENT!;
+	list.unlink_last();
+}
+
+/**
+ * @param [&inout] list
+ **/
+fn void! LinkedList.remove_first(LinkedList* list)
+{
+	if (!list._first) return IteratorResult.NO_MORE_ELEMENT!;
+	list.unlink_first();
+}
+
+/**
+ * @param [&inout] list
+ * @require list._last
+ **/
+fn void LinkedList.unlink_last(LinkedList *list) @inline @private
+{
+	Node* l = list._last;
+    Node* prev = l.prev;
+    list._last = prev;
+    list.@free_node(l);
+    if (!prev)
+    {
+        list._first = null;
+    }
+    else
+    {
+        prev.next = null;
+    }
+    list.size--;
+}
+
+/**
+ * @require list != null, x != null
+ **/
+fn void LinkedList.unlink(LinkedList* list, Node* x) @private
+{
+    Node* next = x.next;
+    Node* prev = x.prev;
+    if (!prev)
+    {
+        list._first = next;
+    }
+    else
+    {
+        prev.next = next;
+    }
+    if (!next)
+    {
+        list._last = prev;
+    }
+    else
+    {
+        next.prev = prev;
+    }
+    list.@free_node(x);
+    list.size--;
 }

lib/std/collections/list.c3

@@ -1,510 +1,185 @@
-// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
-// Use of self source code is governed by the MIT license
+// Copyright (c) 2021 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::list(<Type>);
-import std::io,std::math;
+module std::collections::list<Type>;
+import std::math;
 
-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;
-
-struct List (Printable)
+struct List
 {
-	usz size;
-	usz capacity;
-	Allocator *allocator;
-	Type *entries;
+    usz size;
+    usz capacity;
+    Allocator *allocator;
+    Type *entries;
 }
 
-
 /**
- * @param initial_capacity "The initial capacity to reserve"
- * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
+ * @require using != null "A valid allocator must be provided"
  **/
-fn List* List.new_init(&self, usz initial_capacity = 16, Allocator* allocator = allocator::heap())
+fn void List.init(List* list, usz initial_capacity = 16, Allocator* using = mem::heap())
 {
-	self.allocator = allocator;
-	self.size = 0;
+	list.allocator = using;
+	list.size = 0;
 	if (initial_capacity > 0)
 	{
 		initial_capacity = math::next_power_of_2(initial_capacity);
-		self.entries = allocator::malloc_aligned(allocator, Type.sizeof * initial_capacity, .alignment = Type[1].alignof)!!;
+		list.entries = malloc_aligned(Type, initial_capacity, .alignment = Type[1].alignof, .using = using)!!;
 	}
 	else
 	{
-		self.entries = null;
+		list.entries = null;
 	}
-	self.capacity = initial_capacity;
-	return self;
+	list.capacity = initial_capacity;
+}
+
+fn void List.tinit(List* list, usz initial_capacity = 16)
+{
+	list.init(initial_capacity, mem::temp()) @inline;
+}
+
+fn void List.push(List* list, Type element) @inline
+{
+    list.append(element);
+}
+
+fn void List.append(List* list, Type element)
+{
+    list.ensure_capacity();
+    list.entries[list.size++] = element;
 }
 
 /**
- * @param initial_capacity "The initial capacity to reserve"
- * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
- **/
-fn List* List.init_new(&self, usz initial_capacity = 16, Allocator* allocator = allocator::heap()) @deprecated("Replaced by new_init")
+ * @require list.size > 0
+ */
+fn Type List.pop(List* list)
 {
-	return self.new_init(initial_capacity, allocator) @inline;
+    return list.entries[--list.size];
+}
+
+fn void List.clear(List* list)
+{
+    list.size = 0;
 }
 
 /**
- * Initialize the list using the temp allocator.
- *
- * @param initial_capacity "The initial capacity to reserve"
- **/
-fn List* List.temp_init(&self, usz initial_capacity = 16)
+ * @require list.size > 0
+ */
+fn Type List.pop_first(List* list)
 {
-	return self.new_init(initial_capacity, allocator::temp()) @inline;
+    Type value = list.entries[0];
+    list.remove_at(0);
+    return value;
+}
+
+fn void List.remove_at(List* list, usz index)
+{
+    for (usz i = index + 1; i < list.size; i++)
+    {
+        list.entries[i - 1] = list.entries[i];
+    }
+    list.size--;
+}
+
+fn void List.push_front(List* list, Type type) @inline
+{
+    list.insert_at(0, type);
+}
+
+fn void List.insert_at(List* list, usz index, Type type)
+{
+    list.ensure_capacity();
+    for (usz i = list.size; i > index; i--)
+    {
+        list.entries[i] = list.entries[i - 1];
+    }
+    list.size++;
+    list.entries[index] = type;
 }
 
 /**
- * Initialize the list using the temp allocator.
- *
- * @param initial_capacity "The initial capacity to reserve"
+ * @require index < list.size
  **/
-fn List* List.init_temp(&self, usz initial_capacity = 16) @deprecated("Replaced by temp_init")
+fn void List.set_at(List* list, usz index, Type type)
 {
-	return self.temp_init(initial_capacity) @inline;
+    list.entries[index] = type;
 }
 
-/**
- * @require self.size == 0 "The List must be empty"
- **/
-fn void List.init_wrapping_array(&self, Type[] types, Allocator* allocator = allocator::heap())
+fn void List.remove_last(List* list)
 {
-	self.allocator = allocator;
-	self.size = types.len;
-	self.capacity = types.len;
-	self.entries = types.ptr;
+    list.size--;
 }
 
-fn usz! List.to_format(&self, Formatter* formatter) @dynamic
+fn void List.remove_first(List* list)
 {
-	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;
-	}
+    list.remove_at(0);
 }
 
-fn String List.to_new_string(&self, Allocator* allocator = allocator::heap()) @dynamic
+fn Type* List.first(List* list)
 {
-	return string::new_format("%s", *self, .allocator = allocator);
+    return list.size ? &list.entries[0] : null;
 }
 
-fn String List.to_tstring(&self)
+fn Type* List.last(List* list)
 {
-	return string::tformat("%s", *self);
+    return list.size ? &list.entries[list.size - 1] : null;
 }
 
-fn void List.push(&self, Type element) @inline
+fn bool List.is_empty(List* list)
 {
-	self.append(element);
+    return !list.size;
 }
 
-fn void List.append(&self, Type element)
+fn usz List.len(List* list) @operator(len)
 {
-	self.ensure_capacity();
-	self.entries[self.size++] = element;
+    return list.size;
 }
 
-/**
- * @require self.size > 0
- **/
-fn Type List.pop(&self)
+fn Type List.get(List* list, usz index)
 {
-	return self.entries[--self.size];
+    return list.entries[index];
 }
 
-fn void List.clear(&self)
+fn void List.free(List* list)
 {
-	self.size = 0;
+	if (!list.allocator) return;
+    free_aligned(list.entries, .using = list.allocator);
+    list.capacity = 0;
+    list.size = 0;
+    list.entries = null;
 }
 
-/**
- * @require self.size > 0
- **/
-fn Type List.pop_first(&self)
+fn void List.swap(List* list, usz i, usz j)
 {
-	Type value = self.entries[0];
-	self.remove_at(0);
-	return value;
-}
-
-/**
- * @require index < self.size
- **/
-fn void List.remove_at(&self, usz index)
-{
-	if (!--self.size || index == self.size) return;
-	self.entries[index .. self.size - 1] = self.entries[index + 1 .. self.size];
-}
-
-fn void List.add_all(&self, List* other_list)
-{
-	if (!other_list.size) return;
-	self.reserve(other_list.size);
-	foreach (&value : other_list)
-	{
-		self.entries[self.size++] = *value;
-	}
-}
-
-
-fn 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;
-}
-
-fn Type[] List.to_tarray(&self)
-{
-	return self.to_new_array(allocator::temp());
-}
-
-/**
- * Reverse the elements in a list.
- **/
-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]);
-	}
-}
-
-fn Type[] List.array_view(&self)
-{
-	return self.entries[:self.size];
-}
-
-fn void List.add_array(&self, Type[] array)
-{
-	if (!array.len) return;
-	self.reserve(array.len);
-	foreach (&value : array)
-	{
-		self.entries[self.size++] = *value;
-	}
-}
-
-fn void List.push_front(&self, Type type) @inline
-{
-	self.insert_at(0, type);
-}
-
-/**
- * @require index < self.size
- **/
-fn void List.insert_at(&self, usz index, Type type)
-{
-	self.ensure_capacity();
-	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 List.set_at(&self, usz index, Type type)
-{
-	self.entries[index] = type;
-}
-
-/**
- * @require self.size > 0
- **/
-fn void List.remove_last(&self)
-{
-	self.size--;
-}
-
-/**
- * @require self.size > 0
- **/
-fn void List.remove_first(&self)
-{
-	self.remove_at(0);
-}
-
-fn Type* List.first(&self)
-{
-	return self.size ? &self.entries[0] : null;
-}
-
-fn Type* List.last(&self)
-{
-	return self.size ? &self.entries[self.size - 1] : null;
-}
-
-fn bool List.is_empty(&self) @inline
-{
-	return !self.size;
-}
-
-fn usz List.byte_size(&self) @inline
-{
-	return Type.sizeof * self.size;
-}
-
-fn usz List.len(&self) @operator(len) @inline
-{
-	return self.size;
-}
-
-fn Type List.get(&self, usz index) @inline
-{
-	return self.entries[index];
-}
-
-fn void List.free(&self)
-{
-	if (!self.allocator) return;
-	allocator::free_aligned(self.allocator, self.entries);
-	self.capacity = 0;
-	self.size = 0;
-	self.entries = null;
-}
-
-fn void List.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 List.remove_if(&self, ElementPredicate filter)
-{
-	return self._remove_if(filter, false);
-}
-
-/**
- * @param selection "The function to determine if it should be kept or not"
- * @return "the number of deleted elements"
- **/
-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;
-}
-
-fn usz List.remove_using_test(&self, ElementTest filter, any* context)
-{
-	return self._remove_using_test(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
-	}
-	return size - self.size;
+	@swap(list.entries[i], list.entries[j]);
 }
 
 /**
  * Reserve at least min_capacity
  **/
-fn void List.reserve(&self, usz min_capacity)
+fn void List.reserve(List* list, usz min_capacity)
 {
 	if (!min_capacity) return;
-	if (self.capacity >= min_capacity) return;
-	if (!self.allocator) self.allocator = allocator::heap();
+	if (list.capacity >= min_capacity) return;
+	if (!list.allocator) list.allocator = mem::heap();
 	min_capacity = math::next_power_of_2(min_capacity);
-	self.entries = allocator::realloc_aligned(self.allocator, self.entries, Type.sizeof * min_capacity, .alignment = Type[1].alignof) ?? null;
-	self.capacity = min_capacity;
+    list.entries = realloc_aligned(list.entries, Type.sizeof * min_capacity, .alignment = Type[1].alignof, .using = list.allocator) ?? null;
+	list.capacity = min_capacity;
 }
 
-macro Type List.@item_at(&self, usz index) @operator([])
+macro Type List.@item_at(List &list, usz index) @operator([])
 {
-	return self.entries[index];
+    return list.entries[index];
 }
 
-fn Type* List.get_ref(&self, usz index) @operator(&[]) @inline
+fn Type* List.get_ref(List* list, usz index) @operator(&[]) @inline
 {
-	return &self.entries[index];
+    return &list.entries[index];
 }
 
-fn void List.set(&self, usz index, Type value) @operator([]=)
+
+fn void List.ensure_capacity(List* list) @inline @private
 {
-	self.entries[index] = value;
-}
-
-fn void List.ensure_capacity(&self, usz added = 1) @inline @private
-{
-	usz new_size = self.size + added;
-	if (self.capacity >= new_size) return;
-
-	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);
-}
-
-// Functions for equatable types
-
-
-fn usz! List.index_of(&self, Type type) @if(ELEMENT_IS_EQUATABLE)
-{
-	foreach (i, v : self)
-	{
-		if (equals(v, type)) return i;
-	}
-	return SearchResult.MISSING?;
-}
-
-fn usz! List.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 List.equals(&self, List 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 List.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 "the number of deleted elements."
- **/
-fn usz List.remove(&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 < size; j++)
-		{
-			self.entries[j - 1] = self.entries[j];
-		}
-		self.size--;
-	}
-	return size - self.size;
-}
-
-fn void List.remove_all(&self, List* other_list) @if(ELEMENT_IS_EQUATABLE)
-{
-	if (!other_list.size) return;
-	foreach (v : other_list) self.remove(v);
-}
-
-/**
- * @param [&in] self
- * @return "The number non-null values in the list"
- **/
-fn usz List.compact_count(&self) @if(ELEMENT_IS_POINTER)
-{
-	usz vals = 0;
-	foreach (v : self) if (v) vals++;
-	return vals;
-}
-
-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--;
-	}
-	return size - self.size;
+    if (list.capacity == list.size)
+    {
+        list.reserve(list.capacity ? 2 * list.capacity : 16);
+    }
 }

lib/std/collections/map.c3

@@ -1,14 +1,13 @@
 // 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>);
+module std::collections::map<Key, Value>;
 import std::math;
 
 const uint DEFAULT_INITIAL_CAPACITY = 16;
 const uint MAXIMUM_CAPACITY = 1u << 31;
 const float DEFAULT_LOAD_FACTOR = 0.75;
-const VALUE_IS_EQUATABLE = Value.is_eq;
-const bool COPY_KEYS = types::implements_copy(Key);
+
 
 struct HashMap
 {
@@ -20,43 +19,19 @@ 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 !map.allocator "Map was already initialized"
  * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
+ * @require using != null "The allocator must be non-null"
  **/
-fn HashMap* HashMap.new_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator* allocator = allocator::heap())
+fn void HashMap.init(HashMap* map, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator* using = mem::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;
-}
-
-/**
- * @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 !map.allocator "Map was already initialized"
- * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
- **/
-fn HashMap* HashMap.init_new(&map, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR, Allocator* allocator = allocator::heap()) @deprecated("Replaced by new_init")
-{
-	return map.new_init(capacity, load_factor, allocator);
-}
-
-/**
- * @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.new_init(capacity, load_factor, allocator::temp()) @inline;
+	map.allocator = using;
+	map.load_factor = load_factor;
+	map.threshold = (uint)(capacity * load_factor);
+	map.table = calloc(Entry*, capacity, .using = using);
 }
 
 /**
@@ -65,97 +40,53 @@ fn HashMap* HashMap.temp_init(&self, uint capacity = DEFAULT_INITIAL_CAPACITY, f
  * @require !map.allocator "Map was already initialized"
  * @require capacity < MAXIMUM_CAPACITY "Capacity cannot exceed maximum"
  **/
-fn HashMap* HashMap.init_temp(&map, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR) @deprecated("Replaced by temp_init")
+fn void HashMap.tinit(HashMap* map, uint capacity = DEFAULT_INITIAL_CAPACITY, float load_factor = DEFAULT_LOAD_FACTOR)
 {
-	return map.temp_init(capacity, load_factor) @inline;
+	map.init(capacity, load_factor, mem::temp());
 }
 
-/**
- * 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)
+fn void HashMap.init_from_map(HashMap* map, HashMap* other_map, Allocator* using = mem::heap())
 {
-	return (bool)map.allocator;
+	map.init(other_map.table.len, other_map.load_factor, using);
+	map.put_all_for_create(other_map);
 }
 
-/**
- * @param [&inout] allocator "The allocator to use"
- * @param [&in] other_map "The map to copy from."
- **/
-fn HashMap* HashMap.new_init_from_map(&self, HashMap* other_map, Allocator* allocator = allocator::heap())
+fn void HashMap.tinit_from_map(HashMap* map, HashMap* other_map)
 {
-	self.new_init(other_map.table.len, other_map.load_factor, allocator);
-	self.put_all_for_create(other_map);
-	return self;
+	map.init_from_map(other_map, mem::temp()) @inline;
 }
 
-/**
- * @param [&inout] allocator "The allocator to use"
- * @param [&in] other_map "The map to copy from."
- **/
-fn HashMap* HashMap.init_new_from_map(&self, HashMap* other_map, Allocator* allocator = allocator::heap()) @deprecated("Replaced by new_init_from_map")
-
-{
-	return self.new_init_from_map(other_map, allocator) @inline;
-}
-
-/**
- * @param [&in] other_map "The map to copy from."
- **/
-fn HashMap* HashMap.temp_init_from_map(&map, HashMap* other_map)
-{
-	return map.new_init_from_map(other_map, allocator::temp()) @inline;
-}
-
-/**
- * @param [&in] other_map "The map to copy from."
- **/
-fn HashMap* HashMap.init_temp_from_map(&map, HashMap* other_map) @deprecated("Replaced by temp_init_from_map")
-{
-	return map.temp_init_from_map(other_map) @inline;
-}
-
-
-fn bool HashMap.is_empty(&map) @inline
+fn bool HashMap.is_empty(HashMap* map) @inline
 {
 	return !map.count;
 }
 
-fn usz HashMap.len(&map) @inline
+fn Value*! HashMap.get_ref(HashMap* map, Key key)
 {
-	return map.count;
-}
-
-fn Value*! HashMap.get_ref(&map, Key key)
-{
-	if (!map.count) return SearchResult.MISSING?;
+	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?;
+	return SearchResult.MISSING!;
 }
 
-fn Entry*! HashMap.get_entry(&map, Key key)
+fn Entry*! HashMap.get_entry(HashMap* map, Key key)
 {
-	if (!map.count) return SearchResult.MISSING?;
+	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?;
+	return SearchResult.MISSING!;
 }
 
 /**
  * Get the value or update and
- * @require $assignable(#expr, Value)
  **/
-macro Value HashMap.@get_or_set(&map, Key key, Value #expr)
+macro Value HashMap.@get_or_set(HashMap* map, Key key, Value #expr)
 {
 	if (!map.count)
 	{
@@ -174,22 +105,22 @@ macro Value HashMap.@get_or_set(&map, Key key, Value #expr)
 	return val;
 }
 
-fn Value! HashMap.get(&map, Key key) @operator([])
+fn Value! HashMap.get(HashMap* map, Key key) @operator([])
 {
 	return *map.get_ref(key) @inline;
 }
 
-fn bool HashMap.has_key(&map, Key key)
+fn bool HashMap.has_key(HashMap* map, Key key)
 {
-	return @ok(map.get_ref(key));
+	return try? map.get_ref(key);
 }
 
-fn bool HashMap.set(&map, Key key, Value value) @operator([]=)
+fn bool HashMap.set(HashMap* map, Key key, Value value) @operator([]=)
 {
 	// If the map isn't initialized, use the defaults to initialize it.
 	if (!map.allocator)
 	{
-		map.new_init();
+		map.init();
 	}
 	uint hash = rehash(key.hash());
 	uint index = index_for(hash, map.table.len);
@@ -205,49 +136,42 @@ fn bool HashMap.set(&map, Key key, Value value) @operator([]=)
 	return false;
 }
 
-fn void! HashMap.remove(&map, Key key) @maydiscard
+fn void! HashMap.remove(HashMap* map, Key key) @maydiscard
 {
-	if (!map.remove_entry_for_key(key)) return SearchResult.MISSING?;
+	if (!map.remove_entry_for_key(key)) return SearchResult.MISSING!;
 }
 
-fn void HashMap.clear(&map)
+fn void HashMap.clear(HashMap* 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);
+		map.free_internal(entry);
 		*entry_ref = null;
 	}
 	map.count = 0;
 }
 
-fn void HashMap.free(&map)
+fn void HashMap.free(HashMap* map)
 {
 	if (!map.allocator) return;
 	map.clear();
 	map.free_internal(map.table.ptr);
-	map.table = {};
+	map.table = Entry*[] {};
 }
 
-fn Key[] HashMap.key_tlist(&map)
+fn Key[] HashMap.key_tlist(HashMap* map)
 {
-	return map.key_new_list(allocator::temp()) @inline;
+	return map.key_list(mem::temp()) @inline;
 }
 
-fn Key[] HashMap.key_new_list(&map, Allocator* allocator = allocator::heap())
+fn Key[] HashMap.key_list(HashMap* map, Allocator* using = mem::heap())
 {
-	if (!map.count) return {};
+	if (!map.count) return Key[] {};
 
-	Key[] list = allocator::alloc_array(allocator, Key, map.count);
+	Key[] list = calloc(Key, map.count, .using = using);
 	usz index = 0;
 	foreach (Entry* entry : map.table)
 	{
@@ -260,37 +184,15 @@ fn Key[] HashMap.key_new_list(&map, Allocator* allocator = allocator::heap())
 	return list;
 }
 
-macro HashMap.@each(map; @body(key, value))
+fn Value[] HashMap.value_tlist(HashMap* map)
 {
-	map.@each_entry(; Entry* entry) {
-		@body(entry.key, entry.value);
-	};
+	return map.value_list(mem::temp()) @inline;
 }
 
-macro HashMap.@each_entry(map; @body(entry))
+fn Value[] HashMap.value_list(HashMap* map, Allocator* using = mem::heap())
 {
-	if (map.count)
-	{
-		foreach (Entry* entry : map.table)
-		{
-			while (entry)
-			{
-				@body(entry);
-				entry = entry.next;
-			}
-		}
-	}
-}
-
-fn Value[] HashMap.value_tlist(&map)
-{
-	return map.value_new_list(allocator::temp()) @inline;
-}
-
-fn Value[] HashMap.value_new_list(&map, Allocator* allocator = allocator::heap())
-{
-	if (!map.count) return {};
-	Value[] list = allocator::alloc_array(allocator, Value, map.count);
+	if (!map.count) return Value[] {};
+	Value[] list = calloc(Value, map.count, .using = using);
 	usz index = 0;
 	foreach (Entry* entry : map.table)
 	{
@@ -303,7 +205,8 @@ 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)
+$if (types::is_equatable(Value))
+fn bool HashMap.has_value(HashMap* map, Value v)
 {
 	if (!map.count) return false;
 	foreach (Entry* entry : map.table)
@@ -316,23 +219,22 @@ fn bool HashMap.has_value(&map, Value v) @if(VALUE_IS_EQUATABLE)
 	}
 	return false;
 }
+$endif
 
 // --- private methods
 
-fn void HashMap.add_entry(&map, uint hash, Key key, Value value, uint bucket_index) @private
+fn void HashMap.add_entry(HashMap* 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] });
+	Entry* entry = malloc(Entry, .using = 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
+fn void HashMap.resize(HashMap* map, uint new_capacity) @private
 {
 	Entry*[] old_table = map.table;
 	uint old_capacity = old_table.len;
@@ -341,7 +243,7 @@ fn void HashMap.resize(&map, uint new_capacity) @private
 		map.threshold = uint.max;
 		return;
 	}
-	Entry*[] new_table = allocator::new_array(map.allocator, Entry*, new_capacity);
+	Entry*[] new_table = calloc(Entry*, new_capacity, .using = map.allocator);
 	map.transfer(new_table);
 	map.table = new_table;
 	map.free_internal(old_table.ptr);
@@ -350,8 +252,8 @@ fn void HashMap.resize(&map, uint new_capacity) @private
 
 fn uint rehash(uint hash) @inline @private
 {
-	hash ^= (hash >> 20) ^ (hash >> 12);
-	return hash ^ ((hash >> 7) ^ (hash >> 4));
+    hash ^= (hash >> 20) ^ (hash >> 12);
+    return hash ^ ((hash >> 7) ^ (hash >> 4));
 }
 
 macro uint index_for(uint hash, uint capacity) @private
@@ -359,39 +261,39 @@ macro uint index_for(uint hash, uint capacity) @private
 	return hash & (capacity - 1);
 }
 
-fn void HashMap.transfer(&map, Entry*[] new_table) @private
+fn void HashMap.transfer(HashMap* 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);
-	}
+    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
+fn void HashMap.put_all_for_create(HashMap* 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);
-	}
+    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
+fn void HashMap.put_for_create(HashMap* map, Key key, Value value) @private
 {
-	uint hash = rehash(key.hash());
-	uint i = index_for(hash, map.table.len);
+    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))
@@ -403,12 +305,12 @@ fn void HashMap.put_for_create(&map, Key key, Value value) @private
 	map.create_entry(hash, key, value, i);
 }
 
-fn void HashMap.free_internal(&map, void* ptr) @inline @private
+fn void HashMap.free_internal(HashMap* map, void* ptr) @inline @private
 {
-	allocator::free(map.allocator, ptr);
+	map.allocator.free(ptr)!!;
 }
 
-fn bool HashMap.remove_entry_for_key(&map, Key key) @private
+fn bool HashMap.remove_entry_for_key(HashMap* map, Key key) @private
 {
 	uint hash = rehash(key.hash());
 	uint i = index_for(hash, map.table.len);
@@ -428,7 +330,7 @@ fn bool HashMap.remove_entry_for_key(&map, Key key) @private
 			{
 				prev.next = next;
 			}
-			map.free_entry(e);
+			map.free_internal(e);
 			return true;
 		}
 		prev = e;
@@ -437,29 +339,19 @@ 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 HashMap.create_entry(HashMap* 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] });
+	Entry* entry = malloc(Entry, .using = 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);
-}
-
 struct Entry
 {
 	uint hash;
 	Key key;
 	Value value;
 	Entry* next;
-}
+}

lib/std/collections/maybe.c3

@@ -1,19 +0,0 @@
-module std::collections::maybe(<Type>);
-
-struct Maybe
-{
-	Type value;
-	bool has_value;
-}
-
-fn Maybe value(Type val)
-{
-	return { .value = val, .has_value = true };
-}
-
-const Maybe EMPTY = { };
-
-macro Type! Maybe.get(self)
-{
-	return self.has_value ? self.value : SearchResult.MISSING?;
-}

lib/std/collections/object.c3

@@ -2,13 +2,15 @@
 // 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::object;
-import std::collections::map, std::collections::list, std::io;
+import std::collections::map;
+import std::collections::list;
+import std::io;
 
 const Object TRUE_OBJECT = { .b = true, .type = bool.typeid };
 const Object FALSE_OBJECT = { .b = false, .type = bool.typeid };
 const Object NULL_OBJECT = { .type = void*.typeid };
 
-struct Object (Printable)
+struct Object
 {
 	typeid type;
 	Allocator* allocator;
@@ -24,61 +26,65 @@ struct Object (Printable)
 	}
 }
 
-
-fn usz! Object.to_format(&self, Formatter* formatter) @dynamic
+static initialize
 {
-	switch (self.type)
+	io::formatter_register_type(Object);
+}
+
+fn void! Object.to_format(Object* o, Formatter* formatter)
+{
+	switch (o.type)
 	{
 		case void:
-			return formatter.printf("{}")!;
+			formatter.printf("{}")?;
 		case void*:
-			return formatter.printf("null")!;
+			formatter.printf("null")?;
 		case String:
-			return formatter.printf(`"%s"`, self.s)!;
+			formatter.printf(`"%s"`, o.s)?;
 		case bool:
-			return formatter.printf(self.b ? "true" : "false")!;
+			formatter.printf(o.b ? "true" : "false")?;
 		case ObjectInternalList:
-			usz n = formatter.printf("[")!;
-			foreach (i, ol : self.array)
+			formatter.printf("[")?;
+			foreach (i, ol : o.array)
 			{
-				if (i > 0) n += formatter.printf(",")!;
-				n += ol.to_format(formatter)!;
+				formatter.printf(i == 0 ? " " : ", ")?;
+				ol.to_format(formatter)?;
 			}
-			n += formatter.printf("]")!;
-			return n;
+			formatter.printf(" ]")?;
 		case ObjectInternalMap:
-			usz n = formatter.printf("{")!;
+			formatter.printf("{")?;
 			@pool()
 			{
-				foreach (i, key : self.map.key_tlist())
+				foreach (i, key : o.map.key_tlist())
 				{
-					if (i > 0) n += formatter.printf(",")!;
-					n += formatter.printf(`"%s":`, key)!;
-					n += self.map.get(key).to_format(formatter)!;
+					formatter.printf(i == 0 ? " " : ", ")?;
+					formatter.printf(`"%s": `, key)?;
+					o.map.get(key).to_format(formatter)?;
 				}
 			};
-			n += formatter.printf("}")!;
-			return n;
+			formatter.printf(" }")?;
 		default:
-			switch (self.type.kindof)
+			switch (o.type.kindof)
 			{
 				case SIGNED_INT:
-					return formatter.printf("%d", self.i)!;
+					formatter.printf("%d", o.i)?;
 				case UNSIGNED_INT:
-					return formatter.printf("%d", (uint128)self.i)!;
+					formatter.printf("%d", (uint128)o.i)?;
 				case FLOAT:
-					return formatter.printf("%d", self.f)!;
+					formatter.printf("%d", o.f)?;
 				case ENUM:
-					return formatter.printf("%d", self.i)!;
+					formatter.printf("%d", o.i)?;
 				default:
-					return formatter.printf("<>")!;
+					formatter.printf("<>")?;
 			}
 	}
 }
 
-fn Object* new_obj(Allocator* allocator)
+fn Object* new_obj(Allocator* using = mem::heap())
 {
-	return allocator::new(allocator, Object, { .allocator = allocator, .type = void.typeid });
+	Object* o = malloc(Object, .using = using);
+	*o = { .allocator = using, .type = void.typeid };
+	return o;
 }
 
 fn Object* new_null()
@@ -86,24 +92,32 @@ fn Object* new_null()
 	return &NULL_OBJECT;
 }
 
-fn Object* new_int(int128 i, Allocator* allocator)
+fn Object* new_int(int128 i, Allocator* using = mem::heap())
 {
-	return allocator::new(allocator, Object, { .i = i, .allocator = allocator, .type = int128.typeid });
+	Object* o = malloc(Object, .using = using);
+	*o = { .i = i, .allocator = using, .type = int128.typeid };
+	return o;
 }
 
-macro Object* new_enum(e, Allocator* allocator)
+macro Object* new_enum(e, Allocator* using = mem::heap())
 {
-	return allocator::new(allocator, Object, { .i = (int128)e, .allocator = allocator, .type = @typeid(e) });
+	Object* o = malloc(Object, .using = using);
+	*o = { .i = (int128)e, .allocator = using, .type = $typeof(e).typeid };
+	return o;
 }
 
-fn Object* new_float(double f, Allocator* allocator)
+fn Object* new_float(double f, Allocator* using = mem::current_allocator())
 {
-	return allocator::new(allocator, Object, { .f = f, .allocator = allocator, .type = double.typeid });
+	Object* o = malloc(Object, .using = using);
+	*o = { .f = f, .allocator = using, .type = double.typeid };
+	return o;
 }
 
-fn Object* new_string(String s, Allocator* allocator)
+fn Object* new_string(String s, Allocator* using = mem::heap())
 {
-	return allocator::new(allocator, Object, { .s = s.copy(allocator), .allocator = allocator, .type = String.typeid });
+	Object* o = malloc(Object, .using = using);
+	*o = { .s = s.copy(using), .allocator = using, .type = String.typeid };
+	return o;
 }
 
 
@@ -112,190 +126,187 @@ fn Object* new_bool(bool b)
 	return b ? &TRUE_OBJECT : &FALSE_OBJECT;
 }
 
-fn void Object.free(&self)
+/**
+ * @param [&inout] o
+ **/
+fn void Object.free(Object* o)
 {
-	switch (self.type)
+	switch (o.type)
 	{
 		case void:
 			break;
 		case String:
-			allocator::free(self.allocator, self.s);
+			free(o.s, .using = o.allocator);
 		case ObjectInternalList:
-			foreach (ol : self.array)
+			foreach (ol : o.array)
 			{
 				ol.free();
 			}
-			self.array.free();
+			o.array.free();
 		case ObjectInternalMap:
-			self.map.@each_entry(; ObjectInternalMapEntry* entry) {
-				allocator::free(self.allocator, entry.key);
-				entry.value.free();
+			@pool()
+			{
+				foreach (key : o.map.key_tlist())
+				{
+					o.map.get(key).free();
+					free(key, .using = o.allocator);
+				}
+				o.map.free();
 			};
 		default:
 			break;
 	}
-	if (self.allocator) allocator::free(self.allocator, self);
+	if (o.allocator) free(o, .using = o.allocator);
 }
 
-fn bool Object.is_null(&self) @inline => self == &NULL_OBJECT;
-fn bool Object.is_empty(&self) @inline => self.type == void.typeid;
-fn bool Object.is_map(&self) @inline => self.type == ObjectInternalMap.typeid;
-fn bool Object.is_array(&self) @inline => self.type == ObjectInternalList.typeid;
-fn bool Object.is_bool(&self) @inline => self.type == bool.typeid;
-fn bool Object.is_string(&self) @inline => self.type == String.typeid;
-fn bool Object.is_float(&self) @inline => self.type == double.typeid;
-fn bool Object.is_int(&self) @inline => self.type == int128.typeid;
-fn bool Object.is_keyable(&self) => self.is_empty() || self.is_map();
-fn bool Object.is_indexable(&self) => self.is_empty() || self.is_array();
+fn bool Object.is_null(Object* this) @inline => this == &NULL_OBJECT;
+fn bool Object.is_empty(Object* this) @inline => this.type == void.typeid;
+fn bool Object.is_map(Object* this) @inline => this.type == ObjectInternalMap.typeid;
+fn bool Object.is_array(Object* this) @inline => this.type == ObjectInternalList.typeid;
+fn bool Object.is_bool(Object* this) @inline => this.type == bool.typeid;
+fn bool Object.is_string(Object* this) @inline => this.type == String.typeid;
+fn bool Object.is_float(Object* this) @inline => this.type == double.typeid;
+fn bool Object.is_int(Object* this) @inline => this.type == int128.typeid;
+fn bool Object.is_keyable(Object* this) => this.is_empty() || this.is_map();
+fn bool Object.is_indexable(Object* this) => this.is_empty() || this.is_array();
 
 /**
- * @require self.is_keyable()
+ * @require o.is_keyable()
  **/
-fn void Object.init_map_if_needed(&self) @private
+fn void Object.init_map_if_needed(Object* o) @private
 {
-	if (self.is_empty())
+	if (o.is_empty())
 	{
-		self.type = ObjectInternalMap.typeid;
-		self.map.new_init(.allocator = self.allocator);
+		o.type = ObjectInternalMap.typeid;
+		o.map.init(.using = o.allocator);
 	}
 }
 
 /**
- * @require self.is_indexable()
+ * @require o.is_indexable()
  **/
-fn void Object.init_array_if_needed(&self) @private
+fn void Object.init_array_if_needed(Object* o) @private
 {
-	if (self.is_empty())
+	if (o.is_empty())
 	{
-		self.type = ObjectInternalList.typeid;
-		self.array.new_init(.allocator = self.allocator);
+		o.type = ObjectInternalList.typeid;
+		o.array.init(.using = o.allocator);
 	}
 }
 
 /**
- * @require self.is_keyable()
+ * @require o.is_keyable()
  **/
-fn void Object.set_object(&self, String key, Object* new_object) @private
+fn void Object.set_object(Object* o, String key, Object* new_object) @private
 {
-	self.init_map_if_needed();
-	ObjectInternalMapEntry*! entry = self.map.get_entry(key);
+	o.init_map_if_needed();
+	ObjectInternalMapEntry*! entry = o.map.get_entry(key);
 	defer
 	{
-		(void)allocator::free(self.allocator, entry.key);
-		(void)entry.value.free();
+		(void)free(entry.key, .using = o.allocator);
+		entry.value.free();
 	}
-	self.map.set(key.copy(self.map.allocator), new_object);
+	o.map.set(key.copy(o.map.allocator), new_object);
 }
 
-macro Object* Object.object_from_value(&self, value) @private
+macro Object* object_from_value(value) @private
 {
 	var $Type = $typeof(value);
 
-	$switch
-		$case types::is_int($Type):
-			return new_int(value, self.allocator);
-		$case types::is_float($Type):
-			return new_float(value, self.allocator);
-		$case $Type.typeid == String.typeid:
-			return new_string(value, self.allocator);
-		$case $Type.typeid == bool.typeid:
-			return new_bool(value);
-		$case $Type.typeid == Object*.typeid:
-			return value;
-		$case $Type.typeid == void*.typeid:
-			if (value != null) return CastResult.TYPE_MISMATCH?;
-			return &NULL_OBJECT;
-		$case $assignable(value, String):
-			return new_string(value, self.allocator);
-		$default:
-			$error "Unsupported object type.";
-	$endswitch
+$switch
+	$case types::is_int($Type):
+		return new_int(value);
+	$case types::is_float($Type):
+		return new_float(value);
+	$case $Type.typeid == String.typeid:
+		return new_string(value);
+	$case $Type.typeid == bool.typeid:
+		return new_bool(value);
+	$case $Type.typeid == Object*.typeid:
+		return value;
+	$case $Type.typeid == void*.typeid:
+		assert(value == null);
+		return &NULL_OBJECT;
+	$case $checks(String s = value):
+		return new_string(value);
+	$default:
+		$assert(false, "Unsupported object type.");
+$endswitch
 
 }
 
-macro Object* Object.set(&self, String key, value)
+macro Object* Object.set(Object* o, String key, value)
 {
-	Object* val = self.object_from_value(value);
-	self.set_object(key, val);
+	Object* val = object_from_value(value);
+	o.set_object(key, val);
 	return val;
 }
 
 /**
- * @require self.is_indexable()
+ * @require o.is_indexable()
  **/
-macro Object* Object.set_at(&self, usz index, String key, value)
+macro Object* Object.set_at(Object* o, usz index, String key, value)
 {
-	Object* val = self.object_from_value(value);
-	self.set_object_at(key, index, val);
+	Object* val = object_from_value(value);
+	o.set_object_at(key, index, val);
 	return val;
 }
 
 /**
- * @require self.is_indexable()
+ * @require o.is_indexable()
  * @ensure return != null
  **/
-macro Object* Object.append(&self, value)
+macro Object* Object.append(Object* o, value)
 {
-	Object* val = self.object_from_value(value);
-	self.append_object(val);
+	Object* val = object_from_value(value);
+	o.append_object(val);
 	return val;
 }
 
 /**
- * @require self.is_keyable()
+ * @require o.is_keyable()
  **/
-fn Object*! Object.get(&self, String key) => self.is_empty() ? SearchResult.MISSING? : self.map.get(key);
+fn Object*! Object.get(Object* o, String key) => o.is_empty() ? SearchResult.MISSING! : o.map.get(key);
 
 
-fn bool Object.has_key(&self, String key) => self.is_map() && self.map.has_key(key);
+fn bool Object.has_key(Object* o, String key) => o.is_map() && o.map.has_key(key);
 
 /**
- * @require self.is_indexable()
+ * @require o.is_indexable()
  **/
-fn Object* Object.get_at(&self, usz index)
+fn Object* Object.get_at(Object* o, usz index)
 {
-	return self.array.get(index);
+	return o.array.get(index);
 }
 
 /**
- * @require self.is_indexable()
+ * @require o.is_indexable()
  **/
-fn usz Object.get_len(&self)
+fn void Object.append_object(Object* o, Object* to_append)
 {
-	return self.array.len();
+	o.init_array_if_needed();
+	o.array.append(to_append);
 }
 
 /**
- * @require self.is_indexable()
+ * @require o.is_indexable()
  **/
-fn void Object.append_object(&self, Object* to_append)
+fn void Object.set_object_at(Object* o, usz index, Object* to_set)
 {
-	self.init_array_if_needed();
-	self.array.append(to_append);
-}
-
-/**
- * @require self.is_indexable()
- **/
-fn void Object.set_object_at(&self, usz index, Object* to_set)
-{
-	self.init_array_if_needed();
-	while (self.array.len() < index)
+	o.init_array_if_needed();
+	while (o.array.len() < index)
 	{
-		self.array.append(&NULL_OBJECT);
+		o.array.append(&NULL_OBJECT);
 	}
-	if (self.array.len() == index)
+	if (o.array.len() == index)
 	{
-		self.array.append(to_set);
+		o.array.append(to_set);
 		return;
 	}
-	self.array.get(index).free();
-	self.array.set_at(index, to_set);
+	o.array.get(index).free();
+	o.array.set_at(index, to_set);
 }
 
-/**
- * @require $Type.kindof.is_int() "Expected an integer type."
- **/
 macro get_integer_value(Object* value, $Type)
 {
 	if (value.is_float())
@@ -304,126 +315,123 @@ macro get_integer_value(Object* value, $Type)
 	}
 	if (value.is_string())
 	{
-		$if $Type.kindof == TypeKind.SIGNED_INT:
-			return ($Type)value.s.to_int128();
+		$if ($Type.kindof == TypeKind.SIGNED_INT)
+			return ($Type)str::to_int128(value.s);
 		$else
-			return ($Type)value.s.to_uint128();
+			return ($Type)str::to_uint128(value.s);
 		$endif
 	}
-	if (!value.is_int()) return NumberConversion.MALFORMED_INTEGER?;
+	if (!value.is_int()) return NumberConversion.MALFORMED_INTEGER!;
 	return ($Type)value.i;
 }
 
-
 /**
- * @require self.is_indexable()
- * @require $Type.kindof.is_int() : "Expected an integer type"
+ * @require o.is_indexable()
  **/
-macro Object.get_integer_at(&self, $Type, usz index) @private
+macro Object.get_integer_at(Object* o, $Type, usz index) @private
 {
-	return get_integer_value(self.get_at(index), $Type);
+	return get_integer_value(o.get_at(index), $Type);
 }
 
 /**
- * @require self.is_keyable()
- * @require $Type.kindof.is_int() : "Expected an integer type"
+ * @require o.is_keyable()
  **/
-macro Object.get_integer(&self, $Type, String key) @private
+macro Object.get_integer(Object* o, $Type, String key) @private
 {
-	return get_integer_value(self.get(key), $Type);
+	return get_integer_value(o.get(key), $Type);
 }
 
-fn ichar! Object.get_ichar(&self, String key) => self.get_integer(ichar, key);
-fn short! Object.get_short(&self, String key) => self.get_integer(short, key);
-fn int! Object.get_int(&self, String key) => self.get_integer(int, key);
-fn long! Object.get_long(&self, String key) => self.get_integer(long, key);
-fn int128! Object.get_int128(&self, String key) => self.get_integer(int128, key);
+fn ichar! Object.get_ichar(Object* o, String key) => o.get_integer(ichar, key);
+fn short! Object.get_short(Object* o, String key) => o.get_integer(short, key);
+fn int! Object.get_int(Object* o, String key) => o.get_integer(int, key);
+fn long! Object.get_long(Object* o, String key) => o.get_integer(long, key);
+fn int128! Object.get_int128(Object* o, String key) => o.get_integer(int128, key);
 
-fn ichar! Object.get_ichar_at(&self, usz index) => self.get_integer_at(ichar, index);
-fn short! Object.get_short_at(&self, usz index) => self.get_integer_at(short, index);
-fn int! Object.get_int_at(&self, usz index) => self.get_integer_at(int, index);
-fn long! Object.get_long_at(&self, usz index) => self.get_integer_at(long, index);
-fn int128! Object.get_int128_at(&self, usz index) => self.get_integer_at(int128, index);
+fn ichar! Object.get_ichar_at(Object* o, usz index) => o.get_integer_at(ichar, index);
+fn short! Object.get_short_at(Object* o, usz index) => o.get_integer_at(short, index);
+fn int! Object.get_int_at(Object* o, usz index) => o.get_integer_at(int, index);
+fn long! Object.get_long_at(Object* o, usz index) => o.get_integer_at(long, index);
+fn int128! Object.get_int128_at(Object* o, usz index) => o.get_integer_at(int128, index);
 
-fn char! Object.get_char(&self, String key) => self.get_integer(ichar, key);
-fn short! Object.get_ushort(&self, String key) => self.get_integer(ushort, key);
-fn uint! Object.get_uint(&self, String key) => self.get_integer(uint, key);
-fn ulong! Object.get_ulong(&self, String key) => self.get_integer(ulong, key);
-fn uint128! Object.get_uint128(&self, String key) => self.get_integer(uint128, key);
+fn char! Object.get_char(Object* o, String key) => o.get_integer(ichar, key);
+fn short! Object.get_ushort(Object* o, String key) => o.get_integer(ushort, key);
+fn uint! Object.get_uint(Object* o, String key) => o.get_integer(uint, key);
+fn ulong! Object.get_ulong(Object* o, String key) => o.get_integer(ulong, key);
+fn uint128! Object.get_uint128(Object* o, String key) => o.get_integer(uint128, key);
 
-fn char! Object.get_char_at(&self, usz index) => self.get_integer_at(char, index);
-fn ushort! Object.get_ushort_at(&self, usz index) => self.get_integer_at(ushort, index);
-fn uint! Object.get_uint_at(&self, usz index) => self.get_integer_at(uint, index);
-fn ulong! Object.get_ulong_at(&self, usz index) => self.get_integer_at(ulong, index);
-fn uint128! Object.get_uint128_at(&self, usz index) => self.get_integer_at(uint128, index);
+fn char! Object.get_char_at(Object* o, usz index) => o.get_integer_at(char, index);
+fn ushort! Object.get_ushort_at(Object* o, usz index) => o.get_integer_at(ushort, index);
+fn uint! Object.get_uint_at(Object* o, usz index) => o.get_integer_at(uint, index);
+fn ulong! Object.get_ulong_at(Object* o, usz index) => o.get_integer_at(ulong, index);
+fn uint128! Object.get_uint128_at(Object* o, usz index) => o.get_integer_at(uint128, index);
 
 /**
- * @require self.is_keyable()
+ * @require o.is_keyable()
  **/
-fn String! Object.get_string(&self, String key)
+fn String! Object.get_string(Object* o, String key)
 {
-	Object* value = self.get(key)!;
-	if (!value.is_string()) return CastResult.TYPE_MISMATCH?;
+	Object* value = o.get(key)?;
+	assert(value.is_string());
 	return value.s;
 }
 
 /**
- * @require self.is_indexable()
+ * @require o.is_indexable()
  **/
-fn String! Object.get_string_at(&self, usz index)
+fn String Object.get_string_at(Object* o, usz index)
 {
-	Object* value = self.get_at(index);
-	if (!value.is_string()) return CastResult.TYPE_MISMATCH?;
+	Object* value = o.get_at(index);
+	assert(value.is_string());
 	return value.s;
 }
 
 /**
- * @require self.is_keyable()
+ * @require o.is_keyable()
  **/
-macro String! Object.get_enum(&self, $EnumType, String key)
+macro String! Object.get_enum(Object* o, $EnumType, String key)
 {
-	Object value = self.get(key)!;
-	if ($EnumType.typeid != value.type) return CastResult.TYPE_MISMATCH?;
+	Object value = o.get(key)?;
+	assert($EnumType.typeid == value.type);
 	return ($EnumType)value.i;
 }
 
 /**
- * @require self.is_indexable()
+ * @require o.is_indexable()
  **/
-macro String! Object.get_enum_at(&self, $EnumType, usz index)
+macro String Object.get_enum_at(Object* o, $EnumType, usz index)
 {
-	Object value = self.get_at(index);
-	if ($EnumType.typeid != value.type) return CastResult.TYPE_MISMATCH?;
+	Object value = o.get_at(index);
+	assert($EnumType.typeid == value.type);
 	return ($EnumType)value.i;
 }
 
 /**
- * @require self.is_keyable()
+ * @require o.is_keyable()
  **/
-fn bool! Object.get_bool(&self, String key)
+fn bool! Object.get_bool(Object* o, String key)
 {
-	Object* value = self.get(key)!;
-	if (!value.is_bool()) return CastResult.TYPE_MISMATCH?;
+	Object* value = o.get(key)?;
+	assert(value.is_bool());
 	return value.b;
 }
 
 
 /**
- * @require self.is_indexable()
+ * @require o.is_indexable()
  **/
-fn bool! Object.get_bool_at(&self, usz index)
+fn bool Object.get_bool_at(Object* o, usz index)
 {
-	Object* value = self.get_at(index);
-	if (!value.is_bool()) return CastResult.TYPE_MISMATCH?;
+	Object* value = o.get_at(index);
+	assert(value.is_bool());
 	return value.b;
 }
 
 /**
- * @require self.is_keyable()
+ * @require o.is_keyable()
  **/
-fn double! Object.get_float(&self, String key)
+fn double! Object.get_float(Object* o, String key)
 {
-	Object* value = self.get(key)!;
+	Object* value = o.get(key)?;
 	switch (value.type.kindof)
 	{
 		case SIGNED_INT:
@@ -433,16 +441,16 @@ fn double! Object.get_float(&self, String key)
 		case FLOAT:
 			return value.f;
 		default:
-			return CastResult.TYPE_MISMATCH?;
+			unreachable();
 	}
 }
 
 /**
- * @require self.is_indexable()
+ * @require o.is_indexable()
  **/
-fn double! Object.get_float_at(&self, usz index)
+fn double Object.get_float_at(Object* o, usz index)
 {
-	Object* value = self.get_at(index);
+	Object* value = o.get_at(index);
 	switch (value.type.kindof)
 	{
 		case SIGNED_INT:
@@ -452,19 +460,19 @@ fn double! Object.get_float_at(&self, usz index)
 		case FLOAT:
 			return value.f;
 		default:
-			return CastResult.TYPE_MISMATCH?;
+			unreachable();
 	}
 }
 
-fn Object* Object.get_or_create_obj(&self, String key)
+fn Object* Object.get_or_create_obj(Object* o, String key)
 {
-	if (try obj = self.get(key) && !obj.is_null()) return obj;
-	Object* container = new_obj(self.allocator);
-	self.set(key, container);
+	if (try obj = o.get(key) && !obj.is_null()) return obj;
+	Object* container = new_obj();
+	o.set(key, container);
 	return container;
 }
 
-def ObjectInternalMap = HashMap(<String, Object*>) @private;
-def ObjectInternalList = List(<Object*>) @private;
-def ObjectInternalMapEntry = Entry(<String, Object*>) @private;
+typedef ObjectInternalMap @private = HashMap<String, Object*>;
+typedef ObjectInternalList @private = List<Object*>;
+typedef ObjectInternalMapEntry @private = Entry<String, Object*>;
 

lib/std/collections/priorityqueue.c3

@@ -20,139 +20,94 @@
 //  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //  SOFTWARE.
-module std::collections::priorityqueue(<Type>);
-import std::collections::priorityqueue::private;
+module std::collections::priorityqueue<Type>;
+import std::collections::list;
 
-distinct PriorityQueue = inline PrivatePriorityQueue(<Type, false>);
-distinct PriorityQueueMax = inline PrivatePriorityQueue(<Type, true>);
+typedef Heap = List<Type>;
 
-module std::collections::priorityqueue::private(<Type, MAX>);
-import std::collections::list, std::io;
-
-def Heap = List(<Type>);
-
-struct PrivatePriorityQueue (Printable)
+struct PriorityQueue
 {
 	Heap heap;
+	bool max;  // true if max-heap, false if min-heap
 }
 
-fn void PrivatePriorityQueue.init_new(&self, usz initial_capacity = 16, Allocator* allocator = allocator::heap()) @inline @deprecated("Replaced by new_init")
+fn void PriorityQueue.push(PriorityQueue* pq, Type element)
 {
-	return self.new_init(initial_capacity, allocator);
-}
-
-fn void PrivatePriorityQueue.new_init(&self, usz initial_capacity = 16, Allocator* allocator = allocator::heap()) @inline
-{
-	self.heap.new_init(initial_capacity, allocator);
-}
-
-fn void PrivatePriorityQueue.temp_init(&self, usz initial_capacity = 16) @inline
-{
-	self.heap.new_init(initial_capacity, allocator::temp()) @inline;
-}
-
-fn void PrivatePriorityQueue.init_temp(&self, usz initial_capacity = 16) @inline @deprecated("Replaced by temp_init")
-{
-	return self.temp_init(initial_capacity) @inline;
-}
-
-fn void PrivatePriorityQueue.push(&self, Type element)
-{
-	self.heap.push(element);
-	usz i = self.heap.len() - 1;
+	pq.heap.push(element);
+	usz i = pq.heap.len() - 1;
 	while (i > 0)
 	{
 		usz parent = (i - 1) / 2;
-		Type item = self.heap[i];
-		Type parent_item = self.heap[parent];
-		$if MAX:
-			bool ok = greater(item, parent_item);
-		$else
-			bool ok = less(item, parent_item);
-		$endif
-		if (!ok) break;
-		self.heap.swap(i, parent);
-		i = parent;
+		if ((pq.max && greater(pq.heap.get(i), pq.heap.get(parent))) || (!pq.max && less(pq.heap.get(i), pq.heap.get(parent))))
+		{
+			pq.heap.swap(i, parent);
+			i = parent;
+			continue;
+		}
+		break;
 	}
 }
 
 /**
-* @require self != null
+* @require pq != null
 */
-fn Type! PrivatePriorityQueue.pop(&self)
+fn Type! PriorityQueue.pop(PriorityQueue* pq)
 {
 	usz i = 0;
-	usz len = self.heap.len();
-	if (!len) return IteratorResult.NO_MORE_ELEMENT?;
-	usz new_count = len - 1;
-	self.heap.swap(0, new_count);
-	while OUTER: ((2 * i + 1) < new_count)
+	usz len = pq.heap.len() @inline;
+	if (!len) return IteratorResult.NO_MORE_ELEMENT!;
+	usz newCount = len - 1;
+	pq.heap.swap(0, newCount);
+	while ((2 * i + 1) < newCount)
 	{
 		usz j = 2 * i + 1;
-		Type left = self.heap[j];
-		Type item = self.heap[i];
-		switch
+		if (((j + 1) < newCount) &&
+			((pq.max && greater(pq.heap.get(j + 1), pq.heap[j]))
+				|| (!pq.max && less(pq.heap.get(j + 1), pq.heap.get(j)))))
 		{
-			case j + 1 < new_count:
-				Type right = self.heap[j + 1];
-				$if MAX:
-				if (!greater(right, left)) nextcase;
-				if (!greater(right, item)) break OUTER;
-				$else
-				if (!greater(left, right)) nextcase;
-				if (!greater(item, right)) break OUTER;
-				$endif
-				j++;
-			default:
-				$if MAX:
-				if (!greater(left, item)) break OUTER;
-				$else
-				if (!greater(item, left)) break OUTER;
-				$endif
+			j++;
 		}
-		self.heap.swap(i, j);
-		i = j;
+		if ((pq.max && less(pq.heap.get(i), pq.heap.get(j))) || (!pq.max && greater(pq.heap.get(i), pq.heap.get(j))))
+		{
+			pq.heap.swap(i, j);
+			i = j;
+			continue;
+		}
+		break;
 	}
 
-	return self.heap.pop();
-}
-
-fn Type! PrivatePriorityQueue.peek(&self)
-{
-	if (!self.len()) return IteratorResult.NO_MORE_ELEMENT?;
-	return self.heap.get(0);
-}
-
-fn void PrivatePriorityQueue.free(&self)
-{
-	self.heap.free();
-}
-
-fn usz PrivatePriorityQueue.len(&self) @operator(len)
-{
-	return self.heap.len();
-}
-
-fn bool PrivatePriorityQueue.is_empty(&self)
-{
-	return self.heap.is_empty();
+	return pq.heap.pop();
 }
 
 /**
- * @require index < self.len()
+ * @require pq != null
  */
-fn Type PrivatePriorityQueue.peek_at(&self, usz index) @operator([])
+fn Type! PriorityQueue.peek(PriorityQueue* pq)
 {
-	return self.heap[index];
+	if (!pq.len()) return IteratorResult.NO_MORE_ELEMENT!;
+	return pq.heap.get(0);
 }
 
-fn usz! PrivatePriorityQueue.to_format(&self, Formatter* formatter) @dynamic
+/**
+ * @require pq != null
+ */
+fn void PriorityQueue.free(PriorityQueue* pq)
 {
-	return self.heap.to_format(formatter);
+	pq.heap.free();
 }
 
-fn String PrivatePriorityQueue.to_new_string(&self, Allocator* allocator = allocator::heap()) @dynamic
+/**
+ * @require pq != null
+ */
+fn usz PriorityQueue.len(PriorityQueue* pq) @operator(len)
 {
-	return self.heap.to_new_string(allocator);
+	return pq.heap.len();
 }
 
+/**
+ * @require pq != null, index < pq.len()
+ */
+fn Type PriorityQueue.peek_at(PriorityQueue* pq, usz index) @operator([])
+{
+	return pq.heap[index];
+}

lib/std/collections/range.c3

@@ -1,85 +0,0 @@
-/**
- * @require Type.is_ordered : "The type must be ordered"
- **/
-module std::collections::range(<Type>);
-import std::io;
-
-struct Range (Printable)
-{
-	Type start;
-	Type end;
-}
-
-fn usz Range.len(&self) @operator(len)
-{
-	if (self.end < self.start) return 0;
-	return (usz)(self.end - self.start) + 1;
-}
-
-fn bool Range.contains(&self, Type value) @inline
-{
-	return value >= self.start && value <= self.end;
-}
-
-/**
- * @require index < self.len() : "Can't index into an empty range"
- **/
-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
-{
-	return string::new_format("[%s..%s]", self.start, self.end, .allocator = allocator);
-}
-
-fn String Range.to_tstring(&self)
-{
-	return self.to_new_string(allocator::temp());
-}
-
-fn usz! Range.to_format(&self, Formatter* formatter) @dynamic
-{
-	return formatter.printf("[%s..%s]", self.start, self.end)!;
-}
-
-struct ExclusiveRange (Printable)
-{
-	Type start;
-	Type end;
-}
-
-fn usz ExclusiveRange.len(&self) @operator(len)
-{
-	if (self.end < self.start) return 0;
-	return (usz)(self.end - self.start);
-}
-
-fn bool ExclusiveRange.contains(&self, Type value) @inline
-{
-	return value >= self.start && value < self.end;
-}
-
-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
-{
-	return string::new_format("[%s..<%s]", self.start, self.end, .allocator = allocator);
-}
-
-fn String ExclusiveRange.to_tstring(&self)
-{
-	return self.to_new_string(allocator::temp());
-}
-
-/**
- * @require index < self.len() : "Can't index into an empty range"
- **/
-fn Type ExclusiveRange.get(&self, usz index) @operator([])
-{
-	return (Type)(self.start + index);
-}

lib/std/collections/ringbuffer.c3

@@ -1,103 +0,0 @@
-module std::collections::ringbuffer(<Type, SIZE>);
-
-struct RingBuffer
-{
-	Type[SIZE] buf;
-	usz written;
-	usz head;
-}
-
-fn void RingBuffer.init(&self) @inline
-{
-	*self = {};
-}
-
-fn void RingBuffer.putc(&self, Type c)
-{
-	if (self.written < SIZE)
-	{
-		self.buf[self.written] = c;
-		self.written++;
-	}
-	else
-	{
-		self.buf[self.head] = c;
-		self.head = (self.head + 1) % SIZE;
-	}
-}
-
-fn Type RingBuffer.getc(&self, usz index)
-{
-	index %= SIZE;
-	usz avail = SIZE - self.head;
-	if (index < avail)
-	{
-		return self.buf[self.head + index];
-	}
-	return self.buf[index - avail];
-}
-
-fn Type! RingBuffer.popc(&self)
-{
-	switch
-	{
-		case self.written == 0:
-			return SearchResult.MISSING?;
-		case self.written < SIZE:
-			self.written--;
-			return self.buf[self.written];
-		default:
-			self.head = (self.head - 1) % SIZE;
-			return self.buf[self.head];
-	}
-}
-
-fn usz RingBuffer.get(&self, usz index, Type[] buffer)
-{
-	index %= SIZE;
-	if (self.written < SIZE)
-	{
-		if (index >= self.written) return 0;
-		usz end = self.written - index;
-		usz n = min(end, buffer.len);
-		buffer[:n] = self.buf[index:n];
-		return n;
-	}
-	usz end = SIZE - self.head;
-	if (index >= end)
-	{
-		index -= end;
-		if (index >= self.head) return 0;
-		usz n = min(self.head - index, buffer.len);
-		buffer[:n] = self.buf[index:n];
-		return n;
-	}
-	if (buffer.len <= SIZE - index)
-	{
-		usz n = buffer.len;
-		buffer[:n] = self.buf[self.head + index:n];
-		return n;
-	}
-	usz n1 = SIZE - index;
-	buffer[:n1] = self.buf[self.head + index:n1];
-	buffer = buffer[n1..];
-	index -= n1;
-	usz n2 = min(self.head - index, buffer.len);
-	buffer[:n2] = self.buf[index:n2];
-	return n1 + n2;
-}
-
-fn void RingBuffer.push(&self, Type[] buffer)
-{
-	usz i;
-	while (self.written < SIZE && i < buffer.len)
-	{
-		self.buf[self.written] = buffer[i++];
-		self.written++;
-	}
-	foreach (c : buffer[i..])
-	{
-		self.buf[self.head] = c;
-		self.head = (self.head + 1) % SIZE;
-	}
-}

lib/std/collections/tuple.c3

@@ -1,16 +0,0 @@
-module std::collections::tuple(<Type1, Type2>);
-
-struct Tuple
-{
-	Type1 first;
-	Type2 second;
-}
-
-module std::collections::triple(<Type1, Type2, Type3>);
-
-struct Triple
-{
-	Type1 first;
-	Type2 second;
-	Type3 third;
-}

lib/std/core/allocators/arena_allocator.c3

@@ -2,105 +2,148 @@
 // 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;
-import std::math;
 
-struct ArenaAllocator (Allocator)
+struct ArenaAllocator
 {
+	inline Allocator allocator;
 	char[] data;
 	usz used;
 }
 
 /**
  * Initialize a memory arena for use using the provided bytes.
+ *
+ * @require this != null
  **/
-fn void ArenaAllocator.init(&self, char[] data)
+fn void ArenaAllocator.init(ArenaAllocator* this, char[] data)
 {
-	self.data = data;
-	self.used = 0;
+	this.function = &arena_allocator_function;
+	this.data = data;
+	this.used = 0;
 }
 
-fn void ArenaAllocator.clear(&self)
+/**
+ * @require this != null
+ **/
+fn void ArenaAllocator.reset(ArenaAllocator* this)
 {
-	self.used = 0;
+	this.used = 0;
 }
 
-struct ArenaAllocatorHeader @local
+struct ArenaAllocatorHeader
 {
 	usz size;
 	char[*] data;
 }
-
-/*
- * @require ptr != null
- **/
-fn void ArenaAllocator.release(&self, void* ptr, bool) @dynamic
-{
-	assert((uptr)ptr >= (uptr)self.data.ptr, "Pointer originates from a different allocator.");
-	ArenaAllocatorHeader* header = ptr - ArenaAllocatorHeader.sizeof;
-	// Reclaim memory if it's the last element.
-	if (ptr + header.size == &self.data[self.used])
-	{
-		self.used -= header.size + ArenaAllocatorHeader.sizeof;
-	}
-}
-
-fn usz ArenaAllocator.mark(&self) @dynamic => self.used;
-fn void ArenaAllocator.reset(&self, usz mark) @dynamic => self.used = mark;
-
 /**
  * @require !alignment || math::is_power_of_2(alignment)
- * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
- * @require size > 0
- **/
-fn void*! ArenaAllocator.acquire(&self, usz size, bool clear, usz alignment, usz offset) @dynamic
+ * @require data `unexpectedly missing the allocator`
+ */
+fn void*! arena_allocator_function(Allocator* data, usz size, usz alignment, usz offset, void* old_pointer, AllocationKind kind) @private
 {
-	alignment = alignment_for_allocation(alignment);
-	usz total_len = self.data.len;
-	if (size > total_len) return AllocationFailure.CHUNK_TOO_LARGE?;
-	void* start_mem = self.data.ptr;
-	void* unaligned_pointer_to_offset = start_mem + self.used + ArenaAllocatorHeader.sizeof;
-	void* mem = mem::aligned_pointer(unaligned_pointer_to_offset, alignment);
-	usz end = (usz)(mem - self.data.ptr) + size;
-	if (end > total_len) return AllocationFailure.OUT_OF_MEMORY?;
-	self.used = end;
+	ArenaAllocator* arena = (ArenaAllocator*)data;
+	bool clear = false;
+	switch (kind)
+	{
+		case CALLOC:
+		case ALIGNED_CALLOC:
+			clear = true;
+			nextcase;
+		case ALLOC:
+		case ALIGNED_ALLOC:
+			assert(!old_pointer, "Unexpected old pointer for alloc.");
+			if (!size) return null;
+			alignment = alignment_for_allocation(alignment);
+			void* mem = arena._alloc(size, alignment, offset)?;
+			if (clear) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
+        	return mem;
+		case ALIGNED_REALLOC:
+		case REALLOC:
+			if (!size) nextcase FREE;
+			if (!old_pointer) nextcase ALLOC;
+			alignment = alignment_for_allocation(alignment);
+			return arena._realloc(old_pointer, size, alignment, offset)?;
+		case ALIGNED_FREE:
+		case FREE:
+			if (!old_pointer) return null;
+			assert((uptr)old_pointer >= (uptr)arena.data.ptr, "Pointer originates from a different allocator.");
+			ArenaAllocatorHeader* header = old_pointer - ArenaAllocatorHeader.sizeof;
+			// Reclaim memory if it's the last element.
+			if (old_pointer + header.size == &arena.data[arena.used])
+        	{
+        		arena.used -= header.size + ArenaAllocatorHeader.sizeof;
+        	}
+        	return null;
+        case MARK:
+            return (void*)(uptr)arena.used;
+		case RESET:
+			arena.used = size;
+			return null;
+	}
+	unreachable();
+}
+
+/**
+ * @require alignment > 0 `alignment must be non zero`
+ * @require math::is_power_of_2(alignment)
+ * @require size > 0
+ * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+ * @require offset <= mem::MAX_MEMORY_ALIGNMENT `offset too big`
+ * @require offset <= size && offset >= 0
+ * @require mem::aligned_offset(offset, ArenaAllocatorHeader.alignof) == offset
+ * @require this != null
+ **/
+fn void*! ArenaAllocator._alloc(ArenaAllocator* this, usz size, usz alignment, usz offset) @private
+{
+	usz total_len = this.data.len;
+	if (size > total_len) return AllocationFailure.CHUNK_TOO_LARGE!;
+    void* start_mem = this.data.ptr;
+	void* unaligned_pointer_to_offset = start_mem + this.used + ArenaAllocatorHeader.sizeof + offset;
+	void* aligned_pointer_to_offset = mem::aligned_pointer(unaligned_pointer_to_offset, alignment);
+	usz end = (usz)(aligned_pointer_to_offset - this.data.ptr) + size - offset;
+	if (end > total_len) return AllocationFailure.OUT_OF_MEMORY!;
+	this.used = end;
+	void *mem = aligned_pointer_to_offset - offset;
 	ArenaAllocatorHeader* header = mem - ArenaAllocatorHeader.sizeof;
 	header.size = size;
-	if (clear) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
 	return mem;
 }
 
 /**
- * @require !alignment || math::is_power_of_2(alignment)
- * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
- * @require old_pointer != null
+ * @require alignment > 0 `alignment must be non zero`
+ * @require math::is_power_of_2(alignment)
  * @require size > 0
+ * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+ * @require offset <= mem::MAX_MEMORY_ALIGNMENT `offset too big`
+ * @require offset <= size && offset >= 0
+ * @require mem::aligned_offset(offset, ArenaAllocatorHeader.alignof) == offset
+ * @require this != null
  **/
-fn void*! ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignment, usz offset) @dynamic
+fn void*! ArenaAllocator._realloc(ArenaAllocator* this, void *old_pointer, usz size, usz alignment, usz offset) @private
 {
-	alignment = alignment_for_allocation(alignment);
-	assert(old_pointer >= self.data.ptr, "Pointer originates from a different allocator.");
-	usz total_len = self.data.len;
-	if (size > total_len) return AllocationFailure.CHUNK_TOO_LARGE?;
+	assert(old_pointer >= this.data.ptr, "Pointer originates from a different allocator.");
+	usz total_len = this.data.len;
+	if (size > total_len) return AllocationFailure.CHUNK_TOO_LARGE!;
 	ArenaAllocatorHeader* header = old_pointer - ArenaAllocatorHeader.sizeof;
 	usz old_size = header.size;
 	// Do last allocation and alignment match?
-	if (&self.data[self.used] == old_pointer + old_size && mem::ptr_is_aligned(old_pointer, alignment))
+	if (&this.data[this.used] == old_pointer + old_size && mem::ptr_is_aligned(old_pointer + offset, alignment))
 	{
 		if (old_size >= size)
-		{
-			self.used -= old_size - size;
-		}
-		else
-		{
-			usz new_used = self.used + size - old_size;
-			if (new_used > total_len) return AllocationFailure.OUT_OF_MEMORY?;
-			self.used = new_used;
-		}
-		header.size = size;
-		return old_pointer;
+        {
+        	this.used -= old_size - size;
+        }
+        else
+        {
+	        usz new_used = this.used + size - old_size;
+            if (new_used > total_len) return AllocationFailure.OUT_OF_MEMORY!;
+            this.used = new_used;
+        }
+        header.size = size;
+        return old_pointer;
 	}
 	// Otherwise just allocate new memory.
-	void* mem = self.acquire(size, false, alignment, 0)!;
+	void* mem = this._alloc(size, alignment, offset)?;
 	mem::copy(mem, old_pointer, old_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
 	return mem;
 }

lib/std/core/allocators/dynamic_arena.c3

@@ -1,11 +1,12 @@
-// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021 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::core::mem::allocator;
-import std::math;
 
-struct DynamicArenaAllocator (Allocator)
+module std::core::mem::allocator;
+
+struct DynamicArenaAllocator
 {
+	inline Allocator allocator;
 	Allocator* backing_allocator;
 	DynamicArenaPage* page;
 	DynamicArenaPage* unused_page;
@@ -13,44 +14,48 @@ struct DynamicArenaAllocator (Allocator)
 }
 
 /**
- * @param [&inout] allocator
  * @require page_size >= 128
+ * @require this != null
  **/
-fn void DynamicArenaAllocator.init(&self, usz page_size, Allocator* allocator)
+fn void DynamicArenaAllocator.init(DynamicArenaAllocator* this, usz page_size, Allocator* backing_allocator = mem::heap())
 {
-	self.page = null;
-	self.unused_page = null;
-	self.page_size = page_size;
-	self.backing_allocator = allocator;
+	this.function = &dynamic_arena_allocator_function;
+	this.page = null;
+	this.unused_page = null;
+	this.page_size = page_size;
+	this.backing_allocator = backing_allocator;
 }
 
-fn void DynamicArenaAllocator.free(&self)
+/**
+ * @require this != null
+ **/
+fn void DynamicArenaAllocator.destroy(DynamicArenaAllocator* this)
 {
-	DynamicArenaPage* page = self.page;
+	DynamicArenaPage* page = this.page;
 	while (page)
 	{
 		DynamicArenaPage* next_page = page.prev_arena;
-		allocator::free(self.backing_allocator, page);
+		free(page, .using = this.backing_allocator);
 		page = next_page;
 	}
-	page = self.unused_page;
+	page = this.unused_page;
 	while (page)
 	{
 		DynamicArenaPage* next_page = page.prev_arena;
-		allocator::free(self.backing_allocator, page);
+		free(page, .using = this.backing_allocator);
 		page = next_page;
 	}
-	self.page = null;
-	self.unused_page = null;
+	this.page = null;
+	this.unused_page = null;
 }
 
-struct DynamicArenaPage @local
+struct DynamicArenaPage
 {
 	void* memory;
 	void* prev_arena;
 	usz total;
 	usz used;
-	void* current_stack_ptr;
+	void* last_ptr;
 }
 
 struct DynamicArenaChunk @local
@@ -59,27 +64,26 @@ struct DynamicArenaChunk @local
 }
 
 /**
- * @require ptr
- * @require self.page `tried to free pointer on invalid allocator`
+ * @require ptr && this
+ * @require this.page `tried to free pointer on invalid allocator`
  */
-fn void DynamicArenaAllocator.release(&self, void* ptr, bool) @dynamic
+fn void DynamicArenaAllocator.free(DynamicArenaAllocator* this, void* ptr) @private
 {
-	DynamicArenaPage* current_page = self.page;
-	if (ptr == current_page.current_stack_ptr)
+	DynamicArenaPage* current_page = this.page;
+	if (ptr == current_page.last_ptr)
 	{
 		current_page.used = (usz)((ptr - DEFAULT_SIZE_PREFIX) - current_page.memory);
 	}
-	current_page.current_stack_ptr = null;
+	current_page.last_ptr = null;
 }
 
 /**
- * @require size > 0 `Resize doesn't support zeroing`
- * @require old_pointer != null `Resize doesn't handle null pointers`
- * @require self.page `tried to realloc pointer on invalid allocator`
+ * @require old_pointer && size > 0
+ * @require this.page `tried to realloc pointer on invalid allocator`
  */
-fn void*! DynamicArenaAllocator.resize(&self, void* old_pointer, usz size, usz alignment, usz offset) @dynamic
+fn void*! DynamicArenaAllocator._realloc(DynamicArenaAllocator* this, void* old_pointer, usz size, usz alignment, usz offset) @local
 {
-	DynamicArenaPage* current_page = self.page;
+	DynamicArenaPage* current_page = this.page;
 	alignment = alignment_for_allocation(alignment);
 	usz* old_size_ptr = old_pointer - DEFAULT_SIZE_PREFIX;
 	usz old_size = *old_size_ptr;
@@ -87,13 +91,13 @@ fn void*! DynamicArenaAllocator.resize(&self, void* old_pointer, usz size, usz a
 	if (old_size >= size && mem::ptr_is_aligned(old_pointer, alignment))
 	{
 		*old_size_ptr = size;
-		if (current_page.current_stack_ptr == old_pointer)
+		if (current_page.last_ptr == old_pointer)
 		{
 			current_page.used = (usz)((old_pointer - DEFAULT_SIZE_PREFIX) - current_page.memory);
 		}
 		return old_pointer;
 	}
-	if REUSE: (current_page.current_stack_ptr == old_pointer && mem::ptr_is_aligned(old_pointer, alignment))
+	if REUSE: (current_page.last_ptr == old_pointer && mem::ptr_is_aligned(old_pointer, alignment))
 	{
 		assert(size > old_size);
 		usz add_size = size - old_size;
@@ -102,99 +106,142 @@ fn void*! DynamicArenaAllocator.resize(&self, void* old_pointer, usz size, usz a
 		current_page.used += add_size;
 		return old_pointer;
 	}
-	void* new_mem = self.acquire(size, false, alignment, 0)!;
+	void* new_mem = this._alloc(size, alignment, offset)?;
 	mem::copy(new_mem, old_pointer, old_size, mem::DEFAULT_MEM_ALIGNMENT);
 	return new_mem;
 }
 
-fn void DynamicArenaAllocator.reset(&self, usz mark = 0) @dynamic
+fn void DynamicArenaAllocator.reset(DynamicArenaAllocator* this) @private
 {
-	assert(mark == 0, "Unexpectedly reset dynamic arena allocator with mark %d", mark);
-	DynamicArenaPage* page = self.page;
-	DynamicArenaPage** unused_page_ptr = &self.unused_page;
-	while (page)
-	{
-		DynamicArenaPage* next_page = page.prev_arena;
-		page.used = 0;
-		DynamicArenaPage* prev_unused = *unused_page_ptr;
-		*unused_page_ptr = page;
-		page.prev_arena = prev_unused;
-		page = next_page;
-	}
-	self.page = page;
+	DynamicArenaPage* page = this.page;
+	DynamicArenaPage** unused_page_ptr = &this.unused_page;
+    while (page)
+    {
+        DynamicArenaPage* next_page = page.prev_arena;
+        page.used = 0;
+        DynamicArenaPage* prev_unused = *unused_page_ptr;
+        *unused_page_ptr = page;
+        page.prev_arena = prev_unused;
+        page = next_page;
+    }
+    this.page = page;
 }
 
 /**
  * @require math::is_power_of_2(alignment)
  * @require size > 0
  */
-fn void*! DynamicArenaAllocator._alloc_new(&self, usz size, usz alignment) @local
+fn void*! DynamicArenaAllocator._alloc_new(DynamicArenaAllocator* this, usz size, usz alignment, usz offset) @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(this.page_size, mem::aligned_offset(size + DynamicArenaChunk.sizeof + offset, alignment) - offset);
 
 	// 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);
+	void* mem = this.backing_allocator.alloc(page_size)?;
+	DynamicArenaPage*! page = malloc(DynamicArenaPage, .using = this.backing_allocator);
 	if (catch err = page)
 	{
-		allocator::free(self.backing_allocator, mem);
-		return err?;
+		free(mem, .using = this.backing_allocator);
+		return err!;
 	}
-	page.memory = mem;
-	void* mem_start = mem::aligned_pointer(mem + DynamicArenaChunk.sizeof, alignment);
-	assert(mem_start + size < mem + page_size);
-	DynamicArenaChunk* chunk = (DynamicArenaChunk*)mem_start - 1;
-	chunk.size = size;
-	page.prev_arena = self.page;
+    page.memory = mem;
+    void* mem_start = mem::aligned_pointer(mem + offset + DynamicArenaChunk.sizeof, alignment) - offset;
+    assert(mem_start + size < mem + page_size);
+    DynamicArenaChunk* chunk = (DynamicArenaChunk*)mem_start - 1;
+    chunk.size = size;
+	page.prev_arena = this.page;
 	page.total = page_size;
 	page.used = mem_start + size - page.memory;
-	self.page = page;
-	page.current_stack_ptr = mem_start;
+	this.page = page;
+	page.last_ptr = mem_start;
 	return mem_start;
 }
 
 /**
- * @require size > 0 `acquire expects size > 0`
  * @require !alignment || math::is_power_of_2(alignment)
+ * @require size > 0
+ * @require this
  */
-fn void*! DynamicArenaAllocator.acquire(&self, usz size, bool clear, usz alignment, usz offset) @dynamic
+fn void*! DynamicArenaAllocator._alloc(DynamicArenaAllocator* this, usz size, usz alignment, usz offset) @local
 {
 	alignment = alignment_for_allocation(alignment);
-	DynamicArenaPage* page = self.page;
-	void* ptr = {|
-		if (!page && self.unused_page)
-		{
-			self.page = page = self.unused_page;
-			self.unused_page = page.prev_arena;
-			page.prev_arena = null;
-		}
-		if (!page) return self._alloc_new(size, alignment);
-		void* start = mem::aligned_pointer(page.memory + page.used + DynamicArenaChunk.sizeof, alignment);
-		usz new_used = start - page.memory + size;
-		if ALLOCATE_NEW: (new_used > page.total)
-		{
-			if ((page = self.unused_page))
-			{
-				start = mem::aligned_pointer(page.memory + page.used + DynamicArenaChunk.sizeof, alignment);
-				new_used = start + size - page.memory;
-				if (page.total >= new_used)
-				{
-					self.unused_page = page.prev_arena;
-					page.prev_arena = self.page;
-					self.page = page;
-					break ALLOCATE_NEW;
-				}
-			}
-			return self._alloc_new(size, alignment);
-		}
-		page.used = new_used;
-		assert(start + size == page.memory + page.used);
-		void* mem = start;
-		DynamicArenaChunk* chunk = (DynamicArenaChunk*)mem - 1;
-		chunk.size = size;
-		return mem;
-	|}!;
-	if (clear) mem::clear(ptr, size, mem::DEFAULT_MEM_ALIGNMENT);
-	return ptr;
+	DynamicArenaPage* page = this.page;
+	if (!page && this.unused_page)
+	{
+		this.page = page = this.unused_page;
+		this.unused_page = page.prev_arena;
+		page.prev_arena = null;
+	}
+    if (!page) return this._alloc_new(size, alignment, offset);
+    void* start = mem::aligned_pointer(page.memory + page.used + DynamicArenaChunk.sizeof + offset, alignment) - offset;
+    usz new_used = start - page.memory + size;
+    if ALLOCATE_NEW: (new_used > page.total)
+    {
+        if ((page = this.unused_page))
+        {
+            start = mem::aligned_pointer(page.memory + page.used + DynamicArenaChunk.sizeof + offset, alignment) - offset;
+            new_used = start + size - page.memory;
+            if (page.total >= new_used)
+            {
+	    		this.unused_page = page.prev_arena;
+    	    	page.prev_arena = this.page;
+    		    this.page = page;
+    		    break ALLOCATE_NEW;
+            }
+        }
+ 	    return this._alloc_new(size, alignment, offset);
+    }
+
+    page.used = new_used;
+	assert(start + size == page.memory + page.used);
+    void* mem = start;
+    DynamicArenaChunk* chunk = (DynamicArenaChunk*)mem - 1;
+    chunk.size = size;
+    return mem;
+}
+
+/**
+ * @require !alignment || math::is_power_of_2(alignment)
+ * @require data `unexpectedly missing the allocator`
+ */
+fn void*! dynamic_arena_allocator_function(Allocator* data, usz size, usz alignment, usz offset, void* old_pointer, AllocationKind kind) @private
+{
+	DynamicArenaAllocator* allocator = (DynamicArenaAllocator*)data;
+	switch (kind)
+	{
+		case CALLOC:
+		case ALIGNED_CALLOC:
+			assert(!old_pointer, "Unexpected no old pointer for calloc.");
+			if (!size) return null;
+			void* mem = allocator._alloc(size, alignment, offset)?;
+			mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
+			return mem;
+		case ALLOC:
+		case ALIGNED_ALLOC:
+			assert(!old_pointer, "Unexpected no old pointer for alloc.");
+			if (!size) return null;
+			return allocator._alloc(size, alignment, offset);
+		case REALLOC:
+		case ALIGNED_REALLOC:
+			if (!size)
+			{
+				if (!old_pointer) return null;
+				allocator.free(old_pointer);
+				return null;
+			}
+			if (!old_pointer) return allocator._alloc(size, alignment, offset);
+			void* mem = allocator._realloc(old_pointer, size, alignment, offset)?;
+			return mem;
+		case ALIGNED_FREE:
+		case FREE:
+			if (!old_pointer) return null;
+			allocator.free(old_pointer);
+			return null;
+		case MARK:
+			unreachable("Tried to mark a dynamic arena");
+		case RESET:
+			allocator.reset();
+			return null;
+	}
+	unreachable();
 }

lib/std/core/allocators/heap_allocator.c3

@@ -1,85 +1,99 @@
-// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021 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::core::mem::allocator;
-import std::math;
 
-struct SimpleHeapAllocator (Allocator)
+typedef MemoryAllocFn = fn char[]!(usz);
+
+struct SimpleHeapAllocator
 {
+	inline Allocator allocator;
 	MemoryAllocFn alloc_fn;
 	Header* free_list;
 }
 
 /**
+ * @require this "Unexpectedly missing the allocator"
  * @require allocator "An underlying memory provider must be given"
- * @require !self.free_list "The allocator may not be already initialized"
+ * @require !this.free_list "The allocator may not be already initialized"
  **/
-fn void SimpleHeapAllocator.init(&self, MemoryAllocFn allocator)
+fn void SimpleHeapAllocator.init(SimpleHeapAllocator* this, MemoryAllocFn allocator)
 {
-	self.alloc_fn = allocator;
-	self.free_list = null;
+	this.alloc_fn = allocator;
+	this.allocator = { &simple_heap_allocator_function };
+	this.free_list = null;
 }
 
-fn void*! SimpleHeapAllocator.acquire(&self, usz size, bool clear, usz alignment, usz offset) @dynamic
+/**
+ * @require !alignment || math::is_power_of_2(alignment)
+ * @require this `unexpectedly missing the allocator`
+ */
+fn void*! simple_heap_allocator_function(Allocator* this, usz size, usz alignment, usz offset, void* old_pointer, AllocationKind kind) @private
 {
-	if (clear)
-	{
-		return alignment > 0 ? @aligned_alloc(self._calloc, size, alignment) : self._calloc(size);
-	}
-	return alignment > 0 ? @aligned_alloc(self._alloc, size, alignment) : self._alloc(size);
-}
-
-fn void*! SimpleHeapAllocator.resize(&self, void* old_pointer, usz size, usz alignment, usz offset) @dynamic
-{
-	return alignment > 0
-		? @aligned_realloc(self._calloc, self._free, old_pointer, size, alignment)
-		:  self._realloc(old_pointer, size);
-}
-
-fn void SimpleHeapAllocator.release(&self, void* old_pointer, bool aligned) @dynamic
-{
-	if (aligned)
-	{
-		@aligned_free(self._free, old_pointer)!!;
-	}
-	else
-	{
-		self._free(old_pointer);
+	SimpleHeapAllocator* heap = (SimpleHeapAllocator*)this;
+	switch (kind)
+    {
+        case ALIGNED_ALLOC:
+            return @aligned_alloc(heap._alloc, size, alignment, offset);
+		case ALLOC:
+            return heap._alloc(size);
+        case ALIGNED_CALLOC:
+            return @aligned_calloc(heap._calloc, size, alignment, offset);
+    	case CALLOC:
+            return heap._calloc(size);
+        case ALIGNED_REALLOC:
+            if (!size) nextcase ALIGNED_FREE;
+            if (!old_pointer) nextcase ALIGNED_CALLOC;
+            return @aligned_realloc(heap._calloc, heap._free, old_pointer, size, alignment, offset);
+        case REALLOC:
+            if (!size) nextcase FREE;
+            if (!old_pointer) nextcase CALLOC;
+            return heap._realloc(old_pointer, size);
+        case RESET:
+            return AllocationFailure.UNSUPPORTED_OPERATION!;
+        case ALIGNED_FREE:
+            @aligned_free(heap._free, old_pointer)?;
+            return null;
+        case FREE:
+            heap._free(old_pointer);
+            return null;
+        default:
+            unreachable();
 	}
 }
 
 /**
- * @require old_pointer && bytes > 0
+ * @require this && old_pointer && bytes > 0
  **/
-fn void*! SimpleHeapAllocator._realloc(&self, void* old_pointer, usz bytes) @local
+fn void*! SimpleHeapAllocator._realloc(SimpleHeapAllocator* this, void* old_pointer, usz bytes)
 {
 	// Find the block header.
 	Header* block = (Header*)old_pointer - 1;
 	if (block.size >= bytes) return old_pointer;
-	void* new = self._alloc(bytes)!;
+	void* new = this._alloc(bytes)?;
 	usz max_to_copy = math::min(block.size, bytes);
 	mem::copy(new, old_pointer, max_to_copy);
-	self._free(old_pointer);
+	this._free(old_pointer);
 	return new;
 }
 
-fn void*! SimpleHeapAllocator._calloc(&self, usz bytes) @local
+fn void*! SimpleHeapAllocator._calloc(SimpleHeapAllocator* this, usz bytes) @local
 {
-	void* data = self._alloc(bytes)!;
+	void* data = this._alloc(bytes)?;
 	mem::clear(data, bytes, mem::DEFAULT_MEM_ALIGNMENT);
 	return data;
 }
 
-fn void*! SimpleHeapAllocator._alloc(&self, usz bytes) @local
+fn void*! SimpleHeapAllocator._alloc(SimpleHeapAllocator* this, usz bytes) @local
 {
 	usz aligned_bytes = mem::aligned_offset(bytes, mem::DEFAULT_MEM_ALIGNMENT);
-	if (!self.free_list)
-	{
-		self.add_block(aligned_bytes)!;
-	}
+    if (!this.free_list)
+    {
+		this.add_block(aligned_bytes)?;
+    }
 
-	Header* current = self.free_list;
+	Header* current = this.free_list;
 	Header* previous = current;
 	while (current)
 	{
@@ -88,21 +102,21 @@ fn void*! SimpleHeapAllocator._alloc(&self, usz bytes) @local
 			case current.size >= aligned_bytes && current.size <= aligned_bytes + Header.sizeof + 64:
 				if (current == previous)
 				{
-					self.free_list = current.next;
+					this.free_list = current.next;
 				}
 				else
 				{
 					previous.next = current.next;
-				}
-				current.next = null;
-				return current + 1;
-			case current.size > aligned_bytes:
+                }
+                current.next = null;
+                return current + 1;
+            case current.size > aligned_bytes:
 				Header* unallocated = (Header*)((char*)current + aligned_bytes + Header.sizeof);
 				unallocated.size = current.size - aligned_bytes;
 				unallocated.next = current.next;
-				if (current == self.free_list)
+				if (current == this.free_list)
 				{
-					self.free_list = unallocated;
+					this.free_list = unallocated;
 				}
 				else
 				{
@@ -116,22 +130,22 @@ fn void*! SimpleHeapAllocator._alloc(&self, usz bytes) @local
 				current = current.next;
 		}
 	}
-	self.add_block(aligned_bytes)!;
-	return self._alloc(aligned_bytes);
+	this.add_block(aligned_bytes)?;
+	return this.alloc(aligned_bytes);
 }
 
-fn void! SimpleHeapAllocator.add_block(&self, usz aligned_bytes) @local
+fn void! SimpleHeapAllocator.add_block(SimpleHeapAllocator* this, usz aligned_bytes) @local
 {
 	assert(mem::aligned_offset(aligned_bytes, mem::DEFAULT_MEM_ALIGNMENT) == aligned_bytes);
-	char[] result = self.alloc_fn(aligned_bytes + Header.sizeof)!;
+	char[] result = this.alloc_fn(aligned_bytes + Header.sizeof)?;
 	Header* new_block = (Header*)result.ptr;
 	new_block.size = result.len - Header.sizeof;
 	new_block.next = null;
-	self._free(new_block + 1);
+	this._free(new_block + 1);
 }
 
 
-fn void SimpleHeapAllocator._free(&self, void* ptr) @local
+fn void SimpleHeapAllocator._free(SimpleHeapAllocator* this, void* ptr) @local
 {
 	// Empty ptr -> do nothing.
 	if (!ptr) return;
@@ -139,15 +153,15 @@ fn void SimpleHeapAllocator._free(&self, void* ptr) @local
 	// Find the block header.
 	Header* block = (Header*)ptr - 1;
 
-	// No free list? Then just return self.
-	if (!self.free_list)
+	// No free list? Then just return this.
+	if (!this.free_list)
 	{
-		self.free_list = block;
+		this.free_list = block;
 		return;
 	}
 
 	// Find where in the list it should be inserted.
-	Header* current = self.free_list;
+	Header* current = this.free_list;
 	Header* prev = current;
 	while (current)
 	{
@@ -164,46 +178,46 @@ fn void SimpleHeapAllocator._free(&self, void* ptr) @local
 	if (current)
 	{
 		// Insert after the current block.
-		// Are the blocks adjacent?
-		if (current == (Header*)((char*)(block + 1) + block.size))
-		{
-			// Merge
-			block.size += current.size + Header.sizeof;
-			block.next = current.next;
-		}
-		else
-		{
-			// Chain to current
-			block.next = current;
-		}
+        // Are the blocks adjacent?
+        if (current == (Header*)((char*)(block + 1) + block.size))
+        {
+            // Merge
+    		block.size += current.size + Header.sizeof;
+            block.next = current.next;
+        }
+        else
+        {
+            // Chain to current
+            block.next = current;
+        }
 	}
 	if (prev == current)
 	{
 		// Swap new start of free list
-		self.free_list = block;
+		this.free_list = block;
 	}
 	else
 	{
 		// Prev adjacent?
 		if (block == (Header*)((char*)(prev + 1) + prev.size))
 		{
-			prev.size += block.size + Header.sizeof;
+    		prev.size += block.size + Header.sizeof;
 			prev.next = block.next;
 		}
 		else
 		{
-			// Link prev to block
-			prev.next = block;
+	        // Link prev to block
+	        prev.next = block;
 		}
 	}
 }
 
-union Header @local
+union Header @private
 {
 	struct
 	{
 		Header* next;
-		usz size;
-	}
-	usz align;
+  	    usz size;
+    }
+    usz align;
 }

lib/std/core/allocators/libc_allocator.c3

@@ -1,166 +0,0 @@
-// Copyright (c) 2021-2024 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::core::mem::allocator;
-import libc;
-
-const LibcAllocator LIBC_ALLOCATOR = {};
-distinct LibcAllocator (Allocator) = uptr;
-
-module std::core::mem::allocator @if(env::POSIX);
-import std::os;
-import libc;
-
-fn void*! LibcAllocator.acquire(&self, usz bytes, bool clear, usz alignment, usz offset) @dynamic
-{
-	if (clear)
-	{
-		void* data @noinit;
-		if (alignment > mem::DEFAULT_MEM_ALIGNMENT)
-		{
-			if (posix::posix_memalign(&data, alignment, bytes)) return AllocationFailure.OUT_OF_MEMORY?;
-			mem::clear(data, bytes, mem::DEFAULT_MEM_ALIGNMENT);
-			return data;
-		}
-        return libc::calloc(1, bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
-	}
-	else
-	{
-		void* data @noinit;
-		if (alignment > mem::DEFAULT_MEM_ALIGNMENT)
-		{
-			if (posix::posix_memalign(&data, alignment, bytes)) return AllocationFailure.OUT_OF_MEMORY?;
-		}
-		else
-		{
-			if (!(data = libc::malloc(bytes))) return AllocationFailure.OUT_OF_MEMORY?;
-		}
-        $if env::TESTING:
-		    for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
-        $endif
-        return data;
-	}
-}
-
-fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment, usz offset) @dynamic
-{
-	if (!new_bytes)
-	{
-		self.release(old_ptr, alignment > 0);
-		return null;
-	}
-	if (!old_ptr)
-	{
-		return self.acquire(new_bytes, false, alignment, 0);
-	}
-	if (alignment <= mem::DEFAULT_MEM_ALIGNMENT) return libc::realloc(old_ptr, new_bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
-
-    void* new_ptr;
-	if (posix::posix_memalign(&new_ptr, alignment, new_bytes)) return AllocationFailure.OUT_OF_MEMORY?;
-
-	$switch
-	$case env::DARWIN:
-		usz old_usable_size = darwin::malloc_size(old_ptr);
-	$case env::LINUX:
-		usz old_usable_size = linux::malloc_usable_size(old_ptr);
-	$default:
-		usz old_usable_size = new_bytes;
-	$endswitch
-
-	usz copy_size = new_bytes < old_usable_size ? new_bytes : old_usable_size;
-	mem::copy(new_ptr, old_ptr, copy_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
-	libc::free(old_ptr);
-	return new_ptr;
-}
-
-fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
-{
-	libc::free(old_ptr);
-}
-
-module std::core::mem::allocator @if(env::WIN32);
-import std::os::win32;
-import libc;
-
-fn void*! LibcAllocator.acquire(&self, usz bytes, bool clear, usz alignment, usz offset) @dynamic
-{
-	if (clear)
-	{
-		if (alignment > 0)
-		{
-			return win32::_aligned_recalloc(null, bytes, alignment) ?: AllocationFailure.OUT_OF_MEMORY?;
-		}
-		return libc::calloc(1, bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
-	}
-	void* data = alignment > 0 ? win32::_aligned_malloc(bytes, alignment) : libc::malloc(bytes);
-	if (!data) return AllocationFailure.OUT_OF_MEMORY?;
-    $if env::TESTING:
-		for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
-	$endif
-    return data;
-}
-
-fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment, usz offset) @dynamic
-{
-	if (alignment)
-	{
-		return win32::_aligned_realloc(old_ptr, new_bytes, alignment) ?: AllocationFailure.OUT_OF_MEMORY?;
-	}
-	return libc::realloc(old_ptr, new_bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
-}
-
-fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
-{
-	if (aligned)
-	{
-    	win32::_aligned_free(old_ptr);
-    	return;
-	}
-	libc::free(old_ptr);
-}
-
-module std::core::mem::allocator @if(!env::WIN32 && !env::POSIX);
-import libc;
-
-fn void*! LibcAllocator.acquire(&self, usz bytes, bool clear, usz alignment, usz offset) @dynamic
-{
-	if (clear)
-	{
-		void* data = alignment ? @aligned_alloc(fn void*(usz bytes) => libc::calloc(bytes, 1), bytes, alignment)!! : libc::calloc(bytes, 1);
-        return data ?: AllocationFailure.OUT_OF_MEMORY?;
-	}
-	else
-	{
-		void* data = alignment ? @aligned_alloc(libc::malloc, bytes, alignment)!! : libc::malloc(bytes);
-        if (!data) return AllocationFailure.OUT_OF_MEMORY?;
-        $if env::TESTING:
-		    for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
-        $endif
-        return data;
-	}
-}
-
-
-fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment, usz offset) @dynamic
-{
-	if (alignment)
-	{
-		void* data = @aligned_realloc(fn void*(usz bytes) => libc::malloc(bytes), libc::free, old_ptr, new_bytes, alignment)!!;
-		return data ?: AllocationFailure.OUT_OF_MEMORY?;
-	}
-	return libc::realloc(old_ptr, new_bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
-}
-
-
-fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
-{
-	if (aligned)
-	{
-		@aligned_free(libc::free, old_ptr)!!;
-	}
-	else
-	{
-		libc::free(old_ptr);
-	}
-}

lib/std/core/allocators/mem_allocator_fn.c3

@@ -0,0 +1,136 @@
+// Copyright (c) 2021 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::core::mem::allocator;
+import libc;
+
+const Allocator _NULL_ALLOCATOR @private = { &null_allocator_fn };
+const Allocator _SYSTEM_ALLOCATOR @private = { &libc_allocator_fn };
+
+fn void*! null_allocator_fn(Allocator* this, usz bytes, usz alignment, usz offset, void* old_pointer, AllocationKind kind) @private
+{
+	switch (kind)
+	{
+		case ALLOC:
+        case CALLOC:
+        case REALLOC:
+        case ALIGNED_ALLOC:
+        case ALIGNED_REALLOC:
+        case ALIGNED_CALLOC:
+			return AllocationFailure.OUT_OF_MEMORY!;
+		default:
+			return null;
+	}
+}
+
+struct AlignedBlock
+{
+	usz len;
+	void* start;
+}
+
+/**
+ * @require bytes > 0
+ * @require alignment > 0
+ **/
+macro void*! @aligned_alloc(#alloc_fn, usz bytes, usz alignment, usz offset)
+{
+	usz header = mem::aligned_offset(AlignedBlock.sizeof + offset, alignment) - offset;
+	$if ($checks(#alloc_fn(bytes)?))
+		void* data = #alloc_fn(header + bytes)?;
+	$else
+		void* data = #alloc_fn(header + bytes);
+	$endif
+    void* mem = mem::aligned_pointer(data + header + offset, alignment) - offset;
+	assert(mem > data);
+	AlignedBlock* desc = (AlignedBlock*)mem - 1;
+	*desc = { bytes, data };
+	return mem;
+}
+
+/**
+ * @require bytes > 0
+ * @require alignment > 0
+ **/
+macro void*! @aligned_calloc(#calloc_fn, usz bytes, usz alignment, usz offset)
+{
+	usz header = mem::aligned_offset(AlignedBlock.sizeof + offset, alignment) - offset;
+	$if ($checks(#calloc_fn(bytes)?))
+		void* data = #calloc_fn(header + bytes)?;
+	$else
+		void* data = #calloc_fn(header + bytes);
+	$endif
+	void* mem = mem::aligned_pointer(data + header + offset, alignment) - offset;
+	AlignedBlock* desc = (AlignedBlock*)mem - 1;
+	assert(mem > data);
+	*desc = { bytes, data };
+	return mem;
+}
+
+/**
+ * @require bytes > 0
+ * @require alignment > 0
+ **/
+macro void*! @aligned_realloc(#calloc_fn, #free_fn, void* old_pointer, usz bytes, usz alignment, usz offset)
+{
+	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
+	void* data_start = desc.start;
+    void* new_data = @aligned_calloc(#calloc_fn, bytes, alignment, offset)?;
+	mem::copy(new_data, old_pointer, desc.len > bytes ? desc.len : bytes, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
+	$if ($checks(#free_fn(data_start)?))
+	#free_fn(data_start)?;
+	$else
+	#free_fn(data_start);
+	$endif
+	return new_data;
+}
+
+macro void! @aligned_free(#free_fn, void* old_pointer)
+{
+	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
+	$if ($checks(#free_fn(desc.start)?))
+	#free_fn(desc.start)?;
+	$else
+	#free_fn(desc.start);
+	$endif
+}
+
+fn void*! libc_allocator_fn(Allocator* unused, usz bytes, usz alignment, usz offset, void* old_pointer, AllocationKind kind) @inline
+{
+	if (!alignment) alignment = mem::DEFAULT_MEM_ALIGNMENT;
+	assert(math::is_power_of_2(alignment), "Alignment was not a power of 2");
+
+    void* data;
+    switch (kind)
+    {
+        case ALIGNED_ALLOC:
+            data = @aligned_alloc(libc::malloc, bytes, alignment, offset)!!;
+        case ALLOC:
+            data = libc::malloc(bytes);
+        case ALIGNED_CALLOC:
+            data = @aligned_calloc(fn void*(usz bytes) => libc::calloc(bytes, 1), bytes, alignment, offset)!!;
+		case CALLOC:
+            data = libc::calloc(bytes, 1);
+        case ALIGNED_REALLOC:
+            if (!bytes) nextcase ALIGNED_FREE;
+            if (!old_pointer) nextcase ALIGNED_CALLOC;
+            data = @aligned_realloc(fn void*(usz bytes) => libc::calloc(bytes, 1), libc::free, old_pointer, bytes, alignment, offset)!!;
+        case REALLOC:
+            if (!bytes) nextcase FREE;
+            if (!old_pointer) nextcase CALLOC;
+            data = libc::realloc(old_pointer, bytes);
+        case RESET:
+            return AllocationFailure.UNSUPPORTED_OPERATION!;
+        case ALIGNED_FREE:
+            @aligned_free(libc::free, old_pointer)!!;
+            return null;
+        case FREE:
+            libc::free(old_pointer);
+            return null;
+        default:
+            unreachable();
+    }
+    if (!data) return AllocationFailure.OUT_OF_MEMORY!;
+    return data;
+}

lib/std/core/allocators/on_stack_allocator.c3

@@ -1,13 +1,34 @@
 module std::core::mem::allocator;
 
-struct OnStackAllocator (Allocator)
+struct OnStackAllocator
 {
+	inline Allocator allocator;
 	Allocator* backing_allocator;
 	char[] data;
 	usz used;
 	OnStackAllocatorExtraChunk* chunk;
 }
 
+macro void @stack_mem(usz $size; @body(Allocator* mem)) @builtin
+{
+	char[$size] buffer;
+	OnStackAllocator allocator;
+	allocator.init(&buffer, mem::heap());
+	defer allocator.free();
+	@body(&allocator);
+}
+
+macro void @stack_pool(usz $size; @body) @builtin
+{
+	char[$size] buffer;
+	OnStackAllocator allocator;
+	allocator.init(&buffer, mem::heap());
+	defer allocator.free();
+	mem::@scoped(&allocator)
+	{
+		@body();
+	};
+}
 
 struct OnStackAllocatorExtraChunk @local
 {
@@ -17,35 +38,40 @@ struct OnStackAllocatorExtraChunk @local
 }
 
 /**
- * @param [&inout] allocator
  * Initialize a memory arena for use using the provided bytes.
+ *
+ * @require this != null
  **/
-fn void OnStackAllocator.init(&self, char[] data, Allocator* allocator)
+fn void OnStackAllocator.init(OnStackAllocator* this, char[] data, Allocator* using = mem::heap())
 {
-	self.data = data;
-	self.backing_allocator = allocator;
-	self.used = 0;
+	this.function = &on_stack_allocator_function;
+	this.data = data;
+	this.backing_allocator = using;
+	this.used = 0;
 }
 
-fn void OnStackAllocator.free(&self)
+/**
+ * @require this != null
+ **/
+fn void OnStackAllocator.free(OnStackAllocator* this)
 {
-	OnStackAllocatorExtraChunk* chunk = self.chunk;
+	OnStackAllocatorExtraChunk* chunk = this.chunk;
 	while (chunk)
 	{
 		if (chunk.is_aligned)
 		{
-			allocator::free_aligned(self.backing_allocator, chunk.data);
+			this.backing_allocator.free_aligned(chunk.data)!!;
 		}
 		else
 		{
-			allocator::free(self.backing_allocator, chunk.data);
+			this.backing_allocator.free(chunk.data)!!;
 		}
 		void* old = chunk;
 		chunk = chunk.prev;
-		allocator::free(self.backing_allocator, old);
+		this.backing_allocator.free(old)!!;
 	}
-	self.chunk = null;
-	self.used = 0;
+	this.chunk = null;
+	this.used = 0;
 }
 
 struct OnStackAllocatorHeader
@@ -55,13 +81,48 @@ struct OnStackAllocatorHeader
 }
 
 /**
- * @require old_pointer
- **/
-fn void OnStackAllocator.release(&self, void* old_pointer, bool aligned) @dynamic
+ * @require !alignment || math::is_power_of_2(alignment)
+ * @require data `unexpectedly missing the allocator`
+ */
+fn void*! on_stack_allocator_function(Allocator* data, usz size, usz alignment, usz offset, void* old_pointer, AllocationKind kind) @private
 {
-	if (allocation_in_stack_mem(self, old_pointer)) return;
-	on_stack_allocator_remove_chunk(self, old_pointer);
-	self.release(old_pointer, aligned);
+	OnStackAllocator* allocator = (OnStackAllocator*)data;
+	bool clear = false;
+	switch (kind)
+	{
+		case CALLOC:
+		case ALIGNED_CALLOC:
+			clear = true;
+			nextcase;
+		case ALLOC:
+		case ALIGNED_ALLOC:
+			assert(!old_pointer, "Unexpected old pointer for alloc.");
+			if (!size) return null;
+			return on_stack_allocator_alloc(allocator, size, alignment, offset, clear, kind == AllocationKind.ALIGNED_ALLOC || kind == AllocationKind.ALIGNED_CALLOC);
+		case ALIGNED_REALLOC:
+		case REALLOC:
+			if (!size) nextcase FREE;
+			if (!old_pointer) nextcase ALLOC;
+			return on_stack_allocator_realloc(allocator, old_pointer, size, alignment, offset, kind == AllocationKind.ALIGNED_REALLOC);
+		case ALIGNED_FREE:
+		case FREE:
+			if (!old_pointer) return null;
+			if (allocation_in_stack_mem(allocator, old_pointer)) return null;
+			on_stack_allocator_remove_chunk(allocator, old_pointer);
+			if (kind == AllocationKind.ALIGNED_FREE)
+			{
+				allocator.backing_allocator.free_aligned(old_pointer)?;
+			}
+			else
+			{
+				allocator.backing_allocator.free(old_pointer)?;
+			}
+        	return null;
+        case MARK:
+		case RESET:
+			return AllocationFailure.UNSUPPORTED_OPERATION!;
+	}
+	unreachable();
 }
 
 fn bool allocation_in_stack_mem(OnStackAllocator* a, void* ptr) @local
@@ -78,7 +139,7 @@ fn void on_stack_allocator_remove_chunk(OnStackAllocator* a, void* ptr) @local
 		if (chunk.data == ptr)
 		{
 			*addr = chunk.prev;
-			allocator::free(a.backing_allocator, chunk);
+			a.backing_allocator.free(chunk)!!;
 			return;
 		}
 		addr = &chunk.prev;
@@ -100,49 +161,74 @@ fn OnStackAllocatorExtraChunk* on_stack_allocator_find_chunk(OnStackAllocator* a
 
 /**
  * @require size > 0
- * @require old_pointer != null
  * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+ * @require offset <= mem::MAX_MEMORY_ALIGNMENT `offset too big`
+ * @require offset <= size && offset >= 0
+ * @require mem::aligned_offset(offset, ArenaAllocatorHeader.alignof) == offset
+ * @require a != null
  **/
-fn void*! OnStackAllocator.resize(&self, void* old_pointer, usz size, usz alignment, usz deprecated) @dynamic
+fn void*! on_stack_allocator_realloc(OnStackAllocator* a, void* old_pointer, usz size, usz alignment, usz offset, bool aligned) @local @inline
 {
-	if (!allocation_in_stack_mem(self, old_pointer))
+	if (!allocation_in_stack_mem(a, old_pointer))
 	{
-		OnStackAllocatorExtraChunk* chunk = on_stack_allocator_find_chunk(self, old_pointer);
+		OnStackAllocatorExtraChunk* chunk = on_stack_allocator_find_chunk(a, old_pointer);
 		assert(chunk, "Tried to realloc pointer not belonging to the allocator");
-		return chunk.data = self.backing_allocator.resize(old_pointer, size, alignment, 0)!;
+		if (aligned)
+		{
+			return chunk.data = a.backing_allocator.realloc_aligned(old_pointer, size, alignment, offset)?;
+		}
+		return chunk.data = a.backing_allocator.realloc(old_pointer, size)?;
 	}
 
 	OnStackAllocatorHeader* header = old_pointer - OnStackAllocatorHeader.sizeof;
 	usz old_size = header.size;
-	void* mem = self.acquire(size, false, alignment, 0)!;
+	void* mem = on_stack_allocator_alloc(a, size, alignment, offset, true, aligned)?;
 	mem::copy(mem, old_pointer, old_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
 	return mem;
 }
 
+import std::io;
 /**
- * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
  * @require size > 0
+ * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+ * @require offset <= mem::MAX_MEMORY_ALIGNMENT `offset too big`
+ * @require offset <= size && offset >= 0
+ * @require mem::aligned_offset(offset, ArenaAllocatorHeader.alignof) == offset
+ * @require a != null
  **/
-fn void*! OnStackAllocator.acquire(&self, usz size, bool clear, usz alignment, usz deprecated) @dynamic
+fn void*! on_stack_allocator_alloc(OnStackAllocator* a, usz size, usz alignment, usz offset, bool clear, bool aligned) @local @inline
 {
-	bool aligned = alignment > 0;
 	alignment = alignment_for_allocation(alignment);
-	usz total_len = self.data.len;
-	void* start_mem = self.data.ptr;
-	void* unaligned_pointer_to_offset = start_mem + self.used + OnStackAllocatorHeader.sizeof ;
-	void* mem = mem::aligned_pointer(unaligned_pointer_to_offset, alignment);
-	usz end = (usz)(mem - self.data.ptr) + size;
-	Allocator* backing_allocator = self.backing_allocator;
+	usz total_len = a.data.len;
+    void* start_mem = a.data.ptr;
+	void* unaligned_pointer_to_offset = start_mem + a.used + OnStackAllocatorHeader.sizeof + offset;
+	void* aligned_pointer_to_offset = mem::aligned_pointer(unaligned_pointer_to_offset, alignment);
+	usz end = (usz)(aligned_pointer_to_offset - a.data.ptr) + size - offset;
+
+	Allocator* backing_allocator = a.backing_allocator;
 
 	if (end > total_len)
 	{
-		OnStackAllocatorExtraChunk* chunk = allocator::alloc_try(backing_allocator, OnStackAllocatorExtraChunk)!;
-		defer catch allocator::free(backing_allocator, chunk);
-		defer try self.chunk = chunk;
-		*chunk = { .prev = self.chunk, .is_aligned = aligned };
-		return chunk.data = backing_allocator.acquire(size, clear, aligned ? alignment : 0, 0)!;
+		OnStackAllocatorExtraChunk* chunk = backing_allocator.alloc(OnStackAllocatorExtraChunk.sizeof)?;
+		defer catch backing_allocator.free(chunk)!!;
+		defer try a.chunk = chunk;
+		*chunk = { .prev = a.chunk, .is_aligned = aligned };
+		void* data @noinit;
+		switch
+		{
+			case !aligned && !clear:
+				data = backing_allocator.alloc(size)?;
+			case aligned && !clear:
+				data = backing_allocator.alloc_aligned(size, alignment, offset)?;
+			case !aligned && clear:
+				data = backing_allocator.calloc(size)?;
+			case aligned && clear:
+				data = backing_allocator.calloc_aligned(size, alignment, offset)?;
+		}
+		return chunk.data = data;
 	}
-	self.used = end;
+	a.used = end;
+	void *mem = aligned_pointer_to_offset - offset;
 	OnStackAllocatorHeader* header = mem - OnStackAllocatorHeader.sizeof;
 	header.size = size;
 	return mem;

lib/std/core/allocators/temp_allocator.c3

@@ -1,5 +1,5 @@
 module std::core::mem::allocator;
-import std::io, std::math;
+import std::io;
 
 struct TempAllocatorChunk @local
 {
@@ -7,8 +7,9 @@ struct TempAllocatorChunk @local
 	char[*] data;
 }
 
-struct TempAllocator (Allocator)
+struct TempAllocator
 {
+	inline Allocator allocator;
 	Allocator* backing_allocator;
 	TempAllocatorPage* last_page;
 	usz used;
@@ -16,6 +17,7 @@ struct TempAllocator (Allocator)
 	char[*] data;
 }
 
+
 const usz PAGE_IS_ALIGNED @private = (usz)isz.max + 1u;
 
 
@@ -29,63 +31,98 @@ struct TempAllocatorPage
 	char[*] data;
 }
 
-macro usz TempAllocatorPage.pagesize(&self) => self.size & ~PAGE_IS_ALIGNED;
-macro bool TempAllocatorPage.is_aligned(&self) => self.size & PAGE_IS_ALIGNED == PAGE_IS_ALIGNED;
+macro usz TempAllocatorPage.pagesize(TempAllocatorPage* page) => page.size & ~PAGE_IS_ALIGNED;
+macro bool TempAllocatorPage.is_aligned(TempAllocatorPage* page) => page.size & PAGE_IS_ALIGNED == PAGE_IS_ALIGNED;
 
 /**
  * @require size >= 16
  **/
-fn TempAllocator*! new_temp_allocator(usz size, Allocator* allocator)
+fn TempAllocator*! new_temp(usz size, Allocator* backing_allocator)
 {
-	TempAllocator* temp = allocator::alloc_with_padding(allocator, TempAllocator, size)!;
-	temp.last_page = null;
-	temp.backing_allocator = allocator;
-	temp.used = 0;
-	temp.capacity = size;
-	return temp;
+	TempAllocator* allocator = malloc_checked(TempAllocator, .using = backing_allocator, .end_padding = size)?;
+	allocator.last_page = null;
+	allocator.function = &temp_allocator_function;
+	allocator.backing_allocator = backing_allocator;
+	allocator.used = 0;
+	allocator.capacity = size;
+	return allocator;
 }
 
-fn TempAllocator*! new_temp(usz size, Allocator* allocator) @deprecated("Use new_temp_allocator")
+/**
+ * @require !alignment || math::is_power_of_2(alignment)
+ * @require data `unexpectedly missing the allocator`
+ */
+fn void*! temp_allocator_function(Allocator* data, usz size, usz alignment, usz offset, void* old_pointer, AllocationKind kind) @private
 {
-	return new_temp_allocator(size, allocator);
-}
-
-fn usz TempAllocator.mark(&self) @dynamic => self.used;
-
-fn void TempAllocator.release(&self, void* old_pointer, bool) @dynamic
-{
-	usz old_size = *(usz*)(old_pointer - DEFAULT_SIZE_PREFIX);
-	if (old_pointer + old_size == &self.data[self.used])
+	TempAllocator* arena = (TempAllocator*)data;
+	switch (kind)
 	{
-		self.used -= old_size;
+		case CALLOC:
+		case ALIGNED_CALLOC:
+			assert(!old_pointer, "Unexpected old pointer for alloc.");
+			if (!size) return null;
+			return arena._alloc(size, alignment_for_allocation(alignment), offset, true);
+		case ALLOC:
+		case ALIGNED_ALLOC:
+			assert(!old_pointer, "Unexpected old pointer for alloc.");
+			if (!size) return null;
+			return arena._alloc(size, alignment_for_allocation(alignment), offset, false);
+		case ALIGNED_REALLOC:
+		case REALLOC:
+			if (!size) nextcase FREE;
+			if (!old_pointer) nextcase ALLOC;
+			return arena._realloc(old_pointer, size, alignment_for_allocation(alignment), offset);
+		case FREE:
+		case ALIGNED_FREE:
+			if (!old_pointer) return null;
+			arena._free(old_pointer)?;
+        	return null;
+        case MARK:
+            return (void*)(uptr)arena.used;
+		case RESET:
+			arena._reset(size)?;
+			return null;
 	}
+	unreachable();
 }
-fn void TempAllocator.reset(&self, usz mark) @dynamic
+
+fn void! TempAllocator._free(TempAllocator* this, void* old_pointer) @local
 {
-	TempAllocatorPage *last_page = self.last_page;
+	// TODO fix free
+	assert((uptr)old_pointer >= (uptr)&this.data, "Pointer originates from a different allocator.");
+	usz old_size = *(usz*)(old_pointer - DEFAULT_SIZE_PREFIX);
+	if (old_pointer + old_size == &this.data[this.used])
+    {
+        this.used -= old_size;
+    }
+}
+fn void! TempAllocator._reset(TempAllocator* this, usz mark) @local
+{
+	TempAllocatorPage *last_page = this.last_page;
 	while (last_page && last_page.mark > mark)
 	{
 		TempAllocatorPage *to_free = last_page;
 		last_page = last_page.prev_page;
-		self._free_page(to_free)!!;
+		this._free_page(to_free)?;
 	}
-	self.last_page = last_page;
-	self.used = mark;
+	this.last_page = last_page;
+	this.used = mark;
 }
 
-fn void! TempAllocator._free_page(&self, TempAllocatorPage* page) @inline @local
+fn void! TempAllocator._free_page(TempAllocator* this, TempAllocatorPage* page) @inline @local
 {
 	void* mem = page.start;
-	return self.backing_allocator.release(mem, page.is_aligned());
+	if (page.is_aligned()) return this.backing_allocator.free_aligned(mem);
+	return this.backing_allocator.free(mem);
 }
 
-fn void*! TempAllocator._realloc_page(&self, TempAllocatorPage* page, usz size, usz alignment) @inline @local
+fn void*! TempAllocator._realloc_page(TempAllocator* this, TempAllocatorPage* page, usz size, usz alignment, usz offset) @inline @local
 {
 	// Then the actual start pointer:
 	void* real_pointer = page.start;
 
 	// Walk backwards to find the pointer to this page.
-	TempAllocatorPage **pointer_to_prev = &self.last_page;
+	TempAllocatorPage **pointer_to_prev = &this.last_page;
 	// Remove the page from the list
 	while (*pointer_to_prev != page)
 	{
@@ -94,76 +131,82 @@ fn void*! TempAllocator._realloc_page(&self, TempAllocatorPage* page, usz size,
 	*pointer_to_prev = page.prev_page;
 	usz page_size = page.pagesize();
 	// Clear on size > original size.
-	void* data = self.acquire(size, size > page_size, alignment, 0)!;
+	void* data = this._alloc(size, alignment, offset, false)?;
 	mem::copy(data, &page.data[0], page_size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
-	self.backing_allocator.release(real_pointer, page.is_aligned());
+	if (page.is_aligned())
+	{
+		this.backing_allocator.free_aligned(real_pointer)?;
+	}
+	else
+	{
+		this.backing_allocator.free(real_pointer)?;
+	}
 	return data;
 }
 
-fn void*! TempAllocator.resize(&self, void* pointer, usz size, usz alignment, usz deprecated) @dynamic
+fn void*! TempAllocator._realloc(TempAllocator* this, void* pointer, usz size, usz alignment, usz offset) @inline @local
 {
 	TempAllocatorChunk *chunk = pointer - TempAllocatorChunk.sizeof;
 	if (chunk.size == (usz)-1)
 	{
-		assert(self.last_page, "Realloc of non temp pointer");
+		assert(this.last_page, "Realloc of non temp pointer");
 		// First grab the page
 		TempAllocatorPage *page = pointer - TempAllocatorPage.sizeof;
-		return self._realloc_page(page, size, alignment);
+		return this._realloc_page(page, size, alignment, offset);
 	}
 
 	// TODO optimize last allocation
-	TempAllocatorChunk* data = self.acquire(size, size > chunk.size, alignment, 0)!;
+	TempAllocatorChunk* data = this._alloc(size, alignment, offset, size > chunk.size)?;
 	mem::copy(data, pointer, chunk.size, mem::DEFAULT_MEM_ALIGNMENT, mem::DEFAULT_MEM_ALIGNMENT);
 
 	return data;
 }
 
 /**
+ * @require math::is_power_of_2(alignment)
  * @require size > 0
- * @require !alignment || math::is_power_of_2(alignment)
  * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
+ * @require this != null
  **/
-fn void*! TempAllocator.acquire(&self, usz size, bool clear, usz alignment, usz deprecated) @dynamic
+fn void*! TempAllocator._alloc(TempAllocator* this, usz size, usz alignment, usz offset, bool clear) @local
 {
-	alignment = alignment_for_allocation(alignment);
-	void* start_mem = &self.data;
-	void* starting_ptr = start_mem + self.used;
+	void* start_mem = &this.data;
+	void* starting_ptr = start_mem + this.used;
 	void* aligned_header_start = mem::aligned_pointer(starting_ptr, TempAllocatorChunk.alignof);
 	void* mem = aligned_header_start + TempAllocatorChunk.sizeof;
 	if (alignment > TempAllocatorChunk.alignof)
 	{
-		mem = mem::aligned_pointer(mem, alignment);
+		mem = mem::aligned_pointer(mem + offset, alignment) - offset;
 	}
 	usz new_usage = (usz)(mem - start_mem) + size;
 
 	// Arena alignment, simple!
-	if (new_usage <= self.capacity)
+	if (new_usage <= this.capacity)
 	{
 		TempAllocatorChunk* chunk_start = mem - TempAllocatorChunk.sizeof;
-		chunk_start.size = size;
-		self.used = new_usage;
-		if (clear) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
-		return mem;
+    	chunk_start.size = size;
+    	this.used = new_usage;
+    	if (clear) mem::clear(mem, size, mem::DEFAULT_MEM_ALIGNMENT);
+    	return mem;
 	}
 
 	// Fallback to backing allocator
 	TempAllocatorPage* page;
 
 	// We have something we need to align.
-	if (alignment > mem::DEFAULT_MEM_ALIGNMENT)
+	if (alignment > mem::DEFAULT_MEM_ALIGNMENT || offset)
 	{
 		// This is actually simpler, since it will create the offset for us.
-		usz total_alloc_size = mem::aligned_offset(TempAllocatorPage.sizeof + size, alignment);
-		if (clear)
+		usz total_alloc_size = TempAllocatorPage.sizeof + size;
+    	if (clear)
 		{
-			mem = allocator::calloc_aligned(self.backing_allocator, total_alloc_size, alignment)!;
+			page = this.backing_allocator.calloc_aligned(total_alloc_size, alignment, TempAllocatorPage.sizeof + offset)?;
 		}
 		else
 		{
-			mem = allocator::malloc_aligned(self.backing_allocator, total_alloc_size, alignment)!;
+			page = this.backing_allocator.alloc_aligned(total_alloc_size, alignment, TempAllocatorPage.sizeof + offset)?;
 		}
-		page = (TempAllocatorPage*)mem - 1;
-		page.start = mem;
+		page.start = page;
 		page.size = size | PAGE_IS_ALIGNED;
 	}
 	else
@@ -171,7 +214,7 @@ fn void*! TempAllocator.acquire(&self, usz size, bool clear, usz alignment, usz
 		// Here we might need to pad
 		usz padded_header_size = mem::aligned_offset(TempAllocatorPage.sizeof, mem::DEFAULT_MEM_ALIGNMENT);
 		usz total_alloc_size = padded_header_size + size;
-		void* alloc = self.backing_allocator.acquire(total_alloc_size, clear, 0, 0)!;
+		void* alloc = (clear ? this.backing_allocator.calloc(total_alloc_size) : this.backing_allocator.alloc(total_alloc_size))?;
 
 		// Find the page.
 		page = alloc + padded_header_size - TempAllocatorPage.sizeof;
@@ -184,28 +227,28 @@ fn void*! TempAllocator.acquire(&self, usz size, bool clear, usz alignment, usz
 	// Mark it as a page
 	page.ident = ~(usz)0;
 	// Store when it was created
-	page.mark = ++self.used;
+	page.mark = ++this.used;
 	// Hook up the page.
-	page.prev_page = self.last_page;
-	self.last_page = page;
+	page.prev_page = this.last_page;
+	this.last_page = page;
 	return &page.data[0];
 }
 
-fn void! TempAllocator.print_pages(&self, File* f)
+fn void TempAllocator.print_pages(TempAllocator* this, File f)
 {
-	TempAllocatorPage *last_page = self.last_page;
+	TempAllocatorPage *last_page = this.last_page;
 	if (!last_page)
 	{
-		io::fprintf(f, "No pages.\n")!;
+		f.printf("No pages.\n");
 		return;
 	}
-	io::fprintf(f, "---Pages----\n")!;
+	f.printf("---Pages----\n");
 	uint index = 0;
 	while (last_page)
 	{
 		bool is_not_aligned = !(last_page.size & (1u64 << 63));
-		io::fprintf(f, "%d. Alloc: %d %d at %p%s\n", ++index,
-				last_page.size & ~(1u64 << 63), last_page.mark, &last_page.data[0], is_not_aligned ? "" : " [aligned]")!;
+		f.printf("%d. Alloc: %d %d at %p%s\n", ++index,
+				last_page.size & ~(1u64 << 63), last_page.mark, &last_page.data[0], is_not_aligned ? "" : " [aligned]");
 		last_page = last_page.prev_page;
 	}
 }

lib/std/core/allocators/tracking_allocator.c3

@@ -1,217 +1,105 @@
-// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021 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::core::mem::allocator;
-import std::collections, std::io, std::os::backtrace;
+import std::collections::map;
 
-const MAX_BACKTRACE = 16;
-struct Allocation
-{
-	void* ptr;
-	usz size;
-	void*[MAX_BACKTRACE] backtrace;
-}
-
-def AllocMap = HashMap(<uptr, Allocation>);
+typedef PtrMap = HashMap<uptr, usz>;
 
 // A simple tracking allocator.
 // It tracks allocations using a hash map but
 // is not compatible with allocators that uses mark()
-struct TrackingAllocator (Allocator)
+struct TrackingAllocator
 {
+	inline Allocator allocator;
 	Allocator* inner_allocator;
-	AllocMap map;
+	PtrMap map;
 	usz mem_total;
 	usz allocs_total;
 }
 
 /**
- * Initialize a tracking allocator to wrap (and track) another allocator.
+ * Initialize a memory arena for use using the provided bytes.
  *
- * @param [&inout] allocator "The allocator to track"
+ * @require this != null
  **/
-fn void TrackingAllocator.init(&self, Allocator* allocator)
+fn void TrackingAllocator.init(TrackingAllocator* this, Allocator* allocator)
 {
-	*self = { .inner_allocator = allocator };
-	self.map.new_init(.allocator = allocator);
+	*this = { .inner_allocator = allocator, .allocator.function = &tracking_allocator_fn };
+	this.map.init(.using = allocator);
+}
+
+fn void TrackingAllocator.free(TrackingAllocator* this)
+{
+	this.map.free();
+	*this = {};
 }
 
 /**
- * Free this tracking allocator.
- **/
-fn void TrackingAllocator.free(&self)
+ * @param [inout] data
+ * @require !alignment || math::is_power_of_2(alignment)
+ */
+fn void*! tracking_allocator_fn(Allocator* data, usz size, usz alignment, usz offset, void* old_pointer, AllocationKind kind) @private
 {
-	self.map.free();
-	*self = {};
+	TrackingAllocator* this = (TrackingAllocator*)data;
+	void* result = this.inner_allocator.function(this.inner_allocator, size, alignment, offset, old_pointer, kind)?;
+	switch (kind)
+	{
+		case CALLOC:
+		case ALIGNED_CALLOC:
+		case ALLOC:
+		case ALIGNED_ALLOC:
+			this.map.set((uptr)result, size);
+			this.mem_total += size;
+			this.allocs_total++;
+			return result;
+		case REALLOC:
+		case ALIGNED_REALLOC:
+			this.map.remove((uptr)old_pointer);
+			this.map.set((uptr)result, size);
+			this.mem_total += size;
+			if (size > 0) this.allocs_total++;
+			return result;
+		case ALIGNED_FREE:
+		case FREE:
+			if (!old_pointer) return null;
+			this.map.remove((uptr)old_pointer);
+			return null;
+		case MARK:
+			// Unsupported
+			return null;
+		case RESET:
+			this.map.clear();
+			return null;
+	}
+	unreachable();
 }
 
-/**
- * @return "the total allocated memory not yet freed."
- **/
-fn usz TrackingAllocator.allocated(&self)
+fn usz TrackingAllocator.allocated(TrackingAllocator* this)
 {
 	usz allocated = 0;
 	@pool()
 	{
-		foreach (&allocation : self.map.value_tlist()) allocated += allocation.size;
+		foreach (usz allocation : this.map.value_tlist())
+		{
+			allocated += allocation;
+		}
 	};
 	return allocated;
 }
 
-/**
- * @return "the total memory allocated (freed or not)."
- **/
-fn usz TrackingAllocator.total_allocated(&self) => self.mem_total;
-
-/**
- * @return "the total number of allocations (freed or not)."
- **/
-fn usz TrackingAllocator.total_allocation_count(&self) => self.allocs_total;
-
-fn Allocation[] TrackingAllocator.allocations_tlist(&self, Allocator* allocator)
+fn usz TrackingAllocator.total_allocated(TrackingAllocator* this)
 {
-	return self.map.value_tlist();
+	return this.mem_total;
 }
 
-/**
- * @return "the number of non-freed allocations."
- **/
-fn usz TrackingAllocator.allocation_count(&self) => self.map.count;
-
-fn void*! TrackingAllocator.acquire(&self, usz size, bool clear, usz alignment, usz deprecated) @dynamic
+fn usz TrackingAllocator.total_allocation_count(TrackingAllocator* this)
 {
-	void* data = self.inner_allocator.acquire(size, clear, alignment, 0)!;
-	self.allocs_total++;
-	void*[MAX_BACKTRACE] bt;
-	backtrace::capture_current(&bt);
-	self.map.set((uptr)data, { data, size, bt });
-    self.mem_total += size;
-	self.allocs_total++;
-	return data;
+	return this.allocs_total;
 }
 
-fn void*! TrackingAllocator.resize(&self, void* old_pointer, usz size, usz alignment, usz deprecated) @dynamic
+fn usz TrackingAllocator.allocation_count(TrackingAllocator* this)
 {
-	void* data = self.inner_allocator.resize(old_pointer, size, alignment, 0)!;
-	self.map.remove((uptr)old_pointer);
-	void*[MAX_BACKTRACE] bt;
-	backtrace::capture_current(&bt);
-	self.map.set((uptr)data, { data, size, bt });
-    self.mem_total += size;
-	self.allocs_total++;
-	return data;
-}
-
-fn void TrackingAllocator.release(&self, void* old_pointer, bool is_aligned) @dynamic
-{
-	if (catch self.map.remove((uptr)old_pointer))
-    {
-        assert(false, "Attempt to release untracked pointer %p, this is likely a bug.", old_pointer);
-    }
-	self.inner_allocator.release(old_pointer, is_aligned);
-}
-
-fn void TrackingAllocator.clear(&self)
-{
-	self.map.clear();
-}
-
-fn void TrackingAllocator.print_report(&self) => self.fprint_report(io::stdout())!!;
-
-fn void! TrackingAllocator.fprint_report(&self, OutStream* out)
-{
-
-	usz total = 0;
-	usz entries = 0;
-	bool leaks = false;
-	@pool()
-	{
-		Allocation[] allocs = self.map.value_tlist();
-		if (allocs.len)
-		{
-			if (!allocs[0].backtrace[0])
-			{
-				io::fprintn(out, "======== Memory Report ========")!;
-            	io::fprintn(out, "Size in bytes   Address")!;
-            	foreach (i, &allocation : allocs)
-            	{
-            	    entries++;
-            		total += allocation.size;
-            		io::fprintfn(out, "%13s   %p", allocation.size, allocation.ptr)!;
-            	}
-            	io::fprintn(out, "===============================")!;
-
-			}
-			else
-			{
-				io::fprintn(out, "================================== Memory Report ==================================")!;
-				io::fprintn(out, "Size in bytes   Address          Function                       ")!;
-				foreach (i, &allocation : allocs)
-				{
-					entries++;
-					total += allocation.size;
-					BacktraceList backtraces = {};
-					Backtrace trace = backtrace::BACKTRACE_UNKNOWN;
-					if (allocation.backtrace[3])
-					{
-						trace = backtrace::symbolize_backtrace(allocation.backtrace[3:1], allocator::temp()).get(0) ?? backtrace::BACKTRACE_UNKNOWN;
-					}
-					if (trace.function.len)	leaks = true;
-					io::fprintfn(out, "%13s   %p   %s:%d", allocation.size,
-						allocation.ptr, trace.function.len ? trace.function : "???",
-						trace.line ? trace.line : 0)!;
-				}
-				io::fprintn(out, "===================================================================================")!;
-			}
-		}
-		else
-		{
-			io::fprintn(out, "* NO ALLOCATIONS FOUND *")!;
-		}
-		io::fprintfn(out, "- Total currently allocated memory:            %d", total)!;
-        io::fprintfn(out, "- Total current allocations:                   %d", entries)!;
-        io::fprintfn(out, "- Total allocations (freed and retained):      %d", self.allocs_total)!;
-        io::fprintfn(out, "- Total allocated memory (freed and retained): %d", self.mem_total)!;
-        if (leaks)
-        {
-			io::fprintn(out)!;
-			io::fprintn(out, "Full leak report:")!;
-            foreach (i, &allocation : allocs)
-            {
-                if (!allocation.backtrace[3])
-                {
-                    io::fprintfn(out, "Allocation %d (%d bytes) - no backtrace available.", i + 1, allocation.size)!;
-                	continue;
-				}
-                BacktraceList backtraces = {};
-                usz end = MAX_BACKTRACE;
-                foreach (j, val : allocation.backtrace)
-                {
-                    if (!val)
-                	{
-                	    end = j;
-                	    break;
-					}
-				}
-        		BacktraceList list = backtrace::symbolize_backtrace(allocation.backtrace[3..(end - 1)], allocator::temp())!;
-                io::fprintfn(out, "Allocation %d (%d bytes): ", i + 1, allocation.size)!;
-        		foreach (trace : list)
-        		{
-        			if (trace.has_file())
-                	{
-                	    io::fprintfn(out, "   %s (in %s:%d)", trace.function, trace.file, trace.line);
-                	    continue;
-                	}
-                	if (trace.is_unknown())
-                	{
-                	    io::fprintfn(out, "   ??? (in unknown)");
-                	    continue;
-                	}
-					io::fprintfn(out, "   %s (source unavailable)", trace.function);
-				}
-        	}
-        }
-	};
-
+	return this.map.count;
 }

lib/std/core/array.c3

@@ -1,64 +1,9 @@
 module std::core::array;
-import std::core::array::slice;
 
-/**
- * @param [in] array
- * @param [in] element
- * @return "the first index of the element"
- * @return! SearchResult.MISSING
- **/
-macro index_of(array, element)
-{
-	foreach (i, &e : array)
-	{
-		if (*e == element) return i;
-	}
-	return SearchResult.MISSING?;
-}
-
-/**
- * @require @typekind(array) == VECTOR || @typekind(array) == ARRAY
- * @require @typekind(array[0]) == VECTOR || @typekind(array[0]) == ARRAY
- **/
-macro slice2d(array, x = 0, xlen = 0, y = 0, ylen = 0)
-{
-	if (xlen < 1) xlen = $typeof(array[0]).len + xlen;
-	if (ylen < 1) ylen = $typeof(array).len + ylen;
-	var $ElementType = $typeof(array[0][0]);
-	return Slice2d(<$ElementType>) { ($ElementType*)&array, $typeof(array[0]).len, y, ylen, x, xlen };
-}
-
-
-/**
- * @param [in] array
- * @param [in] element
- * @return "the last index of the element"
- * @return! SearchResult.MISSING
- **/
-macro rindex_of(array, element)
-{
-	foreach_r (i, &e : array)
-	{
-		if (*e == element) return i;
-	}
-	return SearchResult.MISSING?;
-}
-
-/**
- * Concatenate two arrays or subarrays, returning a subarray 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) == SUBARRAY || @typekind(arr1) == ARRAY
- * @require @typekind(arr2) == SUBARRAY || @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())
+macro tconcat(arr1, arr2)
 {
 	var $Type = $typeof(arr1[0]);
-	$Type[] result = allocator::alloc_array(allocator, $Type, arr1.len + arr2.len);
+	$Type[] result = array::talloc($Type, arr1.len + arr2.len);
 	if (arr1.len > 0)
 	{
 		mem::copy(result.ptr, &arr1[0], arr1.len * $Type.sizeof, $Type.alignof, $Type.alignof);
@@ -70,78 +15,26 @@ macro concat_new(arr1, arr2, Allocator* allocator = allocator::heap())
 	return result;
 }
 
-/**
- * Concatenate two arrays or subarrays, returning a subarray containing the concatenation of them,
- * allocated using the temp allocator.
- *
- * @param [in] arr1
- * @param [in] arr2
- * @require @typekind(arr1) == SUBARRAY || @typekind(arr1) == ARRAY
- * @require @typekind(arr2) == SUBARRAY || @typekind(arr2) == ARRAY
- * @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());
-
-module std::core::array::slice(<Type>);
-
-struct Slice2d
+macro index_of(array, element)
 {
-	Type* ptr;
-	usz inner_len;
-	usz ystart;
-	usz ylen;
-	usz xstart;
-	usz xlen;
-}
-
-fn usz Slice2d.len(&self) @operator(len)
-{
-	return self.ylen;
-}
-
-fn usz Slice2d.count(&self)
-{
-	return self.ylen * self.xlen;
-}
-
-macro void Slice2d.@each(&self; @body(usz[<2>], Type))
-{
-	foreach (y, line : *self)
+	foreach (i, &e : array)
 	{
-		foreach (x, val : line)
-		{
-			@body({ x, y }, val);
-		}
+		if (*e == element) return i;
 	}
+	return SearchResult.MISSING!;
 }
 
-macro void Slice2d.@each_ref(&self; @body(usz[<2>], Type*))
+macro concat(arr1, arr2)
 {
-	foreach (y, line : *self)
+	var $Type = $typeof(arr1[0]);
+	$Type[] result = array::alloc($Type, arr1.len + arr2.len);
+	if (arr1.len > 0)
 	{
-		foreach (x, &val : line)
-		{
-			@body({ x, y }, val);
-		}
+		mem::copy(result.ptr, &arr1[0], arr1.len * $Type.sizeof, $Type.alignof, $Type.alignof);
 	}
-}
-
-/**
- * @require idy >= 0 && idy < self.ylen
- **/
-macro Type[] Slice2d.get(self, usz idy) @operator([])
-{
-	return (self.ptr + self.inner_len * (idy + self.ystart))[self.xstart:self.xlen];
-}
-
-/**
- * @require y >= 0 && y < self.ylen
- * @require x >= 0 && x < self.xlen
- **/
-fn Slice2d Slice2d.slice(&self, isz x = 0, isz xlen = 0, isz y = 0, isz ylen = 0)
-{
-	if (xlen < 1) xlen = self.xlen + xlen;
-	if (ylen < 1) ylen = self.ylen + ylen;
-	return { self.ptr, self.inner_len, y + self.ystart, ylen, x + self.xstart, xlen };
-}
+	if (arr2.len > 0)
+	{
+		mem::copy(&result[arr1.len], &arr2[0], arr2.len * $Type.sizeof, $Type.alignof, $Type.alignof);
+	}
+	return result;
+}

lib/std/core/bitorder.c3

@@ -1,12 +1,5 @@
-// Copyright (c) 2023 Christoffer Lerno and contributors. 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::core::bitorder;
 
-// This module contains types of different endianness.
-// *BE types represent big-endian types
-// *LE types represent little-endian types.
-
 bitstruct ShortBE : short @bigendian
 {
 	short val : 0..15;
@@ -87,94 +80,3 @@ bitstruct UInt128LE : uint128 @littleendian
 	uint128 val : 0..127;
 }
 
-/**
- * @require is_array_or_sub_of_char(bytes) "argument must be an array, a pointer to an array or a subarray of char"
- * @require is_bitorder($Type) "type must be a bitorder integer"
- **/
-macro read(bytes, $Type)
-{
-	char[] s;
-	$switch (@typekind(bytes))
-	$case POINTER:
-		s = (*bytes)[:$Type.sizeof];
-	$default:
-		s = bytes[:$Type.sizeof];
-	$endswitch
-	return bitcast(*(char[$Type.sizeof]*)s.ptr, $Type).val;
-}
-
-/**
- * @require is_arrayptr_or_sub_of_char(bytes) "argument must be a pointer to an array or a subarray of char"
- * @require is_bitorder($Type) "type must be a bitorder integer"
- **/
-macro write(x, bytes, $Type)
-{
-	char[] s;
-	$switch (@typekind(bytes))
-	$case POINTER:
-		s = (*bytes)[:$Type.sizeof];
-	$default:
-		s = bytes[:$Type.sizeof];
-	$endswitch
-	*($typeof(x)*)s.ptr = bitcast(x, $Type).val;
-}
-
-macro is_bitorder($Type)
-{
-	$switch ($Type)
-	$case UShortLE:
-	$case ShortLE:
-	$case UIntLE:
-	$case IntLE:
-	$case ULongLE:
-	$case LongLE:
-	$case UInt128LE:
-	$case Int128LE:
-	$case UShortBE:
-	$case ShortBE:
-	$case UIntBE:
-	$case IntBE:
-	$case ULongBE:
-	$case LongBE:
-	$case UInt128BE:
-	$case Int128BE:
-		return true;
-	$default:
-		return false;
-	$endswitch
-}
-
-macro bool is_array_or_sub_of_char(bytes)
-{
-	$switch (@typekind(bytes))
-	$case POINTER:
-		var $Inner = $typefrom($typeof(bytes).inner);
-		$if $Inner.kindof == ARRAY:
-			var $Inner2 = $typefrom($Inner.inner);
-			return $Inner2.typeid == char.typeid;
-		$endif
-	$case ARRAY:
-	$case SUBARRAY:
-		var $Inner = $typefrom($typeof(bytes).inner);
-		return $Inner.typeid == char.typeid;
-	$default:
-		return false;
-	$endswitch
-}
-
-macro bool is_arrayptr_or_sub_of_char(bytes)
-{
-	$switch (@typekind(bytes))
-	$case POINTER:
-		var $Inner = $typefrom($typeof(bytes).inner);
-		$if $Inner.kindof == ARRAY:
-			var $Inner2 = $typefrom($Inner.inner);
-			return $Inner2.typeid == char.typeid;
-		$endif
-	$case SUBARRAY:
-		var $Inner = $typefrom($typeof(bytes).inner);
-		return $Inner.typeid == char.typeid;
-	$default:
-		return false;
-	$endswitch
-}

lib/std/core/builtin.c3

@@ -1,29 +1,21 @@
-// Copyright (c) 2021-2024 Christoffer Lerno and contributors. All rights reserved.
+// Copyright (c) 2021-2022 Christoffer Lerno and contributors. 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::core::builtin;
-import libc, std::hash, std::io, std::os::backtrace;
+import libc;
+import std::hash;
 
-/**
- * Use `IteratorResult` when reading the end of an iterator, or accessing a result out of bounds.
- **/
 fault IteratorResult
 {
 	NO_MORE_ELEMENT
 }
 
-/**
- * Use `SearchResult` when trying to return a value from some collection but the element is missing.
- **/
 fault SearchResult
 {
 	MISSING
 }
 
-/**
- * Use `CastResult` when an attempt at conversion fails.
- **/
-fault CastResult
+fault VarCastResult
 {
 	TYPE_MISMATCH
 }
@@ -36,229 +28,127 @@ fault CastResult
  **/
 macro void @scope(&variable; @body) @builtin
 {
-	var temp = *variable;
-	defer *variable = temp;
+	var temp = variable;
+	defer variable = temp;
 	@body();
 }
 
-/**
- * Swap two variables
- * @require $assignable(*b, $typeof(*a)) && $assignable(*a, $typeof(*b))
- **/
 macro void @swap(&a, &b) @builtin
 {
-	var temp = *a;
-	*a = *b;
-	*b = temp;
+	var temp = a;
+	a = b;
+	b = temp;
 }
 
 /**
- * Convert an `any` type to a type, returning an failure if there is a type mismatch.
+ * Convert a variant type to a type, returning an failure if there is a type mismatch.
  *
- * @param v `the any to convert to the given type.`
+ * @param v `the variant to convert to the given type.`
  * @param $Type `the type to convert to`
- * @return `The any.ptr converted to its type.`
- * @ensure @typeis(return, $Type*)
- * @return! CastResult.TYPE_MISMATCH
+ * @return `The variant.ptr converted to its type.`
  **/
-macro anycast(any* v, $Type) @builtin
+macro varcast(variant v, $Type) @builtin
 {
-	if (v.type != $Type.typeid) return CastResult.TYPE_MISMATCH?;
+	if (v.type != $Type.typeid) return VarCastResult.TYPE_MISMATCH!;
 	return ($Type*)v.ptr;
 }
 
-fn bool print_backtrace(String message, int backtraces_to_ignore) @if(env::NATIVE_STACKTRACE)
+struct CallstackElement
 {
-	@pool()
-	{
-		void*[256] buffer;
-		void*[] backtraces = backtrace::capture_current(&buffer);
-		backtraces_to_ignore++;
-		BacktraceList! backtrace = backtrace::symbolize_backtrace(backtraces, allocator::temp());
-		if (catch backtrace) return false;
-		if (backtrace.len() <= backtraces_to_ignore) return false;
-		io::eprint("\nERROR: '");
-        io::eprint(message);
-        io::eprintn("'");
-		foreach (i, &trace : backtrace)
-        {
-            if (i < backtraces_to_ignore) continue;
-            if (trace.is_unknown())
-            {
-				io::eprintn("  in ???");
-				continue;
-			}
-			if (trace.has_file())
-            {
-                io::eprintfn("  in %s (%s:%d) [%s]", trace.function, trace.file, trace.line, trace.object_file);
-                continue;
-            }
-            io::eprintfn("  in %s (source unavailable) [%s]", trace.function, trace.object_file);
-		}
-		return true;
-	};
+	CallstackElement* prev;
+	String function;
+	String file;
+	uint line;
 }
-fn void default_panic(String message, String file, String function, uint line) @if(env::NATIVE_STACKTRACE)
+
+fn void default_panic(String message, String file, String function, uint line)
 {
-	$if $defined(io::stderr):
-	if (!print_backtrace(message, 2))
+	CallstackElement* stack = $$stacktrace();
+	$if ($defined(libc::stderr) && $defined(libc::fprintf))
+
+	if (stack) stack = stack.prev;
+	if (stack)
 	{
-		io::eprintfn("\nERROR: '%s', in %s (%s:%d)", message, function, file, line);
-		return;
+		libc::fprintf(libc::stderr(), "\nERROR: '%.*s'\n", (int)message.len, message.ptr);
+	}
+	else
+	{
+		libc::fprintf(libc::stderr(), "\nERROR: '%.*s', function %.*s (%.*s:%d)\n",
+			(int)message.len, message.ptr, (int)function.len, function.ptr, (int)file.len, file.ptr, line);
+	}
+	while (stack)
+	{
+		libc::fprintf(libc::stderr(), "  at function %.*s (%.*s:%u)\n", (int)stack.function.len, stack.function.ptr,
+		    (int)stack.file.len, stack.file.ptr, stack.line);
+		if (stack == stack.prev) break;
+		stack = stack.prev;
 	}
-	$endif
-	$$trap();
 
-}
-fn void default_panic(String message, String file, String function, uint line) @if(!env::NATIVE_STACKTRACE)
-{
-	$if $defined(io::stderr):
-	io::eprint("\nERROR: '");
-	io::eprint(message);
-	io::eprintfn("', in %s (%s:%d)", function, file, line);
 	$endif
 	$$trap();
 }
 
-def PanicFn = fn void(String message, String file, String function, uint line);
+typedef PanicFn = fn void(String message, String file, String function, uint line);
 
 PanicFn panic = &default_panic;
 
-fn void panicf(String fmt, String file, String function, uint line, args...)
+macro void unreachable($string = "Unreachable statement reached.") @builtin @noreturn
 {
-	@stack_mem(512; Allocator* allocator)
-	{
-		DString s;
-		s.new_init(.allocator = allocator);
-		s.appendf(fmt, ...args);
-		panic(s.str_view(), file, function, line);
-	};
-}
-
-/**
- * Marks the path as unreachable. This will panic in safe mode, and in fast will simply be assumed
- * never happens.
- * @param [in] string "The panic message or format string"
- **/
-macro void unreachable(String string = "Unreachable statement reached.", ...) @builtin @noreturn
-{
-	panicf(string, $$FILE, $$FUNC, $$LINE, $vasplat());
+	panic($string, $$FILE, $$FUNC, $$LINE);
 	$$unreachable();
 }
 
-/**
- * Marks the path as unsupported, this is similar to unreachable.
- * @param [in] string "The error message"
- **/
-macro void unsupported(String string = "Unsupported function invoked") @builtin @noreturn
-{
-	panicf(string, $$FILE, $$FUNC, $$LINE, $vasplat());
-	$$unreachable();
-}
-
-macro any_make(void* ptr, typeid type) @builtin
-{
-	return $$any_make(ptr, type);
-}
-
-macro any.retype_to(&self, typeid type)
-{
-	return $$any_make(self.ptr, type);
-}
-
-macro any.as_inner(&self)
-{
-	return $$any_make(self.ptr, self.type.inner);
-}
-
-/**
- * @param expr "the expression to cast"
- * @param $Type "the type to cast to"
- *
- * @require $sizeof(expr) == $Type.sizeof  "Cannot bitcast between types of different size."
- * @ensure @typeis(return, $Type)
- **/
 macro bitcast(expr, $Type) @builtin
 {
-	$if $Type.alignof <= $alignof(expr):
-		return *($Type*)&expr;
-	$else
-		$Type x @noinit;
-		$$memcpy(&x, &expr, $sizeof(expr), false, $Type.alignof, $alignof(expr));
-		return x;
-	$endif
+	var $size = (usz)($sizeof(expr));
+	$assert($size == $Type.sizeof, "Cannot bitcast between types of different size.");
+	$Type x @noinit;
+	mem::copy(&x, &expr, $size, $Type.alignof, $alignof(expr));
+	return x;
 }
 
 /**
- * @param $Type `The type of the enum`
- * @param [in] enum_name `The name of the enum to search for`
- * @require $Type.kindof == ENUM `Only enums may be used`
- * @ensure @typeis(return, $Type)
- * @return! SearchResult.MISSING
+ * @require $Type.kindof == TypeKind.ENUM `Only enums may be used`
  **/
 macro enum_by_name($Type, String enum_name) @builtin
 {
 	typeid x = $Type.typeid;
 	foreach (i, name : x.names)
 	{
-		if (name == enum_name) return ($Type)i;
+		if (str::compare(name, enum_name)) return ($Type)i;
 	}
-	return SearchResult.MISSING?;
+	return SearchResult.MISSING!;
+}
+
+macro bool @likely(bool value, $probability = 1.0) @builtin
+{
+    $if ($probability == 1.0)
+	return $$expect(value, true);
+    $else
+	return $$expect_with_probability(value, true, $probability);
+    $endif
+}
+
+macro bool @unlikely(bool value, $probability = 1.0) @builtin
+{
+    $if ($probability == 1.0)
+	return $$expect(value, false);
+    $else
+	return $$expect_with_probability(value, false, $probability);
+    $endif
 }
 
 /**
- * Mark an expression as likely to be true
- *
- * @param #value "expression to be marked likely"
- * @param $probability "in the range 0 - 1"
- * @require $probability >= 0 && $probability <= 1.0
+ * @require values::@is_int(value) || values::@is_bool(value)
+ * @checked $typeof(value) a = expected
  **/
-macro bool @likely(bool #value, $probability = 1.0) @builtin
+macro @expect(value, expected, $probability = 1.0) @builtin
 {
-    $switch
-    $case env::BUILTIN_EXPECT_IS_DISABLED:
-	return #value;
-    $case $probability == 1.0:
-	return $$expect(#value, true);
-    $default:
-	return $$expect_with_probability(#value, true, $probability);
-    $endswitch
-}
-
-/**
- * Mark an expression as unlikely to be true
- *
- * @param #value "expression to be marked unlikely"
- * @param $probability "in the range 0 - 1"
- * @require $probability >= 0 && $probability <= 1.0
- **/
-macro bool @unlikely(bool #value, $probability = 1.0) @builtin
-{
-    $switch
-    $case env::BUILTIN_EXPECT_IS_DISABLED:
-	return #value;
-    $case $probability == 1.0:
-	return $$expect(#value, false);
-    $default:
-	return $$expect_with_probability(#value, false, $probability);
-    $endswitch
-}
-
-/**
- * @require values::@is_int(#value) || values::@is_bool(#value)
- * @require $assignable(expected, $typeof(#value))
- * @require $probability >= 0 && $probability <= 1.0
- **/
-macro @expect(#value, expected, $probability = 1.0) @builtin
-{
-    $switch
-    $case env::BUILTIN_EXPECT_IS_DISABLED:
-	return #value == expected;
-    $case $probability == 1.0:
-	return $$expect(#value, ($typeof(#value))expected);
-    $default:
-	return $$expect_with_probability(#value, expected, $probability);
-    $endswitch
+    $if ($probability == 1.0)
+	return $$expect(value, ($typeof(value))expected);
+    $else
+	return $$expect_with_probability(value, expected, $probability);
+    $endif
 }
 
 /**
@@ -280,11 +170,9 @@ enum PrefetchLocality
  * @param $locality `Locality ranging from none to extremely local`
  * @param $write `Prefetch for write, otherwise prefetch for read.`
  **/
-macro @prefetch(void* ptr, PrefetchLocality $locality = VERY_NEAR, bool $write = false) @builtin
+macro prefetch(void* ptr, PrefetchLocality $locality = VERY_NEAR, bool $write = false) @builtin
 {
-	$if !env::BUILTIN_PREFETCH_IS_DISABLED:
-		$$prefetch(ptr, $write ? 1 : 0, $locality.ordinal);
-	$endif
+	$$prefetch(ptr, $write ? 1 : 0, $locality.ordinal);
 }
 
 macro swizzle(v, ...) @builtin
@@ -297,21 +185,14 @@ macro swizzle2(v, v2, ...) @builtin
 	return $$swizzle2(v, v2, $vasplat());
 }
 
-macro anyfault @catch(#expr) @builtin
+macro bool @castable(#expr, $To) @builtin
 {
-	if (catch f = #expr) return f;
-	return anyfault {};
+	return $checks(($To)#expr);
 }
 
-macro bool @ok(#expr) @builtin
+macro bool @convertible(#expr, $To) @builtin
 {
-	if (catch #expr) return false;
-	return true;
-}
-
-macro char[] @as_char_view(&value) @builtin
-{
-	return ((char*)value)[:$sizeof(*value)];
+	return $checks($To x = #expr);
 }
 
 macro uint int.hash(int i) => i;
@@ -322,349 +203,7 @@ macro uint char.hash(char c) => c;
 macro uint ichar.hash(ichar c) => c;
 macro uint long.hash(long i) => (uint)((i >> 32) ^ i);
 macro uint ulong.hash(ulong i) => (uint)((i >> 32) ^ i);
-macro uint int128.hash(int128 i) => (uint)((i >> 96) ^ (i >> 64) ^ (i >> 32) ^ i);
-macro uint uint128.hash(uint128 i) => (uint)((i >> 96) ^ (i >> 64) ^ (i >> 32) ^ i);
 macro uint bool.hash(bool b) => (uint)b;
-macro uint typeid.hash(typeid t) => ((ulong)(uptr)t).hash();
+macro uint typeid.hash(typeid t) => (uint)(((uptr)t >> 32) ^ (uptr)t);
 macro uint String.hash(String c) => (uint)fnv32a::encode(c);
-macro uint char[].hash(char[] c) => (uint)fnv32a::encode(c);
-macro uint void*.hash(void* ptr) => ((ulong)(uptr)ptr).hash();
-
-const MAX_FRAMEADDRESS = 128;
-/**
- * @require n >= 0
- **/
-macro void* get_frameaddress(int n)
-{
-	if (n > MAX_FRAMEADDRESS) return null;
-	switch (n)
-	{
-		case 0: return $$frameaddress(0);
-		case 1: return $$frameaddress(1);
-		case 2: return $$frameaddress(2);
-		case 3: return $$frameaddress(3);
-		case 4: return $$frameaddress(4);
-		case 5: return $$frameaddress(5);
-		case 6: return $$frameaddress(6);
-		case 7: return $$frameaddress(7);
-		case 8: return $$frameaddress(8);
-		case 9: return $$frameaddress(9);
-		case 10: return $$frameaddress(10);
-		case 11: return $$frameaddress(11);
-		case 12: return $$frameaddress(12);
-		case 13: return $$frameaddress(13);
-		case 14: return $$frameaddress(14);
-		case 15: return $$frameaddress(15);
-		case 16: return $$frameaddress(16);
-		case 17: return $$frameaddress(17);
-		case 18: return $$frameaddress(18);
-		case 19: return $$frameaddress(19);
-		case 20: return $$frameaddress(20);
-		case 21: return $$frameaddress(21);
-		case 22: return $$frameaddress(22);
-		case 23: return $$frameaddress(23);
-		case 24: return $$frameaddress(24);
-		case 25: return $$frameaddress(25);
-		case 26: return $$frameaddress(26);
-		case 27: return $$frameaddress(27);
-		case 28: return $$frameaddress(28);
-		case 29: return $$frameaddress(29);
-		case 30: return $$frameaddress(30);
-		case 31: return $$frameaddress(31);
-		case 32: return $$frameaddress(32);
-		case 33: return $$frameaddress(33);
-		case 34: return $$frameaddress(34);
-		case 35: return $$frameaddress(35);
-		case 36: return $$frameaddress(36);
-		case 37: return $$frameaddress(37);
-		case 38: return $$frameaddress(38);
-		case 39: return $$frameaddress(39);
-		case 40: return $$frameaddress(40);
-		case 41: return $$frameaddress(41);
-		case 42: return $$frameaddress(42);
-		case 43: return $$frameaddress(43);
-		case 44: return $$frameaddress(44);
-		case 45: return $$frameaddress(45);
-		case 46: return $$frameaddress(46);
-		case 47: return $$frameaddress(47);
-		case 48: return $$frameaddress(48);
-		case 49: return $$frameaddress(49);
-		case 50: return $$frameaddress(50);
-		case 51: return $$frameaddress(51);
-		case 52: return $$frameaddress(52);
-		case 53: return $$frameaddress(53);
-		case 54: return $$frameaddress(54);
-		case 55: return $$frameaddress(55);
-		case 56: return $$frameaddress(56);
-		case 57: return $$frameaddress(57);
-		case 58: return $$frameaddress(58);
-		case 59: return $$frameaddress(59);
-		case 60: return $$frameaddress(60);
-		case 61: return $$frameaddress(61);
-		case 62: return $$frameaddress(62);
-		case 63: return $$frameaddress(63);
-		case 64: return $$frameaddress(64);
-		case 65: return $$frameaddress(65);
-		case 66: return $$frameaddress(66);
-		case 67: return $$frameaddress(67);
-		case 68: return $$frameaddress(68);
-		case 69: return $$frameaddress(69);
-		case 70: return $$frameaddress(70);
-		case 71: return $$frameaddress(71);
-		case 72: return $$frameaddress(72);
-		case 73: return $$frameaddress(73);
-		case 74: return $$frameaddress(74);
-		case 75: return $$frameaddress(75);
-		case 76: return $$frameaddress(76);
-		case 77: return $$frameaddress(77);
-		case 78: return $$frameaddress(78);
-		case 79: return $$frameaddress(79);
-		case 80: return $$frameaddress(80);
-		case 81: return $$frameaddress(81);
-		case 82: return $$frameaddress(82);
-		case 83: return $$frameaddress(83);
-		case 84: return $$frameaddress(84);
-		case 85: return $$frameaddress(85);
-		case 86: return $$frameaddress(86);
-		case 87: return $$frameaddress(87);
-		case 88: return $$frameaddress(88);
-		case 89: return $$frameaddress(89);
-		case 90: return $$frameaddress(90);
-		case 91: return $$frameaddress(91);
-		case 92: return $$frameaddress(92);
-		case 93: return $$frameaddress(93);
-		case 94: return $$frameaddress(94);
-		case 95: return $$frameaddress(95);
-		case 96: return $$frameaddress(96);
-		case 97: return $$frameaddress(97);
-		case 98: return $$frameaddress(98);
-		case 99: return $$frameaddress(99);
-		case 100: return $$frameaddress(100);
-		case 101: return $$frameaddress(101);
-		case 102: return $$frameaddress(102);
-		case 103: return $$frameaddress(103);
-		case 104: return $$frameaddress(104);
-		case 105: return $$frameaddress(105);
-		case 106: return $$frameaddress(106);
-		case 107: return $$frameaddress(107);
-		case 108: return $$frameaddress(108);
-		case 109: return $$frameaddress(109);
-		case 110: return $$frameaddress(110);
-		case 111: return $$frameaddress(111);
-		case 112: return $$frameaddress(112);
-		case 113: return $$frameaddress(113);
-		case 114: return $$frameaddress(114);
-		case 115: return $$frameaddress(115);
-		case 116: return $$frameaddress(116);
-		case 117: return $$frameaddress(117);
-		case 118: return $$frameaddress(118);
-		case 119: return $$frameaddress(119);
-		case 120: return $$frameaddress(120);
-		case 121: return $$frameaddress(121);
-		case 122: return $$frameaddress(122);
-		case 123: return $$frameaddress(123);
-		case 124: return $$frameaddress(124);
-		case 125: return $$frameaddress(125);
-		case 126: return $$frameaddress(126);
-		case 127: return $$frameaddress(127);
-		case 128: return $$frameaddress(128);
-		default: unreachable();
-	}
-}
-
-/**
- * @require n >= 0
- **/
-macro void* get_returnaddress(int n)
-{
-	if (n > MAX_FRAMEADDRESS) return null;
-	switch (n)
-	{
-		case 0: return $$returnaddress(0);
-		case 1: return $$returnaddress(1);
-		case 2: return $$returnaddress(2);
-		case 3: return $$returnaddress(3);
-		case 4: return $$returnaddress(4);
-		case 5: return $$returnaddress(5);
-		case 6: return $$returnaddress(6);
-		case 7: return $$returnaddress(7);
-		case 8: return $$returnaddress(8);
-		case 9: return $$returnaddress(9);
-		case 10: return $$returnaddress(10);
-		case 11: return $$returnaddress(11);
-		case 12: return $$returnaddress(12);
-		case 13: return $$returnaddress(13);
-		case 14: return $$returnaddress(14);
-		case 15: return $$returnaddress(15);
-		case 16: return $$returnaddress(16);
-		case 17: return $$returnaddress(17);
-		case 18: return $$returnaddress(18);
-		case 19: return $$returnaddress(19);
-		case 20: return $$returnaddress(20);
-		case 21: return $$returnaddress(21);
-		case 22: return $$returnaddress(22);
-		case 23: return $$returnaddress(23);
-		case 24: return $$returnaddress(24);
-		case 25: return $$returnaddress(25);
-		case 26: return $$returnaddress(26);
-		case 27: return $$returnaddress(27);
-		case 28: return $$returnaddress(28);
-		case 29: return $$returnaddress(29);
-		case 30: return $$returnaddress(30);
-		case 31: return $$returnaddress(31);
-		case 32: return $$returnaddress(32);
-		case 33: return $$returnaddress(33);
-		case 34: return $$returnaddress(34);
-		case 35: return $$returnaddress(35);
-		case 36: return $$returnaddress(36);
-		case 37: return $$returnaddress(37);
-		case 38: return $$returnaddress(38);
-		case 39: return $$returnaddress(39);
-		case 40: return $$returnaddress(40);
-		case 41: return $$returnaddress(41);
-		case 42: return $$returnaddress(42);
-		case 43: return $$returnaddress(43);
-		case 44: return $$returnaddress(44);
-		case 45: return $$returnaddress(45);
-		case 46: return $$returnaddress(46);
-		case 47: return $$returnaddress(47);
-		case 48: return $$returnaddress(48);
-		case 49: return $$returnaddress(49);
-		case 50: return $$returnaddress(50);
-		case 51: return $$returnaddress(51);
-		case 52: return $$returnaddress(52);
-		case 53: return $$returnaddress(53);
-		case 54: return $$returnaddress(54);
-		case 55: return $$returnaddress(55);
-		case 56: return $$returnaddress(56);
-		case 57: return $$returnaddress(57);
-		case 58: return $$returnaddress(58);
-		case 59: return $$returnaddress(59);
-		case 60: return $$returnaddress(60);
-		case 61: return $$returnaddress(61);
-		case 62: return $$returnaddress(62);
-		case 63: return $$returnaddress(63);
-		case 64: return $$returnaddress(64);
-		case 65: return $$returnaddress(65);
-		case 66: return $$returnaddress(66);
-		case 67: return $$returnaddress(67);
-		case 68: return $$returnaddress(68);
-		case 69: return $$returnaddress(69);
-		case 70: return $$returnaddress(70);
-		case 71: return $$returnaddress(71);
-		case 72: return $$returnaddress(72);
-		case 73: return $$returnaddress(73);
-		case 74: return $$returnaddress(74);
-		case 75: return $$returnaddress(75);
-		case 76: return $$returnaddress(76);
-		case 77: return $$returnaddress(77);
-		case 78: return $$returnaddress(78);
-		case 79: return $$returnaddress(79);
-		case 80: return $$returnaddress(80);
-		case 81: return $$returnaddress(81);
-		case 82: return $$returnaddress(82);
-		case 83: return $$returnaddress(83);
-		case 84: return $$returnaddress(84);
-		case 85: return $$returnaddress(85);
-		case 86: return $$returnaddress(86);
-		case 87: return $$returnaddress(87);
-		case 88: return $$returnaddress(88);
-		case 89: return $$returnaddress(89);
-		case 90: return $$returnaddress(90);
-		case 91: return $$returnaddress(91);
-		case 92: return $$returnaddress(92);
-		case 93: return $$returnaddress(93);
-		case 94: return $$returnaddress(94);
-		case 95: return $$returnaddress(95);
-		case 96: return $$returnaddress(96);
-		case 97: return $$returnaddress(97);
-		case 98: return $$returnaddress(98);
-		case 99: return $$returnaddress(99);
-		case 100: return $$returnaddress(100);
-		case 101: return $$returnaddress(101);
-		case 102: return $$returnaddress(102);
-		case 103: return $$returnaddress(103);
-		case 104: return $$returnaddress(104);
-		case 105: return $$returnaddress(105);
-		case 106: return $$returnaddress(106);
-		case 107: return $$returnaddress(107);
-		case 108: return $$returnaddress(108);
-		case 109: return $$returnaddress(109);
-		case 110: return $$returnaddress(110);
-		case 111: return $$returnaddress(111);
-		case 112: return $$returnaddress(112);
-		case 113: return $$returnaddress(113);
-		case 114: return $$returnaddress(114);
-		case 115: return $$returnaddress(115);
-		case 116: return $$returnaddress(116);
-		case 117: return $$returnaddress(117);
-		case 118: return $$returnaddress(118);
-		case 119: return $$returnaddress(119);
-		case 120: return $$returnaddress(120);
-		case 121: return $$returnaddress(121);
-		case 122: return $$returnaddress(122);
-		case 123: return $$returnaddress(123);
-		case 124: return $$returnaddress(124);
-		case 125: return $$returnaddress(125);
-		case 126: return $$returnaddress(126);
-		case 127: return $$returnaddress(127);
-		case 128: return $$returnaddress(128);
-		default: unreachable();
-	}
-}
-
-module std::core::builtin @if((env::LINUX || env::DARWIN) && env::COMPILER_SAFE_MODE && env::DEBUG_SYMBOLS);
-import libc, std::io;
-
-fn void sig_panic(String message)
-{
-	default_panic(message, "???", "???", 0);
-}
-
-SignalFunction old_bus_error;
-SignalFunction old_segmentation_fault;
-
-fn void sig_bus_error(CInt i)
-{
-	$if !env::NATIVE_STACKTRACE:
-		sig_panic("Illegal memory access.");
-	$else
-		$if $defined(io::stderr):
-			if (!print_backtrace("Illegal memory access.", 1))
-			{
-				io::eprintn("\nERROR: 'Illegal memory access'.");
-			}
-		$endif
-	$endif
-	$$trap();
-}
-
-fn void sig_segmentation_fault(CInt i)
-{
-	$if !env::NATIVE_STACKTRACE:
-		sig_panic("Out of bounds memory access.");
-	$else
-		$if $defined(io::stderr):
-			if (!print_backtrace("Out of bounds memory access.", 1))
-			{
-				io::eprintn("\nERROR: Memory error without backtrace, possible stack overflow.");
-			}
-		$endif
-	$endif
-	$$trap();
-}
-
-fn void install_signal_handler(CInt signal, SignalFunction func) @local
-{
-	SignalFunction old = libc::signal(signal, func);
-	// Restore
-	if ((iptr)old > 1024) libc::signal(signal, old);
-}
-
-// Clean this up
-fn void install_signal_handlers() @init(101) @local
-{
-	install_signal_handler(libc::SIGBUS, &sig_bus_error);
-	install_signal_handler(libc::SIGSEGV, &sig_segmentation_fault);
-}
-
+macro uint char[].hash(char[] c) => (uint)fnv32a::encode(c);

lib/std/core/builtin_comparison.c3

@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2024 Christoffer Lerno and contributors. All rights reserved.
+// Copyright (c) 2021-2022 Christoffer Lerno and contributors. 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::core::builtin;
@@ -8,14 +8,14 @@ module std::core::builtin;
  **/
 macro less(a, b) @builtin
 {
-	$switch
+$switch
 	$case $defined(a.less):
 		return a.less(b);
 	$case $defined(a.compare_to):
 		return a.compare_to(b) < 0;
 	$default:
 		return a < b;
-	$endswitch
+$endswitch
 }
 
 /**
@@ -23,14 +23,14 @@ macro less(a, b) @builtin
  **/
 macro less_eq(a, b) @builtin
 {
-	$switch
+$switch
 	$case $defined(a.less):
 		return !b.less(a);
 	$case $defined(a.compare_to):
 		return a.compare_to(b) <= 0;
 	$default:
 		return a <= b;
-	$endswitch
+$endswitch
 }
 
 /**
@@ -38,43 +38,29 @@ macro less_eq(a, b) @builtin
  **/
 macro greater(a, b) @builtin
 {
-	$switch
+$switch
 	$case $defined(a.less):
 		return b.less(a);
 	$case $defined(a.compare_to):
 		return a.compare_to(b) > 0;
 	$default:
 		return a > b;
-	$endswitch
+$endswitch
 }
 
-/**
- * @require types::is_comparable_value(a) && types::is_comparable_value(b)
- **/
-macro int compare_to(a, b) @builtin
-{
-	$switch
-	$case $defined(a.compare_to):
-		return a.compare_to(b);
-	$case $defined(a.less):
-		return (int)b.less(a) - (int)a.less(b);
-	$default:
-		return (int)(a > b) - (int)(a < b);
-	$endswitch
-}
 /**
  * @require types::is_comparable_value(a) && types::is_comparable_value(b)
  **/
 macro greater_eq(a, b) @builtin
 {
-	$switch
+$switch
 	$case $defined(a.less):
 		return !a.less(b);
 	$case $defined(a.compare_to):
 		return a.compare_to(b) >= 0;
 	$default:
 		return a >= b;
-	$endswitch
+$endswitch
 }
 
 /**
@@ -82,47 +68,47 @@ macro greater_eq(a, b) @builtin
  **/
 macro bool equals(a, b) @builtin
 {
-	$switch
-	$case $defined(a.equals, a.equals(b)):
+$switch
+	$case $defined(a.equals):
 		return a.equals(b);
-	$case $defined(a.compare_to, a.compare_to(b)):
+	$case $defined(a.compare_to):
 		return a.compare_to(b) == 0;
 	$case $defined(a.less):
 		return !a.less(b) && !b.less(a);
 	$default:
 		return a == b;
-	$endswitch
+$endswitch
 }
 
 macro min(x, ...) @builtin
 {
-	$if $vacount == 1:
-		return less(x, $vaarg(0)) ? x : $vaarg(0);
-	$else
-		var result = x;
-		$for (var $i = 0; $i < $vacount; $i++)
-			if (less($vaarg($i), result))
-			{
-				 result = $vaarg($i);
-			}
-		$endfor
-		return result;
-	$endif
+    $if ($vacount == 1)
+        return less(x, $vaarg(0)) ? x : $vaarg(0);
+    $else
+        var result = x;
+        $for (var $i = 0; $i < $vacount; $i++)
+            if (less($vaarg($i), result))
+            {
+                 result = $vaarg($i);
+            }
+        $endfor
+        return result;
+    $endif
 }
 
 macro max(x, ...) @builtin
 {
-	$if $vacount == 1:
-		return greater(x, $vaarg(0)) ? x : $vaarg(0);
-	$else
-		var result = x;
-		$for (var $i = 0; $i < $vacount; $i++)
-			if (greater($vaarg($i), result))
-			{
-				 result = $vaarg($i);
-			}
-		$endfor
-		return result;
-	$endif
+    $if ($vacount == 1)
+        return greater(x, $vaarg(0)) ? x : $vaarg(0);
+    $else
+        var result = x;
+        $for (var $i = 0; $i < $vacount; $i++)
+            if (greater($vaarg($i), result))
+            {
+                 result = $vaarg($i);
+            }
+        $endfor
+        return result;
+    $endif
 }
 

lib/std/core/cinterop.c3

@@ -1,4 +1,4 @@
-// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021 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::core::cinterop;
@@ -8,48 +8,80 @@ const C_LONG_SIZE = $$C_LONG_SIZE;
 const C_SHORT_SIZE = $$C_SHORT_SIZE;
 const C_LONG_LONG_SIZE = $$C_LONG_LONG_SIZE;
 
-$assert C_SHORT_SIZE < 32;
-$assert C_INT_SIZE < 128;
-$assert C_LONG_SIZE < 128;
-$assert C_LONG_LONG_SIZE <= 128;
-$assert C_SHORT_SIZE <= C_INT_SIZE;
-$assert C_INT_SIZE <= C_LONG_SIZE;
-$assert C_LONG_SIZE <= C_LONG_LONG_SIZE;
+$assert (C_SHORT_SIZE < 32);
+$assert (C_INT_SIZE < 128);
+$assert (C_LONG_SIZE < 128);
+$assert (C_LONG_LONG_SIZE <= 128);
+$assert (C_SHORT_SIZE <= C_INT_SIZE);
+$assert (C_INT_SIZE <= C_LONG_SIZE);
+$assert (C_LONG_SIZE <= C_LONG_LONG_SIZE);
 
-def CShort = $typefrom(signed_int_from_bitsize($$C_SHORT_SIZE));
-def CUShort = $typefrom(unsigned_int_from_bitsize($$C_SHORT_SIZE));
-def CInt = $typefrom(signed_int_from_bitsize($$C_INT_SIZE));
-def CUInt = $typefrom(unsigned_int_from_bitsize($$C_INT_SIZE));
-def CLong = $typefrom(signed_int_from_bitsize($$C_LONG_SIZE));
-def CULong = $typefrom(unsigned_int_from_bitsize($$C_LONG_SIZE));
-def CLongLong = $typefrom(signed_int_from_bitsize($$C_LONG_LONG_SIZE));
-def CULongLong = $typefrom(unsigned_int_from_bitsize($$C_LONG_LONG_SIZE));
-def CSChar = ichar;
-def CUChar = char;
+$switch ($$C_INT_SIZE)
+$case 64:
+    typedef CInt = long;
+    typedef CUInt = ulong;
+$case 32:
+    typedef CInt = int;
+    typedef CUInt = uint;
+$case 16:
+    typedef CInt = short;
+    typedef CUInt = ushort;
+$default:
+    $assert(false, "Invalid C int size");
+$endswitch
 
-def CChar = $typefrom($$C_CHAR_IS_SIGNED ? ichar.typeid : char.typeid);
+$switch ($$C_LONG_SIZE)
+$case 64:
+    typedef CLong = long;
+    typedef CULong = ulong;
+$case 32:
+    typedef CLong = int;
+    typedef CULong = uint;
+$case 16:
+    typedef CLong = short;
+    typedef CULong = ushort;
+$default:
+    $assert(false, "Invalid C long size");
+$endswitch
 
-// Helper macros
-macro typeid signed_int_from_bitsize(usz $bitsize) @private
-{
-	$switch ($bitsize)
-		$case 128: return int128.typeid;
-		$case 64: return long.typeid;
-		$case 32: return int.typeid;
-		$case 16: return short.typeid;
-		$case 8: return ichar.typeid;
-		$default: $error("Invalid bitsize");
-	$endswitch
-}
+$switch ($$C_SHORT_SIZE)
+$case 32:
+    typedef CShort = int;
+    typedef CUShort = uint;
+$case 16:
+    typedef CShort = short;
+    typedef CUShort = ushort;
+$case 8:
+    typedef CShort = ichar;
+    typedef CUShort = char;
+$default:
+    $assert(false, "Invalid C short size");
+$endswitch
 
-macro typeid unsigned_int_from_bitsize(usz $bitsize) @private
-{
-	$switch ($bitsize)
-		$case 128: return uint128.typeid;
-		$case 64: return ulong.typeid;
-		$case 32: return uint.typeid;
-		$case 16: return ushort.typeid;
-		$case 8: return char.typeid;
-		$default: $error("Invalid bitsize");
-	$endswitch
-}
+$switch ($$C_LONG_LONG_SIZE)
+$case 128:
+    typedef CLongLong = int128;
+    typedef CULongLong = uint128;
+$case 64:
+    typedef CLongLong = long;
+    typedef CULongLong = ulong;
+$case 32:
+    typedef CLongLong = int;
+    typedef CULongLong = uint;
+$case 16:
+    typedef CLongLong = short;
+    typedef CULongLong = ushort;
+$default:
+    $assert(false, "Invalid C long long size");
+$endswitch
+
+
+
+typedef CSChar = ichar;
+typedef CUChar = char;
+
+$if ($$C_CHAR_IS_SIGNED)
+    typedef CChar = ichar;
+$else
+    typedef CChar = char;
+$endif

lib/std/core/conv.c3

@@ -12,36 +12,37 @@ const uint UTF16_SURROGATE_HIGH_VALUE @private = 0xD800;
 /**
  * @param c `The utf32 codepoint to convert`
  * @param [out] output `the resulting buffer`
+ * @param available `the size available`
  **/
-fn usz! char32_to_utf8(Char32 c, char[] output)
+fn usz! char32_to_utf8(Char32 c, char* output, usz available)
 {
-	if (!output.len) return UnicodeResult.CONVERSION_FAILED?;
+	if (!available) return UnicodeResult.CONVERSION_FAILED!;
 	switch (true)
 	{
 		case c <= 0x7f:
 			output[0] = (char)c;
 			return 1;
 		case c <= 0x7ff:
-			if (output.len < 2) return UnicodeResult.CONVERSION_FAILED?;
+	        if (available < 2) return UnicodeResult.CONVERSION_FAILED!;
 			output[0] = (char)(0xC0 | c >> 6);
-			output[1] = (char)(0x80 | (c & 0x3F));
-			return 2;
-		case c <= 0xffff:
-			if (output.len < 3) return UnicodeResult.CONVERSION_FAILED?;
-			output[0] = (char)(0xE0 | c >> 12);
-			output[1] = (char)(0x80 | (c >> 6 & 0x3F));
-			output[2] = (char)(0x80 | (c & 0x3F));
-			return 3;
-		case c <= 0x10ffff:
-			if (output.len < 4) return UnicodeResult.CONVERSION_FAILED?;
-			output[0] = (char)(0xF0 | c >> 18);
-			output[1] = (char)(0x80 | (c >> 12 & 0x3F));
-			output[2] = (char)(0x80 | (c >> 6 & 0x3F));
-			output[3] = (char)(0x80 | (c & 0x3F));
-			return 4;
-		default:
-			// 0x10FFFF and above is not defined.
-			return UnicodeResult.CONVERSION_FAILED?;
+            output[1] = (char)(0x80 | (c & 0x3F));
+            return 2;
+        case c <= 0xffff:
+	        if (available < 3) return UnicodeResult.CONVERSION_FAILED!;
+            output[0] = (char)(0xE0 | c >> 12);
+            output[1] = (char)(0x80 | (c >> 6 & 0x3F));
+            output[2] = (char)(0x80 | (c & 0x3F));
+            return 3;
+        case c <= 0x10ffff:
+	        if (available < 4) return UnicodeResult.CONVERSION_FAILED!;
+		    output[0] = (char)(0xF0 | c >> 18);
+            output[1] = (char)(0x80 | (c >> 12 & 0x3F));
+            output[2] = (char)(0x80 | (c >> 6 & 0x3F));
+            output[3] = (char)(0x80 | (c & 0x3F));
+            return 4;
+        default:
+            // 0x10FFFF and above is not defined.
+            return UnicodeResult.CONVERSION_FAILED!;
 	}
 }
 
@@ -82,21 +83,21 @@ fn void! char16_to_utf8_unsafe(Char16 *ptr, usz *available, char** output)
 		*available = 1;
 		return;
 	}
-	// Low surrogate first is an error
-	if (high & UTF16_SURROGATE_MASK != UTF16_SURROGATE_HIGH_VALUE) return UnicodeResult.INVALID_UTF16?;
+    // Low surrogate first is an error
+	if (high & UTF16_SURROGATE_MASK != UTF16_SURROGATE_HIGH_VALUE) return UnicodeResult.INVALID_UTF16!;
 
 	// Unmatched high surrogate is an error
-	if (*available == 1) return UnicodeResult.INVALID_UTF16?;
+	if (*available == 1) return UnicodeResult.INVALID_UTF16!;
 
 	Char16 low = ptr[1];
 
 	// Unmatched high surrogate, invalid
-	if (low & UTF16_SURROGATE_MASK != UTF16_SURROGATE_LOW_VALUE) return UnicodeResult.INVALID_UTF16?;
+	if (low & UTF16_SURROGATE_MASK != UTF16_SURROGATE_LOW_VALUE) return UnicodeResult.INVALID_UTF16!;
 
-	// The high bits of the codepoint are the value bits of the high surrogate
-	// The low bits of the codepoint are the value bits of the low surrogate
-	Char32 uc = (high & UTF16_SURROGATE_CODEPOINT_MASK) << UTF16_SURROGATE_BITS
-				| (low & UTF16_SURROGATE_CODEPOINT_MASK) + UTF16_SURROGATE_OFFSET;
+    // The high bits of the codepoint are the value bits of the high surrogate
+    // The low bits of the codepoint are the value bits of the low surrogate
+    Char32 uc = (high & UTF16_SURROGATE_CODEPOINT_MASK) << UTF16_SURROGATE_BITS
+                | (low & UTF16_SURROGATE_CODEPOINT_MASK) + UTF16_SURROGATE_OFFSET;
 	char32_to_utf8_unsafe(uc, output);
 	*available = 2;
 }
@@ -104,28 +105,24 @@ fn void! char16_to_utf8_unsafe(Char16 *ptr, usz *available, char** output)
  * @param c `The utf32 codepoint to convert`
  * @param [inout] output `the resulting buffer`
  **/
-fn usz char32_to_utf8_unsafe(Char32 c, char** output)
+fn void char32_to_utf8_unsafe(Char32 c, char** output)
 {
-	switch
+	switch (true)
 	{
 		case c < 0x7f:
 			(*output)++[0] = (char)c;
-			return 1;
 		case c < 0x7ff:
 			(*output)++[0] = (char)(0xC0 | c >> 6);
-			(*output)++[0] = (char)(0x80 | (c & 0x3F));
-			return 2;
-		case c < 0xffff:
-			(*output)++[0] = (char)(0xE0 | c >> 12);
-			(*output)++[0] = (char)(0x80 | (c >> 6 & 0x3F));
-			(*output)++[0] = (char)(0x80 | (c & 0x3F));
-			return 3;
-		default:
-			(*output)++[0] = (char)(0xF0 | c >> 18);
-			(*output)++[0] = (char)(0x80 | (c >> 12 & 0x3F));
-			(*output)++[0] = (char)(0x80 | (c >> 6 & 0x3F));
-			(*output)++[0] = (char)(0x80 | (c & 0x3F));
-			return 4;
+            (*output)++[0] = (char)(0x80 | (c & 0x3F));
+        case c < 0xffff:
+	        (*output)++[0] = (char)(0xE0 | c >> 12);
+            (*output)++[0] = (char)(0x80 | (c >> 6 & 0x3F));
+            (*output)++[0] = (char)(0x80 | (c & 0x3F));
+        default:
+	 	    (*output)++[0] = (char)(0xF0 | c >> 18);
+            (*output)++[0] = (char)(0x80 | (c >> 12 & 0x3F));
+            (*output)++[0] = (char)(0x80 | (c >> 6 & 0x3F));
+            (*output)++[0] = (char)(0x80 | (c & 0x3F));
 	}
 }
 
@@ -137,50 +134,50 @@ fn usz char32_to_utf8_unsafe(Char32 c, char** output)
 fn Char32! utf8_to_char32(char* ptr, usz* size)
 {
 	usz max_size = *size;
-	if (max_size < 1) return UnicodeResult.INVALID_UTF8?;
+	if (max_size < 1) return UnicodeResult.INVALID_UTF8!;
 	char c = (ptr++)[0];
 
-	if ((c & 0x80) == 0)
-	{
-		*size = 1;
-		return c;
-	}
-	if ((c & 0xE0) == 0xC0)
-	{
-		if (max_size < 2) return UnicodeResult.INVALID_UTF8?;
-		*size = 2;
-		Char32 uc = (c & 0x1F) << 6;
-		c = *ptr;
-		// Overlong sequence or invalid second.
-		if (!uc || c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
+    if ((c & 0x80) == 0)
+    {
+        *size = 1;
+        return c;
+    }
+    if ((c & 0xE0) == 0xC0)
+    {
+		if (max_size < 2) return UnicodeResult.INVALID_UTF8!;
+        *size = 2;
+        Char32 uc = (c & 0x1F) << 6;
+        c = *ptr;
+        // Overlong sequence or invalid second.
+		if (!uc || c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
 		return uc + c & 0x3F;
-	}
-	if ((c & 0xF0) == 0xE0)
-	{
-		if (max_size < 3) return UnicodeResult.INVALID_UTF8?;
-		*size = 3;
-		Char32 uc = (c & 0x0F) << 12;
+    }
+    if ((c & 0xF0) == 0xE0)
+    {
+		if (max_size < 3) return UnicodeResult.INVALID_UTF8!;
+        *size = 3;
+        Char32 uc = (c & 0x0F) << 12;
 		c = ptr++[0];
-		if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
+		if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
 		uc += (c & 0x3F) << 6;
 		c = ptr++[0];
 		// Overlong sequence or invalid last
-		if (!uc || c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
+		if (!uc || c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
 		return uc + c & 0x3F;
-	}
-	if (max_size < 4) return UnicodeResult.INVALID_UTF8?;
-	if ((c & 0xF8) != 0xF0) return UnicodeResult.INVALID_UTF8?;
-	*size = 4;
-	Char32 uc = (c & 0x07) << 18;
+    }
+    if (max_size < 4) return UnicodeResult.INVALID_UTF8!;
+    if ((c & 0xF8) != 0xF0) return UnicodeResult.INVALID_UTF8!;
+    *size = 4;
+    Char32 uc = (c & 0x07) << 18;
 	c = ptr++[0];
-	if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
+	if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
 	uc += (c & 0x3F) << 12;
 	c = ptr++[0];
-	if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
+	if (c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
 	uc += (c & 0x3F) << 6;
 	c = ptr++[0];
 	// Overlong sequence or invalid last
-	if (!uc || c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8?;
+	if (!uc || c & 0xC0 != 0x80) return UnicodeResult.INVALID_UTF8!;
 	return uc + c & 0x3F;
 }
 
@@ -275,8 +272,8 @@ fn usz utf16len_for_utf8(String utf8)
 		if (c & 0xF0 == 0xE0) continue;
 		i++;
 		len16++;
-	}
-	return len16;
+    }
+    return len16;
 }
 
 /**
@@ -300,17 +297,19 @@ fn usz utf16len_for_utf32(Char32[] utf32)
  * @param [out] utf8_buffer
  * @return `the number of bytes written.`
  **/
-fn usz! utf32to8(Char32[] utf32, char[] utf8_buffer)
+fn usz! utf32to8(Char32[] utf32, String utf8_buffer)
 {
-	char[] buffer = utf8_buffer;
-	foreach (uc : utf32)
+	usz len = utf8_buffer.len;
+	char* ptr = utf8_buffer.ptr;
+	foreach (Char32 uc : utf32)
 	{
-		usz used = char32_to_utf8(uc, buffer) @inline!;
-		buffer = buffer[used..];
+		usz used = char32_to_utf8(uc, ptr, len) @inline?;
+		len -= used;
+		ptr += used;
 	}
 	// Zero terminate if there is space.
-	if (buffer.len > 0) buffer[0] = 0;
-	return utf8_buffer.len - buffer.len;
+    if (len > 0) ptr[0] = 0;
+	return utf8_buffer.len - len;
 }
 
 /**
@@ -324,19 +323,19 @@ fn usz! utf8to32(String utf8, Char32[] utf32_buffer)
 {
 	usz len = utf8.len;
 	Char32* ptr = utf32_buffer.ptr;
-	usz len32 = 0;
-	usz buf_len = utf32_buffer.len;
-	for (usz i = 0; i < len;)
-	{
-		if (len32 == buf_len) return UnicodeResult.CONVERSION_FAILED?;
-		usz width = len - i;
-		Char32 uc = utf8_to_char32(&utf8[i], &width) @inline!;
-		i += width;
-		ptr[len32++] = uc;
-	}
-	// Zero terminate if possible
-	if (len32 + 1 < buf_len) ptr[len32] = 0;
-	return len32;
+    usz len32 = 0;
+    usz buf_len = utf32_buffer.len;
+    for (usz i = 0; i < len;)
+    {
+        if (len32 == buf_len) return UnicodeResult.CONVERSION_FAILED!;
+        usz width = len - i;
+    	Char32 uc = utf8_to_char32(&utf8[i], &width) @inline?;
+    	i += width;
+    	ptr[len32++] = uc;
+    }
+    // Zero terminate if possible
+    if (len32 + 1 < buf_len) ptr[len32] = 0;
+    return len32;
 }
 
 /**
@@ -353,7 +352,7 @@ fn void! utf16to8_unsafe(Char16[] utf16, char* utf8_buffer)
 	for (usz i = 0; i < len16;)
 	{
 		usz available = len16 - i;
-		char16_to_utf8_unsafe(&utf16[i], &available, &utf8_buffer) @inline!;
+		char16_to_utf8_unsafe(&utf16[i], &available, &utf8_buffer) @inline?;
 		i += available;
 	}
 }
@@ -370,12 +369,12 @@ fn void! utf8to32_unsafe(String utf8, Char32* utf32_buffer)
 {
 	usz len = utf8.len;
 	for (usz i = 0; i < len;)
-	{
-		usz width = len - i;
-		Char32 uc = utf8_to_char32(&utf8[i], &width) @inline!;
-		i += width;
-		(utf32_buffer++)[0] = uc;
-	}
+    {
+        usz width = len - i;
+    	Char32 uc = utf8_to_char32(&utf8[i], &width) @inline?;
+    	i += width;
+    	(utf32_buffer++)[0] = uc;
+    }
 }
 
 /**
@@ -389,13 +388,13 @@ fn void! utf8to32_unsafe(String utf8, Char32* utf32_buffer)
 fn void! utf8to16_unsafe(String utf8, Char16* utf16_buffer)
 {
 	usz len = utf8.len;
-	for (usz i = 0; i < len;)
-	{
-		usz width = len - i;
-		Char32 uc = utf8_to_char32(&utf8[i], &width) @inline!;
-		char32_to_utf16_unsafe(uc, &utf16_buffer) @inline;
-		i += width;
-	}
+    for (usz i = 0; i < len;)
+    {
+        usz width = len - i;
+    	Char32 uc = utf8_to_char32(&utf8[i], &width) @inline?;
+        char32_to_utf16_unsafe(uc, &utf16_buffer) @inline;
+        i += width;
+    }
 }
 
 /**

lib/std/core/dstring.c3

@@ -1,59 +1,40 @@
 module std::core::dstring;
-import std::io;
 
-distinct DString (OutStream) = void*;
+typedef DString = distinct void*;
 
 const usz MIN_CAPACITY @private = 16;
 
 /**
- * @require !self.data() "String already initialized"
+ * @require !str.data() "String already initialized"
  **/
-fn DString DString.new_init(&self, usz capacity = MIN_CAPACITY, Allocator* allocator = allocator::heap())
+fn void DString.init(DString *str, usz capacity = MIN_CAPACITY, Allocator* using = mem::heap())
 {
 	if (capacity < MIN_CAPACITY) capacity = MIN_CAPACITY;
-	StringData* data = allocator::alloc_with_padding(allocator, StringData, capacity)!!;
-	data.allocator = allocator;
+	StringData* data = malloc(StringData, 1, .using = using, .end_padding = capacity);
+	data.allocator = using;
 	data.len = 0;
 	data.capacity = capacity;
-	return *self = (DString)data;
+	*str = (DString)data;
 }
 
 /**
- * @require !self.data() "String already initialized"
+ * @require !str.data() "String already initialized"
  **/
-fn DString DString.init_new(&self, usz capacity = MIN_CAPACITY, Allocator* allocator = allocator::heap()) @deprecated("Replaced by new_init")
+fn void DString.tinit(DString *str, usz capacity = MIN_CAPACITY) => str.init(capacity, mem::temp()) @inline;
+
+fn DString new_with_capacity(usz capacity, Allocator* using = mem::heap())
 {
-	return self.new_init(capacity, allocator) @inline;
+	DString dstr;
+	dstr.init(capacity, using);
+	return dstr;
 }
 
-/**
- * @require !self.data() "String already initialized"
- **/
-fn DString DString.temp_init(&self, usz capacity = MIN_CAPACITY)
-{
-	self.new_init(capacity, allocator::temp()) @inline;
-	return *self;
-}
+fn DString tnew_with_capacity(usz capacity) => new_with_capacity(capacity, mem::temp()) @inline;
 
-/**
- * @require !self.data() "String already initialized"
- **/
-fn DString DString.init_temp(&self, usz capacity = MIN_CAPACITY) @deprecated("Replaced by temp_init")
-{
-	return self.temp_init(capacity) @inline;
-}
-
-fn DString new_with_capacity(usz capacity, Allocator* allocator = allocator::heap())
-{
-	return DString{}.new_init(capacity, allocator);
-}
-
-fn DString temp_with_capacity(usz capacity) => new_with_capacity(capacity, allocator::temp()) @inline;
-
-fn DString new(String c = "", Allocator* allocator = allocator::heap())
+fn DString new(String c = "", Allocator* using = mem::heap())
 {
 	usz len = c.len;
-	StringData* data = (StringData*)new_with_capacity(len, allocator);
+	StringData* data = (StringData*)new_with_capacity(len, using);
 	if (len)
 	{
 		data.len = len;
@@ -62,29 +43,26 @@ fn DString new(String c = "", Allocator* allocator = allocator::heap())
 	return (DString)data;
 }
 
-fn DString temp_new(String s = "") => new(s, allocator::temp()) @inline;
+fn DString tnew(String s = "") => new(s, mem::temp()) @inline;
 
-fn DString DString.new_concat(self, DString b, Allocator* allocator = allocator::heap())
+fn DString DString.new_concat(DString a, DString b, Allocator* using = mem::heap())
 {
 	DString string;
-	string.new_init(self.len() + b.len(), allocator);
-	string.append(self);
+	string.init(a.len() + b.len(), using);
+	string.append(a);
 	string.append(b);
 	return string;
 }
 
-fn DString DString.temp_concat(self, DString b) => self.new_concat(b, allocator::temp());
+fn DString DString.new_tconcat(DString a, DString b) => a.new_concat(b, mem::temp());
 
-fn DString DString.new_tconcat(self, DString b) @deprecated("Replaced by temp_concat") => self.new_concat(b, allocator::temp());
-
-fn ZString DString.zstr_view(&self)
+fn ZString DString.zstr(DString str)
 {
-	StringData* data = self.data();
+	StringData* data = str.data();
 	if (!data) return "";
 	if (data.capacity == data.len)
 	{
-		self.reserve(1);
-		data = self.data();
+		str.reserve(1);
 		data.chars[data.len] = 0;
 	}
 	else if (data.chars[data.len] != 0)
@@ -94,116 +72,139 @@ fn ZString DString.zstr_view(&self)
 	return (ZString)&data.chars[0];
 }
 
-fn usz DString.capacity(self)
+fn usz DString.capacity(DString this)
 {
-	if (!self) return 0;
-	return self.data().capacity;
+	if (!this) return 0;
+	return this.data().capacity;
 }
 
-fn usz DString.len(&self) @dynamic
+fn usz DString.len(DString this)
 {
-	if (!*self) return 0;
-	return self.data().len;
+	if (!this) return 0;
+	return this.data().len;
 }
 
 /**
- * @require new_size <= self.len()
+ * @require new_size <= this.len()
  */
-fn void DString.chop(self, usz new_size)
+fn void DString.chop(DString this, usz new_size)
 {
-	if (!self) return;
-	self.data().len = new_size;
+	if (!this) return;
+	this.data().len = new_size;
 }
 
-fn String DString.str_view(self)
+fn String DString.str(DString str)
 {
-	StringData* data = self.data();
+	StringData* data = (StringData*)str;
 	if (!data) return "";
 	return (String)data.chars[:data.len];
 }
 
-fn void DString.append_utf32(&self, Char32[] chars)
+fn void DString.append_utf32(DString* str, Char32[] chars)
 {
-	self.reserve(chars.len);
+	str.reserve(chars.len);
 	foreach (Char32 c : chars)
 	{
-		self.append_char32(c);
+		str.append_char32(c);
 	}
 }
 
 /**
- * @require index < self.len()
+ * @require index < str.len()
  **/
-fn void DString.set(self, usz index, char c)
+fn void DString.set(DString str, usz index, char c)
 {
-	self.data().chars[index] = c;
+	str.data().chars[index] = c;
 }
 
-fn void DString.append_repeat(&self, char c, usz times)
+fn void DString.append_repeat(DString* str, char c, usz times)
 {
 	if (times == 0) return;
-	self.reserve(times);
-	StringData* data = self.data();
+	str.reserve(times);
+	StringData* data = str.data();
 	for (usz i = 0; i < times; i++)
 	{
-		data.chars[data.len++] = c;
+        data.chars[data.len++] = c;
 	}
 }
 
 /**
  * @require c <= 0x10ffff
  */
-fn void DString.append_char32(&self, Char32 c)
+fn void DString.append_char32(DString* str, 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();
-	data.chars[data.len:n] = buffer[:n];
-	data.len += n;
+	if (c < 0x7f)
+	{
+		str.reserve(1);
+		StringData* data = str.data();
+        data.chars[data.len++] = (char)c;
+        return;
+    }
+    if (c < 0x7ff)
+    {
+		str.reserve(2);
+		StringData* data = str.data();
+		data.chars[data.len++] = (char)(0xC0 | c >> 6);
+        data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
+        return;
+    }
+    if (c < 0xffff)
+    {
+		str.reserve(3);
+		StringData* data = str.data();
+		data.chars[data.len++] = (char)(0xE0 | c >> 12);
+        data.chars[data.len++] = (char)(0x80 | (c >> 6 & 0x3F));
+        data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
+        return;
+    }
+	str.reserve(4);
+	StringData* data = str.data();
+	data.chars[data.len++] = (char)(0xF0 | c >> 18);
+    data.chars[data.len++] = (char)(0x80 | (c >> 12 & 0x3F));
+    data.chars[data.len++] = (char)(0x80 | (c >> 6 & 0x3F));
+    data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
 }
 
-fn DString DString.tcopy(&self) => self.copy(allocator::temp());
+fn DString DString.tcopy(DString* str) => str.copy(mem::temp());
 
-fn DString DString.copy(self, Allocator* allocator = null)
+fn DString DString.copy(DString* str, Allocator* using = null)
 {
-	if (!self)
+	if (!str)
 	{
-		if (allocator) return new_with_capacity(0, allocator);
+		if (using) return new_with_capacity(0, using);
 		return (DString)null;
 	}
-	StringData* data = self.data();
-	if (!allocator) allocator = allocator::heap();
-	DString new_string = new_with_capacity(data.capacity, allocator);
+	if (!using) using = mem::heap();
+	StringData* data = str.data();
+	DString new_string = new_with_capacity(data.capacity, using);
 	mem::copy((char*)new_string.data(), (char*)data, StringData.sizeof + data.len);
 	return new_string;
 }
 
-fn ZString DString.copy_zstr(self, Allocator* allocator = allocator::heap())
+fn ZString DString.copy_zstr(DString* str, Allocator* using = mem::heap())
 {
-	usz str_len = self.len();
+	usz str_len = str.len();
 	if (!str_len)
 	{
-		return (ZString)allocator::calloc(allocator, 1);
+		return (ZString)calloc(1, .using = using);
 	}
-	char* zstr = allocator::malloc(allocator, str_len + 1);
-	StringData* data = self.data();
+	char* zstr = malloc(str_len + 1, .using = using);
+	StringData* data = str.data();
 	mem::copy(zstr, &data.chars, str_len);
 	zstr[str_len] = 0;
 	return (ZString)zstr;
 }
 
-fn String DString.copy_str(self, Allocator* allocator = allocator::heap())
+fn String DString.copy_str(DString* str, Allocator* using = mem::heap())
 {
-	return (String)self.copy_zstr(allocator)[:self.len()];
+	return (String)str.copy_zstr(using)[:str.len()];
 }
 
-fn String DString.tcopy_str(self) => self.copy_str(allocator::temp()) @inline;
+fn String DString.tcopy_str(DString* str) => str.copy_str(mem::temp()) @inline;
 
-fn bool DString.equals(self, DString other_string)
+fn bool DString.equals(DString str, DString other_string)
 {
-	StringData *str1 = self.data();
+	StringData *str1 = str.data();
 	StringData *str2 = other_string.data();
 	if (str1 == str2) return true;
 	if (!str1) return str2.len == 0;
@@ -217,18 +218,18 @@ fn bool DString.equals(self, DString other_string)
 	return true;
 }
 
-fn void DString.free(&self)
+fn void DString.free(DString* str)
 {
-	if (!*self) return;
-	StringData* data = self.data();
+	if (!*str) return;
+	StringData* data = str.data();
 	if (!data) return;
-	allocator::free(data.allocator, data);
-	*self = (DString)null;
+	free(data, .using = data.allocator);
+	*str = (DString)null;
 }
 
-fn bool DString.less(self, DString other_string)
+fn bool DString.less(DString str, DString other_string)
 {
-	StringData* str1 = self.data();
+	StringData* str1 = str.data();
 	StringData* str2 = other_string.data();
 	if (str1 == str2) return false;
 	if (!str1) return str2.len != 0;
@@ -243,167 +244,93 @@ fn bool DString.less(self, DString other_string)
 	return true;
 }
 
-fn void DString.append_chars(&self, String str)
+fn void DString.append_chars(DString* this, String str)
 {
 	usz other_len = str.len;
 	if (!other_len) return;
-	if (!*self)
+	if (!*this)
 	{
-		*self = new(str);
+		*this = new(str);
 		return;
 	}
-	self.reserve(other_len);
-	StringData* data = self.data();
+	this.reserve(other_len);
+	StringData* data = (StringData*)*this;
 	mem::copy(&data.chars[data.len], str.ptr, other_len);
 	data.len += other_len;
 }
 
-fn Char32[] DString.copy_utf32(&self, Allocator* allocator = allocator::heap())
+fn Char32[] DString.copy_utf32(DString* this, Allocator* using = mem::heap())
 {
-	return self.str_view().to_new_utf32(allocator) @inline!!;
+	return str::utf8to32(this.str(), using) @inline!!;
 }
 
-fn void DString.append_string(&self, DString str)
+fn void DString.append_string(DString* this, DString str)
 {
-	StringData* other = str.data();
+	StringData* other = (StringData*)str;
 	if (!other) return;
-	self.append(str.str_view());
+	this.append(str.str());
 }
 
-fn void DString.clear(self)
+fn void DString.clear(DString* str)
 {
-	if (!self) return;
-	self.data().len = 0;
+	str.data().len = 0;
 }
 
-fn usz! DString.write(&self, char[] buffer) @dynamic
+fn void DString.append_char(DString* str, char c)
 {
-	self.append_chars((String)buffer);
-	return buffer.len;
-}
-
-fn void! DString.write_byte(&self, char c) @dynamic
-{
-	self.append_char(c);
-}
-
-fn void DString.append_char(&self, char c)
-{
-	if (!*self)
+	if (!*str)
 	{
-		*self = new_with_capacity(MIN_CAPACITY);
+		*str = new_with_capacity(MIN_CAPACITY);
 	}
-	self.reserve(1);
-	StringData* data = self.data();
+	str.reserve(1);
+	StringData* data = (StringData*)*str;
 	data.chars[data.len++] = c;
 }
 
-/**
- * @require start < self.len()
- * @require end < self.len()
- * @require end >= start "End must be same or equal to the start"
- **/
-fn void DString.delete_range(&self, usz start, usz end)
-{
-	self.delete(start, end - start + 1);
-}
 
-/**
- * @require start < self.len()
- * @require start + len <= self.len()
- **/
-fn void DString.delete(&self, usz start, usz len = 1)
-{
-	if (!len) return;
-	StringData* data = self.data();
-	usz new_len = data.len - len;
-	if (new_len == 0)
-	{
-		data.len = 0;
-		return;
-	}
-	usz len_after = data.len - start - len;
-	if (len_after > 0)
-	{
-		data.chars[start:len_after] = data.chars[start + len:len_after];
-	}
-	data.len = new_len;
-}
-
-macro void DString.append(&self, value)
+macro void DString.append(DString* str, value)
 {
 	var $Type = $typeof(value);
 	$switch ($Type)
 		$case char:
 		$case ichar:
-			self.append_char(value);
+			str.append_char(value);
 		$case DString:
-			self.append_string(value);
+			str.append_string(value);
 		$case String:
-			self.append_chars(value);
+			str.append_chars(value);
 		$case Char32:
-			self.append_char32(value);
+			str.append_char32(value);
 		$default:
 			$switch
-				$case $defined((Char32)value):
-					self.append_char32((Char32)value);
-				$case $defined((String)value):
-					self.append_chars((String)value);
+				$case @convertible(value, Char32):
+					str.append_char32(value);
+				$case @convertible(value, String):
+					str.append_chars(value);
 				$default:
-					$error "Unsupported type for append – use appendf instead.";
+					$assert(false, "Unsupported type for append – use printf instead.");
 			$endswitch
 	$endswitch
 }
 
-fn void DString.insert_at(&self, usz index, String s)
-{
-	if (s.len == 0) return;
-	self.reserve(s.len);
-	StringData* data = self.data();
-	usz len = self.len();
-	if (data.chars[:len].ptr == s.ptr)
-	{
-		// Source and destination are the same: nothing to do.
-		return;
-	}
-	index = min(index, len);
-	data.len += s.len;
 
-	char* start = data.chars[index:s.len].ptr; // area to insert into
-	mem::move(start + s.len, start, len - index); // move existing data
-	switch
-	{
-		case s.ptr <= start && start < s.ptr + s.len:
-			// Overlapping areas.
-			foreach_r (i, c : s)
-			{
-				data.chars[index + i] = c;
-			}
-		case start <= s.ptr && s.ptr < start + len:
-			// Source has moved.
-			mem::move(start, s.ptr + s.len, s.len);
-		default:
-			mem::move(start, s, s.len);
-	}
-}
-
-fn usz! DString.appendf(&self, String format, args...) @maydiscard
+fn usz! DString.printf(DString* str, String format, args...) @maydiscard
 {
 	Formatter formatter;
-	formatter.init(&out_string_append_fn, self);
+	formatter.init(&out_string_append_fn, str);
 	return formatter.vprintf(format, args);
 }
 
-fn usz! DString.appendfn(&self, String format, args...) @maydiscard
+fn usz! DString.printfn(DString* str, String format, args...) @maydiscard
 {
 	Formatter formatter;
-	formatter.init(&out_string_append_fn, self);
-	usz len = formatter.vprintf(format, args)!;
-	self.append('\n');
+	formatter.init(&out_string_append_fn, str);
+	usz len = formatter.vprintf(format, args)?;
+	str.append('\n');
 	return len + 1;
 }
 
-fn DString new_join(String[] s, String joiner, Allocator* allocator = allocator::heap())
+fn DString new_join(String[] s, String joiner, Allocator* using = mem::heap())
 {
 	if (!s.len) return (DString)null;
 	usz total_size = joiner.len * s.len;
@@ -411,7 +338,7 @@ fn DString new_join(String[] s, String joiner, Allocator* allocator = allocator:
 	{
 		total_size += str.len;
 	}
-	DString res = new_with_capacity(total_size, allocator);
+	DString res = new_with_capacity(total_size, using);
 	res.append(s[0]);
 	foreach (String* &str : s[1..])
 	{
@@ -421,45 +348,43 @@ fn DString new_join(String[] s, String joiner, Allocator* allocator = allocator:
 	return res;
 }
 
-fn void! out_string_append_fn(void* data, char c) @private
+fn void! out_string_append_fn(char c, void* data) @private
 {
-	DString* s = data;
+	DynString* s = data;
 	s.append_char(c);
 }
 
 
-fn StringData* DString.data(self) @inline @private
+fn StringData* DString.data(DString str) @inline @private
 {
-	return (StringData*)self;
+	return (StringData*)str;
 }
 
-fn void DString.reserve(&self, usz addition)
+fn void DString.reserve(DString* str, usz addition)
 {
-	StringData* data = self.data();
+	StringData* data = str.data();
 	if (!data)
 	{
-		*self = dstring::new_with_capacity(addition);
+		*str = dstring::new_with_capacity(addition);
 		return;
 	}
 	usz len = data.len + addition;
 	if (data.capacity >= len) return;
-	usz new_capacity = data.capacity * 2;
+	usz new_capacity = data.capacity *= 2;
 	if (new_capacity < MIN_CAPACITY) new_capacity = MIN_CAPACITY;
-	while (new_capacity < len) new_capacity *= 2;
-	data.capacity = new_capacity;
-	*self = (DString)allocator::realloc(data.allocator, data, StringData.sizeof + new_capacity);
+	*str = (DString)realloc(data, StringData.sizeof + new_capacity, .using = data.allocator);
 }
 
-fn usz! DString.read_from_stream(&self, InStream* reader)
+fn usz! DString.read_from_stream(DString* string, Stream* reader)
 {
-	if (&reader.available)
+	if (reader.supports_available())
 	{
 		usz total_read = 0;
-		while (usz available = reader.available()!)
+		while (usz available = reader.available()?)
 		{
-			self.reserve(available);
-			StringData* data = self.data();
-			usz len = reader.read(data.chars[data.len..(data.capacity - 1)])!;
+			string.reserve(available);
+			StringData* data = string.data();
+			usz len = reader.read(data.chars[data.len..(data.capacity - 1)])?;
 			total_read += len;
 			data.len += len;
 		}
@@ -469,10 +394,10 @@ fn usz! DString.read_from_stream(&self, InStream* reader)
 	while (true)
 	{
 		// Reserve at least 16 bytes
-		self.reserve(16);
-		StringData* data = self.data();
+		string.reserve(16);
+		StringData* data = string.data();
 		// Read into the rest of the buffer
-		usz read = reader.read(data.chars[data.len..(data.capacity - 1)])!;
+		usz read = reader.read(data.chars[data.len..(data.capacity - 1)])?;
 		data.len += read;
 		// Ok, we reached the end.
 		if (read < 16) return total_read;

lib/std/core/env.c3

@@ -1,14 +1,14 @@
-// Copyright (c) 2021-2024 Christoffer Lerno. All rights reserved.
+// Copyright (c) 2021 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::core::env;
-
+import libc;
 enum CompilerOptLevel
 {
-	O0,
-	O1,
-	O2,
-	O3
+    O0,
+    O1,
+    O2,
+    O3
 }
 
 enum MemoryEnvironment
@@ -32,7 +32,7 @@ enum OsType
 	KFREEBSD,
 	LINUX,
 	PS3,
-	MACOS,
+	MACOSX,
 	NETBSD,
 	OPENBSD,
 	SOLARIS,
@@ -116,39 +116,28 @@ enum ArchType
 
 const OsType OS_TYPE = (OsType)$$OS_TYPE;
 const ArchType ARCH_TYPE = (ArchType)$$ARCH_TYPE;
-const bool LIBC = $$COMPILER_LIBC_AVAILABLE;
-const bool NO_LIBC = !$$COMPILER_LIBC_AVAILABLE;
+const bool COMPILER_LIBC_AVAILABLE = $$COMPILER_LIBC_AVAILABLE;
 const CompilerOptLevel COMPILER_OPT_LEVEL = (CompilerOptLevel)$$COMPILER_OPT_LEVEL;
 const bool BIG_ENDIAN = $$PLATFORM_BIG_ENDIAN;
 const bool I128_NATIVE_SUPPORT = $$PLATFORM_I128_SUPPORTED;
 const bool F16_SUPPORT = $$PLATFORM_F16_SUPPORTED;
 const bool F128_SUPPORT = $$PLATFORM_F128_SUPPORTED;
 const bool COMPILER_SAFE_MODE = $$COMPILER_SAFE_MODE;
-const bool DEBUG_SYMBOLS = $$DEBUG_SYMBOLS;
 const usz LLVM_VERSION = $$LLVM_VERSION;
 const bool BENCHMARKING = $$BENCHMARKING;
 const bool TESTING = $$TESTING;
 const MemoryEnvironment MEMORY_ENV = (MemoryEnvironment)$$MEMORY_ENVIRONMENT;
-const bool TRACK_MEMORY = DEBUG_SYMBOLS && (COMPILER_SAFE_MODE || TESTING);
-const bool X86_64 = ARCH_TYPE == X86_64;
-const bool X86 = ARCH_TYPE == X86;
-const bool AARCH64 = ARCH_TYPE == AARCH64;
-const bool NATIVE_STACKTRACE = LINUX || DARWIN || WIN32;
-const bool LINUX = LIBC && OS_TYPE == LINUX;
-const bool DARWIN = LIBC && os_is_darwin();
-const bool WIN32 = LIBC && OS_TYPE == WIN32;
-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 WASI = LIBC && OS_TYPE == WASI;
-const bool WASM_NOLIBC @builtin = !LIBC && ARCH_TYPE == ArchType.WASM32 || ARCH_TYPE == ArchType.WASM64;
+
+macro bool os_is_win32()
+{
+	return OS_TYPE == OsType.WIN32;
+}
 
 macro bool os_is_darwin()
 {
 	$switch (OS_TYPE)
 	$case IOS:
-	$case MACOS:
+	$case MACOSX:
 	$case TVOS:
 	$case WATCHOS:
 		return true;
@@ -161,7 +150,7 @@ macro bool os_is_posix()
 {
 	$switch (OS_TYPE)
 	$case IOS:
-	$case MACOS:
+	$case MACOSX:
 	$case NETBSD:
 	$case LINUX:
 	$case KFREEBSD:
@@ -181,5 +170,57 @@ macro bool os_is_posix()
 	$endswitch
 }
 
-const BUILTIN_EXPECT_IS_DISABLED = $feature(DISABLE_BUILTIN_EXPECT);
-const BUILTIN_PREFETCH_IS_DISABLED = $feature(DISABLE_BUILTIN_PREFETCH);
+
+/**
+ * @param [&in] name
+ * @require name.len > 0
+ **/
+fn String! get_var(String name)
+{
+$if (COMPILER_LIBC_AVAILABLE && OS_TYPE != OsType.WIN32)
+	@pool()
+	{
+		ZString val = libc::getenv(name.zstr_tcopy());
+		return val ? val.as_str() : SearchResult.MISSING!;
+	};
+$else
+	return "";
+$endif
+}
+
+
+/**
+ * @param [&in] name
+ * @param [&in] value
+ * @require name.len > 0
+ **/
+fn void set_var(String name, String value, bool overwrite = true)
+{
+$if (COMPILER_LIBC_AVAILABLE && OS_TYPE != OsType.WIN32)
+	@pool()
+	{
+		if (libc::setenv(name.zstr_tcopy(), value.zstr_copy(), (int)overwrite))
+		{
+			unreachable();
+		}
+	};
+$endif
+}
+
+/**
+ * @param [&in] name
+ * @require name.len > 0
+ **/
+fn void clear_var(String name)
+{
+$if (COMPILER_LIBC_AVAILABLE && OS_TYPE != OsType.WIN32)
+	@pool()
+	{
+		if (libc::unsetenv(name.zstr_tcopy()))
+		{
+			unreachable();
+		}
+	};
+$endif
+}
+

lib/std/core/floatparse.c3

@@ -1,4 +1,4 @@
-module std::core::string;
+module std::core::str;
 import std::math;
 
 // Float parsing based on code in Musl floatscan.c by Rich Felker.
@@ -64,7 +64,7 @@ macro double! decfloat(char[] chars, int $bits, int $emin, int sign)
 		got_rad = true;
 		if (index == last_char)
 		{
-			if (!got_digit) return NumberConversion.MALFORMED_FLOAT?;
+			if (!got_digit) return NumberConversion.MALFORMED_FLOAT!;
 			return sign * 0.0;
 		}
 		if (index != last_char && (c = chars[++index]) == '0')
@@ -83,7 +83,7 @@ macro double! decfloat(char[] chars, int $bits, int $emin, int sign)
 		switch
 		{
 			case c == '.':
-				if (got_rad) return NumberConversion.MALFORMED_FLOAT?;
+				if (got_rad) return NumberConversion.MALFORMED_FLOAT!;
 				got_rad = true;
 				lrp = dc;
 			case k < KMAX - 3:
@@ -105,7 +105,7 @@ macro double! decfloat(char[] chars, int $bits, int $emin, int sign)
 				got_digit = true;
 			default:
 				dc++;
-				if (c != '0') x[KMAX - 4] |= 1;
+        		if (c != '0') x[KMAX - 4] |= 1;
 
 		}
 		if (index == last_char) break;
@@ -113,24 +113,24 @@ macro double! decfloat(char[] chars, int $bits, int $emin, int sign)
 		c = chars[++index];
 	}
 	if (!got_rad) lrp = dc;
-	if (!got_digit) return NumberConversion.MALFORMED_FLOAT?;
+	if (!got_digit) return NumberConversion.MALFORMED_FLOAT!;
 	if ((c | 32) == 'e')
 	{
-		if (last_char == index) return NumberConversion.MALFORMED_FLOAT?;
-		long e10 = String.to_long((String)chars[index + 1..]) ?? NumberConversion.MALFORMED_FLOAT?!;
+		if (last_char == index) return NumberConversion.MALFORMED_FLOAT!;
+		long e10 = str::to_long((String)chars[index + 1..]) ?? NumberConversion.MALFORMED_FLOAT!?;
 		lrp += e10;
 	}
 	else if (index != last_char)
 	{
-		return NumberConversion.MALFORMED_FLOAT?;
+		return NumberConversion.MALFORMED_FLOAT!;
 	}
 	// Handle zero specially to avoid nasty special cases later
 	if (!x[0]) return sign * 0.0;
 
 	// Optimize small integers (w/no exponent) and over/under-flow
 	if (lrp == dc && dc < 10 && ($bits > 30 || (ulong)x[0] >> $bits == 0)) return sign * (double)x[0];
-	if (lrp > - $emin / 2) return NumberConversion.FLOAT_OUT_OF_RANGE?;
-	if (lrp < $emin - 2 * math::DOUBLE_MANT_DIG) return NumberConversion.FLOAT_OUT_OF_RANGE?;
+	if (lrp > - $emin / 2) return NumberConversion.FLOAT_OUT_OF_RANGE!;
+	if (lrp < $emin - 2 * math::DOUBLE_MANT_DIG) return NumberConversion.FLOAT_OUT_OF_RANGE!;
 
 	// Align incomplete final B1B digit
 	if (j)
@@ -235,7 +235,7 @@ macro double! decfloat(char[] chars, int $bits, int $emin, int sign)
 			carry = (1000000000 >> sh) * tmp;
 			if (k == a && !x[k])
 			{
-				a = (a + 1) & MASK;
+			 	a = (a + 1) & MASK;
 				i--;
 				rp -= 9;
 			}
@@ -320,7 +320,7 @@ macro double! decfloat(char[] chars, int $bits, int $emin, int sign)
 			y *= 0.5;
 			e2++;
 		}
-		if (e2 + math::DOUBLE_MANT_DIG > emax || (denormal && frac)) return NumberConversion.MALFORMED_FLOAT?;
+		if (e2 + math::DOUBLE_MANT_DIG > emax || (denormal && frac)) return NumberConversion.MALFORMED_FLOAT!;
 	}
 	return math::scalbn(y, e2);
 }
@@ -351,7 +351,7 @@ macro double! hexfloat(char[] chars, int $bits, int $emin, int sign)
 		got_rad = true;
 		if (index == last_char)
 		{
-			if (!got_digit) return NumberConversion.MALFORMED_FLOAT?;
+			if (!got_digit) return NumberConversion.MALFORMED_FLOAT!;
 			return sign * 0.0;
 		}
 		if (index != last_char && (c = chars[++index]) == '0')
@@ -369,7 +369,7 @@ macro double! hexfloat(char[] chars, int $bits, int $emin, int sign)
 	{
 		if (c == '.')
 		{
-			if (got_rad) return NumberConversion.MALFORMED_FLOAT?;
+			if (got_rad) return NumberConversion.MALFORMED_FLOAT!;
 			got_rad = true;
 			rp = dc;
 		}
@@ -396,20 +396,20 @@ macro double! hexfloat(char[] chars, int $bits, int $emin, int sign)
 		if (index == last_char) break;
 		c = chars[++index];
 	}
-	if (!got_digit) return NumberConversion.MALFORMED_FLOAT?;
+	if (!got_digit) return NumberConversion.MALFORMED_FLOAT!;
 	if (!got_rad) rp = dc;
 	for (; dc < 8; dc++) x *= 16;
 
 	long e2;
 	if ((c | 32) == 'p')
 	{
-		long e2val = String.to_long((String)chars[index + 1..]) ?? (NumberConversion.MALFORMED_FLOAT?)!;
-		e2 = e2val;
+		long e2val = str::to_long((String)chars[index + 1..]) ?? NumberConversion.MALFORMED_FLOAT!?;
+    	e2 = e2val;
 	}
 	e2 += 4 * rp - 32;
 	if (!x) return sign * 0.0;
-	if (e2 > -$emin) return NumberConversion.FLOAT_OUT_OF_RANGE?;
-	if (e2 < $emin - 2 * math::DOUBLE_MANT_DIG) return NumberConversion.FLOAT_OUT_OF_RANGE?;
+	if (e2 > -$emin) return NumberConversion.FLOAT_OUT_OF_RANGE!;
+	if (e2 < $emin - 2 * math::DOUBLE_MANT_DIG) return NumberConversion.FLOAT_OUT_OF_RANGE!;
 
 	while (x < 0x80000000)
 	{
@@ -444,12 +444,12 @@ macro double! hexfloat(char[] chars, int $bits, int $emin, int sign)
 	}
 	y = bias + sign * (double)x + sign * y;
 	y -= bias;
-	if (!y) return NumberConversion.FLOAT_OUT_OF_RANGE?;
+	if (!y) return NumberConversion.FLOAT_OUT_OF_RANGE!;
 
 	return math::scalbn(y, (int)e2);
 }
 
-macro String.to_real(chars, $Type) @private
+macro floatparse(String chars, $Type) @private
 {
 	int sign = 1;
 	$switch ($Type)
@@ -460,23 +460,23 @@ macro String.to_real(chars, $Type) @private
 		const int BITS = math::DOUBLE_MANT_DIG;
 		const int EMIN = math::DOUBLE_MIN_EXP - BITS;
 	$case float128:
-		$error "Not yet supported";
+		$assert(false, "Not yet supported");
 	$default:
-		$error "Unexpected type";
+		$assert(false, "Unexpected type");
 	$endswitch
 
-	while (chars.len && chars[0] == ' ') chars = chars[1..];
-	if (!chars.len) return NumberConversion.MALFORMED_FLOAT?;
-	switch (chars[0])
-	{
-		case '-':
-			sign = -1;
-			nextcase;
-		case '+':
-			chars = chars[1..];
-	}
-	if (chars == "infinity" || chars == "INFINITY") return sign * $Type.inf;
-	if (chars == "NAN" || chars == "nan") return $Type.nan;
+ 	while (chars.len && chars[0] == ' ') chars = chars[1..];
+ 	if (!chars.len) return NumberConversion.MALFORMED_FLOAT!;
+ 	switch (chars[0])
+ 	{
+ 	    case '-':
+ 	        sign = -1;
+ 	        nextcase;
+ 	    case '+':
+ 	        chars = chars[1..];
+ 	}
+ 	if (chars == "infinity" || chars == "INFINITY") return sign * $Type.inf;
+ 	if (chars == "NAN" || chars == "nan") return $Type.nan;
 
 	if (chars.len > 2 && chars[0] == '0' && (chars[1] | 32) == 'x')
 	{

lib/std/core/mem.c3

@@ -2,179 +2,26 @@
 // 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;
-import std::core::mem::allocator @public;
-import std::math;
 
 const MAX_MEMORY_ALIGNMENT = 0x1000_0000;
 const DEFAULT_MEM_ALIGNMENT = (void*.alignof) * 2;
 
 
-/**
- * Load a vector from memory according to a mask assuming default alignment.
- *
- * @param ptr "The pointer address to load from."
- * @param mask "The mask for the load"
- * @param passthru "The value to use for non masked values"
- * @require $assignable(&&passthru, $typeof(ptr)) : "Pointer and passthru must match"
- * @require @typekind(passthru) == VECTOR : "Expected passthru to be a vector"
- * @require passthru.len == mask.len : "Mask and passthru must have the same length"
- *
- * @return "A vector with the loaded values where the mask is true, passthru where the mask is false"
- **/
-macro masked_load(ptr, bool[<*>] mask, passthru)
-{
-	return $$masked_load(ptr, mask, passthru, 0);
-}
-
-/**
- * Load a vector from memory according to a mask.
- *
- * @param ptr "The pointer address to load from."
- * @param mask "The mask for the load"
- * @param passthru "The value to use for non masked values"
- * @param $alignment "The alignment to assume for the pointer"
- *
- * @require $assignable(&&passthru, $typeof(ptr)) : "Pointer and passthru must match"
- * @require @typekind(passthru) == VECTOR : "Expected passthru to be a vector"
- * @require passthru.len == mask.len : "Mask and passthru must have the same length"
- * @require math::is_power_of_2($alignment) : "The alignment must be a power of two"
- *
- * @return "A vector with the loaded values where the mask is true, passthru where the mask is false"
- **/
-macro @masked_load_aligned(ptr, bool[<*>] mask, passthru, usz $alignment)
-{
-	return $$masked_load(ptr, mask, passthru, $alignment);
-}
-
-/**
- * Load values from a pointer vector, assuming default alignment.
- *
- * @param ptrvec "The vector of pointers to load from."
- * @param mask "The mask for the load"
- * @param passthru "The value to use for non masked values"
- *
- * @require @typekind(ptrvec) == VECTOR : "Expected ptrvec to be a vector"
- * @require @typekind(passthru) == VECTOR : "Expected passthru to be a vector"
- * @require $assignable(&&passthru[0], $typeof(ptrvec[0])) : "Pointer and passthru must match"
- * @require passthru.len == mask.len : "Mask and passthru must have the same length"
- * @require mask.len == ptrvec.len : "Mask and ptrvec must have the same length"
- *
- * @return "A vector with the loaded values where the mask is true, passthru where the mask is false"
- **/
-macro gather(ptrvec, bool[<*>] mask, passthru)
-{
-	return $$gather(ptrvec, mask, passthru, 0);
-}
-
-
-/**
- * Load values from a pointer vector.
- *
- * @param ptrvec "The vector of pointers to load from."
- * @param mask "The mask for the load"
- * @param passthru "The value to use for non masked values"
- * @param $alignment "The alignment to assume for the pointers"
- *
- * @require @typekind(ptrvec) == VECTOR : "Expected ptrvec to be a vector"
- * @require @typekind(passthru) == VECTOR : "Expected passthru to be a vector"
- * @require $assignable(&&passthru[0], $typeof(ptrvec[0])) : "Pointer and passthru must match"
- * @require passthru.len == mask.len : "Mask and passthru must have the same length"
- * @require mask.len == ptrvec.len : "Mask and ptrvec must have the same length"
- * @require math::is_power_of_2($alignment) : "The alignment must be a power of two"
- *
- * @return "A vector with the loaded values where the mask is true, passthru where the mask is false"
- **/
-macro @gather_aligned(ptrvec, bool[<*>] mask, passthru, usz $alignment)
-{
-	return $$gather(ptrvec, mask, passthru, $alignment);
-}
-
-
-/**
- * Store parts of a vector according to the mask, assuming default alignment.
- *
- * @param ptr "The pointer address to store to."
- * @param value "The value to store masked"
- * @param mask "The mask for the store"
- *
- * @require $assignable(&&value, $typeof(ptr)) : "Pointer and value must match"
- * @require @typekind(value) == VECTOR : "Expected value to be a vector"
- * @require value.len == mask.len : "Mask and value must have the same length"
- **/
-macro masked_store(ptr, value, bool[<*>] mask)
-{
-	return $$masked_store(ptr, value, mask, 0);
-}
-
-/**
- * @param ptr "The pointer address to store to."
- * @param value "The value to store masked"
- * @param mask "The mask for the store"
- * @param $alignment "The alignment of the pointer"
- *
- * @require $assignable(&&value, $typeof(ptr)) : "Pointer and value must match"
- * @require @typekind(value) == VECTOR : "Expected value to be a vector"
- * @require value.len == mask.len : "Mask and value must have the same length"
- * @require math::is_power_of_2($alignment) : "The alignment must be a power of two"
- *
- **/
-macro @masked_store_aligned(ptr, value, bool[<*>] mask, usz $alignment)
-{
-	return $$masked_store(ptr, value, mask, $alignment);
-}
-
-/**
- * @param ptrvec "The vector pointer containing the addresses to store to."
- * @param value "The value to store masked"
- * @param mask "The mask for the store"
- * @require @typekind(ptrvec) == VECTOR : "Expected ptrvec to be a vector"
- * @require @typekind(value) == VECTOR : "Expected value to be a vector"
- * @require $assignable(&&value[0], $typeof(ptrvec[0])) : "Pointer and value must match"
- * @require value.len == mask.len : "Mask and value must have the same length"
- * @require mask.len == ptrvec.len : "Mask and ptrvec must have the same length"
- *
- **/
-macro scatter(ptrvec, value, bool[<*>] mask)
-{
-	return $$scatter(ptrvec, value, mask, 0);
-}
-
-/**
- * @param ptrvec "The vector pointer containing the addresses to store to."
- * @param value "The value to store masked"
- * @param mask "The mask for the store"
- * @param $alignment "The alignment of the load"
- *
- * @require @typekind(ptrvec) == VECTOR : "Expected ptrvec to be a vector"
- * @require @typekind(value) == VECTOR : "Expected value to be a vector"
- * @require $assignable(&&value[0], $typeof(ptrvec[0])) : "Pointer and value must match"
- * @require value.len == mask.len : "Mask and value must have the same length"
- * @require mask.len == ptrvec.len : "Mask and ptrvec must have the same length"
- * @require math::is_power_of_2($alignment) : "The alignment must be a power of two"
- **/
-macro @scatter_aligned(ptrvec, value, bool[<*>] mask, usz $alignment)
-{
-	return $$scatter(ptrvec, value, mask, $alignment);
-}
-
 macro @volatile_load(&x) @builtin
 {
-	return $$volatile_load(x);
+    return $$volatile_load(&x);
 }
 
-/**
- * @require $assignable(y, $typeof(*x)) : "The value doesn't match the variable"
- **/
 macro @volatile_store(&x, y) @builtin
 {
-	return $$volatile_store(x, ($typeof(*x))y);
+    return $$volatile_store(&x, ($typeof(x))y);
 }
 
 enum AtomicOrdering : int
 {
 	NOT_ATOMIC,         // Not atomic
 	UNORDERED,          // No lock
-	RELAXED,            // Consistent ordering
+	MONOTONIC,          // Consistent ordering
 	ACQUIRE,            // Barrier locking load/store
 	RELEASE,            // Barrier releasing load/store
 	ACQUIRE_RELEASE,    // Barrier fence to load/store
@@ -190,11 +37,10 @@ enum AtomicOrdering : int
  * @require $ordering != AtomicOrdering.RELEASE "Release ordering is not valid for load."
  * @require $ordering != AtomicOrdering.ACQUIRE_RELEASE "Acquire release is not valid for load."
  * @require types::may_load_atomic($typeof(x)) "Only integer, float and pointers may be used."
- * @require @typekind(x) == POINTER "You can only load from a pointer"
  **/
 macro @atomic_load(&x, AtomicOrdering $ordering = SEQ_CONSISTENT, $volatile = false) @builtin
 {
-	return $$atomic_load(x, $volatile, (int)$ordering);
+	return $$atomic_load(&x, $volatile, (int)$ordering);
 }
 
 /**
@@ -209,22 +55,14 @@ macro @atomic_load(&x, AtomicOrdering $ordering = SEQ_CONSISTENT, $volatile = fa
  **/
 macro void @atomic_store(&x, value, AtomicOrdering $ordering = SEQ_CONSISTENT, $volatile = false) @builtin
 {
-	$$atomic_store(x, value, $volatile, (int)$ordering);
+	$$atomic_store(&x, value, $volatile, (int)$ordering);
 }
 
-/**
- * @require $success != AtomicOrdering.NOT_ATOMIC && $success != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
- * @require $failure != AtomicOrdering.RELEASE && $failure != AtomicOrdering.ACQUIRE_RELEASE "Acquire release is not valid."
- **/
 macro compare_exchange(ptr, compare, value, AtomicOrdering $success = SEQ_CONSISTENT, AtomicOrdering $failure = SEQ_CONSISTENT, bool $volatile = true, bool $weak = false, usz $alignment = 0)
 {
 	return $$compare_exchange(ptr, compare, value, $volatile, $weak, $success.ordinal, $failure.ordinal, $alignment);
 }
 
-/**
- * @require $success != AtomicOrdering.NOT_ATOMIC && $success != AtomicOrdering.UNORDERED "Acquire ordering is not valid."
- * @require $failure != AtomicOrdering.RELEASE && $failure != AtomicOrdering.ACQUIRE_RELEASE "Acquire release is not valid."
- **/
 macro compare_exchange_volatile(ptr, compare, value, AtomicOrdering $success = SEQ_CONSISTENT, AtomicOrdering $failure = SEQ_CONSISTENT)
 {
 	return compare_exchange(ptr, compare, value, $success, $failure, true);
@@ -253,110 +91,51 @@ fn bool ptr_is_aligned(void* ptr, usz alignment) @inline
 
 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);
+	$if ($inlined)
+		$$memset_inline(dst, (char)0, len, $is_volatile, $dst_align);
+	$else
+		$$memset(dst, (char)0, len, $is_volatile, $dst_align);
+	$endif
 }
 
-macro void clear_inline(void* dst, usz $len, usz $dst_align = 0, bool $is_volatile = false)
-{
-	$$memset_inline(dst, (char)0, $len, $is_volatile, $dst_align);
-}
-
-/**
- * Copy memory from src to dst efficiently, assuming the memory ranges do not overlap.
- *
- * @param [&out] dst "The destination to copy to"
- * @param [&in] src "The source to copy from"
- * @param len "The number of bytes to copy"
- * @param $dst_align "the alignment of the destination if different from the default, 0 assumes the default"
- * @param $src_align "the alignment of the destination if different from the default, 0 assumes the default"
- * @param $is_volatile "True if this copy should be treated as volatile, i.e. it can't be optimized away."
- *
- * @require len == 0 || dst + len <= src || src + len <= dst : "Ranges may not overlap"
- **/
 macro void copy(void* dst, void* src, usz len, usz $dst_align = 0, usz $src_align = 0, bool $is_volatile = false, bool $inlined = false)
 {
-	$$memcpy(dst, src, len, $is_volatile, $dst_align, $src_align);
+	$if ($inlined)
+		$$memcpy_inline(dst, src, len, $is_volatile, $dst_align, $src_align);
+	$else
+		$$memcpy(dst, src, len, $is_volatile, $dst_align, $src_align);
+	$endif
 }
 
-/**
- * Copy memory from src to dst efficiently, assuming the memory ranges do not overlap, it
- * will always be inlined and never call memcopy
- *
- * @param [&out] dst "The destination to copy to"
- * @param [&in] src "The source to copy from"
- * @param $len "The number of bytes to copy"
- * @param $dst_align "the alignment of the destination if different from the default, 0 assumes the default"
- * @param $src_align "the alignment of the destination if different from the default, 0 assumes the default"
- * @param $is_volatile "True if this copy should be treated as volatile, i.e. it can't be optimized away."
- *
- * @require $len == 0 || dst + $len <= src || src + $len <= dst : "Ranges may not overlap"
- **/
-macro void copy_inline(void* dst, void* src, usz $len, usz $dst_align = 0, usz $src_align = 0, bool $is_volatile = false)
-{
-	$$memcpy_inline(dst, src, $len, $is_volatile, $dst_align, $src_align);
-}
-
-/**
- * Copy memory from src to dst but correctly handle the possibility of overlapping ranges.
- *
- * @param [&out] dst "The destination to copy to"
- * @param [&in] src "The source to copy from"
- * @param len "The number of bytes to copy"
- * @param $dst_align "the alignment of the destination if different from the default, 0 assumes the default"
- * @param $src_align "the alignment of the destination if different from the default, 0 assumes the default"
- * @param $is_volatile "True if this copy should be treated as volatile, i.e. it can't be optimized away."
- **/
 macro void move(void* dst, void* src, usz len, usz $dst_align = 0, usz $src_align = 0, bool $is_volatile = false)
 {
 	$$memmove(dst, src, len, $is_volatile, $dst_align, $src_align);
 }
 
-/**
- * Sets all memory in a region to that of the provided byte.
- *
- * @param [&out] dst "The destination to copy to"
- * @param val "The value to copy into memory"
- * @param len "The number of bytes to copy"
- * @param $dst_align "the alignment of the destination if different from the default, 0 assumes the default"
- * @param $is_volatile "True if this copy should be treated as volatile, i.e. it can't be optimized away."
- *
- * @ensure !len || (dst[0] == val && dst[len - 1] == val)
- **/
-macro void set(void* dst, char val, usz len, usz $dst_align = 0, bool $is_volatile = false)
+macro void set(void* dst, char val, usz len, usz $dst_align = 0, bool $is_volatile = false, bool $inlined = false)
 {
-	$$memset(dst, val, len, $is_volatile, $dst_align);
+	$if ($inlined)
+		$$memset_inline(dst, val, len, $is_volatile, $dst_align);
+	$else
+		$$memset(dst, val, len, $is_volatile, $dst_align);
+	$endif
 }
 
-/**
- * Sets all memory in a region to that of the provided byte. Never calls OS memset.
- *
- * @param [&out] dst "The destination to copy to"
- * @param val "The value to copy into memory"
- * @param $len "The number of bytes to copy"
- * @param $dst_align "the alignment of the destination if different from the default, 0 assumes the default"
- * @param $is_volatile "True if this copy should be treated as volatile, i.e. it can't be optimized away."
- *
- * @ensure !$len || (dst[0] == val && dst[$len - 1] == val)
- **/
-macro void set_inline(void* dst, char val, usz $len, usz $dst_align = 0, bool $is_volatile = false)
-{
-	$$memset_inline(dst, val, $len, $is_volatile, $dst_align);
-}
 /**
  * @require values::@inner_kind(a) == TypeKind.SUBARRAY || values::@inner_kind(a) == TypeKind.POINTER
  * @require values::@inner_kind(b) == TypeKind.SUBARRAY || values::@inner_kind(b) == TypeKind.POINTER
  * @require values::@inner_kind(a) != TypeKind.SUBARRAY || len == -1
  * @require values::@inner_kind(a) != TypeKind.POINTER || len > -1
- * @require values::@assign_to(a, b) && values::@assign_to(b, a)
+ * @checked (a = b), (b = a)
  **/
 macro bool equals(a, b, isz len = -1, usz $align = 0)
 {
-	$if !$align:
+	$if (!$align)
 		$align = $typeof(a[0]).alignof;
 	$endif
 	void* x @noinit;
 	void* y @noinit;
-	$if values::@inner_kind(a) == TypeKind.SUBARRAY:
+	$if (values::@inner_kind(a) == TypeKind.SUBARRAY)
 		len = a.len;
 		if (len != b.len) return false;
 		x = a.ptr;
@@ -369,7 +148,7 @@ macro bool equals(a, b, isz len = -1, usz $align = 0)
 
 	if (!len) return true;
 	var $Type;
-	$switch ($align)
+    $switch ($align)
 		$case 1:
 			$Type = char;
 		$case 2:
@@ -394,361 +173,265 @@ macro bool equals(a, b, isz len = -1, usz $align = 0)
 	return true;
 }
 
+macro @clone(&value) @builtin
+{
+	$typeof(value)* x = malloc($typeof(value));
+	*x = value;
+	return x;
+}
+
+macro @tclone(&value) @builtin
+{
+	$typeof(value)* x = talloc($typeof(value));
+	*x = value;
+	return x;
+}
 
 macro type_alloc_must_be_aligned($Type)
 {
 	return $Type.alignof > DEFAULT_MEM_ALIGNMENT;
 }
+/**
+ * @require $vacount > 0 && $vacount < 3 "Expected size, type, or type + len"
+ * @require $vacount != 2 || $checks($vatype(0).sizeof) "Expected 'malloc(Foo, 12)'"
+ **/
+macro malloc(..., Allocator* using = mem::heap(), usz end_padding = 0) @builtin
+{
+	return malloc_checked($vasplat(), .using = using, .end_padding = end_padding)!!;
+}
+
+/**
+ * @require $vacount > 0 && $vacount < 3 "Expected size, type, or type + len"
+ * @require $vacount != 2 || $checks($vatype(0).sizeof) "Expected 'malloc(Foo, 12)'"
+ **/
+macro malloc_checked(..., Allocator* using = mem::heap(), usz end_padding = 0) @builtin
+{
+	$if ($checks($vatype(0).sizeof))
+		var $Type = $vatype(0);
+		$assert(!type_alloc_must_be_aligned($vatype(0)),  "Type must be allocated with malloc_aligned");
+		$if ($vacount == 2)
+			usz size = $vaarg(1);
+			return (($Type*)using.alloc($Type.sizeof * size + end_padding))[:size];
+		$else
+			return ($Type*)using.alloc($Type.sizeof + end_padding);
+		$endif
+	$else
+		return using.alloc($vaarg(0) + end_padding);
+	$endif
+}
+
+
+/**
+ * @require $vacount > 0 && $vacount < 3 "Expected size, type, or type + len"
+ * @require $vacount != 2 || $checks($vatype(0).sizeof) "Expected 'malloc(Foo, 12)'"
+ * @require alignment && math::is_power_of_2(alignment)
+ **/
+macro malloc_aligned(..., usz alignment = 0, usz end_padding = 0, Allocator* using = mem::heap()) @builtin
+{
+	$if ($checks($vatype(0).sizeof))
+		var $Type = $vatype(0);
+		$if ($vacount == 2)
+			usz size = $vaarg(1);
+			return (($Type*)using.alloc_aligned($Type.sizeof * size + end_padding, alignment))[:size];
+		$else
+			return ($Type*)using.alloc_aligned($Type.sizeof + end_padding, alignment);
+		$endif
+	$else
+		return using.alloc_aligned($vaarg(0) + end_padding, alignment);
+	$endif
+}
+
+macro alloc($Type) @deprecated => malloc($Type);
+
+macro char[] alloc_bytes(usz bytes) @deprecated => malloc(char, bytes);
+
+/**
+ * @require $vacount > 0 && $vacount < 3 "Expected size, type, or type + len"
+ * @require $vacount != 2 || $checks($vatype(0).sizeof) "Expected 'malloc(Foo, 12)'"
+ **/
+macro calloc(..., Allocator* using = mem::heap(), usz end_padding = 0) @builtin
+{
+	return calloc_checked($vasplat(), .using = using, .end_padding = end_padding)!!;
+}
+
+/**
+ * @require $vacount > 0 && $vacount < 3 "Expected size, type, or type + len"
+ * @require $vacount != 2 || $checks($vatype(0).sizeof) "Expected 'malloc(Foo, 12)'"
+ **/
+macro calloc_checked(..., Allocator* using = mem::heap(), usz end_padding = 0) @builtin
+{
+	$if ($checks($vatype(0).sizeof))
+		var $Type = $vatype(0);
+		$assert(!type_alloc_must_be_aligned($vatype(0)),  "Type must be allocated with calloc_aligned");
+		$if ($vacount == 2)
+			usz size = $vaarg(1);
+			return (($Type*)using.calloc($Type.sizeof * size + end_padding))[:size];
+		$else
+			return ($Type*)using.calloc($Type.sizeof + end_padding);
+		$endif
+	$else
+		return using.calloc($vaarg(0) + end_padding);
+	$endif
+}
+
+
+/**
+ * @require $vacount > 0 && $vacount < 3 "Expected size, type, or type + len"
+ * @require $vacount != 2 || $checks($vatype(0).sizeof) "Expected 'malloc(Foo, 12)'"
+ * @require alignment && math::is_power_of_2(alignment)
+ **/
+macro calloc_aligned(..., usz alignment = 0, Allocator* using = mem::heap(), usz end_padding = 0) @builtin
+{
+	$if ($checks($vatype(0).sizeof))
+		var $Type = $vatype(0);
+		$if ($vacount == 2)
+			usz size = $vaarg(1);
+			return (($Type*)using.calloc_aligned($Type.sizeof * size + end_padding, alignment))[:size];
+		$else
+			return ($Type*)using.calloc_aligned($Type.sizeof + end_padding, alignment);
+		$endif
+	$else
+		return using.calloc_aligned($vaarg(0) + end_padding, alignment);
+	$endif
+}
+
+fn void* realloc(void *ptr, usz new_size, Allocator* using = mem::heap()) @builtin @inline
+{
+	return using.realloc(ptr, new_size)!!;
+}
+
+fn void*! realloc_checked(void *ptr, usz new_size, Allocator* using = mem::heap()) @builtin @inline
+{
+	return using.realloc(ptr, new_size);
+}
+
+/**
+ * @require alignment && math::is_power_of_2(alignment)
+ */
+fn void*! realloc_aligned(void *ptr, usz new_size, usz alignment, Allocator* using = mem::heap()) @builtin @inline
+{
+	return using.realloc_aligned(ptr, new_size, alignment);
+}
+
+macro void free(void* ptr, Allocator* using = mem::heap()) @builtin => using.free(ptr)!!;
+macro void! free_checked(void* ptr, Allocator* using = mem::heap()) @builtin => using.free(ptr);
+macro void free_aligned(void* ptr, Allocator* using = mem::heap()) @builtin => using.free_aligned(ptr)!!;
+macro void! free_aligned_checked(void* ptr, Allocator* using = mem::heap()) @builtin => using.free_aligned(ptr);
 
 /**
  * Run with a specific allocator inside of the macro body.
  **/
-macro void @scoped(Allocator* allocator; @body())
+macro void @scoped(Allocator* using; @body())
 {
-	Allocator* old_allocator = allocator::thread_allocator;
-	allocator::thread_allocator = allocator;
-	defer allocator::thread_allocator = old_allocator;
+	Allocator* old_allocator = thread_allocator;
+	thread_allocator = using;
+	defer thread_allocator = old_allocator;
 	@body();
 }
 
-macro void @report_heap_allocs_in_scope(;@body())
-{
-	TrackingAllocator tracker;
-	tracker.init(allocator::thread_allocator);
-	Allocator* old_allocator = allocator::thread_allocator;
-	allocator::thread_allocator = &tracker;
-	defer
-	{
-		allocator::thread_allocator = old_allocator;
-		tracker.print_report();
-		tracker.free();
-	}
-	@body();
-}
-
-macro void @stack_mem(usz $size; @body(Allocator* mem)) @builtin
-{
-	char[$size] buffer;
-	OnStackAllocator allocator;
-	allocator.init(&buffer, allocator::heap());
-	defer allocator.free();
-	@body(&allocator);
-}
-
-macro void @stack_pool(usz $size; @body) @builtin
-{
-	char[$size] buffer;
-	OnStackAllocator allocator;
-	allocator.init(&buffer, allocator::heap());
-	defer allocator.free();
-	mem::@scoped(&allocator)
-	{
-		@body();
-	};
-}
-
-struct TempState
-{
-	TempAllocator* old;
-	TempAllocator* current;
-	usz mark;
-}
+macro talloc($Type) @builtin @deprecated => tmalloc($Type);
 
 /**
- * Push the current temp allocator. A push must always be balanced with a pop using the current state.
+ * @require $vacount > 0 && $vacount < 3 "Expected size, type, or type + len"
+ * @require $vacount != 2 || $checks($vatype(0).sizeof) "Expected 'malloc(Foo, 12)'"
  **/
-fn TempState temp_push(TempAllocator* other = null)
+macro tmalloc(..., usz end_padding = 0, usz alignment = DEFAULT_MEM_ALIGNMENT) @builtin
 {
-	TempAllocator* current = allocator::temp();
-	TempAllocator* old = current;
-	if (other == current)
-	{
-		current = allocator::temp_allocator_next();
-	}
-	return { old, current, current.used };
-}
-
-/**
- * Pop the current temp allocator. A pop must always be balanced with a push.
- **/
-fn void temp_pop(TempState old_state)
-{
-	assert(allocator::thread_temp_allocator == old_state.current, "Tried to pop temp allocators out of order.");
-	assert(old_state.current.used >= old_state.mark, "Tried to pop temp allocators out of order.");
-	old_state.current.reset(old_state.mark);
-	allocator::thread_temp_allocator = old_state.old;
-}
-
-macro void @pool(TempAllocator* #other_temp = null; @body) @builtin
-{
-	TempAllocator* current = allocator::temp();
-	var $has_arg = !$is_const(#other_temp);
-	$if $has_arg:
-		TempAllocator* original = current;
-		if (current == (void*)#other_temp) current = allocator::temp_allocator_next();
+	$if ($checks($vatype(0).sizeof))
+		var $Type = $vatype(0);
+		$if ($vacount == 2)
+			usz size = $vaarg(1);
+			return (($Type*)temp().alloc_aligned($Type.sizeof * size + end_padding, alignment))[:size]!!;
+		$else
+			return ($Type*)temp().alloc_aligned($Type.sizeof + end_padding, alignment)!!;
+		$endif
+	$else
+		return temp().alloc_aligned($vaarg(0) + end_padding, alignment)!!;
 	$endif
-	usz mark = current.used;
-	defer
-	{
-		current.reset(mark);
-		$if $has_arg:
-			allocator::thread_temp_allocator = original;
-		$endif;
-	}
+}
+
+/**
+ * @require $vacount > 0 && $vacount < 3 "Expected size, type, or type + len"
+ * @require $vacount != 2 || $checks($vatype(0).sizeof) "Expected 'malloc(Foo, 12)'"
+ **/
+macro tcalloc(..., usz end_padding = 0, usz alignment = mem::DEFAULT_MEM_ALIGNMENT) @builtin
+{
+	$if ($checks($vatype(0).sizeof))
+		var $Type = $vatype(0);
+		$if ($vacount == 2)
+			usz size = $vaarg(1);
+			return (($Type*)temp().calloc_aligned($Type.sizeof * size + end_padding, alignment))[:size]!!;
+		$else
+			return ($Type*)temp().calloc_aligned($Type.sizeof + end_padding, alignment)!!;
+		$endif
+	$else
+		return temp().calloc_aligned($vaarg(0) + end_padding, alignment)!!;
+	$endif
+}
+
+fn void* trealloc(void* ptr, usz size, usz alignment = mem::DEFAULT_MEM_ALIGNMENT) @builtin @inline
+{
+	return temp().realloc_aligned(ptr, size, alignment)!!;
+}
+
+macro void @pool(;@body) @builtin
+{
+	TempAllocator* allocator = temp();
+	usz mark = allocator.used;
+	defer allocator.reset(mark);
 	@body();
 }
 
+macro void @allocating_pool(Allocator* using; @body(bool is_temp)) @builtin
+{
+	TempAllocator* allocator = temp();
+	usz mark = allocator.used;
+	bool is_temp = allocator == using;
+	defer if (!is_temp) allocator.reset(mark);
+	@body(is_temp);
+}
 
+tlocal Allocator* thread_allocator @private = allocator::LIBC_ALLOCATOR;
+tlocal TempAllocator* thread_temp_allocator @private = null;
 
+macro TempAllocator* temp_allocator() => temp();
 
-import libc;
+macro TempAllocator* temp()
+{
+	if (!thread_temp_allocator)
+	{
+		$switch (env::MEMORY_ENV)
+		$case NORMAL:
+			thread_temp_allocator = allocator::new_temp(1024 * 256, thread_allocator)!!;
+		$case SMALL:
+			thread_temp_allocator = allocator::new_temp(1024 * 16, thread_allocator)!!;
+		$case TINY:
+			thread_temp_allocator = allocator::new_temp(1024 * 2, thread_allocator)!!;
+		$case NONE:
+			unreachable("Temp allocator must explicitly created when memory-env is set to 'none'.");
+		$endswitch
+	}
+	return thread_temp_allocator;
+}
 
+macro Allocator* current_allocator() => thread_allocator;
+macro Allocator* heap() => thread_allocator;
 
-
-macro TempAllocator* temp() @deprecated("Use allocator::temp()") => allocator::temp();
-macro Allocator* current_allocator() @deprecated("Use allocator::heap()") => allocator::heap();
-macro Allocator* heap() @deprecated("Use allocator::heap()") => allocator::heap();
-
-module std::core::mem @if(WASM_NOLIBC);
+$if (!env::COMPILER_LIBC_AVAILABLE && env::ARCH_TYPE == ArchType.WASM32 || env::ARCH_TYPE == ArchType.WASM64)
 
 SimpleHeapAllocator wasm_allocator @private;
+
 extern int __heap_base;
 
-fn void initialize_wasm_mem() @init(1) @private
+static initialize @priority(1)
 {
 	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;
+	thread_allocator = &wasm_allocator;
 }
-
-module std::core::mem;
+$endif
 
 
-macro TrackingEnv* get_tracking_env()
-{
-	$if env::TRACK_MEMORY:
-		return &&TrackingEnv { $$FILE, $$FUNC, $$LINE };
-	$else
-		return null;
-	$endif
-}
-
-macro @clone(value) @builtin @nodiscard
-{
-	return allocator::clone(allocator::heap(), value);
-}
-
-macro @tclone(value) @builtin @nodiscard
-{
-	return temp_new($typeof(value), value);
-}
-
-fn void* malloc(usz size) @builtin @inline @nodiscard
-{
-	return allocator::malloc(allocator::heap(), size);
-}
-
-fn void* tmalloc(usz size, usz alignment = 0, usz offset = 0) @builtin @inline @nodiscard
-{
-	if (!size) return null;
-	return allocator::temp().acquire(size, false, alignment, 0)!!;
-}
-
-/**
- * @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 $Type.alignof <= DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_aligned' instead"
- **/
-macro new($Type, ...) @nodiscard
-{
-	$if $vacount == 0:
-		return ($Type*)calloc($Type.sizeof);
-	$else
-		$Type* val = malloc($Type.sizeof);
-		*val = $vaexpr(0);
-		return val;
-	$endif
-}
-
-/**
- * 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"
- **/
-macro new_aligned($Type, ...) @nodiscard
-{
-	$if $vacount == 0:
-		return ($Type*)calloc_aligned($Type.sizeof, $Type.alignof);
-	$else
-		$Type* val = malloc_aligned($Type.sizeof, $Type.alignof);
-		*val = $vaexpr(0);
-		return val;
-	$endif
-}
-
-/**
- * @require $Type.alignof <= DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_aligned' instead"
- **/
-macro alloc($Type) @nodiscard
-{
-	return ($Type*)malloc($Type.sizeof);
-}
-
-/**
- * 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.
- **/
-macro alloc_aligned($Type) @nodiscard
-{
-	return ($Type*)malloc_aligned($Type.sizeof, $Type.alignof);
-}
-
-macro new_clear($Type) @deprecated("Use mem::new")
-{
-	return new($Type);
-}
-
-macro new_temp($Type) @deprecated("Use mem::temp_alloc or mem::temp_new")
-{
-	return tmalloc($Type.sizeof);
-}
-
-/**
- * @require $vacount < 2 : "Too many arguments."
- * @require $or($vacount == 0, $assignable($vaexpr(0), $Type)) : "The second argument must be an initializer for the type"
- **/
-macro temp_new($Type, ...) @nodiscard
-{
-	$if $vacount == 0:
-		return ($Type*)tcalloc($Type.sizeof) @inline;
-	$else
-		$Type* val = tmalloc($Type.sizeof) @inline;
-		*val = $vaexpr(0);
-		return val;
-	$endif
-}
-
-macro temp_alloc($Type) @nodiscard
-{
-	return tmalloc($Type.sizeof);
-}
-
-macro new_temp_clear($Type) @deprecated("use mem::temp_new")
-{
-	return tcalloc($Type.sizeof);
-}
-
-
-
-/**
- * @require $Type.alignof <= DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_array_aligned' instead"
- **/
-macro new_array($Type, usz elements) @nodiscard
-{
-	return allocator::new_array(allocator::heap(), $Type, elements);
-}
-
-/**
- * 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.
- **/
-macro new_array_aligned($Type, usz elements) @nodiscard
-{
-	return allocator::new_array_aligned(allocator::heap(), $Type, elements);
-}
-
-/**
- * @require $Type.alignof <= DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_array_aligned' instead"
- **/
-macro alloc_array($Type, usz elements) @nodiscard
-{
-	return allocator::alloc_array(allocator::heap(), $Type, elements);
-}
-
-/**
- * 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.
- **/
-macro alloc_array_aligned($Type, usz elements) @nodiscard
-{
-	return allocator::alloc_array(allocator::heap(), $Type, elements);
-}
-
-macro talloc_array($Type, usz elements) @nodiscard @deprecated("use mem::temp_alloc_array")
-{
-	return temp_alloc_array($Type, elements);
-}
-
-macro temp_alloc_array($Type, usz elements) @nodiscard
-{
-	return (($Type*)tmalloc($Type.sizeof * elements, $Type.alignof))[:elements];
-}
-
-macro temp_array($Type, usz elements) @nodiscard @deprecated("use mem::temp_alloc_array")
-{
-	return temp_alloc_array($Type, elements);
-}
-
-macro temp_new_array($Type, usz elements) @nodiscard
-{
-	return (($Type*)tcalloc($Type.sizeof * elements, $Type.alignof))[:elements];
-}
-
-macro new_zero_array($Type, usz elements) @deprecated("Use new_array")
-{
-	return new_array($Type, elements);
-}
-
-macro temp_zero_array($Type, usz elements) @deprecated("Use temp_new_array")
-{
-	return temp_new_array($Type, elements);
-}
-
-fn void* calloc(usz size) @builtin @inline @nodiscard
-{
-	return allocator::calloc(allocator::heap(), size);
-}
-
-fn void* calloc_aligned(usz size, usz alignment) @builtin @inline @nodiscard
-{
-	return allocator::calloc_aligned(allocator::heap(), size, alignment)!!;
-}
-
-fn void* tcalloc(usz size, usz alignment = 0, usz offset = 0) @builtin @inline @nodiscard
-{
-	if (!size) return null;
-	return allocator::temp().acquire(size, false, alignment, 0)!!;
-}
-
-fn void* realloc(void *ptr, usz new_size) @builtin @inline @nodiscard
-{
-	return allocator::realloc(allocator::heap(), ptr, new_size);
-}
-
-fn void* realloc_aligned(void *ptr, usz new_size, usz alignment) @builtin @inline @nodiscard
-{
-	return allocator::realloc_aligned(allocator::heap(), ptr, new_size, alignment)!!;
-}
-
-fn void free(void* ptr) @builtin @inline
-{
-	return allocator::free(allocator::heap(), ptr);
-}
-
-fn void free_aligned(void* ptr) @builtin @inline
-{
-	return allocator::free_aligned(allocator::heap(), ptr);
-}
-
-fn void* trealloc(void* ptr, usz size, usz alignment = mem::DEFAULT_MEM_ALIGNMENT) @builtin @inline @nodiscard
-{
-	if (!size) return null;
-    if (!ptr) return tmalloc(size, alignment);
-	return allocator::temp().resize(ptr, size, alignment, 0)!!;
-}
-

lib/std/core/mem_allocator.c3

@@ -3,442 +3,107 @@ module std::core::mem::allocator;
 const DEFAULT_SIZE_PREFIX = usz.sizeof;
 const DEFAULT_SIZE_PREFIX_ALIGNMENT = usz.alignof;
 
-struct TrackingEnv
+const Allocator* NULL_ALLOCATOR = &_NULL_ALLOCATOR;
+const Allocator* LIBC_ALLOCATOR = &_SYSTEM_ALLOCATOR;
+
+typedef AllocatorFunction = fn void*!(Allocator* allocator, usz new_size, usz alignment, usz offset, void* old_pointer, AllocationKind kind);
+
+struct Allocator
 {
-	String file;
-	String function;
-	uint line;
+    AllocatorFunction function;
 }
 
-
-interface Allocator
+enum AllocationKind
 {
-	fn void reset(usz mark) @optional;
-	fn usz mark() @optional;
-	/**
-     * @require !alignment || math::is_power_of_2(alignment)
-     * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
-     * @require offset == 0 `offset no longer supported`
-     * @require size > 0
-     **/
-	fn void*! acquire(usz size, bool clear, usz alignment, usz offset);
-	/**
-     * @require !alignment || math::is_power_of_2(alignment)
-     * @require alignment <= mem::MAX_MEMORY_ALIGNMENT `alignment too big`
-     * @require offset == 0 `offset no longer supported`
-     * @require ptr != null
-     * @require new_size > 0
-     **/
-	fn void*! resize(void* ptr, usz new_size, usz alignment, usz offset);
-	/**
-     * @require ptr != null
-     **/
-	fn void release(void* ptr, bool aligned);
+    ALLOC,
+    CALLOC,
+    REALLOC,
+    FREE,
+    ALIGNED_ALLOC,
+    ALIGNED_CALLOC,
+    ALIGNED_REALLOC,
+    ALIGNED_FREE,
+    RESET,
+    MARK,
 }
 
-def MemoryAllocFn = fn char[]!(usz);
-
 fault AllocationFailure
 {
-	OUT_OF_MEMORY,
-	CHUNK_TOO_LARGE,
+    OUT_OF_MEMORY,
+    UNSUPPORTED_OPERATION,
+    CHUNK_TOO_LARGE,
+}
+
+
+
+fn void*! Allocator.alloc(Allocator* allocator, usz size) @inline
+{
+	return allocator.function(allocator, size, 0, 0, null, ALLOC);
+}
+
+/**
+ * @require alignment && math::is_power_of_2(alignment)
+ */
+fn void*! Allocator.alloc_aligned(Allocator* allocator, usz size, usz alignment, usz offset = 0) @inline
+{
+	return allocator.function(allocator, size, alignment, offset, null, ALIGNED_ALLOC);
+}
+
+fn void*! Allocator.realloc(Allocator* allocator, void* old_pointer, usz size) @inline
+{
+	return allocator.function(allocator, size, 0, 0, old_pointer, REALLOC);
+}
+
+/**
+ * @require alignment && math::is_power_of_2(alignment)
+ */
+fn void*! Allocator.realloc_aligned(Allocator* allocator, void* old_pointer, usz size, usz alignment, usz offset = 0) @inline
+{
+	return allocator.function(allocator, size, alignment, offset, old_pointer, ALIGNED_REALLOC);
+}
+
+fn usz! Allocator.mark(Allocator* allocator) @inline
+{
+	return (usz)(uptr)allocator.function(allocator, 0, 0, 0, null, MARK);
+}
+
+
+fn void*! Allocator.calloc(Allocator* allocator, usz size) @inline
+{
+	return allocator.function(allocator, size, 0, 0, null, CALLOC);
+}
+
+/**
+ * @require alignment && math::is_power_of_2(alignment)
+ */
+fn void*! Allocator.calloc_aligned(Allocator* allocator, usz size, usz alignment, usz offset = 0) @inline
+{
+	return allocator.function(allocator, size, alignment, offset, null, ALIGNED_CALLOC);
+}
+
+fn void! Allocator.free(Allocator* allocator, void* old_pointer) @inline
+{
+	allocator.function(allocator, 0, 0, 0, old_pointer, FREE)?;
+}
+
+fn void! Allocator.free_aligned(Allocator* allocator, void* old_pointer) @inline
+{
+	allocator.function(allocator, 0, 0, 0, old_pointer, ALIGNED_FREE)?;
+}
+
+fn void Allocator.reset(Allocator* allocator, usz mark = 0)
+{
+	allocator.function(allocator, mark, 0, 0, null, RESET)!!;
 }
 
 fn usz alignment_for_allocation(usz alignment) @inline @private
 {
-	return alignment < mem::DEFAULT_MEM_ALIGNMENT ? alignment = mem::DEFAULT_MEM_ALIGNMENT : alignment;
-}
-
-macro void* malloc(Allocator* allocator, usz size) @nodiscard
-{
-	return malloc_try(allocator, size)!!;
-}
-
-macro void*! malloc_try(Allocator* allocator, usz size) @nodiscard
-{
-	if (!size) return null;
-	$if env::TESTING:
-		char* data = allocator.acquire(size, false, 0, 0)!;
-		mem::set(data, 0xAA, size, mem::DEFAULT_MEM_ALIGNMENT);
-		return data;
-	$else
-		return allocator.acquire(size, false, 0, 0);
-	$endif
-}
-
-macro void* calloc(Allocator* allocator, usz size) @nodiscard
-{
-	return calloc_try(allocator, size)!!;
-}
-
-macro void*! calloc_try(Allocator* allocator, usz size) @nodiscard
-{
-	if (!size) return null;
-	return allocator.acquire(size, true, 0, 0);
-}
-
-macro void* realloc(Allocator* allocator, void* ptr, usz new_size) @nodiscard
-{
-	return realloc_try(allocator, ptr, new_size)!!;
-}
-
-macro void*! realloc_try(Allocator* allocator, void* ptr, usz new_size) @nodiscard
-{
-	if (!new_size)
+	if (alignment < mem::DEFAULT_MEM_ALIGNMENT)
 	{
-		free(allocator, ptr);
-		return null;
+		alignment = mem::DEFAULT_MEM_ALIGNMENT;
 	}
-	if (!ptr) return allocator.acquire(new_size, false, 0, 0);
-	return allocator.resize(ptr, new_size, 0, 0);
-}
-
-macro void free(Allocator* allocator, void* ptr)
-{
-	if (!ptr) return;
-	$if env::TESTING:
-		((char*)ptr)[0] = 0xBA;
-	$endif
-	allocator.release(ptr, false);
-}
-
-macro void*! malloc_aligned(Allocator* allocator, usz size, usz alignment, usz offset = 0) @nodiscard
-{
-	if (!size) return null;
-	$if env::TESTING:
-		char* data = allocator.acquire(size, false, alignment, offset)!;
-		mem::set(data, 0xAA, size, mem::DEFAULT_MEM_ALIGNMENT);
-		return data;
-	$else
-		return allocator.acquire(size, false, alignment, offset);
-	$endif
-}
-
-macro void*! calloc_aligned(Allocator* allocator, usz size, usz alignment, usz offset = 0) @nodiscard
-{
-	if (!size) return null;
-	return allocator.acquire(size, true, alignment, offset);
-}
-
-macro void*! realloc_aligned(Allocator* allocator, void* ptr, usz new_size, usz alignment, usz offset = 0) @nodiscard
-{
-	if (!new_size)
-	{
-		free_aligned(allocator, ptr);
-		return null;
-	}
-	if (!ptr)
-	{
-		return malloc_aligned(allocator, new_size, alignment);
-	}
-	return allocator.resize(ptr, new_size, alignment, offset);
-}
-
-macro void free_aligned(Allocator* allocator, void* ptr)
-{
-	if (!ptr) return;
-	$if env::TESTING:
-	((char*)ptr)[0] = 0xBA;
-	$endif
-	allocator.release(ptr, true);
-}
-
-/**
- * @require $vacount < 2 : "Too many arguments."
- * @require $or($vacount == 0, $assignable($vaexpr(0), $Type)) : "The second argument must be an initializer for the type"
- **/
-macro new(Allocator* allocator, $Type, ...) @nodiscard
-{
-	$if $vacount == 0:
-		return ($Type*)calloc(allocator, $Type.sizeof);
-	$else
-		$Type* val = malloc(allocator, $Type.sizeof);
-		*val = $vaexpr(0);
-		return val;
-	$endif
-}
-
-/**
- * @require $vacount < 2 : "Too many arguments."
- * @require $or($vacount == 0, $assignable($vaexpr(0), $Type)) : "The second argument must be an initializer for the type"
- **/
-macro new_try(Allocator* allocator, $Type, ...) @nodiscard
-{
-	$if $vacount == 0:
-		return ($Type*)calloc_try(allocator, $Type.sizeof);
-	$else
-		$Type* val = malloc_try(allocator, $Type.sizeof)!;
-		*val = $vaexpr(0);
-		return val;
-	$endif
-}
-
-macro new_with_padding(Allocator* allocator, $Type, usz padding) @nodiscard
-{
-	return ($Type*)calloc_try(allocator, $Type.sizeof + padding);
-}
-
-macro alloc(Allocator* allocator, $Type) @nodiscard
-{
-	return ($Type*)malloc(allocator, $Type.sizeof);
-}
-
-macro alloc_try(Allocator* allocator, $Type) @nodiscard
-{
-	return ($Type*)malloc_try(allocator, $Type.sizeof);
-}
-
-macro alloc_with_padding(Allocator* allocator, $Type, usz padding) @nodiscard
-{
-	return ($Type*)malloc_try(allocator, $Type.sizeof + padding);
-}
-
-macro new_array(Allocator* allocator, $Type, usz elements) @nodiscard
-{
-	return new_array_try(allocator, $Type, elements)!!;
-}
-
-macro new_array_try(Allocator* allocator, $Type, usz elements) @nodiscard
-{
-	return (($Type*)calloc_try(allocator, $Type.sizeof * elements))[:elements];
-}
-
-macro new_array_aligned(Allocator* allocator, $Type, usz elements) @nodiscard
-{
-	return ((Type*)calloc_aligned(allocator, $Type.sizeof * elements, $Type.alignof))[:elements]!!;
-}
-
-macro alloc_array(Allocator* allocator, $Type, usz elements) @nodiscard
-{
-	return alloc_array_try(allocator, $Type, elements)!!;
-}
-
-macro alloc_array_aligned(Allocator* allocator, $Type, usz elements) @nodiscard
-{
-	return ((Type*)malloc_aligned(allocator, $Type.sizeof * elements, $Type.alignof))[:elements]!!;
-}
-
-macro alloc_array_try(Allocator* allocator, $Type, usz elements) @nodiscard
-{
-	return (($Type*)malloc_try(allocator, $Type.sizeof * elements))[:elements];
-}
-
-macro clone(Allocator* allocator, value) @nodiscard
-{
-	return new(allocator, $typeof(value), value);
-}
-
-fn any* clone_any(Allocator* allocator, any* value) @nodiscard
-{
-	usz size = value.type.sizeof;
-	void* data = malloc(allocator, size);
-	mem::copy(data, value.ptr, size);
-	return any_make(data, value.type);
-}
-
-// Allocator "functions"
-
-macro void*! Allocator.alloc_checked(&self, usz size) @deprecated("Use allocator::malloc_try")
-{
-	return malloc_try(self, size);
-}
-
-macro void*! Allocator.calloc_checked(&self, usz size) @deprecated("Use allocator::calloc_try")
-{
-	return calloc_try(self, size);
-}
-
-macro void*! Allocator.realloc_checked(&self, void* ptr, usz new_size) @deprecated("Use allocator::realloc_try")
-{
-	return realloc_try(ptr, new_size);
-}
-
-macro Allocator.new_array(&self, $Type, usz size, usz end_padding = 0) @deprecated("Use allocator::alloc_array")
-{
-	return (($Type*)self.alloc_checked($Type.sizeof * size + end_padding))[:size]!!;
-}
-
-macro Allocator.new_array_checked(&self, $Type, usz size, usz end_padding = 0) @deprecated("Use allocator::alloc_array_try")
-{
-	return (($Type*)self.alloc_checked($Type.sizeof * size + end_padding))[:size];
-}
-
-macro Allocator.new_zero_array(&self, $Type, usz size, usz end_padding = 0) @deprecated("Use allocator::new_array")
-{
-	return (($Type*)self.calloc_checked($Type.sizeof * size + end_padding))[:size]!!;
-}
-
-macro Allocator.new_zero_array_checked(&self, $Type, usz size, usz end_padding = 0) @deprecated("Use allocator::new_array_try")
-{
-	return (($Type*)self.calloc_checked($Type.sizeof * size + end_padding))[:size];
-}
-
-macro Allocator.new(&self, $Type, usz end_padding = 0) @nodiscard @deprecated("Use allocator::alloc")
-{
-	return ($Type*)self.alloc_checked($Type.sizeof + end_padding)!!;
-}
-
-macro Allocator.new_checked(&self, $Type, usz end_padding = 0) @nodiscard @deprecated("Use allocator::alloc_try")
-{
-	return ($Type*)self.alloc_checked($Type.sizeof + end_padding);
-}
-
-macro Allocator.new_clear(&self, $Type, usz end_padding = 0) @nodiscard @deprecated("Use allocator::new")
-{
-	return ($Type*)self.calloc_checked($Type.sizeof + end_padding)!!;
-}
-
-macro Allocator.new_clear_checked(&self, $Type, usz end_padding = 0) @nodiscard  @deprecated("Use allocator::new_try")
-{
-	return ($Type*)self.calloc_checked($Type.sizeof + end_padding);
-}
-macro Allocator.clone(&self, value) @deprecated("Use allocator::clone")
-{
-	var x = self.alloc($typeof(value));
-	*x = value;
-	return x;
-}
-
-fn void* Allocator.alloc(&self, usz size) @nodiscard @deprecated("Use allocator::malloc")
-{
-	return malloc(self, size);
-}
-fn void* Allocator.calloc(&self, usz size) @nodiscard @deprecated("Use allocator::calloc")
-{
-	return calloc(self, size);
-}
-fn void* Allocator.realloc(&self, void* ptr, usz new_size) @nodiscard @deprecated("Use allocator::realloc")
-{
-	return realloc(self, ptr, new_size);
-}
-
-fn void*! Allocator.alloc_aligned(&self, usz size, usz alignment, usz offset = 0) @deprecated("Use allocator::malloc_aligned")
-{
-	return malloc_aligned(self, size, alignment, 0);
-}
-
-fn void*! Allocator.calloc_aligned(&self, usz size, usz alignment, usz offset = 0) @deprecated("Use allocator::calloc_aligned")
-{
-	return calloc_aligned(self, size, alignment, 0);
-}
-
-fn void*! Allocator.realloc_aligned(&self, void* ptr, usz new_size, usz alignment = 0, usz offset = 0)  @deprecated("Use allocator::realloc_aligned")
-{
-	return realloc_aligned(self, ptr, new_size, alignment, 0);
-}
-
-fn void Allocator.free(&self, void* ptr) @deprecated("Use allocator::free")
-{
-	free(self, ptr);
-}
-fn void Allocator.free_aligned(&self, void* ptr) @deprecated("Use allocator::free_aligned")
-{
-	free_aligned(self, ptr);
+	return alignment;
 }
 
 
-/**
- * @require bytes > 0
- * @require alignment > 0
- * @require bytes <= isz.max
- **/
-macro void*! @aligned_alloc(#alloc_fn, usz bytes, usz alignment)
-{
-	if (alignment < void*.alignof) alignment = void*.alignof;
-	usz header = AlignedBlock.sizeof + alignment;
-	usz alignsize = bytes + header;
-	$if @typekind(#alloc_fn(bytes)) == OPTIONAL:
-		void* data = #alloc_fn(alignsize)!;
-	$else
-		void* data = #alloc_fn(alignsize);
-	$endif
-	void* mem = mem::aligned_pointer(data + AlignedBlock.sizeof, alignment);
-	AlignedBlock* desc = (AlignedBlock*)mem - 1;
-	assert(mem > data);
-	*desc = { bytes, data };
-	return mem;
-}
 
-struct AlignedBlock
-{
-	usz len;
-	void* start;
-}
-
-macro void! @aligned_free(#free_fn, void* old_pointer)
-{
-	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
-	$if @typekind(#free_fn(desc.start)) == OPTIONAL:
-	#free_fn(desc.start)!;
-	$else
-	#free_fn(desc.start);
-	$endif
-}
-
-/**
- * @require bytes > 0
- * @require alignment > 0
- **/
-macro void*! @aligned_realloc(#calloc_fn, #free_fn, void* old_pointer, usz bytes, usz alignment)
-{
-	AlignedBlock* desc = (AlignedBlock*)old_pointer - 1;
-	void* data_start = desc.start;
-	void* new_data = @aligned_alloc(#calloc_fn, bytes, alignment)!;
-	mem::copy(new_data, old_pointer, desc.len < bytes ? desc.len : bytes, 1, 1);
-	$if @typekind(#free_fn(data_start)) == OPTIONAL:
-	#free_fn(data_start)!;
-	$else
-	#free_fn(data_start);
-	$endif
-	return new_data;
-}
-
-
-// All allocators
-tlocal Allocator* thread_allocator @private = &allocator::LIBC_ALLOCATOR;
-tlocal TempAllocator* thread_temp_allocator @private = null;
-tlocal TempAllocator*[2] temp_allocator_pair @private;
-Allocator* temp_base_allocator @private = &allocator::LIBC_ALLOCATOR;
-
-macro TempAllocator* create_default_sized_temp_allocator(Allocator* allocator) @local
-{
-	$switch (env::MEMORY_ENV)
-	$case NORMAL:
-		return new_temp_allocator(1024 * 256, allocator)!!;
-	$case SMALL:
-		return new_temp_allocator(1024 * 16, allocator)!!;
-	$case TINY:
-		return new_temp_allocator(1024 * 2, allocator)!!;
-	$case NONE:
-		unreachable("Temp allocator must explicitly created when memory-env is set to 'none'.");
-	$endswitch
-}
-
-macro Allocator* heap() => thread_allocator;
-
-macro TempAllocator* temp()
-{
-	if (!thread_temp_allocator)
-	{
-		init_default_temp_allocators();
-	}
-	return thread_temp_allocator;
-}
-
-fn void init_default_temp_allocators() @private
-{
-	temp_allocator_pair[0] = create_default_sized_temp_allocator(temp_base_allocator);
-	temp_allocator_pair[1] = create_default_sized_temp_allocator(temp_base_allocator);
-	thread_temp_allocator = temp_allocator_pair[0];
-}
-
-fn TempAllocator *temp_allocator_next() @private
-{
-	if (!thread_temp_allocator)
-	{
-		init_default_temp_allocators();
-		return thread_temp_allocator;
-	}
-	usz index = thread_temp_allocator == temp_allocator_pair[0] ? 1 : 0;
-	return thread_temp_allocator = temp_allocator_pair[index];
-}

lib/std/core/mem_array.c3

@@ -0,0 +1,31 @@
+// Copyright (c) 2021-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::core::mem::array;
+
+/**
+ * @require usz.max / elements > $Type.sizeof
+ **/
+macro alloc($Type, usz elements) @deprecated => malloc($Type, elements);
+
+/**
+ * @require usz.max / elements > $Type.sizeof
+ **/
+macro talloc($Type, usz elements) @deprecated => tmalloc($Type, elements);
+
+/**
+ * @require (usz.max / elements > $Type.sizeof)
+ **/
+macro make($Type, usz elements, Allocator* using = mem::heap()) @deprecated
+{
+	return calloc($Type, elements, .using = using);
+}
+
+/**
+ * @require (usz.max / elements > $Type.sizeof)
+ **/
+macro tmake($Type, usz elements) @deprecated
+{
+	return tcalloc($Type, elements);
+}

lib/std/core/os/wasm_memory.c3

@@ -11,22 +11,22 @@ struct WasmMemory
 	uptr use;
 }
 
-fn char[]! WasmMemory.allocate_block(&self, usz bytes)
+fn char[]! WasmMemory.allocate_block(WasmMemory* this, usz bytes)
 {
-	if (!self.allocation)
+	if (!this.allocation)
 	{
-		self.allocation = $$wasm_memory_size(0) * WASM_BLOCK_SIZE;
+		this.allocation = $$wasm_memory_size(0) * WASM_BLOCK_SIZE;
 	}
-	isz bytes_required = bytes + self.use - self.allocation;
-	if (bytes_required <= 0)
+	isz bytes_required = bytes + this.use - this.allocation;
+    if (bytes_required <= 0)
 	{
-		defer self.use += bytes;
-		return ((char*)self.use)[:bytes];
+		defer this.use += bytes;
+		return ((char*)this.use)[:bytes];
 	}
 
 	usz blocks_required = (bytes_required + WASM_BLOCK_SIZE + 1) / WASM_BLOCK_SIZE;
-	if ($$wasm_memory_grow(0, blocks_required) == -1) return AllocationFailure.OUT_OF_MEMORY?;
-	self.allocation = $$wasm_memory_size(0) * WASM_BLOCK_SIZE;
-	defer self.use += bytes;
-	return ((char*)self.use)[:bytes];
+	if ($$wasm_memory_grow(0, blocks_required) == -1) return AllocationFailure.OUT_OF_MEMORY!;
+	this.allocation = $$wasm_memory_size(0) * WASM_BLOCK_SIZE;
+	defer this.use += bytes;
+	return ((char*)this.use)[:bytes];
 }

lib/std/core/private/cpu_detect.c3

@@ -1,258 +0,0 @@
-module std::core::cpudetect @if(env::X86 || env::X86_64);
-
-struct CpuId
-{
-	uint eax, ebx, ecx, edx;
-}
-fn CpuId x86_cpuid(uint eax, uint ecx = 0)
-{
-	int edx;
-	int ebx;
-	asm
-	{
-		movl $eax, eax;
-		movl $ecx, ecx;
-		cpuid;
-		movl eax, $eax;
-		movl ebx, $ebx;
-		movl ecx, $ecx;
-		movl edx, $edx;
-	}
-	return { eax, ebx, ecx, edx };
-}
-
-enum X86Feature
-{
-	ADX,
-	AES,
-	AMX_BF16,
-	AMX_COMPLEX,
-	AMX_FP16,
-	AMX_INT8,
-	AMX_TILE,
-	AVX,
-	AVX10_1_256,
-	AVX10_1_512,
-	AVX2,
-	AVX5124FMAPS,
-	AVX5124VNNIW,
-	AVX512BF16,
-	AVX512BITALG,
-	AVX512BW,
-	AVX512CD,
-	AVX512DQ,
-	AVX512ER,
-	AVX512F,
-	AVX512FP16,
-	AVX512IFMA,
-	AVX512PF,
-	AVX512VBMI,
-	AVX512VBMI2,
-	AVX512VL,
-	AVX512VNNI,
-	AVX512VP2INTERSECT,
-	AVX512VPOPCNTDQ,
-	AVXIFMA,
-	AVXNECONVERT,
-	AVXVNNI,
-	AVXVNNIINT16,
-	AVXVNNIINT8,
-	BMI,
-	BMI2,
-	CLDEMOTE,
-	CLFLUSHOPT,
-	CLWB,
-	CLZERO,
-	CMOV,
-	CMPCCXADD,
-	CMPXCHG16B,
-	CX8,
-	ENQCMD,
-	F16C,
-	FMA,
-	FMA4,
-	FSGSBASE,
-	FXSR,
-	GFNI,
-	HRESET,
-	INVPCID,
-	KL,
-	LWP,
-	LZCNT,
-	MMX,
-	MOVBE,
-	MOVDIR64B,
-	MOVDIRI,
-	MWAITX,
-	PCLMUL,
-	PCONFIG,
-	PKU,
-	POPCNT,
-	PREFETCHI,
-	PREFETCHWT1,
-	PRFCHW,
-	PTWRITE,
-	RAOINT,
-	RDPID,
-	RDPRU,
-	RDRND,
-	RDSEED,
-	RTM,
-	SAHF,
-	SERIALIZE,
-	SGX,
-	SHA,
-	SHA512,
-	SHSTK,
-	SM3,
-	SM4,
-	SSE,
-	SSE2,
-	SSE3,
-	SSE4_1,
-	SSE4_2,
-	SSE4_A,
-	SSSE3,
-	TBM,
-	TSXLDTRK,
-	UINTR,
-	USERMSR,
-	VAES,
-	VPCLMULQDQ,
-	WAITPKG,
-	WBNOINVD,
-	WIDEKL,
-	X87,
-	XOP,
-	XSAVE,
-	XSAVEC,
-	XSAVEOPT,
-	XSAVES,
-}
-
-uint128 x86_features;
-
-fn void add_feature_if_bit(X86Feature feature, uint register, int bit)
-{
-	if (register & 1U << bit) x86_features |= 1u128 << feature.ordinal;
-}
-
-fn void x86_initialize_cpu_features()
-{
-	uint max_level = x86_cpuid(0).eax;
-	CpuId feat = x86_cpuid(1);
-	CpuId leaf7 = max_level >= 8 ? x86_cpuid(7) : CpuId {};
-	CpuId leaf7s1 = leaf7.eax >= 1 ? x86_cpuid(7, 1) : CpuId {};
-	CpuId ext1 = x86_cpuid(0x80000000).eax >= 0x80000001 ? x86_cpuid(0x80000001) : CpuId {};
-	CpuId ext8 = x86_cpuid(0x80000000).eax >= 0x80000008 ? x86_cpuid(0x80000008) : CpuId {};
-	CpuId leaf_d = max_level >= 0xd ? x86_cpuid(0xd, 0x1) : CpuId {};
-	CpuId leaf_14 = max_level >= 0x14 ? x86_cpuid(0x14) : CpuId {};
-	CpuId leaf_19 = max_level >= 0x19 ? x86_cpuid(0x19) : CpuId {};
-	CpuId leaf_24 = max_level >= 0x24 ? x86_cpuid(0x24) : CpuId {};
-	add_feature_if_bit(ADX, leaf7.ebx, 19);
-	add_feature_if_bit(AES, feat.ecx, 25);
-	add_feature_if_bit(AMX_BF16, leaf7.edx, 22);
-	add_feature_if_bit(AMX_COMPLEX, leaf7s1.edx, 8);
-	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(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);
-	add_feature_if_bit(AVX2, leaf7.ebx, 5);
-	add_feature_if_bit(AVX5124FMAPS, leaf7.edx, 3);
-	add_feature_if_bit(AVX5124VNNIW, leaf7.edx, 2);
-	add_feature_if_bit(AVX512BF16, leaf7s1.eax, 5);
-	add_feature_if_bit(AVX512BITALG, leaf7.ecx, 12);
-	add_feature_if_bit(AVX512BW, leaf7.ebx, 30);
-	add_feature_if_bit(AVX512CD, leaf7.ebx, 28);
-	add_feature_if_bit(AVX512DQ, leaf7.ebx, 17);
-	add_feature_if_bit(AVX512ER, leaf7.ebx, 27);
-	add_feature_if_bit(AVX512F, leaf7.ebx, 16);
-	add_feature_if_bit(AVX512FP16, leaf7.edx, 23);
-	add_feature_if_bit(AVX512IFMA, leaf7.ebx, 21);
-	add_feature_if_bit(AVX512PF, leaf7.ebx, 26);
-	add_feature_if_bit(AVX512VBMI, leaf7.ecx, 1);
-	add_feature_if_bit(AVX512VBMI2, leaf7.ecx, 6);
-	add_feature_if_bit(AVX512VL, leaf7.ebx, 31);
-	add_feature_if_bit(AVX512VNNI, leaf7.ecx, 11);
-	add_feature_if_bit(AVX512VP2INTERSECT, leaf7.edx, 8);
-	add_feature_if_bit(AVX512VPOPCNTDQ, leaf7.ecx, 14);
-	add_feature_if_bit(AVXIFMA, leaf7s1.eax, 23);
-	add_feature_if_bit(AVXNECONVERT, leaf7s1.edx, 5);
-	add_feature_if_bit(AVXVNNI, leaf7s1.eax, 4);
-	add_feature_if_bit(AVXVNNIINT16, leaf7s1.edx, 10);
-	add_feature_if_bit(AVXVNNIINT8, leaf7s1.edx, 4);
-	add_feature_if_bit(BMI, leaf7.ebx, 3);
-	add_feature_if_bit(BMI2, leaf7.ebx, 8);
-	add_feature_if_bit(CLDEMOTE, leaf7.ecx, 25);
-	add_feature_if_bit(CLFLUSHOPT, leaf7.ebx, 23);
-	add_feature_if_bit(CLWB, leaf7.ebx, 24);
-	add_feature_if_bit(CLZERO, ext8.ecx, 0);
-	add_feature_if_bit(CMOV, feat.edx, 15);
-	add_feature_if_bit(CMPCCXADD, leaf7s1.eax, 7);
-	add_feature_if_bit(CMPXCHG16B, feat.ecx, 12);
-	add_feature_if_bit(CX8, feat.edx, 8);
-	add_feature_if_bit(ENQCMD, leaf7.ecx, 29);
-	add_feature_if_bit(F16C, feat.ecx, 29);
-	add_feature_if_bit(FMA, feat.ecx, 12);
-	add_feature_if_bit(FMA4, ext1.ecx, 16);
-	add_feature_if_bit(FSGSBASE, leaf7.ebx, 0);
-	add_feature_if_bit(FXSR, feat.edx, 24);
-	add_feature_if_bit(GFNI, leaf7.ecx, 8);
-	add_feature_if_bit(HRESET, leaf7s1.eax, 22);
-	add_feature_if_bit(INVPCID, leaf7.ebx, 10);
-	add_feature_if_bit(KL, leaf7.ecx, 23);
-	add_feature_if_bit(LWP, ext1.ecx, 15);
-	add_feature_if_bit(LZCNT, ext1.ecx, 5);
-	add_feature_if_bit(MMX, feat.edx, 23);
-	add_feature_if_bit(MOVBE, feat.ecx, 22);
-	add_feature_if_bit(MOVDIR64B, leaf7.ecx, 28);
-	add_feature_if_bit(MOVDIRI, leaf7.ecx, 27);
-	add_feature_if_bit(MWAITX, ext1.ecx, 29);
-	add_feature_if_bit(PCLMUL, feat.ecx, 1);
-	add_feature_if_bit(PCONFIG, leaf7.edx, 18);
-	add_feature_if_bit(PKU, leaf7.ecx, 4);
-	add_feature_if_bit(POPCNT, feat.ecx, 23);
-	add_feature_if_bit(PREFETCHI, leaf7s1.edx, 14);
-	add_feature_if_bit(PREFETCHWT1, leaf7.ecx, 0);
-	add_feature_if_bit(PRFCHW, ext1.ecx, 8);
-	add_feature_if_bit(PTWRITE, leaf_14.ebx, 4);
-	add_feature_if_bit(RAOINT, leaf7s1.eax, 3);
-	add_feature_if_bit(RDPID, leaf7.ecx, 22);
-	add_feature_if_bit(RDPRU, ext8.ecx, 4);
-	add_feature_if_bit(RDRND, feat.ecx, 30);
-	add_feature_if_bit(RDSEED, leaf7.ebx, 18);
-	add_feature_if_bit(RTM, leaf7.ebx, 11);
-	add_feature_if_bit(SAHF, ext1.ecx, 0);
-	add_feature_if_bit(SERIALIZE, leaf7.edx, 14);
-	add_feature_if_bit(SGX, leaf7.ebx, 2);
-	add_feature_if_bit(SHA, leaf7.ebx, 29);
-	add_feature_if_bit(SHA512, leaf7s1.eax, 0);
-	add_feature_if_bit(SHSTK, leaf7.ecx, 7);
-	add_feature_if_bit(SM3, leaf7s1.eax, 1);
-	add_feature_if_bit(SM4, leaf7s1.eax, 2);
-	add_feature_if_bit(SSE, feat.edx, 25);
-	add_feature_if_bit(SSE2, feat.edx, 26);
-	add_feature_if_bit(SSE3, feat.ecx, 0);
-	add_feature_if_bit(SSE4_1, feat.ecx, 19);
-	add_feature_if_bit(SSE4_2, feat.ecx, 20);
-	add_feature_if_bit(SSE4_A, ext1.ecx, 6);
-	add_feature_if_bit(SSSE3, feat.ecx, 9);
-	add_feature_if_bit(TBM, ext1.ecx, 21);
-	add_feature_if_bit(TSXLDTRK, leaf7.edx, 16);
-	add_feature_if_bit(UINTR, leaf7.edx, 5);
-	add_feature_if_bit(USERMSR, leaf7s1.edx, 15);
-	add_feature_if_bit(VAES, leaf7.ecx, 9);
-	add_feature_if_bit(VPCLMULQDQ, leaf7.ecx, 10);
-	add_feature_if_bit(WAITPKG, leaf7.ecx, 5);
-	add_feature_if_bit(WBNOINVD, ext8.ecx, 9);
-	add_feature_if_bit(WIDEKL, leaf_19.ebx, 2);
-	add_feature_if_bit(X87, feat.edx, 0);
-	add_feature_if_bit(XOP, ext1.ecx, 11);
-	add_feature_if_bit(XSAVE, feat.ecx, 26);
-	add_feature_if_bit(XSAVEC, leaf_d.eax, 1);
-	add_feature_if_bit(XSAVEOPT, leaf_d.eax, 0);
-	add_feature_if_bit(XSAVES, leaf_d.eax, 3);
-
-}

lib/std/core/private/macho_runtime.c3

@@ -1,254 +0,0 @@
-module std::core::machoruntime @if(env::DARWIN) @private;
-
-struct SegmentCommand64
-{
-	uint cmd;
-	uint cmdsize;
-	char[16] segname;
-	ulong vmaddr;
-	ulong vmsize;
-	ulong fileoff;
-	ulong filesize;
-	uint maxprot;
-	uint initprot;
-	uint nsects;
-	uint flags;
-}
-
-struct LoadCommand
-{
-	uint cmd;
-	uint cmdsize;
-}
-
-struct Section64
-{
-	char[16] sectname;
-	char[16] segname;
-	ulong addr;
-	ulong size;
-	uint offset;
-	uint align;
-	uint reloff;
-	uint nreloc;
-	uint flags;
-	uint reserved1;
-	uint reserved2;
-	uint reserved3;
-}
-
-struct MachHeader
-{
-	uint magic;
-	uint cputype;
-	uint cpusubtype;
-	uint filetype;
-	uint ncmds;
-	uint sizeofcmds;
-	uint flags;
-}
-
-struct MachHeader64
-{
-	inline MachHeader header;
-	uint reserved;
-}
-
-const LC_SEGMENT_64 = 0x19;
-
-fault MachoSearch
-{
-	NOT_FOUND
-}
-fn bool name_cmp(char* a, char[16]* b)
-{
-	for (usz i = 0; i < 16; i++)
-	{
-		if (a[i] != (*b)[i]) return false;
-		if (a[i] == '\0') return true;
-	}
-	return false;
-}
-
-fn SegmentCommand64*! find_segment(MachHeader* header, char* segname)
-{
-	LoadCommand* command = (void*)header + MachHeader64.sizeof;
-	for (uint i = 0; i < header.ncmds; i++)
-	{
-		if (command.cmd == LC_SEGMENT_64)
-		{
-			SegmentCommand64* segment = (SegmentCommand64*)command;
-			if (name_cmp(segname, &segment.segname)) return segment;
-		}
-		command = (void*)command + command.cmdsize;
-	}
-	return MachoSearch.NOT_FOUND?;
-}
-fn Section64*! find_section(SegmentCommand64* command, char* sectname)
-{
-	Section64* section = (void*)command + SegmentCommand64.sizeof;
-	for (uint i = 0; i < command.nsects; i++)
-	{
-		if (name_cmp(sectname, &section.sectname)) return section;
-		section++;
-	}
-	return MachoSearch.NOT_FOUND?;
-}
-
-macro find_segment_section_body(MachHeader* header, char* segname, char* sectname, $Type)
-{
-
-	Section64*! section = find_section(find_segment(header, segname), sectname);
-	if (catch section)
-	{
-		return $Type[] {};
-	}
-	$Type* ptr = (void*)header + section.offset;
-	return ptr[:section.size / $Type.sizeof];
-}
-
-def DyldCallback = fn void (MachHeader* mh, isz vmaddr_slide);
-
-extern fn void _dyld_register_func_for_add_image(DyldCallback);
-
-
-struct DlInfo
-{
-	char* dli_fname;
-	void* dli_fbase;
-	char* dli_sname;
-	void* dli_saddr;
-}
-
-extern fn void printf(char*, ...);
-extern fn int dladdr(MachHeader* mh, DlInfo* dlinfo);
-extern fn void* realloc(void* ptr, usz size);
-extern fn void* malloc(usz size);
-extern fn void free(void* ptr);
-
-def CallbackFn = fn void();
-struct Callback
-{
-	uint priority;
-	CallbackFn xtor;
-	Callback* next;
-}
-struct DynamicMethod
-{
-	void* fn_ptr;
-	char* sel;
-	union
-	{
-		DynamicMethod* next;
-		TypeId* type;
-	}
-}
-
-enum StartupState
-{
-	NOT_STARTED,
-	INIT,
-	RUN_CTORS,
-	READ_DYLIB,
-	RUN_DYLIB_CTORS,
-	RUN_DTORS,
-	SHUTDOWN
-}
-
-StartupState runtime_state = NOT_STARTED;
-
-Callback* ctor_first;
-Callback* dtor_first;
-
-fn void runtime_startup() @public @export("__c3_runtime_startup")
-{
-	if (runtime_state != NOT_STARTED) return;
-	runtime_state = INIT;
-	_dyld_register_func_for_add_image(&dl_reg_callback);
-	assert(runtime_state == INIT);
-	runtime_state = RUN_CTORS;
-	Callback* ctor = ctor_first;
-	while (ctor)
-	{
-		ctor.xtor();
-		ctor = ctor.next;
-	}
-	assert(runtime_state == RUN_CTORS);
-	runtime_state = READ_DYLIB;
-	ctor = null;
-}
-
-fn void runtime_finalize() @public @export("__c3_runtime_finalize")
-{
-	if (runtime_state != READ_DYLIB) return;
-	runtime_state = RUN_DTORS;
-	Callback* dtor = dtor_first;
-	while (dtor)
-	{
-		dtor.xtor();
-		dtor = dtor.next;
-	}
-	assert(runtime_state == RUN_DTORS);
-	runtime_state = SHUTDOWN;
-}
-
-fn void append_xxlizer(Callback** ref, Callback* cb)
-{
-	while (Callback* current = *ref, current)
-	{
-		if (current.priority > cb.priority)
-		{
-			cb.next = current;
-			break;
-		}
-		ref = &current.next;
-	}
-	*ref = cb;
-}
-
-struct TypeId
-{
-	char type;
-	TypeId* parentof;
-	DynamicMethod* dtable;
-	usz sizeof;
-	TypeId* inner;
-	usz len;
-	typeid[*] additional;
-}
-
-fn void dl_reg_callback(MachHeader* mh, isz vmaddr_slide)
-{
-	usz size = 0;
-	assert(runtime_state == INIT || runtime_state == READ_DYLIB, "State was %s", runtime_state);
-	foreach (&dm : find_segment_section_body(mh, "__DATA", "__c3_dynamic", DynamicMethod))
-	{
-		TypeId* type = dm.type;
-		dm.next = type.dtable;
-		type.dtable = dm;
-		DynamicMethod* m = dm;
-		while (m)
-		{
-			m = m.next;
-		}
-	}
-	foreach (&cb : find_segment_section_body(mh, "__DATA", "__c3dtor", Callback))
-	{
-		append_xxlizer(&dtor_first, cb);
-	}
-	foreach (&cb : find_segment_section_body(mh, "__DATA", "__c3ctor", Callback))
-	{
-		append_xxlizer(&ctor_first, cb);
-	}
-	if (runtime_state != READ_DYLIB) return;
-	runtime_state = RUN_DYLIB_CTORS;
-	Callback* ctor = ctor_first;
-	ctor_first = null;
-	while (ctor)
-	{
-		ctor.xtor();
-		ctor = ctor.next;
-	}
-	assert(runtime_state == RUN_DYLIB_CTORS);
-	runtime_state = READ_DYLIB;
-}

lib/std/core/private/main_stub.c3

@@ -7,11 +7,7 @@ macro usz _strlen(ptr) @private
 	return len;
 }
 
-macro int @main_to_err_main(#m, int, char**)
-{
-	if (catch #m()) return 1;
-	return 0;
-}
+macro int @main_to_err_main(#m, int, char**) => catch? #m() ? 1 : 0;
 macro int @main_to_int_main(#m, int, char**) => #m();
 macro int @main_to_void_main(#m, int, char**)
 {
@@ -21,7 +17,7 @@ macro int @main_to_void_main(#m, int, char**)
 
 macro String[] args_to_strings(int argc, char** argv) @private
 {
-	String[] list = mem::alloc_array(String, argc);
+	String[] list = malloc(String, argc);
 	for (int i = 0; i < argc; i++)
 	{
 		char* arg = argv[i];
@@ -36,8 +32,7 @@ macro int @main_to_err_main_args(#m, int argc, char** argv)
 {
 	String[] list = args_to_strings(argc, argv);
 	defer free(list.ptr);
-	if (catch #m(list)) return 1;
-	return 0;
+	return catch? #m(list) ? 1 : 0;
 }
 
 macro int @main_to_int_main_args(#m, int argc, char** argv)
@@ -55,7 +50,7 @@ macro int @main_to_void_main_args(#m, int argc, char** argv)
 	return 0;
 }
 
-module std::core::main_stub @if(env::WIN32);
+$if (env::OS_TYPE == OsType.WIN32)
 
 extern fn Char16** _win_command_line_to_argv_w(ushort* cmd_line, int* argc_ptr) @extern("CommandLineToArgvW");
 
@@ -68,12 +63,12 @@ macro String[] win_command_line_to_strings(ushort* cmd_line) @private
 
 macro String[] wargs_strings(int argc, Char16** argv) @private
 {
-	String[] list = mem::alloc_array(String, argc);
+	String[] list = malloc(String, argc);
 	for (int i = 0; i < argc; i++)
 	{
 		Char16* arg = argv[i];
 		Char16[] argstring = arg[:_strlen(arg)];
-		list[i] = string::new_from_utf16(argstring) ?? "?".copy();
+		list[i] = string::from_utf16(argstring) ?? "?".copy();
 	}
 	return list[:argc];
 }
@@ -84,11 +79,7 @@ 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)
-{
-	if (catch #m()) return 1;
-	return 0;
-}
+macro int @win_to_err_main_noargs(#m, void* handle, Char16* cmd_line, int show_cmd) => catch? #m() ? 1 : 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)
 {
@@ -100,15 +91,14 @@ macro int @win_to_err_main_args(#m, void* handle, Char16* cmd_line, int show_cmd
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
-	if (catch #m(args)) return 1;
-	return 0;
+    return catch? #m(args) ? 1 : 0;
 }
 
 macro int @win_to_int_main_args(#m, void* handle, Char16* cmd_line, int show_cmd)
 {
 	String[] args = win_command_line_to_strings(cmd_line);
 	defer release_wargs(args);
-	return #m(args);
+    return #m(args);
 }
 
 macro int @win_to_void_main_args(#m, void* handle, Char16* cmd_line, int show_cmd)
@@ -123,15 +113,14 @@ macro int @win_to_err_main(#m, void* 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;
-	return 0;
+    return catch? #m(handle, args, show_cmd) ? 1 : 0;
 }
 
 macro int @win_to_int_main(#m, void* 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, args, show_cmd);
 }
 
 macro int @win_to_void_main(#m, void* handle, Char16* cmd_line, int show_cmd)
@@ -146,15 +135,14 @@ macro int @wmain_to_err_main_args(#m, int argc, Char16** argv)
 {
 	String[] args = wargs_strings(argc, argv);
 	defer release_wargs(args);
-	if (catch #m(args)) return 1;
-	return 1;
+    return catch? #m(args) ? 1 : 0;
 }
 
 macro int @wmain_to_int_main_args(#m, int argc, Char16** argv)
 {
 	String[] args = wargs_strings(argc, argv);
 	defer release_wargs(args);
-	return #m(args);
+    return #m(args);
 }
 
 macro int @wmain_to_void_main_args(#m, int argc, Char16** argv)
@@ -164,3 +152,5 @@ macro int @wmain_to_void_main_args(#m, int argc, Char16** argv)
 	#m(args);
 	return 0;
 }
+
+$endif

lib/std/core/runtime.c3

@@ -2,249 +2,108 @@
 // 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::runtime;
-import libc, std::time, std::io, std::sort;
 
-struct AnyStruct
+struct VirtualAny
 {
-	void* ptr;
-	typeid type;
+    void* ptr;
+    typeid type_id;
 }
 
-struct SubArrayStruct
+struct VirtualContainer
 {
-	void* ptr;
-	usz len;
+    void* ptr;
+    void* impl_ptr;
 }
 
-def BenchmarkFn = fn void!();
-
-struct BenchmarkUnit
+struct SubArrayContainer
 {
-	String name;
-	BenchmarkFn func;
+    void* ptr;
+    usz len;
 }
 
-fn BenchmarkUnit[] benchmark_collection_create(Allocator* allocator = allocator::heap())
+struct VarArrayHeader
 {
-	BenchmarkFn[] fns = $$BENCHMARK_FNS;
-	String[] names = $$BENCHMARK_NAMES;
-	BenchmarkUnit[] benchmarks = allocator::alloc_array(allocator, BenchmarkUnit, names.len);
-	foreach (i, benchmark : fns)
-	{
-		benchmarks[i] = { names[i], fns[i] };
-	}
-	return benchmarks;
+    usz size;
+    usz capacity;
+    void *allocator;
 }
 
-const DEFAULT_BENCHMARK_WARMUP_ITERATIONS = 3;
-const DEFAULT_BENCHMARK_MAX_ITERATIONS = 10000;
+typedef TestFn = fn void!();
 
-uint benchmark_warmup_iterations @private = DEFAULT_BENCHMARK_WARMUP_ITERATIONS;
-uint benchmark_max_iterations @private = DEFAULT_BENCHMARK_MAX_ITERATIONS;
-
-fn void set_benchmark_warmup_iterations(uint value) @builtin
-{
-    benchmark_warmup_iterations = value;
-}
-
-fn void set_benchmark_max_iterations(uint value) @builtin
-{
-    assert(value > 0);
-    benchmark_max_iterations = value;
-}
-
-fn bool run_benchmarks(BenchmarkUnit[] benchmarks)
-{
-	int benchmarks_passed = 0;
-	int benchmark_count = benchmarks.len;
-	usz max_name;
-
-	foreach (&unit : benchmarks)
-	{
-		if (max_name < unit.name.len) max_name = unit.name.len;
-	}
-
-	usz len = max_name + 9;
-
-	DString name = dstring::temp_with_capacity(64);
-	name.append_repeat('-', len / 2);
-	name.append(" BENCHMARKS ");
-	name.append_repeat('-', len - len / 2);
-
-	io::printn(name);
-
-	name.clear();
-
-	long sys_clock_started;
-	long sys_clock_finished;
-	long sys_clocks;
-	Clock clock;
-	anyfault err;
-
-	foreach(unit : benchmarks)
-	{
-		defer name.clear();
-		name.appendf("Benchmarking %s ", unit.name);
-		name.append_repeat('.', max_name - unit.name.len + 2);
-		io::printf("%s ", name.str_view());
-
-		for (uint i = 0; i < benchmark_warmup_iterations; i++)
-		{
-			err = @catch(unit.func()) @inline;
-			@volatile_load(err);
-		}
-
-		clock = std::time::clock::now();
-		sys_clock_started = $$sysclock();
-
-		for (uint i = 0; i < benchmark_max_iterations; i++)
-		{
-			err = @catch(unit.func()) @inline;
-			@volatile_load(err);
-		}
-
-		sys_clock_finished = $$sysclock();
-		NanoDuration nano_seconds = clock.mark();
-		sys_clocks = sys_clock_finished - sys_clock_started;
-
-		if (err)
-		{
-			io::printfn("[failed] Failed due to: %s", err);
-			continue;
-		}
-
-		io::printfn("[ok] %.2f ns, %.2f CPU's clocks", (float)nano_seconds / benchmark_max_iterations, (float)sys_clocks / benchmark_max_iterations);
-		benchmarks_passed++;
-	}
-
-	io::printfn("\n%d benchmark%s run.\n", benchmark_count, benchmark_count > 1 ? "s" : "");
-	io::printfn("Benchmarks Result: %s. %d passed, %d failed.",
-		benchmarks_passed < benchmark_count ? "FAILED" : "ok",
-		benchmarks_passed,
-		benchmark_count - benchmarks_passed);
-
-	return benchmark_count == benchmarks_passed;
-}
-
-fn bool default_benchmark_runner()
-{
-	@pool()
-	{
-		return run_benchmarks(benchmark_collection_create(allocator::temp()));
-	};
-}
-
-def TestFn = fn void!();
-
-struct TestUnit
-{
-	String name;
-	TestFn func;
-}
-
-fn TestUnit[] test_collection_create(Allocator* allocator = allocator::heap())
-{
-	TestFn[] fns = $$TEST_FNS;
-	String[] names = $$TEST_NAMES;
-	TestUnit[] tests = allocator::alloc_array(allocator, TestUnit, names.len);
-	foreach (i, test : fns)
-	{
-		tests[i] = { names[i], fns[i] };
-	}
-	return tests;
-}
-
-struct TestContext
+struct TestRunner
 {
+	String[] test_names;
+	TestFn[] test_fns;
 	JmpBuf buf;
 }
 
-// Sort the tests by their name in ascending order.
-fn int cmp_test_unit(TestUnit a, TestUnit b)
+fn TestRunner test_runner_create()
 {
-	usz an = a.name.len;
-	usz bn = b.name.len;
-	if (an > bn) @swap(a, b);
-	foreach (i, ac : a.name)
-	{
-		char bc = b.name[i];
-		if (ac != bc) return an > bn ? bc - ac : ac - bc;
-	}
-	return (int)(an - bn);
+	return TestRunner {
+		.test_fns = $$TEST_FNS,
+		.test_names = $$TEST_NAMES,
+	};
 }
 
-TestContext* test_context @private;
+import libc;
 
+TestRunner* current_runner @private;
 fn void test_panic(String message, String file, String function, uint line)
 {
 	io::printn("[error]");
-	io::print("\n Error: ");
-	io::print(message);
-	io::printn();
+	io::printfn("\n Error: %s", message);
 	io::printfn("  - in %s %s:%s.\n", function, file, line);
-	libc::longjmp(&test_context.buf, 1);
+	libc::longjmp(&current_runner.buf, 1);
 }
 
-fn bool run_tests(TestUnit[] tests)
+fn bool TestRunner.run(TestRunner* runner)
 {
-	usz max_name;
-	foreach (&unit : tests)
-	{
-		if (max_name < unit.name.len) max_name = unit.name.len;
-	}
-	quicksort(tests, &cmp_test_unit);
-
-	TestContext context;
-	test_context = &context;
-
+	current_runner = runner;
 	PanicFn old_panic = builtin::panic;
 	defer builtin::panic = old_panic;
 	builtin::panic = &test_panic;
 	int tests_passed = 0;
-	int test_count = tests.len;
-	DString name = dstring::temp_with_capacity(64);
-	usz len = max_name + 9;
-	name.append_repeat('-', len / 2);
-	name.append(" TESTS ");
-	name.append_repeat('-', len - len / 2);
-	io::printn(name);
-	name.clear();
-	foreach(unit : tests)
+	int tests = runner.test_names.len;
+	io::printn("----- TESTS -----");
+	foreach(i, String name : runner.test_names)
 	{
-		defer name.clear();
-		name.appendf("Testing %s ", unit.name);
-		name.append_repeat('.', max_name - unit.name.len + 2);
-		io::printf("%s ", name.str_view());
-		if (libc::setjmp(&context.buf) == 0)
+		io::printf("Testing %s ... ", name);
+		if (libc::setjmp(&runner.buf) == 0)
 		{
-			if (catch err = unit.func())
+			if (catch err = runner.test_fns[i]())
 			{
-				io::printfn("[failed] Failed due to: %s", err);
+				io::printn("[failed]");
 				continue;
 			}
 			io::printn("[ok]");
 			tests_passed++;
 		}
 	}
-	io::printfn("\n%d test%s run.\n", test_count, test_count > 1 ? "s" : "");
-	io::printfn("Test Result: %s. %d passed, %d failed.",
-		tests_passed < test_count ? "FAILED" : "ok", tests_passed, test_count - tests_passed);
-	return test_count == tests_passed;
-}
-
-fn bool default_test_runner()
-{
-	@pool()
+	io::printfn("\n%d test(s) run.\n", tests);
+	io::print("Test Result: ");
+	if (tests_passed < tests)
 	{
-		return run_tests(test_collection_create(allocator::temp()));
-	};
+		io::print("FAILED");
+	}
+	else
+	{
+		io::print("ok");
+	}
+	io::printfn(". %d passed, %d failed.", tests_passed, tests - tests_passed);
+	return tests == tests_passed;
 }
 
-module std::core::runtime @if(WASM_NOLIBC);
+fn bool __run_default_test_runner()
+{
+	return test_runner_create().run();
+}
+
+$if (!env::COMPILER_LIBC_AVAILABLE && env::ARCH_TYPE == ArchType.WASM32 || env::ARCH_TYPE == ArchType.WASM64)
 
 extern fn void __wasm_call_ctors();
 fn void wasm_initialize() @extern("_initialize") @wasm
 {
 	// The linker synthesizes this to call constructors.
 	__wasm_call_ctors();
-}
+}
+$endif

lib/std/core/str.c3

@@ -0,0 +1,259 @@
+module std::core::str;
+
+fn VarString join(String[] s, String joiner)
+{
+	if (!s.len) return (VarString)null;
+	usz total_size = joiner.len * s.len;
+	foreach (String* &str : s)
+	{
+		total_size += str.len;
+	}
+	VarString res = string::new_with_capacity(total_size);
+	res.append(s[0]);
+	foreach (String* &str : s[1..])
+	{
+		res.append(joiner);
+		res.append(*str);
+	}
+	return res;
+}
+
+macro bool char_in_set(char c, String set)
+{
+	foreach (ch : set)
+	{
+		if (ch == c) return true;
+	}
+	return false;
+}
+
+macro char_is_space_tab(char c) @private
+{
+	return c == ' ' || c == '\t';
+}
+
+macro to_integer($Type, String string) @private
+{
+	usz len = string.len;
+	usz index = 0;
+	char* ptr = string.ptr;
+	while (index < len && char_is_space_tab(ptr[index])) index++;
+	if (len == index) return NumberConversion.EMPTY_STRING!;
+	bool is_negative;
+	switch (string[index])
+	{
+		case '-':
+			if ($Type.min == 0) return NumberConversion.NEGATIVE_VALUE!;
+			is_negative = true;
+			index++;
+		case '+':
+			index++;
+		default:
+			break;
+	}
+	if (len == index) return NumberConversion.MALFORMED_INTEGER!;
+	$Type base = 10;
+	if (string[index] == '0')
+	{
+		index++;
+		if (index == len) return ($Type)0;
+		switch (string[index])
+		{
+			case 'x':
+			case 'X':
+				base = 16;
+				index++;
+			case 'b':
+			case 'B':
+				base = 2;
+				index++;
+			case 'o':
+			case 'O':
+				base = 8;
+				index++;
+			default:
+				break;
+		}
+		if (len == index) return NumberConversion.MALFORMED_INTEGER!;
+	}
+	$Type value = 0;
+	while (index != len)
+	{
+		char c = {|
+			char ch = string[index++];
+			if (base != 16 || ch < 'A') return (char)(ch - '0');
+			if (ch <= 'F') return (char)(ch - 'A');
+			if (ch < 'a') return NumberConversion.MALFORMED_INTEGER!;
+			if (ch > 'f') return NumberConversion.MALFORMED_INTEGER!;
+			return (char)(ch - 'a');
+		|}?;
+		if (c >= base) return NumberConversion.MALFORMED_INTEGER!;
+		value = {|
+			if (is_negative)
+			{
+				$Type new_value = value * base - c;
+				if (new_value > value) return NumberConversion.INTEGER_OVERFLOW!;
+				return new_value;
+			}
+			$Type new_value = value * base + c;
+			if (new_value < value) return NumberConversion.INTEGER_OVERFLOW!;
+			return new_value;
+		|}?;
+	}
+	return value;
+}
+
+fn float! to_float(String string) => floatparse(string, float);
+fn double! to_double(String string) => floatparse(string, double);
+fn int128! to_int128(String string) => to_integer(int128, string);
+fn long! to_long(String string) => to_integer(long, string);
+fn int! to_int(String string) => to_integer(int, string);
+fn short! to_short(String string) => to_integer(short, string);
+fn ichar! to_ichar(String string) => to_integer(ichar, string);
+
+fn uint128! to_uint128(String str) => to_integer(uint128, str);
+fn ulong! to_ulong(String str) => to_integer(ulong, str);
+fn uint! to_uint(String str) => to_integer(uint, str);
+fn ushort! to_ushort(String str) => to_integer(ushort, str);
+fn char! to_uchar(String str) => to_integer(char, str);
+
+fn String trim(String string, String to_trim = "\t\n\r ") @deprecated => string.trim(to_trim);
+
+fn bool starts_with(String s, String needle) @deprecated => s.starts_with(needle);
+
+fn String[] tsplit(String s, String needle) @deprecated => s.split(needle, .using = mem::temp()) @inline;
+fn String[] split(String s, String needle, Allocator* using = mem::heap()) @deprecated => s.split(needle, .using = using);
+fn usz! rindex_of(String s, String needle) @deprecated => s.rindex_of(needle);
+fn usz! index_of(String s, String needle) @deprecated => s.index_of(needle);
+
+fn ZString String.zstrcopy(String s, Allocator* using = mem::heap()) @deprecated => s.zstr_copy(using);
+fn ZString String.zstrtcopy(String s) @deprecated => s.zstr_tcopy();
+
+fn ZString copy_zstring(String s, Allocator* using = mem::heap()) @deprecated => s.zstr_copy(using);
+fn String copyz(String s, Allocator* using = mem::heap()) @deprecated => s.copy(using);
+fn ZString tcopy_zstring(String s) @deprecated => s.zstr_tcopy();
+
+fn bool compare(String a, String b)
+{
+	if (a.len != b.len) return false;
+	foreach (i, c : a)
+	{
+		if (c != b[i]) return false;
+	}
+	return true;
+}
+
+fault UnicodeResult
+{
+	INVALID_UTF8,
+	INVALID_UTF16,
+	CONVERSION_FAILED,
+}
+
+fn usz utf8_codepoints(String utf8)
+{
+	usz len = 0;
+	foreach (char c : utf8)
+	{
+		if (c & 0xC0 != 0x80) len++;
+	}
+	return len;
+}
+
+fn Char32[]! utf8to32(String utf8, Allocator* using = mem::heap())
+{
+	usz codepoints = conv::utf8_codepoints(utf8);
+	Char32* data = malloc_checked(Char32, codepoints + 1, .using = using)?;
+	conv::utf8to32_unsafe(utf8, data)?;
+	data[codepoints] = 0;
+	return data[:codepoints];
+}
+
+fn String utf32to8(Char32[] utf32, Allocator* using = mem::heap())
+{
+	usz len = conv::utf8len_for_utf32(utf32);
+	char* data = malloc_checked(len + 1, .using = using)!!;
+	conv::utf32to8_unsafe(utf32, data);
+	data[len] = 0;
+	return (String)data[:len];
+}
+
+fn Char16[]! utf8to16(String utf8, Allocator* using = mem::heap())
+{
+	usz len16 = conv::utf16len_for_utf8(utf8);
+	Char16* data = malloc_checked(Char16, len16 + 1, .using = using)?;
+	conv::utf8to16_unsafe(utf8, data)?;
+	data[len16] = 0;
+	return data[:len16];
+}
+
+
+fn String! utf16to8(Char16[] utf16, Allocator* using = mem::heap())
+{
+	usz len = conv::utf8len_for_utf16(utf16);
+	char* data = malloc_checked(len + 1, .using = using)?;
+	conv::utf16to8_unsafe(utf16, data)?;
+	data[len] = 0;
+	return (String)data[:len];
+}
+
+fn String copy(String s, Allocator* using = mem::heap()) @deprecated
+{
+    usz len = s.len;
+    ZString str_copy = s.zstr_copy(using) @inline;
+    return (String)str_copy[:len];
+}
+
+fn String tcopy(String s) @deprecated
+{
+    usz len = s.len;
+    ZString str_copy = s.zstr_tcopy() @inline;
+    return (String)str_copy[:len];
+}
+
+fn String tconcat(String s1, String s2)
+{
+    usz full_len = s1.len + s2.len;
+    char* str = tmalloc(full_len + 1);
+    usz s1_len = s1.len;
+    mem::copy(str, s1.ptr, s1_len);
+    mem::copy(str + s1_len, s2.ptr, s2.len);
+    str[full_len] = 0;
+    return (String)str[:full_len];
+}
+
+fn String concat(String s1, String s2)
+{
+    usz full_len = s1.len + s2.len;
+    char* str = malloc(full_len + 1);
+    usz s1_len = s1.len;
+    mem::copy(str, s1.ptr, s1_len);
+    mem::copy(str + s1_len, s2.ptr, s2.len);
+    str[full_len] = 0;
+    return (String)str[:full_len];
+}
+
+fn String ZString.as_str(ZString str)
+{
+	return (String)((char*)str)[:str.len()];
+}
+
+fn usz ZString.char_len(ZString str)
+{
+	usz len = 0;
+	char* ptr = (char*)str;
+	while (char c = ptr++[0])
+	{
+		if (c & 0xC0 != 0x80) len++;
+	}
+	return len;
+}
+
+fn usz ZString.len(ZString str)
+{
+	usz len = 0;
+    char* ptr = (char*)str;
+    while (char c = ptr++[0]) len++;
+    return len;
+}
+

lib/std/core/string.c3

@@ -1,17 +1,8 @@
 module std::core::string;
-import std::ascii;
 
-distinct ZString = inline char*;
-distinct WString = inline Char16*;
-def Char32 = uint;
-def Char16 = ushort;
-
-fault UnicodeResult
-{
-	INVALID_UTF8,
-	INVALID_UTF16,
-	CONVERSION_FAILED,
-}
+typedef ZString = distinct inline char*;
+typedef Char32 = uint;
+typedef Char16 = ushort;
 
 const uint SURROGATE_OFFSET @private = 0x10000;
 const uint SURROGATE_GENERIC_MASK @private = 0xF800;
@@ -31,23 +22,24 @@ fault NumberConversion
 	FLOAT_OUT_OF_RANGE,
 }
 
-macro String tformat(String fmt, ...)
+macro String printf(String fmt, ..., Allocator* using = mem::heap())
 {
-	DString str = dstring::temp_with_capacity(fmt.len + $vacount * 8);
-	str.appendf(fmt, $vasplat());
-	return str.str_view();
-}
-
-macro String new_format(String fmt, ..., Allocator* allocator = allocator::heap())
-{
-	@pool(allocator)
+	@stack_mem(256; Allocator* mem)
 	{
-		DString str = dstring::temp_with_capacity(fmt.len + $vacount * 8);
-		str.appendf(fmt, $vasplat());
-		return str.copy_str(allocator);
+		DString str;
+		str.init(.using = mem);
+		str.printf(fmt, $vasplat());
+		return str.copy_str(using);
 	};
 }
 
+macro String tprintf(String fmt, ...)
+{
+	DString str;
+	str.tinit();
+	str.printf(fmt, $vasplat());
+	return str.str();
+}
 
 macro bool char_in_set(char c, String set)
 {
@@ -55,36 +47,11 @@ macro bool char_in_set(char c, String set)
 	return false;
 }
 
-fn String join_new(String[] s, String joiner, Allocator* allocator = allocator::heap())
-{
-	if (!s)
-	{
-		return (String)allocator::new_array(allocator, char, 2)[:0];
-	}
-
-	usz total_size = joiner.len * s.len;
-	foreach (String* &str : s)
-	{
-		total_size += str.len;
-	}
-	@pool(allocator)
-	{
-		DString res = dstring::temp_with_capacity(total_size);
-		res.append(s[0]);
-		foreach (String* &str : s[1..])
-		{
-			res.append(joiner);
-			res.append(*str);
-		}
-		return res.copy_str(allocator);
-	};
-}
-
 /**
  * @param [in] string
  * @param [in] to_trim
  **/
-fn String String.trim(string, String to_trim = "\t\n\r ")
+fn String String.trim(String string, String to_trim = "\t\n\r ")
 {
 	usz start = 0;
 	usz len = string.len;
@@ -99,7 +66,7 @@ fn String String.trim(string, String to_trim = "\t\n\r ")
  * @param [in] string
  * @param [in] needle
  **/
-fn bool String.starts_with(string, String needle)
+fn bool String.starts_with(String string, String needle)
 {
 	if (needle.len > string.len) return false;
 	if (!needle.len) return true;
@@ -110,7 +77,7 @@ fn bool String.starts_with(string, String needle)
  * @param [in] string
  * @param [in] needle
  **/
-fn bool String.ends_with(string, String needle)
+fn bool String.ends_with(String string, String needle)
 {
 	if (needle.len > string.len) return false;
 	if (!needle.len) return true;
@@ -123,7 +90,7 @@ fn bool String.ends_with(string, String needle)
  * @param [in] string
  * @param [in] needle
  **/
-fn String String.strip(string, String needle)
+fn String String.strip(String string, String needle)
 {
 	if (!needle.len || !string.starts_with(needle)) return string;
 	return string[needle.len..];
@@ -135,7 +102,7 @@ fn String String.strip(string, String needle)
  * @param [in] string
  * @param [in] needle
  **/
-fn String String.strip_end(string, String needle)
+fn String String.strip_end(String string, String needle)
 {
 	if (!needle.len || !string.ends_with(needle)) return string;
 	// Note that this is the safe way if we want to support zero length.
@@ -148,20 +115,20 @@ fn String String.strip_end(string, String needle)
  *
  * @param [in] s
  * @param [in] needle
- * @param [&inout] allocator "The allocator, defaults to the heap allocator"
+ * @param [&inout] using "The allocator, defaults to the heap allocator"
  * @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.split(s, String needle, usz max = 0, Allocator* allocator = allocator::heap())
+fn String[] String.split(String s, String needle, usz max = 0, Allocator* using = mem::heap())
 {
 	usz capacity = 16;
 	usz i = 0;
-	String* holder = allocator::alloc_array(allocator, String, capacity);
+	String* holder = malloc(String, capacity, .using = using);
 	bool no_more = false;
 	while (!no_more)
 	{
-		usz! index = i == max - 1 ? SearchResult.MISSING? : s.index_of(needle);
+		usz! index = i == max - 1 ? SearchResult.MISSING! : s.index_of(needle);
 		String res @noinit;
 		if (try index)
 		{
@@ -176,7 +143,7 @@ fn String[] String.split(s, String needle, usz max = 0, Allocator* allocator = a
 		if (i == capacity)
 		{
 			capacity *= 2;
-			holder = allocator::realloc(allocator, holder, String.sizeof * capacity);
+			holder = realloc(holder, String.sizeof * capacity, .using = using);
 		}
 		holder[i++] = res;
 	}
@@ -191,50 +158,9 @@ fn String[] String.split(s, String needle, usz max = 0, Allocator* allocator = a
  * @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)
+fn String[] String.tsplit(String s, String needle, usz max = 0)
 {
-	return s.split(needle, max, allocator::temp()) @inline;
-}
-
-fn bool String.contains(s, String needle)
-{
-	return @ok(s.index_of(needle));
-}
-
-/**
- * Find the index of the first incidence of a string.
- *
- * @param [in] s
- * @pure
- * @ensure return < s.len
- * @return "the index of the needle"
- * @return! SearchResult.MISSING "if the needle cannot be found"
- **/
-fn usz! String.index_of_char(s, char needle)
-{
-	foreach (i, c : s)
-	{
-		if (c == needle) return i;
-	}
-	return SearchResult.MISSING?;
-}
-
-/**
- * Find the index of the first incidence of a string.
- *
- * @param [in] s
- * @pure
- * @ensure return < s.len
- * @return "the index of the needle"
- * @return! SearchResult.MISSING "if the needle cannot be found"
- **/
-fn usz! String.rindex_of_char(s, char needle)
-{
-	foreach_r (i, c : s)
-	{
-		if (c == needle) return i;
-	}
-	return SearchResult.MISSING?;
+	return s.split(needle, max, mem::temp()) @inline;
 }
 
 /**
@@ -244,22 +170,31 @@ fn usz! String.rindex_of_char(s, char needle)
  * @param [in] needle
  * @pure
  * @ensure return < s.len
- * @require needle.len > 0 : "The needle must be len 1 or more"
- * @return "the index of the needle"
- * @return! SearchResult.MISSING "if the needle cannot be found"
+ * @require needle.len > 0 "The needle must be len 1 or more"
  **/
-fn usz! String.index_of(s, String needle)
+fn usz! String.index_of(String s, String needle)
 {
+	usz match = 0;
 	usz needed = needle.len;
-	if (needed > 0 && s.len >= needed)
+	usz index_start = 0;
+	char search = needle[0];
+	foreach (usz i, char c : s)
 	{
-		char first = needle[0];
-		foreach (i, c: s[..^needed])
+		if (c == search)
 		{
-			if (c == first && s[i:needed] == needle) return i;
+			if (!match) index_start = i;
+			match++;
+			if (match == needed) return index_start;
+			search = needle[match];
+			continue;
+		}
+		if (match)
+		{
+			match = 0;
+			search = needle[0];
 		}
 	}
-	return SearchResult.MISSING?;
+	return SearchResult.MISSING!;
 }
 
 /**
@@ -270,352 +205,88 @@ fn usz! String.index_of(s, String needle)
  * @pure
  * @ensure return < s.len
  * @require needle.len > 0 "The needle must be len 1 or more"
- * @return "the index of the needle"
- * @return! SearchResult.MISSING "if the needle cannot be found"
  **/
-fn usz! String.rindex_of(s, String needle)
+fn usz! String.rindex_of(String s, String needle)
 {
+	usz match = 0;
 	usz needed = needle.len;
-	if (needed > 0 && s.len >= needed)
+	usz index_start = 0;
+	char search = needle[^1];
+	foreach_r (usz i, char c : s)
 	{
-		char first = needle[0];
-		foreach_r (i, c: s[..^needed])
+		if (c == search)
 		{
-			if (c == first && s[i:needed] == needle) return i;
+			if (!match) index_start = i;
+			match++;
+			if (match == needed) return index_start - needle.len + 1;
+			search = needle[^(match + 1)];
+			continue;
+		}
+		if (match)
+		{
+			match = 0;
+			search = needle[^1];
 		}
 	}
-	return SearchResult.MISSING?;
+	return SearchResult.MISSING!;
 }
 
-fn String ZString.str_view(str)
+fn ZString String.zstr_copy(String s, Allocator* using = mem::heap())
 {
-	return (String)(str[:str.len()]);
+    usz len = s.len;
+    char* str = malloc(len + 1, .using = using);
+    mem::copy(str, s.ptr, len);
+    str[len] = 0;
+    return (ZString)str;
 }
 
-fn usz ZString.char_len(str)
+fn String String.concat(String s1, String s2, Allocator* using = mem::heap())
 {
-	usz len = 0;
-	char* ptr = (char*)str;
-	while (char c = ptr++[0])
-	{
-		if (c & 0xC0 != 0x80) len++;
-	}
-	return len;
+    usz full_len = s1.len + s2.len;
+    char* str = malloc(full_len + 1, .using = using);
+    usz s1_len = s1.len;
+    mem::copy(str, s1.ptr, s1_len);
+    mem::copy(str + s1_len, s2.ptr, s2.len);
+    str[full_len] = 0;
+    return (String)str[:full_len];
 }
 
-fn usz ZString.len(str)
+fn String String.tconcat(String s1, String s2) => s1.concat(s2, mem::temp());
+
+
+fn ZString String.zstr_tcopy(String s) => s.zstr_copy(mem::temp()) @inline;
+
+fn String String.copy(String s, Allocator* using = mem::heap())
 {
-	usz len = 0;
-	char* ptr = (char*)str;
-	while (char c = ptr++[0]) len++;
-	return len;
+    usz len = s.len;
+    char* str = malloc(len + 1, .using = using);
+    mem::copy(str, s.ptr, len);
+    str[len] = 0;
+    return (String)str[:len];
 }
 
+fn String String.tcopy(String s) => s.copy(mem::temp()) @inline;
 
-fn ZString String.zstr_copy(s, Allocator* allocator = allocator::heap())
-{
-	usz len = s.len;
-	char* str = allocator::malloc(allocator, len + 1);
-	mem::copy(str, s.ptr, len);
-	str[len] = 0;
-	return (ZString)str;
-}
+fn String ZString.copy(ZString z, Allocator* using = mem::heap()) => z.as_str().copy(using) @inline;
+fn String ZString.tcopy(ZString z) => z.as_str().copy(mem::temp()) @inline;
 
-fn String String.concat(s1, String s2, Allocator* allocator = allocator::heap())
-{
-	usz full_len = s1.len + s2.len;
-	char* str = allocator::malloc(allocator, full_len + 1);
-	usz s1_len = s1.len;
-	mem::copy(str, s1.ptr, s1_len);
-	mem::copy(str + s1_len, s2.ptr, s2.len);
-	str[full_len] = 0;
-	return (String)str[:full_len];
-}
-
-fn String String.tconcat(s1, String s2) => s1.concat(s2, allocator::temp());
-
-
-fn ZString String.zstr_tcopy(s) => s.zstr_copy(allocator::temp()) @inline;
-
-fn String String.copy(s, Allocator* allocator = allocator::heap())
-{
-	usz len = s.len;
-	char* str = allocator::malloc(allocator, len + 1);
-	mem::copy(str, s.ptr, len);
-	str[len] = 0;
-	return (String)str[:len];
-}
-
-fn void String.free(&s, Allocator* allocator = allocator::heap())
-{
-	if (!s.len) return;
-	allocator::free(allocator, s.ptr);
-	*s = "";
-}
-
-fn String String.tcopy(s) => s.copy(allocator::temp()) @inline;
-
-fn String ZString.copy(z, Allocator* allocator = allocator::temp())
-{
-	return z.str_view().copy(allocator) @inline;
-}
-
-fn String ZString.tcopy(z)
-{
-	return z.str_view().copy(allocator::temp()) @inline;
-}
-
-/**
- * Convert an UTF-8 string to UTF-16
- * @return "The UTF-16 string as a slice, allocated using the given allocator"
- * @return! UnicodeResult.INVALID_UTF8 "If the string contained an invalid UTF-8 sequence"
- * @return! AllocationFailure "If allocation of the string fails"
- **/
-fn Char16[]! String.to_new_utf16(s, Allocator* allocator = allocator::heap())
+fn Char16[]! String.to_utf16(String s, Allocator* using = mem::heap())
 {
 	usz len16 = conv::utf16len_for_utf8(s);
-	Char16* data = allocator::alloc_array_try(allocator, Char16, len16 + 1)!;
-	conv::utf8to16_unsafe(s, data)!;
+	Char16* data = malloc_checked(Char16, len16 + 1, .using = using)?;
+	conv::utf8to16_unsafe(s, data)?;
 	data[len16] = 0;
 	return data[:len16];
 }
 
-/**
- * Convert an UTF-8 string to UTF-16
- * @return "The UTF-16 string as a slice, allocated using the given allocator"
- * @return! UnicodeResult.INVALID_UTF8 "If the string contained an invalid UTF-8 sequence"
- * @return! AllocationFailure "If allocation of the string fails"
- **/
-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())
-{
-	return (WString)s.to_new_utf16(allocator).ptr;
-}
-
-fn WString! String.to_temp_wstring(s)
-{
-	return (WString)s.to_temp_utf16().ptr;
-}
-
-fn Char32[]! String.to_new_utf32(s, Allocator* allocator = allocator::heap())
-{
-	usz codepoints = conv::utf8_codepoints(s);
-	Char32* data = allocator::alloc_array_try(allocator, Char32, codepoints + 1)!;
-	conv::utf8to32_unsafe(s, data)!;
-	data[codepoints] = 0;
-	return data[:codepoints];
-}
-
-fn Char32[]! String.to_temp_utf32(s)
-{
-	return s.to_new_utf32(allocator::temp());
-}
-
-fn void String.convert_ascii_to_lower(s)
-{
-	foreach (&c : s) if (c.is_upper()) *c += 'a' - 'A';
-}
-
-fn String String.new_ascii_to_lower(s, Allocator* allocator = allocator::heap())
-{
-	String copy = s.copy(allocator);
-	copy.convert_ascii_to_lower();
-	return copy;
-}
-
-fn String String.temp_ascii_to_lower(s, Allocator* allocator = allocator::heap())
-{
-	return s.new_ascii_to_lower(allocator::temp());
-}
-
-fn void String.convert_ascii_to_upper(s)
-{
-	foreach (&c : s) if (c.is_lower()) *c -= 'a' - 'A';
-}
-
-fn String String.new_ascii_to_upper(s, Allocator* allocator = allocator::heap())
-{
-	String copy = s.copy(allocator);
-	copy.convert_ascii_to_upper();
-	return copy;
-}
-
-fn StringIterator String.iterator(s)
-{
-	return { s, 0 };
-}
-
-fn String String.temp_ascii_to_upper(s)
-{
-	return s.new_ascii_to_upper(allocator::temp());
-}
-
-fn String! new_from_utf32(Char32[] utf32, Allocator* allocator = allocator::heap())
-{
-	usz len = conv::utf8len_for_utf32(utf32);
-	char* data = allocator::malloc_try(allocator, len + 1)!;
-	defer catch allocator::free(allocator, data);
-	conv::utf32to8_unsafe(utf32, data);
-	data[len] = 0;
-	return (String)data[:len];
-}
-
-fn String! new_from_utf16(Char16[] utf16, Allocator* allocator = allocator::heap())
+fn String! from_utf16(Char16[] utf16, Allocator* using = mem::heap())
 {
 	usz len = conv::utf8len_for_utf16(utf16);
-	char* data = allocator::malloc_try(allocator, len + 1)!;
-	defer catch allocator::free(allocator, data);
-	conv::utf16to8_unsafe(utf16, data)!;
+	char* data = malloc_checked(len + 1, .using = using)?;
+	conv::utf16to8_unsafe(utf16, data)?;
 	data[len] = 0;
 	return (String)data[:len];
 }
 
-fn String! new_from_wstring(WString wstring, Allocator* allocator = allocator::heap())
-{
-	usz utf16_len;
-	while (wstring[utf16_len] != 0) utf16_len++;
-	Char16[] utf16 = wstring[:utf16_len];
-	return new_from_utf16(utf16, allocator);
-}
-
-fn String! temp_from_wstring(WString wstring) => new_from_wstring(wstring, allocator::temp()) @inline;
-fn String! temp_from_utf16(Char16[] utf16) => new_from_utf16(utf16, allocator::temp()) @inline;
-
-fn usz String.utf8_codepoints(s)
-{
-	usz len = 0;
-	foreach (char c : s)
-	{
-		if (c & 0xC0 != 0x80) len++;
-	}
-	return len;
-}
-
-
-/**
- * @require (base <= 10 && base > 1) || base == 16 : "Unsupported base"
- **/
-macro String.to_integer(string, $Type, int base = 10)
-{
-	usz len = string.len;
-	usz index = 0;
-	char* ptr = string.ptr;
-	while (index < len && ascii::is_blank_m(ptr[index])) index++;
-	if (len == index) return NumberConversion.EMPTY_STRING?;
-	bool is_negative;
-	switch (string[index])
-	{
-		case '-':
-			if ($Type.min == 0) return NumberConversion.NEGATIVE_VALUE?;
-			is_negative = true;
-			index++;
-		case '+':
-			index++;
-		default:
-			break;
-	}
-	if (len == index) return NumberConversion.MALFORMED_INTEGER?;
-	$Type base_used = ($Type)base;
-	if (string[index] == '0' && base == 10)
-	{
-		index++;
-		if (index == len) return ($Type)0;
-		switch (string[index])
-		{
-			case 'x':
-			case 'X':
-				base_used = 16;
-				index++;
-			case 'b':
-			case 'B':
-				base_used = 2;
-				index++;
-			case 'o':
-			case 'O':
-				base_used = 8;
-				index++;
-			default:
-				break;
-		}
-		if (len == index) return NumberConversion.MALFORMED_INTEGER?;
-	}
-	$Type value = 0;
-	while (index != len)
-	{
-		char c = {|
-			char ch = string[index++];
-			if (base_used != 16 || ch < 'A') return (char)(ch - '0');
-			if (ch <= 'F') return (char)(ch - 'A' + 10);
-			if (ch < 'a') return NumberConversion.MALFORMED_INTEGER?;
-			if (ch > 'f') return NumberConversion.MALFORMED_INTEGER?;
-			return (char)(ch - 'a' + 10);
-		|}!;
-		if (c >= base_used) return NumberConversion.MALFORMED_INTEGER?;
-		value = {|
-			if (is_negative)
-			{
-				$Type new_value = value * base_used - c;
-				if (new_value > value) return NumberConversion.INTEGER_OVERFLOW?;
-				return new_value;
-			}
-			$Type new_value = value * base_used + c;
-			if (new_value < value) return NumberConversion.INTEGER_OVERFLOW?;
-			return new_value;
-		|}!;
-	}
-	return value;
-}
-
-fn int128! String.to_int128(s, int base = 10) => s.to_integer(int128, base);
-fn long! String.to_long(s, int base = 10) => s.to_integer(long, base);
-fn int! String.to_int(s, int base = 10) => s.to_integer(int, base);
-fn short! String.to_short(s, int base = 10) => s.to_integer(short, base);
-fn ichar! String.to_ichar(s, int base = 10) => s.to_integer(ichar, base);
-
-fn uint128! String.to_uint128(s, int base = 10) => s.to_integer(uint128, base);
-fn ulong! String.to_ulong(s, int base = 10) => s.to_integer(ulong, base);
-fn uint! String.to_uint(s, int base = 10) => s.to_integer(uint, base);
-fn ushort! String.to_ushort(s, int base = 10) => s.to_integer(ushort, base);
-fn char! String.to_uchar(s, int base = 10) => s.to_integer(char, base);
-
-fn double! String.to_double(s) => s.to_real(double);
-fn float! String.to_float(s) => s.to_real(float);
-
-fn Splitter String.splitter(self, String split)
-{
-	return Splitter { self, split, 0 };
-}
-
-struct Splitter
-{
-	String string;
-	String split;
-	usz current;
-}
-
-fn void Splitter.reset(&self)
-{
-	self.current = 0;
-}
-
-fn String! Splitter.next(&self)
-{
-	usz len = self.string.len;
-	usz current = self.current;
-	if (current >= len) return IteratorResult.NO_MORE_ELEMENT?;
-	String remaining = self.string[current..];
-	usz! next = remaining.index_of(self.split);
-	if (try next)
-	{
-		defer self.current = current + next + self.split.len;
-		return remaining[:next];
-	}
-	self.current = len;
-	return remaining;
-}
-
 
+fn Char16[]! String.to_temp_utf16(String s) => s.to_utf16(mem::temp());

lib/std/core/string_iterator.c3

@@ -6,18 +6,18 @@ struct StringIterator
 	usz current;
 }
 
-fn void StringIterator.reset(&self)
+fn void StringIterator.reset(StringIterator* this)
 {
-	self.current = 0;
+	this.current = 0;
 }
 
-fn Char32! StringIterator.next(&self)
+fn Char32! StringIterator.next(StringIterator* this)
 {
-	usz len = self.utf8.len;
-	usz current = self.current;
-	if (current >= len) return IteratorResult.NO_MORE_ELEMENT?;
+	usz len = this.utf8.len;
+	usz current = this.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;
+	Char32 res = conv::utf8_to_char32(&this.utf8[current], &read)?;
+	this.current += read;
 	return res;
-}
+}

lib/std/core/types.c3

@@ -1,4 +1,3 @@
-
 module std::core::types;
 import libc;
 
@@ -11,103 +10,107 @@ fault ConversionResult
 /**
  * @require $Type.kindof.is_int() || $Type.kindof == TypeKind.ENUM "Argument was not an integer"
  **/
-macro any_to_int(any* v, $Type)
+macro variant_to_int(variant v, $Type)
 {
-	typeid any_type = v.type;
-	TypeKind kind = any_type.kindof;
+	typeid variant_type = v.type;
+	TypeKind kind = variant_type.kindof;
 	if (kind == TypeKind.ENUM)
 	{
-		any_type = any_type.inner;
-		kind = any_type.kindof;
+		variant_type = variant_type.inner;
+		kind = variant_type.kindof;
 	}
-	bool is_mixed_signed = $Type.kindof != any_type.kindof;
+	bool is_mixed_signed = $Type.kindof != variant_type.kindof;
 	$Type max = $Type.max;
 	$Type min = $Type.min;
-	switch (any_type)
+	switch (variant_type)
 	{
 		case ichar:
 			ichar c = *(char*)v.ptr;
-			if (is_mixed_signed && c < 0) return ConversionResult.VALUE_OUT_OF_UNSIGNED_RANGE?;
+			if (is_mixed_signed && c < 0) return ConversionResult.VALUE_OUT_OF_UNSIGNED_RANGE!;
 			return ($Type)c;
 		case short:
 			short s = *(short*)v.ptr;
-			if (is_mixed_signed && s < 0) return ConversionResult.VALUE_OUT_OF_UNSIGNED_RANGE?;
-			if (s > max || s < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (is_mixed_signed && s < 0) return ConversionResult.VALUE_OUT_OF_UNSIGNED_RANGE!;
+			if (s > max || s < min) return ConversionResult.VALUE_OUT_OF_RANGE!;
 			return ($Type)s;
 		case int:
 			int i = *(int*)v.ptr;
-			if (is_mixed_signed && i < 0) return ConversionResult.VALUE_OUT_OF_UNSIGNED_RANGE?;
-			if (i > max || i < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (is_mixed_signed && i < 0) return ConversionResult.VALUE_OUT_OF_UNSIGNED_RANGE!;
+			if (i > max || i < min) return ConversionResult.VALUE_OUT_OF_RANGE!;
 			return ($Type)i;
 		case long:
 			long l = *(long*)v.ptr;
-			if (is_mixed_signed && l < 0) return ConversionResult.VALUE_OUT_OF_UNSIGNED_RANGE?;
-			if (l > max || l < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (is_mixed_signed && l < 0) return ConversionResult.VALUE_OUT_OF_UNSIGNED_RANGE!;
+			if (l > max || l < min) return ConversionResult.VALUE_OUT_OF_RANGE!;
 			return ($Type)l;
 		case int128:
 			int128 i = *(int128*)v.ptr;
-			if (is_mixed_signed && i < 0) return ConversionResult.VALUE_OUT_OF_UNSIGNED_RANGE?;
-			if (i > max || i < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (is_mixed_signed && i < 0) return ConversionResult.VALUE_OUT_OF_UNSIGNED_RANGE!;
+			if (i > max || i < min) return ConversionResult.VALUE_OUT_OF_RANGE!;
 			return ($Type)i;
 		case char:
 			char c = *(char*)v.ptr;
-			if (c > max) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (c > max) return ConversionResult.VALUE_OUT_OF_RANGE!;
 			return ($Type)c;
 		case ushort:
 			ushort s = *(ushort*)v.ptr;
-			if (s > max || s < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (s > max || s < min) return ConversionResult.VALUE_OUT_OF_RANGE!;
 			return ($Type)s;
 		case uint:
 			uint i = *(uint*)v.ptr;
-			if (i > max || i < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (i > max || i < min) return ConversionResult.VALUE_OUT_OF_RANGE!;
 			return ($Type)i;
 		case ulong:
 			ulong l = *(ulong*)v.ptr;
-			if (l > max || l < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (l > max || l < min) return ConversionResult.VALUE_OUT_OF_RANGE!;
 			return ($Type)l;
 		case uint128:
 			uint128 i = *(uint128*)v.ptr;
-			if (i > max || i < min) return ConversionResult.VALUE_OUT_OF_RANGE?;
+			if (i > max || i < min) return ConversionResult.VALUE_OUT_OF_RANGE!;
 			return ($Type)i;
 		default:
 			unreachable();
 	}
 }
 
-fn bool typeid.is_subtype_of(self, typeid other)
-{
-	while (self != void.typeid)
-	{
-		if (self == other) return true;
-		self = self.parentof;
-	}
-	return false;
-}
-
-macro bool is_subtype_of($Type, $OtherType)
-{
-	var $typeid = $Type.typeid;
-	$switch ($Type)
-		$case $OtherType: return true;
-		$default: return false;
-	$endswitch
-}
 macro bool is_numerical($Type)
 {
 	var $kind = $Type.kindof;
-	$if $kind == TypeKind.DISTINCT:
-		return is_numerical($typefrom($Type.inner));
+	$if ($kind == TypeKind.DISTINCT)
+		return is_numerical($Type.inner);
 	$else
 		return $kind == TypeKind.SIGNED_INT || $kind == TypeKind.UNSIGNED_INT || $kind == TypeKind.FLOAT
 			|| $kind == TypeKind.VECTOR;
 	$endif
 }
 
-fn bool TypeKind.is_int(kind) @inline
+fn bool TypeKind.is_int(TypeKind kind) @inline
 {
 	return kind == TypeKind.SIGNED_INT || kind == TypeKind.UNSIGNED_INT;
 }
 
+macro bool is_indexable($Type)
+{
+	return $checks($Type t, int i, t[i]);
+}
+
+macro bool is_comparable($Type)
+{
+	var $kind = $Type.kindof;
+	$if ($kind == TypeKind.DISTINCT)
+		return is_comparable($Type.inner);
+	$else
+		return $kind == TypeKind.SIGNED_INT || $kind == TypeKind.UNSIGNED_INT || $kind == TypeKind.FLOAT
+			|| $kind == TypeKind.VECTOR || $kind == TypeKind.BOOL || $kind == TypeKind.POINTER
+			|| $kind == TypeKind.ENUM;
+	$endif
+}
+
+macro bool is_equatable($Type)
+{
+	return $checks($Type a, a == a);
+}
+
 macro bool is_subarray_convertable($Type)
 {
 	$switch ($Type.kindof)
@@ -136,18 +139,6 @@ macro bool is_intlike($Type)
 	$endswitch
 }
 
-macro bool is_underlying_int($Type)
-{
-	$switch ($Type.kindof)
-		$case SIGNED_INT:
-		$case UNSIGNED_INT:
-			return true;
-		$case DISTINCT:
-			return is_underlying_int($typefrom($Type.inner));
-		$default:
-			return false;
-	$endswitch
-}
 
 macro bool is_float($Type) => $Type.kindof == TypeKind.FLOAT;
 
@@ -170,13 +161,18 @@ macro bool is_vector($Type)
 
 macro TypeKind inner_kind($Type)
 {
-	$if $Type.kindof == TypeKind.DISTINCT:
+	$if ($Type.kindof == TypeKind.DISTINCT)
 		return inner_kind($typefrom($Type.inner));
 	$else
 		return $Type.kindof;
 	$endif
 }
 
+macro bool @convertable(#a, $TypeB) @builtin
+{
+	return $checks($TypeB x = #a);
+}
+
 macro bool is_same($TypeA, $TypeB)
 {
 	return $TypeA.typeid == $TypeB.typeid;
@@ -184,12 +180,12 @@ macro bool is_same($TypeA, $TypeB)
 
 macro bool @has_same(#a, #b, ...)
 {
-	var $type_a = @typeid(#a);
-	$if $type_a != @typeid(#b):
-		return false;
+	var $type_a = $typeof(#a).typeid;
+	$if ($type_a != $typeof(#b).typeid)
+	    return false;
 	$endif
 	$for (var $i = 0; $i < $vacount; $i++)
-		$if @typeid($vaexpr($i)) != $type_a:
+		$if ($typeof($vaexpr($i)).typeid != $type_a)
 			return false;
 		$endif
 	$endfor
@@ -211,97 +207,58 @@ macro bool may_load_atomic($Type)
 	$endswitch
 }
 
-macro lower_to_atomic_compatible_type($Type) 
-{
-	$switch ($Type.kindof)
-    $case SIGNED_INT:
-	  $case UNSIGNED_INT:
-      return $Type.typeid;
-		$case DISTINCT:
-			return lower_to_atomic_compatible_type($Type.inner);
-		$case FLOAT:
-			$switch ($Type)
-				$case float16: 
-					return ushort.typeid;
-				$case float: 
-					return uint.typeid;
-				$case double:
-					return ulong.typeid;
-				$case float128:
-					return uint128.typeid;
-				$default: 
-					return void.typeid;
-			$endswitch
-		$default:
-			return void.typeid;
-  $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_same_vector_type($Type1, $Type2)
 {
-	$if $Type1.kindof != TypeKind.VECTOR:
+	$if ($Type1.kindof != TypeKind.VECTOR)
 		return $Type2.kindof != TypeKind.VECTOR;
 	$else
 		return $Type1.inner == $Type2.inner && $Type1.len == $Type2.len;
 	$endif
 }
 
-macro bool is_equatable_type($Type)
-{
-	$if $defined($Type.less) || $defined($Type.compare_to) || $defined($Type.equals):
-		return true;
-	$else
-		return $Type.is_eq;
-	$endif
-}
-
-/**
- * Checks if a type implements the copy protocol.
- **/
-macro bool implements_copy($Type)
-{
-	return $defined($Type.copy) && $defined($Type.free);
-}
-
 macro bool is_equatable_value(value)
 {
-	return is_equatable_type($typeof(value));
+	$if ($defined(value.less) || $defined(value.compare_to) || $defined(value.equals))
+		return true;
+	$else
+		return is_equatable($typeof(value));
+	$endif
 }
 
 macro bool is_comparable_value(value)
 {
-	$if $defined(value.less) || $defined(value.compare_to):
+	$if ($defined(value.less) || $defined(value.compare_to))
 		return true;
 	$else
-		return $typeof(value).is_ordered;
+		return is_comparable($typeof(value));
 	$endif
 }
 
 enum TypeKind : char
 {
-	VOID,
-	BOOL,
-	SIGNED_INT,
-	UNSIGNED_INT,
-	FLOAT,
-	TYPEID,
-	ANYFAULT,
-	ANY,
-	ENUM,
-	FAULT,
-	STRUCT,
-	UNION,
-	BITSTRUCT,
-	FUNC,
-	OPTIONAL,
-	ARRAY,
-	SUBARRAY,
-	VECTOR,
-	DISTINCT,
-	POINTER,
+    VOID,
+    BOOL,
+    SIGNED_INT,
+    UNSIGNED_INT,
+    FLOAT,
+    TYPEID,
+    ANYERR,
+    VARIANT,
+    ENUM,
+    FAULT,
+    STRUCT,
+    UNION,
+    BITSTRUCT,
+    FUNC,
+    OPTIONAL,
+    ARRAY,
+    SUBARRAY,
+    VECTOR,
+    DISTINCT,
+    POINTER,
 }
 
 struct TypeEnum

lib/std/core/values.c3

@@ -1,25 +1,18 @@
 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;
-/**
- * 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 @convertable_to(#a, #b) => $checks($typeof(#b) x = #a);
 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 promote_int(x)
 {
-	$if @is_int(x):
+	$if (@is_int(x))
 		return (double)x;
 	$else
 		return x;
@@ -27,4 +20,3 @@ macro promote_int(x)
 }
 
 macro TypeKind @inner_kind(#value) => types::inner_kind($typeof(#value));
-

lib/std/core/varstring.c3

@@ -0,0 +1,327 @@
+module std::core::string;
+import libc;
+
+typedef VarString = distinct void*;
+typedef DynStr = VarString;
+typedef DynString = VarString;
+typedef VString = VarString;
+typedef Text = VarString;
+
+const usz MIN_CAPACITY = 16;
+
+fn VarString new_with_capacity(usz capacity, Allocator* allocator = mem::heap())
+{
+	if (capacity < MIN_CAPACITY) capacity = MIN_CAPACITY;
+	StringData* data = malloc(StringData, 1, .using = allocator, .end_padding = capacity);
+	data.allocator = allocator;
+	data.len = 0;
+	data.capacity = capacity;
+	return (VarString)data;
+}
+
+fn VarString new(String c)
+{
+	usz len = c.len;
+	VarString str = new_with_capacity(len);
+	StringData* data = str.data();
+	if (len)
+	{
+		data.len = len;
+		mem::copy(&data.chars, c.ptr, len);
+	}
+	return (VarString)data;
+}
+
+fn ZString VarString.zstr(VarString str)
+{
+	StringData* data = str.data();
+	if (!data) return (ZString)"";
+	if (data.capacity == data.len)
+	{
+		str.reserve(1);
+		data.chars[data.len] = 0;
+	}
+	else if (data.chars[data.len] != 0)
+	{
+		data.chars[data.len] = 0;
+	}
+	return (ZString)&data.chars[0];
+}
+
+fn usz VarString.capacity(VarString this)
+{
+	if (!this) return 0;
+	return this.data().capacity;
+}
+
+fn usz VarString.len(VarString this)
+{
+	if (!this) return 0;
+	return this.data().len;
+}
+
+/**
+ * @require new_size <= this.len()
+ */
+fn void VarString.chop(VarString this, usz new_size)
+{
+	if (!this) return;
+	this.data().len = new_size;
+}
+
+fn String VarString.str(VarString str)
+{
+	StringData* data = (StringData*)str;
+	if (!data) return "";
+	return (String)data.chars[:data.len];
+}
+
+fn void VarString.append_utf32(VarString* str, Char32[] chars)
+{
+	str.reserve(chars.len);
+	foreach (Char32 c : chars)
+	{
+		str.append_char32(c);
+	}
+}
+
+/**
+ * @require index < str.len()
+ **/
+fn void VarString.set(VarString str, usz index, char c)
+{
+	str.data().chars[index] = c;
+}
+
+fn void VarString.append_repeat(VarString* str, char c, usz times)
+{
+	if (times == 0) return;
+	str.reserve(times);
+	StringData* data = str.data();
+	for (usz i = 0; i < times; i++)
+	{
+        data.chars[data.len++] = c;
+	}
+}
+
+/**
+ * @require c <= 0x10ffff
+ */
+fn void VarString.append_char32(VarString* str, Char32 c)
+{
+	if (c < 0x7f)
+	{
+		str.reserve(1);
+		StringData* data = str.data();
+        data.chars[data.len++] = (char)c;
+        return;
+    }
+    if (c < 0x7ff)
+    {
+		str.reserve(2);
+		StringData* data = str.data();
+		data.chars[data.len++] = (char)(0xC0 | c >> 6);
+        data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
+        return;
+    }
+    if (c < 0xffff)
+    {
+		str.reserve(3);
+		StringData* data = str.data();
+		data.chars[data.len++] = (char)(0xE0 | c >> 12);
+        data.chars[data.len++] = (char)(0x80 | (c >> 6 & 0x3F));
+        data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
+        return;
+    }
+	str.reserve(4);
+	StringData* data = str.data();
+	data.chars[data.len++] = (char)(0xF0 | c >> 18);
+    data.chars[data.len++] = (char)(0x80 | (c >> 12 & 0x3F));
+    data.chars[data.len++] = (char)(0x80 | (c >> 6 & 0x3F));
+    data.chars[data.len++] = (char)(0x80 | (c & 0x3F));
+}
+
+fn VarString VarString.tcopy(VarString* str) => str.copy(mem::temp());
+
+fn VarString VarString.copy(VarString* str, Allocator* allocator = null)
+{
+	if (!str)
+	{
+		if (allocator) return new_with_capacity(0, allocator);
+		return (VarString)null;
+	}
+	if (!allocator) allocator = mem::heap();
+	StringData* data = str.data();
+	VarString new_string = new_with_capacity(data.capacity, allocator);
+	mem::copy((char*)new_string.data(), (char*)data, StringData.sizeof + data.len);
+	return new_string;
+}
+
+fn ZString VarString.copy_zstr(VarString* str, Allocator* allocator = mem::heap())
+{
+	usz str_len = str.len();
+	if (!str_len)
+	{
+		return (ZString)calloc(1, .using = allocator);
+	}
+	char* zstr = malloc(str_len + 1, .using = allocator);
+	StringData* data = str.data();
+	mem::copy(zstr, &data.chars, str_len);
+	zstr[str_len] = 0;
+	return (ZString)zstr;
+}
+
+fn String VarString.copy_str(VarString* str, Allocator* allocator = mem::heap())
+{
+	return (String)str.copy_zstr(allocator)[:str.len()];
+}
+
+fn String VarString.tcopy_str(VarString* str) => str.copy_str(mem::temp()) @inline;
+
+fn bool VarString.equals(VarString str, VarString other_string)
+{
+	StringData *str1 = str.data();
+	StringData *str2 = other_string.data();
+	if (str1 == str2) return true;
+	if (!str1) return str2.len == 0;
+	if (!str2) return str1.len == 0;
+	usz str1_len = str1.len;
+	if (str1_len != str2.len) return false;
+	for (int i = 0; i < str1_len; i++)
+	{
+		if (str1.chars[i] != str2.chars[i]) return false;
+	}
+	return true;
+}
+
+fn void VarString.destroy(VarString* str)
+{
+	if (!*str) return;
+	StringData* data = str.data();
+	if (!data) return;
+	free(data, .using = data.allocator);
+	*str = (VarString)null;
+}
+
+fn bool VarString.less(VarString str, VarString other_string)
+{
+	StringData* str1 = str.data();
+	StringData* str2 = other_string.data();
+	if (str1 == str2) return false;
+	if (!str1) return str2.len != 0;
+	if (!str2) return str1.len == 0;
+	usz str1_len = str1.len;
+	usz str2_len = str2.len;
+	if (str1_len != str2_len) return str1_len < str2_len;
+	for (int i = 0; i < str1_len; i++)
+	{
+		if (str1.chars[i] >= str2.chars[i]) return false;
+	}
+	return true;
+}
+
+fn void VarString.append_chars(VarString* this, String str)
+{
+	usz other_len = str.len;
+	if (!other_len) return;
+	if (!*this)
+	{
+		*this = new(str);
+		return;
+	}
+	this.reserve(other_len);
+	StringData* data = (StringData*)*this;
+	mem::copy(&data.chars[data.len], str.ptr, other_len);
+	data.len += other_len;
+}
+
+fn Char32[] VarString.copy_utf32(VarString* this, Allocator* allocator = mem::heap())
+{
+	return str::utf8to32(this.str(), allocator) @inline!!;
+}
+
+fn void VarString.append_string(VarString* this, VarString str)
+{
+	StringData* other = (StringData*)str;
+	if (!other) return;
+	this.append(str.str());
+}
+
+fn void VarString.clear(VarString* str)
+{
+	str.data().len = 0;
+}
+
+fn void VarString.append_char(VarString* str, char c)
+{
+	if (!*str)
+	{
+		*str = new_with_capacity(MIN_CAPACITY);
+	}
+	str.reserve(1);
+	StringData* data = (StringData*)*str;
+	data.chars[data.len++] = c;
+}
+
+
+macro void VarString.append(VarString* str, value)
+{
+	var $Type = $typeof(value);
+	$switch ($Type)
+		$case char:
+		$case ichar:
+			str.append_char(value);
+		$case VarString:
+			str.append_string(value);
+		$case String:
+			str.append_chars(value);
+		$case Char32:
+			str.append_char32(value);
+		$default:
+			$switch
+				$case @convertible(value, Char32):
+					str.append_char32(value);
+				$case @convertible(value, String):
+					str.append_chars(value);
+				$default:
+					$assert(false, "Unsupported type for append – use printf instead.");
+			$endswitch
+	$endswitch
+}
+
+
+fn StringData* VarString.data(VarString str) @inline @private
+{
+	return (StringData*)str;
+}
+
+fn void VarString.reserve(VarString* str, usz addition) @private
+{
+	StringData* data = str.data();
+	if (!data)
+	{
+		*str = string::new_with_capacity(addition);
+		return;
+	}
+	usz len = data.len + addition;
+	if (data.capacity >= len) return;
+	usz new_capacity = data.capacity *= 2;
+	if (new_capacity < MIN_CAPACITY) new_capacity = MIN_CAPACITY;
+	*str = (VarString)realloc(data, StringData.sizeof + new_capacity, .using = data.allocator);
+}
+
+fn VarString VarString.new_concat(VarString a, VarString b, Allocator* allocator = mem::heap())
+{
+	VarString string = new_with_capacity(a.len() + b.len(), allocator);
+	string.append(a);
+	string.append(b);
+	return string; 
+}
+
+struct StringData @private
+{
+	Allocator* allocator;
+	usz len;
+	usz capacity;
+	char[*] chars;
+}

lib/std/crypto/rc4.c3

@@ -12,34 +12,36 @@ struct Rc4
 /**
  * Initialize the RC4 state.
  *
+ * @param [inout] this "The RC4 state"
  * @param [in] key "The key to use"
  * @require key.len > 0 "The key must be at least 1 byte long"
  **/
-fn void Rc4.init(&self, char[] key)
+fn void Rc4.init(Rc4* this, char[] key)
 {
 	// Init the state matrix
-	foreach (char i, &c : self.state) *c = i;
+	foreach (char i, &c : this.state) *c = i;
 	for (int i = 0, int j = 0; i < 256; i++)
 	{
-		j = (j + self.state[i] + key[i % key.len]) & 0xFF;
-		@swap(self.state[i], self.state[j]);
+		j = (j + this.state[i] + key[i % key.len]) & 0xFF;
+		@swap(this.state[i], this.state[j]);
 	}
-	self.i = 0;
-	self.j = 0;
+	this.i = 0;
+	this.j = 0;
 }
 
 /**
  * Encrypt or decrypt a sequence of bytes.
  *
+ * @param [inout] this "The RC4 State"
  * @param [in] in "The input"
  * @param [out] out "The output"
  * @require in.len <= out.len "Output would overflow"
  **/
-fn void Rc4.crypt(&self, char[] in, char[] out)
+fn void Rc4.crypt(Rc4* this, char[] in, char[] out)
 {
-	uint i = self.i;
-	uint j = self.j;
-	char* state = &self.state;
+	uint i = this.i;
+	uint j = this.j;
+	char* state = &this.state;
 	isz len = in.len;
 	foreach (idx, c : in)
 	{
@@ -48,16 +50,16 @@ fn void Rc4.crypt(&self, char[] in, char[] out)
 		@swap(state[i], state[j]);
 		out[idx] = in[idx] ^ state[(state[i] + state[j]) & 0xFF];
 	}
-	self.i = i;
-	self.j = j;
+	this.i = i;
+	this.j = j;
 }
 
 /**
  * Clear the rc4 state.
  *
- * @param [&out] self "The RC4 State"
+ * @param [out] this "The RC4 State"
  **/
-fn void Rc4.destroy(&self)
+fn void Rc4.destroy(Rc4* this)
 {
-	*self = {};
+	*this = {};
 }

lib/std/encoding/base64.c3

@@ -1,288 +0,0 @@
-module std::encoding::base64;
-import std::core::bitorder;
-
-// The implementation is based on https://www.rfc-editor.org/rfc/rfc4648
-// Specifically this section:
-// https://www.rfc-editor.org/rfc/rfc4648#section-4
-
-const STD_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-const URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-
-const MASK @private = 0b111111;
-
-struct Base64Encoder
-{
-	int padding;
-	String alphabet;
-}
-
-fault Base64Error
-{
-	DUPLICATE_IN_ALPHABET,
-	PADDING_IN_ALPHABET,
-	DESTINATION_TOO_SMALL,
-	INVALID_PADDING,
-	INVALID_CHARACTER,
-}
-
-/**
- * @param alphabet "The alphabet used for encoding."
- * @param padding "Set to a negative value to disable padding."
- * @require alphabet.len == 64
- * @require padding < 256
- * @return! Base64Error.DUPLICATE_IN_ALPHABET, Base64Error.PADDING_IN_ALPHABET
- **/
-fn void! Base64Encoder.init(&self, String alphabet, int padding = '=')
-{
-	check_alphabet(alphabet, padding)!;
-	*self = { .padding = padding, .alphabet = alphabet };
-}
-
-/**
- * Calculate the size of the encoded data.
- * @param n "Size of the input to be encoded."
- * @return "The size of the input once encoded."
- **/
-fn usz Base64Encoder.encode_len(&self, usz n)
-{
-	if (self.padding >= 0) return (n + 2) / 3 * 4;
-	usz trailing = n % 3;
-	return n / 3 * 4 + (trailing * 4 + 2) / 3;
-}
-
-/**
- * Encode the content of src into dst, which must be properly sized.
- * @param src "The input to be encoded."
- * @param dst "The encoded input."
- * @return "The encoded size."
- * @return! Base64Error.DESTINATION_TOO_SMALL
- **/
-fn usz! Base64Encoder.encode(&self, char[] src, char[] dst)
-{
-	if (src.len == 0) return 0;
-	usz dn = self.encode_len(src.len);
-	if (dst.len < dn) return Base64Error.DESTINATION_TOO_SMALL?;
-	usz trailing = src.len % 3;
-	char[] src3 = src[:^trailing];
-
-	while (src3.len > 0)
-	{
-		uint group = (uint)src3[0] << 16 | (uint)src3[1] << 8 | (uint)src3[2];
-		dst[0] = self.alphabet[group >> 18 & MASK];
-		dst[1] = self.alphabet[group >> 12 & MASK];
-		dst[2] = self.alphabet[group >> 6 & MASK];
-		dst[3] = self.alphabet[group & MASK];
-		dst = dst[4..];
-		src3 = src3[3..];
-	}
-
-	// Encode the remaining bytes according to:
-	// https://www.rfc-editor.org/rfc/rfc4648#section-3.5
-	switch (trailing)
-	{
-		case 1:
-			uint group = (uint)src[^1] << 16;
-			dst[0] = self.alphabet[group >> 18 & MASK];
-			dst[1] = self.alphabet[group >> 12 & MASK];
-			if (self.padding >= 0)
-			{
-				char pad = (char)self.padding;
-				dst[2] = pad;
-				dst[3] = pad;
-			}
-		case 2:
-			uint group = (uint)src[^2] << 16 | (uint)src[^1] << 8;
-			dst[0] = self.alphabet[group >> 18 & MASK];
-			dst[1] = self.alphabet[group >> 12 & MASK];
-			dst[2] = self.alphabet[group >> 6 & MASK];
-			if (self.padding >= 0)
-			{
-				char pad = (char)self.padding;
-				dst[3] = pad;
-			}
-	}
-	return dn;
-}
-
-struct Base64Decoder
-{
-	int padding;
-	String alphabet;
-	char[256] reverse;
-	char invalid;
-}
-
-/**
- * @param alphabet "The alphabet used for encoding."
- * @param padding "Set to a negative value to disable padding."
- * @require alphabet.len == 64
- * @require padding < 256
- * @return! Base64Error.DUPLICATE_IN_ALPHABET, Base64Error.PADDING_IN_ALPHABET
- **/
-fn void! Base64Decoder.init(&self, String alphabet, int padding = '=')
-{
-	check_alphabet(alphabet, padding)!;
-	*self = { .padding = padding, .alphabet = alphabet };
-
-	bool[256] checked;
-	foreach (i, c : alphabet)
-	{
-		checked[c] = true;
-		self.reverse[c] = (char)i;
-	}
-	if (padding < 0)
-	{
-		self.invalid = 255;
-		return;
-	}
-	// Find a character for invalid neither in the alphabet nor equal to the padding.
-	char pad = (char)padding;
-	foreach (i, ok : checked)
-	{
-		if (!ok && (char)i != pad)
-		{
-			self.invalid = (char)i;
-			break;
-		}
-	}
-}
-
-/**
- * Calculate the size of the decoded data.
- * @param n "Size of the input to be decoded."
- * @return "The size of the input once decoded."
- * @return! Base64Error.INVALID_PADDING
- **/
-fn usz! Base64Decoder.decode_len(&self, usz n)
-{
-	usz dn = n / 4 * 3;
-	usz trailing = n % 4;
-	if (self.padding >= 0)
-	{
-		if (trailing != 0) return Base64Error.INVALID_PADDING?;
-		// source size is multiple of 4
-	}
-	else
-	{
-		if (trailing == 1) return Base64Error.INVALID_PADDING?;
-		dn += trailing * 3 / 4;
-	}
-	return dn;
-}
-
-/**
- * Decode the content of src into dst, which must be properly sized.
- * @param src "The input to be decoded."
- * @param dst "The decoded input."
- * @return "The decoded size."
- * @return! Base64Error.DESTINATION_TOO_SMALL, Base64Error.INVALID_PADDING, Base64Error.INVALID_CHARACTER
- **/
-fn usz! Base64Decoder.decode(&self, char[] src, char[] dst)
-{
-	if (src.len == 0) return 0;
-	usz dn = self.decode_len(src.len)!;
-	if (dst.len < dn) return Base64Error.DESTINATION_TOO_SMALL?;
-
-	usz trailing = src.len % 4;
-	char[] src4 = src;
-	switch
-	{
-		case self.padding < 0:
-			src4 = src[:^trailing];
-		default:
-			// If there is padding, keep the last 4 bytes for later.
-			// NB. src.len >= 4 as decode_len passed
-			trailing = 4;
-			char pad = (char)self.padding;
-			if (src[^1] == pad) src4 = src[:^4];
-	}
-	while (src4.len > 0)
-	{
-		char c0 = self.reverse[src4[0]];
-		char c1 = self.reverse[src4[1]];
-		char c2 = self.reverse[src4[2]];
-		char c3 = self.reverse[src4[3]];
-		switch (self.invalid)
-		{
-			case c0:
-			case c1:
-			case c2:
-			case c3:
-				return Base64Error.INVALID_CHARACTER?;
-		}
-		uint group = (uint)c0 << 18 | (uint)c1 << 12 | (uint)c2 << 6 | (uint)c3;
-		dst[0] = (char)(group >> 16);
-		dst[1] = (char)(group >> 8);
-		dst[2] = (char)group;
-		dst = dst[3..];
-		src4 = src4[4..];
-	}
-
-	if (trailing == 0) return dn;
-
-	src = src[^trailing..];
-	char c0 = self.reverse[src[0]];
-	char c1 = self.reverse[src[1]];
-	if (c0 == self.invalid || c1 == self.invalid) return Base64Error.INVALID_PADDING?;
-	if (self.padding < 0)
-	{
-		switch (src.len)
-		{
-			case 2:
-				uint group = (uint)c0 << 18 | (uint)c1 << 12;
-				dst[0] = (char)(group >> 16);
-			case 3:
-				char c2 = self.reverse[src[2]];
-				if (c2 == self.invalid) return Base64Error.INVALID_CHARACTER?;
-				uint group = (uint)c0 << 18 | (uint)c1 << 12 | (uint)c2 << 6;
-				dst[0] = (char)(group >> 16);
-				dst[1] = (char)(group >> 8);
-		}
-	}
-	else
-	{
-		// Valid paddings are:
-		// 2: xx==
-		// 1: xxx=
-		char pad = (char)self.padding;
-		switch (pad)
-		{
-			case src[2]:
-				if (src[3] != pad) return Base64Error.INVALID_PADDING?;
-				uint group = (uint)c0 << 18 | (uint)c1 << 12;
-				dst[0] = (char)(group >> 16);
-				dn -= 2;
-			case src[3]:
-				char c2 = self.reverse[src[2]];
-				if (c2 == self.invalid) return Base64Error.INVALID_CHARACTER?;
-				uint group = (uint)c0 << 18 | (uint)c1 << 12 | (uint)c2 << 6;
-				dst[0] = (char)(group >> 16);
-				dst[1] = (char)(group >> 8);
-				dn -= 1;
-		}
-	}
-	return dn;
-}
-
-// Make sure that all bytes in the alphabet are unique and
-// the padding is not present in the alphabet.
-fn void! check_alphabet(String alphabet, int padding) @local
-{
-	bool[256] checked;
-	if (padding < 0)
-	{
-		foreach (c : alphabet)
-		{
-			if (checked[c]) return Base64Error.DUPLICATE_IN_ALPHABET?;
-			checked[c] = true;
-		}
-		return;
-	}
-	char pad = (char)padding;
-	foreach (c : alphabet)
-	{
-		if (c == pad) return Base64Error.PADDING_IN_ALPHABET?;
-		if (checked[c]) return Base64Error.DUPLICATE_IN_ALPHABET?;
-		checked[c] = true;
-	}
-}

lib/std/encoding/csv.c3

@@ -1,64 +0,0 @@
-module std::encoding::csv;
-import std::io;
-
-struct CsvReader
-{
-	InStream* stream;
-	String separator;
-}
-
-fn void CsvReader.init(&self, InStream* stream, String separator = ",")
-{
-	self.stream = stream;
-	self.separator = separator;
-}
-
-fn String[]! CsvReader.read_new_row(self, Allocator* allocator = allocator::heap())
-{
-	return self.read_new_row_with_allocator(allocator::temp()) @inline;
-}
-
-fn String[]! CsvReader.read_new_row_with_allocator(self, Allocator* allocator = allocator::heap())
-{
-	@pool(allocator)
-	{
-		return io::treadline(self.stream).split(self.separator, .allocator = allocator);
-	};
-}
-
-fn String[]! CsvReader.read_temp_row(self)
-{
-	return self.read_new_row_with_allocator(allocator::temp()) @inline;
-}
-
-fn void! CsvReader.skip_row(self) @maydiscard
-{
-	@pool()
-	{
-		(void)io::treadline(self.stream);
-	};
-}
-
-macro CsvReader.@each_row(self, int rows = int.max; @body(String[] row))
-{
-	InputStream* stream = self.stream;
-	String sep = self.separator;
-	while (rows--)
-	{
-		@stack_mem(512; Allocator* mem)
-		{
-			String[] parts;
-			@pool()
-			{
-				String! s = stream.treadline();
-				if (catch err = s)
-				{
-					if (err == IoError.EOF) return;
-					return err?;
-				}
-				parts = s.split(sep, .allocator = mem);
-			};
-			@body(parts);
-		};
-	}
-}

lib/std/encoding/json.c3

@@ -6,25 +6,7 @@ import std::io;
 import std::ascii;
 import std::collections::object;
 
-fault JsonParsingError
-{
-	EOF,
-	UNEXPECTED_CHARACTER,
-	INVALID_ESCAPE_SEQUENCE,
-	DUPLICATE_MEMBERS,
-	INVALID_NUMBER,
-}
-
-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);
-}
-
-// -- Implementation follows --
-
-enum JsonTokenType @local
+enum JsonTokenType
 {
 	NO_TOKEN,
 	LBRACE,
@@ -41,67 +23,79 @@ enum JsonTokenType @local
 	EOF,
 }
 
-struct JsonContext @local
+struct JsonParser
 {
 	uint line;
-	InStream* stream;
+	Stream stream;
 	Allocator* allocator;
 	JsonTokenType token;
 	DString last_string;
 	double last_number;
 	char current;
-	bitstruct : char {
-		bool skip_comments;
-		bool reached_end;
-		bool pushed_back;
-	}
+	anyerr current_err;
+	bool skip_comments;
+	bool reached_end;
 }
 
+fault JsonParsingError
+{
+	EOF,
+	UNEXPECTED_CHARACTER,
+	INVALID_ESCAPE_SEQUENCE,
+	DUPLICATE_MEMBERS,
+	INVALID_NUMBER,
+}
 
-fn Object*! parse_from_token(JsonContext* context, JsonTokenType token) @local
+fn void JsonParser.init(JsonParser* parser, Stream s, Allocator* using = mem::heap())
+{
+	*parser = { .last_string = dstring::new_with_capacity(64, using), .stream = s, .allocator = using };
+}
+
+fn Object*! JsonParser.parse_from_token(JsonParser* this, JsonTokenType token)
 {
 	switch (token)
 	{
 		case NO_TOKEN: unreachable();
-		case LBRACE: return parse_map(context);
-		case LBRACKET: return parse_array(context);
+		case LBRACE: return this.parse_map();
+		case LBRACKET: return this.parse_array();
 		case COMMA:
 		case RBRACE:
 		case RBRACKET:
-		case COLON: return JsonParsingError.UNEXPECTED_CHARACTER?;
-		case STRING: return object::new_string(context.last_string.str_view(), context.allocator);
-		case NUMBER: return object::new_float(context.last_number, context.allocator);
+		case COLON: return JsonParsingError.UNEXPECTED_CHARACTER!;
+		case STRING: return object::new_string(this.last_string.str(), this.allocator);
+		case NUMBER: return object::new_float(this.last_number, this.allocator);
 		case TRUE: return object::new_bool(true);
 		case FALSE: return object::new_bool(false);
 		case NULL: return object::new_null();
-		case EOF: return JsonParsingError.EOF?;
+		case EOF: return JsonParsingError.EOF!;
 	}
+	unreachable();
 }
-fn Object*! parse_any(JsonContext* context) @local
+fn Object*! JsonParser.parse_any(JsonParser* this)
 {
-	return parse_from_token(context, advance(context));
+	return this.parse_from_token(this.advance());
 }
 
-fn JsonTokenType! lex_number(JsonContext *context, char c) @local
+fn JsonTokenType! JsonParser.lex_number(JsonParser* this, char c)
 {
 	@pool()
 	{
-		DString t = dstring::temp_with_capacity(32);
+		DString t = dstring::tnew_with_capacity(32);
 		bool negate = c == '-';
 		if (negate)
 		{
 			t.append(c);
-			c = read_next(context)!;
+			c = this.read_next()?;
 		}
-		while (c.is_digit())
+		while (c >= '0' && c <= '9')
 		{
 			t.append(c);
-			c = read_next(context)!;
+			c = this.read_next()?;
 		}
 		if (c == '.')
 		{
 			t.append(c);
-			while (c = read_next(context)!, c.is_digit())
+			while (c = this.read_next()?, c >= '0' && c <= '9')
 			{
 				t.append(c);
 			}
@@ -109,123 +103,113 @@ fn JsonTokenType! lex_number(JsonContext *context, char c) @local
 		if ((c | 32) == 'e')
 		{
 			t.append(c);
-			c = read_next(context)!;
+			c = this.read_next()?;
 			switch (c)
 			{
 				case '-':
 				case '+':
 					t.append(c);
-					c = read_next(context)!;
+					c = this.read_next()?;
 			}
-			if (!c.is_digit()) return JsonParsingError.INVALID_NUMBER?;
-			while (c.is_digit())
+			if (c < '0' || c > '9') return JsonParsingError.INVALID_NUMBER!;
+			while (c >= '0' && c <= '9')
 			{
 				t.append(c);
-				c = read_next(context)!;
+				c = this.read_next()?;
 			}
 		}
-		pushback(context, c);
-		double! d = t.str_view().to_double() ?? JsonParsingError.INVALID_NUMBER?;
-		context.last_number = d!;
+		this.pushback();
+		double! d = str::to_double(t.str()) ?? JsonParsingError.INVALID_NUMBER!;
+		this.last_number = d?;
 		return NUMBER;
 	};
 }
 
-fn Object*! parse_map(JsonContext* context) @local
+fn Object*! JsonParser.parse_map(JsonParser* this)
 {
-	Object* map = object::new_obj(context.allocator);
-	JsonTokenType token = advance(context)!;
+	Object* map = object::new_obj(this.allocator);
+	JsonTokenType token = this.advance()?;
 	defer catch map.free();
 
-	DString temp_key = dstring::new_with_capacity(32, context.allocator);
+	DString temp_key = dstring::new_with_capacity(32, this.allocator);
 	defer temp_key.free();
 	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. 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)
-		{
-			token = advance(context)!;
-			continue;
-		}
-		if (token != JsonTokenType.RBRACE) return JsonParsingError.UNEXPECTED_CHARACTER?;
+		if (token != JsonTokenType.STRING) return JsonParsingError.UNEXPECTED_CHARACTER!;
+        DString string = this.last_string;
+        if (map.has_key(string.str())) 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);
+        this.parse_expected(COLON)?;
+        Object* element = this.parse_any()?;
+		map.set(temp_key.str(), element);
+        token = this.advance()?;
+        if (token == JsonTokenType.COMMA)
+        {
+            token = this.advance()?;
+            continue;
+        }
+        if (token != JsonTokenType.RBRACE) return JsonParsingError.UNEXPECTED_CHARACTER!;
 	}
 	return map;
 }
 
-fn Object*! parse_array(JsonContext* context) @local
+fn Object*! JsonParser.parse_array(JsonParser* this)
 {
-	Object* list = object::new_obj(context.allocator);
+	Object* list = object::new_obj(this.allocator);
 	defer catch list.free();
-	JsonTokenType token = advance(context)!;
+	JsonTokenType token = this.advance()?;
 	while (token != JsonTokenType.RBRACKET)
 	{
-		Object* element = parse_from_token(context, token)!;
+		Object* element = this.parse_from_token(token)?;
 		list.append(element);
-		token = advance(context)!;
+		token = this.advance()?;
 		if (token == JsonTokenType.COMMA)
 		{
-			token = advance(context)!;
-			continue;
+			token = this.advance()?;
+		    continue;
 		}
-		if (token != JsonTokenType.RBRACKET) return JsonParsingError.UNEXPECTED_CHARACTER?;
+		if (token != JsonTokenType.RBRACKET) return JsonParsingError.UNEXPECTED_CHARACTER!;
 	}
 	return list;
 }
 
-fn void pushback(JsonContext* context, char c) @local
+fn void JsonParser.pushback(JsonParser* this)
 {
-	if (!context.reached_end)
-	{
-		assert(!context.pushed_back);
-		context.pushed_back = true;
-		context.current = c;
-	}
+	if (!this.reached_end) this.stream.pushback_byte()!!;
 }
 
-fn char! read_next(JsonContext* context) @local
+fn char! JsonParser.read_next(JsonParser* this)
 {
-	if (context.reached_end) return '\0';
-	if (context.pushed_back)
-	{
-		context.pushed_back = false;
-		return context.current;
-	}
-	char! c = context.stream.read_byte();
+	if (this.reached_end) return '\0';
+	char! c = this.stream.read_byte();
 	if (catch err = c)
 	{
 		case IoError.EOF:
-			context.reached_end = true;
+			this.reached_end = true;
 			return '\0';
 		default:
-			return err?;
+			return err!;
 	}
 	if (c == 0)
 	{
-		context.reached_end = true;
+		this.reached_end = true;
 	}
 	return c;
 }
 
-fn JsonTokenType! advance(JsonContext* context) @local
+fn JsonTokenType! JsonParser.advance(JsonParser* this)
 {
 	char c;
 	// Skip whitespace
-	while WS: (c = read_next(context)!)
+	while WS: (c = this.read_next()?)
 	{
 		switch (c)
 		{
 			case '\n':
-				context.line++;
+				this.line++;
 				nextcase;
 			case ' ':
 			case '\t':
@@ -233,24 +217,24 @@ fn JsonTokenType! advance(JsonContext* context) @local
 			case '\v':
 				continue;
 			case '/':
-				if (!context.skip_comments) break;
-				c = read_next(context)!;
+				if (!this.skip_comments) break;
+				c = this.read_next()?;
 				if (c != '*')
 				{
-					pushback(context, c);
+					this.pushback();
 					break WS;
 				}
-				while COMMENT: (true)
+				while COMMENT: (1)
 				{
 					// Skip to */
-					while (c = read_next(context)!)
+					while (c = this.read_next()?)
 					{
-						if (c == '\n') context.line++;
+						if (c == '\n') this.line++;
 						if (c != '*') continue;
 						// Skip through all the '*'
-						while (c = read_next(context)!)
+						while (c = this.read_next()?)
 						{
-							if (c == '\n') context.line++;
+							if (c == '\n') this.line++;
 							if (c != '*') break;
 						}
 						if (c == '/') break COMMENT;
@@ -264,7 +248,7 @@ fn JsonTokenType! advance(JsonContext* context) @local
 	switch (c)
 	{
 		case '\0':
-			return IoError.EOF?;
+			return IoError.EOF!;
 		case '{':
 			return LBRACE;
 		case '}':
@@ -278,65 +262,65 @@ fn JsonTokenType! advance(JsonContext* context) @local
 		case ',':
 			return COMMA;
 		case '"':
-			return lex_string(context);
+			return this.lex_string();
 		case '-':
 		case '0'..'9':
-			return lex_number(context, c);
+			return this.lex_number(c);
 		case 't':
-			match(context, "rue")!;
+			this.match("rue")?;
 			return TRUE;
 		case 'f':
-			match(context, "alse")!;
+			this.match("alse")?;
 			return FALSE;
 		case 'n':
-			match(context, "ull")!;
+			this.match("ull")?;
 			return NULL;
 		default:
-			return JsonParsingError.UNEXPECTED_CHARACTER?;
+			return JsonParsingError.UNEXPECTED_CHARACTER!;
 	}
 }
 
-fn void! match(JsonContext* context, String str) @local
+fn void! JsonParser.match(JsonParser* this, String str)
 {
 	foreach (c : str)
 	{
-		char l = read_next(context)!;
-		if (l != c) return JsonParsingError.UNEXPECTED_CHARACTER?;
+		char l = this.read_next()?;
+		if (l != c) return JsonParsingError.UNEXPECTED_CHARACTER!;
 	}
 }
 
-fn void! parse_expected(JsonContext* context, JsonTokenType token) @local
+fn void! JsonParser.parse_expected(JsonParser* this, JsonTokenType token) @local
 {
-	if (advance(context)! != token) return JsonParsingError.UNEXPECTED_CHARACTER?;
+	if (this.advance()? != token) return JsonParsingError.UNEXPECTED_CHARACTER!;
 }
 
-fn JsonTokenType! lex_string(JsonContext* context)
+fn JsonTokenType! JsonParser.lex_string(JsonParser *this)
 {
-	context.last_string.clear();
-	while LOOP: (true)
+	this.last_string.clear();
+	while LOOP: (1)
 	{
-		char c = read_next(context)!;
+		char c = this.read_next()?;
 		switch (c)
 		{
 			case '\0':
-				return JsonParsingError.EOF?;
+				return JsonParsingError.EOF!;
 			case 1..31:
-				return JsonParsingError.UNEXPECTED_CHARACTER?;
+				return JsonParsingError.UNEXPECTED_CHARACTER!;
 			case '"':
 				break LOOP;
 			case '\\':
 				break;
 			default:
-				context.last_string.append(c);
+				this.last_string.append(c);
 				continue;
 		}
-		c = read_next(context)!;
+		c = this.read_next()?;
 		switch (c)
 		{
 			case '\0':
-				return JsonParsingError.EOF?;
+				return JsonParsingError.EOF!;
 			case 1..31:
-				return JsonParsingError.UNEXPECTED_CHARACTER?;
+				return JsonParsingError.UNEXPECTED_CHARACTER!;
 			case '"':
 			case '\\':
 			case '/':
@@ -355,14 +339,14 @@ fn JsonTokenType! lex_string(JsonContext* context)
 				uint val;
 				for (int i = 0; i < 4; i++)
 				{
-					c = read_next(context)!;
-					if (!c.is_xdigit()) return JsonParsingError.INVALID_ESCAPE_SEQUENCE?;
+					c = this.read_next()?;
+					if (!c.is_xdigit()) return JsonParsingError.INVALID_ESCAPE_SEQUENCE!;
 					val = val << 4 + (c > '9' ? (c | 32) - 'a' + 10 : c - '0');
 				}
-				context.last_string.append_char32(val);
+				this.last_string.append_char32(val);
 				continue;
 			default:
-				 return JsonParsingError.INVALID_ESCAPE_SEQUENCE?;
+				 return JsonParsingError.INVALID_ESCAPE_SEQUENCE!;
 		}
 	}
 	return STRING;

lib/std/hash/adler32.c3

@@ -8,46 +8,46 @@ const uint ADLER_CONST @private = 65521;
 
 struct Adler32
 {
-	uint a;
-	uint b;
+    uint a;
+    uint b;
 }
 
-fn void Adler32.init(&self)
+fn void Adler32.init(Adler32 *this)
 {
-	*self = { 1, 0 };
+    *this = { 1, 0 };
 }
 
-fn void Adler32.updatec(&self, char c)
+fn void Adler32.updatec(Adler32* this, char c)
 {
-	self.a = (self.a + c) % ADLER_CONST;
-	self.b = (self.b + self.a) % ADLER_CONST;
+    this.a = (this.a + c) % ADLER_CONST;
+    this.b = (this.b + this.a) % ADLER_CONST;
 }
 
-fn void Adler32.update(&self, char[] data)
+fn void Adler32.update(Adler32* this, char[] data)
 {
-	uint a = self.a;
-	uint b = self.b;
-	foreach (char x : data)
-	{
-		a = (a + x) % ADLER_CONST;
-		b = (b + a) % ADLER_CONST;
-	}
-	*self = { a, b };
+    uint a = this.a;
+    uint b = this.b;
+    foreach (char x : data)
+    {
+        a = (a + x) % ADLER_CONST;
+        b = (b + a) % ADLER_CONST;
+    }
+    *this = { a, b };
 }
 
-fn uint Adler32.final(&self)
+fn uint Adler32.final(Adler32* this)
 {
-	return (self.b << 16) | self.a;
+    return (this.b << 16) | this.a;
 }
 
 fn uint encode(char[] data)
 {
-	uint a = 1;
-	uint b = 0;
-	foreach (char x : data)
-	{
-		a = (a + x) % ADLER_CONST;
-		b = (b + a) % ADLER_CONST;
-	}
-	return (b << 16) | a;
+    uint a = 1;
+    uint b = 0;
+    foreach (char x : data)
+    {
+        a = (a + x) % ADLER_CONST;
+        b = (b + a) % ADLER_CONST;
+    }
+    return (b << 16) | a;
 }

lib/std/hash/crc32.c3

@@ -5,41 +5,41 @@ module std::hash::crc32;
 
 struct Crc32
 {
-	uint result;
+    uint result;
 }
 
-fn void Crc32.init(&self, uint seed = 0)
+fn void Crc32.init(Crc32* this, uint seed = 0)
 {
-	self.result = ~seed;
+    this.result = ~seed;
 }
 
-fn void Crc32.updatec(&self, char c)
+fn void Crc32.updatec(Crc32* this, char c)
 {
-	self.result = (self.result >> 8) ^ CRC32_TABLE[(self.result ^ c) & 0xFF];
+    this.result = (this.result >> 8) ^ CRC32_TABLE[(this.result ^ c) & 0xFF];
 }
 
-fn void Crc32.update(&self, char[] data)
+fn void Crc32.update(Crc32* this, char[] data)
 {
-	uint result = self.result;
-	foreach (char x : data)
-	{
-		result = (result >> 8) ^ CRC32_TABLE[(result ^ x) & 0xFF];
-	}
-	self.result = result;
+    uint result = this.result;
+    foreach (char x : data)
+    {
+        result = (result >> 8) ^ CRC32_TABLE[(result ^ x) & 0xFF];
+    }
+    this.result = result;
 }
 
-fn uint Crc32.final(&self)
+fn uint Crc32.final(Crc32* this)
 {
-	return ~self.result;
+    return ~this.result;
 }
 
 fn uint encode(char[] data)
 {
-	uint result = ~(uint)(0);
-	foreach (char x : data)
-	{
-		result = (result >> 8) ^ CRC32_TABLE[(result ^ x) & 0xFF];
-	}
+    uint result = ~(uint)(0);
+    foreach (char x : data)
+    {
+        result = (result >> 8) ^ CRC32_TABLE[(result ^ x) & 0xFF];
+    }
 	return ~result;
 }
 

lib/std/hash/crc64.c3

@@ -5,107 +5,107 @@ module std::hash::crc64;
 
 struct Crc64
 {
-	ulong result;
+    ulong result;
 }
 
-fn void Crc64.init(&self, uint seed = 0)
+fn void Crc64.init(Crc64* this, uint seed = 0)
 {
-	self.result = seed;
+    this.result = seed;
 }
 
-fn void Crc64.updatec(&self, char c)
+fn void Crc64.updatec(Crc64* this, char c)
 {
-	self.result = (self.result << 8) ^ CRC64_TABLE[(char)((self.result >> 56) ^ c)];
+    this.result = (this.result << 8) ^ CRC64_TABLE[(char)((this.result >> 56) ^ c)];
 }
 
-fn void Crc64.update(&self, char[] data)
+fn void Crc64.update(Crc64* this, char[] data)
 {
-	ulong result = self.result;
-	foreach (char x : data)
-	{
-		result = (result << 8) ^ CRC64_TABLE[(char)((result >> 56) ^ x)];
-	}
-	self.result = result;
+    ulong result = this.result;
+    foreach (char x : data)
+    {
+        result = (result << 8) ^ CRC64_TABLE[(char)((result >> 56) ^ x)];
+    }
+    this.result = result;
 }
 
-fn ulong Crc64.final(&self)
+fn ulong Crc64.final(Crc64* this)
 {
-	return self.result;
+    return this.result;
 }
 
 fn ulong encode(char[] data)
 {
-	ulong result = (ulong)(0);
-	foreach (char x : data)
-	{
-		result = (result << 8) ^ CRC64_TABLE[(char)((result >> 56) ^ x)];
-	}
+    ulong result = (ulong)(0);
+    foreach (char x : data)
+    {
+        result = (result << 8) ^ CRC64_TABLE[(char)((result >> 56) ^ x)];
+    }
 	return result;
 }
 
 const ulong[256] CRC64_TABLE @private = {
-	0x0000000000000000, 0x42f0e1eba9ea3693, 0x85e1c3d753d46d26, 0xc711223cfa3e5bb5,
-	0x493366450e42ecdf, 0x0bc387aea7a8da4c, 0xccd2a5925d9681f9, 0x8e224479f47cb76a,
-	0x9266cc8a1c85d9be, 0xd0962d61b56fef2d, 0x17870f5d4f51b498, 0x5577eeb6e6bb820b,
-	0xdb55aacf12c73561, 0x99a54b24bb2d03f2, 0x5eb4691841135847, 0x1c4488f3e8f96ed4,
-	0x663d78ff90e185ef, 0x24cd9914390bb37c, 0xe3dcbb28c335e8c9, 0xa12c5ac36adfde5a,
-	0x2f0e1eba9ea36930, 0x6dfeff5137495fa3, 0xaaefdd6dcd770416, 0xe81f3c86649d3285,
-	0xf45bb4758c645c51, 0xb6ab559e258e6ac2, 0x71ba77a2dfb03177, 0x334a9649765a07e4,
-	0xbd68d2308226b08e, 0xff9833db2bcc861d, 0x388911e7d1f2dda8, 0x7a79f00c7818eb3b,
-	0xcc7af1ff21c30bde, 0x8e8a101488293d4d, 0x499b3228721766f8, 0x0b6bd3c3dbfd506b,
-	0x854997ba2f81e701, 0xc7b97651866bd192, 0x00a8546d7c558a27, 0x4258b586d5bfbcb4,
-	0x5e1c3d753d46d260, 0x1cecdc9e94ace4f3, 0xdbfdfea26e92bf46, 0x990d1f49c77889d5,
-	0x172f5b3033043ebf, 0x55dfbadb9aee082c, 0x92ce98e760d05399, 0xd03e790cc93a650a,
-	0xaa478900b1228e31, 0xe8b768eb18c8b8a2, 0x2fa64ad7e2f6e317, 0x6d56ab3c4b1cd584,
-	0xe374ef45bf6062ee, 0xa1840eae168a547d, 0x66952c92ecb40fc8, 0x2465cd79455e395b,
-	0x3821458aada7578f, 0x7ad1a461044d611c, 0xbdc0865dfe733aa9, 0xff3067b657990c3a,
-	0x711223cfa3e5bb50, 0x33e2c2240a0f8dc3, 0xf4f3e018f031d676, 0xb60301f359dbe0e5,
-	0xda050215ea6c212f, 0x98f5e3fe438617bc, 0x5fe4c1c2b9b84c09, 0x1d14202910527a9a,
-	0x93366450e42ecdf0, 0xd1c685bb4dc4fb63, 0x16d7a787b7faa0d6, 0x5427466c1e109645,
-	0x4863ce9ff6e9f891, 0x0a932f745f03ce02, 0xcd820d48a53d95b7, 0x8f72eca30cd7a324,
-	0x0150a8daf8ab144e, 0x43a04931514122dd, 0x84b16b0dab7f7968, 0xc6418ae602954ffb,
-	0xbc387aea7a8da4c0, 0xfec89b01d3679253, 0x39d9b93d2959c9e6, 0x7b2958d680b3ff75,
-	0xf50b1caf74cf481f, 0xb7fbfd44dd257e8c, 0x70eadf78271b2539, 0x321a3e938ef113aa,
-	0x2e5eb66066087d7e, 0x6cae578bcfe24bed, 0xabbf75b735dc1058, 0xe94f945c9c3626cb,
-	0x676dd025684a91a1, 0x259d31cec1a0a732, 0xe28c13f23b9efc87, 0xa07cf2199274ca14,
-	0x167ff3eacbaf2af1, 0x548f120162451c62, 0x939e303d987b47d7, 0xd16ed1d631917144,
-	0x5f4c95afc5edc62e, 0x1dbc74446c07f0bd, 0xdaad56789639ab08, 0x985db7933fd39d9b,
-	0x84193f60d72af34f, 0xc6e9de8b7ec0c5dc, 0x01f8fcb784fe9e69, 0x43081d5c2d14a8fa,
-	0xcd2a5925d9681f90, 0x8fdab8ce70822903, 0x48cb9af28abc72b6, 0x0a3b7b1923564425,
-	0x70428b155b4eaf1e, 0x32b26afef2a4998d, 0xf5a348c2089ac238, 0xb753a929a170f4ab,
-	0x3971ed50550c43c1, 0x7b810cbbfce67552, 0xbc902e8706d82ee7, 0xfe60cf6caf321874,
-	0xe224479f47cb76a0, 0xa0d4a674ee214033, 0x67c58448141f1b86, 0x253565a3bdf52d15,
-	0xab1721da49899a7f, 0xe9e7c031e063acec, 0x2ef6e20d1a5df759, 0x6c0603e6b3b7c1ca,
-	0xf6fae5c07d3274cd, 0xb40a042bd4d8425e, 0x731b26172ee619eb, 0x31ebc7fc870c2f78,
-	0xbfc9838573709812, 0xfd39626eda9aae81, 0x3a28405220a4f534, 0x78d8a1b9894ec3a7,
-	0x649c294a61b7ad73, 0x266cc8a1c85d9be0, 0xe17dea9d3263c055, 0xa38d0b769b89f6c6,
-	0x2daf4f0f6ff541ac, 0x6f5faee4c61f773f, 0xa84e8cd83c212c8a, 0xeabe6d3395cb1a19,
-	0x90c79d3fedd3f122, 0xd2377cd44439c7b1, 0x15265ee8be079c04, 0x57d6bf0317edaa97,
-	0xd9f4fb7ae3911dfd, 0x9b041a914a7b2b6e, 0x5c1538adb04570db, 0x1ee5d94619af4648,
-	0x02a151b5f156289c, 0x4051b05e58bc1e0f, 0x87409262a28245ba, 0xc5b073890b687329,
-	0x4b9237f0ff14c443, 0x0962d61b56fef2d0, 0xce73f427acc0a965, 0x8c8315cc052a9ff6,
-	0x3a80143f5cf17f13, 0x7870f5d4f51b4980, 0xbf61d7e80f251235, 0xfd913603a6cf24a6,
-	0x73b3727a52b393cc, 0x31439391fb59a55f, 0xf652b1ad0167feea, 0xb4a25046a88dc879,
-	0xa8e6d8b54074a6ad, 0xea16395ee99e903e, 0x2d071b6213a0cb8b, 0x6ff7fa89ba4afd18,
-	0xe1d5bef04e364a72, 0xa3255f1be7dc7ce1, 0x64347d271de22754, 0x26c49cccb40811c7,
-	0x5cbd6cc0cc10fafc, 0x1e4d8d2b65facc6f, 0xd95caf179fc497da, 0x9bac4efc362ea149,
-	0x158e0a85c2521623, 0x577eeb6e6bb820b0, 0x906fc95291867b05, 0xd29f28b9386c4d96,
-	0xcedba04ad0952342, 0x8c2b41a1797f15d1, 0x4b3a639d83414e64, 0x09ca82762aab78f7,
-	0x87e8c60fded7cf9d, 0xc51827e4773df90e, 0x020905d88d03a2bb, 0x40f9e43324e99428,
-	0x2cffe7d5975e55e2, 0x6e0f063e3eb46371, 0xa91e2402c48a38c4, 0xebeec5e96d600e57,
-	0x65cc8190991cb93d, 0x273c607b30f68fae, 0xe02d4247cac8d41b, 0xa2dda3ac6322e288,
-	0xbe992b5f8bdb8c5c, 0xfc69cab42231bacf, 0x3b78e888d80fe17a, 0x7988096371e5d7e9,
-	0xf7aa4d1a85996083, 0xb55aacf12c735610, 0x724b8ecdd64d0da5, 0x30bb6f267fa73b36,
-	0x4ac29f2a07bfd00d, 0x08327ec1ae55e69e, 0xcf235cfd546bbd2b, 0x8dd3bd16fd818bb8,
-	0x03f1f96f09fd3cd2, 0x41011884a0170a41, 0x86103ab85a2951f4, 0xc4e0db53f3c36767,
-	0xd8a453a01b3a09b3, 0x9a54b24bb2d03f20, 0x5d45907748ee6495, 0x1fb5719ce1045206,
-	0x919735e51578e56c, 0xd367d40ebc92d3ff, 0x1476f63246ac884a, 0x568617d9ef46bed9,
-	0xe085162ab69d5e3c, 0xa275f7c11f7768af, 0x6564d5fde549331a, 0x279434164ca30589,
-	0xa9b6706fb8dfb2e3, 0xeb46918411358470, 0x2c57b3b8eb0bdfc5, 0x6ea7525342e1e956,
-	0x72e3daa0aa188782, 0x30133b4b03f2b111, 0xf7021977f9cceaa4, 0xb5f2f89c5026dc37,
-	0x3bd0bce5a45a6b5d, 0x79205d0e0db05dce, 0xbe317f32f78e067b, 0xfcc19ed95e6430e8,
-	0x86b86ed5267cdbd3, 0xc4488f3e8f96ed40, 0x0359ad0275a8b6f5, 0x41a94ce9dc428066,
-	0xcf8b0890283e370c, 0x8d7be97b81d4019f, 0x4a6acb477bea5a2a, 0x089a2aacd2006cb9,
-	0x14dea25f3af9026d, 0x562e43b4931334fe, 0x913f6188692d6f4b, 0xd3cf8063c0c759d8,
-	0x5dedc41a34bbeeb2, 0x1f1d25f19d51d821, 0xd80c07cd676f8394, 0x9afce626ce85b507,
+    0x0000000000000000, 0x42f0e1eba9ea3693, 0x85e1c3d753d46d26, 0xc711223cfa3e5bb5,
+   	0x493366450e42ecdf, 0x0bc387aea7a8da4c, 0xccd2a5925d9681f9, 0x8e224479f47cb76a,
+   	0x9266cc8a1c85d9be, 0xd0962d61b56fef2d, 0x17870f5d4f51b498, 0x5577eeb6e6bb820b,
+   	0xdb55aacf12c73561, 0x99a54b24bb2d03f2, 0x5eb4691841135847, 0x1c4488f3e8f96ed4,
+   	0x663d78ff90e185ef, 0x24cd9914390bb37c, 0xe3dcbb28c335e8c9, 0xa12c5ac36adfde5a,
+   	0x2f0e1eba9ea36930, 0x6dfeff5137495fa3, 0xaaefdd6dcd770416, 0xe81f3c86649d3285,
+   	0xf45bb4758c645c51, 0xb6ab559e258e6ac2, 0x71ba77a2dfb03177, 0x334a9649765a07e4,
+   	0xbd68d2308226b08e, 0xff9833db2bcc861d, 0x388911e7d1f2dda8, 0x7a79f00c7818eb3b,
+   	0xcc7af1ff21c30bde, 0x8e8a101488293d4d, 0x499b3228721766f8, 0x0b6bd3c3dbfd506b,
+   	0x854997ba2f81e701, 0xc7b97651866bd192, 0x00a8546d7c558a27, 0x4258b586d5bfbcb4,
+   	0x5e1c3d753d46d260, 0x1cecdc9e94ace4f3, 0xdbfdfea26e92bf46, 0x990d1f49c77889d5,
+   	0x172f5b3033043ebf, 0x55dfbadb9aee082c, 0x92ce98e760d05399, 0xd03e790cc93a650a,
+   	0xaa478900b1228e31, 0xe8b768eb18c8b8a2, 0x2fa64ad7e2f6e317, 0x6d56ab3c4b1cd584,
+   	0xe374ef45bf6062ee, 0xa1840eae168a547d, 0x66952c92ecb40fc8, 0x2465cd79455e395b,
+   	0x3821458aada7578f, 0x7ad1a461044d611c, 0xbdc0865dfe733aa9, 0xff3067b657990c3a,
+   	0x711223cfa3e5bb50, 0x33e2c2240a0f8dc3, 0xf4f3e018f031d676, 0xb60301f359dbe0e5,
+   	0xda050215ea6c212f, 0x98f5e3fe438617bc, 0x5fe4c1c2b9b84c09, 0x1d14202910527a9a,
+   	0x93366450e42ecdf0, 0xd1c685bb4dc4fb63, 0x16d7a787b7faa0d6, 0x5427466c1e109645,
+   	0x4863ce9ff6e9f891, 0x0a932f745f03ce02, 0xcd820d48a53d95b7, 0x8f72eca30cd7a324,
+   	0x0150a8daf8ab144e, 0x43a04931514122dd, 0x84b16b0dab7f7968, 0xc6418ae602954ffb,
+   	0xbc387aea7a8da4c0, 0xfec89b01d3679253, 0x39d9b93d2959c9e6, 0x7b2958d680b3ff75,
+   	0xf50b1caf74cf481f, 0xb7fbfd44dd257e8c, 0x70eadf78271b2539, 0x321a3e938ef113aa,
+   	0x2e5eb66066087d7e, 0x6cae578bcfe24bed, 0xabbf75b735dc1058, 0xe94f945c9c3626cb,
+   	0x676dd025684a91a1, 0x259d31cec1a0a732, 0xe28c13f23b9efc87, 0xa07cf2199274ca14,
+   	0x167ff3eacbaf2af1, 0x548f120162451c62, 0x939e303d987b47d7, 0xd16ed1d631917144,
+   	0x5f4c95afc5edc62e, 0x1dbc74446c07f0bd, 0xdaad56789639ab08, 0x985db7933fd39d9b,
+   	0x84193f60d72af34f, 0xc6e9de8b7ec0c5dc, 0x01f8fcb784fe9e69, 0x43081d5c2d14a8fa,
+   	0xcd2a5925d9681f90, 0x8fdab8ce70822903, 0x48cb9af28abc72b6, 0x0a3b7b1923564425,
+   	0x70428b155b4eaf1e, 0x32b26afef2a4998d, 0xf5a348c2089ac238, 0xb753a929a170f4ab,
+   	0x3971ed50550c43c1, 0x7b810cbbfce67552, 0xbc902e8706d82ee7, 0xfe60cf6caf321874,
+   	0xe224479f47cb76a0, 0xa0d4a674ee214033, 0x67c58448141f1b86, 0x253565a3bdf52d15,
+   	0xab1721da49899a7f, 0xe9e7c031e063acec, 0x2ef6e20d1a5df759, 0x6c0603e6b3b7c1ca,
+   	0xf6fae5c07d3274cd, 0xb40a042bd4d8425e, 0x731b26172ee619eb, 0x31ebc7fc870c2f78,
+   	0xbfc9838573709812, 0xfd39626eda9aae81, 0x3a28405220a4f534, 0x78d8a1b9894ec3a7,
+   	0x649c294a61b7ad73, 0x266cc8a1c85d9be0, 0xe17dea9d3263c055, 0xa38d0b769b89f6c6,
+   	0x2daf4f0f6ff541ac, 0x6f5faee4c61f773f, 0xa84e8cd83c212c8a, 0xeabe6d3395cb1a19,
+   	0x90c79d3fedd3f122, 0xd2377cd44439c7b1, 0x15265ee8be079c04, 0x57d6bf0317edaa97,
+   	0xd9f4fb7ae3911dfd, 0x9b041a914a7b2b6e, 0x5c1538adb04570db, 0x1ee5d94619af4648,
+   	0x02a151b5f156289c, 0x4051b05e58bc1e0f, 0x87409262a28245ba, 0xc5b073890b687329,
+   	0x4b9237f0ff14c443, 0x0962d61b56fef2d0, 0xce73f427acc0a965, 0x8c8315cc052a9ff6,
+   	0x3a80143f5cf17f13, 0x7870f5d4f51b4980, 0xbf61d7e80f251235, 0xfd913603a6cf24a6,
+   	0x73b3727a52b393cc, 0x31439391fb59a55f, 0xf652b1ad0167feea, 0xb4a25046a88dc879,
+   	0xa8e6d8b54074a6ad, 0xea16395ee99e903e, 0x2d071b6213a0cb8b, 0x6ff7fa89ba4afd18,
+   	0xe1d5bef04e364a72, 0xa3255f1be7dc7ce1, 0x64347d271de22754, 0x26c49cccb40811c7,
+   	0x5cbd6cc0cc10fafc, 0x1e4d8d2b65facc6f, 0xd95caf179fc497da, 0x9bac4efc362ea149,
+   	0x158e0a85c2521623, 0x577eeb6e6bb820b0, 0x906fc95291867b05, 0xd29f28b9386c4d96,
+   	0xcedba04ad0952342, 0x8c2b41a1797f15d1, 0x4b3a639d83414e64, 0x09ca82762aab78f7,
+   	0x87e8c60fded7cf9d, 0xc51827e4773df90e, 0x020905d88d03a2bb, 0x40f9e43324e99428,
+   	0x2cffe7d5975e55e2, 0x6e0f063e3eb46371, 0xa91e2402c48a38c4, 0xebeec5e96d600e57,
+   	0x65cc8190991cb93d, 0x273c607b30f68fae, 0xe02d4247cac8d41b, 0xa2dda3ac6322e288,
+   	0xbe992b5f8bdb8c5c, 0xfc69cab42231bacf, 0x3b78e888d80fe17a, 0x7988096371e5d7e9,
+   	0xf7aa4d1a85996083, 0xb55aacf12c735610, 0x724b8ecdd64d0da5, 0x30bb6f267fa73b36,
+   	0x4ac29f2a07bfd00d, 0x08327ec1ae55e69e, 0xcf235cfd546bbd2b, 0x8dd3bd16fd818bb8,
+   	0x03f1f96f09fd3cd2, 0x41011884a0170a41, 0x86103ab85a2951f4, 0xc4e0db53f3c36767,
+   	0xd8a453a01b3a09b3, 0x9a54b24bb2d03f20, 0x5d45907748ee6495, 0x1fb5719ce1045206,
+   	0x919735e51578e56c, 0xd367d40ebc92d3ff, 0x1476f63246ac884a, 0x568617d9ef46bed9,
+   	0xe085162ab69d5e3c, 0xa275f7c11f7768af, 0x6564d5fde549331a, 0x279434164ca30589,
+   	0xa9b6706fb8dfb2e3, 0xeb46918411358470, 0x2c57b3b8eb0bdfc5, 0x6ea7525342e1e956,
+   	0x72e3daa0aa188782, 0x30133b4b03f2b111, 0xf7021977f9cceaa4, 0xb5f2f89c5026dc37,
+   	0x3bd0bce5a45a6b5d, 0x79205d0e0db05dce, 0xbe317f32f78e067b, 0xfcc19ed95e6430e8,
+   	0x86b86ed5267cdbd3, 0xc4488f3e8f96ed40, 0x0359ad0275a8b6f5, 0x41a94ce9dc428066,
+   	0xcf8b0890283e370c, 0x8d7be97b81d4019f, 0x4a6acb477bea5a2a, 0x089a2aacd2006cb9,
+   	0x14dea25f3af9026d, 0x562e43b4931334fe, 0x913f6188692d6f4b, 0xd3cf8063c0c759d8,
+   	0x5dedc41a34bbeeb2, 0x1f1d25f19d51d821, 0xd80c07cd676f8394, 0x9afce626ce85b507,
 };

lib/std/hash/fnv32a.c3

@@ -3,39 +3,39 @@
 // a copy of which can be found in the LICENSE_STDLIB file.
 module std::hash::fnv32a;
 
-distinct Fnv32a = uint;
+typedef Fnv32a = distinct uint;
 
 const FNV32A_START @private = 0x811c9dc5;
 const FNV32A_MUL @private = 0x01000193;
 
-macro void @update(uint* &h, char x) @private => *h = (*h * FNV32A_MUL) ^ x;
+macro void @update(uint &h, char x) @private => h = (h * FNV32A_MUL) ^ x;
 
-fn void Fnv32a.init(&self)
+fn void Fnv32a.init(Fnv32a* this)
 {
-	*self = FNV32A_START;
+    *this = FNV32A_START;
 }
 
-fn void Fnv32a.update(&self, char[] data)
+fn void Fnv32a.update(Fnv32a* this, char[] data)
 {
-	uint h = (uint)*self;
+	uint h = (uint)*this;
 	foreach (char x : data)
-	{
-		@update(h, x);
-	}
-	*self = (Fnv32a)h;
+    {
+        @update(h, x);
+    }
+    *this = (Fnv32a)h;
 }
 
-macro void Fnv32a.update_char(&self, char c)
+macro void Fnv32a.update_char(Fnv32a* this, char c)
 {
-	@update(*self, x);
+	@update(*this, x);
 }
 
 fn uint encode(char[] data)
 {
 	uint h = FNV32A_START;
 	foreach (char x : data)
-	{
+    {
 		@update(h, x);
-	}
-	return h;
+    }
+    return h;
 }

lib/std/hash/fnv64a.c3

@@ -1,41 +0,0 @@
-// Copyright (c) 2021 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::hash::fnv64a;
-
-distinct Fnv64a = ulong;
-
-const FNV64A_START @private = 0xcbf29ce484222325;
-const FNV64A_MUL @private = 0x00000100000001b3;
-
-macro void @update(ulong* &h, char x) @private => *h = (*h * FNV64A_MUL) ^ x;
-
-fn void Fnv64a.init(&self)
-{
-	*self = FNV64A_START;
-}
-
-fn void Fnv64a.update(&self, char[] data)
-{
-	ulong h = (ulong)*self;
-	foreach (char x : data)
-	{
-		@update(h, x);
-	}
-	*self = (Fnv64a)h;
-}
-
-macro void Fnv64a.update_char(&self, char c)
-{
-	@update(*self, x);
-}
-
-fn ulong encode(char[] data)
-{
-	ulong h = FNV64A_START;
-	foreach (char x : data)
-	{
-		@update(h, x);
-	}
-	return h;
-}

lib/std/hash/sha1.c3

@@ -14,69 +14,70 @@ struct Sha1
 	char[64] buffer;
 }
 
-fn void Sha1.init(&self)
+fn void Sha1.init(Sha1* this)
 {
-	// SHA1 initialization constants
-	*self = {
-		.state = {
-			0x67452301,
-			0xEFCDAB89,
-			0x98BADCFE,
-			0x10325476,
-			0xC3D2E1F0
-		}
+    // SHA1 initialization constants
+    *this = {
+        .state = {
+            0x67452301,
+            0xEFCDAB89,
+            0x98BADCFE,
+            0x10325476,
+            0xC3D2E1F0
+        }
 	};
 }
 
 /**
+ * @param [&inout] this
  * @param [in] data
  * @require data.len <= uint.max
  **/
-fn void Sha1.update(&self, char[] data)
+fn void Sha1.update(Sha1* this, char[] data)
 {
-	uint j = self.count[0];
+	uint j = this.count[0];
 	uint len = data.len;
-	if ((self.count[0] += len << 3) < j) self.count[1]++;
-	self.count[1] += len >> 29;
+	if ((this.count[0] += len << 3) < j) this.count[1]++;
+	this.count[1] += len >> 29;
 	j = (j >> 3) & 63;
 	uint i;
 	if (j + len > 63)
 	{
 		i = 64 - j;
-		self.buffer[j..] = data[:i];
-		sha1_transform(&self.state, &self.buffer);
+		this.buffer[j..] = data[:i];
+		sha1_transform(&this.state, &this.buffer);
 		for (; i + 63 < len; i += 64)
 		{
-			sha1_transform(&self.state, &data[i]);
+			sha1_transform(&this.state, &data[i]);
 		}
 		j = 0;
 	}
-	self.buffer[j:len - i] = data[i..];
+	this.buffer[j:len - i] = data[i..];
 }
 
 
-fn char[20] Sha1.final(&self)
+fn char[20] Sha1.final(Sha1* this)
 {
 	char[8] finalcount;
 	for (uint i = 0; i < 8; i++)
 	{
-		finalcount[i] = (char)((self.count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 0xFF);
+		finalcount[i] = (char)((this.count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 0xFF);
 	}
-	self.update(char[] { 0o200 });
-	while ((self.count[0] & 504) != 448)
+	this.update(char[] { 0o200 });
+	while ((this.count[0] & 504) != 448)
 	{
-		self.update(char[] { 0 });
+		this.update(char[] { 0 });
 	}
 
-	self.update(&finalcount);
+	this.update(&finalcount);
 	char[20] digest;
 	for (uint i = 0; i < 20; i++)
 	{
-		digest[i] = (char)((self.state[i >> 2] >> ((3 - (i & 3)) * 8)) & 0xFF);
+		digest[i] = (char)((this.state[i >> 2] >> ((3 - (i & 3)) * 8)) & 0xFF);
 	}
 
 	// Clear mem
-	mem::clear(self, Sha1.sizeof);
+	mem::clear(this, Sha1.sizeof);
 	finalcount = {};
 	return digest;
 }
@@ -95,47 +96,42 @@ macro @blk(&block, i) @local
 
 macro @blk0(&block, i) @local
 {
-	$if env::BIG_ENDIAN:
-		return block.l[i];
-	$else
-		return block.l[i] = (block.l[i].rotl(24) & 0xFF00FF00)
-			| (block.l[i].rotl(8) & 0x00FF00FF);
-	$endif
+$if (env::BIG_ENDIAN)
+	return block.l[i];
+$else
+	return block.l[i] = (block.l[i].rotl(24) & 0xFF00FF00)
+        | (block.l[i].rotl(8) & 0x00FF00FF);
+$endif
 }
 
-macro @r0(&block, v, &wref, x, y, &z, i) @local
+macro @r0(&block, v, &w, x, y, &z, i) @local
 {
-	var w = *wref;
-	*z += ((w & (x ^ y)) ^ y) + @blk0(*block, i) + 0x5A827999 + v.rotl(5);
-	*wref = w.rotl(30);
+	z += ((w & (x ^ y)) ^ y) + @blk0(block, i) + 0x5A827999 + v.rotl(5);
+	w = w.rotl(30);
 }
 
-macro @r1(&block, v, &wref, x, y, &z, i) @local
+macro @r1(&block, v, &w, x, y, &z, i) @local
 {
-	var w = *wref;
-	*z += ((w & (x ^ y)) ^ y) + @blk(*block, i) + 0x5A827999 + v.rotl(5);
-	*wref = w.rotl(30);
+	z += ((w & (x ^ y)) ^ y) + @blk(block, i) + 0x5A827999 + v.rotl(5);
+	w = w.rotl(30);
 }
 
-macro @r2(&block, v, &wref, x, y, &z, i) @local
+macro @r2(&block, v, &w, x, y, &z, i) @local
 {
-	var w = *wref;
-	*z += (w ^ x ^ y) + @blk(*block, i) + 0x6ED9EBA1 + v.rotl(5);
-	*wref = w.rotl(30);
+	z += (w ^ x ^ y) + @blk(block, i) + 0x6ED9EBA1 + v.rotl(5);
+	w = w.rotl(30);
 }
 
-macro @r3(&block, v, &wref, x, y, &z, i) @local
+macro @r3(&block, v, &w, x, y, &z, i) @local
 {
-	var w = *wref;
-	*z += (((w | x) & y) | (w & x)) + @blk(*block, i) + 0x8F1BBCDC + v.rotl(5);
-	*wref = w.rotl(30);
+	z += (((w | x) &y) | (w & x)) + @blk(block, i) + 0x8F1BBCDC + v.rotl(5);
+	w = w.rotl(30);
 }
 
-macro @r4(&block, v, &wref, x, y, &z, i) @local
+macro @r4(&block, v, &w, x, y, &z, i) @local
 {
-	var w = *wref;
-	*z += (w ^ x ^ y) + @blk(*block, i) + 0xCA62C1D6 + v.rotl(5);
-	*wref = w.rotl(30);
+	z += (w ^ x ^ y) + @blk(block, i) + 0xCA62C1D6 + v.rotl(5);
+	w = w.rotl(30);
 }
 
 /**

lib/std/io/bits.c3

@@ -1,85 +0,0 @@
-module std::io;
-
-struct BitReader
-{
-	InStream* reader;
-	uint bits;
-	uint len;
-}
-
-fn void BitReader.init(&self, InStream* byte_reader)
-{
-	*self = { .reader = byte_reader };
-}
-
-fn void BitReader.clear(&self) @inline
-{
-	self.len = 0;
-}
-
-/**
- * @require nbits <= 8
- * @require self.len + nbits <= uint.sizeof * 8
- **/
-fn char! BitReader.read_bits(&self, uint nbits)
-{
-	uint bits = self.bits;
-	if (self.len < nbits)
-	{
-		// New bits are pushed right.
-		char c = self.reader.read_byte()!;
-		bits <<= 8;
-		bits |= c;
-		self.bits = bits;
-		self.len += 8;
-	}
-	self.len -= nbits;
-	uint mask = (1 << nbits) - 1;
-	return (char)((bits >> self.len) & mask);
-}
-
-struct BitWriter
-{
-	OutStream* writer;
-	uint bits;
-	uint len;
-}
-
-fn void BitWriter.init(&self, OutStream* byte_writer)
-{
-	*self = { .writer = byte_writer };
-}
-
-fn void! BitWriter.flush(&self)
-{
-	if (self.len == 0) return;
-	uint bits = self.bits << (32 - self.len);
-	uint n = (self.len + 7) / 8;
-	char[4] buffer;
-	bitorder::write(bits, &buffer, UIntBE);
-	io::write_all(self.writer, buffer[:n])!;
-	self.len = 0;
-}
-
-/**
- * @require nbits <= 8
- **/
-fn void! BitWriter.write_bits(&self, uint bits, uint nbits)
-{
-	if (nbits == 0) return;
-	uint n = self.len + nbits;
-	uint to_write = n / 8;
-	uint left = n % 8;
-	if (to_write > 0)
-	{
-		ulong lbits;
-		if (self.len > 0) lbits = (ulong)self.bits << (64 - self.len);
-		lbits |= (ulong)(bits >> left) << (64 - (n - left));
-		char[8] buffer;
-		bitorder::write(lbits, &buffer, ULongBE);
-		io::write_all(self.writer, buffer[:to_write])!;
-	}
-	self.bits <<= left;
-	self.bits |= bits & ((1 << left) - 1);
-	self.len = left;
-}

lib/std/io/dir.c3

@@ -0,0 +1,3 @@
+module std::io::dir;
+import std::io::os;
+

lib/std/io/file.c3

@@ -1,191 +0,0 @@
-module std::io;
-import libc;
-
-struct File (InStream, OutStream)
-{
-	CFile file;
-}
-
-module std::io::file;
-import libc, std::io::path, std::io::os;
-
-fn File! open(String filename, String mode)
-{
-	return from_handle(os::native_fopen(filename, mode));
-}
-
-fn File! open_path(Path path, String mode)
-{
-	return from_handle(os::native_fopen(path.str_view(), mode));
-}
-
-fn File from_handle(CFile file)
-{
-	return { .file = file };
-}
-
-fn bool is_file(String path)
-{
-	return os::native_is_file(path);
-}
-
-fn usz! get_size(String path)
-{
-	return os::native_file_size(path);
-}
-
-fn void! delete(String filename) => os::native_remove(filename) @inline;
-
-
-/**
- * @require self.file != null
- **/
-fn void! File.reopen(&self, String filename, String mode)
-{
-	self.file = os::native_freopen(self.file, filename, mode)!;
-}
-
-/**
- * @require self.file != null
- **/
-fn usz! File.seek(&self, isz offset, Seek seek_mode = Seek.SET) @dynamic
-{
-	os::native_fseek(self.file, offset, seek_mode)!;
-	return os::native_ftell(self.file);
-}
-
-
-/*
-Implement later
-/**
- * @require self.file == null
- **/
-fn void! File.memopen(File* file, char[] data, String mode)
-{
-	@pool()
-	{
-		file.file = libc::memopen(data.ptr, data.len, mode.zstr_tcopy(), file.file);
-		// TODO errors
-	};
-}
-*/
-
-
-/**
- * @require self.file != null
- */
-fn void! File.write_byte(&self, char c) @dynamic
-{
-	if (!libc::fputc(c, self.file)) return IoError.EOF?;
-}
-
-/**
- * @param [&inout] self
- */
-fn void! File.close(&self) @inline @dynamic
-{
-	if (self.file && libc::fclose(self.file))
-	{
-		switch (libc::errno())
-		{
-			case errno::ECONNRESET:
-			case errno::EBADF: return IoError.FILE_NOT_VALID?;
-			case errno::EINTR: return IoError.INTERRUPTED?;
-			case errno::EDQUOT:
-			case errno::EFAULT:
-			case errno::EAGAIN:
-			case errno::EFBIG:
-			case errno::ENETDOWN:
-			case errno::ENETUNREACH:
-			case errno::ENOSPC:
-			case errno::EIO: return IoError.INCOMPLETE_WRITE?;
-			default: return IoError.UNKNOWN_ERROR?;
-		}
-	}
-	self.file = null;
-}
-
-/**
- * @require self.file
- */
-fn bool File.eof(&self) @inline
-{
-	return libc::feof(self.file) != 0;
-}
-
-/**
- * @param [in] buffer
- */
-fn usz! File.read(&self, char[] buffer) @dynamic
-{
-	return os::native_fread(self.file, buffer);
-}
-
-/**
- * @param [out] buffer
- * @require self.file `File must be initialized`
- */
-fn usz! File.write(&self, char[] buffer) @dynamic
-{
-	return os::native_fwrite(self.file, buffer);
-}
-
-
-fn char! File.read_byte(&self) @dynamic
-{
-	int c = libc::fgetc(self.file);
-	if (c == -1) return IoError.EOF?;
-	return (char)c;
-}
-
-/**
- * Load up to buffer.len characters. Returns IoError.OVERFLOW if the file is longer
- * than the buffer.
- *
- * @param filename "The path to the file to read"
- * @param [in] buffer "The buffer to read to"
- **/
-fn char[]! load_buffer(String filename, char[] buffer)
-{
-	File file = open(filename, "rb")!;
-	defer (void)file.close();
-	usz len = file.seek(0, END)!;
-	if (len > buffer.len) return IoError.OVERFLOW?;
-	file.seek(0, SET)!;
-	usz read = 0;
-	while (read < len)
-	{
-		read += file.read(buffer[read:len - read])!;
-	}
-	return buffer[:len];
-
-}
-
-fn char[]! load_new(String filename, Allocator* allocator = allocator::heap())
-{
-	File file = open(filename, "rb")!;
-	defer (void)file.close();
-	usz len = file.seek(0, END)!;
-	file.seek(0, SET)!;
-	char* data = allocator::malloc_try(allocator, len)!;
-	defer catch allocator::free(allocator, data);
-	usz read = 0;
-	while (read < len)
-	{
-		read += file.read(data[read:len - read])!;
-	}
-	return data[:len];
-}
-
-fn char[]! load_temp(String filename)
-{
-	return load_new(filename, allocator::temp());
-}
-
-/**
- * @require self.file `File must be initialized`
- */
-fn void! File.flush(&self) @dynamic
-{
-	libc::fflush(self.file);
-}

lib/std/io/formatter.c3

@@ -1,461 +0,0 @@
-module std::io;
-import std::collections::map;
-import libc;
-
-const int PRINTF_NTOA_BUFFER_SIZE = 256;
-
-interface Printable
-{
-	fn String to_new_string(Allocator *allocator) @optional;
-	fn usz! to_format(Formatter* formatter) @optional;
-}
-
-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,
-}
-
-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;
-}
-
-struct Formatter
-{
-	void *data;
-	OutputFn out_fn;
-	struct
-	{
-		PrintFlags flags;
-		uint width;
-		uint prec;
-		usz idx;
-	}
-}
-
-bitstruct PrintFlags : uint
-{
-	bool zeropad;
-	bool left;
-	bool plus;
-	bool space;
-	bool hash;
-	bool uppercase;
-	bool precision;
-}
-
-fn void Formatter.init(&self, OutputFn out_fn, void* data = null)
-{
-	*self = { .data = data, .out_fn = out_fn};
-}
-
-fn usz! Formatter.out(&self, char c) @private
-{
-	self.out_fn(self.data, c)!;
-	return 1;
-}
-
-fn usz! Formatter.print_with_function(&self, Printable* arg)
-{
-	if (&arg.to_format)
-	{
-		PrintFlags old = self.flags;
-		uint old_width = self.width;
-		uint old_prec = self.prec;
-		defer
-		{
-			self.flags = old;
-			self.width = old_width;
-			self.prec = old_prec;
-		}
-		return arg.to_format(self);
-	}
-	if (&arg.to_new_string)
-	{
-		PrintFlags old = self.flags;
-		uint old_width = self.width;
-		uint old_prec = self.prec;
-		defer
-		{
-			self.flags = old;
-			self.width = old_width;
-			self.prec = old_prec;
-		}
-		@stack_mem(1024; Allocator* mem)
-		{
-			return self.out_substr(arg.to_new_string(mem));
-		};
-	}
-	return SearchResult.MISSING?;
-}
-
-
-fn usz! Formatter.out_str(&self, any* arg) @private
-{
-	switch (arg.type.kindof)
-	{
-		case TYPEID:
-			return self.out_substr("typeid");
-		case VOID:
-			return self.out_substr("void");
-		case ANYFAULT:
-		case FAULT:
-			return self.out_substr((*(anyfault*)arg.ptr).nameof);
-		case ANY:
-			return self.out_str(*(any**)arg);
-		case OPTIONAL:
-			unreachable();
-		case SIGNED_INT:
-		case UNSIGNED_INT:
-			PrintFlags flags = self.flags;
-			uint width = self.width;
-			defer
-			{
-				self.flags = flags;
-				self.width = width;
-			}
-			self.flags = {};
-			self.width = 0;
-			return self.ntoa_any(arg, 10);
-		case FLOAT:
-			PrintFlags flags = self.flags;
-			uint width = self.width;
-			defer
-			{
-				self.flags = flags;
-				self.width = width;
-			}
-			self.flags = {};
-			self.width = 0;
-			return self.ftoa(float_from_any(arg)!!);
-		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;
-	}
-	switch (arg.type.kindof)
-	{
-		case ENUM:
-			usz i = types::any_to_int(arg, usz)!!;
-			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:
-			return self.out_substr("<struct>");
-		case UNION:
-			return self.out_substr("<union>");
-		case BITSTRUCT:
-			return self.out_substr("<bitstruct>");
-		case FUNC:
-			return self.out_substr("<function>");
-		case DISTINCT:
-			if (arg.type == ZString.typeid)
-			{
-				return self.out_substr(((ZString*)arg).str_view());
-			}
-			if (arg.type == DString.typeid)
-			{
-				return self.out_substr(((DString*)arg).str_view());
-			}
-			return self.out_str(arg.as_inner());
-		case POINTER:
-			PrintFlags flags = self.flags;
-			uint width = self.width;
-			defer
-			{
-				self.flags = flags;
-				self.width = width;
-			}
-			self.flags = {};
-			self.width = 0;
-			return self.ntoa_any(arg, 16);
-		case ARRAY:
-			// this is SomeType[*] so grab the "SomeType"
-			PrintFlags flags = self.flags;
-			uint width = self.width;
-			defer
-			{
-				self.flags = flags;
-				self.width = width;
-			}
-			self.flags = {};
-			self.width = 0;
-			typeid inner = arg.type.inner;
-			usz size = inner.sizeof;
-			usz alen = arg.type.len;
-			// Pretend this is a String
-			void* ptr = (void*)arg.ptr;
-			usz len = self.out('[')!;
-			for (usz i = 0; i < alen; i++)
-			{
-				if (i != 0) len += self.out_substr(", ")!;
-				len += self.out_str(any_make(ptr, inner))!;
-				ptr += size;
-			}
-			len += self.out(']')!;
-			return len;
-		case VECTOR:
-			PrintFlags flags = self.flags;
-			uint width = self.width;
-			defer
-			{
-				self.flags = flags;
-				self.width = width;
-			}
-			self.flags = {};
-			self.width = 0;
-			// this is SomeType[*] so grab the "SomeType"
-			typeid inner = arg.type.inner;
-			usz size = inner.sizeof;
-			usz vlen = arg.type.len;
-			// Pretend this is a String
-			void* ptr = (void*)arg.ptr;
-			usz len = self.out_substr("[<")!;
-			for (usz i = 0; i < vlen; i++)
-			{
-				if (i != 0) len += self.out_substr(", ")!;
-				len += self.out_str(any_make(ptr, inner))!;
-				ptr += size;
-			}
-			len += self.out_substr(">]")!;
-			return len;
-		case SUBARRAY:
-			// this is SomeType[] so grab the "SomeType"
-			typeid inner = arg.type.inner;
-			if (inner == char.typeid)
-			{
-				return self.out_substr(*(String*)arg);
-			}
-			if (inner == void.typeid) inner = char.typeid;
-			PrintFlags flags = self.flags;
-			uint width = self.width;
-			defer
-			{
-				self.flags = flags;
-				self.width = width;
-			}
-			self.flags = {};
-			self.width = 0;
-			usz size = inner.sizeof;
-			// Pretend this is a String
-			String* temp = (void*)arg.ptr;
-			void* ptr = (void*)temp.ptr;
-			usz slen = temp.len;
-			usz len = self.out('[')!;
-			for (usz i = 0; i < slen; i++)
-			{
-				if (i != 0) len += self.out_substr(", ")!;
-				len += self.out_str(any_make(ptr, inner))!;
-				ptr += size;
-			}
-			len += self.out(']')!;
-			return len;
-		default:
-	}
-	return self.out_substr("Invalid type");
-}
-
-
-
-
-fn void! out_null_fn(void* data @unused, char c @unused) @private
-{
-}
-
-
-
-fn usz! Formatter.vprintf(&self, String format, any*[] anys)
-{
-	if (!self.out_fn)
-	{
-		// use null output function
-		self.out_fn = &out_null_fn;
-	}
-	usz total_len;
-	usz format_len = format.len;
-	usz variant_index = 0;
-	for (usz i = 0; i < format_len; i++)
-	{
-		// format specifier?  %[flags][width][.precision][length]
-		char c = format[i];
-		if (c != '%')
-		{
-			// no
-			total_len += self.out(c)!;
-			continue;
-		}
-		i++;
-		if (i >= format_len) return PrintFault.INVALID_FORMAT_STRING?;
-		c = format[i];
-		if (c == '%')
-		{
-			total_len += self.out(c)!;
-			continue;
-		}
-		// evaluate flags
-		self.flags = {};
-		while FLAG_EVAL: (true)
-		{
-			switch (c)
-			{
-				case '0': self.flags.zeropad = true;
-				case '-': self.flags.left = true;
-				case '+': self.flags.plus = true;
-				case ' ': self.flags.space = true;
-				case '#': self.flags.hash = true;
-				default: break FLAG_EVAL;
-			}
-			if (++i >= format_len) return PrintFault.INVALID_FORMAT_STRING?;
-			c = format[i];
-		}
-		// evaluate width field
-		int w = printf_parse_format_field(anys.ptr, anys.len, &variant_index, format.ptr, format.len, &i)!;
-		c = format[i];
-		if (w < 0)
-		{
-			self.flags.left = true;
-			w = -w;
-		}
-		self.width = w;
-		// evaluate precision field
-		self.prec = 0;
-		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)!;
-			self.prec = prec < 0 ? 0 : prec;
-			c = format[i];
-		}
-
-		// evaluate specifier
-		uint base = 0;
-		if (variant_index >= anys.len) return PrintFault.MISSING_ARG?;
-		any* current = anys[variant_index++];
-		switch (c)
-		{
-			case 'd':
-				base = 10;
-				self.flags.hash = false;
-			case 'X' :
-				self.flags.uppercase = true;
-				nextcase;
-			case 'x' :
-				base = 16;
-			case 'O':
-				self.flags.uppercase = true;
-				nextcase;
-			case 'o' :
-				base = 8;
-			case 'B':
-				self.flags.uppercase = true;
-				nextcase;
-			case 'b' :
-				base = 2;
-			case 'A':
-				self.flags.uppercase = true;
-				nextcase;
-			case 'a':
-				total_len += self.atoa(float_from_any(current)!!)!;
-				continue;
-			case 'F' :
-				self.flags.uppercase = true;
-				nextcase;
-			case 'f':
-				total_len += self.ftoa(float_from_any(current)!!)!;
-				continue;
-			case 'E':
-				self.flags.uppercase = true;
-				nextcase;
-			case 'e':
-				total_len += self.etoa(float_from_any(current)!!)!;
-				continue;
-			case 'G':
-				self.flags.uppercase = true;
-				nextcase;
-			case 'g':
-				total_len += self.gtoa(float_from_any(current)!!)!;
-				continue;
-			case 'c':
-				total_len += self.out_char(current)!;
-				continue;
-			case 's':
-				if (self.flags.left)
-				{
-					usz len = self.out_str(current)!;
-					total_len += len;
-					total_len += self.pad(' ', self.width, len)!;
-					continue;
-				}
-				OutputFn out_fn = self.out_fn;
-				self.out_fn = (OutputFn)&out_null_fn;
-				usz len = self.out_str(current)!;
-				self.out_fn = out_fn;
-				total_len += self.pad(' ', self.width, len)!;
-				total_len += self.out_str(current)!;
-				continue;
-			case 'p':
-				self.flags.zeropad = true;
-				self.flags.hash = true;
-				base = 16;
-			default:
-				return PrintFault.INVALID_FORMAT_STRING?;
-		}
-		if (base != 10)
-		{
-			self.flags.plus = false;
-			self.flags.space = false;
-		}
-		// ignore '0' flag when precision is given
-		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)!;
-	}
-	// termination
-	//	out((char)0, buffer, idx < maxlen ? idx : maxlen - 1U, maxlen);
-
-	// return written chars without terminating \0
-	return total_len;
-}
-
-
-fn usz! Formatter.print(&self, String str)
-{
-	if (!self.out_fn)
-	{
-		// use null output function
-		self.out_fn = &out_null_fn;
-	}
-	foreach (c : str) self.out(c)!;
-	return self.idx;
-}

lib/std/io/io.c3

@@ -4,287 +4,136 @@
 module std::io;
 import libc;
 
+struct File
+{
+    CFile file;
+}
+
 enum Seek
 {
-	SET,
-	CURSOR,
-	END
+    SET,
+    CURSOR,
+    END
 }
 
 fault IoError
 {
-	ALREADY_EXISTS,
-	BUSY,
-	CANNOT_READ_DIR,
-	DIR_NOT_EMPTY,
-	EOF,
-	FILE_CANNOT_DELETE,
-	FILE_IS_DIR,
-	FILE_IS_PIPE,
-	FILE_NOT_DIR,
-	FILE_NOT_FOUND,
-	FILE_NOT_VALID,
-	GENERAL_ERROR,
-	ILLEGAL_ARGUMENT,
-	INCOMPLETE_WRITE,
-	INTERRUPTED,
-	INVALID_POSITION,
-	INVALID_PUSHBACK,
-	NAME_TOO_LONG,
-	NOT_SEEKABLE,
-	NO_PERMISSION,
-	OUT_OF_SPACE,
-	OVERFLOW,
-	READ_ONLY,
-	SYMLINK_FAILED,
-	TOO_MANY_DESCRIPTORS,
-	UNEXPECTED_EOF,
-	UNKNOWN_ERROR,
-	UNSUPPORTED_OPERATION,
-	WOULD_BLOCK,
+    FILE_NOT_FOUND,
+    FILE_NOT_VALID,
+    INVALID_POSITION,
+    OVERFLOW,
+    FILE_IS_PIPE,
+    FILE_EOF,
+    INCOMPLETE_WRITE,
+    NO_PERMISSION,
+    OUT_OF_SPACE,
+    INVALID_PUSHBACK,
+    EOF,
+    CANNOT_READ_DIR,
+    TOO_MANY_DESCRIPTORS,
+    FILE_IS_DIR,
+    READ_ONLY,
+    FILE_NOT_DIR,
+    SYMLINK_FAILED,
+    ALREADY_EXISTS,
+    NOT_SEEKABLE,
+    NAME_TOO_LONG,
+    WOULD_BLOCK,
+    INTERRUPTED,
+    GENERAL_ERROR,
+    UNKNOWN_ERROR,
+    UNSUPPORTED_OPERATION,
 }
 
-
-/**
- * @param stream
- * @require @is_instream(stream)
- **/
-macro String! readline(stream = io::stdin(), Allocator* allocator = allocator::heap())
+fn void putchar(char c) @inline
 {
-	bool $is_stream = @typeid(stream) == InStream*.typeid;
-	$if $is_stream:
-		$typeof(&stream.read_byte) func = &stream.read_byte;
-		char val = func((void*)stream)!;
-	$else
-		char val = stream.read_byte()!;
-	$endif
-
-    if (val == '\n') return "";
-    @pool(allocator)
-    {
-        DString str = dstring::temp_with_capacity(256);
-    	if (val != '\r') str.append(val);
-    	while (1)
-    	{
-    	    $if $is_stream:
-    	        char! c = func((void*)stream);
-    	    $else
-    	        char! c = stream.read_byte();
-    	    $endif
-    		if (catch err = c)
-    		{
-    			if (err == IoError.EOF) break;
-    			return err?;
-    		}
-    		if (c == '\r') continue;
-    		if (c == '\n') break;
-    		str.append_char(c);
-    	}
-    	return str.copy_str(allocator);
-    };
-}
-
-macro String! treadline(stream = io::stdin()) => readline(stream, allocator::temp()) @inline;
-
-/**
- * @require @is_outstream(out) "The output must implement OutStream"
- */
-macro usz! fprint(out, x)
-{
-	var $Type = $typeof(x);
-	$switch ($Type)
-	$case String:
-		return out.write(x);
-	$case ZString:
-		return out.write(x.str_view());
-	$case DString:
-		return out.write(x.str_view());
-	$default:
-		$if $assignable(x, String):
-			return out.write((String)x);
-		$else
-			return fprintf(out, "%s", x);
-		$endif
-	$endswitch
-}
-
-fn usz! fprintf(OutStream* out, String format, args...)
-{
-	Formatter formatter;
-	formatter.init(&out_putstream_fn, &out);
-	return formatter.vprintf(format, args);
-}
-
-fn usz! fprintfn(OutStream* out, String format, args...) @maydiscard
-{
-	Formatter formatter;
-	formatter.init(&out_putstream_fn, &out);
-	usz len = formatter.vprintf(format, args)!;
-	out.write_byte('\n')!;
-	if (&out.flush) out.flush()!;
-	return len + 1;
-}
-
-/**
- * @require @is_outstream(out) "The output must implement OutStream"
- */
-macro usz! fprintn(out, x = "")
-{
-	usz len = fprint(out, x)!;
-	out.write_byte('\n')!;
-	$switch
-		$case @typeid(out) == OutStream*.typeid:
-			if (&out.flush) out.flush()!;
-		$case $defined(out.flush):
-			out.flush()!;
-	$endswitch
-	return len + 1;
+    libc::putchar(c);
 }
 
 macro void print(x)
 {
-	(void)fprint(io::stdout(), x);
+	var $Type = $typeof(x);
+	$switch ($Type)
+	$case String:
+		catch? stdout().print(x);
+	$case ZString:
+		catch? stdout().print(x.as_str());
+	$case DString:
+		catch? stdout().print(x.str());
+	$case VarString:
+		catch? stdout().print(x.str());
+	$default:
+		$if (@convertible(x, String))
+			catch? stdout().print((String)x);
+		$else
+			catch? stdout().printf("%s", x);
+		$endif
+	$endswitch
 }
 
 macro void printn(x = "")
 {
-	(void)fprintn(io::stdout(), x);
+	var $Type = $typeof(x);
+	$switch ($Type)
+	$case String:
+		catch? stdout().printn(x);
+	$case ZString:
+		catch? stdout().printn(x.as_str());
+	$case DString:
+		catch? stdout().printn(x.str());
+	$case VarString:
+		catch? stdout().printn(x.str());
+	$default:
+		$if (@convertible(x, String))
+			catch? stdout().printn((String)x);
+		$else
+			catch? stdout().printfn("%s", x);
+		$endif
+	$endswitch
 }
 
-macro void eprint(x)
+macro void println(x = "") @deprecated => printn(x);
+
+fn File stdout()
 {
-	(void)fprint(io::stderr(), x);
+	return { libc::stdout() };
 }
 
-macro void eprintn(x)
+fn File stderr()
 {
-	(void)fprintn(io::stderr(), x);
+	return { libc::stderr() };
 }
 
-
-fn void! out_putstream_fn(void* data, char c) @private
+fn File stdin()
 {
-	OutStream** stream = data;
-	return (*stream).write_byte(c);
+	return { libc::stdin() };
 }
 
-fn void! out_putchar_fn(void* data @unused, char c) @private
+/*
+
+
+error FileError
 {
-	libc::putchar(c);
+    ulong errno;
 }
 
-fn usz! printf(String format, args...) @maydiscard
+fn FileError errorFromErrno()
 {
-	Formatter formatter;
-	formatter.init(&out_putchar_fn);
-	return formatter.vprintf(format, args);
+    return FileError { };
 }
 
-fn usz! printfn(String format, args...) @maydiscard
+
+
+
+pubic fn void! File.clearerr(File *file) @inline
 {
-	Formatter formatter;
-	formatter.init(&out_putchar_fn);
-	usz len = formatter.vprintf(format, args)!;
-	putchar('\n');
-	io::stdout().flush()!;
-	return len + 1;
+    clearerr(file->file);
 }
 
-fn usz! eprintf(String format, args...) @maydiscard
+
+
+fn void File.error(File *file) @inline
 {
-	Formatter formatter;
-	OutStream* stream = stderr();
-	formatter.init(&out_putstream_fn, &stream);
-	return formatter.vprintf(format, args);
-}
-
-
-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;
-	stderr().write_byte('\n')!;
-	stderr().flush()!;
-	return len;
-}
-
-fn char[]! bprintf(char[] buffer, String format, args...) @maydiscard
-{
-	Formatter formatter;
-	BufferData data = { .buffer = buffer };
-	formatter.init(&out_buffer_fn, &data);
-	usz size = formatter.vprintf(format, args)!;
-	return buffer[:data.written];
-}
-
-fn void! out_buffer_fn(void *data, char c) @private
-{
-	BufferData *buffer_data = data;
-	if (buffer_data.written >= buffer_data.buffer.len) return PrintFault.BUFFER_EXCEEDED?;
-	buffer_data.buffer[buffer_data.written++] = c;
-}
-
-
-struct BufferData @private
-{
-	char[] buffer;
-	usz written;
-}
-
-
-module std::io @if (env::LIBC);
-import libc;
-
-fn void putchar(char c) @inline
-{
-	libc::putchar(c);
-}
-
-fn File* stdout()
-{
-	static File file;
-	if (!file.file) file = file::from_handle(libc::stdout());
-	return &file;
-}
-
-fn File* stderr()
-{
-	static File file;
-	if (!file.file) file = file::from_handle(libc::stderr());
-	return &file;
-}
-
-fn File* stdin()
-{
-	static File file;
-	if (!file.file) file = file::from_handle(libc::stdin());
-	return &file;
-}
-
-module std::io @if(!env::LIBC);
-
-File stdin_file;
-File stdout_file;
-File stderr_file;
-
-fn void putchar(char c) @inline
-{
-	(void)stdout_file.putc(c);
-}
-
-fn File* stdout()
-{
-	return &stdout_file;
-}
-
-fn File* stderr()
-{
-	return &stderr_file;
-}
-
-fn File* stdin()
-{
-	return &stdin_file;
+    int err = ferror
 }
+*/

lib/std/io/io_file.c3

@@ -0,0 +1,173 @@
+module std::io::file;
+import libc;
+
+fn File! open(String filename, String mode)
+{
+	return { .file = os::native_fopen(filename, mode) };
+}
+
+fn void! File.open(File* file, String filename, String mode) @deprecated
+{
+	file.file = os::native_fopen(filename, mode)?;
+}
+
+/**
+ * @require file.file != null
+ **/
+fn void! File.reopen(File* file, String filename, String mode)
+{
+	file.file = os::native_freopen(file.file, filename, mode)?;
+}
+
+/**
+ * @require file.file != null
+ **/
+fn usz! File.seek(File file, isz offset, Seek seek_mode = Seek.SET)
+{
+	os::native_fseek(file.file, offset, seek_mode)?;
+	return os::native_ftell(file.file);
+}
+
+
+/*
+Implement later
+/**
+ * @require file.file == null
+ **/
+fn void! File.memopen(File* file, char[] data, String mode)
+{
+	@pool()
+	{
+		file.file = libc::memopen(data.ptr, data.len, mode.zstr_tcopy(), file.file);
+		// TODO errors
+	};
+}
+*/
+
+
+/**
+ * @require file && file.file != null
+ */
+fn void! File.putc(File *file, char c)
+{
+    if (!libc::fputc(c, file.file)) return IoError.FILE_EOF!;
+}
+
+/**
+ * @require file != null
+ */
+fn void! File.close(File *file) @inline
+{
+    if (file.file && libc::fclose(file.file))
+    {
+        switch (libc::errno())
+        {
+            case errno::ECONNRESET:
+            case errno::EBADF: return IoError.FILE_NOT_VALID!;
+            case errno::EINTR: return IoError.INTERRUPTED!;
+            case errno::EDQUOT:
+            case errno::EFAULT:
+            case errno::EAGAIN:
+            case errno::EFBIG:
+            case errno::ENETDOWN:
+            case errno::ENETUNREACH:
+            case errno::ENOSPC:
+            case errno::EIO: return IoError.INCOMPLETE_WRITE!;
+            default: return IoError.UNKNOWN_ERROR!;
+        }
+    }
+    file.file = null;
+}
+
+/**
+ * @require file && file.file
+ */
+fn bool File.eof(File* file) @inline
+{
+    return libc::feof(file.file) != 0;
+}
+
+/**
+ * @param [in] buffer
+ */
+fn usz! File.read(File* file, char[] buffer)
+{
+	return os::native_fread(file.file, buffer);
+}
+
+/**
+ * @param [&in] file
+ * @param [&out] buffer
+ * @require file.file `File must be initialized`
+ */
+fn usz! File.write(File file, char[] buffer)
+{
+	return os::native_fwrite(file.file, buffer);
+}
+
+/**
+ * @param [&in] file
+ * @require file.file `File must be initialized`
+ */
+fn usz! File.printn(File file, String string)
+{
+	usz len = file.print(string)?;
+	if (!libc::putc('\n', file.file)) return IoError.UNKNOWN_ERROR!;
+    return len + 1;
+}
+
+/**
+ * @param [&in] file
+ * @require file.file `File must be initialized`
+ */
+fn usz! File.print(File file, String string)
+{
+    usz len = string.len;
+    if (len != file.write((char[])string)?) return IoError.UNKNOWN_ERROR!;
+    return len;
+}
+
+fn usz! File.println(File file, String string) @deprecated => file.printn(string);
+
+/**
+ * @param [&in] file
+ * @require file.file `File must be initialized`
+ */
+fn DString File.getline(File* file, Allocator* using = mem::heap())
+{
+	DString s = dstring::new_with_capacity(120, using);
+	while (!file.eof())
+	{
+		int c = libc::fgetc(file.file);
+		if (c == -1) break;
+		if (c == '\n') break;
+		s.append_char((char)c);
+	}
+	return s;
+}
+
+/**
+ * @param [&in] file
+ * @require file.file `File must be initialized`
+ * @return "a zero terminated String (the pointer may be safely cast into a ZString)"
+ */
+fn String File.tgetline(File* file)
+{
+	return file.getline(mem::temp()).zstr().as_str();
+}
+
+fn char! File.getc(File* file)
+{
+	int c = libc::fgetc(file.file);
+	if (c == -1) return IoError.FILE_EOF!;
+	return (char)c;
+}
+
+/**
+ * @param [&in] file
+ * @require file.file `File must be initialized`
+ */
+fn void File.flush(File* file)
+{
+	libc::fflush(file.file);
+}

lib/std/io/io_fileinfo.c3

@@ -0,0 +1,14 @@
+module std::io::file;
+import libc;
+
+
+
+fn bool is_file(String path)
+{
+	return os::native_is_file(path);
+}
+
+fn usz! get_size(String path)
+{
+	return os::native_file_size(path);
+}

lib/std/io/io_formatter_private.c3

@@ -1,28 +1,32 @@
 module std::io;
-import std::math;
 
 const char[16] XDIGITS_H = "0123456789ABCDEF";
 const char[16] XDIGITS_L = "0123456789abcdef";
 
-fn usz! Formatter.adjust(&self, usz len) @local
+fn void! Formatter.left_adjust(Formatter* this, usz len) @local
 {
-	if (!self.flags.left) return 0;
-	return self.pad(' ', self.width, len);
+	if (!this.flags.left) return;
+	for (usz l = len; l < this.width; l++) this.out(' ')?;
 }
 
-fn uint128! int_from_any(any* arg, bool *is_neg) @private
+fn void! Formatter.right_adjust(Formatter* this, usz len) @local
+{
+	if (this.flags.left) return;
+	for (usz l = len; l < this.width; l++) this.out(' ')?;
+}
+
+
+fn uint128! int_from_variant(variant arg, bool *is_neg) @private
 {
-	switch (arg.type.kindof)
-	{
-		case TypeKind.POINTER:
-			*is_neg = false;
-			return (uint128)(uptr)*(void**)arg.ptr;
-		case TypeKind.DISTINCT:
-		case TypeKind.ENUM:
-			return int_from_any(arg.as_inner(), is_neg);
-		default:
-	}
 	*is_neg = false;
+	if (arg.type.kindof == TypeKind.POINTER)
+	{
+		return (uint128)(uptr)*(void**)arg.ptr;
+	}
+	if (arg.type.kindof == TypeKind.DISTINCT)
+    {
+    	return int_from_variant(variant { arg.ptr, arg.type.inner }, is_neg);
+    }
 	switch (arg)
 	{
 		case bool:
@@ -40,8 +44,8 @@ fn uint128! int_from_any(any* arg, bool *is_neg) @private
 			long val = *arg;
 			return (*is_neg = val < 0) ? (~(uint128)val) + 1 : (uint128)val;
 		case int128:
-			int128 val = *arg;
-			return (*is_neg = val < 0) ? (~(uint128)val) + 1 : (uint128)val;
+            int128 val = *arg;
+            return (*is_neg = val < 0) ? (~(uint128)val) + 1 : (uint128)val;
 		case char:
 			return *arg;
 		case ushort:
@@ -59,21 +63,21 @@ 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 PrintFault.INVALID_ARGUMENT_TYPE!;
 	}
 }
 
-fn FloatType! float_from_any(any* arg) @private
+fn FloatType! float_from_variant(variant arg) @private
 {
-	$if env::F128_SUPPORT:
+	$if (env::F128_SUPPORT)
 		if (arg.type == float128.typeid) return (FloatType)*((float128*)arg.ptr);
 	$endif
-	$if env::F16_SUPPORT:
+	$if (env::F16_SUPPORT)
 		if (arg.type == float16.typeid) return *((float16*)arg.ptr);
 	$endif
 	if (arg.type.kindof == TypeKind.DISTINCT)
 	{
-		return float_from_any(arg.as_inner());
+		return float_from_variant(variant { arg.ptr, arg.type.inner });
 	}
 	switch (arg)
 	{
@@ -88,7 +92,7 @@ fn FloatType! float_from_any(any* arg) @private
 		case long:
 			return *arg;
 		case int128:
-			return *arg;
+    	    return *arg;
 		case char:
 			return *arg;
 		case ushort:
@@ -98,13 +102,13 @@ fn FloatType! float_from_any(any* arg) @private
 		case ulong:
 			return *arg;
 		case uint128:
-			return *arg;
+            return *arg;
 		case float:
 			return (FloatType)*arg;
 		case double:
 			return (FloatType)*arg;
 		default:
-			return PrintFault.INVALID_ARGUMENT_TYPE?;
+			return PrintFault.INVALID_ARGUMENT_TYPE!;
 	}
 }
 
@@ -122,21 +126,22 @@ fn uint simple_atoi(char* buf, usz maxlen, usz* len_ptr) @inline @private
 	uint i = 0;
 	usz len = *len_ptr;
 	while (len < maxlen)
-	{
-		char c = buf[len];
-		if (!c.is_digit()) break;
-		i = i * 10 + c - '0';
-		len++;
-	}
-	*len_ptr = len;
-	return i;
+    {
+        char c = buf[len];
+        if (c < '0' || c > '9') break;
+        i = i * 10 + c - '0';
+        len++;
+    }
+    *len_ptr = len;
+    return i;
 }
 
-fn usz! Formatter.out_substr(&self, String str) @private
+fn void! Formatter.out_substr(Formatter *this, String str) @private
 {
 	usz l = conv::utf8_codepoints(str);
-	uint prec = self.prec;
-	if (self.flags.precision && l < prec) l = prec;
+	uint prec = this.prec;
+	if (this.flags.precision && l < prec) l = prec;
+	this.right_adjust(' ')?;
 	usz index = 0;
 	usz chars = str.len;
 	char* ptr = str.ptr;
@@ -144,18 +149,16 @@ fn usz! Formatter.out_substr(&self, String str) @private
 	{
 		char c = ptr[index];
 		// Break if we have precision set and we ran out...
-		if (c & 0xC0 != 0x80 && self.flags.precision && !prec--) break;
-		self.out(c)!;
-		index++;
+		if (c & 0xC0 != 0x80 && this.flags.precision && !prec--) break;
+		this.out(c)?;
+        index++;
 	}
-	return index;
+	return this.left_adjust(l);
 }
 
-fn usz! Formatter.pad(&self, char c, isz width, isz len) @inline
+fn void! Formatter.pad(Formatter* this, char c, isz width, isz len) @inline
 {
-	isz delta = width - len;
-	for (isz i = 0; i < delta; i++) self.out(c)!;
-	return max(0, delta);
+	for (isz i = len; i < width; i++) this.out(c)?;
 }
 
 fn char* fmt_u(uint128 x, char* s)
@@ -165,10 +168,9 @@ fn char* fmt_u(uint128 x, char* s)
 	return s;
 }
 
-fn usz! Formatter.out_chars(&self, char[] s)
+fn void! Formatter.out_chars(Formatter* this, char[] s)
 {
-	foreach (c : s) self.out(c)!;
-	return s.len;
+	foreach (c : s) this.out(c)?;
 }
 
 enum FloatFormatting
@@ -179,37 +181,35 @@ enum FloatFormatting
 	HEX
 }
 
-fn usz! Formatter.etoa(&self, double y) => self.floatformat(EXPONENTIAL, y);
-fn usz! Formatter.ftoa(&self, double y) => self.floatformat(FLOAT, y);
-fn usz! Formatter.gtoa(&self, double y) => self.floatformat(ADAPTIVE, y);
-fn usz! Formatter.atoa(&self, double y) => self.floatformat(HEX, y);
+fn void! Formatter.etoa(Formatter* this, double y) => this.floatformat(EXPONENTIAL, y);
+fn void! Formatter.ftoa(Formatter* this, double y) => this.floatformat(FLOAT, y);
+fn void! Formatter.gtoa(Formatter* this, double y) => this.floatformat(ADAPTIVE, y);
+fn void! Formatter.atoa(Formatter* this, double y) => this.floatformat(HEX, y);
 
-fn usz! Formatter.floatformat(&self, FloatFormatting formatting, double y) @private
+fn void! Formatter.floatformat(Formatter* this, FloatFormatting formatting, double y) @private
 {
 	// This code is heavily based on musl's printf code
 	const BUF_SIZE = (math::DOUBLE_MANT_DIG + 28) / 29 + 1
 		+ (math::DOUBLE_MAX_EXP + math::DOUBLE_MANT_DIG + 28 + 8) / 9;
 	uint[BUF_SIZE] big;
-	bool is_neg = false;
-	if (math::signbit(y))
-	{
-		is_neg = true;
-		y = -y;
-	}
-	isz pl = is_neg || self.flags.plus ? 1 : 0;
-	// Print inf/nan
+    bool is_neg = false;
+    if (math::signbit(y))
+    {
+        is_neg = true;
+        y = -y;
+    }
+    int pl = is_neg || this.flags.plus ? 1 : 0;
+    // Print inf/nan
 	if (!math::is_finite(y))
 	{
-		usz len;
 		// Add padding
-		if (!self.flags.left) len += self.pad(' ', self.width, 3 + pl)!;
-		String s = self.flags.uppercase ? "INF" : "inf";
-		if (y != y) s = self.flags.uppercase ? "NAN" : "nan";
-		len += s.len;
-		if (pl) len += self.out(is_neg ? '-' : '+')!;
-		len += self.out_chars(s)!;
-		if (self.flags.left) len += self.pad(' ', self.width, 3 + pl)!;
-		return len;
+		if (!this.flags.left) this.pad(' ', this.width, 3 + pl)?;
+		String s = this.flags.uppercase ? "INF" : "inf";
+		if (y != y) this.flags.uppercase ? "NAN" : "nan";
+		if (pl) this.out(is_neg ? '-' : '+')?;
+		this.out_chars(s)?;
+		if (this.flags.left) this.pad(' ', this.width, 3 + pl)?;
+		return;
 	}
 	// Rescale
 	int e2;
@@ -220,7 +220,7 @@ fn usz! Formatter.floatformat(&self, FloatFormatting formatting, double y) @priv
 	char* ebuf = 12 + (char*)&ebuf0;
 	char[9 + math::DOUBLE_MANT_DIG / 4] buf_array;
 	char* buf = &buf_array;
-	isz p = self.flags.precision ? self.prec : -1;
+	isz p = this.flags.precision ? this.prec : -1;
 	if (formatting == HEX)
 	{
 		double round = 8.0;
@@ -229,51 +229,50 @@ fn usz! Formatter.floatformat(&self, FloatFormatting formatting, double y) @priv
 		if (p > 0 && p < math::DOUBLE_MANT_DIG / 4 - 1)
 		{
 			int re = math::DOUBLE_MANT_DIG / 4 - 1 - (int)p;
-			round *= 1 << (math::DOUBLE_MANT_DIG % 4);
-			while (re--) round *= 16;
-			if (is_neg)
-			{
-				y = -y;
+    		round *= 1 << (math::DOUBLE_MANT_DIG % 4);
+    		while (re--) round *= 16;
+    		if (is_neg)
+    		{
+    		    y = -y;
 				y -= round;
-				y += round;
-				y = -y;
-			}
-			else
-			{
-				y += round;
-				y -= round;
-			}
+    			y += round;
+    			y = -y;
+    		}
+    		else
+    		{
+    		    y += round;
+    			y -= round;
+    		}
 		}
 		// Reverse print
 		char* estr = fmt_u(e2 < 0 ? (int128)-e2 : (int128)e2, ebuf);
 		if (estr == ebuf) *--estr = '0';
 		*--estr = (e2 < 0 ? '-' : '+');
-		*--estr = self.flags.uppercase ? 'P' : 'p';
+		*--estr = this.flags.uppercase ? 'P' : 'p';
 		char* s = buf;
-		char* xdigits = self.flags.uppercase ? &XDIGITS_H : &XDIGITS_L;
+		char* xdigits = this.flags.uppercase ? &XDIGITS_H : &XDIGITS_L;
 		do
 		{
 			int x = (int)y;
 			*s++ = xdigits[x];
 			y = 16 * (y - x);
-			if (s - buf == 1 && (y || p > 0 || self.flags.hash)) *s++ = '.';
+			if (s - buf == 1 && (y || p > 0 || this.flags.hash)) *s++ = '.';
 		} while (y);
 		isz outlen = s - buf;
 		isz explen = ebuf - estr;
-		if (p > int.max - 2 - explen - pl) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
-		usz len;
+		if (p > int.max - 2 - explen - pl) return PrintFault.INTERNAL_BUFFER_EXCEEDED!;
 		usz l = p && outlen - 2 < p
 				? p + 2 + explen
 				: outlen + explen;
-		if (!self.flags.left && !self.flags.zeropad) len += self.pad(' ', self.width, pl + l)!;
-		if (is_neg || self.flags.plus) len += self.out(is_neg ? '-' : '+')!;
-		len += self.out_chars(self.flags.uppercase ? "0X" : "0x")!;
-		if (self.flags.zeropad) len += self.pad('0', self.width, pl + l)!;
-		len += self.out_chars(buf[:outlen])!;
-		len += self.pad('0', l - outlen - explen, 0)!;
-		len += self.out_chars(estr[:explen])!;
-		if (self.flags.left) len += self.pad(' ', self.width, pl + l)!;
-		return len;
+		if (!this.flags.left && !this.flags.zeropad) this.pad(' ', this.width, pl + l)?;
+		if (is_neg || this.flags.plus) this.out(is_neg ? '-' : '+')?;
+		this.out_chars(this.flags.uppercase ? "0X" : "0x")?;
+		if (this.flags.zeropad) this.pad('0', this.width, pl + l)?;
+		this.out_chars(buf[:outlen])?;
+		this.pad('0', l - outlen - explen, 0)?;
+		this.out_chars(estr[:explen])?;
+		if (this.flags.left) this.pad(' ', this.width, pl + l)?;
+		return;
 	}
 	if (p < 0) p = 6;
 	if (y)
@@ -406,7 +405,7 @@ fn usz! Formatter.floatformat(&self, FloatFormatting formatting, double y) @priv
 			formatting = EXPONENTIAL;
 			p--;
 		}
-		if (!self.flags.hash)
+		if (!this.flags.hash)
 		{
 			// Count trailing zeros in last place
 			if (z > a && z[-1])
@@ -428,12 +427,12 @@ fn usz! Formatter.floatformat(&self, FloatFormatting formatting, double y) @priv
 			}
 		}
 	}
-	if (p > int.max - 1 - (isz)(p || self.flags.hash)) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
-	int l = (int)(1 + p + (isz)(p || self.flags.hash));
+	if (p > int.max - 1 - (isz)(p || this.flags.hash)) return PrintFault.INTERNAL_BUFFER_EXCEEDED!;
+	int l = (int)(1 + p + (isz)(p || this.flags.hash));
 	char* estr @noinit;
 	if (formatting == FLOAT)
 	{
-		if (e > int.max - l) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
+		if (e > int.max - l) return PrintFault.INTERNAL_BUFFER_EXCEEDED!;
 		if (e > 0) l += e;
 	}
 	else
@@ -441,15 +440,14 @@ fn usz! Formatter.floatformat(&self, FloatFormatting formatting, double y) @priv
 		estr = fmt_u((uint128)(e < 0 ? -e : e), ebuf);
 		while (ebuf - estr < 2) (--estr)[0] = '0';
 		*--estr = (e < 0 ? '-' : '+');
-		*--estr = self.flags.uppercase ? 'E' : 'e';
-		if (ebuf - estr > (isz)int.max - l) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
+		*--estr = this.flags.uppercase ? 'E' : 'e';
+		if (ebuf - estr > (isz)int.max - l) return PrintFault.INTERNAL_BUFFER_EXCEEDED!;
 		l += (int)(ebuf - estr);
 	}
-	if (l > int.max - pl) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
-	usz len;
-	if (!self.flags.left && !self.flags.zeropad) len += self.pad(' ', self.width, pl + l)!;
-	if (is_neg || self.flags.plus) len += self.out(is_neg ? '-' : '+')!;
-	if (self.flags.zeropad) len += self.pad('0', self.width, pl + l)!;
+	if (l > int.max - pl) return PrintFault.INTERNAL_BUFFER_EXCEEDED!;
+	if (!this.flags.left && !this.flags.zeropad) this.pad(' ', this.width, pl + l)?;
+	if (is_neg || this.flags.plus) this.out(is_neg ? '-' : '+')?;
+	if (this.flags.zeropad) this.pad('0', this.width, pl + l)?;
 	if (formatting == FLOAT)
 	{
 		if (a > r) a = r;
@@ -464,106 +462,106 @@ fn usz! Formatter.floatformat(&self, FloatFormatting formatting, double y) @priv
 				case s == buf + 9:
 					*--s = '0';
 			}
-			len += self.out_chars(s[:buf + 9 - s])!;
+			this.out_chars(s[:buf + 9 - s])?;
 		}
-		if (p || self.flags.hash) len += self.out('.')!;
+		if (p || this.flags.hash) this.out('.')?;
 		for (; d < z && p > 0; d++, p -= 9)
 		{
 			char* s = fmt_u(*d, buf + 9);
 			while (s > buf) *--s = '0';
-			len += self.out_chars(s[:math::min((isz)9, p)])!;
+			this.out_chars(s[:math::min((isz)9, p)])?;
 		}
-		len += self.pad('0', p + 9, 9)!;
+		this.pad('0', p + 9, 9)?;
 	}
 	else
 	{
 		if (z <= a) z = a + 1;
-		for (uint* d = a; d < z && p >= 0; d++)
-		{
+    	for (uint* d = a; d < z && p >= 0; d++)
+    	{
 			char* s = fmt_u(*d, buf + 9);
 			if (s == buf + 9) (--s)[0] = '0';
-			if (d != a)
-			{
-				while (s > buf) (--s)[0] = '0';
-			}
-			else
-			{
-				len += self.out(s++[0])!;
-				if (p > 0 || self.flags.hash) len += self.out('.')!;
-			}
-			len += self.out_chars(s[:math::min(buf + 9 - s, p)])!;
-			p -= buf + 9 - s;
-		}
-		len += self.pad('0', p + 18, 18)!;
-		len += self.out_chars(estr[:ebuf - estr])!;
+    		if (d != a)
+    		{
+    		    while (s > buf) (--s)[0] = '0';
+    		}
+    		else
+    		{
+    		    this.out(s++[0])?;
+    		    if (p > 0 || this.flags.hash) this.out('.')?;
+    		}
+    		this.out_chars(s[:math::min(buf + 9 - s, p)])?;
+    		p -= buf + 9 - s;
+    	}
+    	this.pad('0', p + 18, 18)?;
+    	this.out_chars(estr[:ebuf - estr])?;
 	}
 
-	if (self.flags.left) len += self.pad(' ', self.width, pl + l)!;
+	if (this.flags.left) this.pad(' ', this.width, pl + l)?;
 
-	return len;
+	return;
 }
 
-fn usz! Formatter.ntoa(&self, uint128 value, bool negative, uint base) @private
+fn void! Formatter.ntoa(Formatter* this, uint128 value, bool negative, uint base) @private
 {
 	char[PRINTF_NTOA_BUFFER_SIZE] buf @noinit;
-	usz len;
+	usz len = 0;
 
 	// no hash for 0 values
-	if (!value) self.flags.hash = false;
+	if (!value) this.flags.hash = false;
 
 	// write if precision != 0 or value is != 0
-	if (!self.flags.precision || value)
+	if (!this.flags.precision || value)
 	{
-		char past_10 = (self.flags.uppercase ? 'A' : 'a') - 10;
+		char past_10 = (this.flags.uppercase ? 'A' : 'a') - 10;
 		do
 		{
-			if (len >= PRINTF_NTOA_BUFFER_SIZE) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
+			if (len >= PRINTF_NTOA_BUFFER_SIZE) return PrintFault.INTERNAL_BUFFER_EXCEEDED!;
 			char digit = (char)(value % base);
 			buf[len++] = digit + (digit < 10 ? '0' : past_10);
 			value /= base;
 		}
 		while (value);
 	}
-	return self.ntoa_format((String)buf[:PRINTF_NTOA_BUFFER_SIZE], len, negative, base);
+	return this.ntoa_format((String)buf[:PRINTF_NTOA_BUFFER_SIZE], len, negative, base);
 }
 
-fn usz! Formatter.ntoa_format(&self, String buf, usz len, bool negative, uint base) @private
+fn void! Formatter.ntoa_format(Formatter* this, String buf, usz len, bool negative, uint base) @private
 {
 	// pad leading zeros
-	if (!self.flags.left)
+	if (!this.flags.left)
 	{
-		if (self.width && self.flags.zeropad && (negative || self.flags.plus || self.flags.space)) self.width--;
-		while (len < self.prec)
+		if (this.width && this.flags.zeropad && (negative || this.flags.plus || this.flags.space)) this.width--;
+		while (len < this.prec)
 		{
-			if (len >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
+			if (len >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED!;
 			buf[len++] = '0';
 		}
-		while (self.flags.zeropad && len < self.width)
+		while (this.flags.zeropad && len < this.width)
 		{
-			if (len >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
+			if (len >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED!;
 			buf[len++] = '0';
 		}
 	}
 
 	// handle hash
-	if (self.flags.hash && base != 10)
+	if (this.flags.hash && base != 10)
 	{
-		if (!self.flags.precision && len && len == self.prec && len == self.width)
+		if (!this.flags.precision && len && len == this.prec && len == this.width)
 		{
 			len--;
 			if (len) len--;
 		}
 		if (base != 10)
 		{
-			if (len + 1 >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
+			if (len + 1 >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED!;
 			switch (base)
 			{
 				case 16:
-					buf[len++] = self.flags.uppercase ? 'X' : 'x';
+					buf[len++] = this.flags.uppercase ? 'X' : 'x';
 				case 8:
-					buf[len++] = self.flags.uppercase ? 'O' : 'o';
+					buf[len++] = this.flags.uppercase ? 'O' : 'o';
 				case 2:
-					buf[len++] = self.flags.uppercase ? 'B' : 'b';
+					buf[len++] = this.flags.uppercase ? 'B' : 'b';
 				default:
 					unreachable();
 			}
@@ -574,97 +572,96 @@ fn usz! Formatter.ntoa_format(&self, String buf, usz len, bool negative, uint ba
 	switch (true)
 	{
 		case negative:
-			if (len >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
+			if (len >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED!;
 			buf[len++] = '-';
-		case self.flags.plus:
-			if (len >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
+		case this.flags.plus:
+			if (len >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED!;
 			buf[len++] = '+';
-		case self.flags.space:
-			if (len >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED?;
+		case this.flags.space:
+			if (len >= buf.len) return PrintFault.INTERNAL_BUFFER_EXCEEDED!;
 			buf[len++] = ' ';
 	}
-	if (len) self.out_reverse(buf[:len])!;
-	return len;
+	if (!len) return;
+	return this.out_reverse(buf[:len]);
 }
 
 
-fn usz! Formatter.ntoa_any(&self, any* arg, uint base) @private
+fn void! Formatter.ntoa_variant(Formatter* this, variant arg, uint base) @private
 {
 	bool is_neg;
-	uint128 val = int_from_any(arg, &is_neg)!!;
-	return self.ntoa(val, is_neg, base) @inline;
+	uint128 val = int_from_variant(arg, &is_neg)!!;
+	return this.ntoa(val, is_neg, base) @inline;
 }
 
-fn usz! Formatter.out_char(&self, any* arg) @private
+fn void! Formatter.out_char(Formatter* this, variant arg) @private
 {
-	usz len = 1;
 	uint l = 1;
 	// pre padding
-	len += self.adjust(l)!;
-	// char output
-	Char32 c = types::any_to_int(arg, uint) ?? 0xFFFD;
+	this.right_adjust(l)?;
+    // char output
+    Char32 c = types::variant_to_int(arg, uint) ?? 0xFFFD;
 	switch (true)
 	{
 		case c < 0x7f:
-			self.out((char)c)!;
+			this.out((char)c)?;
 		case c < 0x7ff:
-			self.out((char)(0xC0 | c >> 6))!;
-			self.out((char)(0x80 | (c & 0x3F)))!;
-		case c < 0xffff:
-			self.out((char)(0xE0 | c >> 12))!;
-			self.out((char)(0x80 | (c >> 6 & 0x3F)))!;
-			self.out((char)(0x80 | (c & 0x3F)))!;
-		default:
-			self.out((char)(0xF0 | c >> 18))!;
-			self.out((char)(0x80 | (c >> 12 & 0x3F)))!;
-			self.out((char)(0x80 | (c >> 6 & 0x3F)))!;
-			self.out((char)(0x80 | (c & 0x3F)))!;
+			this.out((char)(0xC0 | c >> 6))?;
+			this.out((char)(0x80 | (c & 0x3F)))?;
+        case c < 0xffff:
+			this.out((char)(0xE0 | c >> 12))?;
+			this.out((char)(0x80 | (c >> 6 & 0x3F)))?;
+			this.out((char)(0x80 | (c & 0x3F)))?;
+        default:
+			this.out((char)(0xF0 | c >> 18))?;
+			this.out((char)(0x80 | (c >> 12 & 0x3F)))?;
+			this.out((char)(0x80 | (c >> 6 & 0x3F)))?;
+			this.out((char)(0x80 | (c & 0x3F)))?;
 	}
-	len += self.adjust(l)!;
-	return len;
+	return this.left_adjust(l);
 }
 
 
-fn usz! Formatter.out_reverse(&self, char[] buf) @private
+fn void! Formatter.out_reverse(Formatter* this, char[] buf) @private
 {
-	usz n;
-	usz buffer_start_idx = self.idx;
+	usz buffer_start_idx = this.idx;
 	usz len = buf.len;
-	// pad spaces up to given width
-	if (!self.flags.zeropad)
-	{
-		n += self.adjust(len)!;
-	}
-	// reverse string
-	while (len) n += self.out(buf[--len])!;
+    // pad spaces up to given width
+    if (!this.flags.left && !this.flags.zeropad)
+    {
+        for (usz i = len; i < this.width; i++)
+        {
+            this.out(' ')?;
+        }
+    }
+    // reverse string
+    while (len) this.out(buf[--len])?;
 
 	// append pad spaces up to given width
-	n += self.adjust(self.idx - buffer_start_idx)!;
-	return n;
+	return this.left_adjust(this.idx - buffer_start_idx);
 }
 
 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?;
+	if (val >= format_len) return FormattingFault.UNTERMINATED_FORMAT!;
 }
 
-fn any*! next_any(any** args_ptr, usz args_len, usz* arg_index_ptr) @inline @private
+fn variant! next_variant(variant* args_ptr, usz args_len, usz* arg_index_ptr) @inline @private
 {
-	if (*arg_index_ptr >= args_len) return FormattingFault.MISSING_ARG?;
+	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,
+	variant* args_ptr, usz args_len, usz* args_index_ptr,
 	char* format_ptr, usz format_len, usz* index_ptr) @inline @private
 {
 	char c = format_ptr[*index_ptr];
-	if (c.is_digit()) return simple_atoi(format_ptr, format_len, index_ptr);
+	if (c >= '0' && c <= '9') 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?;
-	uint! intval = types::any_to_int(val, int);
-	return intval ?? FormattingFault.INVALID_WIDTH_ARG?;
+	printf_advance_format(format_len, index_ptr)?;
+	variant val = next_variant(args_ptr, args_len, args_index_ptr)?;
+    if (!val.type.kindof.is_int()) return FormattingFault.INVALID_WIDTH_ARG!;
+    uint! intval = types::variant_to_int(val, int);
+	return intval ?? FormattingFault.INVALID_WIDTH_ARG!;
 }

lib/std/io/io_printf.c3

@@ -0,0 +1,502 @@
+module std::io;
+import std::collections::map;
+import libc;
+
+const int PRINTF_NTOA_BUFFER_SIZE = 256;
+
+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,
+}
+
+typedef OutputFn = fn void!(char c, void* buffer);
+typedef ToStringFunction = fn String(void* value, Allocator *using);
+typedef ToFormatFunction = fn void!(void* value, Formatter* formatter);
+typedef FloatType = double;
+
+fn usz! printf(String format, args...) @maydiscard
+{
+	Formatter formatter;
+	formatter.init(&out_putchar_fn);
+    return formatter.vprintf(format, args);
+}
+
+define printfln = printfn;
+
+fn usz! printfn(String format, args...) @maydiscard
+{
+	Formatter formatter;
+	formatter.init(&out_putchar_fn);
+    usz len = formatter.vprintf(format, args)?;
+	putchar('\n');
+	return len + 1;
+}
+
+fn usz! VarString.printf(VarString* str, String format, args...) @maydiscard
+{
+	Formatter formatter;
+	formatter.init(&out_string_append_fn, str);
+	return formatter.vprintf(format, args);
+}
+
+fn usz! VarString.printfn(VarString* str, String format, args...) @maydiscard
+{
+	Formatter formatter;
+	formatter.init(&out_string_append_fn, str);
+	usz len = formatter.vprintf(format, args)?;
+	str.append('\n');
+	return len + 1;
+}
+
+fn char[]! bprintf(char[] buffer, String format, args...) @maydiscard
+{
+	Formatter formatter;
+	BufferData data = { .buffer = buffer };
+    formatter.init(&out_buffer_fn, &data);
+    usz size = formatter.vprintf(format, args)?;
+    return buffer[:data.written];
+}
+
+fn usz! File.printf(File file, String format, args...) @maydiscard
+{
+	Formatter formatter;
+    formatter.init(&out_fputchar_fn, &file);
+    return formatter.vprintf(format, args)?;
+}
+
+fn usz! File.printfn(File file, String format, args...) @maydiscard
+{
+	Formatter formatter;
+    formatter.init(&out_fputchar_fn, &file);
+    usz len = formatter.vprintf(format, args)?;
+	file.putc('\n')?;
+	file.flush();
+	return len + 1;
+}
+
+fn usz! Formatter.printf(Formatter* this, String format, args...)
+{
+	return this.vprintf(format, args) @inline;
+}
+
+struct Formatter
+{
+	void *data;
+	OutputFn out_fn;
+	struct
+	{
+		PrintFlags flags;
+    	uint width;
+    	uint prec;
+    	usz idx;
+	}
+}
+
+bitstruct PrintFlags : uint
+{
+	bool zeropad : 0;
+	bool left : 1;
+	bool plus : 2;
+	bool space : 3;
+	bool hash : 4;
+	bool uppercase : 5;
+	bool precision : 6;
+}
+
+fn void Formatter.init(Formatter* this, OutputFn out_fn, void* data = null)
+{
+	*this = { .data = data, .out_fn = out_fn};
+}
+
+/**
+ * @require $checks($Type a, a.to_string()) || $checks($Type a, a.to_format(&&Formatter{}))  "Expected a type with 'to_string' or 'to_format' defined"
+ * @require !$checks($Type a, a.to_string()) || $checks($Type a, a.to_string(&&Allocator{})) "Expected 'to_string' to take an allocator as argument."
+ * @require !$checks($Type a, a.to_format(&&Formatter{})) || $checks($Type a, Formatter b, a.to_format(&b)) "Expected 'to_format' to take a Formatter as argument."
+ */
+macro void formatter_register_type($Type)
+{
+	$if ($checks($Type a, a.to_format(&&Formatter {})))
+		if (!toformat_functions.table.len)
+		{
+			toformat_functions.init(64);
+		}
+		toformat_functions.set($Type.typeid, (ToFormatFunction)&$Type.to_format);
+	$else
+		if (!tostring_functions.table.len)
+		{
+			tostring_functions.init(64);
+		}
+		tostring_functions.set($Type.typeid, (ToStringFunction)&$Type.to_string);
+	$endif
+}
+
+
+static initialize @priority(101)
+{
+	if (!toformat_functions.table.len)
+	{
+		toformat_functions.init(64);
+	}
+	if (!tostring_functions.table.len)
+	{
+		tostring_functions.init(64);
+	}
+}
+
+fn void! Formatter.out(Formatter* this, char c) @private
+{
+	this.out_fn(c, this.data)?;
+}
+
+macro bool! Formatter.print_with_function(Formatter* this, variant arg)
+{
+	if (try to_format = toformat_functions.get(arg.type))
+	{
+		PrintFlags old = this.flags;
+		uint old_width = this.width;
+		uint old_prec = this.prec;
+		defer
+		{
+			this.flags = old;
+			this.width = old_width;
+			this.prec = old_prec;
+		}
+		to_format(arg.ptr, this)?;
+		return true;
+    }
+    if (try to_string = tostring_functions.get(arg.type))
+    {
+		PrintFlags old = this.flags;
+		uint old_width = this.width;
+		uint old_prec = this.prec;
+		defer
+		{
+			this.flags = old;
+			this.width = old_width;
+			this.prec = old_prec;
+		}
+		@pool()
+		{
+			this.out_substr(to_string(arg.ptr, mem::temp()))?;
+			return true;
+		};
+    }
+    return false;
+}
+
+fn void! Formatter.out_str(Formatter* this, variant arg) @private
+{
+	switch (arg.type.kindof)
+	{
+		case TYPEID:
+			return this.out_substr("<typeid>");
+		case VOID:
+        	return this.out_substr("void");
+		case ANYERR:
+		case FAULT:
+        	return this.out_substr((*(anyerr*)arg.ptr).nameof);
+		case VARIANT:
+			return this.out_str(*(variant*)arg);
+		case ENUM:
+			if (this.print_with_function(arg)?) return;
+        	return this.out_substr(arg.type.names[types::variant_to_int(arg, usz)!!]);
+		case STRUCT:
+			if (this.print_with_function(arg)?) return;
+			return this.out_substr("<struct>");
+		case UNION:
+			if (this.print_with_function(arg)?) return;
+			return this.out_substr("<union>");
+		case BITSTRUCT:
+			if (this.print_with_function(arg)?) return;
+			return this.out_substr("<bitstruct>");
+		case FUNC:
+			if (this.print_with_function(arg)?) return;
+			return this.out_substr("<function>");
+		case OPTIONAL:
+			unreachable();
+		case DISTINCT:
+			if (this.print_with_function(arg)?) return;
+			if (arg.type == VarString.typeid)
+			{
+				return this.out_substr(((VarString*)arg).str());
+			}
+			if (arg.type == DString.typeid)
+			{
+				return this.out_substr(((DString*)arg).str());
+			}
+        	return this.out_str(variant { arg.ptr, arg.type.inner });
+		case POINTER:
+			if (this.print_with_function(arg)?) return;
+			return this.ntoa_variant(arg, 16);
+		case SIGNED_INT:
+		case UNSIGNED_INT:
+			return this.ntoa_variant(arg, 10);
+		case FLOAT:
+			return this.ftoa(float_from_variant(arg)!!);
+		case ARRAY:
+			if (this.print_with_function(arg)?) return;
+			// this is SomeType[*] so grab the "SomeType"
+			typeid inner = arg.type.inner;
+			usz size = inner.sizeof;
+			usz len = arg.type.len;
+			// Pretend this is a String
+			void* ptr = (void*)arg.ptr;
+			this.out('[')?;
+			for (usz i = 0; i < len; i++)
+			{
+				if (i != 0) this.out_substr(", ")?;
+				this.out_str(variant { ptr, inner })?;
+				ptr += size;
+			}
+			return this.out(']');
+		case VECTOR:
+			if (this.print_with_function(arg)?) return;
+			// this is SomeType[*] so grab the "SomeType"
+			typeid inner = arg.type.inner;
+			usz size = inner.sizeof;
+			usz len = arg.type.len;
+			// Pretend this is a String
+			void* ptr = (void*)arg.ptr;
+			this.out_substr("[<")?;
+			for (usz i = 0; i < len; i++)
+			{
+				if (i != 0) this.out_substr(", ")?;
+				this.out_str(variant { ptr, inner })?;
+				ptr += size;
+			}
+			return this.out_substr(">]");
+		case SUBARRAY:
+			if (this.print_with_function(arg)?) return;
+			// this is SomeType[] so grab the "SomeType"
+			typeid inner = arg.type.inner;
+			if (inner == char.typeid)
+			{
+				return this.out_substr(*(String*)arg);
+			}
+			usz size = inner.sizeof;
+            // Pretend this is a String
+			String* temp = (void*)arg.ptr;
+			void* ptr = (void*)temp.ptr;
+			usz len = temp.len;
+			this.out('[')?;
+			for (usz i = 0; i < len; i++)
+			{
+				if (i != 0) this.out_substr(", ")?;
+				this.out_str(variant { ptr, inner })?;
+				ptr += size;
+			}
+			this.out(']')?;
+		case BOOL:
+			if (*(bool*)arg.ptr)
+			{
+				return this.out_substr("true");
+			}
+			else
+			{
+				return this.out_substr("false");
+			}
+		default:
+			if (this.print_with_function(arg)?) return;
+			return this.out_substr("Invalid type");
+	}
+}
+
+
+
+fn void! out_buffer_fn(char c, void *data) @private
+{
+	BufferData *buffer_data = data;
+	if (buffer_data.written >= buffer_data.buffer.len) return PrintFault.BUFFER_EXCEEDED!;
+	buffer_data.buffer[buffer_data.written++] = c;
+}
+
+fn void! out_null_fn(char c @unused, void* data @unused) @private
+{
+}
+
+fn void! out_putchar_fn(char c, void* data @unused) @private
+{
+	libc::putchar(c);
+}
+
+fn void! out_fputchar_fn(char c, void* data) @private
+{
+	File* f = data;
+	f.putc(c)?;
+}
+
+fn void! out_string_append_fn(char c, void* data) @private
+{
+	VarString* s = data;
+	s.append_char(c);
+}
+
+
+struct BufferData @private
+{
+	char[] buffer;
+	usz written;
+}
+
+
+fn usz! Formatter.vprintf(Formatter* this, String format, variant[] variants)
+{
+	if (!this.out_fn)
+	{
+		// use null output function
+		this.out_fn = &out_null_fn;
+	}
+	usz format_len = format.len;
+	usz variant_index = 0;
+	for (usz i = 0; i < format_len; i++)
+	{
+		// format specifier?  %[flags][width][.precision][length]
+		char c = format[i];
+		if (c != '%')
+		{
+			// no
+			this.out(c)?;
+			continue;
+		}
+		i++;
+		if (i >= format_len) return PrintFault.INVALID_FORMAT_STRING!;
+		c = format[i];
+		if (c == '%')
+		{
+			this.out(c)?;
+			continue;
+		}
+		// evaluate flags
+		this.flags = {};
+		while FLAG_EVAL: (true)
+		{
+			switch (c)
+			{
+				case '0': this.flags.zeropad = true;
+				case '-': this.flags.left = true;
+				case '+': this.flags.plus = true;
+				case ' ': this.flags.space = true;
+				case '#': this.flags.hash = true;
+				default: break FLAG_EVAL;
+			}
+			if (++i >= format_len) return PrintFault.INVALID_FORMAT_STRING!;
+			c = format[i];
+		}
+		// evaluate width field
+		int w = printf_parse_format_field(variants.ptr, variants.len, &variant_index, format.ptr, format.len, &i)?;
+		c = format[i];
+		if (w < 0)
+		{
+			this.flags.left = true;
+			w = -w;
+		}
+		this.width = w;
+		// evaluate precision field
+		this.prec = 0;
+		if (c == '.')
+		{
+			this.flags.precision = true;
+			if (++i >= format_len) return PrintFault.INVALID_FORMAT_STRING!;
+			int prec = printf_parse_format_field(variants.ptr, variants.len, &variant_index, format.ptr, format.len, &i)?;
+			this.prec = prec < 0 ? 0 : prec;
+			c = format[i];
+		}
+
+		// evaluate specifier
+		uint base = 0;
+		if (variant_index >= variants.len) return PrintFault.MISSING_ARG!;
+		variant current = variants[variant_index++];
+		switch (c)
+		{
+			case 'd':
+				base = 10;
+				this.flags.hash = false;
+			case 'X' :
+				this.flags.uppercase = true;
+				nextcase;
+			case 'x' :
+				base = 16;
+			case 'O':
+				this.flags.uppercase = true;
+				nextcase;
+			case 'o' :
+				base = 8;
+			case 'B':
+				this.flags.uppercase = true;
+				nextcase;
+			case 'b' :
+				base = 2;
+			case 'A':
+				this.flags.uppercase = true;
+				nextcase;
+			case 'a':
+				this.atoa(float_from_variant(current)!!)?;
+				continue;
+		    case 'F' :
+		        this.flags.uppercase = true;
+		        nextcase;
+		    case 'f':
+		        this.ftoa(float_from_variant(current)!!)?;
+				continue;
+			case 'E':
+		        this.flags.uppercase = true;
+		        nextcase;
+            case 'e':
+                this.etoa(float_from_variant(current)!!)?;
+				continue;
+			case 'G':
+				this.flags.uppercase = true;
+				nextcase;
+			case 'g':
+				this.gtoa(float_from_variant(current)!!)?;
+				continue;
+			case 'c':
+				this.out_char(current)?;
+				continue;
+			case 's':
+				this.out_str(current)?;
+				continue;
+			case 'p':
+				this.flags.zeropad = true;
+				this.flags.hash = true;
+				base = 16;
+			default:
+				return PrintFault.INVALID_FORMAT_STRING!;
+		}
+		if (base != 10)
+		{
+			this.flags.plus = false;
+			this.flags.space = false;
+		}
+		// ignore '0' flag when precision is given
+		if (this.flags.precision) this.flags.zeropad = false;
+
+		bool is_neg;
+		uint128 v = int_from_variant(current, &is_neg)!!;
+
+		this.ntoa(v, is_neg, base)?;
+	}
+	// termination
+	//	out((char)0, buffer, idx < maxlen ? idx : maxlen - 1U, maxlen);
+
+	// return written chars without terminating \0
+	return this.idx;
+}
+
+typedef StringFunctionMap @private = HashMap<typeid, ToStringFunction>;
+typedef FormatterFunctionMap @private = HashMap<typeid, ToFormatFunction>;
+
+FormatterFunctionMap toformat_functions @private;
+StringFunctionMap tostring_functions @private;

lib/std/io/io_stream.c3

@@ -0,0 +1,205 @@
+module std::io;
+
+typedef CloseStreamFn = fn void!(Stream*);
+typedef FlushStreamFn = fn void!(Stream*);
+typedef SeekStreamFn = fn usz!(Stream*, isz offset, Seek seek);
+typedef LenStreamFn = fn usz(Stream*);
+typedef AvailableStreamFn = fn usz(Stream*);
+typedef ReadStreamFn = fn usz!(Stream*, char[] bytes);
+typedef ReadFromStreamFn = fn usz!(Stream*, Stream*);
+typedef ReadByteStreamFn = fn char!(Stream*);
+typedef PushbackByteStreamFn = fn void!(Stream*);
+typedef WriteStreamFn = fn usz!(Stream*, char[] bytes);
+typedef WriteToStreamFn = fn usz!(Stream*, Stream* out);
+typedef WriteByteStreamFn = fn void!(Stream*, char c);
+typedef DestroyStreamFn = fn void!(Stream*);
+
+struct StreamInterface
+{
+	CloseStreamFn close_fn;
+	FlushStreamFn flush_fn;
+	SeekStreamFn seek_fn;
+	LenStreamFn len_fn;
+	AvailableStreamFn available_fn;
+	ReadStreamFn read_fn;
+	ReadFromStreamFn read_stream_fn;
+	ReadByteStreamFn read_byte_fn;
+	PushbackByteStreamFn pushback_byte_fn;
+	WriteStreamFn write_fn;
+	WriteToStreamFn write_stream_fn;
+	WriteByteStreamFn write_byte_fn;
+	DestroyStreamFn destroy_fn;
+}
+
+struct Stream
+{
+	StreamInterface *fns;
+	void* data;
+}
+
+fn bool Stream.supports_seek(Stream* s) @inline => (bool)s.fns.seek_fn;
+fn bool Stream.supports_available(Stream* s) @inline => s.fns.available_fn || s.fns.seek_fn;
+fn bool Stream.supports_len(Stream* s) @inline => s.fns.len_fn || s.fns.seek_fn;
+fn bool Stream.supports_read(Stream* s) @inline => s.fns.read_fn || s.fns.read_byte_fn;
+fn bool Stream.supports_read_from(Stream* s) @inline => (bool)s.fns.read_stream_fn;
+fn bool Stream.supports_write_to(Stream* s) @inline => (bool)s.fns.write_stream_fn;
+fn bool Stream.supports_pushback_byte(Stream* s) @inline => s.fns.pushback_byte_fn || s.fns.seek_fn;
+fn bool Stream.supports_write(Stream* s) @inline => s.fns.write_fn || s.fns.write_byte_fn;
+
+fn void! Stream.destroy(Stream* s) @inline @maydiscard
+{
+	if (s.fns.destroy_fn) return s.fns.destroy_fn(s);
+	return s.close();
+}
+
+fn void! Stream.close(Stream* s) @inline @maydiscard
+{
+	if (CloseStreamFn func = s.fns.close_fn) return func(s);
+}
+
+fn usz! Stream.seek(Stream* s, isz offset, Seek seek) @inline
+{
+	if (SeekStreamFn func = s.fns.seek_fn) return func(s, offset, seek);
+	return IoError.NOT_SEEKABLE!;
+}
+
+fn usz! Stream.available(Stream* s) @inline
+{
+	if (AvailableStreamFn func = s.fns.available_fn) return func(s);
+	if (SeekStreamFn func = s.fns.seek_fn)
+	{
+		usz curr = func(s, 0, Seek.CURSOR)?;
+		usz len = func(s, 0, Seek.END)?;
+		func(s, curr, Seek.SET)?;
+		return len - curr;
+	}
+	return IoError.NOT_SEEKABLE!;
+}
+
+fn usz! Stream.read(Stream* s, char[] buffer)
+{
+	if (ReadStreamFn func = s.fns.read_fn) return func(s, buffer);
+	if (ReadByteStreamFn func = s.fns.read_byte_fn)
+	{
+		usz len = 0;
+		foreach (&cptr : buffer)
+		{
+			char! c = func(s);
+			if (catch err = c)
+			{
+				case IoError.EOF: return len;
+				default: return err!;
+			}
+			*cptr = c;
+			len++;
+		}
+	}
+	return IoError.UNSUPPORTED_OPERATION!;
+}
+
+fn char! Stream.read_byte(Stream* s) @inline
+{
+	if (ReadByteStreamFn func = s.fns.read_byte_fn) return func(s);
+	return IoError.UNSUPPORTED_OPERATION!;
+}
+
+fn usz! Stream.write(Stream* s, char[] bytes) @inline
+{
+	if (WriteStreamFn func = s.fns.write_fn) return func(s, bytes);
+	if (WriteByteStreamFn func = s.fns.write_byte_fn)
+	{
+		foreach (c : bytes) func(s, c)?;
+		return bytes.len;
+	}
+	return IoError.UNSUPPORTED_OPERATION!;
+}
+
+fn void! Stream.write_byte(Stream* s, char b) @inline
+{
+	if (WriteByteStreamFn func = s.fns.write_byte_fn) return func(s, b);
+	return IoError.UNSUPPORTED_OPERATION!;
+}
+
+fn usz! Stream.write_to(Stream* s, Stream* to) @inline
+{
+	if (WriteToStreamFn func = s.fns.write_stream_fn) return func(s, to);
+	return IoError.UNSUPPORTED_OPERATION!;
+}
+
+fn usz! Stream.read_from(Stream* s, Stream* from) @inline
+{
+	if (ReadFromStreamFn func = s.fns.read_stream_fn) return func(s, from);
+	return IoError.UNSUPPORTED_OPERATION!;
+}
+
+fn void! Stream.flush(Stream* s) @inline @maydiscard
+{
+	if (FlushStreamFn func = s.fns.flush_fn) return func(s);
+	return IoError.UNSUPPORTED_OPERATION!;
+}
+
+fn usz! Stream.len(Stream* s) @inline
+{
+	if (LenStreamFn func = s.fns.len_fn) return func(s);
+	if (SeekStreamFn func = s.fns.seek_fn)
+	{
+		usz curr = func(s, 0, Seek.CURSOR)?;
+		usz len = func(s, 0, Seek.END)?;
+		func(s, curr, Seek.SET)?;
+		return len;
+	}
+	return IoError.NOT_SEEKABLE!;
+}
+
+fn void! Stream.pushback_byte(Stream* s) @inline
+{
+	if (PushbackByteStreamFn func = s.fns.pushback_byte_fn) return func(s);
+	if (SeekStreamFn func = s.fns.seek_fn)
+	{
+		func(s, -1, CURSOR)?;
+		return;
+	}
+	return IoError.UNSUPPORTED_OPERATION!;
+}
+
+fn void! Stream.write_string(Stream* s, String str) @inline => (void)(s.write((char[])str)?);
+
+fn usz! Stream.copy_to(Stream* s, Stream* dst, char[] buffer = {})
+{
+	if (buffer.len) return copy_through_buffer(s, dst, buffer);
+	if (WriteToStreamFn func = s.fns.write_stream_fn) return func(s, dst);
+	if (ReadFromStreamFn func = dst.fns.read_stream_fn) return func(dst, s);
+$switch (env::MEMORY_ENV)
+$case NORMAL:
+	@pool()
+	{
+		return copy_through_buffer(s, dst, tmalloc(char, 4096));
+	};
+$case SMALL:
+	@pool()
+	{
+		return copy_through_buffer(s, dst, tmalloc(char, 1024));
+	};
+$case TINY:
+$case NONE:
+	return copy_through_buffer(s, dst, &&(char[256]{}));
+$endswitch
+}
+
+macro usz! copy_through_buffer(Stream* s, Stream* dst, char[] buffer) @local
+{
+	usz total_copied;
+	while (true)
+	{
+		usz! len = s.read(buffer);
+		if (catch err = len)
+		{
+			case IoError.EOF: return total_copied;
+			default: return err!;
+		}
+		if (!len) return total_copied;
+		usz written = dst.write(buffer[:len])?;
+		total_copied += len;
+		if (written != len) return IoError.INCOMPLETE_WRITE!;
+	}
+}

lib/std/io/os/chdir.c3

@@ -1,30 +1,43 @@
 module std::io::os;
-import std::io::path, libc, std::os;
+import libc;
+
+
+$switch
+	$case !env::COMPILER_LIBC_AVAILABLE:
+
+fn void! native_chdir(Path path)
+{
+	unreachable("'getcwd' not available");
+}
+
+	$case env::os_is_win32():
 
 macro void! native_chdir(Path path)
 {
-	$switch
-		$case env::POSIX:
-			if (posix::chdir(path.as_zstr()))
-			{
-				switch (libc::errno())
-				{
-					case errno::EACCES: return IoError.NO_PERMISSION?;
-					case errno::ENAMETOOLONG: return IoError.NAME_TOO_LONG?;
-					case errno::ENOTDIR: return IoError.FILE_NOT_DIR?;
-					case errno::ENOENT: return IoError.FILE_NOT_FOUND?;
-					case errno::ELOOP: return IoError.SYMLINK_FAILED?;
-					default: return IoError.GENERAL_ERROR?;
-				}
-			}
-		$case env::WIN32:
-			@pool()
-			{
-				// TODO improve with better error handling.
-				if (win32::setCurrentDirectoryW(path.str_view().to_temp_utf16()!!)) return;
-			};
-			return IoError.GENERAL_ERROR?;
-		$default:
-			return IoError.UNSUPPORTED_OPERATION?;
-	$endswitch
+	@pool()
+	{
+		 if (files::win32_SetCurrentDirectoryW(path.as_str().to_temp_utf16()!!)) return;
+	};
+	return IoError.GENERAL_ERROR!;
 }
+
+	$default:
+
+extern fn int _chdir(ZString) @extern("chdir");
+macro void! native_chdir(Path p)
+{
+	if (_chdir((ZString)p.as_str()))
+	{
+		switch (libc::errno())
+		{
+			case errno::EACCES: return IoError.NO_PERMISSION!;
+			case errno::ENAMETOOLONG: return IoError.NAME_TOO_LONG!;
+			case errno::ENOTDIR: return IoError.FILE_NOT_DIR!;
+			case errno::ENOENT: return IoError.FILE_NOT_FOUND!;
+			case errno::ELOOP: return IoError.SYMLINK_FAILED!;
+			default: return IoError.GENERAL_ERROR!;
+		}
+	}
+}
+
+$endswitch

lib/std/io/os/file.c3

@@ -0,0 +1,187 @@
+module std::io::os;
+import libc;
+
+typedef FopenFn = fn void*!(String, String);
+typedef FreopenFn = fn void*!(void*, String, String);
+typedef FcloseFn = fn void!(void*);
+typedef FseekFn = fn void!(void*, isz, Seek);
+typedef FtellFn = fn usz!(void*);
+typedef FwriteFn = fn usz!(void*, char[] buffer);
+typedef FreadFn = fn usz!(void*, char[] buffer);
+
+$if (!$defined(native_fopen_fn))
+FopenFn native_fopen_fn @weak;
+$endif
+$if (!$defined(native_fclose_fn))
+FcloseFn native_fclose_fn @weak;
+$endif
+$if (!$defined(native_freopen_fn))
+FreopenFn native_freopen_fn @weak;
+$endif
+$if (!$defined(native_fseek_fn))
+FseekFn native_fseek_fn @weak;
+$endif
+$if (!$defined(native_ftell_fn))
+FtellFn native_ftell_fn @weak;
+$endif
+$if (!$defined(native_fwrite_fn))
+FwriteFn native_fwrite_fn @weak;
+$endif
+$if (!$defined(native_fread_fn))
+FreadFn native_fread_fn @weak;
+$endif
+
+
+/**
+ * @require mode.len > 0
+ * @require filename.len > 0
+ **/
+fn void*! native_fopen(String filename, String mode) @inline
+{
+$if (!env::COMPILER_LIBC_AVAILABLE)
+		if (native_fopen_fn) return native_fopen_fn(filename, mode);
+		unreachable("Tried to call fopen without support.");
+$else
+	@pool()
+	{
+	$if (env::os_is_win32())
+		void* file = (CFile)_wfopen(filename.to_temp_utf16(), filename.to_temp_utf16())?;
+	$else
+		void* file = libc::fopen(filename.zstr_tcopy(), mode.zstr_tcopy());
+	$endif
+		return file ?: file_open_errno()!;
+	};
+$endif
+}
+
+/**
+ * @require mode.len > 0
+ * @require filename.len > 0
+ **/
+fn void*! native_freopen(void* file, String filename, String mode) @inline
+{
+$if (!env::COMPILER_LIBC_AVAILABLE)
+		if (native_freopen_fn) return native_freopen_fn(file, filename, mode);
+		unreachable("Tried to call freopen without support.");
+$else
+	@pool()
+	{
+	$if (env::os_is_win32())
+		file = _wfreopen(filename.to_temp_utf16(), mode.to_temp_utf16(), file)?;
+	$else
+		file = libc::freopen(filename.zstr_tcopy(), mode.zstr_tcopy(), file);
+	$endif
+		return file ?: file_open_errno()!;
+	};
+$endif
+}
+
+fn void! native_fseek(void* file, isz offset, Seek seek_mode) @inline
+{
+$if (!env::COMPILER_LIBC_AVAILABLE)
+	if (native_fseek_fn) return native_fseek_fn(file, offset, seek_mode);
+	unreachable("Tried to call fseek without support.");
+$else
+	$if (env::os_is_win32())
+		bool success = _fseeki64(file, (long)offset, (int)seek_mode) == 0;
+	$else
+		bool success = libc::fseek(file, (SeekIndex)offset, (CInt)seek_mode) == 0;
+	$endif
+		if (!success) return file_seek_errno()!;
+$endif
+}
+
+fn usz! native_ftell(CFile file) @inline
+{
+$if (!env::COMPILER_LIBC_AVAILABLE)
+	if (native_ftell_fn) return native_ftell_fn(file);
+	unreachable("Tried to call ftell without support.");
+$else
+	$if (env::os_is_win32())
+		long index = _ftelli64(file);
+		return index >= 0 ? index : file_seek_errno()!;
+	$else
+		SeekIndex index = libc::ftell(file);
+		return index >= 0 ? index : file_seek_errno()!;
+	$endif
+$endif
+}
+
+fn usz! native_fwrite(CFile file, char[] buffer) @inline
+{
+$if (!env::COMPILER_LIBC_AVAILABLE)
+	if (native_fwrite_fn) return native_fwrite_fn(file, buffer);
+	unreachable("Tried to call fwrite without support.");
+$else
+    return libc::fwrite(buffer.ptr, 1, buffer.len, file);
+$endif
+}
+
+fn usz! native_fread(CFile file, char[] buffer) @inline
+{
+$if (!env::COMPILER_LIBC_AVAILABLE)
+	if (native_fread_fn) return native_fread_fn(file, buffer);
+	unreachable("Tried to call fread without support.");
+$else
+    return libc::fread(buffer.ptr, 1, buffer.len, file);
+$endif
+}
+
+macro anyerr file_open_errno() @local
+{
+	switch (libc::errno())
+	{
+	    case errno::EACCES: return IoError.NO_PERMISSION;
+	    case errno::EDQUOT: return IoError.OUT_OF_SPACE;
+	    case errno::EBADF: return IoError.FILE_NOT_VALID;
+	    case errno::EEXIST: return IoError.ALREADY_EXISTS;
+	    case errno::EINTR: return IoError.INTERRUPTED;
+	    case errno::EFAULT: return IoError.GENERAL_ERROR;
+	    case errno::EISDIR: return IoError.FILE_IS_DIR;
+	    case errno::ELOOP: return IoError.SYMLINK_FAILED;
+	    case errno::EMFILE: return IoError.TOO_MANY_DESCRIPTORS;
+	    case errno::ENAMETOOLONG: return IoError.NAME_TOO_LONG;
+	    case errno::ENFILE: return IoError.OUT_OF_SPACE;
+	    case errno::ENOTDIR: return IoError.FILE_NOT_DIR;
+		case errno::ENOENT: return IoError.FILE_NOT_FOUND;
+	    case errno::ENOSPC: return IoError.OUT_OF_SPACE;
+		case errno::ENXIO: return IoError.FILE_NOT_FOUND;
+		case errno::EOVERFLOW: return IoError.OVERFLOW;
+		case errno::EROFS: return IoError.READ_ONLY;
+		case errno::EOPNOTSUPP: return IoError.UNSUPPORTED_OPERATION;
+	    case errno::EIO: return IoError.INCOMPLETE_WRITE;
+	    case errno::EWOULDBLOCK: return IoError.WOULD_BLOCK;
+	    default: return IoError.UNKNOWN_ERROR;
+	}
+}
+
+macro anyerr file_seek_errno() @local
+{
+	switch (libc::errno())
+	{
+		case errno::ESPIPE: return IoError.FILE_IS_PIPE;
+		case errno::EPIPE: return IoError.FILE_IS_PIPE;
+		case errno::EOVERFLOW: return IoError.OVERFLOW;
+	    case errno::ENXIO: return IoError.FILE_NOT_FOUND;
+	    case errno::ENOSPC: return IoError.OUT_OF_SPACE;
+        case errno::EIO: return IoError.INCOMPLETE_WRITE;
+		case errno::EINVAL: return IoError.INVALID_POSITION;
+	    case errno::EINTR: return IoError.INTERRUPTED;
+	    case errno::EFBIG: return IoError.OUT_OF_SPACE;
+	    case errno::EBADF: return IoError.FILE_NOT_VALID;
+	    case errno::EAGAIN: return IoError.WOULD_BLOCK;
+	    default: return IoError.UNKNOWN_ERROR;
+	}
+}
+
+// Win functions
+$if (env::os_is_win32())
+extern fn void* _wfopen(Char16*, Char16*) @local;
+extern fn void* _wfreopen(Char16*, Char16*, CFile) @local;
+extern fn int _fseeki64(CFile, long, int) @local;
+extern fn long _ftelli64(CFile) @local;
+$endif
+
+$if (env::os_is_posix())
+extern fn CInt access(ZString path, CInt mode);
+$endif

lib/std/io/os/file_libc.c3

@@ -1,129 +0,0 @@
-module std::io::os @if(env::LIBC);
-import libc;
-
-/**
- * @require mode.len > 0
- * @require filename.len > 0
- **/
-fn void*! native_fopen(String filename, String mode) @inline
-{
-	@pool()
-	{
-		$if env::WIN32:
-			void* file = libc::_wfopen(filename.to_temp_wstring(), mode.to_temp_wstring())!;
-		$else
-			void* file = libc::fopen(filename.zstr_tcopy(), mode.zstr_tcopy());
-		$endif
-			return file ?: file_open_errno()?;
-	};
-}
-
-fn void! native_remove(String filename)
-{
-	@pool()
-	{
-		$if env::WIN32:
-			CInt result = libc::_wremove(filename.to_temp_wstring())!;
-		$else
-			CInt result = libc::remove(filename.zstr_tcopy());
-		$endif
-		if (result)
-		{
-			switch (libc::errno())
-			{
-				case errno::ENOENT:
-					return IoError.FILE_NOT_FOUND?;
-				case errno::EACCES:
-				default:
-					return IoError.FILE_CANNOT_DELETE?;
-			}
-		}
-	};
-}
-
-/**
- * @require mode.len > 0
- * @require filename.len > 0
- **/
-fn void*! native_freopen(void* file, String filename, String mode) @inline
-{
-	@pool()
-	{
-		$if env::WIN32:
-			file = libc::_wfreopen(filename.to_temp_wstring(), mode.to_temp_wstring(), file)!;
-		$else
-			file = libc::freopen(filename.zstr_tcopy(), mode.zstr_tcopy(), file);
-		$endif
-			return file ?: file_open_errno()?;
-	};
-}
-
-fn void! native_fseek(void* file, isz offset, Seek seek_mode) @inline
-{
-	if (libc::fseek(file, (SeekIndex)offset, (CInt)seek_mode)) return file_seek_errno()?;
-}
-
-
-fn usz! native_ftell(CFile file) @inline
-{
-	long index = libc::ftell(file);
-	return index >= 0 ? (usz)index : file_seek_errno()?;
-}
-
-fn usz! native_fwrite(CFile file, char[] buffer) @inline
-{
-	return libc::fwrite(buffer.ptr, 1, buffer.len, file);
-}
-
-fn usz! native_fread(CFile file, char[] buffer) @inline
-{
-	return libc::fread(buffer.ptr, 1, buffer.len, file);
-}
-
-macro anyfault file_open_errno() @local
-{
-	switch (libc::errno())
-	{
-		case errno::EACCES: return IoError.NO_PERMISSION;
-		case errno::EDQUOT: return IoError.OUT_OF_SPACE;
-		case errno::EBADF: return IoError.FILE_NOT_VALID;
-		case errno::EEXIST: return IoError.ALREADY_EXISTS;
-		case errno::EINTR: return IoError.INTERRUPTED;
-		case errno::EFAULT: return IoError.GENERAL_ERROR;
-		case errno::EISDIR: return IoError.FILE_IS_DIR;
-		case errno::ELOOP: return IoError.SYMLINK_FAILED;
-		case errno::EMFILE: return IoError.TOO_MANY_DESCRIPTORS;
-		case errno::ENAMETOOLONG: return IoError.NAME_TOO_LONG;
-		case errno::ENFILE: return IoError.OUT_OF_SPACE;
-		case errno::ENOTDIR: return IoError.FILE_NOT_DIR;
-		case errno::ENOENT: return IoError.FILE_NOT_FOUND;
-		case errno::ENOSPC: return IoError.OUT_OF_SPACE;
-		case errno::ENXIO: return IoError.FILE_NOT_FOUND;
-		case errno::EOVERFLOW: return IoError.OVERFLOW;
-		case errno::EROFS: return IoError.READ_ONLY;
-		case errno::EOPNOTSUPP: return IoError.UNSUPPORTED_OPERATION;
-		case errno::EIO: return IoError.INCOMPLETE_WRITE;
-		case errno::EWOULDBLOCK: return IoError.WOULD_BLOCK;
-		default: return IoError.UNKNOWN_ERROR;
-	}
-}
-
-macro anyfault file_seek_errno() @local
-{
-	switch (libc::errno())
-	{
-		case errno::ESPIPE: return IoError.FILE_IS_PIPE;
-		case errno::EPIPE: return IoError.FILE_IS_PIPE;
-		case errno::EOVERFLOW: return IoError.OVERFLOW;
-		case errno::ENXIO: return IoError.FILE_NOT_FOUND;
-		case errno::ENOSPC: return IoError.OUT_OF_SPACE;
-		case errno::EIO: return IoError.INCOMPLETE_WRITE;
-		case errno::EINVAL: return IoError.INVALID_POSITION;
-		case errno::EINTR: return IoError.INTERRUPTED;
-		case errno::EFBIG: return IoError.OUT_OF_SPACE;
-		case errno::EBADF: return IoError.FILE_NOT_VALID;
-		case errno::EAGAIN: return IoError.WOULD_BLOCK;
-		default: return IoError.UNKNOWN_ERROR;
-	}
-}
-

lib/std/io/os/file_nolibc.c3

@@ -1,75 +0,0 @@
-module std::io::os @if(env::NO_LIBC);
-import libc;
-
-def FopenFn = fn void*!(String, String);
-def FreopenFn = fn void*!(void*, String, String);
-def FcloseFn = fn void!(void*);
-def FseekFn = fn void!(void*, isz, Seek);
-def FtellFn = fn usz!(void*);
-def FwriteFn = fn usz!(void*, char[] buffer);
-def FreadFn = fn usz!(void*, char[] buffer);
-def RemoveFn = fn void!(String);
-
-FopenFn native_fopen_fn @weak @if(!$defined(native_fopen_fn));
-FcloseFn native_fclose_fn @weak @if(!$defined(native_fclose_fn));
-FreopenFn native_freopen_fn @weak @if(!$defined(native_freopen_fn));
-FseekFn native_fseek_fn @weak @if(!$defined(native_fseek_fn));
-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));
-
-/**
- * @require mode.len > 0
- * @require filename.len > 0
- **/
-fn void*! native_fopen(String filename, String mode) @inline
-{
-	if (native_fopen_fn) return native_fopen_fn(filename, mode);
-	return IoError.UNSUPPORTED_OPERATION?;
-}
-
-/**
- * Delete a file.
- *
- * @require filename.len > 0
- **/
-fn void! native_remove(String filename) @inline
-{
-	if (native_remove_fn) return native_remove_fn(filename);
-	return IoError.UNSUPPORTED_OPERATION?;
-}
-
-/**
- * @require mode.len > 0
- * @require filename.len > 0
- **/
-fn void*! native_freopen(void* file, String filename, String mode) @inline
-{
-	if (native_freopen_fn) return native_freopen_fn(file, filename, mode);
-	return IoError.UNSUPPORTED_OPERATION?;
-}
-
-fn void! native_fseek(void* file, isz offset, Seek seek_mode) @inline
-{
-	if (native_fseek_fn) return native_fseek_fn(file, offset, seek_mode);
-	return IoError.UNSUPPORTED_OPERATION?;
-}
-
-fn usz! native_ftell(CFile file) @inline
-{
-	if (native_ftell_fn) return native_ftell_fn(file);
-	return IoError.UNSUPPORTED_OPERATION?;
-}
-
-fn usz! native_fwrite(CFile file, char[] buffer) @inline
-{
-	if (native_fwrite_fn) return native_fwrite_fn(file, buffer);
-	return IoError.UNSUPPORTED_OPERATION?;
-}
-
-fn usz! native_fread(CFile file, char[] buffer) @inline
-{
-	if (native_fread_fn) return native_fread_fn(file, buffer);
-	return IoError.UNSUPPORTED_OPERATION?;
-}

lib/std/io/os/fileinfo.c3

@@ -1,116 +0,0 @@
-module std::io::os;
-import libc, std::os, std::io;
-
-fn void! native_stat(Stat* stat, String path) @if(env::DARWIN || env::LINUX)
-{
-	@pool()
-	{
-		$if env::DARWIN || env::LINUX:
-			int res = libc::stat(path.zstr_tcopy(), stat);
-		$else
-			unreachable("Stat unimplemented");
-			int res = 0;
-		$endif
-		if (res != 0)
-		{
-			switch (libc::errno())
-			{
-				case errno::EBADF:
-					return IoError.FILE_NOT_VALID?;
-				case errno::EFAULT:
-					unreachable("Invalid stat");
-				case errno::EIO:
-					return IoError.GENERAL_ERROR?;
-				case errno::EACCES:
-					return IoError.NO_PERMISSION?;
-				case errno::ELOOP:
-					return IoError.NO_PERMISSION?;
-				case errno::ENAMETOOLONG:
-					return IoError.NAME_TOO_LONG?;
-				case errno::ENOENT:
-					return IoError.FILE_NOT_FOUND?;
-				case errno::ENOTDIR:
-					return IoError.FILE_NOT_DIR?;
-				case errno::EOVERFLOW:
-					return IoError.GENERAL_ERROR?;
-				default:
-					return IoError.UNKNOWN_ERROR?;
-			}
-		}
-	};
-}
-
-fn usz! native_file_size(String path) @if(env::WIN32)
-{
-	@pool()
-	{
-		Win32_FILE_ATTRIBUTE_DATA data;
-		win32::getFileAttributesExW(path.to_temp_wstring()!, Win32_GET_FILEEX_INFO_LEVELS.STANDARD, &data);
-		Win32_LARGE_INTEGER size;
-		size.lowPart = data.nFileSizeLow;
-		size.highPart = data.nFileSizeHigh;
-		return (usz)size.quadPart;
-	};
-}
-
-fn usz! native_file_size(String path) @if(!env::WIN32 && !env::DARWIN)
-{
-	File f = file::open(path, "r")!;
-	defer (void)f.close();
-	return f.seek(0, Seek.END)!;
-}
-
-fn usz! native_file_size(String path) @if(env::DARWIN)
-{
-	Stat stat;
-	native_stat(&stat, path)!;
-	return stat.st_size;
-}
-
-fn bool native_file_or_dir_exists(String path)
-{
-	$switch
-		$case env::DARWIN:
-		$case env::LINUX:
-			Stat stat;
-			return @ok(native_stat(&stat, path));
-		$case env::WIN32:
-			@pool()
-			{
-				return (bool)win32::pathFileExistsW(path.to_temp_utf16()) ?? false;
-			};
-		$case env::POSIX:
-			@pool()
-			{
-				return posix::access(path.zstr_tcopy(), 0 /* F_OK */) != -1;
-			};
-		$default:
-			unreachable("Not supported");
-	$endswitch
-}
-
-fn bool native_is_file(String path)
-{
-	$switch
-		$case env::DARWIN:
-		$case env::LINUX:
-			Stat stat;
-			return @ok(native_stat(&stat, path)) && stat.st_mode & libc::S_IFREG;
-		$default:
-			File! f = file::open(path, "r");
-			defer (void)f.close();
-			return @ok(f);
-	$endswitch
-}
-
-fn bool native_is_dir(String path)
-{
-	$if env::DARWIN || env::LINUX:
-		Stat stat;
-		return @ok(native_stat(&stat, path)) && stat.st_mode & libc::S_IFDIR;
-	$else
-		return native_file_or_dir_exists(path) && !native_is_file(path);
-	$endif
-}
-
-

lib/std/io/os/fileinfo_darwin.c3

@@ -0,0 +1,102 @@
+module std::io::file::os;
+import libc;
+
+$if (env::os_is_darwin())
+
+
+struct DarwinTimespec @private
+{
+	long tv_sec;
+	long tv_nsec;
+}
+struct Darwin64Stat @private
+{
+	int st_dev;
+	ushort st_mode;
+	ushort st_nlink;
+	ulong st_ino;
+	uint st_uid;
+	uint st_gid;
+	int st_rdev;
+	DarwinTimespec st_atimespec; // time of last access
+    DarwinTimespec st_mtimespec; // time of last data modification
+    DarwinTimespec st_ctimespec; // time of last status change
+    DarwinTimespec st_birthtimespec; // time of file creation(birth)
+    long st_size;
+    long st_blocks;
+    int st_blocksize;
+    uint st_flags;
+    uint st_gen;
+    int st_lspare;
+    long[2] st_qspare;
+}
+extern fn int _stat(ZString str, Darwin64Stat* stat) @extern("stat64");
+
+const S_IFMT   = 0o170000; // type of file mask
+const S_IFIFO  = 0o010000; // named pipe (fifo)
+const S_IFCHR  = 0o020000; // character special
+const S_IFDIR  = 0o040000; // directory
+const S_IFBLK  = 0o060000; // block special
+const S_IFREG  = 0o100000; // regular
+const S_IFLNK  = 0o120000; // symbolic link
+const S_IFSOCK = 0o140000; // socket
+
+fn usz! native_file_size(String path)
+{
+	Darwin64Stat stat;
+	read_stat(&stat, path)?;
+	return stat.st_size;
+}
+
+fn bool native_file_or_dir_exists(String path)
+{
+	Darwin64Stat stat;
+	return try? read_stat(&stat, path);
+}
+
+fn bool native_is_file(String path)
+{
+	Darwin64Stat stat;
+	return try? read_stat(&stat, path) && (stat.st_mode & S_IFREG);
+}
+
+fn bool native_is_dir(String path)
+{
+	Darwin64Stat stat;
+	return try? read_stat(&stat, path) && (stat.st_mode & S_IFDIR);
+}
+
+fn void! read_stat(Darwin64Stat* stat, String path) @local
+{
+	@pool()
+	{
+		int res = _stat(path.zstr_tcopy(), stat);
+		if (res != 0)
+		{
+			switch (libc::errno())
+			{
+				case errno::EBADF:
+					return IoError.FILE_NOT_VALID!;
+				case errno::EFAULT:
+					unreachable("Invalid stat");
+				case errno::EIO:
+					return IoError.GENERAL_ERROR!;
+				case errno::EACCES:
+					return IoError.NO_PERMISSION!;
+				case errno::ELOOP:
+					return IoError.NO_PERMISSION!;
+				case errno::ENAMETOOLONG:
+					return IoError.NAME_TOO_LONG!;
+				case errno::ENOENT:
+					return IoError.FILE_NOT_FOUND!;
+				case errno::ENOTDIR:
+					return IoError.FILE_NOT_DIR!;
+				case errno::EOVERFLOW:
+					return IoError.GENERAL_ERROR!;
+				default:
+					return IoError.UNKNOWN_ERROR!;
+			}
+		}
+	};
+}
+$endif

lib/std/io/os/fileinfo_other.c3

@@ -0,0 +1,143 @@
+module std::io::file::os;
+
+// native_temp_directory, for non Win32
+$if (!env::os_is_win32())
+
+fn Path! native_temp_directory(Allocator* using = mem::heap())
+{
+	foreach (String env : { "TMPDIR", "TMP", "TEMP", "TEMPDIR" })
+	{
+		String tmpdir = env::get_var(env) ?? "";
+		if (tmpdir) return path::new(tmpdir, using);
+	}
+	return path::new("/tmp", using);
+}
+
+$if (env::COMPILER_LIBC_AVAILABLE)
+
+extern fn void* opendir(ZString);
+extern fn void closedir(void*);
+
+const DT_UNKNOWN =  0;
+const DT_FIFO    =  1;
+const DT_CHR     =  2;
+const DT_DIR     =  4;
+const DT_BLK     =  6;
+const DT_REG     =  8;
+const DT_LNK     = 10;
+const DT_SOCK    = 12;
+const DT_WHT     = 14;
+
+fn PathList! native_readdir(Path dir, bool no_dirs, bool no_symlinks, String mask, Allocator* using)
+{
+	PathList list;
+	list.init(.using = using);
+	void* directory = opendir(dir.as_str() ? dir.as_zstr() : (ZString)".");
+	defer if (directory) closedir(directory);
+	if (!directory) return (path::is_dir(dir) ? IoError.CANNOT_READ_DIR : IoError.FILE_NOT_DIR)!;
+	NativeDirentry* entry;
+	while ((entry = readdir(directory)))
+	{
+		String name = ((ZString)&entry.name).as_str();
+		if (!name || name == "." || name == "..") continue;
+		if (entry.type == DT_LNK && no_symlinks) continue;
+		if (entry.type == DT_DIR && no_dirs) continue;
+		Path path = path::new(name.copy(using), using)!!;
+		list.append(path);
+	}
+	return list;
+}
+
+$endif
+
+$endif
+
+$if (!env::os_is_darwin() && !env::os_is_win32())
+
+fn usz! native_file_size(String path)
+{
+	File f = file::open(path, "r")?;
+	defer (void)f.close();
+	return f.seek(0, Seek.END)?;
+}
+
+$if (env::os_is_posix() && env::COMPILER_LIBC_AVAILABLE)
+
+fn bool native_file_or_dir_exists(String path)
+{
+	@pool()
+	{
+		return os::access(path.zstr_tcopy(), 0 /* F_OK */) != -1;
+	};
+}
+
+fn bool native_is_file(String path)
+{
+	File! f = file::open(path, "r");
+	defer (void)f.close();
+	return try? f;
+}
+
+fn bool native_is_dir(String path)
+{
+	return native_file_or_dir_exists(path) && !native_is_file(path);
+}
+
+$else
+
+fn bool native_file_or_dir_exists(String path)
+{
+	unreachable("Tried to call file_or_dir_exists without support.");
+}
+
+fn bool native_is_dir(String path)
+{
+	unreachable("Tried to call is_dir without support.");
+}
+
+fn bool native_is_file(String path)
+{
+	unreachable("Tried to call is_file without support.");
+}
+
+$endif
+
+$endif
+
+$switch (env::OS_TYPE)
+$case IOS:
+$case MACOSX:
+$case TVOS:
+$case WATCHOS:
+extern fn NativeDirentry* readdir(void*) @extern("readdir$INODE64");
+struct NativeDirentry
+{
+	usz ino;
+	usz seekoff;
+	ushort reclen;
+	ushort namelen;
+	char type;
+	char[1024] name;
+}
+$case LINUX:
+extern fn NativeDirentry* readdir(void*);
+struct NativeDirentry
+{
+	usz ino;
+	isz seekoff;
+	ushort reclen;
+	char type;
+	char[*] name;
+}
+$default:
+// Fix this as we go along.
+extern fn NativeDirentry* readdir(void*);
+struct NativeDirentry
+{
+	usz ino;
+	isz seekoff;
+	ushort reclen;
+	char type;
+	char[*] name;
+}
+$endswitch

lib/std/io/os/fileinfo_win32.c3

@@ -0,0 +1,63 @@
+module std::io::file::os;
+import std::os::win32::files;
+
+$if (env::os_is_win32())
+
+fn usz! native_file_size(String path)
+{
+	@pool()
+	{
+		Char16[] path16 = path.to_temp_utf16()?;
+		Win32_FILE_ATTRIBUTE_DATA data;
+		files::win32_GetFileAttributesExW(path16, Win32_GET_FILEEX_INFO_LEVELS.STANDARD, &data);
+		Win32_LARGE_INTEGER size;
+		size.lowPart = data.nFileSizeLow;
+		size.highPart = data.nFileSizeHigh;
+		return (usz)size.quadPart;
+	};
+}
+
+fn bool native_file_or_dir_exists(String path)
+{
+	@pool()
+	{
+		return (bool)files::win32_PathFileExistsW(path.to_temp_utf16()) ?? false;
+	};
+}
+
+
+fn bool native_is_file(String path)
+{
+	File! f = file::open(path, "r");
+	defer (void)f.close();
+	return try? f;
+}
+
+fn bool native_is_dir(String path)
+{
+	return native_file_or_dir_exists(path) && !native_is_file(path);
+}
+
+fn Path! native_temp_directory(Allocator* using = mem::heap())
+{
+	@stack_mem(256; Allocator* mem)
+	{
+	    Win32_DWORD len = files::win32_GetTempPathW(0, null);
+		if (!len) return IoError.GENERAL_ERROR!;
+		Char16[] buff = malloc(Char16, len + 1, .using = mem);
+		if (!files::win32_GetTempPathW(len, buff)) return IoError.GENERAL_ERROR!;
+		return path::new(string::from_utf16(buff[:len], .using = mem), using);
+	};
+}
+
+/*
+
+	}else if(method == file_size_methods::get_attributes){
+		WIN32_FILE_ATTRIBUTE_DATA file_attr_data;
+		if(GetFileAttributesEx(path, GetFileExInfoStandard, &file_attr_data)){
+			file_size.LowPart = file_attr_data.nFileSizeLow;
+			file_size.HighPart = file_attr_data.nFileSizeHigh;
+		}
+	}
+*/
+$endif

lib/std/io/os/getcwd.c3

@@ -1,41 +1,54 @@
 module std::io::os;
-import libc, std::os;
+import libc;
 
-macro String! getcwd(Allocator* allocator = allocator::heap())
+$switch
+$case !env::COMPILER_LIBC_AVAILABLE:
+
+fn String! getcwd(Allocator* using = mem::heap())
 {
-	$switch
-		$case env::WIN32:
-			const DEFAULT_BUFFER = 256;
-			Char16[DEFAULT_BUFFER] buffer;
-			WString res = win32::_wgetcwd(&buffer, DEFAULT_BUFFER);
-			bool free = false;
-			defer if (free) libc::free(res);
-			if (!res)
-			{
-				if (libc::errno() != errno::ERANGE) return IoError.GENERAL_ERROR?;
-				res = win32::_wgetcwd(null, 0);
-				free = true;
-			}
-			Char16[] str16 = res[:win32::wcslen(res)];
-			return string::new_from_utf16(str16, allocator);
-
-		$case env::POSIX:
-			const usz DEFAULT_BUFFER = 256;
-			char[DEFAULT_BUFFER] buffer;
-			ZString res = posix::getcwd(&buffer, DEFAULT_BUFFER);
-			bool free = false;
-			if (!res)
-			{
-				// Improve error
-				if (libc::errno() != errno::ERANGE) return IoError.GENERAL_ERROR?;
-				res = posix::getcwd(null, 0);
-				free = true;
-			}
-			defer if (free) libc::free((void*)res);
-			return res.copy(allocator);
-
-		$default:
-			return IoError.UNSUPPORTED_OPERATION?;
-	$endswitch
+	unreachable("'getcwd' not available");
 }
 
+$case env::os_is_win32():
+
+extern fn Char16* _wgetcwd(Char16* buffer, int maxlen);
+extern fn usz wcslen(Char16* str);
+
+macro String! getcwd(Allocator* using = mem::heap())
+{
+	const DEFAULT_BUFFER = 256;
+	Char16[DEFAULT_BUFFER] buffer;
+	Char16 *res = _wgetcwd(&buffer, DEFAULT_BUFFER);
+	bool free = false;
+	defer if (free) libc::free(res);
+	if (!res)
+	{
+	    if (libc::errno() != errno::ERANGE) return IoError.GENERAL_ERROR!;
+		res = _wgetcwd(null, 0);
+		free = true;
+	}
+	Char16[] str16 = res[:wcslen(res)];
+	return str::utf16to8(str16, using);
+}
+
+$default:
+
+extern fn ZString _getcwd(char* pwd, usz len) @extern("getcwd");
+macro String! getcwd(Allocator* using = mem::heap())
+{
+	const usz DEFAULT_BUFFER = 256;
+	char[DEFAULT_BUFFER] buffer;
+	ZString res = _getcwd(&buffer, DEFAULT_BUFFER);
+	bool free = false;
+	if (!res)
+	{
+		// Improve error
+		if (libc::errno() != errno::ERANGE) return IoError.GENERAL_ERROR!;
+		res = _getcwd(null, 0);
+		free = true;
+	}
+	defer if (free) libc::free((void*)res);
+	return res.copy(using);
+}
+
+$endswitch

lib/std/io/os/ls.c3

@@ -1,51 +0,0 @@
-module std::io::os @if(env::POSIX);
-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);
-	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)?;
-	Posix_dirent* entry;
-	while ((entry = posix::readdir(directory)))
-	{
-		String name = ((ZString)&entry.name).str_view();
-		if (!name || name == "." || name == "..") continue;
-		if (entry.d_type == posix::DT_LNK && no_symlinks) continue;
-		if (entry.d_type == posix::DT_DIR && no_dirs) continue;
-		Path path = path::new(name, allocator)!!;
-		list.append(path);
-	}
-	return list;
-}
-
-module std::io::os @if(env::WIN32);
-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);
-
-	@pool(allocator)
-	{
-		WString result = dir.str_view().tconcat(`\*`).to_temp_wstring()!!;
-		Win32_WIN32_FIND_DATAW find_data;
-		Win32_HANDLE find = win32::findFirstFileW(result, &find_data);
-		if (find == win32::INVALID_HANDLE_VALUE) return IoError.CANNOT_READ_DIR?;
-		defer win32::findClose(find);
-		do
-		{
-			if (no_dirs && (find_data.dwFileAttributes & win32::FILE_ATTRIBUTE_DIRECTORY)) continue;
-			@pool(allocator)
-			{
-				String filename = string::temp_from_wstring((WString)&find_data.cFileName)!;
-				if (filename == ".." || filename == ".") continue;
-				list.append(path::new(filename, allocator)!);
-			};
-		} while (win32::findNextFileW(find, &find_data));
-		return list;
-	};
-}

lib/std/io/os/mkdir.c3

@@ -1,50 +0,0 @@
-module std::io::os;
-import libc;
-import std::io::path;
-import std::os::win32;
-import std::os::posix;
-
-
-macro bool! native_mkdir(Path path, MkdirPermissions permissions)
-{
-	$switch
-		$case env::POSIX:
-			if (!posix::mkdir(path.as_zstr(), permissions == NORMAL ? 0o777 : 0o700)) return true;
-			switch (libc::errno())
-			{
-				case errno::EACCES:
-				case errno::EPERM:
-				case errno::EROFS:
-				case errno::EFAULT: return IoError.NO_PERMISSION?;
-				case errno::ENAMETOOLONG: return IoError.NAME_TOO_LONG?;
-				case errno::EDQUOT:
-				case errno::ENOSPC: return IoError.OUT_OF_SPACE?;
-				case errno::EISDIR:
-				case errno::EEXIST: return false;
-				case errno::ELOOP: return IoError.SYMLINK_FAILED?;
-				case errno::ENOTDIR: return IoError.FILE_NOT_FOUND?;
-				default: return IoError.GENERAL_ERROR?;
-			}
-		$case env::WIN32:
-			@pool()
-			{
-				// TODO security attributes
-				if (win32::createDirectoryW(path.str_view().to_temp_utf16()!!, null)) return true;
-				switch (win32::getLastError())
-				{
-					case win32::ERROR_ACCESS_DENIED:
-						return IoError.NO_PERMISSION?;
-					case win32::ERROR_DISK_FULL:
-						return IoError.OUT_OF_SPACE?;
-					case win32::ERROR_ALREADY_EXISTS:
-						return false;
-					case win32::ERROR_PATH_NOT_FOUND:
-						return IoError.FILE_NOT_FOUND?;
-					default:
-						return IoError.GENERAL_ERROR?;
-				}
-			};
-		$default:
-			return IoError.UNSUPPORTED_OPERATION?;
-	$endswitch
-}

lib/std/io/os/rmdir.c3

@@ -1,48 +0,0 @@
-module std::io::os;
-import libc;
-import std::io::path;
-import std::os::win32;
-import std::os::posix;
-
-macro bool! native_rmdir(Path path)
-{
-	$switch
-		$case env::POSIX:
-			if (!posix::rmdir(path.as_zstr())) return true;
-			switch (libc::errno())
-			{
-				case errno::EBUSY: return IoError.BUSY?;
-				case errno::EACCES:
-				case errno::EPERM:
-				case errno::EROFS:
-				case errno::EFAULT: return IoError.NO_PERMISSION?;
-				case errno::ENAMETOOLONG: return IoError.NAME_TOO_LONG?;
-				case errno::ENOTDIR:
-				case errno::ENOENT: return false;
-				case errno::ENOTEMPTY: return IoError.DIR_NOT_EMPTY?;
-				case errno::ELOOP: return IoError.SYMLINK_FAILED?;
-				default: return IoError.GENERAL_ERROR?;
-			}
-		$case env::WIN32:
-			@pool()
-			{
-				if (win32::removeDirectoryW(path.str_view().to_temp_utf16()!!)) return true;
-				switch (win32::getLastError())
-				{
-					case win32::ERROR_ACCESS_DENIED:
-						return IoError.NO_PERMISSION?;
-					case win32::ERROR_CURRENT_DIRECTORY:
-						return IoError.BUSY?;
-					case win32::ERROR_DIR_NOT_EMPTY:
-						return IoError.DIR_NOT_EMPTY?;
-					case win32::ERROR_DIRECTORY:
-					case win32::ERROR_PATH_NOT_FOUND:
-						return false;
-					default:
-						return IoError.GENERAL_ERROR?;
-				}
-			};
-		$default:
-			return IoError.UNSUPPORTED_OPERATION?;
-	$endswitch
-}

lib/std/io/os/rmtree.c3

@@ -1,64 +0,0 @@
-module std::io::os @if(env::POSIX);
-import std::io, std::os, libc;
-
-/**
- * @require dir.str_view()
- **/
-fn void! native_rmtree(Path dir)
-{
-	DIRPtr directory = posix::opendir(dir.as_zstr());
-	defer if (directory) posix::closedir(directory);
-	if (!directory) return path::is_dir(dir) ? IoError.CANNOT_READ_DIR? : IoError.FILE_NOT_DIR?;
-	Posix_dirent* entry;
-	while ((entry = posix::readdir(directory)))
-	{
-		@pool()
-		{
-			String name = ((ZString)&entry.name).str_view();
-			if (!name || name == "." || name == "..") continue;
-			Path new_path = dir.tappend(name)!;
-			if (entry.d_type == posix::DT_DIR)
-			{
-				native_rmtree(new_path)!;
-				continue;
-			}
-			if (libc::remove(new_path.as_zstr()))
-			{
-				// TODO improve
-				return IoError.GENERAL_ERROR?;
-			}
-		};
-	}
-	os::native_rmdir(dir)!;
-}
-
-module std::io::os @if(env::WIN32);
-import std::io, std::time, std::os;
-
-fn void! native_rmtree(Path path)
-{
-	Win32_WIN32_FIND_DATAW find_data;
-	String s = path.str_view().tconcat("\\*");
-	Win32_HANDLE find = win32::findFirstFileW(s.to_temp_utf16(), &find_data)!;
-
-	if (find == win32::INVALID_HANDLE_VALUE) return IoError.CANNOT_READ_DIR?;
-	defer win32::findClose(find);
-	do
-	{
-		@pool()
-		{
-			String filename = string::new_from_wstring((WString)&find_data.cFileName, allocator::temp())!;
-			if (filename == "." || filename == "..") continue;
-			Path file_path = path.tappend(filename)!;
-			if (find_data.dwFileAttributes & win32::FILE_ATTRIBUTE_DIRECTORY)
-			{
-				native_rmtree(file_path)!;
-			}
-			else
-			{
-				win32::deleteFileW(file_path.str_view().to_temp_wstring()!!);
-			}
-		};
-	} while (win32::findNextFileW(find, &find_data) != 0);
-	os::native_rmdir(path)!;
-}

lib/std/io/os/temp_directory.c3

@@ -1,31 +0,0 @@
-module std::io::os @if(env::LIBC);
-import std::io::path, std::os;
-
-fn Path! native_temp_directory(Allocator* allocator = allocator::heap()) @if(!env::WIN32)
-{
-	foreach (String env : { "TMPDIR", "TMP", "TEMP", "TEMPDIR" })
-	{
-		String tmpdir = env::get_var(env) ?? "";
-		if (tmpdir) return path::new(tmpdir, allocator);
-	}
-	return path::new("/tmp", allocator);
-}
-
-fn Path! native_temp_directory(Allocator* allocator = allocator::heap()) @if(env::WIN32)
-{
-	@pool(allocator)
-	{
-		Win32_DWORD len = win32::getTempPathW(0, null);
-		if (!len) return IoError.GENERAL_ERROR?;
-		Char16[] buff = mem::temp_alloc_array(Char16, len + (usz)1);
-		if (!win32::getTempPathW(len, buff)) return IoError.GENERAL_ERROR?;
-		return path::new(string::temp_from_utf16(buff[:len]), allocator);
-	};
-}
-
-module std::io::os @if(env::NO_LIBC);
-
-macro Path! native_temp_directory(Allocator* allocator = allocator::heap())
-{
-	return IoError.UNSUPPORTED_OPERATION?;
-}

lib/std/io/path.c3

@@ -1,12 +1,12 @@
 module std::io::path;
-import std::collections::list, std::io::os;
+import std::collections::list;
 
-const PathEnv DEFAULT_PATH_ENV = env::WIN32 ? PathEnv.WIN32 : PathEnv.POSIX;
+const PathEnv DEFAULT_PATH_ENV = env::os_is_win32() ? PathEnv.WIN32 : PathEnv.POSIX;
 const char PREFERRED_SEPARATOR_WIN32 = '\\';
 const char PREFERRED_SEPARATOR_POSIX = '/';
-const char PREFERRED_SEPARATOR = env::WIN32 ? PREFERRED_SEPARATOR_WIN32 : PREFERRED_SEPARATOR_POSIX;
+const char PREFERRED_SEPARATOR = env::os_is_win32() ? PREFERRED_SEPARATOR_WIN32 : PREFERRED_SEPARATOR_POSIX;
 
-def PathList = List(<Path>);
+typedef PathList = List<Path>;
 
 fault PathResult
 {
@@ -14,7 +14,7 @@ fault PathResult
 	NO_PARENT,
 }
 
-struct Path (Printable)
+struct Path
 {
 	String path_string;
 	PathEnv env;
@@ -26,22 +26,22 @@ enum PathEnv
 	POSIX
 }
 
-fn Path! getcwd(Allocator* allocator = allocator::heap())
+
+fn Path! getcwd(Allocator* using = mem::heap())
 {
-	@pool(allocator)
+	@stack_mem(256; Allocator* mem)
 	{
-		return new(os::getcwd(allocator::temp()), allocator);
+		return new(os::getcwd(mem), using);
 	};
 }
 
-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 bool is_dir(Path path) => os::native_is_dir(path.as_str());
+fn bool is_file(Path path) => os::native_is_file(path.as_str());
+fn usz! file_size(Path path) => os::native_file_size(path.as_str());
+fn bool exists(Path path) => os::native_file_or_dir_exists(path.as_str());
+fn Path! tgetcwd() => getcwd(mem::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;
+fn Path! temp_directory(Allocator* using = mem::heap()) => os::native_temp_directory(using);
 
 macro bool is_separator(char c, PathEnv path_env = DEFAULT_PATH_ENV)
 {
@@ -58,181 +58,94 @@ 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 Path! new(String path, Allocator* using = mem::heap(), PathEnv path_env = DEFAULT_PATH_ENV)
 {
-	$if $defined(os::native_ls):
-		return os::native_ls(dir, no_dirs, no_symlinks, mask, allocator);
-	$else
-		return IoError.UNSUPPORTED_OPERATION?;
-	$endif
+	return { normalize(path.copy(using), path_env), path_env };
 }
 
-enum MkdirPermissions
+fn Path! new_windows(String path, Allocator* using = mem::heap())
 {
-	NORMAL,
-	USER_ONLY,
-	USER_AND_ADMIN
+	return new(path, using, WIN32);
 }
 
-fn bool! mkdir(Path path, bool recursive = false, MkdirPermissions permissions = NORMAL)
+fn Path! new_posix(String path, Allocator* using = mem::heap())
 {
-	if (!path.path_string.len) return PathResult.INVALID_PATH?;
-	if (is_dir(path)) return false;
-	if (exists(path)) return IoError.FILE_NOT_DIR?;
-
-	if (recursive)
-	{
-		if (try parent = path.parent()) mkdir(parent, true, permissions)!;
-	}
-	if (!is_dir(path.parent()) ?? false) return IoError.CANNOT_READ_DIR?;
-
-	return os::native_mkdir(path, permissions);
+	return new(path, using, POSIX);
 }
 
-fn bool! rmdir(Path path)
+fn bool Path.equals(Path p1, Path p2)
 {
-	if (!path.path_string.len) return PathResult.INVALID_PATH?;
-	return os::native_rmdir(path);
-}
-
-fn void! rmtree(Path path)
-{
-	if (!path.path_string.len) return PathResult.INVALID_PATH?;
-	$if $defined(os::native_rmtree):
-		return os::native_rmtree(path);
-	$else
-		return IoError.UNSUPPORTED_OPERATION?;
-	$endif
-}
-
-fn Path! new(String path, Allocator* allocator = allocator::heap(), PathEnv path_env = DEFAULT_PATH_ENV)
-{
-	return { normalize(path.copy(allocator), path_env), path_env };
-}
-
-fn Path! temp_new(String path, PathEnv path_env = DEFAULT_PATH_ENV)
-{
-	return new(path, allocator::temp(), path_env);
-}
-
-fn Path! new_win32_wstring(WString path, Allocator* allocator = allocator::heap())
-{
-	@pool(allocator)
-	{
-		return path::new(string::temp_from_wstring(path)!, .allocator = allocator);
-	};
-}
-
-fn Path! new_windows(String path, Allocator* allocator = allocator::heap())
-{
-	return new(path, allocator, WIN32);
-}
-
-fn Path! new_posix(String path, Allocator* allocator = allocator::heap())
-{
-	return new(path, allocator, POSIX);
-}
-
-fn bool Path.equals(self, Path p2)
-{
-	return self.env == p2.env && self.path_string == p2.path_string;
+	return p1.env == p2.env && p1.path_string == p2.path_string;
 }
 
 /**
  * Append the string to the current path.
  *
+ * @param [in] path
  * @param [in] filename
+ * @ensure return.path_string.len >= path.path_string.len
  **/
-fn Path! Path.append(self, String filename, Allocator* allocator = allocator::heap())
+fn Path! Path.append(Path path, String filename, Allocator* using = mem::heap())
 {
-	if (!self.path_string.len) return new(filename, allocator, self.env)!;
-	assert(!is_separator(self.path_string[^1], self.env));
+	if (!path.path_string.len) return new(filename, using, path.env)?;
+	assert(!is_separator(path.path_string[^1], path.env));
 
-	@pool(allocator)
+	@stack_mem(256; Allocator* mem)
 	{
-		DString dstr = dstring::temp_with_capacity(self.path_string.len + 1 + filename.len);
-		dstr.append(self.path_string);
+		DString dstr = dstring::new_with_capacity(path.path_string.len + 1 + filename.len, .using = mem);
+		dstr.append(path.path_string);
 		dstr.append(PREFERRED_SEPARATOR);
 		dstr.append(filename);
-		return { normalize(dstr.copy_str(allocator), self.env), self.env };
+		return { normalize(dstr.copy_str(using), path.env), path.env };
 	};
 }
 
-fn Path! Path.tappend(self, String filename) => self.append(filename, allocator::temp());
+fn Path! Path.tappend(Path path, String filename) => path.append(filename, mem::temp());
 
-fn usz Path.start_of_base_name(self) @local
+fn usz Path.start_of_base_name(Path path) @local
 {
-	String path_str = self.path_string;
+	String path_str = path.path_string;
 	if (!path_str.len) return 0;
-	if (self.env == PathEnv.WIN32)
+	if (path.env == PathEnv.WIN32)
 	{
-		return path_str.rindex_of_char('\\') + 1 ?? volume_name_len(path_str, self.env)!!;
+		return path_str.rindex_of(`\`) + 1 ?? volume_name_len(path_str, path.env)!!;
 	}
-	return path_str.rindex_of_char('/') + 1 ?? 0;
+	return path_str.rindex_of("/") + 1 ?? 0;
 }
 
-fn bool! Path.is_absolute(self)
+fn String Path.basename(Path path)
 {
-	String path_str = self.str_view();
-	if (!path_str.len) return false;
-	usz path_start = volume_name_len(path_str, self.env)!;
-	return path_start < path_str.len && is_separator(path_str[path_start], self.env);
-}
-
-fn Path! Path.absolute(self, Allocator* allocator = allocator::heap())
-{
-	String path_str = self.str_view();
-	if (!path_str.len) path_str = ".";
-	if (path_str == ".")
-	{
-		String cwd = os::getcwd(allocator::temp())!;
-		return new(cwd, allocator, self.env);
-	}
-	switch (self.env)
-	{
-		case WIN32:
-			usz path_start = volume_name_len(path_str, self.env)!;
-			if (path_start > 0) return self;
-		case POSIX:
-			if (path_str[0] == PREFERRED_SEPARATOR_POSIX) return self;
-	}
-	String cwd = os::getcwd(allocator::temp())!;
-	return Path{ cwd, self.env }.append(path_str, allocator)!;
-}
-
-fn String Path.basename(self)
-{
-	usz basename_start = self.start_of_base_name();
-	String path_str = self.path_string;
+	usz basename_start = path.start_of_base_name();
+	String path_str = path.path_string;
 	if (basename_start == path_str.len) return "";
 	return path_str[basename_start..];
 }
 
-fn String Path.dirname(self)
+fn String Path.dirname(Path path)
 {
-	usz basename_start = self.start_of_base_name();
-	String path_str = self.path_string;
+	usz basename_start = path.start_of_base_name();
+	String path_str = path.path_string;
 	if (basename_start == 0) return "";
-	usz start = volume_name_len(path_str, self.env)!!;
+	usz start = volume_name_len(path_str, path.env)!!;
 	if (basename_start <= start + 1) return path_str[:basename_start];
 	return path_str[:basename_start - 1];
 }
 
-fn String! Path.extension(self)
+fn String! Path.extension(Path path)
 {
-	String basename = self.basename();
-	usz index = basename.rindex_of(".")!;
+	String basename = path.basename();
+	usz index = basename.rindex_of(".")?;
 	// Plain ".foo" does not have an
-	if (index == 0) return SearchResult.MISSING?;
+	if (index == 0) return SearchResult.MISSING!;
 	if (index == basename.len) return "";
 	return basename[index + 1..];
 }
 
-fn String Path.volume_name(self)
+fn String Path.volume_name(Path path)
 {
-	usz len = volume_name_len(self.str_view(), self.env)!!;
+	usz len = volume_name_len(path.as_str(), path.env)!!;
 	if (!len) return "";
-	return self.path_string[:len];
+	return path.path_string[:len];
 }
 
 fn usz! volume_name_len(String path, PathEnv path_env) @local
@@ -240,47 +153,47 @@ fn usz! volume_name_len(String path, PathEnv path_env) @local
 	usz len = path.len;
 	if (len < 2 || path_env != PathEnv.WIN32) return 0;
 	switch (path[0])
-	{
-		case '\\':
-			// "\\" paths.. must be longer than 2
-			if (len == 2) return 0;
+    {
+    	case '\\':
+    	    // "\\" paths.. must be longer than 2
+    	    if (len == 2) return 0;
 			int count = 1;
 			while (count < len && path[count] == '\\') count++;
 			// Not 2 => folded paths
 			if (count != 2) return 0;
 			// Check that we have a name followed by '/'
 			for (usz i = 2; i < len; i++)
-			{
-				char c = path[i];
-				if (is_win32_separator(c)) return i;
-				if (is_reserved_win32_path_char(c)) return PathResult.INVALID_PATH?;
-			}
-			return PathResult.INVALID_PATH?;
-		case 'A'..'Z':
-		case 'a'..'z':
-			return path[1] == ':' ? 2 : 0;
-		default:
-			return 0;
-	}
+    		{
+    		    char c = path[i];
+    			if (is_win32_separator(c)) return i;
+    			if (is_reserved_win32_path_char(c)) return PathResult.INVALID_PATH!;
+    		}
+    		return PathResult.INVALID_PATH!;
+    	case 'A'..'Z':
+    	case 'a'..'z':
+    	    return path[1] == ':' ? 2 : 0;
+    	default:
+    	    return 0;
+    }
 }
 
-fn Path! Path.parent(self)
+fn Path! Path.parent(Path path)
 {
-	if (self.path_string.len == 1 && is_separator(self.path_string[0], self.env)) return PathResult.NO_PARENT?;
-	foreach_r(i, c : self.path_string)
+	if (path.path_string.len == 1 && is_separator(path.path_string[0], path.env)) return PathResult.NO_PARENT!;
+	foreach_r(i, c : path.path_string)
 	{
-		if (is_separator(c, self.env))
+		if (is_separator(c, path.env))
 		{
-			return { self.path_string[:i], self.env };
+			return { path.path_string[:i], path.env };
 		}
 	}
-	return PathResult.NO_PARENT?;
+	return PathResult.NO_PARENT!;
 }
 
 fn String! normalize(String path_str, PathEnv path_env = DEFAULT_PATH_ENV)
 {
-	if (!path_str.len) return "";
-	usz path_start = volume_name_len(path_str, path_env)!;
+	if (!path_str.len) return path_str;
+    usz path_start = volume_name_len(path_str, path_env)?;
 	usz path_len = path_str.len;
 	if (path_start == path_len) return path_str;
 	char path_separator = path_env == PathEnv.WIN32 ? PREFERRED_SEPARATOR_WIN32 : PREFERRED_SEPARATOR_POSIX;
@@ -312,7 +225,7 @@ fn String! normalize(String path_str, PathEnv path_env = DEFAULT_PATH_ENV)
 
 		// The rest are names of the path elements, so check that the
 		// characters are valid.
-		if (is_reserved_path_char(c, path_env)) return PathResult.INVALID_PATH?;
+		if (is_reserved_path_char(c, path_env)) return PathResult.INVALID_PATH!;
 
 		// If we have '.' after a separator
 		if (c == '.' && previous_was_separator)
@@ -320,20 +233,13 @@ fn String! normalize(String path_str, PathEnv path_env = DEFAULT_PATH_ENV)
 			// Get the number of dots until next separator, expecting 1 or 2
 			bool is_last = i == path_len - 1;
 			int dots = 1;
-			if (!is_last)
+			if (!is_last && path_str[i + 1] == '.')
 			{
-				char next = path_str[i + 1];
-				switch
+				dots = 2;
+				is_last = i == path_len - 2;
+				if (!is_last && !is_separator(path_str[i + 2], path_env))
 				{
-					case next == '.':
-						dots = 2;
-						is_last = i == path_len - 2;
-						if (!is_last && !is_separator(path_str[i + 2], path_env))
-						{
-							dots = 0;
-						}
-					case !is_separator(next, path_env):
-						dots = 0;
+					dots = 0;
 				}
 			}
 			switch (dots)
@@ -345,7 +251,7 @@ fn String! normalize(String path_str, PathEnv path_env = DEFAULT_PATH_ENV)
 					continue;
 				case 2:
 					// This is an error: /a/../..
-					if (len == path_start && has_root) return PathResult.INVALID_PATH?;
+					if (len == path_start && has_root) return PathResult.INVALID_PATH!;
 
 					// If this .. at the start, or after ../? If so, we just copy ..
 					if (len == path_start ||
@@ -372,7 +278,7 @@ fn String! normalize(String path_str, PathEnv path_env = DEFAULT_PATH_ENV)
 					}
 					// Reading, we go from /../abc to /../abc
 					//                      ^            ^
-					i += 2;
+ 					i += 2;
 					continue;
 				default:
 					break;
@@ -388,16 +294,16 @@ fn String! normalize(String path_str, PathEnv path_env = DEFAULT_PATH_ENV)
 	return path_str[:len];
 }
 
-fn ZString Path.as_zstr(self) => (ZString)self.path_string.ptr;
+fn ZString Path.as_zstr(Path path) => (ZString)path.path_string.ptr;
 
-fn String Path.root_directory(self)
+fn String Path.root_directory(Path path)
 {
-	String path_str = self.str_view();
+	String path_str = path.as_str();
 	usz len = path_str.len;
 	if (!len) return "";
-	if (self.env == PathEnv.WIN32)
+	if (path.env == PathEnv.WIN32)
 	{
-		usz root_len = volume_name_len(path_str, self.env)!!;
+		usz root_len = volume_name_len(path_str, path.env)!!;
 		if (root_len == len || !is_win32_separator(path_str[root_len])) return "";
 		return path_str[root_len..root_len];
 	}
@@ -412,57 +318,24 @@ fn String Path.root_directory(self)
 	return path_str;
 }
 
-def PathWalker = fn bool! (Path, bool is_dir, void*);
 
-/*
- * Walk the path recursively. PathWalker is run on every file and
- * directory found. Return true to abort the walk.
- */
-fn bool! Path.walk(self, PathWalker w, void* data)
+fn String Path.as_str(Path path)
 {
-	const PATH_MAX = 512;
-	@stack_mem(PATH_MAX; Allocator* allocator)
-	{
-		Path abs = self.absolute(allocator)!;
-		PathList files = ls(abs, .allocator = allocator)!;
-		foreach (f : files)
-		{
-			if (f.str_view() == "." || f.str_view() == "..") continue;
-			f = abs.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;
-		}
-	};
-	return false;
-}
-
-fn String Path.str_view(self) @inline
-{
-	return self.path_string;
+	return path.path_string;
 }
 
 
-fn bool Path.has_suffix(self, String str)
+fn bool Path.has_suffix(Path path, String str)
 {
-	return self.str_view().ends_with(str);
-}
-
-fn void Path.free(self)
-{
-	free(self.path_string.ptr);
+	return path.as_str().ends_with(str);
 }
 
 
-fn usz! Path.to_format(&self, Formatter* formatter) @dynamic
+fn void Path.free(Path path)
 {
-	return formatter.print(self.str_view());
+	free(path.path_string.ptr);
 }
 
-fn String Path.to_new_string(&self, Allocator* allocator = allocator::heap()) @dynamic
-{
-	return self.str_view().copy(allocator);
-}
 
 const bool[256] RESERVED_PATH_CHAR_POSIX = {
 	[0] = true,
@@ -491,4 +364,5 @@ macro bool is_reserved_path_char(char c, PathEnv path_env = DEFAULT_PATH_ENV)
 	return path_env == PathEnv.WIN32
 		? RESERVED_PATH_CHAR_WIN32[c]
 		: RESERVED_PATH_CHAR_POSIX[c];
-}
+}
+

lib/std/io/stream.c3

@@ -1,234 +0,0 @@
-module std::io;
-import std::math;
-
-interface InStream
-{
-	fn void! close() @optional;
-	fn usz! seek(isz offset, Seek seek) @optional;
-	fn usz len() @optional;
-	fn usz! available() @optional;
-	fn usz! read(char[] buffer);
-	fn char! read_byte();
-	fn usz! write_to(OutStream* out) @optional;
-	fn void! pushback_byte() @optional;
-}
-
-
-interface OutStream
-{
-	fn void! destroy() @optional;
-	fn void! close() @optional;
-	fn void! flush() @optional;
-	fn usz! write(char[] bytes);
-	fn void! write_byte(char c);
-	fn usz! read_to(InStream* in) @optional;
-}
-
-fn usz! available(InStream* s)
-{
-	if (&s.available) return s.available();
-	if (&s.seek)
-	{
-		usz curr = s.seek(0, Seek.CURSOR)!;
-		usz len = s.seek(0, Seek.END)!;
-		s.seek(curr, Seek.SET)!;
-		return len - curr;
-	}
-	return 0;
-}
-
-macro bool @is_instream(#expr)
-{
-	return $assignable(#expr, InStream*);
-}
-
-macro bool @is_outstream(#expr)
-{
-	return $assignable(#expr, OutStream*);
-}
-
-/**
- * @param [&out] ref
- * @require @is_instream(stream)
- **/
-macro usz! read_any(stream, any* ref)
-{
-	return read_all(stream, ((char*)ref)[:ref.type.sizeof]);
-}
-
-/**
- * @param [&in] ref "the object to write."
- * @require @is_outstream(stream)
- * @ensure return == ref.type.sizeof
- */
-macro usz! write_any(stream, any* ref)
-{
-	return write_all(stream, ((char*)ref)[:ref.type.sizeof]);
-}
-
-/**
- * @require @is_instream(stream)
- */
-macro usz! read_all(stream, char[] buffer)
-{
-	if (buffer.len == 0) return 0;
-	usz n = stream.read(buffer)!;
-	if (n != buffer.len) return IoError.UNEXPECTED_EOF?;
-	return n;
-}
-
-/**
- * @require @is_outstream(stream)
- */
-macro usz! write_all(stream, char[] buffer)
-{
-	if (buffer.len == 0) return 0;
-	usz n = stream.write(buffer)!;
-	if (n != buffer.len) return IoError.INCOMPLETE_WRITE?;
-	return n;
-}
-
-macro usz! @read_using_read_byte(&s, char[] buffer)
-{
-	usz len = 0;
-	foreach (&cptr : buffer)
-	{
-		char! c = s.read_byte();
-		if (catch err = c)
-		{
-			case IoError.EOF: return len;
-			default: return err?;
-		}
-		*cptr = c;
-		len++;
-	}
-	return len;
-}
-
-macro void! @write_byte_using_write(&s, char c)
-{
-	char[1] buff = { c };
-	(*s).write(&buff)!;
-}
-
-
-macro char! @read_byte_using_read(&s)
-{
-	char[1] buffer;
-	usz read = (*s).read(&buffer)!;
-	if (read != 1) return IoError.EOF?;
-	return buffer[0];
-}
-
-def ReadByteFn = fn char!();
-
-
-macro usz! @write_using_write_byte(&s, char[] bytes)
-{
-	foreach (c : bytes) s.write_byte(self, c)!;
-	return bytes.len;
-}
-
-macro void! @pushback_using_seek(&s)
-{
-	s.seek(-1, CURSOR)!;
-}
-
-fn usz! copy_to(InStream* in, OutStream* dst, char[] buffer = {})
-{
-	if (buffer.len) return copy_through_buffer(in, dst, buffer);
-	if (&in.write_to) return in.write_to(dst);
-	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));
-			};
-		$case SMALL:
-			@pool()
-			{
-				return copy_through_buffer(in, dst, mem::temp_alloc_array(char, 1024));
-			};
-		$case TINY:
-		$case NONE:
-			return copy_through_buffer(in, dst, &&(char[256]{}));
-	$endswitch
-}
-
-macro usz! copy_through_buffer(InStream *in, OutStream* dst, char[] buffer) @local
-{
-	usz total_copied;
-	while (true)
-	{
-		usz! len = in.read(buffer);
-		if (catch err = len)
-		{
-			case IoError.EOF: return total_copied;
-			default: return err?;
-		}
-		if (!len) return total_copied;
-		usz written = dst.write(buffer[:len])!;
-		total_copied += len;
-		if (written != len) return IoError.INCOMPLETE_WRITE?;
-	}
-}
-
-const char[*] MAX_VARS @private = { [2] = 3, [4] = 5, [8] = 10 };
-
-/**
- * @require @is_instream(stream)
- * @require @typekind(x_ptr) == POINTER && $typeof(x_ptr).inner.kindof.is_int()
- **/
-macro usz! read_varint(stream, x_ptr)
-{
-	var $Type = $typefrom($typeof(x_ptr).inner);
-	const MAX = MAX_VARS[$Type.sizeof];
-	$Type x;
-	uint shift;
-	usz n;
-	for (usz i = 0; i < MAX; i++)
-	{
-		char! c = stream.read_byte();
-		if (catch err = c)
-		{
-			case IoError.EOF:
-				return IoError.UNEXPECTED_EOF?;
-			default:
-				return err?;
-		}
-		n++;
-		if (c & 0x80 == 0)
-		{
-			if (i + 1 == MAX && c > 1) break;
-			x |= c << shift;
-			$if $Type.kindof == SIGNED_INT:
-				x = x & 1 == 0 ? x >> 1 : ~(x >> 1);
-			$endif
-			*x_ptr = x;
-			return n;
-		}
-		x |= (c & 0x7F) << shift;
-		shift += 7;
-	}
-	return MathError.OVERFLOW?;
-}
-/**
- * @require @is_outstream(stream)
- * @require @typekind(x).is_int()
- **/
-macro usz! write_varint(stream, x)
-{
-	var $Type = $typeof(x);
-	const MAX = MAX_VARS[$Type.sizeof];
-	char[MAX] buffer @noinit;
-	usz i;
-	while (x >= 0x80)
-	{
-		buffer[i] = (char)(x | 0x80);
-		x >>= 7;
-		i++;
-	}
-	buffer[i] = (char)x;
-	return write_all(stream, buffer[:i + 1]);
-}

lib/std/io/stream/buffer.c3

@@ -1,133 +0,0 @@
-module std::io;
-
-struct ReadBuffer (InStream)
-{
-	InStream* wrapped_stream;
-	char[] bytes;
-	usz read_idx;
-	usz write_idx;
-}
-
-/**
- * Buffer reads from a stream.
- * @param [inout] self
- * @require bytes.len > 0
- * @require self.bytes.len == 0 "Init may not run on already initialized data"
- **/
-fn ReadBuffer* ReadBuffer.init(&self, InStream* wrapped_stream, char[] bytes)
-{
-	*self = { .wrapped_stream = wrapped_stream, .bytes = bytes };
-	return self;
-}
-fn String ReadBuffer.str_view(&self) @inline
-{
-	return (String)self.bytes[self.read_idx:self.write_idx - self.read_idx];
-}
-
-fn void! ReadBuffer.close(&self) @dynamic
-{
-	if (&self.wrapped_stream.close) self.wrapped_stream.close()!;
-}
-
-fn usz! ReadBuffer.read(&self, char[] bytes) @dynamic
-{
-	if (self.read_idx == self.write_idx)
-	{
-		if (self.read_idx == 0 && bytes.len >= self.bytes.len)
-		{
-			// Read directly into the input buffer.
-			return self.wrapped_stream.read(bytes)!;
-		}
-		self.refill()!;
-	}
-	usz n = min(self.write_idx - self.read_idx, bytes.len);
-	bytes[:n] = self.bytes[self.read_idx:n];
-	self.read_idx += n;
-	return n;
-}
-
-fn char! ReadBuffer.read_byte(&self) @dynamic
-{
-	if (self.read_idx == self.write_idx) self.refill()!;
-	if (self.read_idx == self.write_idx) return IoError.EOF?;
-	char c = self.bytes[self.read_idx];
-	self.read_idx++;
-	return c;
-}
-
-fn void! ReadBuffer.refill(&self) @local @inline
-{
-	self.read_idx = 0;
-	self.write_idx = self.wrapped_stream.read(self.bytes)!;
-}
-
-struct WriteBuffer (OutStream)
-{
-	OutStream* wrapped_stream;
-	char[] bytes;
-	usz index;
-}
-
-/**
- * Buffer writes to a stream. Call `flush` when done writing to the buffer.
- * @param [inout] self
- * @require bytes.len > 0 "Non-empty buffer required"
- * @require self.bytes.len == 0 "Init may not run on already initialized data"
- **/
-fn WriteBuffer* WriteBuffer.init(&self, OutStream* wrapped_stream, char[] bytes)
-{
-	*self = { .wrapped_stream = wrapped_stream, .bytes = bytes };
-	return self;
-}
-
-fn String WriteBuffer.str_view(&self) @inline
-{
-	return (String)self.bytes[:self.index];
-}
-
-fn void! WriteBuffer.close(&self) @dynamic
-{
-	if (&self.wrapped_stream.close) return self.wrapped_stream.close();
-}
-
-fn void! WriteBuffer.flush(&self) @dynamic
-{
-	self.write_pending()!;
-	if (&self.wrapped_stream.flush) self.wrapped_stream.flush()!;
-}
-
-fn usz! WriteBuffer.write(&self, char[] bytes) @dynamic
-{
-	usz n = self.bytes.len - self.index;
-	if (bytes.len < n)
-	{
-		// Enough room in the buffer.
-		self.bytes[self.index:bytes.len] = bytes[..];
-		self.index += bytes.len;
-		return bytes.len;
-	}
-	self.write_pending()!;
-	if (bytes.len >= self.bytes.len)
-	{
-		// Write directly to the stream.
-		return self.wrapped_stream.write(bytes);
-	}
-	// Buffer the data.
-	self.bytes[:bytes.len] = bytes[..];
-	self.index = bytes.len;
-	return bytes.len;
-}
-
-fn void! WriteBuffer.write_byte(&self, char c) @dynamic
-{
-	usz n = self.bytes.len - self.index;
-	if (n == 0) self.write_pending()!;
-	self.bytes[0] = c;
-	self.index = 1;
-}
-
-fn void! WriteBuffer.write_pending(&self) @local
-{
-	self.index -= self.wrapped_stream.write(self.bytes[:self.index])!;
-	if (self.index != 0) return IoError.INCOMPLETE_WRITE?;
-}

lib/std/io/stream/bytebuffer.c3

@@ -1,163 +0,0 @@
-module std::io;
-import std::math;
-
-struct ByteBuffer (InStream, OutStream)
-{
-	Allocator* allocator;
-	usz max_read;
-	char[] bytes;
-	usz read_idx;
-	usz write_idx;
-	bool has_last;
-}
-
-/**
- * ByteBuffer provides a streamable read/write buffer.
- * max_read defines how many bytes might be kept before its internal buffer is shrinked.
- * @require self.bytes.len == 0 "Buffer already initialized."
- **/
-fn ByteBuffer*! ByteBuffer.init_new(&self, usz max_read, usz initial_capacity = 16, Allocator* allocator = allocator::heap()) @deprecated("Replaced by new_init")
-{
-	return self.new_init(max_read, initial_capacity, allocator) @inline;
-}
-
-/**
- * ByteBuffer provides a streamable read/write buffer.
- * max_read defines how many bytes might be kept before its internal buffer is shrinked.
- * @require self.bytes.len == 0 "Buffer already initialized."
- **/
-fn ByteBuffer*! ByteBuffer.new_init(&self, usz max_read, usz initial_capacity = 16, Allocator* allocator = allocator::heap())
-{
-	*self = { .allocator = allocator, .max_read = max_read };
-	initial_capacity = max(initial_capacity, 16);
-	self.grow(initial_capacity)!;
-	return self;
-}
-
-fn ByteBuffer*! ByteBuffer.init_temp(&self, usz max_read, usz initial_capacity = 16) @deprecated("Replaced by temp_init")
-{
-	return self.temp_init(max_read, initial_capacity) @inline;
-}
-
-fn ByteBuffer*! ByteBuffer.temp_init(&self, usz max_read, usz initial_capacity = 16)
-{
-	return self.new_init(max_read, initial_capacity, allocator::temp());
-}
-
-/**
- * @require buf.len > 0
- * @require self.bytes.len == 0 "Buffer already initialized."
- **/
-fn ByteBuffer*! ByteBuffer.init_with_buffer(&self, char[] buf)
-{
-	*self = { .max_read = buf.len, .bytes = buf };
-	return self;
-}
-
-fn void ByteBuffer.free(&self)
-{
-	if (self.allocator) allocator::free(self.allocator, self.bytes);
-	*self = {};
-}
-
-fn usz! ByteBuffer.write(&self, char[] bytes) @dynamic
-{
-	usz cap = self.bytes.len - self.write_idx;
-	if (cap < bytes.len) self.grow(bytes.len)!;
-	self.bytes[self.write_idx:bytes.len] = bytes[..];
-	self.write_idx += bytes.len;
-	return bytes.len;
-}
-
-fn void! ByteBuffer.write_byte(&self, char c) @dynamic
-{
-	usz cap = self.bytes.len - self.write_idx;
-	if (cap == 0) self.grow(1)!;
-	self.bytes[self.write_idx] = c;
-	self.write_idx++;
-}
-
-fn usz! ByteBuffer.read(&self, char[] bytes) @dynamic
-{
-	usz readable = self.write_idx - self.read_idx;
-	if (readable == 0)
-	{
-		self.has_last = false;
-		return IoError.EOF?;
-	}
-	usz n = min(readable, bytes.len);
-	bytes[:n] = self.bytes[self.read_idx:n];
-	self.read_idx += n;
-	self.has_last = n > 0;
-	self.shrink();
-	return n;
-}
-
-fn char! ByteBuffer.read_byte(&self) @dynamic
-{
-	usz readable = self.write_idx - self.read_idx;
-	if (readable == 0)
-	{
-		self.has_last = false;
-		return IoError.EOF?;
-	}
-	char c = self.bytes[self.read_idx];
-	self.read_idx++;
-	self.has_last = true;
-	self.shrink();
-	return c;
-}
-
-/*
- * Only the last byte of a successful read can be pushed back.
- */
-fn void! ByteBuffer.pushback_byte(&self) @dynamic
-{
-	if (!self.has_last) return IoError.EOF?;
-	assert(self.read_idx > 0);
-	self.read_idx--;
-	self.has_last = false;
-}
-
-fn usz! ByteBuffer.seek(&self, isz offset, Seek seek) @dynamic
-{
-	switch (seek)
-	{
-		case SET:
-			if (offset < 0 || offset > self.write_idx) return IoError.INVALID_POSITION?;
-			self.read_idx = offset;
-			return offset;
-		case CURSOR:
-			if ((offset < 0 && self.read_idx < -offset) ||
-				(offset > 0 && self.read_idx + offset > self.write_idx)) return IoError.INVALID_POSITION?;
-			self.read_idx += offset;
-		case END:
-			if (offset < 0 || offset > self.write_idx) return IoError.INVALID_POSITION?;
-			self.read_idx = self.write_idx - offset;
-	}
-	return self.read_idx;
-}
-
-fn usz! ByteBuffer.available(&self) @inline @dynamic
-{
-	return self.write_idx - self.read_idx;
-}
-
-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)!;
-	self.bytes = p[:n];
-}
-
-macro ByteBuffer.shrink(&self)
-{
-	if (self.read_idx >= self.max_read)
-	{
-		// Drop the read data besides the last byte (for pushback_byte).
-		usz readable = self.write_idx - self.read_idx;
-		self.bytes[:1 + readable] = self.bytes[self.read_idx - 1:1 + readable];
-		self.write_idx = 1 + readable;
-		self.read_idx = 1;
-	}
-}

lib/std/io/stream/bytereader.c3

@@ -1,68 +1,80 @@
 module std::io;
+import std::math;
 
-struct ByteReader (InStream)
+struct ByteReader
 {
 	char[] bytes;
 	usz index;
 }
 
-fn usz ByteReader.len(&self) @dynamic
+fn void ByteReader.init(ByteReader* reader, char[] bytes)
 {
-	return self.bytes.len;
+	*reader = { .bytes = bytes };
 }
 
-fn ByteReader* ByteReader.init(&self, char[] bytes)
+fn Stream ByteReader.as_stream(ByteReader* reader)
 {
-	*self = { .bytes = bytes };
-	return self;
+	return { .fns = &bytereader_interface, .data = reader };
 }
 
-fn usz! ByteReader.read(&self, char[] bytes) @dynamic
+fn usz! ByteReader.read(ByteReader* reader, char[] bytes)
 {
-	if (self.index >= self.bytes.len) return IoError.EOF?;
-	usz len = min(self.bytes.len - self.index, bytes.len);
+	if (reader.index >= reader.bytes.len) return IoError.EOF!;
+	usz len = math::min(reader.bytes.len - reader.index, bytes.len);
 	if (len == 0) return 0;
-	mem::copy(bytes.ptr, &self.bytes[self.index], len);
-	self.index += len;
+	mem::copy(bytes.ptr, &reader.bytes[reader.index], len);
+	reader.index += len;
 	return len;
 }
 
-fn char! ByteReader.read_byte(&self) @dynamic
+fn char! ByteReader.read_byte(ByteReader* reader)
 {
-	if (self.index >= self.bytes.len) return IoError.EOF?;
-	return self.bytes[self.index++];
+	if (reader.index >= reader.bytes.len) return IoError.EOF!;
+	return reader.bytes[reader.index++];
 }
 
-fn void! ByteReader.pushback_byte(&self) @dynamic
+fn void! ByteReader.pushback_byte(ByteReader* reader)
 {
-	if (!self.index) return IoError.INVALID_PUSHBACK?;
-	self.index--;
+	if (!reader.index) return IoError.INVALID_PUSHBACK!;
+	reader.index--;
 }
 
-fn usz! ByteReader.seek(&self, isz offset, Seek seek) @dynamic
+fn usz! ByteReader.seek(ByteReader* reader, isz offset, Seek seek)
 {
 	isz new_index;
 	switch (seek)
 	{
 		case SET: new_index = offset;
-		case CURSOR: new_index = self.index + offset;
-		case END: new_index = self.bytes.len + offset;
+		case CURSOR: new_index = reader.index + offset;
+		case END: new_index = reader.bytes.len + offset;
 	}
-	if (new_index < 0) return IoError.INVALID_POSITION?;
-	self.index = new_index;
+	if (new_index < 0) return IoError.INVALID_POSITION!;
+	reader.index = new_index;
 	return new_index;
 }
 
-fn usz! ByteReader.write_to(&self, OutStream* writer) @dynamic
+fn usz! ByteReader.write_stream(ByteReader* reader, Stream* writer)
 {
-	if (self.index >= self.bytes.len) return 0;
-	usz written = writer.write(self.bytes[self.index..])!;
-	self.index += written;
-	assert(self.index <= self.bytes.len);
+	if (reader.index >= reader.bytes.len) return 0;
+	usz written = writer.write(reader.bytes[reader.index..])?;
+	reader.index += written;
+	assert(reader.index <= reader.bytes.len);
 	return written;
 }
 
-fn usz! ByteReader.available(&self) @inline @dynamic
+fn usz ByteReader.available(ByteReader* reader)
 {
-	return max(0, self.bytes.len - self.index);
-}
+	return math::max((isz)0, (isz)reader.bytes.len - reader.index);
+}
+
+StreamInterface bytereader_interface = {
+	.len_fn = fn (s) => ((ByteReader*)s.data).bytes.len,
+	.read_fn = fn (s, char[] bytes) => ((ByteReader*)s.data).read(bytes) @inline,
+	.read_byte_fn = fn (s) => ((ByteReader*)s.data).read_byte() @inline,
+	.pushback_byte_fn = fn (s) => ((ByteReader*)s.data).pushback_byte() @inline,
+	.seek_fn = fn (s, offset, seek) => ((ByteReader*)s.data).seek(offset, seek) @inline,
+	.write_stream_fn = fn (s, writer) => ((ByteReader*)s.data).write_stream(writer) @inline,
+	.available_fn = fn (s) => ((ByteReader*)s.data).available() @inline,
+};
+
+

lib/std/io/stream/bytewriter.c3

@@ -1,7 +1,6 @@
 module std::io;
-import std::math;
 
-struct ByteWriter (OutStream)
+struct ByteWriter
 {
 	char[] bytes;
 	usz index;
@@ -9,126 +8,112 @@ struct ByteWriter (OutStream)
 }
 
 /**
- * @param [&inout] self
- * @param [&inout] allocator
- * @require self.bytes.len == 0 "Init may not run on on already initialized data"
- * @ensure (bool)allocator, self.index == 0
+ * @param [&inout] writer
+ * @param [&in] using
+ * @require writer.bytes.len == 0 "Init may not run on on already initialized data"
+ * @ensure using != null, index == 0
  **/
-fn ByteWriter* ByteWriter.new_init(&self, Allocator* allocator = allocator::heap())
+fn void ByteWriter.init(ByteWriter* writer, Allocator* using = mem::heap())
 {
-	*self = { .bytes = {}, .allocator = allocator };
-	return self;
+	*writer = { .bytes = {}, .allocator = using };
+}
+
+fn void ByteWriter.init_buffer(ByteWriter* writer, char[] data)
+{
+	*writer = { .bytes = data, .allocator = null };
 }
 
 /**
- * @param [&inout] self
- * @param [&inout] allocator
- * @require self.bytes.len == 0 "Init may not run on on already initialized data"
- * @ensure (bool)allocator, self.index == 0
+ * @param [&inout] writer
+ * @require writer.bytes.len == 0 "Init may not run on on already initialized data"
  **/
-fn ByteWriter* ByteWriter.init_new(&self, Allocator* allocator = allocator::heap()) @deprecated("Replaced by new_init")
+fn void ByteWriter.tinit(ByteWriter* writer)
 {
-	return self.new_init(allocator) @inline;
+	*writer = { .bytes = {}, .allocator = mem::temp() };
 }
 
-/**
- * @param [&inout] self
- * @require self.bytes.len == 0 "Init may not run on on already initialized data"
- * @ensure self.index == 0
- **/
-fn ByteWriter* ByteWriter.temp_init(&self)
+fn Stream ByteWriter.as_stream(ByteWriter* writer)
 {
-	return self.new_init(allocator::temp()) @inline;
+	return { .fns = &bytewriter_interface, .data = writer };
 }
 
-/**
- * @param [&inout] self
- * @require self.bytes.len == 0 "Init may not run on on already initialized data"
- * @ensure self.index == 0
- **/
-fn ByteWriter* ByteWriter.init_temp(&self) @deprecated("Replaced by temp_init")
+fn void ByteWriter.destroy(ByteWriter* writer)
 {
-	return self.temp_init() @inline;
+	if (!writer.allocator) return;
+	if (void* ptr = writer.bytes.ptr) free(ptr, .using = writer.allocator);
+	*writer = { };
 }
 
-fn ByteWriter* ByteWriter.init_with_buffer(&self, char[] data)
+fn String ByteWriter.as_str(ByteWriter* writer)
 {
-	*self = { .bytes = data, .allocator = null };
-	return self;
+	return (String)writer.bytes[:writer.index];
 }
 
-fn void! ByteWriter.destroy(&self) @dynamic
+fn void! ByteWriter.ensure_capacity(ByteWriter* writer, usz len) @inline
 {
-	if (!self.allocator) return;
-	if (void* ptr = self.bytes.ptr) allocator::free(self.allocator, ptr);
-	*self = { };
-}
-
-fn String ByteWriter.str_view(&self) @inline
-{
-	return (String)self.bytes[:self.index];
-}
-
-fn void! ByteWriter.ensure_capacity(&self, usz len) @inline
-{
-	if (self.bytes.len > len) return;
-	if (!self.allocator) return IoError.OUT_OF_SPACE?;
+	if (writer.bytes.len > len) return;
+	if (!writer.allocator) return IoError.OUT_OF_SPACE!;
 	if (len < 16) len = 16;
 	usz new_capacity = math::next_power_of_2(len);
-	char* new_ptr = allocator::realloc_try(self.allocator, self.bytes.ptr, new_capacity)!;
-	self.bytes = new_ptr[:new_capacity];
+	char* new_ptr = realloc_checked(writer.bytes.ptr, new_capacity, .using = writer.allocator)?;
+	writer.bytes = new_ptr[:new_capacity];
 }
 
-fn usz! ByteWriter.write(&self, char[] bytes) @dynamic
+fn usz! ByteWriter.write(ByteWriter* writer, char[] bytes)
 {
-	self.ensure_capacity(self.index + bytes.len)!;
-	mem::copy(&self.bytes[self.index], bytes.ptr, bytes.len);
-	self.index += bytes.len;
+	writer.ensure_capacity(writer.index + bytes.len)?;
+	mem::copy(&writer.bytes[writer.index], bytes.ptr, bytes.len);
+	writer.index += bytes.len;
 	return bytes.len;
 }
 
-fn void! ByteWriter.write_byte(&self, char c) @dynamic
+fn void! ByteWriter.write_byte(ByteWriter* writer, char c)
 {
-	self.ensure_capacity(self.index + 1)!;
-	self.bytes[self.index++] = c;
+	writer.ensure_capacity(writer.index + 1)?;
+	writer.bytes[writer.index++] = c;
 }
 
 /**
- * @param [&inout] self
- * @param reader
+ * @param [&inout] writer
+ * @param [&inout] reader
  **/
-fn usz! ByteWriter.read_from(&self, InStream* reader) @dynamic
+fn usz! ByteWriter.read_from(ByteWriter* writer, Stream* reader)
 {
-	usz start_index = self.index;
-	if (&reader.available)
+	if (reader.supports_available())
 	{
-		while (usz available = reader.available()!)
+		usz total_read = 0;
+		while (usz available = reader.available()?)
 		{
-			self.ensure_capacity(self.index + available)!;
-			usz read = reader.read(self.bytes[self.index..])!;
-			self.index += read;
+			writer.ensure_capacity(writer.index + available)?;
+			usz len = reader.read(writer.bytes[writer.index..])?;
+			total_read += len;
+			writer.index += len;
 		}
-		return self.index - start_index;
-	}
-	if (self.bytes.len == 0)
-	{
-		self.ensure_capacity(16)!;
+		return total_read;
 	}
+	usz total_read = 0;
 	while (true)
 	{
 		// See how much we can read.
-		usz len_to_read = self.bytes.len - self.index;
+		usz len_to_read = writer.bytes.len - writer.index;
 		// Less than 16 bytes? Double the capacity
 		if (len_to_read < 16)
 		{
-			self.ensure_capacity(self.bytes.len * 2)!;
-			len_to_read = self.bytes.len - self.index;
+			writer.ensure_capacity(writer.bytes.len * 2)?;
 		}
 		// Read into the rest of the buffer
-		usz read = reader.read(self.bytes[self.index..])!;
-		self.index += read;
+		usz read = reader.read(writer.bytes[writer.index..])?;
+		writer.index += read;
 		// Ok, we reached the end.
-		if (read < len_to_read) return self.index - start_index;
+		if (read < len_to_read) return total_read;
 		// Otherwise go another round
 	}
 }
+
+StreamInterface bytewriter_interface = {
+	.destroy_fn = fn (s) => ((ByteWriter*)s.data).destroy(),
+	.len_fn = fn (s) => ((ByteWriter*)s.data).bytes.len,
+	.write_fn = fn (s, char[] bytes) => ((ByteWriter*)s.data).write(bytes),
+	.write_byte_fn = fn (s, char c) => ((ByteWriter*)s.data).write_byte(c),
+	.read_stream_fn = fn (s, reader) => ((ByteWriter*)s.data).read_from(reader),
+};

lib/std/io/stream/dstringwriter.c3

@@ -0,0 +1,14 @@
+module std::io;
+
+fn Stream DString.as_stream(DString* dstring)
+{
+	return { .fns = &dstring_interface, .data = dstring };
+}
+
+StreamInterface dstring_interface = {
+	.destroy_fn = fn (s) => ((DString*)s.data).free(),
+	.len_fn = fn (s) => ((DString*)s.data).len(),
+	.write_fn = fn (s, char[] bytes) { ((DString*)s.data).append_chars((String)bytes); return bytes.len; },
+	.write_byte_fn = fn (s, char c) => ((DString*)s.data).append_char(c),
+	.read_stream_fn = fn (s, reader) => ((DString*)s.data).read_from_stream(reader),
+};

lib/std/io/stream/filestream.c3

@@ -0,0 +1,18 @@
+module std::io;
+
+fn Stream File.as_stream(File* file)
+{
+	return { .fns = &filestream_interface, .data = file };
+}
+
+StreamInterface filestream_interface = {
+	.close_fn = fn (s) => ((File*)s.data).close(),
+	.seek_fn = fn (s, offset, seek) => ((File*)s.data).seek(offset, seek) @inline,
+	.read_fn = fn (s, char[] bytes) => ((File*)s.data).read(bytes) @inline,
+	.write_fn = fn (s, char[] bytes) => ((File*)s.data).write(bytes) @inline,
+	.write_byte_fn = fn (s, char c) => ((File*)s.data).putc(c) @inline,
+	.read_byte_fn = fn (s) => ((File*)s.data).getc() @inline,
+	.flush_fn = fn (s) => ((File*)s.data).flush() @inline,
+};
+
+

lib/std/io/stream/limitreader.c3

@@ -1,44 +0,0 @@
-module std::io;
-
-struct LimitReader (InStream)
-{
-	InStream* wrapped_stream;
-	usz limit;
-}
-
-/**
- * @param [&inout] wrapped_stream "The stream to read from"
- * @param limit "The max limit to read"
- **/
-fn LimitReader* LimitReader.init(&self, InStream* wrapped_stream, usz limit)
-{
-	*self = { .wrapped_stream = wrapped_stream, .limit = limit };
-	return self;
-}
-
-fn void! LimitReader.close(&self) @dynamic
-{
-	if (&self.wrapped_stream.close) return self.wrapped_stream.close();
-}
-
-
-fn usz! LimitReader.read(&self, char[] bytes) @dynamic
-{
-	if (self.limit == 0) return IoError.EOF?;
-	usz m = min(bytes.len, self.limit);
-	usz n = self.wrapped_stream.read(bytes[:m])!;
-	self.limit -= n;
-	return n;
-}
-
-fn char! LimitReader.read_byte(&self) @dynamic
-{
-	if (self.limit == 0) return IoError.EOF?;
-	defer try self.limit--;
-	return self.wrapped_stream.read_byte();
-}
-
-fn usz! LimitReader.available(&self) @inline @dynamic
-{
-	return self.limit;
-}

lib/std/io/stream/scanner.c3

@@ -1,124 +0,0 @@
-module std::io;
-
-struct Scanner (InStream)
-{
-	InStream* wrapped_stream;
-	char[] buf;
-	usz pattern_idx;
-	usz read_idx;
-}
-
-/**
- * Scanner provides a way to read delimited data (with newlines as the default).
- * The supplied buffer must be at least as large as the expected data length
- * including its pattern.
- *
- * @param [&in] stream "The stream to read data from."
- * @require buffer.len > 0 "Non-empty buffer required."
- **/
-fn void Scanner.init(&self, InStream* stream, char[] buffer)
-{
-	*self = { .wrapped_stream = stream, .buf = buffer };
-}
-
-
-/**
- * Return and clear any remaining unscanned data.
- **/
-fn char[] Scanner.flush(&self) @dynamic
-{
-	assert(self.read_idx >= self.pattern_idx);
-	usz n = self.read_idx - self.pattern_idx;
-	char[] buf = self.buf[self.pattern_idx:n];
-	self.pattern_idx = 0;
-	self.read_idx = 0;
-	return buf;
-}
-
-fn void! Scanner.close(&self) @dynamic
-{
-	if (&self.wrapped_stream.close) return self.wrapped_stream.close();
-}
-
-/**
- * Scan the stream for the next split character and return data up to the match.
- * @require pattern.len > 0 "Non-empty pattern required."
- * @require self.buf.len > pattern.len "Pattern too large."
- **/
-fn char[]! Scanner.scan(&self, String pattern = "\n")
-{
-	if (self.read_idx == 0)
-	{
-		// First read.
-		self.read_idx = self.refill(self.buf)!;
-		self.pattern_idx = 0;
-	}
-	assert(self.read_idx >= self.pattern_idx);
-	usz n = self.read_idx - self.pattern_idx;
-	char[] buf = self.buf[self.pattern_idx:n];
-	if (try i = self.find(buf, pattern))
-	{
-		self.pattern_idx += i + pattern.len;
-		return buf[:i];
-	}
-	if (self.pattern_idx == 0 || self.read_idx < self.buf.len)
-	{
-		// Split pattern not found with maximized search, abort.
-		// Split pattern not found and already read as much as possible.
-		return SearchResult.MISSING?;
-	}
-	// Split pattern not found: maximize the search and try one more time.
-	self.buf[:n] = buf[..];
-	self.pattern_idx = 0;
-
-	buf = self.buf[n..];
-	usz p = self.refill(buf)!;
-	self.read_idx = n + p;
-
-	buf = buf[:p];
-	usz i = self.find(buf, pattern)!;
-	self.pattern_idx = n + i + pattern.len;
-
-	return self.buf[:n + i];
-}
-
-macro usz! Scanner.find(&self, buf, pattern) @private
-{
-	return ((String)buf).index_of(pattern);
-}
-
-macro usz! Scanner.refill(&self, buf) @private
-{
-	usz! n = self.wrapped_stream.read(buf);
-	if (catch err = n)
-	{
-		case IoError.EOF:
-			return SearchResult.MISSING?;
-		default:
-			return err?;
-	}
-	return n;
-}
-
-fn usz! Scanner.read(&self, char[] bytes) @dynamic
-{
-	usz n;
-	if (self.pattern_idx < self.read_idx)
-	{
-		n = min(bytes.len, self.read_idx - self.pattern_idx);
-		bytes[:n] = self.buf[self.pattern_idx:n];
-		self.pattern_idx += n;
-		bytes = bytes[n..];
-	}
-	n += self.wrapped_stream.read(bytes)!;
-	return n;
-}
-
-fn char! Scanner.read_byte(&self) @dynamic
-{
-	if (self.pattern_idx < self.read_idx)
-	{
-		return self.buf[self.pattern_idx++];
-	}
-	return self.wrapped_stream.read_byte();
-}

lib/std/libc/libc.c3

@@ -11,14 +11,14 @@ const int RAND_MAX = 0x7fffffff;
 
 struct DivResult
 {
-	CInt quot;
-	CInt rem;
+    int quot;
+    int rem;
 }
 
 struct LongDivResult
 {
-	CLong quot;
-	CLong rem;
+    long quot;
+    long rem;
 }
 
 fn Errno errno()
@@ -31,200 +31,73 @@ fn void errno_set(Errno e)
 	os::errno_set((int)e);
 }
 
-distinct Errno = inline CInt;
-def TerminateFunction = fn void();
-def CompareFunction = fn int(void*, void*);
-def JmpBuf = uptr[$$JMP_BUF_SIZE];
-def Fd = CInt;
-def Fpos_t = long; // TODO make sure fpos is correct on all targets.
-def SignalFunction = fn void(CInt);
+typedef TerminateFunction = fn void();
+typedef CompareFunction = fn int(void*, void*);
+typedef JmpBuf = uptr[$$JMP_BUF_SIZE];
 
-const CInt SIGHUP = 1;
-const CInt SIGINT = 2;
-const CInt SIGQUIT = 3;
-const CInt SIGILL = 4;
-const CInt SIGTRAP = 5;
-const CInt SIGABTR = 6;
-const CInt SIGBUS = BSD_FLAVOR_SIG ? 10 : 7; // Or Mips
-const CInt SIGFPE = 8;
-const CInt SIGKILL = 9;
-const CInt SIGSEGV = 11;
-const CInt SIGSYS = BSD_FLAVOR_SIG ? 12 : 31;
-const CInt SIGPIPE = 13;
-const CInt SIGALRM = 14;
-const CInt SIGTERM = 15;
-const CInt SIGURG = BSD_FLAVOR_SIG ? 16 : 23;
-const CInt SIGSTOP = BSD_FLAVOR_SIG ? 17 : 19;
-const CInt SIGTSTP = BSD_FLAVOR_SIG ? 18 : 20;
-const CInt SIGCONT = BSD_FLAVOR_SIG ? 19 : 18;
-const CInt SIGCHLD = BSD_FLAVOR_SIG ? 20 : 17;
+$if (env::COMPILER_LIBC_AVAILABLE)
 
-const bool BSD_FLAVOR_SIG @local = env::OPENBSD || env::DARWIN || env::FREEBSD || env::NETBSD;
-
-def Time_t = $typefrom(env::WIN32 ? long.typeid : CLong.typeid);
-def Off_t = $typefrom(env::WIN32 ? int.typeid : usz.typeid);
-
-struct Timespec
-{
-	Time_t tv_sec;
-	CLong tv_nsec;
-}
-
-module libc @if(env::LIBC);
-
-extern fn void abort();
-extern fn CInt abs(CInt n);
-extern fn ZString asctime(Tm* timeptr);
-extern fn ZString asctime_r(Tm* timeptr, char* buf);
-extern fn CInt atexit(TerminateFunction func);
 extern fn double atof(char* str);
 extern fn int atoi(char* str);
 extern fn CLongLong atoll(char* str);
-extern fn void bsearch(void* key, void *base, usz items, usz size, CompareFunction compare);
-extern fn void* calloc(usz count, usz size);
-extern fn void clearerr(CFile stream);
-extern fn Clock_t clock();
-extern fn CInt close(CInt fd) @if(!env::WIN32);
-extern fn double difftime(Time_t time1, Time_t time2) @if(!env::WIN32);
-extern fn DivResult div(CInt numer, CInt denom);
-extern fn void exit(CInt status);
-extern fn CInt fclose(CFile stream);
-extern fn CFile fdopen(CInt fd, ZString mode) @if(!env::WIN32);
-extern fn CInt feof(CFile stream);
-extern fn CInt ferror(CFile stream);
-extern fn CInt fflush(CFile stream);
-extern fn CInt fgetc(CFile stream);
-extern fn ZString fgets(char* string, CInt n, CFile stream);
-extern fn CInt fgetpos(CFile stream, Fpos_t* pos);
-extern fn Fd fileno(CFile stream) @if(!env::WIN32);
-extern fn CFile fopen(ZString filename, ZString mode);
-extern fn CInt fprintf(CFile stream, ZString format, ...);
-extern fn CInt fputc(CInt c, CFile stream);
-extern fn CInt fputs(ZString string, CFile stream);
-extern fn usz fread(void* ptr, usz size, usz nmemb, CFile stream);
-extern fn void* free(void*);
-extern fn CFile freopen(ZString filename, ZString mode, CFile stream);
-extern fn CInt fscanf(CFile stream, ZString format, ...);
-extern fn CInt fseek(CFile stream, SeekIndex offset, CInt whence) @if(!env::WIN32);
-extern fn CInt fsetpos(CFile stream, Fpos_t* pos);
-extern fn SeekIndex ftell(CFile stream) @if(!env::WIN32);
-extern fn usz fwrite(void* ptr, usz size, usz nmemb, CFile stream);
-extern fn CInt getc(CFile stream);
-extern fn CInt getchar();
+extern fn double strtod(char* str, char** endptr);
+extern fn CLong strtol(char* str, char** endptr, int base);
+extern fn CULong stroul(char* str, char** endptr, int base);
+extern fn void abort();
+extern fn void atexit(TerminateFunction f);
+extern fn void exit(int status);
 extern fn ZString getenv(ZString name);
-extern fn ZString gets(char* buffer);
-extern fn Tm* gmtime(Time_t* timer);
-extern fn Tm* gmtime_r(Time_t *timer, Tm* buf) @if(!env::WIN32);
-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 int setenv(ZString name, ZString value, int overwrite);
+extern fn int unsetenv(ZString name);
+extern fn int system(char* str);
+extern fn void bsearch(void* key, void *base, usz items, usz size, CompareFunction compare);
+extern fn void qsort(void* base, usz items, usz size, CompareFunction compare);
+extern fn DivResult div(int numer, int denom);
+extern fn long labs(long x);
+extern fn LongDivResult ldiv(long number, long denom);
+extern fn int rand();
+extern fn void srand(uint seed);
+
 extern fn void longjmp(JmpBuf* buffer, CInt value);
-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);
+$if (env::OS_TYPE == OsType.WIN32)
+// TODO win32 aarch64
+extern fn CInt _setjmp(void* frameptr, JmpBuf* buffer);
+macro CInt setjmp(JmpBuf* buffer) => _setjmp($$frameaddress(), buffer);
+$else
+extern fn CInt setjmp(JmpBuf* buffer);
+$endif
+// MB functions omitted
+
+// string
+extern fn void* memchr(void* str, int c, usz n);
+extern fn int memcmp(void* str1, void* str2, usz n);
 extern fn void* memcpy(void* dest, void* src, usz n);
 extern fn void* memmove(void* dest, void* src, usz n);
 extern fn void* memset(void* dest, CInt value, usz n);
-extern fn Time_t* mktime(Tm* time) @if(!env::WIN32);
-extern fn void perror(ZString string);
-extern fn CInt printf(ZString format, ...);
-extern fn CInt putc(CInt c, CFile stream);
-extern fn CInt putchar(CInt c);
-extern fn CInt puts(ZString str);
-extern fn void qsort(void* base, usz items, usz size, CompareFunction compare);
-extern fn CInt raise(CInt signal);
-extern fn CInt rand();
-extern fn isz read(Fd fd, void* buf, usz nbyte) @if(!env::WIN32);
-extern fn void* realloc(void* ptr, usz size);
-extern fn CInt remove(ZString filename);
-extern fn CInt rename(ZString old_name, ZString new_name);
-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 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, ...);
-extern fn CInt sprintf(char* buffer, ZString format, ...);
-extern fn void srand(uint seed);
-extern fn CInt sscanf(char* buffer, ZString format, ...);
-extern fn ZString strcat(ZString dest, ZString src);
-extern fn char* strchr(char* str, CInt c);
-extern fn CInt strcmp(ZString str1, ZString str2);
-extern fn CInt strcoll(ZString str1, ZString str2);
-extern fn usz strcspn(ZString str1, ZString str2);
-extern fn ZString strcpy(ZString dst, ZString src);
-extern fn ZString strerror(CInt errn);
-extern fn usz strftime(char* dest, usz maxsize, ZString format, Tm* timeptr);
-extern fn usz strlen(ZString str);
-extern fn ZString strncat(char* dest, char* src, usz n);
-extern fn CInt strncmp(char* str1, char* str2, usz n);
+extern fn char* strcat(char* dest, char* src);
+extern fn char* strncat(char* dest, char* src, usz n);
+extern fn char* strchr(char* str, int c);
+extern fn int strcmp(char* str1, char* str2);
+extern fn int strncmp(char* str1, char* str2, usz n);
+extern fn int strcoll(char* str1, char* str2);
+extern fn char* strcpy(char* dst, char* src);
 extern fn char* strncpy(char* dst, char* src, usz n);
-extern fn CULong stroul(char* str, char** endptr, int base);
-extern fn char* strpbrk(ZString str1, ZString str2);
-extern fn usz strspn(ZString str1, ZString str2);
-extern fn ZString strptime(char* buf, ZString format, Tm* tm);
-extern fn char* strrchr(ZString str, CInt c);
-extern fn char* strstr(ZString haystack, ZString needle);
-extern fn double strtod(char* str, char** endptr);
-extern fn float strtof(char* str, char** endptr);
-extern fn ZString strtok(ZString str, ZString delim);
-extern fn CLong strtol(char* str, char** endptr, CInt base);
-extern fn CULong strtul(char* str, char** endptr, CInt base);
-extern fn usz strxfrm(char* dest, ZString src, usz n);
-extern fn CInt system(ZString str);
-extern fn Time_t timegm(Tm *timeptr) @if(!env::WIN32);
-extern fn ZString tmpnam(ZString str);
-extern fn CInt ungetc(CInt c, CFile stream);
-extern fn CInt unsetenv(ZString name);
-extern fn isz write(Fd fd, void* buffer, usz count) @if(!env::WIN32);
+extern fn usz strcspn(char* str1, char* str2);
+extern fn char* strerror(int errn);
+extern fn usz strlen(char* str);
+extern fn char* strpbrk(char* str1, char* str2);
+extern fn usz strspn(char* str1, char* str2);
+extern fn char* strstr(char* haystack, char* needle);
+extern fn char* strtok(char* str, char* delim);
+extern fn usz strxfrm(char* dest, char* src, usz n);
 
-extern fn CFile fmemopen(void* ptr, usz size, ZString mode);
-extern fn isz getline(char** linep, usz* linecapp, CFile stream);
-extern fn int timespec_get(TimeSpec* ts, int base);
-extern fn int nanosleep(TimeSpec* req, TimeSpec* remaining);
-extern fn ZString ctime(Time_t *timer);
-extern fn Time_t time(Time_t *timer);
+// malloc
+extern fn void* malloc(usz size);
+extern fn void* calloc(usz count, usz size);
+extern fn void* free(void*);
+extern fn void* realloc(void* ptr, usz size);
 
-const CInt STDIN_FD = 0;
-const CInt STDOUT_FD = 1;
-const CInt STDERR_FD = 2;
-
-module libc @if(env::LINUX);
-extern CFile __stdin @extern("stdin");
-extern CFile __stdout @extern("stdout");
-extern CFile __stderr @extern("stderr");
-extern fn usz malloc_usable_size(void* ptr);
-macro usz malloc_size(void* ptr) => malloc_usable_size(ptr);
-extern fn void* aligned_alloc(usz align, usz size);
-macro CFile stdin() => __stdin;
-macro CFile stdout() => __stdout;
-macro CFile stderr() => __stderr;
-
-module libc @if(env::DARWIN);
-extern CFile __stdinp;
-extern CFile __stdoutp;
-extern CFile __stderrp;
-extern fn usz malloc_size(void* ptr);
-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::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);
-macro CFile stdin() { return (CFile*)(uptr)STDIN_FD; }
-macro CFile stdout() { return (CFile*)(uptr)STDOUT_FD; }
-macro CFile stderr() { return (CFile*)(uptr)STDERR_FD; }
-
-module libc @if(!env::LIBC);
+$else
 
 fn void longjmp(JmpBuf* buffer, CInt value) @weak @extern("longjmp") @nostrip
 {
@@ -271,6 +144,110 @@ fn void* memset(void* dest, CInt value, usz n) @weak @extern("memset") @nostrip
 	return dest;
 }
 
+$endif
+
+// stdio
+
+typedef Fpos = long;
+typedef CFile = void*;
+
+$switch
+$case env::COMPILER_LIBC_AVAILABLE && env::OS_TYPE == OsType.LINUX:
+    extern CFile __stdin @extern("stdin");
+    extern CFile __stdout @extern("stdout");
+    extern CFile __stderr @extern("stderr");
+    extern fn usz malloc_usable_size(void* ptr);
+    macro usz malloc_size(void* ptr) { return malloc_usable_size(ptr); }
+	extern fn void* aligned_alloc(usz align, usz size);
+    macro CFile stdin() { return __stdin; }
+    macro CFile stdout() { return __stdout; }
+    macro CFile stderr() { return __stderr; }
+$case env::COMPILER_LIBC_AVAILABLE && env::OS_TYPE == OsType.MACOSX:
+    extern CFile __stdinp;
+    extern CFile __stdoutp;
+    extern CFile __stderrp;
+    extern fn usz malloc_size(void* ptr);
+    extern fn void* aligned_alloc(usz align, usz size);
+	macro CFile stdin() { return __stdinp; }
+    macro CFile stdout() { return __stdoutp; }
+    macro CFile stderr() { return __stderrp; }
+$case env::COMPILER_LIBC_AVAILABLE && env::OS_TYPE == OsType.WIN32:
+    extern fn CFile __acrt_iob_func(CInt c);
+    extern fn usz _msize(void* ptr);
+    macro usz malloc_size(void* ptr) { return _msize(ptr); }
+    macro CFile stdin() { return __acrt_iob_func(0); }
+    macro CFile stdout() { return __acrt_iob_func(1); }
+    macro CFile stderr() { return __acrt_iob_func(2); }
+$default:
+    macro CFile stdin() { return (CFile*)(uptr)0; }
+    macro CFile stdout() { return (CFile*)(uptr)1; }
+    macro CFile stderr() { return (CFile*)(uptr)2; }
+$endswitch
+
+const HAS_MALLOC_SIZE =
+	env::OS_TYPE == OsType.LINUX
+	|| env::OS_TYPE == OsType.WIN32
+	|| env::OS_TYPE == OsType.MACOSX;
+
+// The following needs to be set per arch+os
+// For now I have simply pulled the defaults from MacOS
+const int SEEK_SET = 0;
+const int SEEK_CUR = 1;
+const int SEEK_END = 2;
+const int _IOFBF = 0; // Fully buffered
+const int _IOLBF = 1; // Line buffered
+const int _IONBF = 2; // Unbuffered
+const int BUFSIZ = 1024;
+const int EOF = -1;
+const int FOPEN_MAX = 20;
+const int FILENAME_MAX = 1024;
+
+typedef Errno = distinct CInt;
+typedef SeekIndex = CLong;
+
+$if (env::COMPILER_LIBC_AVAILABLE)
+
+extern fn int fclose(CFile stream);
+extern fn void clearerr(CFile stream);
+extern fn int feof(CFile stream);
+extern fn int ferror(CFile stream);
+extern fn int fflush(CFile stream);
+extern fn int fgetpos(CFile stream, Fpos* pos);
+extern fn CFile fopen(ZString filename, ZString mode);
+extern fn usz fread(void* ptr, usz size, usz nmemb, CFile stream);
+extern fn CFile freopen(ZString filename, ZString mode, CFile stream);
+extern fn CFile fmemopen(void* ptr, usz size, ZString mode);
+extern fn int fseek(CFile stream, SeekIndex offset, int whence);
+extern fn int fsetpos(CFile stream, Fpos* pos);
+extern fn SeekIndex ftell(CFile stream);
+extern fn usz fwrite(void* ptr, usz size, usz nmemb, CFile stream);
+extern fn int remove(char* filename);
+extern fn int rename(char* old_name, char* new_name);
+extern fn void rewind(CFile stream);
+extern fn void setbuf(CFile stream, char* buffer);
+extern fn void setvbuf(CFile stream, char* buffer, int mode, usz size);
+extern fn CFile tmpnam(char* str);
+extern fn int fprintf(CFile stream, char* format, ...);
+extern fn int printf(char* format, ...);
+extern fn int sprintf(char* str, char* format, ...);
+extern fn int snprintf(char* str, usz size, char* format, ...);
+extern fn int fscanf(CFile stream, char* format, ...);
+extern fn int scanf(char* format, ...);
+extern fn int sscanf(char* str, char* format, ...);
+extern fn int fgetc(CFile stream);
+extern fn char* fgets(char* str, int n, CFile stream);
+extern fn int fputc(int c, CFile stream);
+extern fn int getc(CFile stream);
+extern fn int getchar();
+extern fn int putc(int c, CFile stream);
+extern fn int putchar(int c);
+extern fn int puts(char* str);
+extern fn int ungetc(int c, CFile stream);
+extern fn void perror(char* str);
+extern fn isz getline(char** linep, usz* linecapp, CFile stream);
+
+$else
+
 fn int fseek(CFile stream, SeekIndex offset, int whence) @weak @extern("fseek") @nostrip
 {
 	unreachable("'fseek' not available.");
@@ -338,240 +315,150 @@ fn int puts(ZString str) @weak @extern("puts") @nostrip
 	unreachable("'puts' not available.");
 }
 
-module libc;
-
-// stdio
-
-def CFile = void*;
-
-
-const HAS_MALLOC_SIZE = env::LINUX || env::WIN32 || env::DARWIN;
-
-// The following needs to be set per arch+os
-// For now I have simply pulled the defaults from MacOS
-const int SEEK_SET = 0;
-const int SEEK_CUR = 1;
-const int SEEK_END = 2;
-const int _IOFBF = 0; // Fully buffered
-const int _IOLBF = 1; // Line buffered
-const int _IONBF = 2; // Unbuffered
-const int BUFSIZ = 1024;
-const int EOF = -1;
-const int FOPEN_MAX = 20;
-const int FILENAME_MAX = 1024;
-
-const S_IFMT   = 0o170000; // type of file mask
-const S_IFIFO  = 0o010000; // named pipe (fifo)
-const S_IFCHR  = 0o020000; // character special
-const S_IFDIR  = 0o040000; // directory
-const S_IFBLK  = 0o060000; // block special
-const S_IFREG  = 0o100000; // regular
-const S_IFLNK  = 0o120000; // symbolic link
-const S_IFSOCK = 0o140000; // socket
-const S_ISUID  = 0o004000; // Set user id on execution
-const S_ISGID  = 0o002000; // Set group id on execution
-const S_ISVTX  = 0o001000; // Save swapped text even after use
-const S_IRUSR  = 0o000400; // Read permission, owner
-const S_IWUSR  = 0o000200; // Write permission, owner
-const S_IXUSR  = 0o000100; // Execute/search permission, owner
-
-def SeekIndex = CLong;
-
+$endif
 // vsprintf vprintf not supported
 
 // time.h
 
+typedef TimeOffset = CLong;
+
 struct Tm
 {
-	CInt	tm_sec;		// seconds after the minute [0-60]
-	CInt	tm_min;		// minutes after the hour [0-59]
-	CInt	tm_hour;	// hours since midnight [0-23]
-	CInt	tm_mday;	// day of the month [1-31]
-	CInt	tm_mon;		// months since January [0-11]
-	CInt	tm_year;	// years since 1900
-	CInt	tm_wday;	// days since Sunday [0-6]
-	CInt	tm_yday;	// days since January 1 [0-365]
-	CInt	tm_isdst;	// Daylight Savings Time flag
-	TimeOffset tm_gmtoff @if(!env::WIN32);	/* offset from UTC in seconds */
-	char *tm_zone @if(!env::WIN32);	/* timezone abbreviation */
-	CInt tm_nsec @if(env::WASI);
+	int	tm_sec;		/* seconds after the minute [0-60] */
+	int	tm_min;		/* minutes after the hour [0-59] */
+	int	tm_hour;	/* hours since midnight [0-23] */
+	int	tm_mday;	/* day of the month [1-31] */
+	int	tm_mon;		/* months since January [0-11] */
+	int	tm_year;	/* years since 1900 */
+	int	tm_wday;	/* days since Sunday [0-6] */
+	int	tm_yday;	/* days since January 1 [0-365] */
+	int	tm_isdst;	/* Daylight Savings Time flag */
+	TimeOffset tm_gmtoff;	/* offset from UTC in seconds */
+    char *tm_zone;	/* timezone abbreviation */
 }
 
 struct TimeSpec
 {
-	Time_t s;
-	ulong ns @if(env::WIN32);
-	CLong ns @if(!env::WIN32);
+	Time s;
+	ulong ns;
 }
 
-
-def Clock_t = int @if(env::WIN32);
-def Clock_t = CULong @if(!env::WIN32);
-
-def TimeOffset = int @if(env::WASI) ;
-def TimeOffset = CLong @if(!env::WASI) ;
-
 const int TIME_UTC = 1;
 
 
+extern fn int timespec_get(TimeSpec* ts, int base);
+extern fn int nanosleep(TimeSpec* req, TimeSpec* remaining);
+
 // Likely wrong, must be per platform.
 const CLOCKS_PER_SEC = 1000000;
 
+// Time also needs to be per platform
+typedef Time = long;
+typedef Clock = ulong;
+
+extern fn ZString asctime(Tm *timeptr);
+extern fn Clock clock();
+extern fn ZString ctime(Time *timer);
+extern fn double difftime(Time time1, Time time2);
+extern fn Tm* gmtime(Time *timer);
+extern fn Tm* localtime(Time *timer);
+extern fn Time mktime(Tm *timeptr);
+extern fn usz strftime(char* str, usz maxsize, char* format, Tm *timeptr);
+extern fn Time time(Time *timer);
+
+// signal
+typedef SignalFunction = fn void(int);
+extern fn SignalFunction signal(int sig, SignalFunction function);
+// Incomplete
+
+
 module libc::errno;
 
-const Errno OK                       = 0;
-const Errno EPERM                    = 1; // Operation not permitted
-const Errno ENOENT                   = 2; // No such file or directory
-const Errno ESRCH                    = 3; // No such process
-const Errno EINTR                    = 4; // Interrupted system call
-const Errno EIO                      = 5; // I/O error
-const Errno ENXIO                    = 6; // No such device or address
-const Errno E2BIG                    = 7; // Argument list too long
-const Errno ENOEXEC                  = 8; // Exec format error
-const Errno EBADF                    = 9; // Bad file number
-const Errno ECHILD                   = 10; // No child processes
+const Errno OK = 0;
+const Errno EPERM = 1;      // Operation not permitted
+const Errno ENOENT = 2;     // No such file or directory
+const Errno ESRCH = 3;      // No such process
+const Errno EINTR = 4;      // Interrupted system call
+const Errno EIO = 5;        // I/O error
+const Errno ENXIO = 6;      // No such device or address
+const Errno E2BIG = 7;      // Argument list too long
+const Errno ENOEXEC = 8;    // Exec format error
+const Errno EBADF = 9;      // Bad file number
+const Errno ECHILD = 10;    // No child processes
 
+$if (env::OS_TYPE == MACOSX)
+const Errno EAGAIN = 35;    // Try again Macos
+$else
+const Errno EAGAIN = 11;    // Try again
+$endif
 
-const Errno EAGAIN @if(env::DARWIN)  = 35; // Try again Macos
-const Errno EAGAIN @if(!env::DARWIN) = 11; // Try again
+const Errno ENOMEM = 12;    // Out of memory
+const Errno EACCES = 13;    // Permission denied
+const Errno EFAULT = 14;    // Bad address
+const Errno ENOTBLK = 15;   // Block device required, not on Win32
+const Errno EBUSY = 16;     // Device or resource busy
+const Errno EEXIST = 17;    // File exists
+const Errno EXDEV = 18;     // Cross-device link
+const Errno ENODEV = 19;    // No such device
+const Errno ENOTDIR = 20;   // Not a directory
+const Errno EISDIR = 21;    // Is a directory
+const Errno EINVAL = 22;    // Invalid argument
+const Errno ENFILE = 23;    // File table overflow
+const Errno EMFILE = 24;    // Too many open files
+const Errno ENOTTY = 25;    // Not a typewriter
+const Errno ETXTBSY = 26;   // Text file busy, not on Win32
+const Errno EFBIG = 27;     // File too large
+const Errno ENOSPC = 28;    // No space left on device
+const Errno ESPIPE = 29;    // Illegal seek
+const Errno EROFS = 30;     // Read-only file system
+const Errno EMLINK = 31;    // Too many links
+const Errno EPIPE = 32;     // Broken pipe
+const Errno EDOM = 33;      // Math argument out of domain of func
+const Errno ERANGE = 34;    // Math result not representable
 
-const Errno ENOMEM                   = 12; // Out of memory
-const Errno EACCES                   = 13; // Permission denied
-const Errno EFAULT                   = 14; // Bad address
-const Errno ENOTBLK                  = 15; // Block device required, not on Win32
-const Errno EBUSY                    = 16; // Device or resource busy
-const Errno EEXIST                   = 17; // File exists
-const Errno EXDEV                    = 18; // Cross-device link
-const Errno ENODEV                   = 19; // No such device
-const Errno ENOTDIR                  = 20; // Not a directory
-const Errno EISDIR                   = 21; // Is a directory
-const Errno EINVAL                   = 22; // Invalid argument
-const Errno ENFILE                   = 23; // File table overflow
-const Errno EMFILE                   = 24; // Too many open files
-const Errno ENOTTY                   = 25; // Not a typewriter
-const Errno ETXTBSY                  = 26; // Text file busy, not on Win32
-const Errno EFBIG                    = 27; // File too large
-const Errno ENOSPC                   = 28; // No space left on device
-const Errno ESPIPE                   = 29; // Illegal seek
-const Errno EROFS                    = 30; // Read-only file system
-const Errno EMLINK                   = 31; // Too many links
-const Errno EPIPE                    = 32; // Broken pipe
-const Errno EDOM                     = 33; // Math argument out of domain of func
-const Errno ERANGE                   = 34; // Math result not representable
+$switch (env::OS_TYPE)
 
-// https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/intro.2.html
-module libc::errno @if(env::DARWIN);
-const Errno EWOULDBLOCK              = EAGAIN; // Operation would block
-const Errno EDEADLK                  = 11; // Resource deadlock would occur
-const Errno EINPROGRESS              = 36; // Operation now in progress
-const Errno EALREADY                 = 37; // Operation already in progress
-const Errno ENOTSOCK                 = 38; // Socket operation on non-socket
-const Errno EDESTADDRREQ             = 39; // Destination address required
-const Errno EMSGSIZE                 = 40; // Message too long
-const Errno EPROTOTYPE               = 41; // Protocol wrong type for socket
-const Errno ENOPROTOOPT              = 42; // Protocol not available
-const Errno EPROTONOSUPPORT          = 43; // Protocol not supported
-const Errno ESOCKTNOSUPPORT          = 44; // Socket type not supported
-const Errno ENOTSUP                  = 45; // Not supported
-const Errno EPFNOSUPPORT             = 46; // Protocol family not supported
-const Errno EAFNOSUPPORT             = 47; // Address family not supported by protocol family
-const Errno EADDRINUSE               = 48; // Address already in use
-const Errno EADDRNOTAVAIL            = 49; // Cannot assign requested address
-const Errno ENETDOWN                 = 50; // Network is down
-const Errno ENETUNREACH              = 51; // Network is unreachable
-const Errno ENETRESET                = 52; // Network dropped connection on reset
-const Errno ECONNABORTED             = 53; // Software caused connection abort
-const Errno ECONNRESET               = 54; // Connection reset by peer
-const Errno ENOBUFS                  = 55; // No buffer space available
-const Errno EISCONN                  = 56; // Socket is already connected
-const Errno ENOTCONN                 = 57; // Socket is not connected
-const Errno ESHUTDOWN                = 58; // Cannot send after socket shutdown
-const Errno ETIMEDOUT                = 60; // Operation timed out
-const Errno ECONNREFUSED             = 61; // Connection refused
-const Errno ELOOP                    = 62; // Too many levels of symbolic links
-const Errno ENAMETOOLONG             = 63; // File name too long
-const Errno EHOSTDOWN                = 64; // Host is down
-const Errno EHOSTUNREACH             = 65; // No route to host
-const Errno ENOTEMPTY                = 66; // Directory not empty
-const Errno EPROCLIM                 = 67; // Too many processes
-const Errno EUSERS                   = 68; // Too many users
-const Errno EDQUOT                   = 69; // Disc quota exceeded
-const Errno ESTALE                   = 70; // Stale NFS file handle
-const Errno EBADRPC                  = 72; // RPC struct is bad
-const Errno ERPCMISMATCH             = 73; // RPC version wrong
-const Errno EPROGUNAVAIL             = 74; // RPC prog. not avail
-const Errno EPROGMISMATCH            = 75; // Program version wrong
-const Errno EPROCUNAVAIL             = 76; // Bad procedure for program
-const Errno ENOLCK                   = 77; // No locks available
-const Errno ENOSYS                   = 78; // Function not implemented
-const Errno EFTYPE                   = 79; // Inappropriate file type or format
-const Errno EAUTH                    = 80; // Authentication error
-const Errno ENEEDAUTH                = 81; // Need authenticator
-const Errno EPWROFF                  = 82; // Device power is off
-const Errno EDEVERR                  = 83; // Device error
-const Errno EOVERFLOW                = 84; // Value too large to be stored in data type
-const Errno EBADEXEC                 = 85; // Bad executable (or shared library)
-const Errno EBADARCH                 = 86; // Bad CPU type in executable
-const Errno ESHLIBVERS               = 87; // Shared library version mismatch
-const Errno EBADMACHO                = 88; // Malformed Mach-o file
-const Errno ECANCELED                = 89; // Operation canceled
-const Errno EIDRM                    = 90; // Identifier removed
-const Errno ENOMSG                   = 91; // No message of desired type
-const Errno EILSEQ                   = 92; // Illegal byte sequence
-const Errno ENOATTR                  = 93; // Attribute not found
-const Errno EBADMSG                  = 94; // Bad message
-const Errno EMULTIHOP                = 95; // Reserved
-const Errno ENODATA                  = 96; // No message available
-const Errno ENOLINK                  = 97; // Reserved
-const Errno ENOSR                    = 98; // No STREAM resources
-const Errno ENOSTR                   = 99; // Not a STREAM
-const Errno EPROTO                   = 100; // Protocol error
-const Errno ETIME                    = 101; // STREAM ioctl() timeout
-const Errno EOPNOTSUPP               = 102; // Operation not supported on socket
+$case MACOSX:
+const Errno EDEADLK = 11;       // Resource deadlock would occur MacOS
+const Errno ENAMETOOLONG = 63;  // File name too long MacOS
+const Errno ELOOP = 62;         // Too many symbolic links encountered
+const Errno EOVERFLOW = 84;     // Value too large for defined data type Macos
+const Errno ECONNRESET = 54;    // Connection reset by peer Macos
+const Errno ENETDOWN = 50;      // Network is down MacOS
+const Errno ENETUNREACH = 51;   // Network is unreachable MacOS
+const Errno ENETRESET = 52;     // Network dropped connection because of reset MacOS
+const Errno EOPNOTSUPP = 45;    // Operation not supported on transport endpoint
 
-module libc::errno @if(env::WIN32);
-const Errno EDEADLK                  = 36; // Resource deadlock would occur Win32
-const Errno ENAMETOOLONG             = 38; // File name too long Win32
-const Errno ENOTEMPTY                = 41; // Directory not empty
-const Errno ELOOP                    = 114; // Too many symbolic links encountered
-const Errno EOVERFLOW                = 132; // Value too large for defined data type
-const Errno ENETDOWN                 = 116; // Network is down
-const Errno ECONNRESET               = 108; // Connection reset by peer
-const Errno ENETUNREACH              = 118; // Network is unreachable
-const Errno ENETRESET                = 117; // Network dropped connection because of reset
-const Errno EOPNOTSUPP               = 130; // Operation not supported on transport endpoint
-const Errno ETIMEDOUT                = 138; // Connection timed out
-const Errno EALREADY                 = 103; // Operation already in progress
-const Errno EINPROGRESS              = 112; // Operation now in progress Win32
-const Errno EDQUOT                   = -122; // Quota exceeded, not in Win32
-const Errno EWOULDBLOCK              = 140; // Operation would block
+$case WIN32:
+const Errno EDEADLK = 36;       // Resource deadlock would occur Win32
+const Errno ENAMETOOLONG = 38;  // File name too long Win32
+const Errno ELOOP = 114;        // Too many symbolic links encountered
+const Errno EOVERFLOW = 132;    // Value too large for defined data type
+const Errno ENETDOWN = 116;     // Network is down
+const Errno ECONNRESET = 108;   // Connection reset by peer
+const Errno ENETUNREACH = 118;  // Network is unreachable
+const Errno ENETRESET = 117;    // Network dropped connection because of reset
+const Errno EOPNOTSUPP = 130;   // Operation not supported on transport endpoint
+
+$default:
+const Errno EDEADLK = 35;       // Resource deadlock would occur Linux (others?)
+const Errno ENAMETOOLONG = 36;  // File name too long Linux (others?)
+const Errno ELOOP = 40;         // Too many symbolic links encountered
+const Errno EOVERFLOW = 75;     // Value too large for defined data type
+const Errno ENETDOWN = 100;     // Network is down
+const Errno ECONNRESET = 104;   // Connection reset by peer
+const Errno ENETUNREACH = 101;  // Network is unreachable
+const Errno ENETRESET = 102;    // Network dropped connection because of reset
+const Errno EOPNOTSUPP = 95;    // Operation not supported on transport endpoint
+
+$endswitch
 
-module libc::errno @if(!env::WIN32 && !env::DARWIN);
-const Errno EDEADLK                  = 35; // Resource deadlock would occur Linux (others?)
-const Errno ENAMETOOLONG             = 36; // File name too long Linux (others?)
-const Errno ENOTEMPTY                = 39; // Directory not empty
-const Errno ELOOP                    = 40; // Too many symbolic links encountered
-const Errno EWOULDBLOCK              = EAGAIN; // Operation would block
-const Errno EOVERFLOW                = 75; // Value too large for defined data type
-const Errno ENOTSOCK                 = 88; // Socket operation on non-socket
-const Errno EOPNOTSUPP               = 95; // Operation not supported on transport endpoint
-const Errno EADDRINUSE               = 98; // Address already in use
-const Errno EADDRNOTAVAIL            = 99; // Cannot assign requested address
-const Errno ENETDOWN                 = 100; // Network is down
-const Errno ENETUNREACH              = 101; // Network is unreachable
-const Errno ENETRESET                = 102; // Network dropped connection because of reset
-const Errno ECONNRESET               = 104; // Connection reset by peer
-const Errno EISCONN                  = 106; // Socket is already connected
-const Errno ETIMEDOUT                = 110; // Connection timed out
-const Errno ECONNREFUSED             = 111; // Connection refused
-const Errno EALREADY                 = 114; // Operation already in progress
-const Errno EINPROGRESS              = 115; // Operation now in progress
-const Errno EDQUOT                   = 122; // Quota exceeded
 
 
 /*
 const Errno ENOLCK = 37;  /* No record locks available */
 const Errno ENOSYS = 38;  /* Function not implemented */
+const Errno ENOTEMPTY = 39;  /* Directory not empty */
 
 const Errno ENOMSG = 42;  /* No message of desired type */
 const Errno EIDRM = 43;  /* Identifier removed */
@@ -628,6 +515,7 @@ const Errno ESOCKTNOSUPPORT = 94;  /* Socket type not supported */
 const Errno EPFNOSUPPORT = 96;  /* Protocol family not supported */
 const Errno EAFNOSUPPORT = 97;  /* Address family not supported by protocol */
 const Errno EADDRINUSE = 98;  /* Address already in use */
+const Errno EADDRNOTAVAIL = 99;  /* Cannot assign requested address */
 const Errno ECONNABORTED = 103; /* Software caused connection abort */
 const Errno ENOBUFS = 105; /* No buffer space available */
 const Errno EISCONN = 106; /* Transport endpoint is already connected */
@@ -639,6 +527,29 @@ const Errno EHOSTDOWN = 112; /* Host is down */
 const Errno EHOSTUNREACH = 113; /* No route to host */
 */
 
+$switch (env::OS_TYPE)
+
+$case MACOSX:
+const Errno ETIMEDOUT = 60;     // Connection timed out
+const Errno EINPROGRESS = 36;   // Operation now in progress MacOS
+const Errno EALREADY = 37;      // Operation already in progress MacOS
+const Errno EDQUOT = 69;        // Quota exceeded, MacOS
+const Errno EWOULDBLOCK = 35;   // Operation would block
+
+$case WIN32:
+const Errno ETIMEDOUT = 138;    // Connection timed out
+const Errno EALREADY = 103;     // Operation already in progress
+const Errno EINPROGRESS = 112;  // Operation now in progress Win32
+const Errno EDQUOT = -122;      // Quota exceeded, not in Win32
+const Errno EWOULDBLOCK = 140;  // Operation would block
+
+$default:
+const Errno ETIMEDOUT = 110;    // Connection timed out
+const Errno EALREADY = 114;     // Operation already in progress
+const Errno EINPROGRESS = 115;  // Operation now in progress
+const Errno EDQUOT = 122;       // Quota exceeded
+const Errno EWOULDBLOCK = 41;   // Operation would block
+$endswitch
 
 /*
 const Errno ESTALE = 116; /* Stale NFS file handle */

lib/std/libc/libc_extra.c3

@@ -1,22 +0,0 @@
-module libc;
-import std::time;
-
-/**
- * @require self >= 0
- **/
-fn TimeSpec NanoDuration.to_timespec(self) @inline
-{
-	CLong ns = (CLong)(self % 1000_000_000);
-	Time_t sec = (Time_t)(self / 1000_000_000);
-	return { .s = sec, .ns = ns };
-}
-
-/**
- * @require self >= 0
- **/
-fn TimeSpec Duration.to_timespec(self) @inline
-{
-	CLong ns = (CLong)(1000 * (self % time::SEC));
-	Time_t sec = (Time_t)(self / time::SEC);
-	return { .s = sec, .ns = ns };
-}