Fix union #maybe comparison against nil -llvm-api

Fix for issue 720 (import name is not an identifier)

.gitattributes

@@ -0,0 +1 @@
+*.odin linguist-language=Odin

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+patreon: gingerbill

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,39 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+## Context
+
+Please provide any relevant information about your setup. This is important in case the issue is not reproducible except for under certain conditions.
+
+* Operating System:
+* Please paste `odin version` output:
+
+## Expected Behavior
+
+Please describe the behavior you are expecting
+
+## Current Behavior
+
+What is the current behavior?
+
+## Failure Information (for bugs)
+
+Please help provide information about the failure if this is a bug. If it is not a bug, please remove the rest of this template.
+
+### Steps to Reproduce
+
+Please provide detailed steps for reproducing the issue.
+
+1. step 1
+2. step 2
+3. you get it...
+
+### Failure Logs
+
+Please include any relevant log snippets or files here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,17 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/ci.yml

@@ -0,0 +1,64 @@
+name: CI
+on: [push, pull_request]
+
+jobs:
+  build_linux:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Download LLVM
+        run: sudo apt-get install llvm-11 clang-11 llvm
+      - name: build odin
+        run: make release
+      - name: Odin run -llvm-api
+        run: ./odin run examples/demo/demo.odin -llvm-api
+      - name: Odin run
+        run: ./odin run examples/demo/demo.odin
+      - name: Odin check
+        run: ./odin check examples/demo/demo.odin -vet
+  build_macOS:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Download LLVM and setup PATH
+        run: |
+          brew install llvm@11
+          echo "/usr/local/opt/llvm/bin" >> $GITHUB_PATH
+          TMP_PATH=$(xcrun --show-sdk-path)/user/include
+          echo "CPATH=$TMP_PATH" >> $GITHUB_ENV
+      - name: build odin
+        run: make release
+      - name: Odin run
+        run: |
+          ./odin run examples/demo/demo.odin
+          ./odin run examples/demo/demo.odin -llvm-api
+      - name: Odin check
+        run: ./odin check examples/demo/demo.odin -vet
+  build_windows:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Download and unpack LLVM bins
+        shell: powershell
+        run: |
+          cd bin
+          $ProgressPreference = "SilentlyContinue";
+          Invoke-WebRequest -Uri https://github.com/odin-lang/Odin/releases/download/llvm-windows/llvm-binaries.zip -OutFile llvm-binaries.zip
+          7z x llvm-binaries.zip > $null
+      - name: build Odin
+        shell: cmd
+        run: |
+          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          ./build.bat 1
+      - name: Odin run
+        shell: cmd
+        run: |
+          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          odin run examples/demo/demo.odin
+      - name: Odin check
+        shell: cmd
+        run: |
+          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          odin check examples/demo/demo.odin -vet
+
+

.github/workflows/nightly.yml

@@ -0,0 +1,152 @@
+name:  Nightly
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: 0 20 * * *
+
+jobs:
+  build_windows:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Install cURL
+        run: choco install curl
+      - name: Download and unpack LLVM bins
+        shell: cmd
+        run: |
+          cd bin
+          curl -sL https://github.com/odin-lang/Odin/releases/download/llvm-windows/llvm-binaries.zip --output llvm-binaries.zip
+          7z x llvm-binaries.zip > nul
+          rm -f llvm-binaries.zip
+      - name: build Odin
+        shell: cmd
+        run: |
+          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          ./build.bat 1 1
+      - name: Odin run
+        shell: cmd
+        run: |
+          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          odin run examples/demo/demo.odin
+      - name: Copy artifacts
+        run: |
+          rm bin/llvm/windows/LLVM-C.lib
+          mkdir dist
+          cp odin.exe dist
+          cp LLVM-C.dll dist
+          cp -r shared dist
+          cp -r core dist
+          cp -r bin dist
+          cp -r examples dist
+      - name: Upload artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: windows_artifacts
+          path: dist
+  build_ubuntu:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: (Linux) Download LLVM
+        run: sudo apt-get install llvm-11 clang-11 llvm
+      - name: build odin
+        run: make nightly
+      - name: Odin run -llvm-api
+        run: ./odin run examples/demo/demo.odin -llvm-api
+      - name: Odin run
+        run: ./odin run examples/demo/demo.odin
+      - name: Copy artifacts
+        run: |
+          mkdir dist
+          cp odin dist
+          cp -r shared dist
+          cp -r core dist
+          cp -r examples dist
+      - name: Upload artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: ubuntu_artifacts
+          path: dist
+  build_macos:
+    runs-on: macOS-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Download LLVM and setup PATH
+        run: |
+          brew install llvm
+          echo "/usr/local/opt/llvm/bin" >> $GITHUB_PATH
+          TMP_PATH=$(xcrun --show-sdk-path)/user/include
+          echo "CPATH=$TMP_PATH" >> $GITHUB_ENV
+      - name: build odin
+        run: make nightly
+      - name: Odin run -llvm-api
+        run: ./odin run examples/demo/demo.odin -llvm-api
+      - name: Odin run
+        run: ./odin run examples/demo/demo.odin
+      - name: Copy artifacts
+        run: |
+          mkdir dist
+          cp odin dist
+          cp -r shared dist
+          cp -r core dist
+          cp -r examples dist
+      - name: Upload artifact
+        uses: actions/upload-artifact@v1
+        with:
+          name: macos_artifacts
+          path: dist
+  upload_b2:
+    runs-on: [ubuntu-latest]
+    needs: [build_windows, build_macos, build_ubuntu]
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions/setup-python@v2
+        with:
+          python-version: '3.x'
+
+      - name: Install B2 CLI
+        shell: bash
+        run: |
+          python -m pip install --upgrade pip
+          pip install --upgrade b2
+
+      - name: Display Python version
+        run: python -c "import sys; print(sys.version)"
+
+      - name: Download Windows artifacts
+        uses: actions/download-artifact@v1
+        with:
+          name: windows_artifacts
+
+      - name: Download Ubuntu artifacts
+        uses: actions/download-artifact@v1
+        with:
+          name: ubuntu_artifacts
+
+      - name: Download macOS artifacts
+        uses: actions/download-artifact@v1
+        with:
+          name: macos_artifacts
+
+      - name: Create archives and upload
+        shell: bash
+        env:
+          APPID: ${{ secrets.B2_APPID }}
+          APPKEY: ${{ secrets.B2_APPKEY }}
+          BUCKET: ${{ secrets.B2_BUCKET }}
+          DAYS_TO_KEEP: ${{ secrets.B2_DAYS_TO_KEEP }}
+        run: |
+          b2 authorize-account "$APPID" "$APPKEY"
+
+          chmod +x ./ci/upload_create_nightly.sh
+          ./ci/upload_create_nightly.sh "$BUCKET" windows-amd64 windows_artifacts/
+          ./ci/upload_create_nightly.sh "$BUCKET" ubuntu-amd64 ubuntu_artifacts/
+          ./ci/upload_create_nightly.sh "$BUCKET" macos-amd64 macos_artifacts/
+
+          python3 ci/delete_old_binaries.py "$BUCKET" "$DAYS_TO_KEEP"
+
+          python3 ci/create_nightly_json.py "$BUCKET" > nightly.json
+          b2 upload-file "$BUCKET" nightly.json nightly.json
+
+          b2 clear-account

.gitignore

@@ -18,11 +18,14 @@ bld/
 [Bb]in/
 [Oo]bj/
 [Ll]og/
-
+![Cc]ore/[Ll]og/
 # Visual Studio 2015 cache/options directory
 .vs/
+# Visual Studio Code options directory
+.vscode/
 # Uncomment if you have tasks that create the project's static files in wwwroot
 #wwwroot/
+demo
 
 # MSTest test Results
 [Tt]est[Rr]esult*/
@@ -251,7 +254,25 @@ paket-files/
 
 
 # Project Specific
+
+# - Windows
 *.sln
-!misc/llvm-bim/lli.exe
-!misc/llvm-bim/opt.exe
-builds
+builds/
+bin/
+*.exe
+*.obj
+*.pdb
+
+# - Linux/MacOS
+odin
+odin.dSYM
+
+# shared collection
+shared/
+
+# temp files
+* .ll
+*.bc
+*.ll
+
+*.sublime-workspace

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2016 Ginger Bill. All rights reserved.
+Copyright (c) 2016-2020 Ginger Bill. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

Makefile

@@ -0,0 +1,34 @@
+GIT_SHA=$(shell git rev-parse --short HEAD)
+DISABLED_WARNINGS=-Wno-switch -Wno-pointer-sign -Wno-tautological-constant-out-of-range-compare -Wno-tautological-compare -Wno-macro-redefined
+LDFLAGS=-pthread -ldl -lm -lstdc++
+CFLAGS=-std=c++14 -DGIT_SHA=\"$(GIT_SHA)\"
+CC=clang
+
+OS=$(shell uname)
+
+ifeq ($(OS), Darwin)
+	LDFLAGS:=$(LDFLAGS) -liconv
+	CFLAGS:=$(CFLAGS) $(shell llvm-config --cxxflags --ldflags) -DLLVM_BACKEND_SUPPORT -DUSE_NEW_LLVM_ABI_SYSTEM
+	LDFLAGS:=$(LDFLAGS) -lLLVM-C
+endif
+ifeq ($(OS), Linux)
+	CFLAGS:=$(CFLAGS) $(shell llvm-config-11 --cxxflags --ldflags) -DLLVM_BACKEND_SUPPORT -DUSE_NEW_LLVM_ABI_SYSTEM
+	LDFLAGS:=$(LDFLAGS) $(shell llvm-config-11 --libs core native --system-libs)
+endif
+
+all: debug demo
+
+demo:
+	./odin run examples/demo/demo.odin
+
+debug:
+	$(CC) src/main.cpp $(DISABLED_WARNINGS) $(CFLAGS) -g $(LDFLAGS) -o odin
+
+release:
+	$(CC) src/main.cpp $(DISABLED_WARNINGS) $(CFLAGS) -O3 -march=native $(LDFLAGS) -o odin
+
+nightly:
+	$(CC) src/main.cpp $(DISABLED_WARNINGS) $(CFLAGS) -DNIGHTLY -O3 $(LDFLAGS) -o odin
+
+
+

PROPOSAL-PROCESS.md

@@ -0,0 +1,64 @@
+# The Proposal Process
+
+## Introduction
+
+The Odin project's development process is driven by design and pragmatism. Significant changes to the language, libraries, or tools _must_ be first discussed, and maybe formally documented, before they can be implemented.
+
+This document describes the process for proposing, documenting, and implementing changes to the Odin project.
+
+## The Proposal Process
+
+The proposal process is the process for reviewing a proposal and reaching a decision about whether to accept or decline the proposal.
+
+1. [Ginger Bill](https://github.com/gingerBill) is [BDFL](https://wikipedia.org/wiki/Benevolent_dictator_for_life) and significant changes _must_ be passed by him.
+
+2. The proposal author creates a brief issue describing the proposal.
+
+   Note: There is no need for a design document at this point.<br>
+   Note: A non-proposal issue can be turned into a proposal by simply adding the _proposal_ label.
+
+3. A discussion on the issue tracker will classify the proposal into one of three outcomes:
+	* Accept proposal
+	* Decline proposal
+	* Ask for a design document.
+
+	If the proposal is accepted or declined, the process is done. Otherwise the discussion around the process is expected to identify issues that ought to be addressed in a more detailed design.
+
+4. The proposal author writes a design document to work out details of the proposed design and address the concerns raised in the initial discussion.
+
+5. Once comments and revisions on the design document calm, there is a final discussion on the issue, to reach one of two outcomes:
+	* Accept proposal
+	* Decline proposal
+
+After the proposal is accepted or declined, implementation of the proposal proceeds in the same way as any other contribution to the project.
+
+## Design Documents
+
+The design document should follow this template:
+
+
+```
+# Proposal: [Title]
+
+Author(s): [Author Name, Co-Author Name]
+Last updated: [Date ISO-8601]
+Discussion at https://github.com/odin-lang/Odin/issues/######
+
+## Abstract
+
+## Background
+
+## Proposal
+
+## Rationale
+
+## Compatibility
+
+## Implementation
+
+```
+
+
+## Help
+
+If you need help with this process, please contact an Odin contributor by posting an issue to the [issue tracker](https://github.com/odin-lang/Odin/issues).

README.md

@@ -1,14 +1,159 @@
-<img src="logo-slim.png" alt="Odin logo" height="74">
+<p align="center">
+    <img src="misc/logo-slim.png" alt="Odin logo" height="120">
+    <br/>
+    A fast, concise, readable, pragmatic and open sourced programming language.
+    <br/>
+    <br/>
+    <a href="https://github.com/odin-lang/odin/releases/latest">
+        <img src="https://img.shields.io/github/release/odin-lang/odin.svg">
+    </a>
+    <a href="https://github.com/odin-lang/odin/releases/latest">
+        <img src="https://img.shields.io/badge/platforms-Windows%20|%20Linux%20|%20macOS-green.svg">
+    </a>
+    <br>
+    <a href="https://discord.gg/hnwN2Rj">
+        <img src="https://img.shields.io/discord/568138951836172421?logo=discord">
+    </a>
+    <a href="https://github.com/odin-lang/odin/actions">
+        <img src="https://github.com/odin-lang/odin/workflows/CI/badge.svg?branch=master&event=push">
+    </a>
+</p>
 
 # The Odin Programming Language
 
-Odin is fast, concise, readable, pragmatic and open sourced. It is designed with the intent of replacing C with the following goals:
+The Odin programming language is fast, concise, readable, pragmatic and open sourced. It is designed with the intent of creating an alternative to C with the following goals:
 * simplicity
 * high performance
 * built for modern systems
 * joy of programming
-* metaprogramming
-* designed for good programmers
+
+Website: [https://odin-lang.org/](https://odin-lang.org/)
+
+```odin
+package main
+
+import "core:fmt"
+
+main :: proc() {
+	program := "+ + * 😃 - /";
+	accumulator := 0;
+
+	for token in program {
+		switch token {
+		case '+': accumulator += 1;
+		case '-': accumulator -= 1;
+		case '*': accumulator *= 2;
+		case '/': accumulator /= 2;
+		case '😃': accumulator *= accumulator;
+		case: // Ignore everything else
+		}
+	}
+
+	fmt.printf("The program \"%s\" calculates the value %d\n",
+	           program, accumulator);
+}
+
+```
+
+
+## Documentation
+
+#### [Getting Started](https://odin-lang.org/docs/install)
+
+Instructions for downloading and installing the Odin compiler and libraries.
+
+### Learning Odin
+
+#### [Overview of Odin](https://odin-lang.org/docs/overview)
+
+An overview of the Odin programming language.
+
+#### [Frequently Asked Questions (FAQ)](https://odin-lang.org/docs/faq)
+
+Answers to common questions about Odin.
+
+#### [The Odin Wiki](https://github.com/odin-lang/Odin/wiki)
+
+A wiki maintained by the Odin community.
+
+#### [Odin Discord](https://discord.gg/sVBPHEv)
+
+Get live support and talk with other odiners on the Odin Discord.
+
+### References
+
+#### [Language Specification](https://odin-lang.org/ref/spec)
+
+The official Odin Language specification.
+
+### Articles
+
+#### [The Odin Blog](https://odin-lang.org/blog)
+
+The official blog of the Odin programming language, featuring announcements, news, and in-depth articles by the Odin team and guests.
+
+## Setup
+
+Odin only supports x86-64/amd64 at the moment (64-bit), relies on LLVM for code generation and an external linker.
+
+In addition, the following platform-specific steps are necessary:
+
+- Windows
+    * Have Visual Studio installed (MSVC 2010 or later, for the linker)
+    * Have a copy of `opt.exe` and `llc.exe` in `Odin/bin`. Pre-built Windows binaries can be found [here](https://github.com/odin-lang/Odin/releases/tag/llvm-windows) and *must* be explicitly copied
+    * Open a valid command prompt:
+        * **Basic:** run the `x64 Native Tools Command Prompt for VS2017` shortcut bundled with VS 2017, or
+        * **Advanced:** run `vcvarsall.bat x64` from a blank `cmd` session
+
+- MacOS
+    * Have LLVM explicitly installed (`brew install llvm`)
+    * Have XCode installed (version X.X or later, for linking)
+    * Make sure the LLVM binaries and the linker are added to your `$PATH` environmental variable
+
+- GNU/Linux
+    * Have LLVM installed (opt/llc)
+    * Have Clang installed (version X.X or later, for linking)
+    * Make sure the LLVM binaries and the linker are added to your `$PATH` environmental variable
+
+Then build the compiler by calling `build.bat` (Windows) or `make` (Linux/MacOS). This will automatically run the demo program if successful.
+
+**Notes for Linux:**: The compiler currently relies on the `core` and `shared` library collection being relative to the compiler executable. Installing the compiler in the usual sense (to `/usr/local/bin` or similar) is therefore not as straight forward as you need to make sure the mentioned libraries are available. As a result, it is recommended to simply explicitly invoke the compiler with `/path/to/odin` in your preferred build system, or add `/path/to/odin` to `$PATH`.
+
+Please read the [Getting Started Guide](https://github.com/odin-lang/Odin/wiki#getting-started-with-odin) for more information.
+
+## Requirements to build and run
+
+Please read the [Getting Started Guide](https://github.com/odin-lang/Odin/wiki#getting-started-with-odin).
+
+- Windows
+	* x86-64/amd64
+	* MSVC 2010 installed (C++11 support)
+	* [LLVM binaries](https://github.com/odin-lang/Odin/releases/tag/llvm-windows) for `opt.exe`, `llc.exe`, and `lld-link.exe`
+	* Requires MSVC's link.exe as the linker
+		* run `vcvarsall.bat` to setup the path
+
+- MacOS
+	* x86-64/amd64
+	* LLVM explicitly installed (`brew install llvm`)
+	* XCode installed (for the linker)
+
+- GNU/Linux
+	* x86-64/amd64
+	* Build tools (ld)
+	* LLVM installed
+	* Clang installed (temporary - this is Calling the linker for now)
+
+- FreeBSD
+	* x86-64/amd64
+	* Build tools (ld)
+	* LLVM installed
+	* Clang installed (temporary - this is Calling the linker for now)
+
+Other platforms may be supported but are experimental for the time being.
+
+## Warnings
+
+* The Odin compiler is still in development.
 
 ## Demonstrations:
 * First Talk & Demo
@@ -18,39 +163,11 @@ Odin is fast, concise, readable, pragmatic and open sourced. It is designed with
 * [Composition & Refactorability](https://www.youtube.com/watch?v=n1wemZfcbXM)
 * [Introspection, Modules, and Record Layout](https://www.youtube.com/watch?v=UFq8rhWhx4s)
 * [push_allocator & Minimal Dependency Building](https://www.youtube.com/watch?v=f_LGVOAMb78)
-
-## Requirements to build and run
-
-* Windows
-* x86-64
-* MSVC 2015 installed (C99 support)
-* Requires MSVC's link.exe as the linker
-	- run `vcvarsall.bat` to setup the path
-
-## Warnings
-
-* This is still highly in development and the language's design is quite volatile.
-* Syntax is definitely not fixed
-
-## Roadmap
-
-Not in any particular order
-
-* Custom backend to replace LLVM
-	- Improve SSA design to accommodate for lowering to a "bytecode"
-	- SSA optimizations
-	- COFF generation
-	- linker
-* Type safe "macros"
-* Documentation generator for "Entities"
-* Multiple architecture support
-* Inline assembly
-* Linking options
-	- Executable
-	- Static/Dynamic Library
-* Debug information
-	- pdb format too
-* Command line tooling
-* Compiler internals:
-	- Big numbers library
+* [when, for & procedure overloading](https://www.youtube.com/watch?v=OzeOekzyZK8)
+* [Context Types, Unexported Entities, Labelled Branches](https://www.youtube.com/watch?v=CkHVwT1Qk-g)
+* [Bit Fields, i128 & u128, Syntax Changes](https://www.youtube.com/watch?v=NlTutcLyF64)
+* [Default and Named Arguments; Explicit Parametric Polymorphism](https://www.youtube.com/watch?v=-XQZE6S6zUU)
+* [Loadsachanges](https://www.youtube.com/watch?v=ar0vFMoMtrI)
+* [Packages, Bit Sets, cstring](https://youtu.be/b8bJbjiXZrQ)
+	- [Q&A](https://youtu.be/5jmxyIfyyTk)
 

bin/CODE_OWNERS.TXT

@@ -1,200 +0,0 @@
-This file is a list of the people responsible for ensuring that patches for a
-particular part of LLVM are reviewed, either by themself or by someone else.
-They are also the gatekeepers for their part of LLVM, with the final word on
-what goes in or not.
-
-The list is sorted by surname and formatted to allow easy grepping and
-beautification by scripts.  The fields are: name (N), email (E), web-address
-(W), PGP key ID and fingerprint (P), description (D), and snail-mail address
-(S). Each entry should contain at least the (N), (E) and (D) fields.
-
-N: Joe Abbey
-E: jabbey@arxan.com
-D: LLVM Bitcode (lib/Bitcode/* include/llvm/Bitcode/*)
-
-N: Owen Anderson
-E: resistor@mac.com
-D: SelectionDAG (lib/CodeGen/SelectionDAG/*)
-
-N: Rafael Avila de Espindola
-E: rafael.espindola@gmail.com
-D: Gold plugin (tools/gold/*)
-
-N: Justin Bogner
-E: mail@justinbogner.com
-D: InstrProfiling and related parts of ProfileData
-
-N: Chandler Carruth
-E: chandlerc@gmail.com
-E: chandlerc@google.com
-D: Config, ADT, Support, inlining & related passes, SROA/mem2reg & related passes, CMake, library layering
-
-N: Evan Cheng
-E: evan.cheng@apple.com
-D: parts of code generator not covered by someone else
-
-N: Eric Christopher
-E: echristo@gmail.com
-D: Debug Information, autotools/configure/make build, inline assembly
-
-N: Greg Clayton
-E: gclayton@apple.com
-D: LLDB
-
-N: Marshall Clow
-E: mclow.lists@gmail.com
-D: libc++
-
-N: Peter Collingbourne
-E: peter@pcc.me.uk
-D: llgo
-
-N: Quentin Colombet
-E: qcolombet@apple.com
-D: Register allocators
-
-N: Duncan P. N. Exon Smith
-E: dexonsmith@apple.com
-D: Branch weights and BlockFrequencyInfo
-
-N: Hal Finkel
-E: hfinkel@anl.gov
-D: BBVectorize, the loop reroller, alias analysis and the PowerPC target
-
-N: Dan Gohman
-E: sunfish@mozilla.com
-D: WebAssembly Backend (lib/Target/WebAssembly/*)
-
-N: Renato Golin
-E: renato.golin@linaro.org
-D: ARM Linux support
-
-N: Venkatraman Govindaraju
-E: venkatra@cs.wisc.edu
-D: Sparc Backend (lib/Target/Sparc/*)
-
-N: Tobias Grosser
-E: tobias@grosser.es
-D: Polly
-
-N: James Grosbach
-E: grosbach@apple.com
-D: MC layer
-
-N: Justin Holewinski
-E: jholewinski@nvidia.com
-D: NVPTX Target (lib/Target/NVPTX/*)
-
-N: Lang Hames
-E: lhames@gmail.com
-D: MCJIT, RuntimeDyld and JIT event listeners
-
-N: Galina Kistanova
-E: gkistanova@gmail.com
-D: LLVM Buildbot
-
-N: Anton Korobeynikov
-E: anton@korobeynikov.info
-D: Exception handling, Windows codegen, ARM EABI
-
-N: Benjamin Kramer
-E: benny.kra@gmail.com
-D: DWARF Parser
-
-N: Sergei Larin
-E: slarin@codeaurora.org
-D: VLIW Instruction Scheduling, Packetization
-
-N: Chris Lattner
-E: sabre@nondot.org
-W: http://nondot.org/~sabre/
-D: Everything not covered by someone else
-
-N: David Majnemer
-E: david.majnemer@gmail.com
-D: IR Constant Folder, InstCombine
-
-N: Dylan McKay
-E: dylanmckay34@gmail.com
-D: AVR Backend
-
-N: Tim Northover
-E: t.p.northover@gmail.com
-D: AArch64 backend, misc ARM backend
-
-N: Diego Novillo
-E: dnovillo@google.com
-D: SampleProfile and related parts of ProfileData
-
-N: Jakob Olesen
-E: stoklund@2pi.dk
-D: TableGen
-
-N: Richard Osborne
-E: richard@xmos.com
-D: XCore Backend
-
-N: Krzysztof Parzyszek
-E: kparzysz@codeaurora.org
-D: Hexagon Backend
-
-N: Paul Robinson
-E: paul_robinson@playstation.sony.com
-D: Sony PlayStation®4 support
-
-N: Chad Rosier
-E: mcrosier@codeaurora.org
-D: Fast-Isel
-
-N: Nadav Rotem
-E: nrotem@apple.com
-D: X86 Backend, Loop Vectorizer
-
-N: Daniel Sanders
-E: daniel.sanders@imgtec.com
-D: MIPS Backend (lib/Target/Mips/*)
-
-N: Duncan Sands
-E: baldrick@free.fr
-D: DragonEgg
-
-N: Kostya Serebryany
-E: kcc@google.com
-D: AddressSanitizer, ThreadSanitizer (LLVM parts)
-
-N: Michael Spencer
-E: bigcheesegs@gmail.com
-D: Windows parts of Support, Object, ar, nm, objdump, ranlib, size
-
-N: Alexei Starovoitov
-E: alexei.starovoitov@gmail.com
-D: BPF backend
-
-N: Tom Stellard
-E: thomas.stellard@amd.com
-E: mesa-dev@lists.freedesktop.org
-D: Release manager for the 3.5 and 3.6 branches, R600 Backend, libclc
-
-N: Evgeniy Stepanov
-E: eugenis@google.com
-D: MemorySanitizer (LLVM part)
-
-N: Andrew Trick
-E: atrick@apple.com
-D: IndVar Simplify, Loop Strength Reduction, Instruction Scheduling
-
-N: Ulrich Weigand
-E: uweigand@de.ibm.com
-D: SystemZ Backend
-
-N: Bill Wendling
-E: isanbard@gmail.com
-D: libLTO, IR Linker
-
-N: Peter Zotov
-E: whitequark@whitequark.org
-D: OCaml bindings
-
-N: Andrey Churbanov
-E: andrey.churbanov@intel.com
-D: OpenMP runtime library

bin/CREDITS.TXT

@@ -1,467 +0,0 @@
-This file is a partial list of people who have contributed to the LLVM
-project.  If you have contributed a patch or made some other contribution to
-LLVM, please submit a patch to this file to add yourself, and it will be
-done!
-
-The list is sorted by surname and formatted to allow easy grepping and
-beautification by scripts.  The fields are: name (N), email (E), web-address
-(W), PGP key ID and fingerprint (P), description (D), snail-mail address
-(S), and (I) IRC handle.
-
-
-N: Vikram Adve
-E: vadve@cs.uiuc.edu
-W: http://www.cs.uiuc.edu/~vadve/
-D: The Sparc64 backend, provider of much wisdom, and motivator for LLVM
-
-N: Owen Anderson
-E: resistor@mac.com
-D: LCSSA pass and related LoopUnswitch work
-D: GVNPRE pass, DataLayout refactoring, random improvements
-
-N: Henrik Bach
-D: MingW Win32 API portability layer
-
-N: Aaron Ballman
-E: aaron@aaronballman.com
-D: __declspec attributes, Windows support, general bug fixing
-
-N: Nate Begeman
-E: natebegeman@mac.com
-D: PowerPC backend developer
-D: Target-independent code generator and analysis improvements
-
-N: Daniel Berlin
-E: dberlin@dberlin.org
-D: ET-Forest implementation.
-D: Sparse bitmap
-
-N: David Blaikie
-E: dblaikie@gmail.com
-D: General bug fixing/fit & finish, mostly in Clang
-
-N: Neil Booth
-E: neil@daikokuya.co.uk
-D: APFloat implementation.
-
-N: Misha Brukman
-E: brukman+llvm@uiuc.edu
-W: http://misha.brukman.net
-D: Portions of X86 and Sparc JIT compilers, PowerPC backend
-D: Incremental bitcode loader
-
-N: Cameron Buschardt
-E: buschard@uiuc.edu
-D: The `mem2reg' pass - promotes values stored in memory to registers
-
-N: Brendon Cahoon
-E: bcahoon@codeaurora.org
-D: Loop unrolling with run-time trip counts.
-
-N: Chandler Carruth
-E: chandlerc@gmail.com
-E: chandlerc@google.com
-D: Hashing algorithms and interfaces
-D: Inline cost analysis
-D: Machine block placement pass
-D: SROA
-
-N: Casey Carter
-E: ccarter@uiuc.edu
-D: Fixes to the Reassociation pass, various improvement patches
-
-N: Evan Cheng
-E: evan.cheng@apple.com
-D: ARM and X86 backends
-D: Instruction scheduler improvements
-D: Register allocator improvements
-D: Loop optimizer improvements
-D: Target-independent code generator improvements
-
-N: Dan Villiom Podlaski Christiansen
-E: danchr@gmail.com
-E: danchr@cs.au.dk
-W: http://villiom.dk
-D: LLVM Makefile improvements
-D: Clang diagnostic & driver tweaks
-S: Aarhus, Denmark
-
-N: Jeff Cohen
-E: jeffc@jolt-lang.org
-W: http://jolt-lang.org
-D: Native Win32 API portability layer
-
-N: John T. Criswell
-E: criswell@uiuc.edu
-D: Original Autoconf support, documentation improvements, bug fixes
-
-N: Anshuman Dasgupta
-E: adasgupt@codeaurora.org
-D: Deterministic finite automaton based infrastructure for VLIW packetization
-
-N: Stefanus Du Toit
-E: stefanus.du.toit@intel.com
-D: Bug fixes and minor improvements
-
-N: Rafael Avila de Espindola
-E: rafael.espindola@gmail.com
-D: The ARM backend
-
-N: Dave Estes
-E: cestes@codeaurora.org
-D: AArch64 machine description for Cortex-A53
-
-N: Alkis Evlogimenos
-E: alkis@evlogimenos.com
-D: Linear scan register allocator, many codegen improvements, Java frontend
-
-N: Hal Finkel
-E: hfinkel@anl.gov
-D: Basic-block autovectorization, PowerPC backend improvements
-
-N: Eric Fiselier
-E: eric@efcs.ca
-D: LIT patches and documentation.
-
-N: Ryan Flynn
-E: pizza@parseerror.com
-D: Miscellaneous bug fixes
-
-N: Brian Gaeke
-E: gaeke@uiuc.edu
-W: http://www.students.uiuc.edu/~gaeke/
-D: Portions of X86 static and JIT compilers; initial SparcV8 backend
-D: Dynamic trace optimizer
-D: FreeBSD/X86 compatibility fixes, the llvm-nm tool
-
-N: Nicolas Geoffray
-E: nicolas.geoffray@lip6.fr
-W: http://www-src.lip6.fr/homepages/Nicolas.Geoffray/
-D: PPC backend fixes for Linux
-
-N: Louis Gerbarg
-E: lgg@apple.com
-D: Portions of the PowerPC backend
-
-N: Saem Ghani
-E: saemghani@gmail.com
-D: Callgraph class cleanups
-
-N: Mikhail Glushenkov
-E: foldr@codedgers.com
-D: Author of llvmc2
-
-N: Dan Gohman
-E: sunfish@mozilla.com
-D: Miscellaneous bug fixes
-D: WebAssembly Backend
-
-N: David Goodwin
-E: david@goodwinz.net
-D: Thumb-2 code generator
-
-N: David Greene
-E: greened@obbligato.org
-D: Miscellaneous bug fixes
-D: Register allocation refactoring
-
-N: Gabor Greif
-E: ggreif@gmail.com
-D: Improvements for space efficiency
-
-N: James Grosbach
-E: grosbach@apple.com
-I: grosbach
-D: SjLj exception handling support
-D: General fixes and improvements for the ARM back-end
-D: MCJIT
-D: ARM integrated assembler and assembly parser
-D: Led effort for the backend formerly known as ARM64
-
-N: Lang Hames
-E: lhames@gmail.com
-D: PBQP-based register allocator
-
-N: Gordon Henriksen
-E: gordonhenriksen@mac.com
-D: Pluggable GC support
-D: C interface
-D: Ocaml bindings
-
-N: Raul Fernandes Herbster
-E: raul@dsc.ufcg.edu.br
-D: JIT support for ARM
-
-N: Paolo Invernizzi
-E: arathorn@fastwebnet.it
-D: Visual C++ compatibility fixes
-
-N: Patrick Jenkins
-E: patjenk@wam.umd.edu
-D: Nightly Tester
-
-N: Dale Johannesen
-E: dalej@apple.com
-D: ARM constant islands improvements
-D: Tail merging improvements
-D: Rewrite X87 back end
-D: Use APFloat for floating point constants widely throughout compiler
-D: Implement X87 long double
-
-N: Brad Jones
-E: kungfoomaster@nondot.org
-D: Support for packed types
-
-N: Rod Kay
-E: rkay@auroraux.org
-D: Author of LLVM Ada bindings
-
-N: Eric Kidd
-W: http://randomhacks.net/
-D: llvm-config script
-
-N: Anton Korobeynikov
-E: asl@math.spbu.ru
-D: Mingw32 fixes, cross-compiling support, stdcall/fastcall calling conv.
-D: x86/linux PIC codegen, aliases, regparm/visibility attributes
-D: Switch lowering refactoring
-
-N: Sumant Kowshik
-E: kowshik@uiuc.edu
-D: Author of the original C backend
-
-N: Benjamin Kramer
-E: benny.kra@gmail.com
-D: Miscellaneous bug fixes
-
-N: Sundeep Kushwaha
-E: sundeepk@codeaurora.org
-D: Implemented DFA-based target independent VLIW packetizer
-
-N: Christopher Lamb
-E: christopher.lamb@gmail.com
-D: aligned load/store support, parts of noalias and restrict support
-D: vreg subreg infrastructure, X86 codegen improvements based on subregs
-D: address spaces
-
-N: Jim Laskey
-E: jlaskey@apple.com
-D: Improvements to the PPC backend, instruction scheduling
-D: Debug and Dwarf implementation
-D: Auto upgrade mangler
-D: llvm-gcc4 svn wrangler
-
-N: Chris Lattner
-E: sabre@nondot.org
-W: http://nondot.org/~sabre/
-D: Primary architect of LLVM
-
-N: Tanya Lattner (Tanya Brethour)
-E: tonic@nondot.org
-W: http://nondot.org/~tonic/
-D: The initial llvm-ar tool, converted regression testsuite to dejagnu
-D: Modulo scheduling in the SparcV9 backend
-D: Release manager (1.7+)
-
-N: Sylvestre Ledru
-E: sylvestre@debian.org
-W: http://sylvestre.ledru.info/
-W: http://llvm.org/apt/
-D: Debian and Ubuntu packaging
-D: Continuous integration with jenkins
-
-N: Andrew Lenharth
-E: alenhar2@cs.uiuc.edu
-W: http://www.lenharth.org/~andrewl/
-D: Alpha backend
-D: Sampling based profiling
-
-N: Nick Lewycky
-E: nicholas@mxc.ca
-D: PredicateSimplifier pass
-
-N: Tony Linthicum, et. al.
-E: tlinth@codeaurora.org
-D: Backend for Qualcomm's Hexagon VLIW processor.
-
-N: Bruno Cardoso Lopes
-E: bruno.cardoso@gmail.com
-I: bruno
-W: http://brunocardoso.cc
-D: Mips backend
-D: Random ARM integrated assembler and assembly parser improvements
-D: General X86 AVX1 support
-
-N: Duraid Madina
-E: duraid@octopus.com.au
-W: http://kinoko.c.u-tokyo.ac.jp/~duraid/
-D: IA64 backend, BigBlock register allocator
-
-N: John McCall
-E: rjmccall@apple.com
-D: Clang semantic analysis and IR generation
-
-N: Michael McCracken
-E: michael.mccracken@gmail.com
-D: Line number support for llvmgcc
-
-N: Vladimir Merzliakov
-E: wanderer@rsu.ru
-D: Test suite fixes for FreeBSD
-
-N: Scott Michel
-E: scottm@aero.org
-D: Added STI Cell SPU backend.
-
-N: Kai Nacke
-E: kai@redstar.de
-D: Support for implicit TLS model used with MS VC runtime
-D: Dumping of Win64 EH structures
-
-N: Takumi Nakamura
-E: geek4civic@gmail.com
-E: chapuni@hf.rim.or.jp
-D: Cygwin and MinGW support.
-D: Win32 tweaks.
-S: Yokohama, Japan
-
-N: Edward O'Callaghan
-E: eocallaghan@auroraux.org
-W: http://www.auroraux.org
-D: Add Clang support with various other improvements to utils/NewNightlyTest.pl
-D: Fix and maintain Solaris & AuroraUX support for llvm, various build warnings
-D: and error clean ups.
-
-N: Morten Ofstad
-E: morten@hue.no
-D: Visual C++ compatibility fixes
-
-N: Jakob Stoklund Olesen
-E: stoklund@2pi.dk
-D: Machine code verifier
-D: Blackfin backend
-D: Fast register allocator
-D: Greedy register allocator
-
-N: Richard Osborne
-E: richard@xmos.com
-D: XCore backend
-
-N: Devang Patel
-E: dpatel@apple.com
-D: LTO tool, PassManager rewrite, Loop Pass Manager, Loop Rotate
-D: GCC PCH Integration (llvm-gcc), llvm-gcc improvements
-D: Optimizer improvements, Loop Index Split
-
-N: Ana Pazos
-E: apazos@codeaurora.org
-D: Fixes and improvements to the AArch64 backend
-
-N: Wesley Peck
-E: peckw@wesleypeck.com
-W: http://wesleypeck.com/
-D: MicroBlaze backend
-
-N: Francois Pichet
-E: pichet2000@gmail.com
-D: MSVC support
-
-N: Vladimir Prus
-W: http://vladimir_prus.blogspot.com
-E: ghost@cs.msu.su
-D: Made inst_iterator behave like a proper iterator, LowerConstantExprs pass
-
-N: Kalle Raiskila
-E: kalle.rasikila@nokia.com
-D: Some bugfixes to CellSPU
-
-N: Xerxes Ranby
-E: xerxes@zafena.se
-D: Cmake dependency chain and various bug fixes
-
-N: Alex Rosenberg
-E: alexr@leftfield.org
-I: arosenberg
-D: ARM calling conventions rewrite, hard float support
-
-N: Chad Rosier
-E: mcrosier@codeaurora.org
-I: mcrosier
-D: AArch64 fast instruction selection pass
-D: Fixes and improvements to the ARM fast-isel pass
-D: Fixes and improvements to the AArch64 backend
-
-N: Nadav Rotem
-E: nrotem@apple.com
-D: X86 code generation improvements, Loop Vectorizer.
-
-N: Roman Samoilov
-E: roman@codedgers.com
-D: MSIL backend
-
-N: Duncan Sands
-E: baldrick@free.fr
-I: baldrick
-D: Ada support in llvm-gcc
-D: Dragonegg plugin
-D: Exception handling improvements
-D: Type legalizer rewrite
-
-N: Ruchira Sasanka
-E: sasanka@uiuc.edu
-D: Graph coloring register allocator for the Sparc64 backend
-
-N: Arnold Schwaighofer
-E: arnold.schwaighofer@gmail.com
-D: Tail call optimization for the x86 backend
-
-N: Shantonu Sen
-E: ssen@apple.com
-D: Miscellaneous bug fixes
-
-N: Anand Shukla
-E: ashukla@cs.uiuc.edu
-D: The `paths' pass
-
-N: Michael J. Spencer
-E: bigcheesegs@gmail.com
-D: Shepherding Windows COFF support into MC.
-D: Lots of Windows stuff.
-
-N: Reid Spencer
-E: rspencer@reidspencer.com
-W: http://reidspencer.com/
-D: Lots of stuff, see: http://wiki.llvm.org/index.php/User:Reid
-
-N: Alp Toker
-E: alp@nuanti.com
-W: http://atoker.com/
-D: C++ frontend next generation standards implementation
-
-N: Craig Topper
-E: craig.topper@gmail.com
-D: X86 codegen and disassembler improvements. AVX2 support.
-
-N: Edwin Torok
-E: edwintorok@gmail.com
-D: Miscellaneous bug fixes
-
-N: Adam Treat
-E: manyoso@yahoo.com
-D: C++ bugs filed, and C++ front-end bug fixes.
-
-N: Lauro Ramos Venancio
-E: lauro.venancio@indt.org.br
-D: ARM backend improvements
-D: Thread Local Storage implementation
-
-N: Bill Wendling
-I: wendling
-E: isanbard@gmail.com
-D: Release manager, IR Linker, LTO
-D: Bunches of stuff
-
-N: Bob Wilson
-E: bob.wilson@acm.org
-D: Advanced SIMD (NEON) support in the ARM backend.
-

bin/LICENSE.TXT

@@ -1,70 +0,0 @@
-==============================================================================
-LLVM Release License
-==============================================================================
-University of Illinois/NCSA
-Open Source License
-
-Copyright (c) 2003-2015 University of Illinois at Urbana-Champaign.
-All rights reserved.
-
-Developed by:
-
-    LLVM Team
-
-    University of Illinois at Urbana-Champaign
-
-    http://llvm.org
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal with
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimers.
-
-    * Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimers in the
-      documentation and/or other materials provided with the distribution.
-
-    * Neither the names of the LLVM Team, University of Illinois at
-      Urbana-Champaign, nor the names of its contributors may be used to
-      endorse or promote products derived from this Software without specific
-      prior written permission.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-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 WITH THE
-SOFTWARE.
-
-==============================================================================
-Copyrights and Licenses for Third Party Software Distributed with LLVM:
-==============================================================================
-The LLVM software contains code written by third parties.  Such software will
-have its own individual LICENSE.TXT file in the directory in which it appears.
-This file will describe the copyrights, license, and restrictions which apply
-to that code.
-
-The disclaimer of warranty in the University of Illinois Open Source License
-applies to all code in the LLVM Distribution, and nothing in any of the
-other licenses gives permission to use the names of the LLVM Team or the
-University of Illinois to endorse or promote products derived from this
-Software.
-
-The following pieces of software have additional or alternate copyrights,
-licenses, and/or restrictions:
-
-Program             Directory
--------             ---------
-Autoconf            llvm/autoconf
-                    llvm/projects/ModuleMaker/autoconf
-Google Test         llvm/utils/unittest/googletest
-OpenBSD regex       llvm/lib/Support/{reg*, COPYRIGHT.regex}
-pyyaml tests        llvm/test/YAMLParser/{*.data, LICENSE.TXT}
-ARM contributions   llvm/lib/Target/ARM/LICENSE.TXT
-md5 contributions   llvm/lib/Support/MD5.cpp llvm/include/llvm/Support/MD5.h

bin/README.md

@@ -0,0 +1,30 @@
+# The Odin Programming Language
+
+## Setup
+
+Odin only supports x86-64 at the moment (64-bit), relies on LLVM for code generation and an external linker.
+
+In addition, the following platform-specific steps are necessary:
+
+- Windows
+    * Have Visual Studio installed (MSVC 2010 or later, for the linker)
+    * Have a copy of `opt.exe` and `llc.exe` in `Odin/bin`. Pre-built Windows binaries can be found [here](https://github.com/odin-lang/Odin/releases/tag/llvm-windows) and *must* be explicitly copied
+    * Open a valid command prompt:
+        * **Basic:** run the `x64 Native Tools Command Prompt for VS2017` shortcut bundled with VS 2017, or
+        * **Advanced:** run `vcvarsall.bat x64` from a blank `cmd` session
+
+- MacOS
+    * Have LLVM explicitly installed (`brew install llvm`)
+    * Have XCode installed (version X.X or later, for linking)
+    * Make sure the LLVM binaries and the linker are added to your `$PATH` environmental variable
+
+- GNU/Linux
+    * Have LLVM installed (opt/llc)
+    * Have Clang installed (version X.X or later, for linking)
+    * Make sure the LLVM binaries and the linker are added to your `$PATH` environmental variable
+
+Then build the compiler by calling `build.bat` (Windows) or `make` (Linux/MacOS). This will automatically run the demo program if successful.
+
+**Notes for Linux:**: The compiler currently relies on the `core` and `shared` library collection being relative to the compiler executable. Installing the compiler in the usual sense (to `/usr/local/bin` or similar) is therefore not as straight forward as you need to make sure the mentioned libraries are available. As a result, it is recommended to simply explicitly invoke the compiler with `/path/to/odin` in your preferred build system, or add `/path/to/odin` to `$PATH`.
+
+Please read the [Getting Started Guide](https://github.com/odin-lang/Odin/wiki#getting-started-with-odin) for more information.

build-m1.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+
+release_mode=$1
+
+warnings_to_disable="-std=c++11 -Wno-switch"
+
+libraries="-pthread -ldl -lm -lstdc++ -lz -lcurses -lxml2"
+other_args="-DLLVM_BACKEND_SUPPORT"
+compiler="clang"
+
+if [ -z "$release_mode" ]; then release_mode="0"; fi
+
+if [ "$release_mode" -eq "0" ]; then
+	other_args="${other_args} -g"
+fi
+if [ "$release_mode" -eq "1" ]; then
+	other_args="${other_args} -O3 -march=native"
+fi
+
+if [[ "$(uname)" == "Darwin" ]]; then
+
+	# Set compiler to clang on MacOS
+	# MacOS provides a symlink to clang called gcc, but it's nice to be explicit here.
+	compiler="clang"
+
+	llvm_config_flags="--cxxflags --ldflags"
+	# llvm_config_flags="${llvm_config_flags} --link-static"
+	llvm_config="llvm-config ${llvm_config_flags}"
+
+	other_args="${other_args} -liconv"
+	other_args="${other_args} `${llvm_config}` -lLLVM-C"
+elif [[ "$(uname)" == "FreeBSD" ]]; then
+	compiler="clang"
+fi
+
+${compiler} src/main.cpp ${warnings_to_disable} ${libraries} ${other_args} -o odin
+	# && ./odin run examples/demo/demo.odin -llvm-api

build.bat

@@ -4,29 +4,46 @@
 set exe_name=odin.exe
 
 :: Debug = 0, Release = 1
-set release_mode=1
+if "%1" == "1" (
+	set release_mode=1
+) else if "%1" == "release" (
+	set release_mode=1
+) else (
+	set release_mode=0
+)
 
-set compiler_flags= -nologo -Oi -TC -fp:fast -fp:except- -Gm- -MP -FC -GS- -EHsc- -GR-
+:: Normal = 0, CI Nightly = 1
+if "%2" == "1" (
+    set nightly=1
+) else (
+    set nightly=0
+)
+
+set compiler_flags= -nologo -Oi -TP -fp:precise -Gm- -MP -FC -EHsc- -GR- -GF
+set compiler_defines= -DLLVM_BACKEND_SUPPORT -DUSE_NEW_LLVM_ABI_SYSTEM
+
+for /f %%i in ('git rev-parse --short HEAD') do set GIT_SHA=%%i
+if %ERRORLEVEL% equ 0 set compiler_defines=%compiler_defines% -DGIT_SHA=\"%GIT_SHA%\"
+if %nightly% equ 1 set compiler_defines=%compiler_defines% -DNIGHTLY
 
 if %release_mode% EQU 0 ( rem Debug
 	set compiler_flags=%compiler_flags% -Od -MDd -Z7
-	rem -DDISPLAY_TIMING
 ) else ( rem Release
 	set compiler_flags=%compiler_flags% -O2 -MT -Z7
+	set compiler_defines=%compiler_defines% -DNO_ARRAY_BOUNDS_CHECK
 )
 
 set compiler_warnings= ^
 	-W4 -WX ^
 	-wd4100 -wd4101 -wd4127 -wd4189 ^
-	-wd4201 -wd4204 -wd4244 ^
-	-wd4306 ^
+	-wd4201 -wd4204 ^
 	-wd4456 -wd4457 -wd4480 ^
-	-wd4505 -wd4512 -wd4550
+	-wd4512
 
 set compiler_includes=
 set libs= ^
-	kernel32.lib
-	rem "src\dyncall\lib\*.lib"
+	kernel32.lib ^
+	bin\llvm\windows\LLVM-C.lib
 
 set linker_flags= -incremental:no -opt:ref -subsystem:console
 
@@ -36,18 +53,17 @@ if %release_mode% EQU 0 ( rem Debug
 	set linker_flags=%linker_flags% -debug
 )
 
-set compiler_settings=%compiler_includes% %compiler_flags% %compiler_warnings%
+set compiler_settings=%compiler_includes% %compiler_flags% %compiler_warnings% %compiler_defines%
 set linker_settings=%libs% %linker_flags%
 
-
 del *.pdb > NUL 2> NUL
 del *.ilk > NUL 2> NUL
 
-cl %compiler_settings% "src\main.c" ^
-	/link %linker_settings% -OUT:%exe_name% ^
-	&& odin run code/demo.odin
-	rem && odin build_dll code/example.odin ^
-	rem && odin run code/demo.odin
+cl %compiler_settings% "src\main.cpp" /link %linker_settings% -OUT:%exe_name%
+
+if %errorlevel% neq 0 goto end_of_build
+if %release_mode% EQU 0 odin run examples/demo/demo.odin
+
+del *.obj > NUL 2> NUL
 
 :end_of_build
-

build.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+release_mode=$1
+
+warnings_to_disable="-std=c++11 -Wno-switch -Wno-pointer-sign -Wno-tautological-constant-out-of-range-compare -Wno-tautological-compare -Wno-macro-redefined"
+libraries="-pthread -ldl -lm -lstdc++"
+other_args=""
+compiler="clang"
+
+if [ -z "$release_mode" ]; then release_mode="0"; fi
+
+if [ "$release_mode" -eq "0" ]; then
+	other_args="${other_args} -g"
+fi
+if [ "$release_mode" -eq "1" ]; then
+	other_args="${other_args} -O3 -march=native"
+fi
+
+if [[ "$(uname)" == "Darwin" ]]; then
+
+	# Set compiler to clang on MacOS
+	# MacOS provides a symlink to clang called gcc, but it's nice to be explicit here.
+	compiler="clang"
+
+	other_args="${other_args} -liconv"
+elif [[ "$(uname)" == "FreeBSD" ]]; then
+	compiler="clang"
+fi
+
+${compiler} src/main.cpp ${warnings_to_disable} ${libraries} ${other_args} -o odin && ./odin run examples/demo/demo.odin

ci/create_nightly_json.py

@@ -0,0 +1,51 @@
+import subprocess
+import sys
+import json
+import datetime
+import urllib.parse
+import sys
+
+def main():
+    files_by_date = {}
+    bucket = sys.argv[1]
+
+    files_lines = execute_cli(f"b2 ls --long {bucket} nightly").split("\n")
+    for x in files_lines:
+        parts = x.split(" ", 1)
+        if parts[0]:
+            json_str = execute_cli(f"b2 get-file-info {parts[0]}")
+            data = json.loads(json_str)
+            name = remove_prefix(data['fileName'], "nightly/")
+            url = f"https://f001.backblazeb2.com/file/{bucket}/nightly/{urllib.parse.quote_plus(name)}"
+            sha1 = data['contentSha1']
+            size = int(data['contentLength'])
+            ts = int(data['fileInfo']['src_last_modified_millis'])
+            date = datetime.datetime.fromtimestamp(ts/1000).strftime('%Y-%m-%d')
+            
+            if date not in files_by_date.keys():
+                files_by_date[date] = []
+
+            files_by_date[date].append({
+                                            'name': name,
+                                            'url': url,
+                                            'sha1': sha1,
+                                            'sizeInBytes': size,
+                                         })
+
+    now = datetime.datetime.utcnow().isoformat()
+
+    print(json.dumps({
+                        'last_updated' : now,
+                        'files': files_by_date
+                     }, sort_keys=True, indent=4))
+
+def remove_prefix(text, prefix):
+    return text[text.startswith(prefix) and len(prefix):]
+
+def execute_cli(command):
+    sb = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)
+    return sb.stdout.read().decode("utf-8");
+
+if __name__ == '__main__':
+    sys.exit(main())
+

ci/delete_old_binaries.py

@@ -0,0 +1,34 @@
+import subprocess
+import sys
+import json
+import datetime
+import urllib.parse
+import sys
+
+def main():
+    files_by_date = {}
+    bucket = sys.argv[1]
+    days_to_keep = int(sys.argv[2])
+    print(f"Looking for binaries to delete older than {days_to_keep} days")
+
+    files_lines = execute_cli(f"b2 ls --long --versions {bucket} nightly").split("\n")
+    for x in files_lines:
+        parts = [y for y in x.split(' ') if y]
+
+        if parts and parts[0]:
+            date = datetime.datetime.strptime(parts[2], '%Y-%m-%d').replace(hour=0, minute=0, second=0, microsecond=0)
+            now = datetime.datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0)
+            delta = now - date
+
+            if delta.days > days_to_keep:
+                print(f'Deleting {parts[5]}')
+                execute_cli(f'b2 delete-file-version {parts[0]}')
+
+
+def execute_cli(command):
+    sb = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)
+    return sb.stdout.read().decode("utf-8");
+
+if __name__ == '__main__':
+    sys.exit(main())
+

ci/upload_create_nightly.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+bucket=$1
+platform=$2
+artifact=$3
+
+now=$(date +'%Y-%m-%d')
+filename="odin-$platform-nightly+$now.zip"
+
+echo "Creating archive $filename from $artifact and uploading to $bucket"
+
+7z a -bd "output/$filename" -r "$artifact"
+b2 upload-file --noProgress "$bucket" "output/$filename" "nightly/$filename"

code/demo.odin

@@ -1,60 +0,0 @@
-#import "fmt.odin";
-
-
-
-main :: proc() {
-	{
-		Byte_Size :: enum f64 {
-			_, // Ignore first value
-			KB = 1<<(10*iota),
-			MB,
-			GB,
-			TB,
-			PB,
-		}
-
-		using Byte_Size;
-		fmt.println(KB, MB, GB, TB, PB);
-	}
-	{
-		x := if 1 < 2 {
-			y := 123;
-			give y-2;
-		} else {
-			give 0;
-		};
-
-		x += {
-			x := 2;
-			give x;
-		};
-
-		fmt.println("x =", x);
-	}
-	{
-		list := []int{1, 4, 7, 3, 7, 2, 1};
-		for value : list {
-			fmt.println(value);
-		}
-		for val, idx : 12 ..< 17 {
-			fmt.println(val, idx);
-		}
-		msg := "Hellope";
-		for value : msg {
-			fmt.println(value);
-		}
-	}
-	{
-		i := 0;
-		while i < 2 {
-			i += 1;
-		}
-
-		// Idiom to emulate C-style for loops
-		while x := 0; x < 2 {
-			defer x += 1;
-			// Body of code
-			// ++ and -- have been removed
-		}
-	}
-}

code/game.odin

@@ -1,215 +0,0 @@
-#import "win32.odin" when ODIN_OS == "windows";
-#import "fmt.odin";
-#import "math.odin";
-#import "os.odin";
-#import gl "opengl.odin";
-
-TWO_HEARTS :: '💕';
-
-win32_perf_count_freq := win32.GetQueryPerformanceFrequency();
-time_now :: proc() -> f64 {
-	assert(win32_perf_count_freq != 0);
-
-	counter: i64;
-	win32.QueryPerformanceCounter(^counter);
-	result := counter as f64 / win32_perf_count_freq as f64;
-	return result;
-}
-win32_print_last_error :: proc() {
-	err_code := win32.GetLastError() as int;
-	if err_code != 0 {
-		fmt.println("GetLastError: %", err_code);
-	}
-}
-
-// Yuk!
-to_c_string :: proc(s: string) -> []u8 {
-	c_str := new_slice(u8, s.count+1);
-	copy(c_str, s as []byte);
-	c_str[s.count] = 0;
-	return c_str;
-}
-
-
-Window :: struct {
-	width, height:      int;
-	wc:                 win32.WNDCLASSEXA;
-	dc:                 win32.HDC;
-	hwnd:               win32.HWND;
-	opengl_context, rc: win32.HGLRC;
-	c_title:            []u8;
-}
-
-make_window :: proc(title: string, msg, height: int, window_proc: win32.WNDPROC) -> (Window, bool) {
-	using win32;
-
-	w: Window;
-	w.width, w.height = msg, height;
-
-	class_name := "Win32-Odin-Window\x00";
-	c_class_name := class_name.data;
-	if title[title.count-1] != 0 {
-		w.c_title = to_c_string(title);
-	} else {
-		w.c_title = title as []u8;
-	}
-
-	instance := GetModuleHandleA(nil);
-
-	w.wc = WNDCLASSEXA{
-		size       = size_of(WNDCLASSEXA) as u32,
-		style      = CS_VREDRAW | CS_HREDRAW,
-		instance   = instance as HINSTANCE,
-		class_name = c_class_name,
-		wnd_proc   = window_proc,
-	};
-
-	if RegisterClassExA(^w.wc) == 0 {
-		win32_print_last_error();
-		return w, false;
-	}
-
-	w.hwnd = CreateWindowExA(0,
-	                         c_class_name, w.c_title.data,
-	                         WS_VISIBLE | WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
-	                         CW_USEDEFAULT, CW_USEDEFAULT,
-	                         w.width as i32, w.height as i32,
-	                         nil, nil, instance, nil);
-
-	if w.hwnd == nil {
-		win32_print_last_error();
-		return w, false;
-	}
-
-	w.dc = GetDC(w.hwnd);
-
-	{
-		pfd := PIXELFORMATDESCRIPTOR{
-			size         = size_of(PIXELFORMATDESCRIPTOR) as u32,
-			version      = 1,
-			flags        = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
-			pixel_type   = PFD_TYPE_RGBA,
-			color_bits   = 32,
-			alpha_bits   = 8,
-			depth_bits   = 24,
-			stencil_bits = 8,
-			layer_type   = PFD_MAIN_PLANE,
-		};
-
-		SetPixelFormat(w.dc, ChoosePixelFormat(w.dc, ^pfd), nil);
-		w.opengl_context = wglCreateContext(w.dc);
-		wglMakeCurrent(w.dc, w.opengl_context);
-
-		attribs := [8]i32{
-			WGL_CONTEXT_MAJOR_VERSION_ARB, 2,
-			WGL_CONTEXT_MINOR_VERSION_ARB, 1,
-			WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
-			0, // NOTE(bill): tells the proc that this is the end of attribs
-		};
-
-		wglCreateContextAttribsARB := wglGetProcAddress(("wglCreateContextAttribsARB\x00" as string).data) as wglCreateContextAttribsARBType;
-		w.rc = wglCreateContextAttribsARB(w.dc, 0, ^attribs[0]);
-		wglMakeCurrent(w.dc, w.rc);
-		SwapBuffers(w.dc);
-	}
-
-	return w, true;
-}
-
-destroy_window :: proc(w: ^Window) {
-	free(w.c_title.data);
-}
-
-display_window :: proc(w: ^Window) {
-	win32.SwapBuffers(w.dc);
-}
-
-
-run :: proc() {
-	using win32;
-	using math;
-
-	win32_proc :: proc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT #no_inline {
-		if msg == WM_DESTROY || msg == WM_CLOSE || msg == WM_QUIT {
-			os.exit(0);
-			return 0;
-		}
-		return DefWindowProcA(hwnd, msg, wparam, lparam);
-	}
-
-	window, window_success := make_window("Odin Language Demo", 854, 480, win32_proc);
-	if !window_success {
-		return;
-	}
-	defer destroy_window(^window);
-
-	gl.init();
-
-
-	prev_time := time_now();
-	running := true;
-
-	pos := Vec2{100, 100};
-
-	for running {
-		curr_time := time_now();
-		dt := (curr_time - prev_time) as f32;
-		prev_time = curr_time;
-
-		msg: MSG;
-		for PeekMessageA(^msg, nil, 0, 0, PM_REMOVE) > 0 {
-			if msg.message == WM_QUIT {
-				running = false;
-			}
-			TranslateMessage(^msg);
-			DispatchMessageA(^msg);
-		}
-
-		if is_key_down(Key_Code.ESCAPE) {
-			running = false;
-		}
-
-		{
-			SPEED :: 500;
-			v: Vec2;
-
-			if is_key_down(Key_Code.RIGHT) { v[0] += 1; }
-			if is_key_down(Key_Code.LEFT)  { v[0] -= 1; }
-			if is_key_down(Key_Code.UP)    { v[1] += 1; }
-			if is_key_down(Key_Code.DOWN)  { v[1] -= 1; }
-
-			v = vec2_norm0(v);
-
-			pos += v * Vec2{SPEED * dt};
-		}
-
-
-		gl.ClearColor(0.5, 0.7, 1.0, 1.0);
-		gl.Clear(gl.COLOR_BUFFER_BIT);
-
-		gl.LoadIdentity();
-		gl.Ortho(0, window.width as f64,
-		         0, window.height as f64, 0, 1);
-
-		draw_rect :: proc(x, y, w, h: f32) {
-			gl.Begin(gl.TRIANGLES);
-			defer gl.End();
-
-			gl.Color3f(1, 0, 0); gl.Vertex3f(x,   y,   0);
-			gl.Color3f(0, 1, 0); gl.Vertex3f(x+w, y,   0);
-			gl.Color3f(0, 0, 1); gl.Vertex3f(x+w, y+h, 0);
-
-			gl.Color3f(0, 0, 1); gl.Vertex3f(x+w, y+h, 0);
-			gl.Color3f(1, 1, 0); gl.Vertex3f(x,   y+h, 0);
-			gl.Color3f(1, 0, 0); gl.Vertex3f(x,   y,   0);
-		}
-
-		draw_rect(pos.x, pos.y, 50, 50);
-
-		display_window(^window);
-		ms_to_sleep := (16 - 1000*dt) as i32;
-		if ms_to_sleep > 0 {
-			win32.Sleep(ms_to_sleep);
-		}
-	}
-}

code/http_test.odin

@@ -1,180 +0,0 @@
-#import "fmt.odin"
-
-#foreign_system_library "Ws2_32" when ODIN_OS == "windows"
-
-
-SOCKET :: type uint
-INVALID_SOCKET :: ~(0 as SOCKET)
-
-AF :: enum i32 {
-	UNSPEC    = 0,       // unspecified
-	UNIX      = 1,       // local to host (pipes, portals)
-	INET      = 2,       // internetwork: UDP, TCP, etc.
-	IMPLINK   = 3,       // arpanet imp addresses
-	PUP       = 4,       // pup protocols: e.g. BSP
-	CHAOS     = 5,       // mit CHAOS protocols
-	NS        = 6,       // XEROX NS protocols
-	ISO       = 7,       // ISO protocols
-	OSI       = ISO,     // OSI is ISO
-	ECMA      = 8,       // european computer manufacturers
-	DATAKIT   = 9,       // datakit protocols
-	CCITT     = 10,      // CCITT protocols, X.25 etc
-	SNA       = 11,      // IBM SNA
-	DECnet    = 12,      // DECnet
-	DLI       = 13,      // Direct data link interface
-	LAT       = 14,      // LAT
-	HYLINK    = 15,      // NSC Hyperchannel
-	APPLETALK = 16,      // AppleTalk
-	ROUTE     = 17,      // Internal Routing Protocol
-	LINK      = 18,      // Link layer interface
-	XTP       = 19,      // eXpress Transfer Protocol (no AF)
-	COIP      = 20,      // connection-oriented IP, aka ST II
-	CNT       = 21,      // Computer Network Technology
-	RTIP      = 22,      // Help Identify RTIP packets
-	IPX       = 23,      // Novell Internet Protocol
-	SIP       = 24,      // Simple Internet Protocol
-	PIP       = 25,      // Help Identify PIP packets
-	MAX       = 26,
-}
-
-SOCK_STREAM  :: 1
-SOCKET_ERROR :: -1
-IPPROTO_TCP  :: 6
-AI_PASSIVE   :: 0x0020
-SOMAXCONN    :: 128
-
-SD_RECEIVE :: 0
-SD_SEND    :: 1
-SD_BOTH    :: 2
-
-WSADESCRIPTION_LEN :: 256
-WSASYS_STATUS_LEN  :: 128
-WSADATA :: struct #ordered {
-	version:       i16
-	high_version:  i16
-
-
-// NOTE(bill): This is x64 ordering
-	max_sockets:   u16
-	max_udp_dg:    u16
-	vendor_info:   ^byte
-	description:   [WSADESCRIPTION_LEN+1]byte
-	system_status: [WSASYS_STATUS_LEN+1]byte
-}
-
-addrinfo :: struct #ordered {
-	flags:     i32
-	family:    i32
-	socktype:  i32
-	protocol:  i32
-	addrlen:   uint
-	canonname: ^u8
-	addr:      ^sockaddr
-	next:      ^addrinfo
-}
-
-sockaddr :: struct #ordered {
-	family: u16
-	data:   [14]byte
-}
-
-
-WSAStartup      :: proc(version_requested: i16, data: ^WSADATA) -> i32                             #foreign #dll_import
-WSACleanup      :: proc() -> i32                                                                   #foreign #dll_import
-getaddrinfo     :: proc(node_name, service_name: ^u8, hints: ^addrinfo, result: ^^addrinfo) -> i32 #foreign #dll_import
-freeaddrinfo    :: proc(ai: ^addrinfo)                                                             #foreign #dll_import
-socket          :: proc(af, type_, protocol: i32) -> SOCKET                                        #foreign #dll_import
-closesocket     :: proc(s: SOCKET) -> i32                                                          #foreign #dll_import
-bind            :: proc(s: SOCKET, name: ^sockaddr, name_len: i32) -> i32                          #foreign #dll_import
-listen          :: proc(s: SOCKET, back_log: i32) -> i32                                           #foreign #dll_import
-accept          :: proc(s: SOCKET, addr: ^sockaddr, addr_len: i32) -> SOCKET                       #foreign #dll_import
-recv            :: proc(s: SOCKET, buf: ^byte, len: i32, flags: i32) -> i32                        #foreign #dll_import
-send            :: proc(s: SOCKET, buf: ^byte, len: i32, flags: i32) -> i32                        #foreign #dll_import
-shutdown        :: proc(s: SOCKET, how: i32) -> i32                                                #foreign #dll_import
-WSAGetLastError :: proc() -> i32                                                                   #foreign #dll_import
-
-to_c_string :: proc(s: string) -> ^byte {
-	c_str := new_slice(byte, s.count+1)
-	assert(c_str.data != nil)
-	copy(c_str, s as []byte)
-	c_str[s.count] = 0
-	return c_str.data
-}
-
-run :: proc() {
-	wsa: WSADATA
-	res:  ^addrinfo = nil
-	hints: addrinfo
-	s, client: SOCKET
-
-	if WSAStartup(2 | (2 << 8), ^wsa) != 0 {
-		fmt.println("WSAStartup failed: ", WSAGetLastError())
-		return
-	}
-	defer WSACleanup()
-
-	hints.family   = AF.INET as i32
-	hints.socktype = SOCK_STREAM
-	hints.protocol = IPPROTO_TCP
-	hints.flags    = AI_PASSIVE
-
-	if getaddrinfo(nil, to_c_string("8080"), ^hints, ^res) != 0 {
-		fmt.println("getaddrinfo failed: ", WSAGetLastError())
-		return
-	}
-	defer freeaddrinfo(res)
-
-	s = socket(res.family, res.socktype, res.protocol)
-	if s == INVALID_SOCKET {
-		fmt.println("socket failed: ", WSAGetLastError())
-		return
-	}
-	defer closesocket(s)
-
-	bind(s, res.addr, res.addrlen as i32)
-	listen(s, SOMAXCONN)
-
-	client = accept(s, nil, 0)
-	if client == INVALID_SOCKET {
-		fmt.println("socket failed: ", WSAGetLastError())
-		return
-	}
-	defer closesocket(client)
-
-	html :=
-`HTTP/1.1 200 OK
-Connection: close
-Content-type: text/html
-
-<html>
-<head>
-	<title>Demo Title</title>
-</head>
-<body>
-	<h1 style="color: orange;">Odin Server Demo</h1>
-</body>
-</html>
-`
-
-	buf: [1024]byte
-	for {
-		bytes := recv(client, ^buf[0], buf.count as i32, 0)
-		if bytes > 0 {
-			// fmt.println(buf[:bytes] as string)
-			bytes_sent := send(client, html.data, (html.count-1) as i32, 0)
-			if bytes_sent == SOCKET_ERROR {
-				fmt.println("send failed: ", WSAGetLastError())
-				return
-			}
-			break
-		} else if bytes == 0 {
-			fmt.println("Connection closing...")
-			break
-		} else {
-			fmt.println("recv failed: ", WSAGetLastError())
-			return
-		}
-	}
-
-	shutdown(client, SD_SEND)
-}

code/old_demos/demo002.odin

@@ -1,900 +0,0 @@
-// Demo 002
-#include "basic.odin"
-#include "math.odin"
-// #include "game.odin"
-
-#thread_local tls_int: int
-
-main :: proc() {
-	// Forenotes
-
-	// Semicolons are now optional
-	// Rule for when a semicolon is expected after a statement
-	// - If the next token is not on the same line
-	// - if the next token is a closing brace }
-	// - Otherwise, a semicolon is needed
-	//
-	// Expections:
-	// for, if, match
-	// if x := thing(); x < 123 {}
-	// for i := 0; i < 123; i++ {}
-
-	// Q: Should I use the new rule or go back to the old one without optional semicolons?
-
-
-	// #thread_local - see runtime.odin and above at `tls_int`
-	// #foreign_system_library - see win32.odin
-
-	// struct_compound_literals()
-	// enumerations()
-	// variadic_procedures()
-	// new_builtins()
-	// match_statement()
-	// namespacing()
-	// subtyping()
-	// tagged_unions()
-}
-
-struct_compound_literals :: proc() {
-	Thing :: type struct {
-		id: int
-		x: f32
-		name: string
-	}
-	{
-		t1: Thing
-		t1.id = 1
-
-		t3 := Thing{}
-		t4 := Thing{1, 2, "Fred"}
-		// t5 := Thing{1, 2}
-
-		t6 := Thing{
-			name = "Tom",
-			x    = 23,
-		}
-	}
-}
-
-enumerations :: proc() {
-	{
-		Fruit :: type enum {
-			APPLE,  // 0
-			BANANA, // 1
-			PEAR,   // 2
-		}
-
-		f := Fruit.APPLE
-		// g12: int = Fruit.BANANA
-		g: int = Fruit.BANANA as int
-		// However, you can use enums are index values as _any_ integer allowed
-	}
-	{
-		Fruit1 :: type enum int {
-			APPLE,
-			BANANA,
-			PEAR,
-		}
-
-		Fruit2 :: type enum u8 {
-			APPLE,
-			BANANA,
-			PEAR,
-		}
-
-		Fruit3 :: type enum u8 {
-			APPLE = 1,
-			BANANA, // 2
-			PEAR  = 5,
-			TOMATO, // 6
-		}
-	}
-
-	// Q: remove the need for `type` if it's a record (struct/enum/raw_union/union)?
-}
-
-variadic_procedures :: proc() {
-	print_ints :: proc(args: ..int) {
-		for i := 0; i < len(args); i++ {
-			if i > 0 {
-				print_string(", ")
-			}
-			print_int(args[i])
-		}
-	}
-
-	print_ints(); // nl()
-	print_ints(1); nl()
-	print_ints(1, 2, 3); nl()
-
-	print_prefix_f32s :: proc(prefix: string, args: ..f32) {
-		print_string(prefix)
-		print_string(": ")
-		for i := 0; i < len(args); i++ {
-			if i > 0 {
-				print_string(", ")
-			}
-			print_f32(args[i])
-		}
-	}
-
-	print_prefix_f32s("a"); nl()
-	print_prefix_f32s("b", 1); nl()
-7	print_prefix_f32s("c", 1, 2, 3); nl()
-
-	// Internally, the variadic procedures get allocated to an array on the stack,
-	// and this array is passed a slice
-
-	// This is first step for a `print` procedure but I do not have an `any` type
-	// yet as this requires a few other things first - i.e. introspection
-
-	// NOTE(bill): I haven't yet added the feature of expanding a slice or array into
-	// a variadic a parameter but it's pretty trivial to add
-}
-
-new_builtins :: proc() {
-	{
-		a := new(int)
-		b := new_slice(int, 12)
-		c := new_slice(int, 12, 16)
-
-		defer delete(a)
-		defer delete(b)
-		defer delete(c)
-
-		// NOTE(bill): These use the current context's allocator not the default allocator
-		// see runtime.odin
-
-		// Q: Should this be `free` rather than `delete` and should I overload it for slices too?
-
-		{
-			prev_context := context
-			defer context = prev_context
-			// Q: Should I add a `push_context` feature to the language?
-
-			context.allocator = __default_allocator()
-
-			a := new(int)
-			defer delete(a)
-
-			// Do whatever
-
-		}
-	}
-
-	{
-		a: int = 123
-		b: type_of_val(a) = 321
-
-		// NOTE(bill): This matches the current naming scheme
-		// size_of
-		// align_of
-		// offset_of
-		//
-		// size_of_val
-		// align_of_val
-		// offset_of_val
-		// type_of_val
-	}
-
-	{
-		// Compile time assert
-		COND :: true
-		compile_assert(COND)
-		// compile_assert(!COND)
-
-		// Runtime assert
-		x := true
-		assert(x)
-		// assert(!x)
-	}
-
-	{
-		x: ^u32 = null;
-		y := ptr_offset(x, 100)
-		z := ptr_sub(y, x)
-		w := slice_ptr(x, 12)
-		t := slice_ptr(x, 12, 16)
-
-		// NOTE(bill): These are here because I've removed:
-		// pointer arithmetic
-		// pointer indexing
-		// pointer slicing
-
-		// Reason
-
-		a: [16]int
-		a[1] = 1;
-		b := ^a
-		// Auto pointer deref
-		// consistent with record members
-		assert(b[1] == 1)
-
-		// Q: Should I add them back in at the cost of inconsitency?
-	}
-
-	{
-		a, b := -1, 2
-		print_int(min(a, b)); nl()
-		print_int(max(a, b)); nl()
-		print_int(abs(a)); nl()
-
-		// These work at compile time too
-		A :: -1
-		B :: 2
-		C :: min(A, B)
-		D :: max(A, B)
-		E :: abs(A)
-
-		print_int(C); nl()
-		print_int(D); nl()
-		print_int(E); nl()
-	}
-}
-
-
-match_statement :: proc() {
-	// NOTE(bill): `match` statements are similar to `switch` statements
-	// in other languages but there are few differences
-
-	{
-		match x := 5; x {
-		case 1: // cases must be constant expression
-			print_string("1!\n")
-			// break by default
-
-		case 2:
-			s := "2!\n"; // Each case has its own scope
-			print_string(s)
-			break // explicit break
-
-		case 3, 4: // multiple cases
-			print_string("3 or 4!\n")
-
-		case 5:
-			print_string("5!\n")
-			fallthrough // explicit fallthrough
-
-		default:
-			print_string("default!\n")
-		}
-
-
-
-		match x := 1.5; x {
-		case 1.5:
-			print_string("1.5!\n")
-			// break by default
-		case MATH_TAU:
-			print_string("τ!\n")
-		default:
-			print_string("default!\n")
-		}
-
-
-
-		match x := "Hello"; x {
-		case "Hello":
-			print_string("greeting\n")
-			// break by default
-		case "Goodbye":
-			print_string("farewell\n")
-		default:
-			print_string("???\n")
-		}
-
-
-
-
-
-
-		a := 53
-		match {
-		case a == 1:
-			print_string("one\n")
-		case a == 2:
-			print_string("a couple\n")
-		case a < 7, a == 7:
-			print_string("a few\n")
-		case a < 12: // intentional bug
-			print_string("several\n")
-		case a >= 12 && a < 100:
-			print_string("dozens\n")
-		case a >= 100 && a < 1000:
-			print_string("hundreds\n")
-		default:
-			print_string("a fuck ton\n")
-		}
-
-		// Identical to this
-
-		b := 53
-		if b == 1 {
-			print_string("one\n")
-		} else if b == 2 {
-			print_string("a couple\n")
-		} else if b < 7 || b == 7 {
-			print_string("a few\n")
-		} else if b < 12 { // intentional bug
-			print_string("several\n")
-		} else if b >= 12 && b < 100 {
-			print_string("dozens\n")
-		} else if b >= 100 && b < 1000 {
-			print_string("hundreds\n")
-		} else {
-			print_string("a fuck ton\n")
-		}
-
-		// However, match statements allow for `break` and `fallthrough` unlike
-		// an if statement
-	}
-}
-
-Vector3 :: type struct {
-	x, y, z: f32
-}
-
-print_floats :: proc(args: ..f32) {
-	for i := 0; i < len(args); i++ {
-		if i > 0 {
-			print_string(", ")
-		}
-		print_f32(args[i])
-	}
-	print_nl()
-}
-
-namespacing :: proc() {
-	{
-		Thing :: type struct {
-			x: f32
-			name: string
-		}
-
-		a: Thing
-		a.x = 3
-		{
-			Thing :: type struct {
-				y: int
-				test: bool
-			}
-
-			b: Thing // Uses this scope's Thing
-			b.test = true
-		}
-	}
-
-	{
-		Entity :: type struct {
-			Guid :: type int
-			Nested :: type struct {
-				MyInt :: type int
-				i: int
-			}
-
-			CONSTANT :: 123
-
-
-			guid:   Guid
-			name:   string
-			pos:    Vector3
-			vel:    Vector3
-			nested: Nested
-		}
-
-		guid: Entity.Guid = Entity.CONSTANT
-		i: Entity.Nested.MyInt
-
-
-
-		{
-			using Entity
-			guid: Guid = CONSTANT
-			using Nested
-			i: MyInt
-		}
-
-
-		{
-			using Entity.Nested
-			guid: Entity.Guid = Entity.CONSTANT
-			i: MyInt
-		}
-
-
-		{
-			e: Entity
-			using e
-			guid = 27832
-			name = "Bob"
-
-			print_int(e.guid as int); nl()
-			print_string(e.name); nl()
-		}
-
-		{
-			using e: Entity
-			guid = 78456
-			name = "Thing"
-
-			print_int(e.guid as int); nl()
-			print_string(e.name); nl()
-		}
-	}
-
-	{
-		Entity :: type struct {
-			Guid :: type int
-			Nested :: type struct {
-				MyInt :: type int
-				i: int
-			}
-
-			CONSTANT :: 123
-
-
-			guid:      Guid
-			name:      string
-			using pos: Vector3
-			vel:       Vector3
-			using nested: ^Nested
-		}
-
-		e := Entity{nested = new(Entity.Nested)}
-		e.x = 123
-		e.i = Entity.CONSTANT
-	}
-
-
-
-	{
-		Entity :: type struct {
-			position: Vector3
-		}
-
-		print_pos_1 :: proc(entity: ^Entity) {
-			print_string("print_pos_1: ")
-			print_floats(entity.position.x, entity.position.y, entity.position.z)
-		}
-
-		print_pos_2 :: proc(entity: ^Entity) {
-			using entity
-			print_string("print_pos_2: ")
-			print_floats(position.x, position.y, position.z)
-		}
-
-		print_pos_3 :: proc(using entity: ^Entity) {
-			print_string("print_pos_3: ")
-			print_floats(position.x, position.y, position.z)
-		}
-
-		print_pos_4 :: proc(using entity: ^Entity) {
-			using position
-			print_string("print_pos_4: ")
-			print_floats(x, y, z)
-		}
-
-		e := Entity{position = Vector3{1, 2, 3}}
-		print_pos_1(^e)
-		print_pos_2(^e)
-		print_pos_3(^e)
-		print_pos_4(^e)
-
-		// This is similar to C++'s `this` pointer that is implicit and only available in methods
-	}
-}
-
-subtyping :: proc() {
-	{
-		// C way for subtyping/subclassing
-
-		Entity :: type struct {
-			position: Vector3
-		}
-
-		Frog :: type struct {
-			entity: Entity
-			jump_height: f32
-		}
-
-		f: Frog
-		f.entity.position = Vector3{1, 2, 3}
-
-		using f.entity
-		position = Vector3{1, 2, 3}
-
-	}
-
-	{
-		// C++ way for subtyping/subclassing
-
-		Entity :: type struct {
-			position: Vector3
-		}
-
-		Frog :: type struct {
-			using entity: Entity
-			jump_height: f32
-		}
-
-		f: Frog
-		f.position = Vector3{1, 2, 3}
-
-
-		print_pos :: proc(using entity: Entity) {
-			print_string("print_pos: ")
-			print_floats(position.x, position.y, position.z)
-		}
-
-		print_pos(f.entity)
-		print_pos(f)
-
-		// Subtype Polymorphism
-	}
-
-	{
-		// More than C++ way for subtyping/subclassing
-
-		Entity :: type struct {
-			position: Vector3
-		}
-
-		Frog :: type struct {
-			jump_height: f32
-			using entity: ^Entity // Doesn't have to be first member!
-		}
-
-		f: Frog
-		f.entity = new(Entity)
-		f.position = Vector3{1, 2, 3}
-
-
-		print_pos :: proc(using entity: ^Entity) {
-			print_string("print_pos: ")
-			print_floats(position.x, position.y, position.z)
-		}
-
-		print_pos(f.entity)
-		print_pos(^f)
-		print_pos(f)
-	}
-
-	{
-		// More efficient subtyping
-
-		Entity :: type struct {
-			position: Vector3
-		}
-
-		Frog :: type struct {
-			jump_height: f32
-			using entity: ^Entity
-		}
-
-		MAX_ENTITES :: 64
-		entities: [MAX_ENTITES]Entity
-		entity_count := 0
-
-		next_entity :: proc(entities: []Entity, entity_count: ^int) -> ^Entity {
-			e := ^entities[entity_count^]
-			entity_count^++
-			return e
-		}
-
-		f: Frog
-		f.entity = next_entity(entities[:], ^entity_count)
-		f.position = Vector3{3, 4, 6}
-
-		using f.position
-		print_floats(x, y, z)
-	}
-
-	{
-		// Down casting
-
-		Entity :: type struct {
-			position: Vector3
-		}
-
-		Frog :: type struct {
-			jump_height: f32
-			using entity: Entity
-		}
-
-		f: Frog
-		f.jump_height = 564
-		e := ^f.entity
-
-		frog := e down_cast ^Frog
-		print_string("down_cast: ")
-		print_f32(frog.jump_height); nl()
-
-		// NOTE(bill): `down_cast` is unsafe and there are not check are compile time or run time
-		// Q: Should I completely remove `down_cast` as I added it in about 30 minutes
-	}
-
-	{
-		// Multiple "inheritance"/subclassing
-
-		Entity :: type struct {
-			position: Vector3
-		}
-		Climber :: type struct {
-			speed: f32
-		}
-
-		Frog :: type struct {
-			using entity:  Entity
-			using climber: Climber
-		}
-	}
-}
-
-tagged_unions :: proc() {
-	{
-		EntityKind :: type enum {
-			INVALID,
-			FROG,
-			GIRAFFE,
-			HELICOPTER,
-		}
-
-		Entity :: type struct {
-			kind: EntityKind
-			using data: raw_union {
-				frog: struct {
-					jump_height: f32
-					colour: u32
-				}
-				giraffe: struct {
-					neck_length: f32
-					spot_count: int
-				}
-				helicopter: struct {
-					blade_count: int
-					weight: f32
-					pilot_name: string
-				}
-			}
-		}
-
-		e: Entity
-		e.kind = EntityKind.FROG
-		e.frog.jump_height = 12
-
-		f: type_of_val(e.frog);
-
-		// But this is very unsafe and extremely cumbersome to write
-		// In C++, I use macros to alleviate this but it's not a solution
-	}
-
-	{
-		Entity :: type union {
-			Frog: struct {
-				jump_height: f32
-				colour: u32
-			}
-			Giraffe: struct {
-				neck_length: f32
-				spot_count: int
-			}
-			Helicopter: struct {
-				blade_count: int
-				weight: f32
-				pilot_name: string
-			}
-		}
-
-		using Entity
-		f1: Frog = Frog{12, 0xff9900}
-		f2: Entity = Frog{12, 0xff9900} // Implicit cast
-		f3 := Frog{12, 0xff9900} as Entity // Explicit cast
-
-		// f3.Frog.jump_height = 12 // There are "members" of a union
-
-
-
-		e, f, g, h: Entity
-		f = Frog{12, 0xff9900}
-		g = Giraffe{2.1, 23}
-		h = Helicopter{4, 1000, "Frank"}
-
-
-
-
-		// Requires a pointer to the union
-		// `x` will be a pointer to type of the case
-
-		match type x : ^f {
-		case Frog:
-			print_string("Frog!\n")
-			print_f32(x.jump_height); nl()
-			x.jump_height = 3
-			print_f32(x.jump_height); nl()
-		case Giraffe:
-			print_string("Giraffe!\n")
-		case Helicopter:
-			print_string("ROFLCOPTER!\n")
-		default:
-			print_string("invalid entity\n")
-		}
-
-
-		// Q: Allow for a non pointer version with takes a copy instead?
-		// Or it takes the pointer the data and not a copy
-
-
-		fp := ^f as ^Frog // Unsafe
-		print_f32(fp.jump_height); nl()
-
-
-		// Internals of a tagged union
-		/*
-			struct {
-				data: [size_of_biggest_tag]u8
-				tag_index: int
-			}
-		*/
-		// This is to allow for pointer casting if needed
-
-
-		// Advantage over subtyping version
-		MAX_ENTITES :: 64
-		entities: [MAX_ENTITES]Entity
-
-		entities[0] = Frog{}
-		entities[1] = Helicopter{}
-		// etc.
-	}
-
-
-	{
-		// Transliteration of code from this actual compiler
-		// Some stuff is missing
-		Type       :: type struct {}
-		Scope      :: type struct {}
-		Token      :: type struct {}
-		AstNode    :: type struct {}
-		ExactValue :: type struct {}
-
-		EntityKind :: type enum {
-			Invalid,
-			Constant,
-			Variable,
-			UsingVariable,
-			TypeName,
-			Procedure,
-			Builtin,
-			Count,
-		}
-
-		Entity :: type struct {
-			Guid :: type i64
-
-			kind: EntityKind
-			guid: Guid
-
-			scope: ^Scope
-			token: Token
-			type_: ^Type
-
-			using data: raw_union {
-				Constant: struct {
-					value: ExactValue
-				}
-				Variable: struct {
-					visited:   bool // Cycle detection
-					used:      bool // Variable is used
-					is_field:  bool // Is struct field
-					anonymous: bool // Variable is an anonymous
-				}
-				UsingVariable: struct {
-				}
-				TypeName: struct {
-				}
-				Procedure: struct {
-					used: bool
-				}
-				Builtin: struct {
-					id: int
-				}
-			}
-		}
-
-		// Plus all the constructing procedures that go along with them!!!!
-		// It's a nightmare
-	}
-
-	{
-		Type       :: type struct {}
-		Scope      :: type struct {}
-		Token      :: type struct {}
-		AstNode    :: type struct {}
-		ExactValue :: type struct {}
-
-
-		Entity :: type union {
-			Base :: type struct {
-				Guid :: type i64
-				guid: Guid
-
-				scope: ^Scope
-				token: Token
-				type_: ^Type
-			}
-
-
-			Constant: struct {
-				using base: Base
-				value: ExactValue
-			}
-			Variable: struct {
-				using base: Base
-				visited:   bool // Cycle detection
-				used:      bool // Variable is used
-				is_field:  bool // Is struct field
-				anonymous: bool // Variable is an anonymous
-			}
-			UsingVariable: struct {
-				using base: Base
-			}
-			TypeName: struct {
-				using base: Base
-			}
-			Procedure: struct {
-				using base: Base
-				used: bool
-			}
-			Builtin: struct {
-				using base: Base
-				id: int
-			}
-		}
-
-		using Entity
-
-		e: Entity
-
-		e = Variable{
-			base = Base{},
-			used = true,
-			anonymous = false,
-		}
-
-
-
-		// Q: Allow a "base" type to be added to a union?
-		// Or even `using` on union to get the same properties?
-	}
-
-
-	{
-		// `Raw` unions still have uses, especially for mathematic types
-
-		Vector2 :: type raw_union {
-			using xy_: struct { x, y: f32 }
-			e: [2]f32
-			v: {2}f32
-		}
-
-		Vector3 :: type raw_union {
-			using xyz_: struct { x, y, z: f32 }
-			xy: Vector2
-			e: [3]f32
-			v: {3}f32
-		}
-
-		v2: Vector2
-		v2.x = 1
-		v2.e[0] = 1
-		v2.v[0] = 1
-
-		v3: Vector3
-		v3.x = 1
-		v3.e[0] = 1
-		v3.v[0] = 1
-		v3.xy.x = 1
-	}
-}
-
-nl :: proc() { print_nl() }

code/punity.odin

@@ -1,482 +0,0 @@
-#import "win32.odin"
-#import "fmt.odin"
-#import "os.odin"
-
-CANVAS_WIDTH  :: 128
-CANVAS_HEIGHT :: 128
-CANVAS_SCALE  :: 3
-FRAME_TIME    :: 1.0/30.0
-WINDOW_TITLE  :: "Punity\x00"
-
-_ := compile_assert(CANVAS_WIDTH % 16 == 0)
-
-WINDOW_WIDTH  :: CANVAS_WIDTH  * CANVAS_SCALE
-WINDOW_HEIGHT :: CANVAS_HEIGHT * CANVAS_SCALE
-
-
-STACK_CAPACITY   :: 1<<20
-STORAGE_CAPACITY :: 1<<20
-
-DRAW_LIST_RESERVE :: 128
-
-MAX_KEYS :: 256
-
-Core :: struct {
-	stack:   ^Bank
-	storage: ^Bank
-
-	running:       bool
-	key_modifiers: u32
-	key_states:    [MAX_KEYS]byte
-	key_deltas:    [MAX_KEYS]byte
-
-	perf_frame,
-	perf_frame_inner,
-	perf_step,
-	perf_audio,
-	perf_blit,
-	perf_blit_cvt,
-	perf_blit_gdi: Perf_Span
-
-	frame: i64
-
-	canvas:    Canvas
-	draw_list: ^Draw_List
-}
-
-Perf_Span :: struct {
-	stamp: f64
-	delta: f32
-}
-
-Bank :: struct {
-	memory: []byte
-	cursor: int
-}
-
-Bank_State :: struct {
-	state: Bank
-	bank: ^Bank
-}
-
-
-Color :: raw_union {
-	using channels: struct{ a, b, g, r: byte; }
-	rgba: u32
-}
-
-Palette :: struct {
-	colors: [256]Color
-	colors_count: byte
-}
-
-
-Rect :: raw_union {
-	using minmax: struct {
-		min_x, min_y, max_x, max_y: int
-	}
-	using pos: struct {
-		left, top, right, bottom: int
-	}
-	e: [4]int
-}
-
-Bitmap :: struct {
-	pixels: []byte
-	width:  int
-	height: int
-}
-
-Font :: struct {
-	using bitmap: Bitmap
-	char_width:   int
-	char_height:  int
-}
-
-Canvas :: struct {
-	using bitmap: ^Bitmap
-	palette:      Palette
-	translate_x:  int
-	translate_y:  int
-	clip:         Rect
-	font:         ^Font
-}
-
-DrawFlag :: enum {
-	NONE   = 0,
-	FLIP_H = 1<<0,
-	FLIP_V = 1<<1,
-	MASK   = 1<<2,
-}
-
-
-Draw_List :: struct {
-	Item :: struct {
-
-	}
-	items: []Item
-}
-
-Key :: enum {
-	MOD_SHIFT   = 0x0001,
-	MOD_CONTROL = 0x0002,
-	MOD_ALT     = 0x0004,
-	MOD_SUPER   = 0x0008,
-
-	UNKNOWN            =-1,
-	INVALID            =-2,
-
-	LBUTTON            = 1,
-	RBUTTON            = 2,
-	CANCEL             = 3,
-	MBUTTON            = 4,
-
-	BACK               = 8,
-	TAB                = 9,
-	CLEAR              = 12,
-	RETURN             = 13,
-	SHIFT              = 16,
-	CONTROL            = 17,
-	MENU               = 18,
-	PAUSE              = 19,
-	CAPITAL            = 20,
-	KANA               = 0x15,
-	HANGEUL            = 0x15,
-	HANGUL             = 0x15,
-	JUNJA              = 0x17,
-	FINAL              = 0x18,
-	HANJA              = 0x19,
-	KANJI              = 0x19,
-	ESCAPE             = 0x1B,
-	CONVERT            = 0x1C,
-	NONCONVERT         = 0x1D,
-	ACCEPT             = 0x1E,
-	MODECHANGE         = 0x1F,
-	SPACE              = 32,
-	PRIOR              = 33,
-	NEXT               = 34,
-	END                = 35,
-	HOME               = 36,
-	LEFT               = 37,
-	UP                 = 38,
-	RIGHT              = 39,
-	DOWN               = 40,
-	SELECT             = 41,
-	PRINT              = 42,
-	EXEC               = 43,
-	SNAPSHOT           = 44,
-	INSERT             = 45,
-	DELETE             = 46,
-	HELP               = 47,
-	LWIN               = 0x5B,
-	RWIN               = 0x5C,
-	APPS               = 0x5D,
-	SLEEP              = 0x5F,
-	NUMPAD0            = 0x60,
-	NUMPAD1            = 0x61,
-	NUMPAD2            = 0x62,
-	NUMPAD3            = 0x63,
-	NUMPAD4            = 0x64,
-	NUMPAD5            = 0x65,
-	NUMPAD6            = 0x66,
-	NUMPAD7            = 0x67,
-	NUMPAD8            = 0x68,
-	NUMPAD9            = 0x69,
-	MULTIPLY           = 0x6A,
-	ADD                = 0x6B,
-	SEPARATOR          = 0x6C,
-	SUBTRACT           = 0x6D,
-	DECIMAL            = 0x6E,
-	DIVIDE             = 0x6F,
-	F1                 = 0x70,
-	F2                 = 0x71,
-	F3                 = 0x72,
-	F4                 = 0x73,
-	F5                 = 0x74,
-	F6                 = 0x75,
-	F7                 = 0x76,
-	F8                 = 0x77,
-	F9                 = 0x78,
-	F10                = 0x79,
-	F11                = 0x7A,
-	F12                = 0x7B,
-	F13                = 0x7C,
-	F14                = 0x7D,
-	F15                = 0x7E,
-	F16                = 0x7F,
-	F17                = 0x80,
-	F18                = 0x81,
-	F19                = 0x82,
-	F20                = 0x83,
-	F21                = 0x84,
-	F22                = 0x85,
-	F23                = 0x86,
-	F24                = 0x87,
-	NUMLOCK            = 0x90,
-	SCROLL             = 0x91,
-	LSHIFT             = 0xA0,
-	RSHIFT             = 0xA1,
-	LCONTROL           = 0xA2,
-	RCONTROL           = 0xA3,
-	LMENU              = 0xA4,
-	RMENU              = 0xA5,
-
-	APOSTROPHE         = 39,  /* ' */
-	COMMA              = 44,  /* , */
-	MINUS              = 45,  /* - */
-	PERIOD             = 46,  /* . */
-	SLASH              = 47,  /* / */
-	NUM0               = 48,
-	NUM1               = 49,
-	NUM2               = 50,
-	NUM3               = 51,
-	NUM4               = 52,
-	NUM5               = 53,
-	NUM6               = 54,
-	NUM7               = 55,
-	NUM8               = 56,
-	NUM9               = 57,
-	SEMICOLON          = 59,  /* ; */
-	EQUAL              = 61,  /* = */
-	A                  = 65,
-	B                  = 66,
-	C                  = 67,
-	D                  = 68,
-	E                  = 69,
-	F                  = 70,
-	G                  = 71,
-	H                  = 72,
-	I                  = 73,
-	J                  = 74,
-	K                  = 75,
-	L                  = 76,
-	M                  = 77,
-	N                  = 78,
-	O                  = 79,
-	P                  = 80,
-	Q                  = 81,
-	R                  = 82,
-	S                  = 83,
-	T                  = 84,
-	U                  = 85,
-	V                  = 86,
-	W                  = 87,
-	X                  = 88,
-	Y                  = 89,
-	Z                  = 90,
-	LEFT_BRACKET       = 91,  /* [ */
-	BACKSLASH          = 92,  /* \ */
-	RIGHT_BRACKET      = 93,  /* ] */
-	GRAVE_ACCENT       = 96,  /* ` */
-}
-
-
-key_down :: proc(k: Key) -> bool {
-	return _core.key_states[k] != 0
-}
-
-key_pressed :: proc(k: Key) -> bool {
-	return (_core.key_deltas[k] != 0) && key_down(k)
-}
-
-
-
-
-win32_perf_count_freq := win32.GetQueryPerformanceFrequency()
-time_now :: proc() -> f64 {
-	assert(win32_perf_count_freq != 0)
-
-	counter: i64
-	win32.QueryPerformanceCounter(^counter)
-	result := counter as f64 / win32_perf_count_freq as f64
-	return result
-}
-
-_core: Core
-
-run :: proc(user_init, user_step: proc(c: ^Core)) {
-	using win32
-
-	_core.running = true
-
-	win32_proc :: proc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT #no_inline #stdcall {
-		win32_app_key_mods :: proc() -> u32 {
-			mods: u32 = 0
-
-			if is_key_down(Key_Code.SHIFT) {
-				mods |= Key.MOD_SHIFT as u32
-			}
-			if is_key_down(Key_Code.CONTROL) {
-				mods |= Key.MOD_CONTROL as u32
-			}
-			if is_key_down(Key_Code.MENU) {
-				mods |= Key.MOD_ALT as u32
-			}
-			if is_key_down(Key_Code.LWIN) || is_key_down(Key_Code.RWIN) {
-				mods |= Key.MOD_SUPER as u32
-			}
-
-			return mods
-		}
-
-		match msg {
-		case WM_KEYDOWN:
-			_core.key_modifiers = win32_app_key_mods()
-			if wparam < MAX_KEYS {
-				_core.key_states[wparam] = 1
-				_core.key_deltas[wparam] = 1
-			}
-			return 0
-
-		case WM_KEYUP:
-			_core.key_modifiers = win32_app_key_mods()
-			if wparam < MAX_KEYS {
-				_core.key_states[wparam] = 0
-				_core.key_deltas[wparam] = 1
-			}
-			return 0
-
-		case WM_CLOSE:
-			PostQuitMessage(0)
-			_core.running = false
-			return 0
-		}
-
-		return DefWindowProcA(hwnd, msg, wparam, lparam)
-	}
-
-
-	window_class := WNDCLASSEXA{
-		class_name = ("Punity\x00" as string).data, // C-style string
-		size       = size_of(WNDCLASSEXA) as u32,
-		style      = CS_HREDRAW | CS_VREDRAW | CS_OWNDC,
-		instance   = GetModuleHandleA(nil) as HINSTANCE,
-		wnd_proc   = win32_proc,
-		// wnd_proc   = DefWindowProcA,
-		background = GetStockObject(BLACK_BRUSH) as HBRUSH,
-	}
-
-	if RegisterClassExA(^window_class) == 0 {
-		fmt.fprintln(os.stderr, "RegisterClassExA failed")
-		return
-	}
-
-	screen_width  := GetSystemMetrics(SM_CXSCREEN)
-	screen_height := GetSystemMetrics(SM_CYSCREEN)
-
-	rc: RECT
-	rc.left   = (screen_width - WINDOW_WIDTH)   / 2
-	rc.top    = (screen_height - WINDOW_HEIGHT) / 2
-	rc.right  = rc.left + WINDOW_WIDTH
-	rc.bottom = rc.top + WINDOW_HEIGHT
-
-	style: u32 = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX
-	assert(AdjustWindowRect(^rc, style, 0) != 0)
-
-	wt := WINDOW_TITLE
-
-	win32_window := CreateWindowExA(0,
-	                                window_class.class_name,
-	                                wt.data,
-	                                style,
-	                                rc.left, rc.top,
-	                                rc.right-rc.left, rc.bottom-rc.top,
-	                                nil, nil, window_class.instance,
-	                                nil)
-
-	if win32_window == nil {
-		fmt.fprintln(os.stderr, "CreateWindowExA failed")
-		return
-	}
-
-
-	window_bmi: BITMAPINFO
-	window_bmi.size        = size_of(BITMAPINFO.HEADER) as u32
-	window_bmi.width       = CANVAS_WIDTH
-	window_bmi.height      = CANVAS_HEIGHT
-	window_bmi.planes      = 1
-	window_bmi.bit_count   = 32
-	window_bmi.compression = BI_RGB
-
-
-	user_init(^_core)
-
-
-	ShowWindow(win32_window, SW_SHOW)
-
-	window_buffer := new_slice(u32, CANVAS_WIDTH * CANVAS_HEIGHT)
-	assert(window_buffer.data != nil)
-	defer free(window_buffer.data)
-
-	for i := 0; i < window_buffer.count; i++ {
-		window_buffer[i] = 0xff00ff
-	}
-
-
-	prev_time, curr_time,dt: f64
-	prev_time = time_now()
-	curr_time = time_now()
-	total_time : f64 = 0
-	offset_x := 0
-	offset_y := 0
-
-	message: MSG
-	for _core.running {
-		curr_time = time_now()
-		dt = curr_time - prev_time
-		prev_time = curr_time
-		total_time += dt
-
-		offset_x += 1
-		offset_y += 2
-
-		{
-			data: [128]byte
-			buf := data[:0]
-			fmt.bprintf(^buf, "Punity: % ms\x00", dt*1000)
-			win32.SetWindowTextA(win32_window, buf.data)
-		}
-
-
-		for y := 0; y < CANVAS_HEIGHT; y++ {
-			for x := 0; x < CANVAS_WIDTH; x++ {
-				g := (x % 32) * 8
-				b := (y % 32) * 8
-				window_buffer[x + y*CANVAS_WIDTH] = (g << 8 | b) as u32
-			}
-		}
-
-		_core.key_deltas = nil
-
-		for PeekMessageA(^message, nil, 0, 0, PM_REMOVE) != 0 {
-			if message.message == WM_QUIT {
-				_core.running = false
-			}
-			TranslateMessage(^message)
-			DispatchMessageA(^message)
-		}
-
-		user_step(^_core)
-
-		dc := GetDC(win32_window)
-		StretchDIBits(dc,
-		              0, 0, CANVAS_WIDTH * CANVAS_SCALE, CANVAS_HEIGHT * CANVAS_SCALE,
-		              0, 0, CANVAS_WIDTH, CANVAS_HEIGHT,
-		              window_buffer.data,
-		              ^window_bmi,
-		              DIB_RGB_COLORS,
-		              SRCCOPY)
-		ReleaseDC(win32_window, dc)
-
-
-		{
-			delta := time_now() - prev_time
-			ms := ((FRAME_TIME - delta) * 1000) as i32
-			if ms > 0 {
-				win32.Sleep(ms)
-			}
-		}
-
-		_core.frame++
-	}
-}

code/sub/test.odin

@@ -1,5 +0,0 @@
-#import "fmt.odin" as fmt
-
-thing :: proc() {
-	fmt.println("Sub Hello!")
-}

code/test.odin

@@ -1,35 +0,0 @@
-/*#import "fmt.odin"
-
-thing :: proc() {
-	fmt.println("Hello1!")
-}*/
-
-
-#import "fmt.odin" as format
-
-thing :: proc() {
-	format.println("Hello2!")
-}
-
-
-/*#import "fmt.odin" as .
-
-thing :: proc() {
-	println("Hello3!")
-}
-
-
-*/
-/*#import "fmt.odin" as _
-
-thing :: proc() {
-	// println("Hello4!")
-}
-*/
-
-/*
-#include "fmt.odin"
-
-thing :: proc() {
-	println("Hello5!")
-}*/

core/_preload.odin

@@ -1,336 +0,0 @@
-#shared_global_scope;
-
-#import "os.odin";
-#import "fmt.odin";
-#import "mem.odin";
-#import "utf8.odin";
-
-// IMPORTANT NOTE(bill): `type_info` & `type_info_val` cannot be used within a
-// #shared_global_scope due to  the internals of the compiler.
-// This could change at a later date if the all these data structures are
-// implemented within the compiler rather than in this "preload" file
-
-
-// IMPORTANT NOTE(bill): Do not change the order of any of this data
-// The compiler relies upon this _exact_ order
-Type_Info_Member :: struct #ordered {
-	name:      string;     // can be empty if tuple
-	type_info: ^Type_Info;
-	offset:    int;        // offsets are not used in tuples
-}
-Type_Info_Record :: struct #ordered {
-	fields:  []Type_Info_Member;
-	size:    int; // in bytes
-	align:   int; // in bytes
-	packed:  bool;
-	ordered: bool;
-}
-
-Type_Info :: union {
-	Named: struct #ordered {
-		name: string;
-		base: ^Type_Info; // This will _not_ be a Type_Info.Named
-	};
-	Integer: struct #ordered {
-		size:   int; // in bytes
-		signed: bool;
-	};
-	Float: struct #ordered {
-		size: int; // in bytes
-	};
-	Any:     struct #ordered {};
-	String:  struct #ordered {};
-	Boolean: struct #ordered {};
-	Pointer: struct #ordered {
-		elem: ^Type_Info; // nil -> rawptr
-	};
-	Maybe: struct #ordered {
-		elem: ^Type_Info;
-	};
-	Procedure: struct #ordered {
-		params:   ^Type_Info; // Type_Info.Tuple
-		results:  ^Type_Info; // Type_Info.Tuple
-		variadic: bool;
-	};
-	Array: struct #ordered {
-		elem:      ^Type_Info;
-		elem_size: int;
-		count:     int;
-	};
-	Slice: struct #ordered {
-		elem:      ^Type_Info;
-		elem_size: int;
-	};
-	Vector: struct #ordered {
-		elem:      ^Type_Info;
-		elem_size: int;
-		count:     int;
-		align:     int;
-	};
-	Tuple:     Type_Info_Record;
-	Struct:    Type_Info_Record;
-	Union:     Type_Info_Record;
-	Raw_Union: Type_Info_Record;
-	Enum: struct #ordered {
-		base:  ^Type_Info;
-		names: []string;
-		// TODO(bill): store values some how. Maybe using a raw_union
-	};
-}
-
-type_info_base :: proc(info: ^Type_Info) -> ^Type_Info {
-	if info == nil {
-		return nil;
-	}
-	base := info;
-	match type i : base {
-	case Type_Info.Named:
-		base = i.base;
-	}
-	return base;
-}
-
-
-
-assume :: proc(cond: bool) #foreign "llvm.assume"
-
-__debug_trap       :: proc()        #foreign "llvm.debugtrap"
-__trap             :: proc()        #foreign "llvm.trap"
-read_cycle_counter :: proc() -> u64 #foreign "llvm.readcyclecounter"
-
-bit_reverse16 :: proc(b: u16) -> u16 #foreign "llvm.bitreverse.i16"
-bit_reverse32 :: proc(b: u32) -> u32 #foreign "llvm.bitreverse.i32"
-bit_reverse64 :: proc(b: u64) -> u64 #foreign "llvm.bitreverse.i64"
-
-byte_swap16 :: proc(b: u16) -> u16 #foreign "llvm.bswap.i16"
-byte_swap32 :: proc(b: u32) -> u32 #foreign "llvm.bswap.i32"
-byte_swap64 :: proc(b: u64) -> u64 #foreign "llvm.bswap.i64"
-
-fmuladd32 :: proc(a, b, c: f32) -> f32 #foreign "llvm.fmuladd.f32"
-fmuladd64 :: proc(a, b, c: f64) -> f64 #foreign "llvm.fmuladd.f64"
-
-
-
-
-
-
-Allocator_Mode :: enum u8 {
-	ALLOC = iota,
-	FREE,
-	FREE_ALL,
-	RESIZE,
-}
-Allocator_Proc :: type proc(allocator_data: rawptr, mode: Allocator_Mode,
-                            size, alignment: int,
-                            old_memory: rawptr, old_size: int, flags: u64) -> rawptr;
-Allocator :: struct #ordered {
-	procedure: Allocator_Proc;
-	data:      rawptr;
-}
-
-Context :: struct #ordered {
-	thread_id: int;
-
-	allocator: Allocator;
-
-	user_data:  rawptr;
-	user_index: int;
-}
-
-#thread_local __context: Context;
-
-
-DEFAULT_ALIGNMENT :: align_of([vector 4]f32);
-
-
-__check_context :: proc() {
-	c := ^__context;
-
-	if c.allocator.procedure == nil {
-		c.allocator = default_allocator();
-	}
-	if c.thread_id == 0 {
-		c.thread_id = os.current_thread_id();
-	}
-}
-
-alloc :: proc(size: int) -> rawptr #inline { return alloc_align(size, DEFAULT_ALIGNMENT); }
-
-alloc_align :: proc(size, alignment: int) -> rawptr #inline {
-	__check_context();
-	a := context.allocator;
-	return a.procedure(a.data, Allocator_Mode.ALLOC, size, alignment, nil, 0, 0);
-}
-
-free :: proc(ptr: rawptr) #inline {
-	__check_context();
-	a := context.allocator;
-	if ptr != nil {
-		a.procedure(a.data, Allocator_Mode.FREE, 0, 0, ptr, 0, 0);
-	}
-}
-free_all :: proc() #inline {
-	__check_context();
-	a := context.allocator;
-	a.procedure(a.data, Allocator_Mode.FREE_ALL, 0, 0, nil, 0, 0);
-}
-
-
-resize       :: proc(ptr: rawptr, old_size, new_size: int) -> rawptr #inline { return resize_align(ptr, old_size, new_size, DEFAULT_ALIGNMENT); }
-resize_align :: proc(ptr: rawptr, old_size, new_size, alignment: int) -> rawptr #inline {
-	__check_context();
-	a := context.allocator;
-	return a.procedure(a.data, Allocator_Mode.RESIZE, new_size, alignment, ptr, old_size, 0);
-}
-
-
-
-default_resize_align :: proc(old_memory: rawptr, old_size, new_size, alignment: int) -> rawptr {
-	if old_memory == nil {
-		return alloc_align(new_size, alignment);
-	}
-
-	if new_size == 0 {
-		free(old_memory);
-		return nil;
-	}
-
-	if new_size == old_size {
-		return old_memory;
-	}
-
-	new_memory := alloc_align(new_size, alignment);
-	if new_memory == nil {
-		return nil;
-	}
-
-	mem.copy(new_memory, old_memory, min(old_size, new_size));;
-	free(old_memory);
-	return new_memory;
-}
-
-
-default_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
-                               size, alignment: int,
-                               old_memory: rawptr, old_size: int, flags: u64) -> rawptr {
-	using Allocator_Mode;
-
-	when false {
-		match mode {
-		case ALLOC:
-			total_size := size + alignment + size_of(mem.AllocationHeader);
-			ptr := os.heap_alloc(total_size);
-			header := ptr as ^mem.AllocationHeader;
-			ptr = mem.align_forward(header+1, alignment);
-			mem.allocation_header_fill(header, ptr, size);
-			return mem.zero(ptr, size);
-
-		case FREE:
-			os.heap_free(mem.allocation_header(old_memory));
-			return nil;
-
-		case FREE_ALL:
-			// NOTE(bill): Does nothing
-
-		case RESIZE:
-			total_size := size + alignment + size_of(mem.AllocationHeader);
-			ptr := os.heap_resize(mem.allocation_header(old_memory), total_size);
-			header := ptr as ^mem.AllocationHeader;
-			ptr = mem.align_forward(header+1, alignment);
-			mem.allocation_header_fill(header, ptr, size);
-			return mem.zero(ptr, size);
-		}
-	} else {
-		match mode {
-		case ALLOC:
-			return os.heap_alloc(size);
-
-		case FREE:
-			os.heap_free(old_memory);
-			return nil;
-
-		case FREE_ALL:
-			// NOTE(bill): Does nothing
-
-		case RESIZE:
-			return os.heap_resize(old_memory, size);
-		}
-	}
-
-	return nil;
-}
-
-default_allocator :: proc() -> Allocator {
-	return Allocator{
-		procedure = default_allocator_proc,
-		data = nil,
-	};
-}
-
-
-
-
-
-
-
-
-
-
-
-__string_eq :: proc(a, b: string) -> bool {
-	if a.count != b.count {
-		return false;
-	}
-	if a.data == b.data {
-		return true;
-	}
-	return mem.compare(a.data, b.data, a.count) == 0;
-}
-
-__string_cmp :: proc(a, b: string) -> int {
-	return mem.compare(a.data, b.data, min(a.count, b.count));
-}
-
-__string_ne :: proc(a, b: string) -> bool #inline { return !__string_eq(a, b); }
-__string_lt :: proc(a, b: string) -> bool #inline { return __string_cmp(a, b) < 0; }
-__string_gt :: proc(a, b: string) -> bool #inline { return __string_cmp(a, b) > 0; }
-__string_le :: proc(a, b: string) -> bool #inline { return __string_cmp(a, b) <= 0; }
-__string_ge :: proc(a, b: string) -> bool #inline { return __string_cmp(a, b) >= 0; }
-
-
-__assert :: proc(file: string, line, column: int, msg: string) #inline {
-	fmt.fprintf(os.stderr, "%(%:%) Runtime assertion: %\n",
-	            file, line, column, msg);
-	__debug_trap();
-}
-
-__bounds_check_error :: proc(file: string, line, column: int, index, count: int) {
-	if 0 <= index && index < count {
-		return;
-	}
-	fmt.fprintf(os.stderr, "%(%:%) Index % is out of bounds range [0, %)\n",
-	            file, line, column, index, count);
-	__debug_trap();
-}
-
-__slice_expr_error :: proc(file: string, line, column: int, low, high: int) {
-	if 0 <= low && low <= high {
-		return;
-	}
-	fmt.fprintf(os.stderr, "%(%:%) Invalid slice indices: [%:%]\n",
-	            file, line, column, low, high);
-	__debug_trap();
-}
-__substring_expr_error :: proc(file: string, line, column: int, low, high: int) {
-	if 0 <= low && low <= high {
-		return;
-	}
-	fmt.fprintf(os.stderr, "%(%:%) Invalid substring indices: [%:%]\n",
-	            file, line, column, low, high);
-	__debug_trap();
-}
-
-__string_decode_rune :: proc(s: string) -> (rune, int) #inline {
-	return utf8.decode_rune(s);
-}
-

core/_soft_numbers.odin

@@ -1,158 +0,0 @@
-#shared_global_scope;
-
-
-// import "fmt.odin";
-
-// proc __u128_mod(a, b: u128) -> u128 #link_name "__umodti3" {
-// 	var _, r := __u128_quo_mod(a, b)
-// 	return r
-// }
-
-// proc __u128_quo(a, b: u128) -> u128 #link_name "__udivti3" {
-// 	var n, _ := __u128_quo_mod(a, b)
-// 	return n
-// }
-
-// proc __i128_mod(a, b: i128) -> i128 #link_name "__modti3" {
-// 	var _, r := __i128_quo_mod(a, b)
-// 	return r
-// }
-
-// proc __i128_quo(a, b: i128) -> i128 #link_name "__divti3" {
-// 	var n, _ := __i128_quo_mod(a, b)
-// 	return n
-// }
-
-// proc __i128_quo_mod(a, b: i128) -> (i128, i128) #link_name "__divmodti4" {
-// 	var s := b >> 127
-// 	b = (b ~ s) - s
-// 	s = a >> 127
-// 	a = (a ~ s) - s
-
-// 	var n, r := __u128_quo_mod(a as u128, b as u128)
-// 	return (n as i128 ~ s) - s, (r as i128 ~ s) - s
-// }
-
-
-// proc __u128_quo_mod(a, b: u128) -> (u128, u128) #link_name "__udivmodti4" {
-// 	proc clz(x: u64) -> u64 {
-// 		proc clz_u64(x: u64, is_zero_undef: bool) -> u64 #foreign "llvm.ctlz.i64"
-// 		return clz_u64(x, false)
-// 	}
-// 	proc ctz(x: u64) -> u64 {
-// 		proc ctz_u64(x: u64, is_zero_undef: bool) -> u64 #foreign "llvm.cttz.i64"
-// 		return ctz_u64(x, false)
-// 	}
-
-
-// 	u128_lo_hi :: raw_union {
-// 		all: u128
-// 		using _lohi: struct {lo, hi: u64;}
-// 	}
-
-// 	n, d, q, r: u128_lo_hi
-// 	sr: u64
-
-// 	n.all = a
-// 	d.all = b
-
-// 	if n.hi == 0 {
-// 		if d.hi == 0 {
-// 			return (n.lo / d.lo) as u128, (n.lo % d.lo) as u128
-// 		}
-// 		return 0, n.lo as u128
-// 	}
-// 	if d.lo == 0 {
-// 		if d.hi == 0 {
-// 			return (n.hi / d.lo) as u128, (n.hi % d.lo) as u128
-// 		}
-// 		if n.lo == 0 {
-// 			r.hi = n.hi % d.hi
-// 			r.lo = 0
-// 			return (n.hi / d.hi) as u128, r.all
-// 		}
-// 		if (d.hi & (d.hi-1)) == 0 {
-// 			r.lo = n.lo
-// 			r.hi = n.hi & (d.hi-1)
-// 			return (n.hi >> ctz(d.hi)) as u128, r.all
-// 		}
-
-// 		sr = clz(d.hi) - clz(n.hi)
-// 		if sr > 64 - 2 {
-// 			return 0, n.all
-// 		}
-// 		sr++
-// 		q.lo = 0
-// 		q.hi = n.lo << (64-sr)
-// 		r.hi = n.hi >> sr
-// 		r.lo = (n.hi << (64-sr)) | (n.lo >> sr)
-// 	} else {
-// 		if d.hi == 0 {
-// 			if (d.lo & (d.lo - 1)) == 0 {
-// 				var rem := (n.lo % (d.lo - 1)) as u128
-// 				if d.lo == 1 {
-// 					return n.all, rem
-// 				}
-// 				sr = ctz(d.lo)
-// 				q.hi = n.hi >> sr
-// 				q.lo = (n.hi << (64-sr)) | (n.lo >> sr)
-// 				return q.all, rem
-// 			}
-
-// 			sr = 1 + 64 + clz(d.lo) - clz(n.hi)
-
-// 			q.all = n.all << (128-sr)
-// 			r.all = n.all >> sr
-// 			if sr == 64 {
-// 				q.lo = 0
-// 				q.hi = n.lo
-// 				r.hi = 0
-// 				r.lo = n.hi
-// 			} else if sr < 64 {
-// 				q.lo = 0
-// 				q.hi = n.lo << (64-sr)
-// 				r.hi = n.hi >> sr
-// 				r.lo = (n.hi << (64-sr)) | (n.lo >> sr)
-// 			} else {
-// 				q.lo = n.lo << (128-sr)
-// 				q.hi = (n.hi << (128-sr)) | (n.lo >> (sr-64))
-// 				r.hi = 0
-// 				r.lo = n.hi >> (sr-64)
-// 			}
-// 		} else {
-// 			sr = clz(d.hi) - clz(n.hi)
-// 			if sr > 64-1 {
-// 				return 0, n.all
-// 			}
-// 			sr++
-// 			q.lo = 0
-// 			q.hi = n.lo << (64-sr)
-// 			r.all = n.all >> sr
-// 			if sr < 64 {
-// 				r.hi = n.hi >> sr
-// 				r.lo = (n.hi << (64-sr)) | (n.lo >> sr)
-// 			} else {
-// 				r.hi = 0
-// 				r.lo = n.hi
-// 			}
-// 		}
-// 	}
-
-// 	carry: u64
-// 	for ; sr > 0; sr-- {
-// 		r.hi = (r.hi << 1) | (r.lo >> (64-1))
-// 		r.lo = (r.lo << 1) | (r.hi >> (64-1))
-// 		q.hi = (q.hi << 1) | (q.lo >> (64-1))
-// 		q.lo = (q.lo << 1) | carry
-
-// 		carry = 0
-// 		if r.all >= d.all {
-// 			r.all -= d.all
-// 			carry = 1
-// 		}
-// 	}
-
-// 	q.all = (q.all << 1) | (carry as u128)
-// 	return q.all, r.all
-// }
-

core/atomic.odin

@@ -1,101 +0,0 @@
-// TODO(bill): Use assembly instead here to implement atomics
-// Inline vs external file?
-
-#import win32 "sys/windows.odin" when ODIN_OS == "windows";
-_ := compile_assert(ODIN_ARCH == "amd64"); // TODO(bill): x86 version
-
-
-yield_thread :: proc() { win32._mm_pause(); }
-mfence       :: proc() { win32.ReadWriteBarrier(); }
-sfence       :: proc() { win32.WriteBarrier(); }
-lfence       :: proc() { win32.ReadBarrier(); }
-
-
-load32 :: proc(a: ^i32) -> i32 {
-	return a^;
-}
-store32 :: proc(a: ^i32, value: i32) {
-	a^ = value;
-}
-compare_exchange32 :: proc(a: ^i32, expected, desired: i32) -> i32 {
-	return win32.InterlockedCompareExchange(a, desired, expected);
-}
-exchanged32 :: proc(a: ^i32, desired: i32) -> i32 {
-	return win32.InterlockedExchange(a, desired);
-}
-fetch_add32 :: proc(a: ^i32, operand: i32) -> i32 {
-	return win32.InterlockedExchangeAdd(a, operand);
-
-}
-fetch_and32 :: proc(a: ^i32, operand: i32) -> i32 {
-	return win32.InterlockedAnd(a, operand);
-
-}
-fetch_or32 :: proc(a: ^i32, operand: i32) -> i32 {
-	return win32.InterlockedOr(a, operand);
-}
-spin_lock32 :: proc(a: ^i32, time_out: int) -> bool { // NOTE(bill) time_out = -1 as default
-	old_value := compare_exchange32(a, 1, 0);
-	counter := 0;
-	while old_value != 0 && (time_out < 0 || counter < time_out) {
-		counter += 1;
-		yield_thread();
-		old_value = compare_exchange32(a, 1, 0);
-		mfence();
-	}
-	return old_value == 0;
-}
-spin_unlock32 :: proc(a: ^i32) {
-	store32(a, 0);
-	mfence();
-}
-try_acquire_lock32 :: proc(a: ^i32) -> bool {
-	yield_thread();
-	old_value := compare_exchange32(a, 1, 0);
-	mfence();
-	return old_value == 0;
-}
-
-
-load64 :: proc(a: ^i64) -> i64 {
-	return a^;
-}
-store64 :: proc(a: ^i64, value: i64) {
-	a^ = value;
-}
-compare_exchange64 :: proc(a: ^i64, expected, desired: i64) -> i64 {
-	return win32.InterlockedCompareExchange64(a, desired, expected);
-}
-exchanged64 :: proc(a: ^i64, desired: i64) -> i64 {
-	return win32.InterlockedExchange64(a, desired);
-}
-fetch_add64 :: proc(a: ^i64, operand: i64) -> i64 {
-	return win32.InterlockedExchangeAdd64(a, operand);
-}
-fetch_and64 :: proc(a: ^i64, operand: i64) -> i64 {
-	return win32.InterlockedAnd64(a, operand);
-}
-fetch_or64 :: proc(a: ^i64, operand: i64) -> i64 {
-	return win32.InterlockedOr64(a, operand);
-}
-spin_lock64 :: proc(a: ^i64, time_out: int) -> bool { // NOTE(bill) time_out = -1 as default
-	old_value := compare_exchange64(a, 1, 0);
-	counter := 0;
-	while old_value != 0 && (time_out < 0 || counter < time_out) {
-		counter += 1;
-		yield_thread();
-		old_value = compare_exchange64(a, 1, 0);
-		mfence();
-	}
-	return old_value == 0;
-}
-spin_unlock64 :: proc(a: ^i64) {
-	store64(a, 0);
-	mfence();
-}
-try_acquire_lock64 :: proc(a: ^i64) -> bool {
-	yield_thread();
-	old_value := compare_exchange64(a, 1, 0);
-	mfence();
-	return old_value == 0;
-}

core/bufio/read_writer.odin

@@ -0,0 +1,68 @@
+package bufio
+
+import "core:io"
+
+// Read_Writer stores pointers to a Reader and a Writer
+Read_Writer :: struct {
+	r: ^Reader,
+	w: ^Writer,
+}
+
+
+read_writer_init :: proc(rw: ^Read_Writer, r: ^Reader, w: ^Writer) {
+	rw.r, rw.w = r, w;
+}
+
+read_writer_to_stream :: proc(rw: ^Read_Writer) -> (s: io.Stream) {
+	s.stream_data = rw;
+	s.stream_vtable = _read_writer_vtable;
+	return;
+}
+
+@(private)
+_read_writer_vtable := &io.Stream_VTable{
+	impl_read = proc(s: io.Stream, p: []byte) -> (n: int, err: io.Error) {
+		b := (^Read_Writer)(s.stream_data).r;
+		return reader_read(b, p);
+	},
+	impl_read_byte = proc(s: io.Stream) -> (c: byte, err: io.Error) {
+		b := (^Read_Writer)(s.stream_data).r;
+		return reader_read_byte(b);
+	},
+	impl_unread_byte = proc(s: io.Stream) -> io.Error {
+		b := (^Read_Writer)(s.stream_data).r;
+		return reader_unread_byte(b);
+	},
+	impl_read_rune = proc(s: io.Stream) -> (r: rune, size: int, err: io.Error) {
+		b := (^Read_Writer)(s.stream_data).r;
+		return reader_read_rune(b);
+	},
+	impl_unread_rune = proc(s: io.Stream) -> io.Error {
+		b := (^Read_Writer)(s.stream_data).r;
+		return reader_unread_rune(b);
+	},
+	impl_write_to = proc(s: io.Stream, w: io.Writer) -> (n: i64, err: io.Error) {
+		b := (^Read_Writer)(s.stream_data).r;
+		return reader_write_to(b, w);
+	},
+	impl_flush = proc(s: io.Stream)  -> io.Error {
+		b := (^Read_Writer)(s.stream_data).w;
+		return writer_flush(b);
+	},
+	impl_write = proc(s: io.Stream, p: []byte) -> (n: int, err: io.Error) {
+		b := (^Read_Writer)(s.stream_data).w;
+		return writer_write(b, p);
+	},
+	impl_write_byte = proc(s: io.Stream, c: byte) -> io.Error {
+		b := (^Read_Writer)(s.stream_data).w;
+		return writer_write_byte(b, c);
+	},
+	impl_write_rune = proc(s: io.Stream, r: rune) -> (int, io.Error) {
+		b := (^Read_Writer)(s.stream_data).w;
+		return writer_write_rune(b, r);
+	},
+	impl_read_from = proc(s: io.Stream, r: io.Reader) -> (n: i64, err: io.Error) {
+		b := (^Read_Writer)(s.stream_data).w;
+		return writer_read_from(b, r);
+	},
+};

core/bufio/reader.odin

@@ -0,0 +1,474 @@
+package bufio
+
+import "core:io"
+import "core:mem"
+import "core:unicode/utf8"
+import "core:bytes"
+
+// Reader is a buffered wrapper for an io.Reader
+Reader :: struct {
+	buf:            []byte,
+	buf_allocator:  mem.Allocator,
+
+	rd:             io.Reader, // reader
+	r, w:           int, // read and write positions for buf
+
+	err:            io.Error,
+
+	last_byte:      int, // last byte read, invalid is -1
+	last_rune_size: int, // size of last rune read, invalid is -1
+}
+
+
+DEFAULT_BUF_SIZE :: 4096;
+
+@(private)
+MIN_READ_BUFFER_SIZE :: 16;
+@(private)
+MAX_CONSECUTIVE_EMPTY_READS :: 128;
+
+reader_init :: proc(b: ^Reader, rd: io.Reader, size: int = DEFAULT_BUF_SIZE, allocator := context.allocator) {
+	size := size;
+	size = max(size, MIN_READ_BUFFER_SIZE);
+	reader_reset(b, rd);
+	b.buf_allocator = allocator;
+	b.buf = make([]byte, size, allocator);
+}
+
+reader_init_with_buf :: proc(b: ^Reader, rd: io.Reader, buf: []byte) {
+	reader_reset(b, rd);
+	b.buf_allocator = {};
+	b.buf = buf;
+}
+
+// reader_destroy destroys the underlying buffer with its associated allocator IFF that allocator has been set
+reader_destroy :: proc(b: ^Reader) {
+	delete(b.buf, b.buf_allocator);
+	b^ = {};
+}
+
+reader_size :: proc(b: ^Reader) -> int {
+	return len(b.buf);
+}
+
+reader_reset :: proc(b: ^Reader, r: io.Reader) {
+	b.rd = r;
+	b.r, b.w = 0, 0;
+	b.err = nil;
+	b.last_byte      = -1;
+	b.last_rune_size = -1;
+}
+
+@(private)
+_reader_read_new_chunk :: proc(b: ^Reader) -> io.Error {
+	if b.r > 0 {
+		copy(b.buf, b.buf[b.r:b.w]);
+		b.w -= b.r;
+		b.r = 0;
+	}
+
+	if b.w >= len(b.buf) {
+		return .Buffer_Full;
+	}
+
+	// read new data, and try a limited number of times
+	for i := MAX_CONSECUTIVE_EMPTY_READS; i > 0; i -= 1 {
+		n, err := io.read(b.rd, b.buf[b.w:]);
+		if n < 0 {
+			return .Negative_Read;
+		}
+		b.w += n;
+		if err != nil {
+			b.err = err;
+			return nil;
+		}
+		if n > 0 {
+			return nil;
+		}
+	}
+	b.err = .No_Progress;
+	return nil;
+}
+
+@(private)
+_reader_consume_err :: proc(b: ^Reader) -> io.Error {
+	err := b.err;
+	b.err = nil;
+	return err;
+}
+
+// reader_peek returns the next n bytes without advancing the reader
+// The bytes stop being valid on the next read call
+// If reader_peek returns fewer than n bytes, it also return an error
+// explaining why the read is short
+// The error will be .Buffer_Full if n is larger than the internal buffer size
+reader_peek :: proc(b: ^Reader, n: int) -> (data: []byte, err: io.Error) {
+	n := n;
+
+	if n < 0 {
+		return nil, .Negative_Count;
+	}
+	b.last_byte = -1;
+	b.last_rune_size = -1;
+
+	for b.w-b.r < n && b.w-b.r < len(b.buf) && b.err == nil {
+		if fill_err := _reader_read_new_chunk(b); fill_err != nil {
+			return nil, fill_err;
+		}
+	}
+
+	if n > len(b.buf) {
+		return b.buf[b.r : b.w], .Buffer_Full;
+	}
+
+	if available := b.w - b.r; available < n {
+		n = available;
+		err = _reader_consume_err(b);
+		if err == nil {
+			err = .Buffer_Full;
+		}
+	}
+
+	return b.buf[b.r : b.r+n], err;
+}
+
+// reader_buffered returns the number of bytes that can be read from the current buffer
+reader_buffered :: proc(b: ^Reader) -> int {
+	return b.w - b.r;
+}
+
+// reader_discard skips the next n bytes, and returns the number of bytes that were discarded
+reader_discard :: proc(b: ^Reader, n: int) -> (discarded: int, err: io.Error) {
+	if n < 0 {
+		return 0, .Negative_Count;
+	}
+	if n == 0 {
+		return;
+	}
+
+	remaining := n;
+	for {
+		skip := reader_buffered(b);
+		if skip == 0 {
+			if fill_err := _reader_read_new_chunk(b); fill_err != nil {
+				return 0, fill_err;
+			}
+			skip = reader_buffered(b);
+		}
+		skip = min(skip, remaining);
+		b.r += skip;
+		remaining -= skip;
+		if remaining == 0 {
+			return n, nil;
+		}
+		if b.err != nil {
+			return n - remaining, _reader_consume_err(b);
+		}
+	}
+
+	return;
+}
+
+// reader_read reads data into p
+// The bytes are taken from at most one read on the underlying Reader, which means n may be less than len(p)
+reader_read :: proc(b: ^Reader, p: []byte) -> (n: int, err: io.Error) {
+	n = len(p);
+	if n == 0 {
+		if reader_buffered(b) > 0 {
+			return 0, nil;
+		}
+		return 0, _reader_consume_err(b);
+	}
+	if b.r == b.w {
+		if b.err != nil {
+			return 0, _reader_consume_err(b);
+		}
+
+		if len(p) >= len(b.buf) {
+			n, b.err = io.read(b.rd, p);
+			if n < 0 {
+				return 0, .Negative_Read;
+			}
+
+			if n > 0 {
+				b.last_byte = int(p[n-1]);
+				b.last_rune_size = -1;
+			}
+			return n, _reader_consume_err(b);
+		}
+
+		b.r, b.w = 0, 0;
+		n, b.err = io.read(b.rd, b.buf);
+		if n < 0 {
+			return 0, .Negative_Read;
+		}
+		if n == 0 {
+			return 0, _reader_consume_err(b);
+		}
+		b.w += n;
+	}
+
+	n = copy(p, b.buf[b.r:b.w]);
+	b.r += n;
+	b.last_byte = int(b.buf[b.r-1]);
+	b.last_rune_size = -1;
+	return n, nil;
+}
+
+// reader_read_byte reads and returns a single byte
+// If no byte is available, it return an error
+reader_read_byte :: proc(b: ^Reader) -> (byte, io.Error) {
+	b.last_rune_size = -1;
+	for b.r == b.w {
+		if b.err != nil {
+			return 0, _reader_consume_err(b);
+		}
+		if err := _reader_read_new_chunk(b); err != nil {
+			return 0, err;
+		}
+	}
+	c := b.buf[b.r];
+	b.r += 1;
+	b.last_byte = int(c);
+	return c, nil;
+}
+
+// reader_unread_byte unreads the last byte. Only the most recently read byte can be unread
+reader_unread_byte :: proc(b: ^Reader) -> io.Error {
+	if b.last_byte < 0 || b.r == 0 && b.w > 0 {
+		return .Invalid_Unread;
+	}
+	if b.r > 0 {
+		b.r -= 1;
+	} else {
+		// b.r == 0 && b.w == 0
+		b.w = 1;
+	}
+	b.buf[b.r] = byte(b.last_byte);
+	b.last_byte = -1;
+	b.last_rune_size = -1;
+	return nil;
+}
+
+// reader_read_rune reads a single UTF-8 encoded unicode character
+// and returns the rune and its size in bytes
+// If the encoded rune is invalid, it consumes one byte and returns utf8.RUNE_ERROR (U+FFFD) with a size of 1
+reader_read_rune :: proc(b: ^Reader) -> (r: rune, size: int, err: io.Error) {
+	for b.r+utf8.UTF_MAX > b.w &&
+	    !utf8.full_rune(b.buf[b.r:b.w]) &&
+	    b.err == nil &&
+	    b.w-b.w < len(b.buf) {
+		if err = _reader_read_new_chunk(b); err != nil {
+			return;
+		}
+	}
+
+	b.last_rune_size = -1;
+	if b.r == b.w {
+		err = _reader_consume_err(b);
+		return;
+	}
+	r, size = rune(b.buf[b.r]), 1;
+	if r >= utf8.RUNE_SELF {
+		r, size = utf8.decode_rune(b.buf[b.r : b.w]);
+	}
+	b.r += size;
+	b.last_byte = int(b.buf[b.r-1]);
+	b.last_rune_size = size;
+	return;
+}
+
+// reader_unread_rune unreads the last rune. Only the most recently read rune can be unread
+reader_unread_rune :: proc(b: ^Reader) -> io.Error {
+	if b.last_rune_size < 0 || b.r < b.last_rune_size {
+		return .Invalid_Unread;
+	}
+	b.r -= b.last_rune_size;
+	b.last_byte = -1;
+	b.last_rune_size = -1;
+	return nil;
+}
+
+reader_write_to :: proc(b: ^Reader, w: io.Writer) -> (n: i64, err: io.Error) {
+	write_buf :: proc(b: ^Reader, w: io.Writer) -> (i64, io.Error) {
+		n, err := io.write(w, b.buf[b.r:b.w]);
+		if n < 0 {
+			return 0, .Negative_Write;
+		}
+		b.r += n;
+		return i64(n), err;
+	}
+
+	n, err = write_buf(b, w);
+	if err != nil {
+		return;
+	}
+
+	m: i64;
+	if nr, ok := io.to_writer_to(b.rd); ok {
+		m, err = io.write_to(nr, w);
+		n += m;
+		return n, err;
+	}
+
+	if nw, ok := io.to_reader_from(w); ok {
+		m, err = io.read_from(nw, b.rd);
+		n += m;
+		return n, err;
+	}
+
+	if b.w-b.r < len(b.buf) {
+		if err = _reader_read_new_chunk(b); err != nil {
+			return;
+		}
+	}
+
+	for b.r < b.w {
+		m, err = write_buf(b, w);
+		n += m;
+		if err != nil {
+			return;
+		}
+		if err = _reader_read_new_chunk(b); err != nil {
+			return;
+		}
+	}
+
+	if b.err == .EOF {
+		b.err = nil;
+	}
+
+	err = _reader_consume_err(b);
+	return;
+}
+
+
+
+// reader_to_stream converts a Reader into an io.Stream
+reader_to_stream :: proc(b: ^Reader) -> (s: io.Stream) {
+	s.stream_data = b;
+	s.stream_vtable = _reader_vtable;
+	return;
+}
+
+
+
+@(private)
+_reader_vtable := &io.Stream_VTable{
+	impl_destroy = proc(s: io.Stream) -> io.Error {
+		b := (^Reader)(s.stream_data);
+		reader_destroy(b);
+		return nil;
+	},
+	impl_read = proc(s: io.Stream, p: []byte) -> (n: int, err: io.Error) {
+		b := (^Reader)(s.stream_data);
+		return reader_read(b, p);
+	},
+	impl_read_byte = proc(s: io.Stream) -> (c: byte, err: io.Error) {
+		b := (^Reader)(s.stream_data);
+		return reader_read_byte(b);
+	},
+	impl_unread_byte = proc(s: io.Stream) -> io.Error {
+		b := (^Reader)(s.stream_data);
+		return reader_unread_byte(b);
+	},
+	impl_read_rune = proc(s: io.Stream) -> (r: rune, size: int, err: io.Error) {
+		b := (^Reader)(s.stream_data);
+		return reader_read_rune(b);
+	},
+	impl_unread_rune = proc(s: io.Stream) -> io.Error {
+		b := (^Reader)(s.stream_data);
+		return reader_unread_rune(b);
+	},
+	impl_write_to = proc(s: io.Stream, w: io.Writer) -> (n: i64, err: io.Error) {
+		b := (^Reader)(s.stream_data);
+		return reader_write_to(b, w);
+	},
+};
+
+
+
+//
+// Utility procedures
+//
+
+
+// reader_read_slice reads until the first occurrence of delim from the reader
+// It returns a slice pointing at the bytes in the buffer
+// The bytes stop being valid at the next read
+// If reader_read_slice encounters an error before finding a delimiter
+// reader_read_slice fails with error .Buffer_Full if the buffer fills without a delim
+// Because the data returned from reader_read_slice will be overwritten on the
+// next IO operation, reader_read_bytes or reader_read_string is usually preferred
+//
+// reader_read_slice returns err != nil if and only if line does not end in delim
+//
+reader_read_slice :: proc(b: ^Reader, delim: byte) -> (line: []byte, err: io.Error) {
+	s := 0;
+	for {
+		if i := bytes.index_byte(b.buf[b.r+s : b.w], delim); i >= 0 {
+			i += s;
+			line = b.buf[b.r:][:i+1];
+			b.r += i + 1;
+			break;
+		}
+
+		if b.err != nil {
+			line = b.buf[b.r : b.w];
+			b.r = b.w;
+			err = _reader_consume_err(b);
+			break;
+		}
+
+		if reader_buffered(b) >= len(b.buf) {
+			b.r = b.w;
+			line = b.buf;
+			err = .Buffer_Full;
+			break;
+		}
+
+		s = b.w - b.r;
+
+		if err = _reader_read_new_chunk(b); err != nil {
+			break;
+		}
+	}
+
+	if i := len(line)-1; i >= 0 {
+		b.last_byte = int(line[i]);
+		b.last_rune_size = -1;
+	}
+
+	return;
+}
+
+// reader_read_bytes reads until the first occurrence of delim from the Reader
+// It returns an allocated slice containing the data up to and including the delimiter
+reader_read_bytes :: proc(b: ^Reader, delim: byte, allocator := context.allocator) -> (buf: []byte, err: io.Error) {
+	full: [dynamic]byte;
+	full.allocator = allocator;
+
+	frag: []byte;
+	for {
+		e: io.Error;
+		frag, e = reader_read_slice(b, delim);
+		if e == nil {
+			break;
+		}
+		if e != .Buffer_Full {
+			err = e;
+			break;
+		}
+
+		append(&full, ..frag);
+	}
+	append(&full, ..frag);
+	return full[:], err;
+}
+
+// reader_read_string reads until the first occurrence of delim from the Reader
+// It returns an allocated string containing the data up to and including the delimiter
+reader_read_string :: proc(b: ^Reader, delim: byte, allocator := context.allocator) -> (string, io.Error) {
+	buf, err := reader_read_bytes(b, delim, allocator);
+	return string(buf), err;
+}

core/bufio/writer.odin

@@ -0,0 +1,255 @@
+package bufio
+
+import "core:io"
+import "core:mem"
+import "core:unicode/utf8"
+// import "core:bytes"
+
+// Writer is a buffered wrapper for an io.Writer
+Writer :: struct {
+	buf:            []byte,
+	buf_allocator:  mem.Allocator,
+
+	wr: io.Writer,
+	n: int,
+
+	err: io.Error,
+
+}
+
+writer_init :: proc(b: ^Writer, wr: io.Writer, size: int = DEFAULT_BUF_SIZE, allocator := context.allocator) {
+	size := size;
+	size = max(size, MIN_READ_BUFFER_SIZE);
+	writer_reset(b, wr);
+	b.buf_allocator = allocator;
+	b.buf = make([]byte, size, allocator);
+}
+
+writer_init_with_buf :: proc(b: ^Writer, wr: io.Writer, buf: []byte) {
+	writer_reset(b, wr);
+	b.buf_allocator = {};
+	b.buf = buf;
+}
+
+// writer_destroy destroys the underlying buffer with its associated allocator IFF that allocator has been set
+writer_destroy :: proc(b: ^Writer) {
+	delete(b.buf, b.buf_allocator);
+	b^ = {};
+}
+
+// writer_size returns the size of underlying buffer in bytes
+writer_size :: proc(b: ^Writer) -> int {
+	return len(b.buf);
+}
+
+writer_reset :: proc(b: ^Writer, w: io.Writer) {
+	b.wr = w;
+	b.n = 0;
+	b.err = nil;
+}
+
+
+// writer_flush writes any buffered data into the underlying io.Writer
+writer_flush :: proc(b: ^Writer) -> io.Error {
+	if b.err != nil {
+		return b.err;
+	}
+	if b.n == 0 {
+		return nil;
+	}
+
+	n, err := io.write(b.wr, b.buf[0:b.n]);
+	if n < b.n && err == nil {
+		err = .Short_Write;
+	}
+	if err != nil {
+		if n > 0 && n < b.n {
+			copy(b.buf[:b.n-n], b.buf[n : b.n]);
+		}
+		b.n -= n;
+		b.err = err;
+		return err;
+	}
+	b.n = 0;
+	return nil;
+}
+
+// writer_available returns how many bytes are unused in the buffer
+writer_available :: proc(b: ^Writer) -> int {
+	return len(b.buf) - b.n;
+}
+
+// writer_buffered returns the number of bytes that have been writted into the current buffer
+writer_buffered :: proc(b: ^Writer) -> int {
+	return b.n;
+}
+
+// writer_write writes the contents of p into the buffer
+// It returns the number of bytes written
+// If n < len(p), it will return an error explaining why the write is short
+writer_write :: proc(b: ^Writer, p: []byte) -> (n: int, err: io.Error) {
+	p := p;
+	for len(p) > writer_available(b) && b.err == nil {
+		m: int;
+		if writer_buffered(b) == 0 {
+			m, b.err = io.write(b.wr, p);
+		} else {
+			m = copy(b.buf[b.n:], p);
+			b.n += m;
+			writer_flush(b);
+		}
+		n += m;
+		p = p[m:];
+	}
+	if b.err != nil {
+		return n, b.err;
+	}
+	m := copy(b.buf[b.n:], p);
+	b.n += m;
+	m += n;
+	return m, nil;
+}
+
+// writer_write_byte writes a single byte
+writer_write_byte :: proc(b: ^Writer, c: byte) -> io.Error {
+	if b.err != nil {
+		return b.err;
+	}
+	if writer_available(b) <= 0 && writer_flush(b) != nil {
+		return b.err;
+	}
+	b.buf[b.n] = c;
+	b.n += 1;
+	return nil;
+}
+
+// writer_write_rune writes a single unicode code point, and returns the number of bytes written with any error
+writer_write_rune :: proc(b: ^Writer, r: rune) -> (size: int, err: io.Error) {
+	if r < utf8.RUNE_SELF {
+		err = writer_write_byte(b, byte(r));
+		size = 0 if err != nil else 1;
+		return;
+	}
+	if b.err != nil {
+		return 0, b.err;
+	}
+
+	buf: [4]u8;
+
+	n := writer_available(b);
+	if n < utf8.UTF_MAX {
+		writer_flush(b);
+		if b.err != nil {
+			return 0, b.err;
+		}
+		n = writer_available(b);
+		if n < utf8.UTF_MAX {
+			// this only happens if the buffer is very small
+			w: int;
+			buf, w = utf8.encode_rune(r);
+			return writer_write(b, buf[:w]);
+		}
+	}
+
+	buf, size = utf8.encode_rune(r);
+	copy(b.buf[b.n:], buf[:size]);
+	b.n += size;
+	return;
+}
+
+// writer_write writes a string into the buffer
+// It returns the number of bytes written
+// If n < len(p), it will return an error explaining why the write is short
+writer_write_string :: proc(b: ^Writer, s: string) -> (int, io.Error) {
+	return writer_write(b, transmute([]byte)s);
+}
+
+// writer_read_from is to support io.Reader_From types
+// If the underlying writer supports the io,read_from, and b has no buffered data yet,
+// this procedure calls the underlying read_from implementation without buffering
+writer_read_from :: proc(b: ^Writer, r: io.Reader) -> (n: i64, err: io.Error) {
+	if b.err != nil {
+		return 0, b.err;
+	}
+	if writer_buffered(b) == 0 {
+		if w, ok := io.to_reader_from(b.wr); !ok {
+			n, err = io.read_from(w, r);
+			b.err = err;
+			return;
+		}
+	}
+
+	for {
+		if writer_available(b) == 0 {
+			if ferr := writer_flush(b); ferr != nil {
+				return n, ferr;
+			}
+		}
+		m: int;
+		nr := 0;
+		for nr < MAX_CONSECUTIVE_EMPTY_READS {
+			m, err = io.read(r, b.buf[b.n:]);
+			if m != 0 || err != nil {
+				break;
+			}
+			nr += 1;
+		}
+		if nr == MAX_CONSECUTIVE_EMPTY_READS {
+			return n, .No_Progress;
+		}
+		b.n += m;
+		n += i64(m);
+		if err != nil {
+			break;
+		}
+	}
+
+	if err == .EOF {
+		if writer_available(b) == 0 {
+			err = writer_flush(b);
+		} else {
+			err = nil;
+		}
+	}
+	return;
+}
+
+
+
+// writer_to_stream converts a Writer into an io.Stream
+writer_to_stream :: proc(b: ^Writer) -> (s: io.Stream) {
+	s.stream_data = b;
+	s.stream_vtable = _writer_vtable;
+	return;
+}
+
+
+
+@(private)
+_writer_vtable := &io.Stream_VTable{
+	impl_destroy = proc(s: io.Stream) -> io.Error {
+		b := (^Writer)(s.stream_data);
+		writer_destroy(b);
+		return nil;
+	},
+	impl_flush = proc(s: io.Stream)  -> io.Error {
+		b := (^Writer)(s.stream_data);
+		return writer_flush(b);
+	},
+	impl_write = proc(s: io.Stream, p: []byte) -> (n: int, err: io.Error) {
+		b := (^Writer)(s.stream_data);
+		return writer_write(b, p);
+	},
+	impl_write_byte = proc(s: io.Stream, c: byte) -> io.Error {
+		b := (^Writer)(s.stream_data);
+		return writer_write_byte(b, c);
+	},
+	impl_write_rune = proc(s: io.Stream, r: rune) -> (int, io.Error) {
+		b := (^Writer)(s.stream_data);
+		return writer_write_rune(b, r);
+	},
+	impl_read_from = proc(s: io.Stream, r: io.Reader) -> (n: i64, err: io.Error) {
+		b := (^Writer)(s.stream_data);
+		return writer_read_from(b, r);
+	},
+};

core/builtin/builtin.odin

@@ -0,0 +1,120 @@
+// This is purely for documentation
+package builtin
+
+nil   :: nil;
+false :: 0!==0;
+true  :: 0==0;
+
+ODIN_OS      :: ODIN_OS;
+ODIN_ARCH    :: ODIN_ARCH;
+ODIN_ENDIAN  :: ODIN_ENDIAN;
+ODIN_VENDOR  :: ODIN_VENDOR;
+ODIN_VERSION :: ODIN_VERSION;
+ODIN_ROOT    :: ODIN_ROOT;
+ODIN_DEBUG   :: ODIN_DEBUG;
+
+byte :: u8; // alias
+
+bool          :: bool;
+b8            :: b8;
+b16           :: b16;
+b32           :: b32;
+b64           :: b64;
+
+i8            :: i8;
+u8            :: u8;
+i16           :: i16;
+u16           :: u16;
+i32           :: i32;
+u32           :: u32;
+i64           :: i64;
+u64           :: u64;
+
+i128          :: i128;
+u128          :: u128;
+
+rune          :: rune;
+
+f16           :: f16;
+f32           :: f32;
+f64           :: f64;
+
+complex32     :: complex32;
+complex64     :: complex64;
+complex128    :: complex128;
+
+quaternion64  :: quaternion64;
+quaternion128 :: quaternion128;
+quaternion256 :: quaternion256;
+
+int           :: int;
+uint          :: uint;
+uintptr       :: uintptr;
+
+rawptr        :: rawptr;
+string        :: string;
+cstring       :: cstring;
+any           :: any;
+
+typeid        :: typeid;
+
+// Endian Specific Types
+i16le         :: i16le;
+u16le         :: u16le;
+i32le         :: i32le;
+u32le         :: u32le;
+i64le         :: i64le;
+u64le         :: u64le;
+i128le        :: i128le;
+u128le        :: u128le;
+
+i16be         :: i16be;
+u16be         :: u16be;
+i32be         :: i32be;
+u32be         :: u32be;
+i64be         :: i64be;
+u64be         :: u64be;
+i128be        :: i128be;
+u128be        :: u128be;
+
+
+f16le         :: f16le;
+f32le         :: f32le;
+f64le         :: f64le;
+
+f16be         :: f16be;
+f32be         :: f32be;
+f64be         :: f64be;
+
+
+
+// Procedures
+len :: proc(array: Array_Type) -> int ---
+cap :: proc(array: Array_Type) -> int ---
+
+size_of      :: proc($T: typeid) -> int ---
+align_of     :: proc($T: typeid) -> int ---
+offset_of    :: proc($T: typeid) -> uintptr ---
+type_of      :: proc(x: expr) -> type ---
+type_info_of :: proc($T: typeid) -> ^runtime.Type_Info ---
+typeid_of    :: proc($T: typeid) -> typeid ---
+
+swizzle :: proc(x: [N]T, indices: ..int) -> [len(indices)]T ---
+
+complex    :: proc(real, imag: Float) -> Complex_Type ---
+quaternion :: proc(real, imag, jmag, kmag: Float) -> Quaternion_Type ---
+real       :: proc(value: Complex_Or_Quaternion) -> Float ---
+imag       :: proc(value: Complex_Or_Quaternion) -> Float ---
+jmag       :: proc(value: Quaternion) -> Float ---
+kmag       :: proc(value: Quaternion) -> Float ---
+conj       :: proc(value: Complex_Or_Quaternion) -> Complex_Or_Quaternion ---
+
+expand_to_tuple :: proc(value: Struct_Or_Array) -> (A, B, C, ...) ---
+
+min   :: proc(values: ..T) -> T ---
+max   :: proc(values: ..T) -> T ---
+abs   :: proc(value: T) -> T ---
+clamp :: proc(value, minimum, maximum: T) -> T ---
+
+soa_zip :: proc(slices: ...) -> #soa[]Struct ---
+soa_unzip :: proc(value: $S/#soa[]$E) -> (slices: ...) ---

core/bytes/buffer.odin

@@ -0,0 +1,433 @@
+package bytes
+
+import "core:io"
+import "core:unicode/utf8"
+
+MIN_READ :: 512;
+
+@(private)
+SMALL_BUFFER_SIZE :: 64;
+
+// A Buffer is a variable-sized buffer of bytes with a io.Stream interface
+// The zero value for Buffer is an empty buffer ready to use.
+Buffer :: struct {
+	buf: [dynamic]byte,
+	off: int,
+	last_read: Read_Op,
+}
+
+@(private)
+Read_Op :: enum i8 {
+	Read       = -1,
+	Invalid    =  0,
+	Read_Rune1 =  1,
+	Read_Rune2 =  2,
+	Read_Rune3 =  3,
+	Read_Rune4 =  4,
+}
+
+
+buffer_init :: proc(b: ^Buffer, buf: []byte) {
+	resize(&b.buf, len(buf));
+	copy(b.buf[:], buf);
+}
+
+buffer_init_string :: proc(b: ^Buffer, s: string) {
+	resize(&b.buf, len(s));
+	copy(b.buf[:], s);
+}
+
+buffer_init_allocator :: proc(b: ^Buffer, len, cap: int, allocator := context.allocator) {
+	b.buf.allocator = allocator;
+	reserve(&b.buf, cap);
+	resize(&b.buf, len);
+}
+
+buffer_destroy :: proc(b: ^Buffer) {
+	delete(b.buf);
+	buffer_reset(b);
+}
+
+buffer_to_bytes :: proc(b: ^Buffer) -> []byte {
+	return b.buf[b.off:];
+}
+
+buffer_to_string :: proc(b: ^Buffer) -> string {
+	if b == nil {
+		return "<nil>";
+	}
+	return string(b.buf[b.off:]);
+}
+
+buffer_is_empty :: proc(b: ^Buffer) -> bool {
+	return len(b.buf) <= b.off;
+}
+
+buffer_length :: proc(b: ^Buffer) -> int {
+	return len(b.buf) - b.off;
+}
+
+buffer_capacity :: proc(b: ^Buffer) -> int {
+	return cap(b.buf);
+}
+
+buffer_reset :: proc(b: ^Buffer) {
+	clear(&b.buf);
+	b.off = 0;
+	b.last_read = .Invalid;
+}
+
+
+buffer_truncate :: proc(b: ^Buffer, n: int) {
+	if n == 0 {
+		buffer_reset(b);
+		return;
+	}
+	b.last_read = .Invalid;
+	if n < 0 || n > buffer_length(b) {
+		panic("bytes.truncate: truncation out of range");
+	}
+	resize(&b.buf, b.off+n);
+}
+
+@(private)
+_buffer_try_grow :: proc(b: ^Buffer, n: int) -> (int, bool) {
+	if l := len(b.buf); n <= cap(b.buf)-l {
+		resize(&b.buf, l+n);
+		return l, true;
+	}
+	return 0, false;
+}
+
+@(private)
+_buffer_grow :: proc(b: ^Buffer, n: int) -> int {
+	m := buffer_length(b);
+	if m == 0 && b.off != 0 {
+		buffer_reset(b);
+	}
+	if i, ok := _buffer_try_grow(b, n); ok {
+		return i;
+	}
+	if b.buf == nil && n <= SMALL_BUFFER_SIZE {
+		b.buf = make([dynamic]byte, n, SMALL_BUFFER_SIZE);
+		return 0;
+	}
+
+	c := cap(b.buf);
+	if n <= c/2 - m {
+		copy(b.buf[:], b.buf[b.off:]);
+	} else if c > max(int) - c - n {
+		panic("bytes.Buffer: too large");
+	} else {
+		resize(&b.buf, 2*c + n);
+		copy(b.buf[:], b.buf[b.off:]);
+	}
+	b.off = 0;
+	resize(&b.buf, m+n);
+	return m;
+}
+
+buffer_grow :: proc(b: ^Buffer, n: int) {
+	if n < 0 {
+		panic("bytes.buffer_grow: negative count");
+	}
+	m := _buffer_grow(b, n);
+	resize(&b.buf, m);
+}
+
+buffer_write_at :: proc(b: ^Buffer, p: []byte, offset: int) -> (n: int, err: io.Error) {
+	b.last_read = .Invalid;
+	if offset < 0 {
+		err = .Invalid_Offset;
+		return;
+	}
+	_, ok := _buffer_try_grow(b, offset+len(p));
+	if !ok {
+		_ = _buffer_grow(b, offset+len(p));
+	}
+	if len(b.buf) <= offset {
+		return 0, .Short_Write;
+	}
+	return copy(b.buf[offset:], p), nil;
+}
+
+
+buffer_write :: proc(b: ^Buffer, p: []byte) -> (n: int, err: io.Error) {
+	b.last_read = .Invalid;
+	m, ok := _buffer_try_grow(b, len(p));
+	if !ok {
+		m = _buffer_grow(b, len(p));
+	}
+	return copy(b.buf[m:], p), nil;
+}
+
+buffer_write_string :: proc(b: ^Buffer, s: string) -> (n: int, err: io.Error) {
+	b.last_read = .Invalid;
+	m, ok := _buffer_try_grow(b, len(s));
+	if !ok {
+		m = _buffer_grow(b, len(s));
+	}
+	return copy(b.buf[m:], s), nil;
+}
+
+buffer_write_byte :: proc(b: ^Buffer, c: byte) -> io.Error {
+	b.last_read = .Invalid;
+	m, ok := _buffer_try_grow(b, 1);
+	if !ok {
+		m = _buffer_grow(b, 1);
+	}
+	b.buf[m] = c;
+	return nil;
+}
+
+buffer_write_rune :: proc(b: ^Buffer, r: rune) -> (n: int, err: io.Error) {
+	if r < utf8.RUNE_SELF {
+		buffer_write_byte(b, byte(r));
+		return 1, nil;
+	}
+	b.last_read = .Invalid;
+	m, ok := _buffer_try_grow(b, utf8.UTF_MAX);
+	if !ok {
+		m = _buffer_grow(b, utf8.UTF_MAX);
+	}
+	res: [4]byte;
+	res, n = utf8.encode_rune(r);
+	copy(b.buf[m:][:utf8.UTF_MAX], res[:n]);
+	resize(&b.buf, m+n);
+	return;
+}
+
+buffer_next :: proc(b: ^Buffer, n: int) -> []byte {
+	n := n;
+	b.last_read = .Invalid;
+	m := buffer_length(b);
+	if n > m {
+		n = m;
+	}
+	data := b.buf[b.off : b.off + n];
+	b.off += n;
+	if n > 0 {
+		b.last_read = .Read;
+	}
+	return data;
+}
+
+buffer_read :: proc(b: ^Buffer, p: []byte) -> (n: int, err: io.Error) {
+	b.last_read = .Invalid;
+	if buffer_is_empty(b) {
+		buffer_reset(b);
+		if len(p) == 0 {
+			return 0, nil;
+		}
+		return 0, .EOF;
+	}
+	n = copy(p, b.buf[b.off:]);
+	b.off += n;
+	if n > 0 {
+		b.last_read = .Read;
+	}
+	return;
+}
+
+buffer_read_at :: proc(b: ^Buffer, p: []byte, offset: int) -> (n: int, err: io.Error) {
+	b.last_read = .Invalid;
+
+	if offset < 0 || offset >= len(b.buf) {
+		err = .Invalid_Offset;
+		return;
+	}
+
+	if 0 <= offset && offset < len(b.buf) {
+		n = copy(p, b.buf[offset:]);
+	}
+	if n > 0 {
+		b.last_read = .Read;
+	}
+	return;
+}
+
+
+buffer_read_byte :: proc(b: ^Buffer) -> (byte, io.Error) {
+	if buffer_is_empty(b) {
+		buffer_reset(b);
+		return 0, .EOF;
+	}
+	c := b.buf[b.off];
+	b.off += 1;
+	b.last_read = .Read;
+	return c, nil;
+}
+
+buffer_read_rune :: proc(b: ^Buffer) -> (r: rune, size: int, err: io.Error) {
+	if buffer_is_empty(b) {
+		buffer_reset(b);
+		return 0, 0, .EOF;
+	}
+	c := b.buf[b.off];
+	if c < utf8.RUNE_SELF {
+		b.off += 1;
+		b.last_read = .Read_Rune1;
+		return rune(c), 1, nil;
+	}
+	r, size = utf8.decode_rune(b.buf[b.off:]);
+	b.off += size;
+	b.last_read = Read_Op(i8(size));
+	return;
+}
+
+buffer_unread_byte :: proc(b: ^Buffer) -> io.Error {
+	if b.last_read == .Invalid {
+		return .Invalid_Unread;
+	}
+	b.last_read = .Invalid;
+	if b.off > 0 {
+		b.off -= 1;
+	}
+	return nil;
+}
+
+buffer_unread_rune :: proc(b: ^Buffer) -> io.Error {
+	if b.last_read <= .Invalid {
+		return .Invalid_Unread;
+	}
+	if b.off >= int(b.last_read) {
+		b.off -= int(i8(b.last_read));
+	}
+	b.last_read = .Invalid;
+	return nil;
+}
+
+
+buffer_read_bytes :: proc(b: ^Buffer, delim: byte) -> (line: []byte, err: io.Error) {
+	i := index_byte(b.buf[b.off:], delim);
+	end := b.off + i + 1;
+	if i < 0 {
+		end = len(b.buf);
+		err = .EOF;
+	}
+	line = b.buf[b.off:end];
+	b.off = end;
+	b.last_read = .Read;
+	return;
+}
+
+buffer_read_string :: proc(b: ^Buffer, delim: byte) -> (line: string, err: io.Error) {
+	slice: []byte;
+	slice, err = buffer_read_bytes(b, delim);
+	return string(slice), err;
+}
+
+buffer_write_to :: proc(b: ^Buffer, w: io.Writer) -> (n: i64, err: io.Error) {
+	b.last_read = .Invalid;
+	if byte_count := buffer_length(b); byte_count > 0 {
+		m, e := io.write(w, b.buf[b.off:]);
+		if m > byte_count {
+			panic("bytes.buffer_write_to: invalid io.write count");
+		}
+		b.off += m;
+		n = i64(m);
+		if e != nil {
+			err = e;
+			return;
+		}
+		if m != byte_count {
+			err = .Short_Write;
+			return;
+		}
+	}
+	buffer_reset(b);
+	return;
+}
+
+buffer_read_from :: proc(b: ^Buffer, r: io.Reader) -> (n: i64, err: io.Error) #no_bounds_check {
+	b.last_read = .Invalid;
+	for {
+		i := _buffer_grow(b, MIN_READ);
+		resize(&b.buf, i);
+		m, e := io.read(r, b.buf[i:cap(b.buf)]);
+		if m < 0 {
+			err = .Negative_Read;
+			return;
+		}
+
+		resize(&b.buf, i+m);
+		n += i64(m);
+		if e == .EOF {
+			return;
+		}
+		if e != nil {
+			err = e;
+			return;
+		}
+	}
+	return;
+}
+
+
+buffer_to_stream :: proc(b: ^Buffer) -> (s: io.Stream) {
+	s.stream_data = b;
+	s.stream_vtable = _buffer_vtable;
+	return;
+}
+
+@(private)
+_buffer_vtable := &io.Stream_VTable{
+	impl_size = proc(s: io.Stream) -> i64 {
+		b := (^Buffer)(s.stream_data);
+		return i64(buffer_capacity(b));
+	},
+	impl_read = proc(s: io.Stream, p: []byte) -> (n: int, err: io.Error) {
+		b := (^Buffer)(s.stream_data);
+		return buffer_read(b, p);
+	},
+	impl_read_at = proc(s: io.Stream, p: []byte, offset: i64) -> (n: int, err: io.Error) {
+		b := (^Buffer)(s.stream_data);
+		return buffer_read_at(b, p, int(offset));
+	},
+	impl_read_byte = proc(s: io.Stream) -> (byte, io.Error) {
+		b := (^Buffer)(s.stream_data);
+		return buffer_read_byte(b);
+	},
+	impl_read_rune = proc(s: io.Stream) -> (r: rune, size: int, err: io.Error) {
+		b := (^Buffer)(s.stream_data);
+		return buffer_read_rune(b);
+	},
+	impl_write = proc(s: io.Stream, p: []byte) -> (n: int, err: io.Error) {
+		b := (^Buffer)(s.stream_data);
+		return buffer_write(b, p);
+	},
+	impl_write_at = proc(s: io.Stream, p: []byte, offset: i64) -> (n: int, err: io.Error) {
+		b := (^Buffer)(s.stream_data);
+		return buffer_write_at(b, p, int(offset));
+	},
+	impl_write_byte = proc(s: io.Stream, c: byte) -> io.Error {
+		b := (^Buffer)(s.stream_data);
+		return buffer_write_byte(b, c);
+	},
+	impl_write_rune = proc(s: io.Stream, r: rune) -> (int, io.Error) {
+		b := (^Buffer)(s.stream_data);
+		return buffer_write_rune(b, r);
+	},
+	impl_unread_byte = proc(s: io.Stream) -> io.Error {
+		b := (^Buffer)(s.stream_data);
+		return buffer_unread_byte(b);
+	},
+	impl_unread_rune = proc(s: io.Stream) -> io.Error {
+		b := (^Buffer)(s.stream_data);
+		return buffer_unread_rune(b);
+	},
+	impl_destroy = proc(s: io.Stream) -> io.Error {
+		b := (^Buffer)(s.stream_data);
+		buffer_destroy(b);
+		return nil;
+	},
+	impl_write_to = proc(s: io.Stream, w: io.Writer) -> (n: i64, err: io.Error) {
+		b := (^Buffer)(s.stream_data);
+		return buffer_write_to(b, w);
+	},
+	impl_read_from = proc(s: io.Stream, r: io.Reader) -> (n: i64, err: io.Error) {
+		b := (^Buffer)(s.stream_data);
+		return buffer_read_from(b, r);
+	},
+};
+

core/bytes/reader.odin

@@ -0,0 +1,177 @@
+package bytes
+
+import "core:io"
+import "core:unicode/utf8"
+
+Reader :: struct {
+	s:         []byte, // read-only buffer
+	i:         i64,    // current reading index
+	prev_rune: int,    // previous reading index of rune or < 0
+}
+
+reader_init :: proc(r: ^Reader, s: []byte) {
+	r.s = s;
+	r.i = 0;
+	r.prev_rune = -1;
+}
+
+reader_to_stream :: proc(r: ^Reader) -> (s: io.Stream) {
+	s.stream_data = r;
+	s.stream_vtable = _reader_vtable;
+	return;
+}
+
+reader_length :: proc(r: ^Reader) -> int {
+	if r.i >= i64(len(r.s)) {
+		return 0;
+	}
+	return int(i64(len(r.s)) - r.i);
+}
+
+reader_size :: proc(r: ^Reader) -> i64 {
+	return i64(len(r.s));
+}
+
+reader_read :: proc(r: ^Reader, p: []byte) -> (n: int, err: io.Error) {
+	if r.i >= i64(len(r.s)) {
+		return 0, .EOF;
+	}
+	r.prev_rune = -1;
+	n = copy(p, r.s[r.i:]);
+	r.i += i64(n);
+	return;
+}
+reader_read_at :: proc(r: ^Reader, p: []byte, off: i64) -> (n: int, err: io.Error) {
+	if off < 0 {
+		return 0, .Invalid_Offset;
+	}
+	if off >= i64(len(r.s)) {
+		return 0, .EOF;
+	}
+	n = copy(p, r.s[off:]);
+	if n < len(p) {
+		err = .EOF;
+	}
+	return;
+}
+reader_read_byte :: proc(r: ^Reader) -> (byte, io.Error) {
+	r.prev_rune = -1;
+	if r.i >= i64(len(r.s)) {
+		return 0, .EOF;
+	}
+	b := r.s[r.i];
+	r.i += 1;
+	return b, nil;
+}
+reader_unread_byte :: proc(r: ^Reader) -> io.Error {
+	if r.i <= 0 {
+		return .Invalid_Unread;
+	}
+	r.prev_rune = -1;
+	r.i -= 1;
+	return nil;
+}
+reader_read_rune :: proc(r: ^Reader) -> (ch: rune, size: int, err: io.Error) {
+	if r.i >= i64(len(r.s)) {
+		r.prev_rune = -1;
+		return 0, 0, .EOF;
+	}
+	r.prev_rune = int(r.i);
+	if c := r.s[r.i]; c < utf8.RUNE_SELF {
+		r.i += 1;
+		return rune(c), 1, nil;
+	}
+	ch, size = utf8.decode_rune(r.s[r.i:]);
+	r.i += i64(size);
+	return;
+}
+reader_unread_rune :: proc(r: ^Reader) -> io.Error {
+	if r.i <= 0 {
+		return .Invalid_Unread;
+	}
+	if r.prev_rune < 0 {
+		return .Invalid_Unread;
+	}
+	r.i = i64(r.prev_rune);
+	r.prev_rune = -1;
+	return nil;
+}
+reader_seek :: proc(r: ^Reader, offset: i64, whence: io.Seek_From) -> (i64, io.Error) {
+	r.prev_rune = -1;
+	abs: i64;
+	switch whence {
+	case .Start:
+		abs = offset;
+	case .Current:
+		abs = r.i + offset;
+	case .End:
+		abs = i64(len(r.s)) + offset;
+	case:
+		return 0, .Invalid_Whence;
+	}
+
+	if abs < 0 {
+		return 0, .Invalid_Offset;
+	}
+	r.i = abs;
+	return abs, nil;
+}
+reader_write_to :: proc(r: ^Reader, w: io.Writer) -> (n: i64, err: io.Error) {
+	r.prev_rune = -1;
+	if r.i >= i64(len(r.s)) {
+		return 0, nil;
+	}
+	s := r.s[r.i:];
+	m: int;
+	m, err = io.write(w, s);
+	if m > len(s) {
+		panic("bytes.Reader.write_to: invalid io.write_string count");
+	}
+	r.i += i64(m);
+	n = i64(m);
+	if m != len(s) && err == nil {
+		err = .Short_Write;
+	}
+	return;
+}
+
+
+@(private)
+_reader_vtable := &io.Stream_VTable{
+	impl_size = proc(s: io.Stream) -> i64 {
+		r := (^Reader)(s.stream_data);
+		return reader_size(r);
+	},
+	impl_read = proc(s: io.Stream, p: []byte) -> (n: int, err: io.Error) {
+		r := (^Reader)(s.stream_data);
+		return reader_read(r, p);
+	},
+	impl_read_at = proc(s: io.Stream, p: []byte, off: i64) -> (n: int, err: io.Error) {
+		r := (^Reader)(s.stream_data);
+		return reader_read_at(r, p, off);
+	},
+	impl_read_byte = proc(s: io.Stream) -> (byte, io.Error) {
+		r := (^Reader)(s.stream_data);
+		return reader_read_byte(r);
+	},
+	impl_unread_byte = proc(s: io.Stream) -> io.Error {
+		r := (^Reader)(s.stream_data);
+		return reader_unread_byte(r);
+	},
+	impl_read_rune = proc(s: io.Stream) -> (ch: rune, size: int, err: io.Error) {
+		r := (^Reader)(s.stream_data);
+		return reader_read_rune(r);
+	},
+	impl_unread_rune = proc(s: io.Stream) -> io.Error {
+		r := (^Reader)(s.stream_data);
+		return reader_unread_rune(r);
+	},
+	impl_seek = proc(s: io.Stream, offset: i64, whence: io.Seek_From) -> (i64, io.Error) {
+		r := (^Reader)(s.stream_data);
+		return reader_seek(r, offset, whence);
+	},
+	impl_write_to = proc(s: io.Stream, w: io.Writer) -> (n: i64, err: io.Error) {
+		r := (^Reader)(s.stream_data);
+		return reader_write_to(r, w);
+	},
+};

core/c/c.odin

@@ -0,0 +1,35 @@
+package c
+
+import b "core:builtin"
+
+CHAR_BIT :: 8;
+
+bool   :: b.bool;
+char   :: b.u8;
+byte   :: b.byte;
+schar  :: b.i8;
+uchar  :: b.u8;
+short  :: b.i16;
+ushort :: b.u16;
+int    :: b.i32;
+uint   :: b.u32;
+
+long  :: b.i32 when (ODIN_OS == "windows" || size_of(b.rawptr) == 4) else b.i64;
+ulong :: b.u32 when (ODIN_OS == "windows" || size_of(b.rawptr) == 4) else b.u64;
+
+longlong       :: b.i64;
+ulonglong      :: b.u64;
+float          :: b.f32;
+double         :: b.f64;
+complex_float  :: b.complex64;
+complex_double :: b.complex128;
+
+#assert(size_of(b.uintptr) == size_of(b.int));
+
+size_t    :: b.uint;
+ssize_t   :: b.int;
+ptrdiff_t :: b.int;
+uintptr_t :: b.uintptr;
+intptr_t  :: b.int;
+
+wchar_t :: b.u16 when (ODIN_OS == "windows") else b.u32;

core/c/frontend/preprocessor/const_expr.odin

@@ -0,0 +1,25 @@
+package c_frontend_preprocess
+
+import "core:c/frontend/tokenizer"
+
+const_expr :: proc(rest: ^^Token, tok: ^Token) -> i64 {
+	// TODO(bill): Handle const_expr correctly
+	// This is effectively a mini-parser
+
+	assert(rest != nil);
+	assert(tok != nil);
+	rest^ = tokenizer.new_eof(tok);
+	switch v in tok.val {
+	case i64:
+		return v;
+	case f64:
+		return i64(v);
+	case string:
+		return 0;
+	case []u16:
+		// TODO
+	case []u32:
+		// TODO
+	}
+	return 0;
+}

core/c/frontend/preprocessor/unquote.odin

@@ -0,0 +1,154 @@
+package c_frontend_preprocess
+
+import "core:unicode/utf8"
+
+unquote_char :: proc(str: string, quote: byte) -> (r: rune, multiple_bytes: bool, tail_string: string, success: bool) {
+	hex_to_int :: proc(c: byte) -> int {
+		switch c {
+		case '0'..'9': return int(c-'0');
+		case 'a'..'f': return int(c-'a')+10;
+		case 'A'..'F': return int(c-'A')+10;
+		}
+		return -1;
+	}
+	w: int;
+
+	if str[0] == quote && quote == '"' {
+		return;
+	} else if str[0] >= 0x80 {
+		r, w = utf8.decode_rune_in_string(str);
+		return r, true, str[w:], true;
+	} else if str[0] != '\\' {
+		return rune(str[0]), false, str[1:], true;
+	}
+
+	if len(str) <= 1 {
+		return;
+	}
+	s := str;
+	c := s[1];
+	s = s[2:];
+
+	switch c {
+	case: r = rune(c);
+
+	case 'a':  r = '\a';
+	case 'b':  r = '\b';
+	case 'e':  r = '\e';
+	case 'f':  r = '\f';
+	case 'n':  r = '\n';
+	case 'r':  r = '\r';
+	case 't':  r = '\t';
+	case 'v':  r = '\v';
+	case '\\': r = '\\';
+
+	case '"':  r = '"';
+	case '\'': r = '\'';
+
+	case '0'..'7':
+		v := int(c-'0');
+		if len(s) < 2 {
+			return;
+		}
+		for i in 0..<len(s) {
+			d := int(s[i]-'0');
+			if d < 0 || d > 7 {
+				return;
+			}
+			v = (v<<3) | d;
+		}
+		s = s[2:];
+		if v > 0xff {
+			return;
+		}
+		r = rune(v);
+
+	case 'x', 'u', 'U':
+		count: int;
+		switch c {
+		case 'x': count = 2;
+		case 'u': count = 4;
+		case 'U': count = 8;
+		}
+
+		if len(s) < count {
+			return;
+		}
+
+		for i in 0..<count {
+			d := hex_to_int(s[i]);
+			if d < 0 {
+				return;
+			}
+			r = (r<<4) | rune(d);
+		}
+		s = s[count:];
+		if c == 'x' {
+			break;
+		}
+		if r > utf8.MAX_RUNE {
+			return;
+		}
+		multiple_bytes = true;
+	}
+
+	success = true;
+	tail_string = s;
+	return;
+}
+
+unquote_string :: proc(lit: string, allocator := context.allocator) -> (res: string, allocated, success: bool) {
+	contains_rune :: proc(s: string, r: rune) -> int {
+		for c, offset in s {
+			if c == r {
+				return offset;
+			}
+		}
+		return -1;
+	}
+
+	assert(len(lit) >= 2);
+
+	s := lit;
+	quote := '"';
+
+	if s == `""` {
+		return "", false, true;
+	}
+
+	if contains_rune(s, '\n') >= 0 {
+		return s, false, false;
+	}
+
+	if contains_rune(s, '\\') < 0 && contains_rune(s, quote) < 0 {
+		if quote == '"' {
+			return s, false, true;
+		}
+	}
+	s = s[1:len(s)-1];
+
+
+	buf_len := 3*len(s) / 2;
+	buf := make([]byte, buf_len, allocator);
+	offset := 0;
+	for len(s) > 0 {
+		r, multiple_bytes, tail_string, ok := unquote_char(s, byte(quote));
+		if !ok {
+			delete(buf);
+			return s, false, false;
+		}
+		s = tail_string;
+		if r < 0x80 || !multiple_bytes {
+			buf[offset] = byte(r);
+			offset += 1;
+		} else {
+			b, w := utf8.encode_rune(r);
+			copy(buf[offset:], b[:w]);
+			offset += w;
+		}
+	}
+
+	new_string := string(buf[:offset]);
+
+	return new_string, true, true;
+}

core/c/frontend/tokenizer/doc.odin

@@ -0,0 +1,34 @@
+/*
+package demo
+
+import tokenizer "core:c/frontend/tokenizer"
+import preprocessor "core:c/frontend/preprocessor"
+import "core:fmt"
+
+main :: proc() {
+	t := &tokenizer.Tokenizer{};
+	tokenizer.init_defaults(t);
+
+	cpp := &preprocessor.Preprocessor{};
+	cpp.warn, cpp.err = t.warn, t.err;
+	preprocessor.init_lookup_tables(cpp);
+	preprocessor.init_default_macros(cpp);
+	cpp.include_paths = {"my/path/to/include"};
+
+	tok := tokenizer.tokenize_file(t, "the/source/file.c", 1);
+
+	tok = preprocessor.preprocess(cpp, tok);
+	if tok != nil {
+		for t := tok; t.kind != .EOF; t = t.next {
+			fmt.println(t.lit);
+		}
+	}
+
+	fmt.println("[Done]");
+}
+*/
+
+
+package c_frontend_tokenizer
+
+

core/c/frontend/tokenizer/hide_set.odin

@@ -0,0 +1,68 @@
+package c_frontend_tokenizer
+
+// NOTE(bill): This is a really dumb approach for a hide set,
+// but it's really simple and probably fast enough in practice
+
+
+Hide_Set :: struct {
+	next: ^Hide_Set,
+	name: string,
+}
+
+
+new_hide_set :: proc(name: string) -> ^Hide_Set {
+	hs := new(Hide_Set);
+	hs.name = name;
+	return hs;
+}
+
+hide_set_contains :: proc(hs: ^Hide_Set, name: string) -> bool {
+	for h := hs; h != nil; h = h.next {
+		if h.name == name {
+			return true;
+		}
+	}
+	return false;
+}
+
+
+hide_set_union :: proc(a, b: ^Hide_Set) -> ^Hide_Set {
+	head: Hide_Set;
+	curr := &head;
+
+	for h := a; h != nil; h = h.next {
+		curr.next = new_hide_set(h.name);
+		curr = curr.next;
+	}
+	curr.next = b;
+	return head.next;
+}
+
+
+hide_set_intersection :: proc(a, b: ^Hide_Set) -> ^Hide_Set {
+	head: Hide_Set;
+	curr := &head;
+
+	for h := a; h != nil; h = h.next {
+		if hide_set_contains(b, h.name) {
+			curr.next = new_hide_set(h.name);
+			curr = curr.next;
+		}
+	}
+	return head.next;
+}
+
+
+add_hide_set :: proc(tok: ^Token, hs: ^Hide_Set) -> ^Token {
+	head: Token;
+	curr := &head;
+
+	tok := tok;
+	for ; tok != nil; tok = tok.next {
+		t := copy_token(tok);
+		t.hide_set = hide_set_union(t.hide_set, hs);
+		curr.next = t;
+		curr = curr.next;
+	}
+	return head.next;
+}

core/c/frontend/tokenizer/token.odin

@@ -0,0 +1,169 @@
+package c_frontend_tokenizer
+
+
+Pos :: struct {
+	file:   string,
+	line:   int,
+	column: int,
+	offset: int,
+}
+
+Token_Kind :: enum {
+	Invalid,
+	Ident,
+	Punct,
+	Keyword,
+	Char,
+	String,
+	Number,
+	PP_Number,
+	Comment,
+	EOF,
+}
+
+File :: struct {
+	name: string,
+	id:   int,
+	src:  []byte,
+
+	display_name: string,
+	line_delta:   int,
+}
+
+
+Token_Type_Hint :: enum u8 {
+	None,
+
+	Int,
+	Long,
+	Long_Long,
+
+	Unsigned_Int,
+	Unsigned_Long,
+	Unsigned_Long_Long,
+
+	Float,
+	Double,
+	Long_Double,
+
+	UTF_8,
+	UTF_16,
+	UTF_32,
+	UTF_Wide,
+}
+
+Token_Value :: union {
+	i64,
+	f64,
+	string,
+	[]u16,
+	[]u32,
+}
+
+Token :: struct {
+	kind: Token_Kind,
+	next: ^Token,
+	lit: string,
+
+	pos:   Pos,
+	file:  ^File,
+	line_delta: int,
+	at_bol:     bool,
+	has_space:  bool,
+
+	type_hint: Token_Type_Hint,
+	val: Token_Value,
+	prefix: string,
+
+	// Preprocessor values
+	hide_set: ^Hide_Set,
+	origin:   ^Token,
+}
+
+Is_Keyword_Proc :: #type proc(tok: ^Token) -> bool;
+
+copy_token :: proc(tok: ^Token) -> ^Token {
+	t := new_clone(tok^);
+	t.next = nil;
+	return t;
+}
+
+new_eof :: proc(tok: ^Token) -> ^Token {
+	t := new_clone(tok^);
+	t.kind = .EOF;
+	t.lit = "";
+	return t;
+}
+
+default_is_keyword :: proc(tok: ^Token) -> bool {
+	if tok.kind == .Keyword {
+		return true;
+	}
+	if len(tok.lit) > 0 {
+		return default_keyword_set[tok.lit];
+	}
+	return false;
+}
+
+
+token_name := [Token_Kind]string {
+	.Invalid   = "invalid",
+	.Ident     = "ident",
+	.Punct     = "punct",
+	.Keyword   = "keyword",
+	.Char      = "char",
+	.String    = "string",
+	.Number    = "number",
+	.PP_Number = "preprocessor number",
+	.Comment   = "comment",
+	.EOF       = "eof",
+};
+
+default_keyword_set := map[string]bool{
+	"auto"          = true,
+	"break"         = true,
+	"case"          = true,
+	"char"          = true,
+	"const"         = true,
+	"continue"      = true,
+	"default"       = true,
+	"do"            = true,
+	"double"        = true,
+	"else"          = true,
+	"enum"          = true,
+	"extern"        = true,
+	"float"         = true,
+	"for"           = true,
+	"goto"          = true,
+	"if"            = true,
+	"int"           = true,
+	"long"          = true,
+	"register"      = true,
+	"restrict"      = true,
+	"return"        = true,
+	"short"         = true,
+	"signed"        = true,
+	"sizeof"        = true,
+	"static"        = true,
+	"struct"        = true,
+	"switch"        = true,
+	"typedef"       = true,
+	"union"         = true,
+	"unsigned"      = true,
+	"void"          = true,
+	"volatile"      = true,
+	"while"         = true,
+	"_Alignas"      = true,
+	"_Alignof"      = true,
+	"_Atomic"       = true,
+	"_Bool"         = true,
+	"_Generic"      = true,
+	"_Noreturn"     = true,
+	"_Thread_local" = true,
+	"__restrict"    = true,
+	"typeof"        = true,
+	"asm"           = true,
+	"__restrict__"  = true,
+	"__thread"      = true,
+	"__attribute__" = true,
+};

core/c/frontend/tokenizer/tokenizer.odin

@@ -0,0 +1,667 @@
+package c_frontend_tokenizer
+
+import "core:fmt"
+import "core:os"
+import "core:strings"
+import "core:unicode/utf8"
+
+
+Error_Handler :: #type proc(pos: Pos, fmt: string, args: ..any);
+
+
+Tokenizer :: struct {
+	// Immutable data
+	path: string,
+	src:  []byte,
+
+
+	// Tokenizing state
+	ch:          rune,
+	offset:      int,
+	read_offset: int,
+	line_offset: int,
+	line_count:  int,
+
+	// Extra information for tokens
+	at_bol:    bool,
+	has_space: bool,
+
+	// Mutable data
+	err:  Error_Handler,
+	warn: Error_Handler,
+	error_count:   int,
+	warning_count: int,
+}
+
+init_defaults :: proc(t: ^Tokenizer, err: Error_Handler = default_error_handler, warn: Error_Handler = default_warn_handler) {
+	t.err = err;
+	t.warn = warn;
+}
+
+
+@(private)
+offset_to_pos :: proc(t: ^Tokenizer, offset: int) -> (pos: Pos) {
+	pos.file = t.path;
+	pos.offset = offset;
+	pos.line = t.line_count;
+	pos.column = offset - t.line_offset + 1;
+	return;
+}
+
+default_error_handler :: proc(pos: Pos, msg: string, args: ..any) {
+	fmt.eprintf("%s(%d:%d) ", pos.file, pos.line, pos.column);
+	fmt.eprintf(msg, ..args);
+	fmt.eprintf("\n");
+}
+
+default_warn_handler :: proc(pos: Pos, msg: string, args: ..any) {
+	fmt.eprintf("%s(%d:%d) warning: ", pos.file, pos.line, pos.column);
+	fmt.eprintf(msg, ..args);
+	fmt.eprintf("\n");
+}
+
+error_offset :: proc(t: ^Tokenizer, offset: int, msg: string, args: ..any) {
+	pos := offset_to_pos(t, offset);
+	if t.err != nil {
+		t.err(pos, msg, ..args);
+	}
+	t.error_count += 1;
+}
+
+warn_offset :: proc(t: ^Tokenizer, offset: int, msg: string, args: ..any) {
+	pos := offset_to_pos(t, offset);
+	if t.warn != nil {
+		t.warn(pos, msg, ..args);
+	}
+	t.warning_count += 1;
+}
+
+error :: proc(t: ^Tokenizer, tok: ^Token, msg: string, args: ..any) {
+	pos := tok.pos;
+	if t.err != nil {
+		t.err(pos, msg, ..args);
+	}
+	t.error_count += 1;
+}
+
+warn :: proc(t: ^Tokenizer, tok: ^Token, msg: string, args: ..any) {
+	pos := tok.pos;
+	if t.warn != nil {
+		t.warn(pos, msg, ..args);
+	}
+	t.warning_count += 1;
+}
+
+
+advance_rune :: proc(t: ^Tokenizer) {
+	if t.read_offset < len(t.src) {
+		t.offset = t.read_offset;
+		if t.ch == '\n' {
+			t.at_bol = true;
+			t.line_offset = t.offset;
+			t.line_count += 1;
+		}
+		r, w := rune(t.src[t.read_offset]), 1;
+		switch {
+		case r == 0:
+			error_offset(t, t.offset, "illegal character NUL");
+		case r >= utf8.RUNE_SELF:
+			r, w = utf8.decode_rune(t.src[t.read_offset:]);
+			if r == utf8.RUNE_ERROR && w == 1 {
+				error_offset(t, t.offset, "illegal UTF-8 encoding");
+			} else if r == utf8.RUNE_BOM && t.offset > 0 {
+				error_offset(t, t.offset, "illegal byte order mark");
+			}
+		}
+		t.read_offset += w;
+		t.ch = r;
+	} else {
+		t.offset = len(t.src);
+		if t.ch == '\n' {
+			t.at_bol = true;
+			t.line_offset = t.offset;
+			t.line_count += 1;
+		}
+		t.ch = -1;
+	}
+}
+
+advance_rune_n :: proc(t: ^Tokenizer, n: int) {
+	for in 0..<n {
+		advance_rune(t);
+	}
+}
+
+is_digit :: proc(r: rune) -> bool {
+	return '0' <= r && r <= '9';
+}
+
+skip_whitespace :: proc(t: ^Tokenizer) {
+	for {
+		switch t.ch {
+		case ' ', '\t', '\r', '\v', '\f', '\n':
+			t.has_space = true;
+			advance_rune(t);
+		case:
+			return;
+		}
+	}
+}
+
+scan_comment :: proc(t: ^Tokenizer) -> string {
+	offset := t.offset-1;
+	next := -1;
+	general: {
+		if t.ch == '/'{ // line comments
+			advance_rune(t);
+			for t.ch != '\n' && t.ch >= 0 {
+				advance_rune(t);
+			}
+
+			next = t.offset;
+			if t.ch == '\n' {
+				next += 1;
+			}
+			break general;
+		}
+
+		/* style comment */
+		advance_rune(t);
+		for t.ch >= 0 {
+			ch := t.ch;
+			advance_rune(t);
+			if ch == '*' && t.ch == '/' {
+				advance_rune(t);
+				next = t.offset;
+				break general;
+			}
+		}
+
+		error_offset(t, offset, "comment not terminated");
+	}
+
+	lit := t.src[offset : t.offset];
+
+	// NOTE(bill): Strip CR for line comments
+	for len(lit) > 2 && lit[1] == '/' && lit[len(lit)-1] == '\r' {
+		lit = lit[:len(lit)-1];
+	}
+
+
+	return string(lit);
+}
+
+scan_identifier :: proc(t: ^Tokenizer) -> string {
+	offset := t.offset;
+
+	for is_ident1(t.ch) {
+		advance_rune(t);
+	}
+
+	return string(t.src[offset : t.offset]);
+}
+
+scan_string :: proc(t: ^Tokenizer) -> string {
+	offset := t.offset-1;
+
+	for {
+		ch := t.ch;
+		if ch == '\n' || ch < 0 {
+			error_offset(t, offset, "string literal was not terminated");
+			break;
+		}
+		advance_rune(t);
+		if ch == '"' {
+			break;
+		}
+		if ch == '\\' {
+			scan_escape(t);
+		}
+	}
+
+	return string(t.src[offset : t.offset]);
+}
+
+digit_val :: proc(r: rune) -> int {
+	switch r {
+	case '0'..'9':
+		return int(r-'0');
+	case 'A'..'F':
+		return int(r-'A' + 10);
+	case 'a'..'f':
+		return int(r-'a' + 10);
+	}
+	return 16;
+}
+
+scan_escape :: proc(t: ^Tokenizer) -> bool {
+	offset := t.offset;
+
+	esc := t.ch;
+	n: int;
+	base, max: u32;
+	switch esc {
+	case 'a', 'b', 'e', 'f', 'n', 't', 'v', 'r', '\\', '\'', '"':
+		advance_rune(t);
+		return true;
+
+	case '0'..'7':
+		for digit_val(t.ch) < 8 {
+			advance_rune(t);
+		}
+		return true;
+	case 'x':
+		advance_rune(t);
+		for digit_val(t.ch) < 16 {
+			advance_rune(t);
+		}
+		return true;
+	case 'u':
+		advance_rune(t);
+		n, base, max = 4, 16, utf8.MAX_RUNE;
+	case 'U':
+		advance_rune(t);
+		n, base, max = 8, 16, utf8.MAX_RUNE;
+	case:
+		if t.ch < 0 {
+			error_offset(t, offset, "escape sequence was not terminated");
+		} else {
+			break;
+		}
+		return false;
+	}
+
+	x: u32;
+	main_loop: for n > 0 {
+		d := u32(digit_val(t.ch));
+		if d >= base {
+			if t.ch == '"' || t.ch == '\'' {
+				break main_loop;
+			}
+			if t.ch < 0 {
+				error_offset(t, t.offset, "escape sequence was not terminated");
+			} else {
+				error_offset(t, t.offset, "illegal character '%r' : %d in escape sequence", t.ch, t.ch);
+			}
+			return false;
+		}
+
+		x = x*base + d;
+		advance_rune(t);
+		n -= 1;
+	}
+
+	if x > max || 0xd800 <= x && x <= 0xe000 {
+		error_offset(t, offset, "escape sequence is an invalid Unicode code point");
+		return false;
+	}
+	return true;
+}
+
+scan_rune :: proc(t: ^Tokenizer) -> string {
+	offset := t.offset-1;
+	valid := true;
+	n := 0;
+	for {
+		ch := t.ch;
+		if ch == '\n' || ch < 0 {
+			if valid {
+				error_offset(t, offset, "rune literal not terminated");
+				valid = false;
+			}
+			break;
+		}
+		advance_rune(t);
+		if ch == '\'' {
+			break;
+		}
+		n += 1;
+		if ch == '\\' {
+			if !scan_escape(t)  {
+				valid = false;
+			}
+		}
+	}
+
+	if valid && n != 1 {
+		error_offset(t, offset, "illegal rune literal");
+	}
+
+	return string(t.src[offset : t.offset]);
+}
+
+scan_number :: proc(t: ^Tokenizer, seen_decimal_point: bool) -> (Token_Kind, string) {
+	scan_mantissa :: proc(t: ^Tokenizer, base: int) {
+		for digit_val(t.ch) < base {
+			advance_rune(t);
+		}
+	}
+	scan_exponent :: proc(t: ^Tokenizer) {
+		if t.ch == 'e' || t.ch == 'E' || t.ch == 'p' || t.ch == 'P' {
+			advance_rune(t);
+			if t.ch == '-' || t.ch == '+' {
+				advance_rune(t);
+			}
+			if digit_val(t.ch) < 10 {
+				scan_mantissa(t, 10);
+			} else {
+				error_offset(t, t.offset, "illegal floating-point exponent");
+			}
+		}
+	}
+	scan_fraction :: proc(t: ^Tokenizer) -> (early_exit: bool) {
+		if t.ch == '.' && peek(t) == '.' {
+			return true;
+		}
+		if t.ch == '.' {
+			advance_rune(t);
+			scan_mantissa(t, 10);
+		}
+		return false;
+	}
+
+	check_end := true;
+
+
+	offset := t.offset;
+	seen_point := seen_decimal_point;
+
+	if seen_point {
+		offset -= 1;
+		scan_mantissa(t, 10);
+		scan_exponent(t);
+	} else {
+		if t.ch == '0' {
+			int_base :: proc(t: ^Tokenizer, base: int, msg: string) {
+				prev := t.offset;
+				advance_rune(t);
+				scan_mantissa(t, base);
+				if t.offset - prev <= 1 {
+					error_offset(t, t.offset, msg);
+				}
+			}
+
+			advance_rune(t);
+			switch t.ch {
+			case 'b', 'B':
+				int_base(t, 2, "illegal binary integer");
+			case 'x', 'X':
+				int_base(t, 16, "illegal hexadecimal integer");
+			case:
+				seen_point = false;
+				scan_mantissa(t, 10);
+				if t.ch == '.' {
+					seen_point = true;
+					if scan_fraction(t) {
+						check_end = false;
+					}
+				}
+				if check_end {
+					scan_exponent(t);
+					check_end = false;
+				}
+			}
+		}
+	}
+
+	if check_end {
+		scan_mantissa(t, 10);
+
+		if !scan_fraction(t) {
+			scan_exponent(t);
+		}
+	}
+
+	return .Number, string(t.src[offset : t.offset]);
+}
+
+scan_punct :: proc(t: ^Tokenizer, ch: rune) -> (kind: Token_Kind) {
+	kind = .Punct;
+	switch ch {
+	case:
+		kind = .Invalid;
+
+	case '<', '>':
+		if t.ch == ch {
+			advance_rune(t);
+		}
+		if t.ch == '=' {
+			advance_rune(t);
+		}
+	case '!', '+', '-', '*', '/', '%', '^', '=':
+		if t.ch == '=' {
+			advance_rune(t);
+		}
+	case '#':
+		if t.ch == '#' {
+			advance_rune(t);
+		}
+	case '&':
+		if t.ch == '=' || t.ch == '&' {
+			advance_rune(t);
+		}
+	case '|':
+		if t.ch == '=' || t.ch == '|' {
+			advance_rune(t);
+		}
+	case '(', ')', '[', ']', '{', '}':
+		// okay
+	case '~', ',', ':', ';', '?':
+		// okay
+	case '`':
+		// okay
+	case '.':
+		if t.ch == '.' && peek(t) == '.' {
+			advance_rune(t);
+			advance_rune(t); // consume last '.'
+		}
+	}
+	return;
+}
+
+peek :: proc(t: ^Tokenizer) -> byte {
+	if t.read_offset < len(t.src) {
+		return t.src[t.read_offset];
+	}
+	return 0;
+}
+peek_str :: proc(t: ^Tokenizer, str: string) -> bool {
+	if t.read_offset < len(t.src) {
+		return strings.has_prefix(string(t.src[t.offset:]), str);
+	}
+	return false;
+}
+
+scan_literal_prefix :: proc(t: ^Tokenizer, str: string, prefix: ^string) -> bool {
+	if peek_str(t, str) {
+		offset := t.offset;
+		for _ in str {
+			advance_rune(t);
+		}
+		prefix^ = string(t.src[offset:][:len(str)-1]);
+		return true;
+	}
+	return false;
+}
+
+
+allow_next_to_be_newline :: proc(t: ^Tokenizer) -> bool {
+	if t.ch == '\n' {
+		advance_rune(t);
+		return true;
+	} else if t.ch == '\r' && peek(t) == '\n' { // allow for MS-DOS style line endings
+		advance_rune(t); // \r
+		advance_rune(t); // \n
+		return true;
+	}
+	return false;
+}
+
+scan :: proc(t: ^Tokenizer, f: ^File) -> ^Token {
+	skip_whitespace(t);
+
+	offset := t.offset;
+
+	kind: Token_Kind;
+	lit: string;
+	prefix: string;
+
+	switch ch := t.ch; {
+	case scan_literal_prefix(t, `u8"`, &prefix):
+		kind = .String;
+		lit = scan_string(t);
+	case scan_literal_prefix(t, `u"`, &prefix):
+		kind = .String;
+		lit = scan_string(t);
+	case scan_literal_prefix(t, `L"`, &prefix):
+		kind = .String;
+		lit = scan_string(t);
+	case scan_literal_prefix(t, `U"`, &prefix):
+		kind = .String;
+		lit = scan_string(t);
+	case scan_literal_prefix(t, `u'`, &prefix):
+		kind = .Char;
+		lit = scan_rune(t);
+	case scan_literal_prefix(t, `L'`, &prefix):
+		kind = .Char;
+		lit = scan_rune(t);
+	case scan_literal_prefix(t, `U'`, &prefix):
+		kind = .Char;
+		lit = scan_rune(t);
+
+	case is_ident0(ch):
+		lit = scan_identifier(t);
+		kind = .Ident;
+	case '0' <= ch && ch <= '9':
+		kind, lit = scan_number(t, false);
+	case:
+		advance_rune(t);
+		switch ch {
+		case -1:
+			kind = .EOF;
+		case '\\':
+			kind = .Punct;
+			if allow_next_to_be_newline(t) {
+				t.at_bol = true;
+				t.has_space = false;
+				return scan(t, f);
+			}
+
+		case '.':
+			if is_digit(t.ch) {
+				kind, lit = scan_number(t, true);
+			} else {
+				kind = scan_punct(t, ch);
+			}
+		case '"':
+			kind = .String;
+			lit = scan_string(t);
+		case '\'':
+			kind = .Char;
+			lit = scan_rune(t);
+		case '/':
+			if t.ch == '/' || t.ch == '*' {
+				kind = .Comment;
+				lit = scan_comment(t);
+				t.has_space = true;
+				break;
+			}
+			fallthrough;
+		case:
+			kind = scan_punct(t, ch);
+			if kind == .Invalid && ch != utf8.RUNE_BOM {
+				error_offset(t, t.offset, "illegal character '%r': %d", ch, ch);
+			}
+		}
+	}
+
+	if lit == "" {
+		lit = string(t.src[offset : t.offset]);
+	}
+
+	if kind == .Comment {
+		return scan(t, f);
+	}
+
+	tok := new(Token);
+	tok.kind = kind;
+	tok.lit = lit;
+	tok.pos = offset_to_pos(t, offset);
+	tok.file = f;
+	tok.prefix = prefix;
+	tok.at_bol = t.at_bol;
+	tok.has_space = t.has_space;
+
+	t.at_bol, t.has_space = false, false;
+
+	return tok;
+}
+
+tokenize :: proc(t: ^Tokenizer, f: ^File) -> ^Token {
+	setup_tokenizer: {
+		t.src = f.src;
+		t.ch = ' ';
+		t.offset = 0;
+		t.read_offset = 0;
+		t.line_offset = 0;
+		t.line_count = len(t.src) > 0 ? 1 : 0;
+		t.error_count = 0;
+		t.path = f.name;
+
+
+		advance_rune(t);
+		if t.ch == utf8.RUNE_BOM {
+			advance_rune(t);
+		}
+	}
+
+
+	t.at_bol = true;
+	t.has_space = false;
+
+	head: Token;
+	curr := &head;
+	for {
+		tok := scan(t, f);
+		if tok == nil {
+			break;
+		}
+		curr.next = tok;
+		curr = curr.next;
+		if tok.kind == .EOF {
+			break;
+		}
+	}
+
+	return head.next;
+}
+
+add_new_file :: proc(t: ^Tokenizer, name: string, src: []byte, id: int) -> ^File {
+	file := new(File);
+	file.id = id;
+	file.src = src;
+	file.name = name;
+	file.display_name = name;
+	return file;
+}
+
+tokenize_file :: proc(t: ^Tokenizer, path: string, id: int, loc := #caller_location) -> ^Token {
+	src, ok := os.read_entire_file(path);
+	if !ok {
+		return nil;
+	}
+	return tokenize(t, add_new_file(t, path, src, id));
+}
+
+
+inline_tokenize :: proc(t: ^Tokenizer, tok: ^Token, src: []byte) -> ^Token {
+	file := new(File);
+	file.src = src;
+	if tok.file != nil {
+		file.id = tok.file.id;
+		file.name = tok.file.name;
+		file.display_name = tok.file.name;
+	}
+
+	return tokenize(t, file);
+}

core/c/frontend/tokenizer/unicode.odin

@@ -0,0 +1,116 @@
+package c_frontend_tokenizer
+
+
+in_range :: proc(range: []rune, c: rune) -> bool #no_bounds_check {
+	for i := 0; range[i] != -1; i += 2 {
+		if range[i] <= c && c <= range[i+1] {
+			return true;
+		}
+	}
+	return false;
+}
+
+
+// [https://www.sigbus.info/n1570#D] C11 allows ASCII and some multibyte characters in certan Unicode ranges to be used in an identifier.
+//
+// is_ident0 returns true if a given character is acceptable as the first character of an identifier.
+is_ident0 :: proc(c: rune) -> bool {
+	return in_range(_range_ident0, c);
+}
+// is_ident0 returns true if a given character is acceptable as a non-first character of an identifier.
+is_ident1 :: proc(c: rune) -> bool {
+	return is_ident0(c) || in_range(_range_ident1, c);
+}
+
+// Returns the number of columns needed to display a given character in a fixed-width font.
+// Based on https://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+char_width :: proc(c: rune) -> int {
+	switch {
+	case in_range(_range_width0, c):
+		return 0;
+	case in_range(_range_width2, c):
+		return 2;
+	}
+	return 1;
+}
+
+display_width :: proc(str: string) -> (w: int) {
+	for c in str {
+		w += char_width(c);
+	}
+	return;
+}
+
+
+
+_range_ident0 := []rune{
+	'_', '_', 'a', 'z', 'A', 'Z', '$', '$',
+	0x00A8, 0x00A8, 0x00AA, 0x00AA, 0x00AD, 0x00AD, 0x00AF, 0x00AF,
+	0x00B2, 0x00B5, 0x00B7, 0x00BA, 0x00BC, 0x00BE, 0x00C0, 0x00D6,
+	0x00D8, 0x00F6, 0x00F8, 0x00FF, 0x0100, 0x02FF, 0x0370, 0x167F,
+	0x1681, 0x180D, 0x180F, 0x1DBF, 0x1E00, 0x1FFF, 0x200B, 0x200D,
+	0x202A, 0x202E, 0x203F, 0x2040, 0x2054, 0x2054, 0x2060, 0x206F,
+	0x2070, 0x20CF, 0x2100, 0x218F, 0x2460, 0x24FF, 0x2776, 0x2793,
+	0x2C00, 0x2DFF, 0x2E80, 0x2FFF, 0x3004, 0x3007, 0x3021, 0x302F,
+	0x3031, 0x303F, 0x3040, 0xD7FF, 0xF900, 0xFD3D, 0xFD40, 0xFDCF,
+	0xFDF0, 0xFE1F, 0xFE30, 0xFE44, 0xFE47, 0xFFFD,
+	0x10000, 0x1FFFD, 0x20000, 0x2FFFD, 0x30000, 0x3FFFD, 0x40000, 0x4FFFD,
+	0x50000, 0x5FFFD, 0x60000, 0x6FFFD, 0x70000, 0x7FFFD, 0x80000, 0x8FFFD,
+	0x90000, 0x9FFFD, 0xA0000, 0xAFFFD, 0xB0000, 0xBFFFD, 0xC0000, 0xCFFFD,
+	0xD0000, 0xDFFFD, 0xE0000, 0xEFFFD,
+	-1,
+};
+
+_range_ident1 := []rune{
+	'0', '9', '$', '$', 0x0300, 0x036F, 0x1DC0, 0x1DFF, 0x20D0, 0x20FF, 0xFE20, 0xFE2F,
+	-1,
+};
+
+
+_range_width0 := []rune{
+	0x0000, 0x001F, 0x007f, 0x00a0, 0x0300, 0x036F, 0x0483, 0x0486,
+	0x0488, 0x0489, 0x0591, 0x05BD, 0x05BF, 0x05BF, 0x05C1, 0x05C2,
+	0x05C4, 0x05C5, 0x05C7, 0x05C7, 0x0600, 0x0603, 0x0610, 0x0615,
+	0x064B, 0x065E, 0x0670, 0x0670, 0x06D6, 0x06E4, 0x06E7, 0x06E8,
+	0x06EA, 0x06ED, 0x070F, 0x070F, 0x0711, 0x0711, 0x0730, 0x074A,
+	0x07A6, 0x07B0, 0x07EB, 0x07F3, 0x0901, 0x0902, 0x093C, 0x093C,
+	0x0941, 0x0948, 0x094D, 0x094D, 0x0951, 0x0954, 0x0962, 0x0963,
+	0x0981, 0x0981, 0x09BC, 0x09BC, 0x09C1, 0x09C4, 0x09CD, 0x09CD,
+	0x09E2, 0x09E3, 0x0A01, 0x0A02, 0x0A3C, 0x0A3C, 0x0A41, 0x0A42,
+	0x0A47, 0x0A48, 0x0A4B, 0x0A4D, 0x0A70, 0x0A71, 0x0A81, 0x0A82,
+	0x0ABC, 0x0ABC, 0x0AC1, 0x0AC5, 0x0AC7, 0x0AC8, 0x0ACD, 0x0ACD,
+	0x0AE2, 0x0AE3, 0x0B01, 0x0B01, 0x0B3C, 0x0B3C, 0x0B3F, 0x0B3F,
+	0x0B41, 0x0B43, 0x0B4D, 0x0B4D, 0x0B56, 0x0B56, 0x0B82, 0x0B82,
+	0x0BC0, 0x0BC0, 0x0BCD, 0x0BCD, 0x0C3E, 0x0C40, 0x0C46, 0x0C48,
+	0x0C4A, 0x0C4D, 0x0C55, 0x0C56, 0x0CBC, 0x0CBC, 0x0CBF, 0x0CBF,
+	0x0CC6, 0x0CC6, 0x0CCC, 0x0CCD, 0x0CE2, 0x0CE3, 0x0D41, 0x0D43,
+	0x0D4D, 0x0D4D, 0x0DCA, 0x0DCA, 0x0DD2, 0x0DD4, 0x0DD6, 0x0DD6,
+	0x0E31, 0x0E31, 0x0E34, 0x0E3A, 0x0E47, 0x0E4E, 0x0EB1, 0x0EB1,
+	0x0EB4, 0x0EB9, 0x0EBB, 0x0EBC, 0x0EC8, 0x0ECD, 0x0F18, 0x0F19,
+	0x0F35, 0x0F35, 0x0F37, 0x0F37, 0x0F39, 0x0F39, 0x0F71, 0x0F7E,
+	0x0F80, 0x0F84, 0x0F86, 0x0F87, 0x0F90, 0x0F97, 0x0F99, 0x0FBC,
+	0x0FC6, 0x0FC6, 0x102D, 0x1030, 0x1032, 0x1032, 0x1036, 0x1037,
+	0x1039, 0x1039, 0x1058, 0x1059, 0x1160, 0x11FF, 0x135F, 0x135F,
+	0x1712, 0x1714, 0x1732, 0x1734, 0x1752, 0x1753, 0x1772, 0x1773,
+	0x17B4, 0x17B5, 0x17B7, 0x17BD, 0x17C6, 0x17C6, 0x17C9, 0x17D3,
+	0x17DD, 0x17DD, 0x180B, 0x180D, 0x18A9, 0x18A9, 0x1920, 0x1922,
+	0x1927, 0x1928, 0x1932, 0x1932, 0x1939, 0x193B, 0x1A17, 0x1A18,
+	0x1B00, 0x1B03, 0x1B34, 0x1B34, 0x1B36, 0x1B3A, 0x1B3C, 0x1B3C,
+	0x1B42, 0x1B42, 0x1B6B, 0x1B73, 0x1DC0, 0x1DCA, 0x1DFE, 0x1DFF,
+	0x200B, 0x200F, 0x202A, 0x202E, 0x2060, 0x2063, 0x206A, 0x206F,
+	0x20D0, 0x20EF, 0x302A, 0x302F, 0x3099, 0x309A, 0xA806, 0xA806,
+	0xA80B, 0xA80B, 0xA825, 0xA826, 0xFB1E, 0xFB1E, 0xFE00, 0xFE0F,
+	0xFE20, 0xFE23, 0xFEFF, 0xFEFF, 0xFFF9, 0xFFFB, 0x10A01, 0x10A03,
+	0x10A05, 0x10A06, 0x10A0C, 0x10A0F, 0x10A38, 0x10A3A, 0x10A3F, 0x10A3F,
+	0x1D167, 0x1D169, 0x1D173, 0x1D182, 0x1D185, 0x1D18B, 0x1D1AA, 0x1D1AD,
+	0x1D242, 0x1D244, 0xE0001, 0xE0001, 0xE0020, 0xE007F, 0xE0100, 0xE01EF,
+	-1,
+};
+
+_range_width2 := []rune{
+	0x1100, 0x115F, 0x2329, 0x2329, 0x232A, 0x232A, 0x2E80, 0x303E,
+	0x3040, 0xA4CF, 0xAC00, 0xD7A3, 0xF900, 0xFAFF, 0xFE10, 0xFE19,
+	0xFE30, 0xFE6F, 0xFF00, 0xFF60, 0xFFE0, 0xFFE6, 0x1F000, 0x1F644,
+	0x20000, 0x2FFFD, 0x30000, 0x3FFFD,
+	-1,
+};

core/container/array.odin

@@ -0,0 +1,216 @@
+package container
+
+import "core:mem"
+import "core:runtime"
+
+Array :: struct(T: typeid) {
+	data:      ^T,
+	len:       int,
+	cap:       int,
+	allocator: mem.Allocator,
+}
+
+ARRAY_DEFAULT_CAPACITY :: 16;
+
+/*
+array_init :: proc {
+	array_init_none,
+	array_init_len,
+	array_init_len_cap,
+}
+array_init
+array_delete
+array_len
+array_cap
+array_space
+array_slice
+array_get
+array_get_ptr
+array_set
+array_reserve
+array_resize
+array_push = array_append :: proc{
+	array_push_back,
+	array_push_back_elems,
+}
+array_push_front
+array_pop_back
+array_pop_front
+array_consume
+array_trim
+array_clear
+array_clone
+array_set_capacity
+array_grow
+*/
+
+
+array_init_none :: proc(a: ^$A/Array, allocator := context.allocator) {
+	array_init_len_cap(a, 0, ARRAY_DEFAULT_CAPACITY, allocator);
+}
+array_init_len :: proc(a: ^$A/Array, len: int, allocator := context.allocator) {
+	array_init_len_cap(a, len, len, allocator);
+}
+array_init_len_cap :: proc(a: ^$A/Array($T), len: int, cap: int, allocator := context.allocator) {
+	a.allocator = allocator;
+	a.data = (^T)(mem.alloc(size_of(T)*cap, align_of(T), a.allocator));
+	a.len = len;
+	a.cap = cap;
+}
+
+array_init :: proc{array_init_none, array_init_len, array_init_len_cap};
+
+array_delete :: proc(a: $A/Array) {
+	mem.free(a.data, a.allocator);
+}
+
+array_len :: proc(a: $A/Array) -> int {
+	return a.len;
+}
+
+array_cap :: proc(a: $A/Array) -> int {
+	return a.cap;
+}
+
+array_space :: proc(a: $A/Array) -> int {
+	return a.cap - a.len;
+}
+
+array_slice :: proc(a: $A/Array($T)) -> []T {
+	s := mem.Raw_Slice{a.data, a.len};
+	return transmute([]T)s;
+}
+
+array_cap_slice :: proc(a: $A/Array($T)) -> []T {
+	s := mem.Raw_Slice{a.data, a.cap};
+	return transmute([]T)s;
+}
+
+array_get :: proc(a: $A/Array($T), index: int, loc := #caller_location) -> T {
+	runtime.bounds_check_error_loc(loc, index, array_len(a));
+	return (^T)(uintptr(a.data) + size_of(T)*uintptr(index))^;
+}
+array_get_ptr :: proc(a: $A/Array($T), index: int, loc := #caller_location) -> ^T {
+	runtime.bounds_check_error_loc(loc, index, array_len(a));
+	return (^T)(uintptr(a.data) + size_of(T)*uintptr(index));
+}
+
+array_set :: proc(a: ^$A/Array($T), index: int, item: T, loc := #caller_location)  {
+	runtime.bounds_check_error_loc(loc, index, array_len(a^));
+	(^T)(uintptr(a.data) + size_of(T)*uintptr(index))^ = item;
+}
+
+
+array_reserve :: proc(a: ^$A/Array, capacity: int) {
+	if capacity > a.len {
+		array_set_capacity(a, capacity);
+	}
+}
+
+array_resize :: proc(a: ^$A/Array, length: int) {
+	if length > a.len {
+		array_set_capacity(a, length);
+	}
+	a.len = length;
+}
+
+
+
+array_push_back :: proc(a: ^$A/Array($T), item: T) {
+	if array_space(a^) == 0 {
+		array_grow(a);
+	}
+
+	a.len += 1;
+	array_set(a, a.len-1, item);
+}
+
+array_push_front :: proc(a: ^$A/Array($T), item: T) {
+	if array_space(a^) == 0 {
+		array_grow(a);
+	}
+
+	a.len += 1;
+	data := array_slice(a^);
+	copy(data[1:], data[:]);
+	data[0] = item;
+}
+
+array_pop_back :: proc(a: ^$A/Array($T), loc := #caller_location) -> T {
+	assert(condition=a.len > 0, loc=loc);
+	item := array_get(a^, a.len-1);
+	a.len -= 1;
+	return item;
+}
+
+array_pop_front :: proc(a: ^$A/Array($T), loc := #caller_location) -> T {
+	assert(condition=a.len > 0, loc=loc);
+	item := array_get(a^, 0);
+	s := array_slice(a^);
+	copy(s[:], s[1:]);
+	a.len -= 1;
+	return item;
+}
+
+
+array_consume :: proc(a: ^$A/Array($T), count: int, loc := #caller_location) {
+	assert(condition=a.len >= count, loc=loc);
+	a.len -= count;
+}
+
+
+array_trim :: proc(a: ^$A/Array($T)) {
+	array_set_capacity(a, a.len);
+}
+
+array_clear :: proc(a: ^$A/Array($T)) {
+	array_resize(a, 0);
+}
+
+array_clone :: proc(a: $A/Array($T), allocator := context.allocator) -> A {
+	res: A;
+	array_init(&res, array_len(a), array_len(a), allocator);
+	copy(array_slice(res), array_slice(a));
+	return res;
+}
+
+array_push_back_elems :: proc(a: ^$A/Array($T), items: ..T) {
+	if array_space(a^) < len(items) {
+		array_grow(a, a.len + len(items));
+	}
+	offset := a.len;
+	data := array_cap_slice(a^);
+	n := copy(data[a.len:], items);
+	a.len += n;
+}
+
+array_push   :: proc{array_push_back, array_push_back_elems};
+array_append :: proc{array_push_back, array_push_back_elems};
+
+array_set_capacity :: proc(a: ^$A/Array($T), new_capacity: int) {
+	if new_capacity == a.cap {
+		return;
+	}
+
+	if new_capacity < a.len {
+		array_resize(a, new_capacity);
+	}
+
+	new_data: ^T;
+	if new_capacity > 0 {
+		if a.allocator.procedure == nil {
+			a.allocator = context.allocator;
+		}
+		new_data = (^T)(mem.alloc(size_of(T)*new_capacity, align_of(T), a.allocator));
+		if new_data != nil {
+			mem.copy(new_data, a.data, size_of(T)*a.len);
+		}
+	}
+	mem.free(a.data, a.allocator);
+	a.data = new_data;
+	a.cap = new_capacity;
+}
+array_grow :: proc(a: ^$A/Array, min_capacity: int = 0) {
+	new_capacity := max(array_len(a^)*2 + 8, min_capacity);
+	array_set_capacity(a, new_capacity);
+}

core/container/bloom_filter.odin

@@ -0,0 +1,80 @@
+package container
+
+import "core:mem"
+
+Bloom_Hash_Proc :: #type proc(data: []byte) -> u32;
+
+Bloom_Hash :: struct {
+	hash_proc: Bloom_Hash_Proc,
+	next:     ^Bloom_Hash,
+}
+
+Bloom_Filter :: struct {
+	allocator: mem.Allocator,
+	hash:      ^Bloom_Hash,
+	bits:      []byte,
+}
+
+bloom_filter_init :: proc(b: ^Bloom_Filter, size: int, allocator := context.allocator) {
+	b.allocator = allocator;
+	b.bits = make([]byte, size, allocator);
+}
+
+bloom_filter_destroy :: proc(b: ^Bloom_Filter) {
+	context.allocator = b.allocator;
+	delete(b.bits);
+	for b.hash != nil {
+		hash := b.hash;
+		b.hash = b.hash.next;
+		free(hash);
+	}
+}
+
+bloom_filter_add_hash_proc :: proc(b: ^Bloom_Filter, hash_proc: Bloom_Hash_Proc) {
+	context.allocator = b.allocator;
+	h := new(Bloom_Hash);
+	h.hash_proc = hash_proc;
+
+	head := &b.hash;
+	for head^ != nil {
+		head = &(head^.next);
+	}
+	head^ = h;
+}
+
+bloom_filter_add :: proc(b: ^Bloom_Filter, item: []byte) {
+	#no_bounds_check for h := b.hash; h != nil; h = h.next {
+		hash := h.hash_proc(item);
+		hash %= u32(len(b.bits) * 8);
+		b.bits[hash >> 3] |= 1 << (hash & 3);
+	}
+}
+
+bloom_filter_add_string :: proc(b: ^Bloom_Filter, item: string) {
+	bloom_filter_add(b, transmute([]byte)item);
+}
+
+bloom_filter_add_raw :: proc(b: ^Bloom_Filter, data: rawptr, size: int) {
+	item := mem.slice_ptr((^byte)(data), size);
+	bloom_filter_add(b, item);
+}
+
+bloom_filter_test :: proc(b: ^Bloom_Filter, item: []byte) -> bool {
+	#no_bounds_check for h := b.hash; h != nil; h = h.next {
+		hash := h.hash_proc(item);
+		hash %= u32(len(b.bits) * 8);
+		if (b.bits[hash >> 3] & (1 << (hash & 3)) == 0) {
+			return false;
+		}
+	}
+	return true;
+}
+
+bloom_filter_test_string :: proc(b: ^Bloom_Filter, item: string) -> bool {
+	return bloom_filter_test(b, transmute([]byte)item);
+}
+
+bloom_filter_test_raw :: proc(b: ^Bloom_Filter, data: rawptr, size: int) -> bool {
+	item := mem.slice_ptr((^byte)(data), size);
+	return bloom_filter_test(b, item);
+}

core/container/map.odin

@@ -0,0 +1,377 @@
+package container
+
+import "intrinsics"
+_ :: intrinsics;
+
+
+Map :: struct(Key, Value: typeid) where intrinsics.type_is_valid_map_key(Key) {
+	hash: Array(int),
+	entries: Array(Map_Entry(Key, Value)),
+}
+
+Map_Entry :: struct(Key, Value: typeid) where intrinsics.type_is_valid_map_key(Key) {
+	hash:  uintptr,
+	next:  int,
+	key:   Key,
+	value: Value,
+}
+
+
+/*
+map_init :: proc{
+	map_init_none,
+	map_init_cap,
+}
+map_delete
+
+map_has
+map_get
+map_get_default
+map_get_ptr
+map_set
+map_remove
+map_reserve
+map_clear
+
+// Multi Map
+
+multi_map_find_first
+multi_map_find_next
+multi_map_count
+multi_map_get :: proc{
+	multi_map_get_array,
+	multi_map_get_slice,
+};
+multi_map_get_as_slice
+multi_map_insert
+multi_map_remove
+multi_map_remove_all
+
+*/
+
+map_init :: proc{map_init_none, map_init_cap};
+
+map_init_none :: proc(m: ^$M/Map($Key, $Value), allocator := context.allocator) {
+	m.hash.allocator = allocator;
+	m.entries.allocator = allocator;
+}
+
+map_init_cap :: proc(m: ^$M/Map($Key, $Value), cap: int, allocator := context.allocator) {
+	m.hash.allocator = allocator;
+	m.entries.allocator = allocator;
+	map_reserve(m, cap);
+}
+
+map_delete :: proc(m: $M/Map($Key, $Value)) {
+	array_delete(m.hash);
+	array_delete(m.entries);
+}
+
+
+map_has :: proc(m: $M/Map($Key, $Value), key: Key) -> bool {
+	return _map_find_or_fail(m, key) >= 0;
+}
+
+map_get :: proc(m: $M/Map($Key, $Value), key: Key) -> (res: Value, ok: bool) #optional_ok {
+	i := _map_find_or_fail(m, key);
+	if i < 0 {
+		return {}, false;
+	}
+	return array_get(m.entries, i).value, true;
+}
+
+map_get_default :: proc(m: $M/Map($Key, $Value), key: Key, default: Value) -> (res: Value, ok: bool) #optional_ok {
+	i := _map_find_or_fail(m, key);
+	if i < 0 {
+		return default, false;
+	}
+	return array_get(m.entries, i).value, true;
+}
+
+map_get_ptr :: proc(m: $M/Map($Key, $Value), key: Key) -> ^Value {
+	i := _map_find_or_fail(m, key);
+	if i < 0 {
+		return nil;
+	}
+	return array_get_ptr(m.entries, i).value;
+}
+
+map_set :: proc(m: ^$M/Map($Key, $Value), key: Key, value: Value) {
+	if array_len(m.hash) == 0 {
+		_map_grow(m);
+	}
+
+	i := _map_find_or_make(m, key);
+	array_get_ptr(m.entries, i).value = value;
+	if _map_full(m^) {
+		_map_grow(m);
+	}
+}
+
+map_remove :: proc(m: ^$M/Map($Key, $Value), key: Key) {
+	fr := _map_find_key(m^, key);
+	if fr.entry_index >= 0 {
+		_map_erase(m, fr);
+	}
+}
+
+
+map_reserve :: proc(m: ^$M/Map($Key, $Value), new_size: int) {
+	nm: M;
+	map_init(&nm, m.hash.allocator);
+	array_resize(&nm.hash, new_size);
+	array_reserve(&nm.entries, array_len(m.entries));
+
+	for i in 0..<new_size {
+		array_set(&nm.hash, i, -1);
+	}
+	for i in 0..<array_len(m.entries) {
+		e := array_get(m.entries, i);
+		multi_map_insert(&nm, e.key, e.value);
+	}
+
+	map_delete(m^);
+	m^ = nm;
+}
+
+map_clear :: proc(m: ^$M/Map($Key, $Value)) {
+	array_clear(&m.hash);
+	array_clear(&m.entries);
+}
+
+
+
+multi_map_find_first :: proc(m: $M/Map($Key, $Value), key: Key) -> ^Map_Entry(Value) {
+	i := _map_find_or_fail(m, key);
+	if i < 0 {
+		return nil;
+	}
+	return array_get_ptr(m.entries, i);
+}
+
+multi_map_find_next :: proc(m: $M/Map($Key, $Value), e: ^Map_Entry(Value)) -> ^Map_Entry(Value) {
+	i := e.next;
+	for i >= 0 {
+		it := array_get_ptr(m.entries, i);
+		if it.hash == e.hash && it.key == e.key {
+			return it;
+		}
+		i = it.next;
+	}
+	return nil;
+}
+
+multi_map_count :: proc(m: $M/Map($Key, $Value), key: Key) -> int {
+	n := 0;
+	e := multi_map_find_first(m, key);
+	for e != nil {
+		n += 1;
+		e = multi_map_find_next(m, e);
+	}
+	return n;
+}
+
+multi_map_get :: proc{multi_map_get_array, multi_map_get_slice};
+
+multi_map_get_array :: proc(m: $M/Map($Key, $Value), key: Key, items: ^Array(Value)) {
+	if items == nil {
+		return;
+	}
+	e := multi_map_find_first(m, key);
+	for e != nil {
+		array_append(items, e.value);
+		e = multi_map_find_next(m, e);
+	}
+}
+
+multi_map_get_slice :: proc(m: $M/Map($Key, $Value), key: Key, items: []Value) {
+	e := multi_map_find_first(m, key);
+	i := 0;
+	for e != nil && i < len(items) {
+		items[i] = e.value;
+		i += 1;
+		e = multi_map_find_next(m, e);
+	}
+}
+
+multi_map_get_as_slice :: proc(m: $M/Map($Key, $Value), key: Key) -> []Value {
+	items: Array(Value);
+	array_init(&items, 0);
+
+	e := multi_map_find_first(m, key);
+	for e != nil {
+		array_append(&items, e.value);
+		e = multi_map_find_next(m, e);
+	}
+
+	return array_slice(items);
+}
+
+
+multi_map_insert :: proc(m: ^$M/Map($Key, $Value), key: Key, value: Value) {
+	if array_len(m.hash) == 0 {
+		_map_grow(m);
+	}
+
+	i := _map_make(m, key);
+	array_get_ptr(m.entries, i).value = value;
+	if _map_full(m^) {
+		_map_grow(m);
+	}
+}
+
+multi_map_remove :: proc(m: ^$M/Map($Key, $Value), e: ^Map_Entry(Value)) {
+	fr := _map_find_entry(m, e);
+	if fr.entry_index >= 0 {
+		_map_erase(m, fr);
+	}
+}
+
+multi_map_remove_all :: proc(m: ^$M/Map($Key, $Value), key: Key) {
+	for map_exist(m^, key) {
+		map_remove(m, key);
+	}
+}
+
+
+/// Internal
+
+
+Map_Find_Result :: struct {
+	hash_index:  int,
+	entry_prev:  int,
+	entry_index: int,
+}
+
+_map_add_entry :: proc(m: ^$M/Map($Key, $Value), key: Key) -> int where intrinsics.type_is_valid_map_key(Key) {
+	hasher := intrinsics.type_hasher_proc(Key);
+
+	e: Map_Entry(Key, Value);
+	e.key = key;
+	e.hash = hasher(&e.key, 0);
+	e.next = -1;
+	idx := array_len(m.entries);
+	array_push(&m.entries, e);
+	return idx;
+}
+
+_map_erase :: proc(m: ^$M/Map, fr: Map_Find_Result) {
+	if fr.entry_prev < 0 {
+		array_set(&m.hash, fr.hash_index, array_get(m.entries, fr.entry_index).next);
+	} else {
+		array_get_ptr(m.entries, fr.entry_prev).next = array_get(m.entries, fr.entry_index).next;
+	}
+
+	if fr.entry_index == array_len(m.entries)-1 {
+		array_pop_back(&m.entries);
+		return;
+	}
+
+	array_set(&m.entries, fr.entry_index, array_get(m.entries, array_len(m.entries)-1));
+	last := _map_find_key(m^, array_get(m.entries, fr.entry_index).key);
+
+	if last.entry_prev < 0 {
+		array_get_ptr(m.entries, last.entry_prev).next = fr.entry_index;
+	} else {
+		array_set(&m.hash, last.hash_index, fr.entry_index);
+	}
+}
+
+
+_map_find_key :: proc(m: $M/Map($Key, $Value), key: Key) -> Map_Find_Result where intrinsics.type_is_valid_map_key(Key) {
+	fr: Map_Find_Result;
+	fr.hash_index = -1;
+	fr.entry_prev = -1;
+	fr.entry_index = -1;
+
+	if array_len(m.hash) == 0 {
+		return fr;
+	}
+
+	hasher := intrinsics.type_hasher_proc(Key);
+
+	key := key;
+	hash := hasher(&key, 0);
+
+	fr.hash_index = int(hash % uintptr(array_len(m.hash)));
+	fr.entry_index = array_get(m.hash, fr.hash_index);
+	for fr.entry_index >= 0 {
+		it := array_get_ptr(m.entries, fr.entry_index);
+		if it.hash == hash && it.key == key {
+			return fr;
+		}
+		fr.entry_prev = fr.entry_index;
+		fr.entry_index = it.next;
+	}
+	return fr;
+}
+
+_map_find_entry :: proc(m: ^$M/Map($Key, $Value), e: ^Map_Entry(Value)) -> Map_Find_Result {
+	fr: Map_Find_Result;
+	fr.hash_index = -1;
+	fr.entry_prev = -1;
+	fr.entry_index = -1;
+
+	if array_len(m.hash) == 0 {
+		return fr;
+	}
+
+	fr.hash_index = int(e.hash % uintptr(array_len(m.hash)));
+	fr.entry_index = array_get(m.hash, fr.hash_index);
+	for fr.entry_index >= 0 {
+		it := array_get_ptr(m.entries, fr.entry_index);
+		if it == e {
+			return fr;
+		}
+		fr.entry_prev = fr.entry_index;
+		fr.entry_index = it.next;
+	}
+	return fr;
+}
+
+_map_find_or_fail :: proc(m: $M/Map($Key, $Value), key: Key) -> int {
+	return _map_find_key(m, key).entry_index;
+}
+_map_find_or_make :: proc(m: ^$M/Map($Key, $Value), key: Key) -> int {
+	fr := _map_find_key(m^, key);
+	if fr.entry_index >= 0 {
+		return fr.entry_index;
+	}
+
+	i := _map_add_entry(m, key);
+	if fr.entry_prev < 0 {
+		array_set(&m.hash, fr.hash_index, i);
+	} else {
+		array_get_ptr(m.entries, fr.entry_prev).next = i;
+	}
+	return i;
+}
+
+
+_map_make :: proc(m: ^$M/Map($Key, $Value), key: Key) -> int {
+	fr := _map_find_key(m^, key);
+	i := _map_add_entry(m, key);
+
+	if fr.entry_prev < 0 {
+		array_set(&m.hash, fr.hash_index, i);
+	} else {
+		array_get_ptr(m.entries, fr.entry_prev).next = i;
+	}
+
+	array_get_ptr(m.entries, i).next = fr.entry_index;
+
+	return i;
+}
+
+
+_map_full :: proc(m: $M/Map($Key, $Value)) -> bool {
+	// TODO(bill): Determine good max load factor
+	return array_len(m.entries) >= (array_len(m.hash) / 4)*3;
+}
+
+_map_grow :: proc(m: ^$M/Map($Key, $Value)) {
+	new_size := array_len(m.entries) * 4 + 7; // TODO(bill): Determine good grow rate
+	map_reserve(m, new_size);
+}
+
+

core/container/priority_queue.odin

@@ -0,0 +1,113 @@
+package container
+
+Priority_Queue :: struct(T: typeid) {
+	data: Array(T),
+	len: int,
+	priority: proc(item: T) -> int,
+}
+
+priority_queue_init_none :: proc(q: ^$Q/Priority_Queue($T), f: proc(item: T) -> int, allocator := context.allocator) {
+	queue_init_len(q, f, 0, allocator);
+}
+priority_queue_init_len :: proc(q: ^$Q/Priority_Queue($T), f: proc(item: T) -> int, len: int, allocator := context.allocator) {
+	queue_init_len_cap(q, f, 0, 16, allocator);
+}
+priority_queue_init_len_cap :: proc(q: ^$Q/Priority_Queue($T), f: proc(item: T) -> int, len: int, cap: int, allocator := context.allocator) {
+	array_init(&q.data, len, cap, allocator);
+	q.len = len;
+	q.priority = f;
+}
+
+priority_queue_init :: proc{priority_queue_init_none, priority_queue_init_len, priority_queue_init_len_cap};
+
+
+priority_queue_delete :: proc(q: $Q/Priority_Queue($T)) {
+	array_delete(q.data);
+}
+
+priority_queue_clear :: proc(q: ^$Q/Priority_Queue($T)) {
+	q.len = 0;
+}
+
+priority_queue_len :: proc(q: $Q/Priority_Queue($T)) -> int {
+	return q.len;
+}
+
+priority_queue_cap :: proc(q: $Q/Priority_Queue($T)) -> int {
+	return array_cap(q.data);
+}
+
+priority_queue_space :: proc(q: $Q/Priority_Queue($T)) -> int {
+	return array_len(q.data) - q.len;
+}
+
+priority_queue_reserve :: proc(q: ^$Q/Priority_Queue($T), capacity: int) {
+	if capacity > q.len {
+		array_resize(&q.data, new_capacity);
+	}
+}
+
+priority_queue_resize :: proc(q: ^$Q/Priority_Queue($T), length: int) {
+	if length > q.len {
+		array_resize(&q.data, new_capacity);
+	}
+	q.len = length;
+}
+
+_priority_queue_grow :: proc(q: ^$Q/Priority_Queue($T), min_capacity: int = 0) {
+	new_capacity := max(array_len(q.data)*2 + 8, min_capacity);
+	array_resize(&q.data, new_capacity);
+}
+
+
+priority_queue_push :: proc(q: ^$Q/Priority_Queue($T), item: T) {
+	if array_len(q.data) - q.len == 0 {
+		_priority_queue_grow(q);
+	}
+
+	s := array_slice(q.data);
+	s[q.len] = item;
+
+	i := q.len;
+	for i > 0 {
+		p := (i - 1) / 2;
+		if q.priority(s[p]) <= q.priority(item) do break;
+		s[i] = s[p];
+		i = p;
+	}
+
+	q.len += 1;
+	if q.len > 0 do s[i] = item;
+}
+
+
+
+priority_queue_pop :: proc(q: ^$Q/Priority_Queue($T)) -> T {
+	assert(q.len > 0);
+
+	s := array_slice(q.data);
+	min := s[0];
+	root := s[q.len-1];
+	q.len -= 1;
+
+	i := 0;
+	for i * 2 + 1 < q.len {
+		a := i * 2 + 1;
+		b := i * 2 + 2;
+		c := b < q.len && q.priority(s[b]) < q.priority(s[a]) ? b : a;
+
+		if q.priority(s[c]) >= q.priority(root) do break;
+		s[i] = s[c];
+		i = c;
+	}
+
+	if q.len > 0 do s[i] = root;
+	return min;
+}
+
+priority_queue_peek :: proc(q: ^$Q/Priority_Queue($T)) -> T {
+	assert(q.len > 0);
+
+	s := array_slice(q.data);
+	return s[0];
+}

core/container/queue.odin

@@ -0,0 +1,175 @@
+package container
+
+Queue :: struct(T: typeid) {
+	data: Array(T),
+	len: int,
+	offset: int,
+}
+
+/*
+queue_init :: proc{
+	queue_init_none,
+	queue_init_len,
+	queue_init_len_cap,
+}
+queue_delete
+queue_clear
+queue_len
+queue_cap
+queue_space
+queue_get
+queue_set
+queue_reserve
+queue_resize
+queue_push :: proc{
+	queue_push_back, 
+	queue_push_elems,
+};
+queue_push_front
+queue_pop_front
+queue_pop_back
+queue_consume
+*/
+
+queue_init_none :: proc(q: ^$Q/Queue($T), allocator := context.allocator) {
+	queue_init_len(q, 0, allocator);
+}
+queue_init_len :: proc(q: ^$Q/Queue($T), len: int, allocator := context.allocator) {
+	queue_init_len_cap(q, 0, 16, allocator);
+}
+queue_init_len_cap :: proc(q: ^$Q/Queue($T), len: int, cap: int, allocator := context.allocator) {
+	array_init(&q.data, len, cap, allocator);
+	q.len = len;
+	q.offset = 0;
+}
+
+queue_init :: proc{queue_init_none, queue_init_len, queue_init_len_cap};
+
+queue_delete :: proc(q: $Q/Queue($T)) {
+	array_delete(q.data);
+}
+
+queue_clear :: proc(q: ^$Q/Queue($T)) {
+	q.len = 0;
+}
+
+queue_len :: proc(q: $Q/Queue($T)) -> int {
+	return q.len;
+}
+
+queue_cap :: proc(q: $Q/Queue($T)) -> int {
+	return array_cap(q.data);
+}
+
+queue_space :: proc(q: $Q/Queue($T)) -> int {
+	return array_len(q.data) - q.len;
+}
+
+queue_get :: proc(q: $Q/Queue($T), index: int) -> T {
+	i := (index + q.offset) % array_len(q.data);
+	data := array_slice(q.data);
+	return data[i];
+}
+
+queue_set :: proc(q: ^$Q/Queue($T), index: int, item: T)  {
+	i := (index + q.offset) % array_len(q.data);
+	data := array_slice(q.data);
+	data[i] = item;
+}
+
+
+queue_reserve :: proc(q: ^$Q/Queue($T), capacity: int) {
+	if capacity > q.len {
+		_queue_increase_capacity(q, capacity);
+	}
+}
+
+queue_resize :: proc(q: ^$Q/Queue($T), length: int) {
+	if length > q.len {
+		_queue_increase_capacity(q, length);
+	}
+	q.len = length;
+}
+
+queue_push_back :: proc(q: ^$Q/Queue($T), item: T) {
+	if queue_space(q^) == 0 {
+		_queue_grow(q);
+	}
+
+	queue_set(q, q.len, item);
+	q.len += 1;
+}
+
+queue_push_front :: proc(q: ^$Q/Queue($T), item: T) {
+	if queue_space(q^) == 0 {
+		_queue_grow(q);
+	}
+
+	q.offset = (q.offset - 1 + array_len(q.data)) % array_len(q.data);
+	q.len += 1;
+	queue_set(q, 0, item);
+}
+
+queue_pop_front :: proc(q: ^$Q/Queue($T)) -> T {
+	assert(q.len > 0);
+	item := queue_get(q^, 0);
+	q.offset = (q.offset + 1) % array_len(q.data);
+	q.len -= 1;
+	if q.len == 0 {
+		q.offset = 0;
+	}
+	return item;
+}
+
+queue_pop_back :: proc(q: ^$Q/Queue($T)) -> T {
+	assert(q.len > 0);
+	item := queue_get(q^, q.len-1);
+	q.len -= 1;
+	return item;
+}
+
+queue_consume :: proc(q: ^$Q/Queue($T), count: int) {
+	q.offset = (q.offset + count) & array_len(q.data);
+	q.len -= count;
+}
+
+
+queue_push_elems :: proc(q: ^$Q/Queue($T), items: ..T) {
+	if queue_space(q^) < len(items) {
+		_queue_grow(q, q.len + len(items));
+	}
+	size := array_len(q.data);
+	insert := (q.offset + q.len) % size;
+
+	to_insert := len(items);
+	if insert + to_insert > size {
+		to_insert = size - insert;
+	}
+
+	the_items := items[:];
+
+	data := array_slice(q.data);
+
+	q.len += copy(data[insert:][:to_insert], the_items);
+	the_items = the_items[to_insert:];
+	q.len += copy(data[:], the_items);
+}
+
+queue_push :: proc{queue_push_back, queue_push_elems};
+
+
+
+_queue_increase_capacity :: proc(q: ^$Q/Queue($T), new_capacity: int) {
+	end := array_len(q.data);
+	array_resize(&q.data, new_capacity);
+	if q.offset + q.len > end {
+		end_items := q.len + end;
+		data := array_slice(q.data);
+		copy(data[new_capacity-end_items:][:end_items], data[q.offset:][:end_items]);
+		q.offset += new_capacity - end;
+	}
+}
+_queue_grow :: proc(q: ^$Q/Queue($T), min_capacity: int = 0) {
+	new_capacity := max(array_len(q.data)*2 + 8, min_capacity);
+	_queue_increase_capacity(q, new_capacity);
+}

core/container/ring.odin

@@ -0,0 +1,73 @@
+package container
+
+
+Ring :: struct(T: typeid) {
+	next, prev: ^Ring(T),
+	value: T,
+}
+
+ring_init :: proc(r: ^$R/Ring) -> ^R {
+	r.prev, r.next = r, r;
+	return r;
+}
+
+ring_next :: proc(r: ^$R/Ring) -> ^R {
+	if r.next == nil {
+		return ring_init(r);
+	}
+	return r.next;
+}
+ring_prev :: proc(r: ^$R/Ring) -> ^R {
+	if r.prev == nil {
+		return ring_init(r);
+	}
+	return r.prev;
+}
+
+
+ring_move :: proc(r: ^$R/Ring, n: int) -> ^R {
+	if r.next == nil {
+		return ring_init(r);
+	}
+
+	switch {
+	case n < 0:
+		for _ in n..<0 {
+			r = r.prev;
+		}
+	case n > 0:
+		for _ in 0..<n {
+			r = r.next;
+		}
+	}
+	return r;
+}
+
+ring_link :: proc(r, s: ^$R/Ring) -> ^R {
+	n := ring_next(r);
+	if s != nil {
+		p := ring_prev(s);
+		r.next = s;
+		s.prev = r;
+		n.prev = p;
+		p.next = n;
+	}
+	return n;
+}
+ring_unlink :: proc(r: ^$R/Ring, n: int) -> ^R {
+	if n <= 0 {
+		return nil;
+	}
+	return ring_link(r, ring_move(r, n+1));
+}
+ring_len :: proc(r: ^$R/Ring) -> int {
+	n := 0;
+	if r != nil {
+		n = 1;
+		for p := ring_next(&p); p != r; p = p.next {
+			n += 1;
+		}
+	}
+	return n;
+}
+

core/container/set.odin

@@ -0,0 +1,240 @@
+package container
+
+Set :: struct {
+	hash:    Array(int),
+	entries: Array(Set_Entry),
+}
+
+Set_Entry :: struct {
+	key:   u64,
+	next:  int,
+}
+
+
+/*
+set_init :: proc{
+	set_init_none,
+	set_init_cap,
+}
+set_delete
+
+set_in
+set_not_in
+set_add
+set_remove
+set_reserve
+set_clear
+*/
+
+set_init :: proc{set_init_none, set_init_cap};
+
+set_init_none :: proc(m: ^Set, allocator := context.allocator) {
+	m.hash.allocator = allocator;
+	m.entries.allocator = allocator;
+}
+
+set_init_cap :: proc(m: ^Set, cap: int, allocator := context.allocator) {
+	m.hash.allocator = allocator;
+	m.entries.allocator = allocator;
+	set_reserve(m, cap);
+}
+
+set_delete :: proc(m: Set) {
+	array_delete(m.hash);
+	array_delete(m.entries);
+}
+
+
+set_in :: proc(m: Set, key: u64) -> bool {
+	return _set_find_or_fail(m, key) >= 0;
+}
+set_not_in :: proc(m: Set, key: u64) -> bool {
+	return _set_find_or_fail(m, key) < 0;
+}
+
+set_add :: proc(m: ^Set, key: u64) {
+	if array_len(m.hash) == 0 {
+		_set_grow(m);
+	}
+
+	_ = _set_find_or_make(m, key);
+	if _set_full(m^) {
+		_set_grow(m);
+	}
+}
+
+set_remove :: proc(m: ^Set, key: u64) {
+	fr := _set_find_key(m^, key);
+	if fr.entry_index >= 0 {
+		_set_erase(m, fr);
+	}
+}
+
+
+set_reserve :: proc(m: ^Set, new_size: int) {
+	nm: Set;
+	set_init(&nm, m.hash.allocator);
+	array_resize(&nm.hash, new_size);
+	array_reserve(&nm.entries, array_len(m.entries));
+
+	for i in 0..<new_size {
+		array_set(&nm.hash, i, -1);
+	}
+	for i in 0..<array_len(m.entries) {
+		e := array_get(m.entries, i);
+		set_add(&nm, e.key);
+	}
+
+	set_delete(m^);
+	m^ = nm;
+}
+
+set_clear :: proc(m: ^Set) {
+	array_clear(&m.hash);
+	array_clear(&m.entries);
+}
+
+
+set_equal :: proc(a, b: Set) -> bool {
+	a_entries := array_slice(a.entries);
+	b_entries := array_slice(b.entries);
+	if len(a_entries) != len(b_entries) {
+		return false;
+	}
+	for e in a_entries {
+		if set_not_in(b, e.key) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+
+/// Internal
+
+_set_add_entry :: proc(m: ^Set, key: u64) -> int {
+	e: Set_Entry;
+	e.key = key;
+	e.next = -1;
+	idx := array_len(m.entries);
+	array_push(&m.entries, e);
+	return idx;
+}
+
+_set_erase :: proc(m: ^Set, fr: Map_Find_Result) {
+	if fr.entry_prev < 0 {
+		array_set(&m.hash, fr.hash_index, array_get(m.entries, fr.entry_index).next);
+	} else {
+		array_get_ptr(m.entries, fr.entry_prev).next = array_get(m.entries, fr.entry_index).next;
+	}
+
+	if fr.entry_index == array_len(m.entries)-1 {
+		array_pop_back(&m.entries);
+		return;
+	}
+
+	array_set(&m.entries, fr.entry_index, array_get(m.entries, array_len(m.entries)-1));
+	last := _set_find_key(m^, array_get(m.entries, fr.entry_index).key);
+
+	if last.entry_prev < 0 {
+		array_get_ptr(m.entries, last.entry_prev).next = fr.entry_index;
+	} else {
+		array_set(&m.hash, last.hash_index, fr.entry_index);
+	}
+}
+
+
+_set_find_key :: proc(m: Set, key: u64) -> Map_Find_Result {
+	fr: Map_Find_Result;
+	fr.hash_index = -1;
+	fr.entry_prev = -1;
+	fr.entry_index = -1;
+
+	if array_len(m.hash) == 0 {
+		return fr;
+	}
+
+	fr.hash_index = int(key % u64(array_len(m.hash)));
+	fr.entry_index = array_get(m.hash, fr.hash_index);
+	for fr.entry_index >= 0 {
+		it := array_get_ptr(m.entries, fr.entry_index);
+		if it.key == key {
+			return fr;
+		}
+		fr.entry_prev = fr.entry_index;
+		fr.entry_index = it.next;
+	}
+	return fr;
+}
+
+_set_find_entry :: proc(m: ^Set, e: ^Set_Entry) -> Map_Find_Result {
+	fr: Map_Find_Result;
+	fr.hash_index = -1;
+	fr.entry_prev = -1;
+	fr.entry_index = -1;
+
+	if array_len(m.hash) == 0 {
+		return fr;
+	}
+
+	fr.hash_index = int(e.key % u64(array_len(m.hash)));
+	fr.entry_index = array_get(m.hash, fr.hash_index);
+	for fr.entry_index >= 0 {
+		it := array_get_ptr(m.entries, fr.entry_index);
+		if it == e {
+			return fr;
+		}
+		fr.entry_prev = fr.entry_index;
+		fr.entry_index = it.next;
+	}
+	return fr;
+}
+
+_set_find_or_fail :: proc(m: Set, key: u64) -> int {
+	return _set_find_key(m, key).entry_index;
+}
+_set_find_or_make :: proc(m: ^Set, key: u64) -> int {
+	fr := _set_find_key(m^, key);
+	if fr.entry_index >= 0 {
+		return fr.entry_index;
+	}
+
+	i := _set_add_entry(m, key);
+	if fr.entry_prev < 0 {
+		array_set(&m.hash, fr.hash_index, i);
+	} else {
+		array_get_ptr(m.entries, fr.entry_prev).next = i;
+	}
+	return i;
+}
+
+
+_set_make :: proc(m: ^Set, key: u64) -> int {
+	fr := _set_find_key(m^, key);
+	i := _set_add_entry(m, key);
+
+	if fr.entry_prev < 0 {
+		array_set(&m.hash, fr.hash_index, i);
+	} else {
+		array_get_ptr(m.entries, fr.entry_prev).next = i;
+	}
+
+	array_get_ptr(m.entries, i).next = fr.entry_index;
+
+	return i;
+}
+
+
+_set_full :: proc(m: Set) -> bool {
+	// TODO(bill): Determine good max load factor
+	return array_len(m.entries) >= (array_len(m.hash) / 4)*3;
+}
+
+_set_grow :: proc(m: ^Set) {
+	new_size := array_len(m.entries) * 4 + 7; // TODO(bill): Determine good grow rate
+	set_reserve(m, new_size);
+}
+
+

core/container/small_array.odin

@@ -0,0 +1,95 @@
+package container
+
+Small_Array :: struct(N: int, T: typeid) where N >= 0 {
+	data: [N]T,
+	len:  int,
+}
+
+
+small_array_len :: proc(a: $A/Small_Array) -> int {
+	return a.len;
+}
+
+small_array_cap :: proc(a: $A/Small_Array) -> int {
+	return len(a.data);
+}
+
+small_array_space :: proc(a: $A/Small_Array) -> int {
+	return len(a.data) - a.len;
+}
+
+small_array_slice :: proc(a: ^$A/Small_Array($N, $T)) -> []T {
+	return a.data[:a.len];
+}
+
+
+small_array_get :: proc(a: $A/Small_Array($N, $T), index: int, loc := #caller_location) -> T {
+	return a.data[index];
+}
+small_array_get_ptr :: proc(a: $A/Small_Array($N, $T), index: int, loc := #caller_location) -> ^T {
+	return &a.data[index];
+}
+
+small_array_set :: proc(a: ^$A/Small_Array($N, $T), index: int, item: T, loc := #caller_location) {
+	a.data[index] = item;
+}
+
+small_array_resize :: proc(a: ^$A/Small_Array, length: int) {
+	a.len = min(length, len(a.data));
+}
+
+
+small_array_push_back :: proc(a: ^$A/Small_Array($N, $T), item: T) -> bool {
+	if a.len < len(a.data) {
+		a.len += 1;
+		a.data[a.len-1] = item;
+		return true;
+	}
+	return false;
+}
+
+small_array_push_front :: proc(a: ^$A/Small_Array($N, $T), item: T) -> bool {
+	if a.len < len(a.data) {
+		a.len += 1;
+		data := small_array_slice(a);
+		copy(data[1:], data[:]);
+		data[0] = item;
+		return true;
+	}
+	return false;
+}
+
+small_array_pop_back :: proc(a: ^$A/Small_Array($N, $T), loc := #caller_location) -> T {
+	assert(condition=a.len > 0, loc=loc);
+	item := a.data[a.len-1];
+	a.len -= 1;
+	return item;
+}
+
+small_array_pop_front :: proc(a: ^$A/Small_Array($N, $T), loc := #caller_location) -> T {
+	assert(condition=a.len > 0, loc=loc);
+	item := a.data[0];
+	s := small_array_slice(a);
+	copy(s[:], s[1:]);
+	a.len -= 1;
+	return item;
+}
+
+
+small_array_consume :: proc(a: ^$A/Small_Array($N, $T), count: int, loc := #caller_location) {
+	assert(condition=a.len >= count, loc=loc);
+	a.len -= count;
+}
+
+small_array_clear :: proc(a: ^$A/Small_Array($N, $T)) {
+	small_array_resize(a, 0);
+}
+
+small_array_push_back_elems :: proc(a: ^$A/Small_Array($N, $T), items: ..T) {
+	n := copy(a.data[a.len:], items[:]);
+	a.len += n;
+}
+
+small_array_push   :: proc{small_array_push_back, small_array_push_back_elems};
+small_array_append :: proc{small_array_push_back, small_array_push_back_elems};
+

core/dynlib/lib.odin

@@ -0,0 +1,3 @@
+package dynlib
+
+Library :: distinct rawptr;

core/dynlib/lib_unix.odin

@@ -0,0 +1,23 @@
+// +build linux, darwin, freebsd
+package dynlib
+
+import "core:os"
+
+load_library :: proc(path: string, global_symbols := false) -> (Library, bool) {
+    flags := os.RTLD_NOW;
+    if global_symbols {
+    	flags |= os.RTLD_GLOBAL;
+    }
+    lib := os.dlopen(path, flags);
+    return Library(lib), lib != nil;
+}
+
+unload_library :: proc(library: Library) {
+    os.dlclose(rawptr(library));
+}
+
+symbol_address :: proc(library: Library, symbol: string) -> (ptr: rawptr, found: bool) {
+    ptr = os.dlsym(rawptr(library), symbol);
+    found = ptr != nil;
+    return;
+}

core/dynlib/lib_windows.odin

@@ -0,0 +1,25 @@
+// +build windows
+package dynlib
+
+import win32 "core:sys/windows"
+import "core:strings"
+
+load_library :: proc(path: string, global_symbols := false) -> (Library, bool) {
+	// NOTE(bill): 'global_symbols' is here only for consistency with POSIX which has RTLD_GLOBAL
+
+	wide_path := win32.utf8_to_wstring(path, context.temp_allocator);
+	handle := cast(Library)win32.LoadLibraryW(wide_path);
+	return handle, handle != nil;
+}
+
+unload_library :: proc(library: Library) -> bool {
+	ok := win32.FreeLibrary(cast(win32.HMODULE)library);
+	return bool(ok);
+}
+
+symbol_address :: proc(library: Library, symbol: string) -> (ptr: rawptr, found: bool) {
+	c_str := strings.clone_to_cstring(symbol, context.temp_allocator);
+	ptr = win32.GetProcAddress(cast(win32.HMODULE)library, c_str);
+	found = ptr != nil;
+	return;
+}

core/encoding/base32/base32.odin

@@ -0,0 +1,148 @@
+package base32
+
+// @note(zh): Encoding utility for Base32
+// A secondary param can be used to supply a custom alphabet to
+// @link(encode) and a matching decoding table to @link(decode).
+// If none is supplied it just uses the standard Base32 alphabet.
+// Incase your specific version does not use padding, you may
+// truncate it from the encoded output.
+
+ENC_TABLE := [32]byte {
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+    'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+    'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+    'Y', 'Z', '2', '3', '4', '5', '6', '7',
+};
+
+PADDING :: '=';
+
+DEC_TABLE := [?]u8 {
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0, 26, 27, 28, 29, 30, 31,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,  0,  0,  0,  0,  0,
+     0,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+};
+
+encode :: proc(data: []byte, ENC_TBL := ENC_TABLE, allocator := context.allocator) -> string {
+    out_length := (len(data) + 4) / 5 * 8;
+    out := make([]byte, out_length);
+    _encode(out, data);
+    return string(out);
+}
+
+@private
+_encode :: proc(out, data: []byte, ENC_TBL := ENC_TABLE, allocator := context.allocator) {
+    out := out;
+    data := data;
+
+    for len(data) > 0 {
+        carry: byte;
+        switch len(data) {
+            case:
+                out[7] = ENC_TABLE[data[4] & 0x1f];
+                carry = data[4] >> 5;
+                fallthrough;
+            case 4:
+                out[6] = ENC_TABLE[carry | (data[3] << 3) & 0x1f];
+                out[5] = ENC_TABLE[(data[3] >> 2) & 0x1f];
+                carry = data[3] >> 7;
+                fallthrough;
+            case 3:
+                out[4] = ENC_TABLE[carry | (data[2] << 1) & 0x1f];
+                carry = (data[2] >> 4) & 0x1f;
+                fallthrough;
+            case 2:
+                out[3] = ENC_TABLE[carry | (data[1] << 4) & 0x1f];
+                out[2] = ENC_TABLE[(data[1] >> 1) & 0x1f];
+                carry = (data[1] >> 6) & 0x1f;
+                fallthrough;
+            case 1:
+                out[1] = ENC_TABLE[carry | (data[0] << 2) & 0x1f];
+                out[0] = ENC_TABLE[data[0] >> 3];
+        }
+
+        if len(data) < 5 {
+            out[7] = byte(PADDING);
+            if len(data) < 4 {
+                out[6] = byte(PADDING);
+                out[5] = byte(PADDING);
+                if len(data) < 3 {
+                    out[4] = byte(PADDING);
+                    if len(data) < 2 {
+                        out[3] = byte(PADDING);
+                        out[2] = byte(PADDING);
+                    }
+                }
+            }
+            break;
+        }
+        data = data[5:];
+        out = out[8:];
+    }
+}
+
+decode :: proc(data: string, DEC_TBL := DEC_TABLE, allocator := context.allocator) -> []byte #no_bounds_check{
+    if len(data) == 0 {
+        return nil;
+    }
+
+    outi := 0;
+    data := data;
+
+    out := make([]byte, len(data) / 8 * 5, allocator);
+    end := false;
+    for len(data) > 0 && !end {
+        dbuf : [8]byte;
+        dlen := 8;
+
+        for j := 0; j < 8; {
+            if len(data) == 0 {
+                dlen, end = j, true;
+                break;
+            }
+            input := data[0];
+            data = data[1:];
+            if input == byte(PADDING) && j >= 2 && len(data) < 8 {
+                assert(!(len(data) + j < 8 - 1), "Corrupted input");
+                for k := 0; k < 8-1-j; k +=1 {
+                    assert(len(data) < k || data[k] == byte(PADDING), "Corrupted input");
+                }
+                dlen, end = j, true;
+                assert(dlen != 1 && dlen != 3 && dlen != 6, "Corrupted input");
+                break;
+            }
+            dbuf[j] = DEC_TABLE[input];
+            assert(dbuf[j] != 0xff, "Corrupted input");
+            j += 1;
+        }
+
+        switch dlen {
+            case 8:
+                out[outi + 4] = dbuf[6] << 5 | dbuf[7];
+                fallthrough;
+            case 7:
+                out[outi + 3] = dbuf[4] << 7 | dbuf[5] << 2 | dbuf[6] >> 3;
+                fallthrough;
+            case 5:
+                out[outi + 2] = dbuf[3] << 4 | dbuf[4] >> 1;
+                fallthrough;
+            case 4:
+                out[outi + 1] = dbuf[1] << 6 | dbuf[2] << 1 | dbuf[3] >> 4;
+                fallthrough;
+            case 2:
+                out[outi + 0] = dbuf[0] << 3 | dbuf[1] >> 2;
+        }
+        outi += 5;
+    }
+    return out;
+}

core/encoding/base64/base64.odin

@@ -0,0 +1,97 @@
+package base64
+
+// @note(zh): Encoding utility for Base64
+// A secondary param can be used to supply a custom alphabet to
+// @link(encode) and a matching decoding table to @link(decode).
+// If none is supplied it just uses the standard Base64 alphabet.
+// Incase your specific version does not use padding, you may
+// truncate it from the encoded output.
+
+ENC_TABLE := [64]byte {
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+    'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+    'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+    'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+    'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+    'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+    'w', 'x', 'y', 'z', '0', '1', '2', '3',
+    '4', '5', '6', '7', '8', '9', '+', '/',
+};
+
+PADDING :: '=';
+
+DEC_TABLE := [128]int {
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, 62, -1, -1, -1, 63,
+    52, 53, 54, 55, 56, 57, 58, 59,
+    60, 61, -1, -1, -1, -1, -1, -1,
+    -1,  0,  1,  2,  3,  4,  5,  6,
+     7,  8,  9, 10, 11, 12, 13, 14,
+    15, 16, 17, 18, 19, 20, 21, 22,
+    23, 24, 25, -1, -1, -1, -1, -1,
+    -1, 26, 27, 28, 29, 30, 31, 32,
+    33, 34, 35, 36, 37, 38, 39, 40,
+    41, 42, 43, 44, 45, 46, 47, 48,
+    49, 50, 51, -1, -1, -1, -1, -1,
+};
+
+encode :: proc(data: []byte, ENC_TBL := ENC_TABLE, allocator := context.allocator) -> string #no_bounds_check {
+    length := len(data);
+    if length == 0 {
+        return "";
+    }
+
+    out_length := ((4 * length / 3) + 3) &~ 3;
+    out := make([]byte, out_length, allocator);
+
+    c0, c1, c2, block: int;
+
+    for i, d := 0, 0; i < length; i, d = i + 3, d + 4 {
+        c0, c1, c2 = int(data[i]), -1, -1;
+
+        if i + 1 < length { c1 = int(data[i + 1]); }
+        if i + 2 < length { c2 = int(data[i + 2]); }
+
+        block = (c0 << 16) | (max(c1, 0) << 8) | max(c2, 0);
+
+        out[d]     = ENC_TBL[block >> 18 & 63];
+        out[d + 1] = ENC_TBL[block >> 12 & 63];
+        out[d + 2] = c1 == -1 ? PADDING : ENC_TBL[block >> 6 & 63];
+        out[d + 3] = c2 == -1 ? PADDING : ENC_TBL[block & 63];
+    }
+    return string(out);
+}
+
+decode :: proc(data: string, DEC_TBL := DEC_TABLE, allocator := context.allocator) -> []byte #no_bounds_check {
+    length := len(data);
+    if length == 0 {
+        return nil;
+    }
+
+    pad_count := data[length - 1] == PADDING ? (data[length - 2] == PADDING ? 2 : 1) : 0;
+    out_length := ((length * 6) >> 3) - pad_count;
+    out := make([]byte, out_length, allocator);
+
+    c0, c1, c2, c3: int;
+    b0, b1, b2: int;
+
+    for i, j := 0, 0; i < length; i, j = i + 4, j + 3 {
+        c0 = DEC_TBL[data[i]];
+        c1 = DEC_TBL[data[i + 1]];
+        c2 = DEC_TBL[data[i + 2]];
+        c3 = DEC_TBL[data[i + 3]];
+
+        b0 = (c0 << 2) | (c1 >> 4);
+        b1 = (c1 << 4) | (c2 >> 2);
+        b2 = (c2 << 6) | c3;
+
+        out[j]     = byte(b0);
+        out[j + 1] = byte(b1);
+        out[j + 2] = byte(b2);
+    }
+    return out;
+}

core/encoding/cel/cel.odin

@@ -0,0 +1,852 @@
+package cel;
+
+import "core:fmt"
+import "core:strconv"
+import "core:unicode/utf8"
+import "core:strings"
+
+Array :: []Value;
+Dict  :: map[string]Value;
+Nil_Value :: struct{};
+
+Value :: union {
+	Nil_Value,
+	bool, i64, f64, string,
+	Array, Dict,
+}
+
+Parser :: struct {
+	tokens:           [dynamic]Token,
+	prev_token:       Token,
+	curr_token:       Token,
+	curr_token_index: int,
+
+	allocated_strings: [dynamic]string,
+
+	error_count: int,
+
+	root: Dict,
+	dict_stack: [dynamic]^Dict, // NOTE: Pointers may be stored on the stack
+}
+
+
+print_value :: proc(value: Value, pretty := true, indent := 0) {
+	print_indent :: proc(indent: int) {
+		for _ in 0..<indent {
+			fmt.print("\t");
+		}
+	}
+
+	switch v in value {
+	case bool: fmt.print(v);
+	case i64: fmt.print(v);
+	case f64: fmt.print(v);
+	case string: fmt.print(v);
+	case Array:
+		fmt.print("[");
+		if pretty { fmt.println(); }
+		for e, i in v {
+			if pretty {
+				print_indent(indent+1);
+				print_value(e, pretty, indent+1);
+				fmt.println(",");
+			} else {
+				if i > 0 { fmt.print(", "); }
+				print_value(e);
+			}
+		}
+		if pretty { print_indent(indent); }
+		fmt.print("]");
+	case Dict:
+		fmt.print("{");
+		if pretty { fmt.println(); }
+
+		i := 0;
+		for name, val in v {
+			if pretty {
+				print_indent(indent+1);
+				fmt.printf("%s = ", name);
+				print_value(val, pretty, indent+1);
+				fmt.println(",");
+			} else {
+				if i > 0 { fmt.print(", "); }
+				fmt.printf("%s = ", name);
+				print_value(val, pretty, indent+1);
+				i += 1;
+			}
+		}
+
+		if pretty { print_indent(indent); }
+		fmt.print("}");
+	case:
+		fmt.print("nil");
+	case Nil_Value:
+		fmt.print("nil");
+	}
+}
+print :: proc(p: ^Parser, pretty := false) {
+	for name, val in p.root {
+		fmt.printf("%s = ", name);
+		print_value(val, pretty);
+		fmt.println(";");
+	}
+}
+
+create_from_string :: proc(src: string) -> (^Parser, bool) {
+	return init(transmute([]byte)src);
+}
+
+
+init :: proc(src: []byte) -> (^Parser, bool) {
+	t: Tokenizer;
+	tokenizer_init(&t, src);
+	return create_from_tokenizer(&t);
+}
+
+
+create_from_tokenizer :: proc(t: ^Tokenizer) -> (^Parser, bool) {
+	p := new(Parser);
+	for {
+		tok := scan(t);
+		if tok.kind == .Illegal {
+			return p, false;
+		}
+		append(&p.tokens, tok);
+		if tok.kind == .EOF {
+			break;
+		}
+	}
+
+	if t.error_count > 0 {
+		return p, false;
+	}
+
+	if len(p.tokens) == 0 {
+		tok := Token{kind = .EOF};
+		tok.line, tok.column = 1, 1;
+		append(&p.tokens, tok);
+		return p, true;
+	}
+
+	p.curr_token_index = 0;
+	p.prev_token = p.tokens[p.curr_token_index];
+	p.curr_token = p.tokens[p.curr_token_index];
+
+	p.root = Dict{};
+	p.dict_stack = make([dynamic]^Dict, 0, 4);
+	append(&p.dict_stack, &p.root);
+
+	for p.curr_token.kind != .EOF &&
+	    p.curr_token.kind != .Illegal &&
+	    p.curr_token_index < len(p.tokens) {
+		if !parse_assignment(p) {
+			break;
+		}
+	}
+
+	return p, true;
+}
+
+destroy :: proc(p: ^Parser) {
+	destroy_value :: proc(value: Value) {
+		#partial switch v in value {
+		case Array:
+			for elem in v {
+				destroy_value(elem);
+			}
+			delete(v);
+
+		case Dict:
+			for _, dv in v {
+				destroy_value(dv);
+			}
+			delete(v);
+		}
+	}
+
+	delete(p.tokens);
+	for s in p.allocated_strings {
+		delete(s);
+	}
+	delete(p.allocated_strings);
+	delete(p.dict_stack);
+
+	destroy_value(p.root);
+	free(p);
+}
+
+error :: proc(p: ^Parser, pos: Pos, msg: string, args: ..any) {
+	fmt.eprintf("%s(%d:%d) Error: ", pos.file, pos.line, pos.column);
+	fmt.eprintf(msg, ..args);
+	fmt.eprintln();
+
+	p.error_count += 1;
+}
+
+next_token :: proc(p: ^Parser) -> Token {
+	p.prev_token = p.curr_token;
+	prev := p.prev_token;
+
+	if p.curr_token_index+1 < len(p.tokens) {
+		p.curr_token_index += 1;
+		p.curr_token = p.tokens[p.curr_token_index];
+		return prev;
+	}
+	p.curr_token_index = len(p.tokens);
+	p.curr_token = p.tokens[p.curr_token_index-1];
+	error(p, prev.pos, "Token is EOF");
+	return prev;
+}
+
+unquote_char :: proc(str: string, quote: byte) -> (r: rune, multiple_bytes: bool, tail_string: string, success: bool) {
+	hex_to_int :: proc(c: byte) -> int {
+		switch c {
+		case '0'..'9': return int(c-'0');
+		case 'a'..'f': return int(c-'a')+10;
+		case 'A'..'F': return int(c-'A')+10;
+		}
+		return -1;
+	}
+	w: int;
+
+	if str[0] == quote && quote == '"' {
+		return;
+	} else if str[0] >= 0x80 {
+		r, w = utf8.decode_rune_in_string(str);
+		return r, true, str[w:], true;
+	} else if str[0] != '\\' {
+		return rune(str[0]), false, str[1:], true;
+	}
+
+	if len(str) <= 1 {
+		return;
+	}
+	s := str;
+	c := s[1];
+	s = s[2:];
+
+	switch c {
+	case:
+		return;
+
+	case 'a':  r = '\a';
+	case 'b':  r = '\b';
+	case 'f':  r = '\f';
+	case 'n':  r = '\n';
+	case 'r':  r = '\r';
+	case 't':  r = '\t';
+	case 'v':  r = '\v';
+	case '\\': r = '\\';
+
+	case '"':  r = '"';
+	case '\'': r = '\'';
+
+	case '0'..'7':
+		v := int(c-'0');
+		if len(s) < 2 {
+			return;
+		}
+		for i in 0..<len(s) {
+			d := int(s[i]-'0');
+			if d < 0 || d > 7 {
+				return;
+			}
+			v = (v<<3) | d;
+		}
+		s = s[2:];
+		if v > 0xff {
+			return;
+		}
+		r = rune(v);
+
+	case 'x', 'u', 'U':
+		count: int;
+		switch c {
+		case 'x': count = 2;
+		case 'u': count = 4;
+		case 'U': count = 8;
+		}
+
+		if len(s) < count {
+			return;
+		}
+
+		for i in 0..<count {
+			d := hex_to_int(s[i]);
+			if d < 0 {
+				return;
+			}
+			r = (r<<4) | rune(d);
+		}
+		s = s[count:];
+		if c == 'x' {
+			break;
+		}
+		if r > utf8.MAX_RUNE {
+			return;
+		}
+		multiple_bytes = true;
+	}
+
+	success = true;
+	tail_string = s;
+	return;
+}
+
+
+unquote_string :: proc(p: ^Parser, t: Token) -> (string, bool) {
+	if t.kind != .String {
+		return t.lit, true;
+	}
+	s := t.lit;
+	quote := '"';
+
+	if s == `""` {
+        return "", true;
+    }
+
+	if strings.contains_rune(s, '\n') >= 0 {
+		return s, false;
+	}
+
+	if strings.contains_rune(s, '\\') < 0 && strings.contains_rune(s, quote) < 0 {
+		if quote == '"' {
+			return s, true;
+		}
+	}
+
+
+	buf_len := 3*len(s) / 2;
+	buf := make([]byte, buf_len);
+	offset := 0;
+	for len(s) > 0 {
+		r, multiple_bytes, tail_string, ok := unquote_char(s, byte(quote));
+		if !ok {
+			delete(buf);
+			return s, false;
+		}
+		s = tail_string;
+		if r < 0x80 || !multiple_bytes {
+			buf[offset] = byte(r);
+			offset += 1;
+		} else {
+			b, w := utf8.encode_rune(r);
+			copy(buf[offset:], b[:w]);
+			offset += w;
+		}
+	}
+
+	new_string := string(buf[:offset]);
+
+	append(&p.allocated_strings, new_string);
+
+	return new_string, true;
+}
+
+
+allow_token :: proc(p: ^Parser, kind: Kind) -> bool {
+	if p.curr_token.kind == kind {
+		next_token(p);
+		return true;
+	}
+	return false;
+}
+
+expect_token :: proc(p: ^Parser, kind: Kind) -> Token {
+	prev := p.curr_token;
+	if prev.kind != kind {
+		got := prev.lit;
+		if got == "\n" {
+			got = ";";
+		}
+		error(p, prev.pos, "Expected %s, got %s", kind_to_string[kind], got);
+	}
+	next_token(p);
+	return prev;
+}
+
+expect_operator :: proc(p: ^Parser) -> Token {
+	prev := p.curr_token;
+	if !is_operator(prev.kind) {
+		error(p, prev.pos, "Expected an operator, got %s", prev.lit);
+	}
+
+
+	next_token(p);
+	return prev;
+}
+
+fix_advance :: proc(p: ^Parser) {
+	for {
+		#partial switch t := p.curr_token; t.kind {
+		case .EOF, .Semicolon:
+			return;
+		}
+		next_token(p);
+	}
+}
+
+copy_value :: proc(value: Value) -> Value {
+	#partial switch v in value {
+	case Array:
+		a := make(Array, len(v));
+		for elem, idx in v {
+			a[idx] = copy_value(elem);
+		}
+		return a;
+	case Dict:
+		d := make(Dict, cap(v));
+		for key, val in v {
+			d[key] = copy_value(val);
+		}
+		return d;
+	}
+	return value;
+}
+
+lookup_value :: proc(p: ^Parser, name: string) -> (Value, bool) {
+	for i := len(p.dict_stack)-1; i >= 0; i -= 1 {
+		d := p.dict_stack[i];
+		if val, ok := d[name]; ok {
+			return copy_value(val), true;
+		}
+	}
+
+	return nil, false;
+}
+
+parse_operand :: proc(p: ^Parser) -> (Value, Pos) {
+	tok := p.curr_token;
+	#partial switch p.curr_token.kind {
+	case .Ident:
+		next_token(p);
+		v, ok := lookup_value(p, tok.lit);
+		if !ok { error(p, tok.pos, "Undeclared identifier %s", tok.lit); }
+		return v, tok.pos;
+
+	case .True:
+		next_token(p);
+		return true, tok.pos;
+	case .False:
+		next_token(p);
+		return false, tok.pos;
+
+	case .Nil:
+		next_token(p);
+		return Nil_Value{}, tok.pos;
+
+	case .Integer:
+		next_token(p);
+		i, _ := strconv.parse_i64(tok.lit);
+		return i, tok.pos;
+
+	case .Float:
+		next_token(p);
+		f, _ := strconv.parse_f64(tok.lit);
+		return f, tok.pos;
+
+	case .String:
+		next_token(p);
+		str, ok := unquote_string(p, tok);
+		if !ok { error(p, tok.pos, "Unable to unquote string"); }
+		return string(str), tok.pos;
+
+	case .Open_Paren:
+		expect_token(p, .Open_Paren);
+		expr, _ := parse_expr(p);
+		expect_token(p, .Close_Paren);
+		return expr, tok.pos;
+
+	case .Open_Bracket:
+		expect_token(p, .Open_Bracket);
+		elems := make([dynamic]Value, 0, 4);
+		for p.curr_token.kind != .Close_Bracket &&
+		    p.curr_token.kind != .EOF {
+			elem, _ := parse_expr(p);
+			append(&elems, elem);
+
+			if p.curr_token.kind == .Semicolon && p.curr_token.lit == "\n" {
+				next_token(p);
+			} else if !allow_token(p, .Comma) {
+				break;
+			}
+
+		}
+		expect_token(p, .Close_Bracket);
+		return Array(elems[:]), tok.pos;
+
+	case .Open_Brace:
+		expect_token(p, .Open_Brace);
+
+    	dict := Dict{};
+    	append(&p.dict_stack, &dict);
+    	defer pop(&p.dict_stack);
+
+		for p.curr_token.kind != .Close_Brace &&
+		    p.curr_token.kind != .EOF {
+		    name_tok := p.curr_token;
+		    if !allow_token(p, .Ident) && !allow_token(p, .String) {
+		    	name_tok = expect_token(p, .Ident);
+		    }
+
+			name, ok := unquote_string(p, name_tok);
+			if !ok { error(p, tok.pos, "Unable to unquote string"); }
+		    expect_token(p, .Assign);
+			elem, _ := parse_expr(p);
+
+			if _, ok2 := dict[name]; ok2 {
+				error(p, name_tok.pos, "Previous declaration of %s in this scope", name);
+			} else {
+				dict[name] = elem;
+			}
+
+			if p.curr_token.kind == .Semicolon && p.curr_token.lit == "\n" {
+				next_token(p);
+			} else if !allow_token(p, .Comma) {
+				break;
+			}
+		}
+		expect_token(p, .Close_Brace);
+		return dict, tok.pos;
+
+	}
+	return nil, tok.pos;
+}
+
+parse_atom_expr :: proc(p: ^Parser, operand: Value, pos: Pos) -> (Value, Pos) {
+	loop := true;
+	for operand := operand; loop;  {
+		#partial switch p.curr_token.kind {
+		case .Period:
+			next_token(p);
+			tok := next_token(p);
+
+			#partial switch tok.kind {
+			case .Ident:
+				d, ok := operand.(Dict);
+				if !ok || d == nil {
+					error(p, tok.pos, "Expected a dictionary");
+					operand = nil;
+					continue;
+				}
+				name, usok := unquote_string(p, tok);
+				if !usok { error(p, tok.pos, "Unable to unquote string"); }
+				val, found := d[name];
+				if !found {
+					error(p, tok.pos, "Field %s not found in dictionary", name);
+					operand = nil;
+					continue;
+				}
+				operand = val;
+			case:
+				error(p, tok.pos, "Expected a selector, got %s", tok.kind);
+				operand = nil;
+			}
+
+		case .Open_Bracket:
+			expect_token(p, .Open_Bracket);
+			index, index_pos := parse_expr(p);
+			expect_token(p, .Close_Bracket);
+
+
+			#partial switch a in operand {
+			case Array:
+				i, ok := index.(i64);
+				if !ok {
+					error(p, index_pos, "Index must be an integer for an array");
+					operand = nil;
+					continue;
+				}
+
+				if 0 <= i && i < i64(len(a)) {
+					operand = a[i];
+				} else {
+					error(p, index_pos, "Index %d out of bounds range 0..%d", i, len(a));
+					operand = nil;
+					continue;
+				}
+
+			case Dict:
+				key, ok := index.(string);
+				if !ok {
+					error(p, index_pos, "Index must be a string for a dictionary");
+					operand = nil;
+					continue;
+				}
+
+				val, found := a[key];
+				if found {
+					operand = val;
+				} else {
+					error(p, index_pos, "`%s` was not found in the dictionary", key);
+					operand = nil;
+					continue;
+				}
+
+
+
+			case:
+				error(p, index_pos, "Indexing is only allowed on an array or dictionary");
+			}
+
+		case:
+			loop = false;
+		}
+	}
+
+	return operand, pos;
+}
+
+parse_unary_expr :: proc(p: ^Parser) -> (Value, Pos) {
+	op := p.curr_token;
+	#partial switch p.curr_token.kind {
+	case .At:
+		next_token(p);
+		tok := expect_token(p, .String);
+		v, ok := lookup_value(p, tok.lit);
+		if !ok { error(p, tok.pos, "Undeclared identifier %s", tok.lit); }
+		return parse_atom_expr(p, v, tok.pos);
+
+	case .Add, .Sub:
+		next_token(p);
+		// TODO(bill): Calcuate values as you go!
+		expr, pos := parse_unary_expr(p);
+
+		#partial switch e in expr {
+		case i64: if op.kind == .Sub { return -e, pos; }
+		case f64: if op.kind == .Sub { return -e, pos; }
+		case:
+			error(p, op.pos, "Unary operator %s can only be used on integers or floats", op.lit);
+			return nil, op.pos;
+		}
+
+		return expr, op.pos;
+
+	case .Not:
+		next_token(p);
+		expr, _ := parse_unary_expr(p);
+		if v, ok := expr.(bool); ok {
+			return !v, op.pos;
+		}
+		error(p, op.pos, "Unary operator %s can only be used on booleans", op.lit);
+		return nil, op.pos;
+	}
+
+	return parse_atom_expr(p, parse_operand(p));
+}
+
+
+value_order :: proc(v: Value) -> int {
+	#partial switch _ in v {
+	case bool, string:
+		return 1;
+	case i64:
+		return 2;
+	case f64:
+		return 3;
+	}
+	return 0;
+}
+
+match_values :: proc(left, right: ^Value) -> bool {
+	if value_order(right^) < value_order(left^) {
+		return match_values(right, left);
+	}
+
+	#partial switch x in left^ {
+	case:
+		right^ = left^;
+	case bool, string:
+		return true;
+	case i64:
+		#partial switch y in right^ {
+		case i64:
+			return true;
+		case f64:
+			left^ = f64(x);
+			return true;
+		}
+
+	case f64:
+		#partial switch y in right {
+		case f64:
+			return true;
+		}
+	}
+
+	return false;
+}
+
+calculate_binary_value :: proc(p: ^Parser, op: Kind, a_, b_: Value) -> (Value, bool) {
+	// TODO(bill): Calculate value as you go!
+	x, y := a_, b_;
+	match_values(&x, &y);
+
+
+	#partial switch a in x {
+	case: return x, true;
+
+	case bool:
+		b, ok := y.(bool);
+		if !ok { return nil, false; }
+		#partial switch op {
+		case .Eq:    return a == b, true;
+		case .NotEq: return a != b, true;
+		case .And:   return a && b, true;
+		case .Or:    return a || b, true;
+		}
+
+	case i64:
+		b, ok := y.(i64);
+		if !ok { return nil, false; }
+		#partial switch op {
+		case .Add:   return a + b, true;
+		case .Sub:   return a - b, true;
+		case .Mul:   return a * b, true;
+		case .Quo:   return a / b, true;
+		case .Rem:   return a % b, true;
+		case .Eq:    return a == b, true;
+		case .NotEq: return a != b, true;
+		case .Lt:    return a <  b, true;
+		case .Gt:    return a >  b, true;
+		case .LtEq:  return a <= b, true;
+		case .GtEq:  return a >= b, true;
+		}
+
+	case f64:
+		b, ok := y.(f64);
+		if !ok { return nil, false; }
+
+		#partial switch op {
+		case .Add:   return a + b, true;
+		case .Sub:   return a - b, true;
+		case .Mul:   return a * b, true;
+		case .Quo:   return a / b, true;
+		case .Eq:    return a == b, true;
+		case .NotEq: return a != b, true;
+		case .Lt:    return a <  b, true;
+		case .Gt:    return a >  b, true;
+		case .LtEq:  return a <= b, true;
+		case .GtEq:  return a >= b, true;
+		}
+
+	case string:
+		b, ok := y.(string);
+		if !ok { return nil, false; }
+
+		#partial switch op {
+		case .Add:
+			n := len(a) + len(b);
+			data := make([]byte, n);
+			copy(data[:], a);
+			copy(data[len(a):], b);
+			s := string(data);
+			append(&p.allocated_strings, s);
+			return s, true;
+
+		case .Eq:    return a == b, true;
+		case .NotEq: return a != b, true;
+		case .Lt:    return a <  b, true;
+		case .Gt:    return a >  b, true;
+		case .LtEq:  return a <= b, true;
+		case .GtEq:  return a >= b, true;
+		}
+	}
+
+	return nil, false;
+}
+
+parse_binary_expr :: proc(p: ^Parser, prec_in: int) -> (Value, Pos) {
+	expr, pos := parse_unary_expr(p);
+	for prec := precedence(p.curr_token.kind); prec >= prec_in; prec -= 1 {
+		for {
+			op := p.curr_token;
+			op_prec := precedence(op.kind);
+			if op_prec != prec {
+				break;
+			}
+			expect_operator(p);
+
+			if op.kind == .Question {
+				cond := expr;
+				x, _ := parse_expr(p);
+				expect_token(p, .Colon);
+				y, _ := parse_expr(p);
+
+				if t, ok := cond.(bool); ok {
+					expr = t ? x : y;
+				} else {
+					error(p, pos, "Condition must be a boolean");
+				}
+
+			} else {
+				right, right_pos := parse_binary_expr(p, prec+1);
+				if right == nil {
+					error(p, right_pos, "Expected expression on the right-hand side of the binary operator %s", op.lit);
+				}
+				left := expr;
+				ok: bool;
+				expr, ok = calculate_binary_value(p, op.kind, left, right);
+				if !ok {
+					error(p, pos, "Invalid binary operation");
+				}
+			}
+		}
+	}
+	return expr, pos;
+}
+
+parse_expr :: proc(p: ^Parser) -> (Value, Pos) {
+	return parse_binary_expr(p, 1);
+}
+
+expect_semicolon :: proc(p: ^Parser) {
+	kind := p.curr_token.kind;
+
+	#partial switch kind {
+	case .Comma:
+		error(p, p.curr_token.pos, "Expected ';', got ','");
+		next_token(p);
+	case .Semicolon:
+		next_token(p);
+	case .EOF:
+		// okay
+	case:
+		error(p, p.curr_token.pos, "Expected ';', got %s", p.curr_token.lit);
+		fix_advance(p);
+	}
+}
+
+parse_assignment :: proc(p: ^Parser) -> bool {
+	top_dict :: proc(p: ^Parser) -> ^Dict {
+		assert(len(p.dict_stack) > 0);
+		return p.dict_stack[len(p.dict_stack)-1];
+	}
+
+	if p.curr_token.kind == .Semicolon {
+		next_token(p);
+		return true;
+	}
+	if p.curr_token.kind == .EOF {
+		return false;
+	}
+
+	tok := p.curr_token;
+	if allow_token(p, .Ident) || allow_token(p, .String) {
+		expect_token(p, .Assign);
+		name, ok := unquote_string(p, tok);
+		if !ok { error(p, tok.pos, "Unable to unquote string"); }
+		expr, _ := parse_expr(p);
+		d := top_dict(p);
+		if _, ok2 := d[name]; ok2 {
+			error(p, tok.pos, "Previous declaration of %s", name);
+		} else {
+			d[name] = expr;
+		}
+		expect_semicolon(p);
+		return true;
+	}
+	error(p, tok.pos, "Expected an assignment, got %s", kind_to_string[tok.kind]);
+	fix_advance(p);
+	return false;
+}

core/encoding/cel/doc.odin

@@ -0,0 +1,51 @@
+/*
+	package cel
+
+	sample := `
+	x = 123;
+	y = 321.456;
+	z = x * (y - 1) / 2;
+	w = "foo" + "bar";
+
+	# This is a comment
+
+	asd = "Semicolons are optional"
+
+	a = {id = {b = 123}} # Dict
+	b = a.id.b
+
+	f = [1, 4, 9] # Array
+	g = f[2]
+
+	h = x < y and w == "foobar"
+	i = h ? 123 : "google"
+
+	j = nil
+
+	"127.0.0.1" = "value" # Keys can be strings
+
+	"foo" = {
+		"bar" = {
+			"baz" = 123, # optional commas if newline is present
+			"zab" = 456,
+			"abz" = 789,
+		},
+	};
+
+	bar = @"foo"["bar"].baz
+	`;
+
+
+	main :: proc() {
+		p, ok := create_from_string(sample);
+		if !ok {
+			return;
+		}
+		defer destroy(p);
+
+		if p.error_count == 0 {
+			print(p);
+		}
+	}
+*/
+package cel

core/encoding/cel/token.odin

@@ -0,0 +1,523 @@
+package cel
+
+import "core:fmt"
+import "core:unicode/utf8"
+
+using Kind :: enum {
+	Illegal,
+	EOF,
+	Comment,
+
+	_literal_start,
+		Ident,
+		Integer,
+		Float,
+		Char,
+		String,
+	_literal_end,
+
+	_keyword_start,
+		True,  // true
+		False, // false
+		Nil,   // nil
+	_keyword_end,
+
+
+	_operator_start,
+		Question, // ?
+
+		And,   // and
+		Or,    // or
+
+		Add,   // +
+		Sub,   // -
+		Mul,   // *
+		Quo,   // /
+		Rem,   // %
+
+		Not,   // !
+
+		Eq,    // ==
+		NotEq, // !=
+		Lt,    // <
+		Gt,    // >
+		LtEq,  // <=
+		GtEq,  // >=
+
+		At,    // @
+	_operator_end,
+
+	_punc_start,
+		Assign, // =
+
+		Open_Paren,    // (
+		Close_Paren,   // )
+		Open_Bracket,  // [
+		Close_Bracket, // ]
+		Open_Brace,    // {
+		Close_Brace,   // }
+
+		Colon,     // :
+		Semicolon, // ;
+		Comma,     // ,
+		Period,    // .
+	_punc_end,
+}
+
+
+Pos :: struct {
+	file:   string,
+	line:   int,
+	column: int,
+}
+
+Token :: struct {
+	kind:      Kind,
+	using pos: Pos,
+	lit:       string,
+}
+
+Tokenizer :: struct {
+	src:         []byte,
+
+	file:        string, // May not be used
+
+	curr_rune:   rune,
+	offset:      int,
+	read_offset: int,
+	line_offset: int,
+	line_count:  int,
+
+	insert_semi: bool,
+
+	error_count: int,
+}
+
+
+keywords := map[string]Kind{
+	"true"  = True,
+	"false" = False,
+	"nil"   = Nil,
+	"and"   = And,
+	"or"    = Or,
+};
+
+kind_to_string := [len(Kind)]string{
+	"illegal",
+	"EOF",
+	"comment",
+
+	"",
+	"identifier",
+	"integer",
+	"float",
+	"character",
+	"string",
+	"",
+
+	"",
+	"true", "false", "nil",
+	"",
+
+	"",
+	"?", "and", "or",
+	"+", "-", "*", "/", "%",
+	"!",
+	"==", "!=", "<", ">", "<=", ">=",
+	"@",
+	"",
+
+	"",
+	"=",
+	"(", ")",
+	"[", "]",
+	"{", "}",
+	":", ";", ",", ".",
+	"",
+};
+
+precedence :: proc(op: Kind) -> int {
+	#partial switch op {
+	case Question:
+		return 1;
+	case Or:
+		return 2;
+	case And:
+		return 3;
+	case Eq, NotEq, Lt, Gt, LtEq, GtEq:
+		return 4;
+	case Add, Sub:
+		return 5;
+	case Mul, Quo, Rem:
+		return 6;
+	}
+	return 0;
+}
+
+
+token_lookup :: proc(ident: string) -> Kind {
+	if tok, is_keyword := keywords[ident]; is_keyword {
+		return tok;
+	}
+	return Ident;
+}
+
+is_literal  :: proc(tok: Kind) -> bool { return _literal_start  < tok && tok < _literal_end;  }
+is_operator :: proc(tok: Kind) -> bool { return _operator_start < tok && tok < _operator_end; }
+is_keyword  :: proc(tok: Kind) -> bool { return _keyword_start  < tok && tok < _keyword_end;  }
+
+
+tokenizer_init :: proc(t: ^Tokenizer, src: []byte, file := "") {
+	t.src = src;
+	t.file = file;
+	t.curr_rune   = ' ';
+	t.offset      = 0;
+	t.read_offset = 0;
+	t.line_offset = 0;
+	t.line_count  = 1;
+
+	advance_to_next_rune(t);
+	if t.curr_rune == utf8.RUNE_BOM {
+		advance_to_next_rune(t);
+	}
+}
+
+token_error :: proc(t: ^Tokenizer, msg: string, args: ..any) {
+	fmt.eprintf("%s(%d:%d) Error: ", t.file, t.line_count, t.read_offset-t.line_offset+1);
+	fmt.eprintf(msg, ..args);
+	fmt.eprintln();
+	t.error_count += 1;
+}
+
+advance_to_next_rune :: proc(t: ^Tokenizer) {
+	if t.read_offset < len(t.src) {
+		t.offset = t.read_offset;
+		if t.curr_rune == '\n' {
+			t.line_offset = t.offset;
+			t.line_count += 1;
+		}
+		r, w := rune(t.src[t.read_offset]), 1;
+		switch {
+		case r == 0:
+			token_error(t, "Illegal character NUL");
+		case r >= utf8.RUNE_SELF:
+			r, w = utf8.decode_rune(t.src[t.read_offset:]);
+			if r == utf8.RUNE_ERROR && w == 1 {
+				token_error(t, "Illegal utf-8 encoding");
+			} else if r == utf8.RUNE_BOM && t.offset > 0 {
+				token_error(t, "Illegal byte order mark");
+			}
+		}
+
+		t.read_offset += w;
+		t.curr_rune = r;
+	} else {
+		t.offset = len(t.src);
+		if t.curr_rune == '\n' {
+			t.line_offset = t.offset;
+			t.line_count += 1;
+		}
+		t.curr_rune = utf8.RUNE_EOF;
+	}
+}
+
+
+get_pos :: proc(t: ^Tokenizer) -> Pos {
+	return Pos {
+		file   = t.file,
+		line   = t.line_count,
+		column = t.offset - t.line_offset + 1,
+	};
+}
+
+is_letter :: proc(r: rune) -> bool {
+	switch r {
+	case 'a'..'z', 'A'..'Z', '_':
+		return true;
+	}
+	return false;
+}
+
+is_digit :: proc(r: rune) -> bool {
+	switch r {
+	case '0'..'9':
+		return true;
+	}
+	return false;
+}
+
+skip_whitespace :: proc(t: ^Tokenizer) {
+	loop: for {
+		switch t.curr_rune {
+		case '\n':
+			if t.insert_semi {
+				break loop;
+			}
+			fallthrough;
+		case ' ', '\t', '\r', '\v', '\f':
+			advance_to_next_rune(t);
+
+		case:
+			break loop;
+		}
+	}
+}
+
+scan_identifier :: proc(t: ^Tokenizer) -> string {
+	offset := t.offset;
+	for is_letter(t.curr_rune) || is_digit(t.curr_rune) {
+		advance_to_next_rune(t);
+	}
+	return string(t.src[offset : t.offset]);
+}
+
+digit_value :: proc(r: rune) -> int {
+	switch r {
+	case '0'..'9': return int(r - '0');
+	case 'a'..'f': return int(r - 'a' + 10);
+	case 'A'..'F': return int(r - 'A' + 10);
+	}
+	return 16;
+}
+
+scan_number :: proc(t: ^Tokenizer, seen_decimal_point: bool) -> (Kind, string) {
+	scan_mantissa :: proc(t: ^Tokenizer, base: int) {
+		for digit_value(t.curr_rune) < base || t.curr_rune == '_' {
+			advance_to_next_rune(t);
+		}
+	}
+	scan_exponent :: proc(t: ^Tokenizer, tok: Kind, offset: int) -> (kind: Kind, text: string) {
+		kind = tok;
+		if t.curr_rune == 'e' || t.curr_rune == 'E' {
+			kind = Float;
+			advance_to_next_rune(t);
+			if t.curr_rune == '-' || t.curr_rune == '+' {
+				advance_to_next_rune(t);
+			}
+			if digit_value(t.curr_rune) < 10 {
+				scan_mantissa(t, 10);
+			} else {
+				token_error(t, "Illegal floating point exponent");
+			}
+		}
+		text = string(t.src[offset : t.offset]);
+		return;
+	}
+	scan_fraction :: proc(t: ^Tokenizer, tok: Kind, offset: int) -> (kind: Kind, text: string)  {
+		kind = tok;
+		if t.curr_rune == '.' {
+			kind = Float;
+			advance_to_next_rune(t);
+			scan_mantissa(t, 10);
+		}
+
+		return scan_exponent(t, kind, offset);
+	}
+
+	offset := t.offset;
+	tok := Integer;
+
+	if seen_decimal_point {
+		offset -= 1;
+		tok = Float;
+		scan_mantissa(t, 10);
+		return scan_exponent(t, tok, offset);
+	}
+
+	if t.curr_rune == '0' {
+		offset = t.offset;
+		advance_to_next_rune(t);
+		switch t.curr_rune {
+		case 'b', 'B':
+			advance_to_next_rune(t);
+			scan_mantissa(t, 2);
+			if t.offset - offset <= 2 {
+				token_error(t, "Illegal binary number");
+			}
+		case 'o', 'O':
+			advance_to_next_rune(t);
+			scan_mantissa(t, 8);
+			if t.offset - offset <= 2 {
+				token_error(t, "Illegal octal number");
+			}
+		case 'x', 'X':
+			advance_to_next_rune(t);
+			scan_mantissa(t, 16);
+			if t.offset - offset <= 2 {
+				token_error(t, "Illegal hexadecimal number");
+			}
+		case:
+			scan_mantissa(t, 10);
+			switch t.curr_rune {
+			case '.', 'e', 'E':
+				return scan_fraction(t, tok, offset);
+			}
+		}
+
+		return tok, string(t.src[offset:t.offset]);
+	}
+
+	scan_mantissa(t, 10);
+
+	return scan_fraction(t, tok, offset);
+}
+
+scan :: proc(t: ^Tokenizer) -> Token {
+	skip_whitespace(t);
+
+	offset := t.offset;
+
+	tok: Kind;
+	pos := get_pos(t);
+	lit: string;
+
+	insert_semi := false;
+
+
+	switch r := t.curr_rune; {
+	case is_letter(r):
+		insert_semi = true;
+		lit = scan_identifier(t);
+		tok = Ident;
+		if len(lit) > 1 {
+			tok = token_lookup(lit);
+		}
+
+	case '0' <= r && r <= '9':
+		insert_semi = true;
+		tok, lit = scan_number(t, false);
+
+	case:
+		advance_to_next_rune(t);
+		switch r {
+		case -1:
+			if t.insert_semi {
+				t.insert_semi = false;
+				return Token{Semicolon, pos, "\n"};
+			}
+			return Token{EOF, pos, "\n"};
+
+		case '\n':
+			t.insert_semi = false;
+			return Token{Semicolon, pos, "\n"};
+
+		case '"':
+			insert_semi = true;
+			quote := r;
+			tok = String;
+			for {
+				this_r := t.curr_rune;
+				if this_r == '\n' || r < 0 {
+					token_error(t, "String literal not terminated");
+					break;
+				}
+				advance_to_next_rune(t);
+				if this_r == quote {
+					break;
+				}
+				// TODO(bill); Handle properly
+				if this_r == '\\' && t.curr_rune == quote {
+					advance_to_next_rune(t);
+				}
+			}
+
+			lit = string(t.src[offset+1:t.offset-1]);
+
+
+		case '#':
+			for t.curr_rune != '\n' && t.curr_rune >= 0 {
+				advance_to_next_rune(t);
+			}
+			if t.insert_semi {
+				t.insert_semi = false;
+				return Token{Semicolon, pos, "\n"};
+			}
+			// Recursive!
+			return scan(t);
+
+		case '?': tok = Question;
+		case ':': tok = Colon;
+		case '@': tok = At;
+
+		case ';':
+			tok = Semicolon;
+			lit = ";";
+		case ',': tok = Comma;
+
+		case '(':
+			tok = Open_Paren;
+		case ')':
+			insert_semi = true;
+			tok = Close_Paren;
+
+		case '[':
+			tok = Open_Bracket;
+		case ']':
+			insert_semi = true;
+			tok = Close_Bracket;
+
+		case '{':
+			tok = Open_Brace;
+		case '}':
+			insert_semi = true;
+			tok = Close_Brace;
+
+		case '+': tok = Add;
+		case '-': tok = Sub;
+		case '*': tok = Mul;
+		case '/': tok = Quo;
+		case '%': tok = Rem;
+
+		case '!':
+			tok = Not;
+			if t.curr_rune == '=' {
+				advance_to_next_rune(t);
+				tok = NotEq;
+			}
+
+		case '=':
+			tok = Assign;
+			if t.curr_rune == '=' {
+				advance_to_next_rune(t);
+				tok = Eq;
+			}
+
+		case '<':
+			tok = Lt;
+			if t.curr_rune == '=' {
+				advance_to_next_rune(t);
+				tok = LtEq;
+			}
+
+		case '>':
+			tok = Gt;
+			if t.curr_rune == '=' {
+				advance_to_next_rune(t);
+				tok = GtEq;
+			}
+
+		case '.':
+			if '0' <= t.curr_rune && t.curr_rune <= '9' {
+				insert_semi = true;
+				tok, lit = scan_number(t, true);
+			} else {
+				tok = Period;
+			}
+
+		case:
+			if r != utf8.RUNE_BOM {
+				token_error(t, "Illegal character '%r'", r);
+			}
+			insert_semi = t.insert_semi;
+			tok = Illegal;
+		}
+	}
+
+	t.insert_semi = insert_semi;
+
+	if lit == "" {
+		lit = string(t.src[offset:t.offset]);
+	}
+
+	return Token{tok, pos, lit};
+}

core/encoding/csv/reader.odin

@@ -0,0 +1,406 @@
+// package csv reads and writes comma-separated values (CSV) files.
+// This package supports the format described in RFC 4180 <https://tools.ietf.org/html/rfc4180.html>
+package csv
+
+import "core:bufio"
+import "core:bytes"
+import "core:io"
+import "core:strings"
+import "core:unicode/utf8"
+
+// Reader is a data structure used for reading records from a CSV-encoded file
+//
+// The associated procedures for Reader expects its input to conform to RFC 4180.
+Reader :: struct {
+	// comma is the field delimiter
+	// reader_init will set it to be ','
+	// A "comma" must be a valid rune, nor can it be \r, \n, or the Unicode replacement character (0xfffd)
+	comma: rune,
+
+	// comment, if not 0, is the comment character
+	// Lines beginning with the comment character without a preceding whitespace are ignored
+	comment: rune,
+
+	// fields_per_record is the number of expected fields per record
+	//         if fields_per_record is >0, 'read' requires each record to have that field count
+	//         if fields_per_record is  0, 'read' sets it to the field count in the first record
+	//         if fields_per_record is <0, no check is made and records may have a variable field count
+	fields_per_record: int,
+
+	// If trim_leading_space is true, leading whitespace in a field is ignored
+	// This is done even if the field delimiter (comma), is whitespace
+	trim_leading_space: bool,
+
+	// If lazy_quotes is true, a quote may appear in an unquoted field and a non-doubled quote may appear in a quoted field
+	lazy_quotes: bool,
+
+	// reuse_record controls whether calls to 'read' may return a slice using the backing buffer
+	// for performance
+	// By default, each call to 'read' returns a newly allocated slice
+	reuse_record: bool,
+
+	// reuse_record_buffer controls whether calls to 'read' clone the strings of each field or uses
+	// the data stored in record buffer for performance
+	// By default, each call to 'read' clones the strings of each field
+	reuse_record_buffer: bool,
+
+
+	// internal buffers
+	r:             bufio.Reader,
+	line_count:    int, // current line being read in the CSV file
+	raw_buffer:    [dynamic]byte,
+	record_buffer: [dynamic]byte,
+	field_indices: [dynamic]int,
+	last_record:   [dynamic]string,
+	sr: strings.Reader, // used by reader_init_with_string
+}
+
+
+Reader_Error_Kind :: enum {
+	Bare_Quote,
+	Quote,
+	Field_Count,
+	Invalid_Delim,
+}
+
+reader_error_kind_string := [Reader_Error_Kind]string{
+	.Bare_Quote     = "bare \" in non-quoted field",
+	.Quote          = "extra or missing \" in quoted field",
+	.Field_Count    = "wrong field count",
+	.Invalid_Delim  = "invalid delimiter",
+};
+
+Reader_Error :: struct {
+	kind:          Reader_Error_Kind,
+	start_line:    int,
+	line:          int,
+	column:        int,
+	expected, got: int, // used by .Field_Count
+}
+
+Error :: union {
+	Reader_Error,
+	io.Error,
+}
+
+DEFAULT_RECORD_BUFFER_CAPACITY :: 256;
+
+// reader_init initializes a new Reader from r
+reader_init :: proc(reader: ^Reader, r: io.Reader, buffer_allocator := context.allocator) {
+	reader.comma = ',';
+
+	context.allocator = buffer_allocator;
+	reserve(&reader.record_buffer, DEFAULT_RECORD_BUFFER_CAPACITY);
+	reserve(&reader.raw_buffer,    0);
+	reserve(&reader.field_indices, 0);
+	reserve(&reader.last_record,   0);
+	bufio.reader_init(&reader.r, r);
+}
+
+
+// reader_init_with_string initializes a new Reader from s
+reader_init_with_string :: proc(reader: ^Reader, s: string, buffer_allocator := context.allocator) {
+	strings.reader_init(&reader.sr, s);
+	r, _ := io.to_reader(strings.reader_to_stream(&reader.sr));
+	reader_init(reader, r, buffer_allocator);
+}
+
+// reader_destroy destroys a Reader
+reader_destroy :: proc(r: ^Reader) {
+	delete(r.raw_buffer);
+	delete(r.record_buffer);
+	delete(r.field_indices);
+	delete(r.last_record);
+	bufio.reader_destroy(&r.r);
+}
+
+// read reads a single record (a slice of fields) from r
+//
+// All \r\n sequences are normalized to \n, including multi-line field
+read :: proc(r: ^Reader, allocator := context.allocator) -> (record: []string, err: Error) {
+	if r.reuse_record {
+		record, err = _read_record(r, &r.last_record, allocator);
+		resize(&r.last_record, len(record));
+		copy(r.last_record[:], record);
+	} else {
+		record, err = _read_record(r, nil, allocator);
+	}
+	return;
+}
+
+// is_io_error checks where an Error is a specific io.Error kind
+is_io_error :: proc(err: Error, io_err: io.Error) -> bool {
+	if v, ok := err.(io.Error); ok {
+		return v == io_err;
+	}
+	return false;
+}
+
+
+// read_all reads all the remaining records from r.
+// Each record is a slice of fields.
+// read_all is defined to read until an EOF, and does not treat, and does not treat EOF as an error
+read_all :: proc(r: ^Reader, allocator := context.allocator) -> ([][]string, Error) {
+	context.allocator = allocator;
+	records: [dynamic][]string;
+	for {
+		record, rerr := _read_record(r, nil, allocator);
+		if is_io_error(rerr, .EOF) {
+			return records[:], nil;
+		}
+		if rerr != nil {
+			return nil, rerr;
+		}
+		append(&records, record);
+	}
+}
+
+// read reads a single record (a slice of fields) from the provided input.
+read_from_string :: proc(input: string, record_allocator := context.allocator, buffer_allocator := context.allocator) -> (record: []string, n: int, err: Error) {
+	ir: strings.Reader;
+	strings.reader_init(&ir, input);
+	input_reader, _ := io.to_reader(strings.reader_to_stream(&ir));
+
+	r: Reader;
+	reader_init(&r, input_reader, buffer_allocator);
+	defer reader_destroy(&r);
+	record, err = read(&r, record_allocator);
+	n = int(r.r.r);
+	return;
+}
+
+
+// read_all reads all the remaining records from the provided input.
+read_all_from_string :: proc(input: string, records_allocator := context.allocator, buffer_allocator := context.allocator) -> ([][]string, Error) {
+	ir: strings.Reader;
+	strings.reader_init(&ir, input);
+	input_reader, _ := io.to_reader(strings.reader_to_stream(&ir));
+
+	r: Reader;
+	reader_init(&r, input_reader, buffer_allocator);
+	defer reader_destroy(&r);
+	return read_all(&r, records_allocator);
+}
+
+@private
+is_valid_delim :: proc(r: rune) -> bool {
+	switch r {
+	case 0, '"', '\r', '\n', utf8.RUNE_ERROR:
+		return false;
+	}
+	return utf8.valid_rune(r);
+}
+
+@private
+_read_record :: proc(r: ^Reader, dst: ^[dynamic]string, allocator := context.allocator) -> ([]string, Error) {
+	read_line :: proc(r: ^Reader) -> ([]byte, io.Error) {
+		line, err := bufio.reader_read_slice(&r.r, '\n');
+		if err == .Buffer_Full {
+			clear(&r.raw_buffer);
+			append(&r.raw_buffer, ..line);
+			for err == .Buffer_Full {
+				line, err = bufio.reader_read_slice(&r.r, '\n');
+				append(&r.raw_buffer, ..line);
+			}
+			line = r.raw_buffer[:];
+		}
+		if len(line) > 0 && err == .EOF {
+			err = nil;
+			if line[len(line)-1] == '\r' {
+				line = line[:len(line)-1];
+			}
+		}
+		r.line_count += 1;
+
+		// normalize \r\n to \n
+		n := len(line);
+		for n >= 2 && string(line[n-2:]) == "\r\n" {
+			line[n-2] = '\n';
+			line = line[:n-1];
+		}
+
+		return line, err;
+	}
+
+	length_newline :: proc(b: []byte) -> int {
+		if len(b) > 0 && b[len(b)-1] == '\n' {
+			return 1;
+		}
+		return 0;
+	}
+
+	next_rune :: proc(b: []byte) -> rune {
+		r, _ := utf8.decode_rune(b);
+		return r;
+	}
+
+	if r.comma == r.comment ||
+	   !is_valid_delim(r.comma) ||
+	   (r.comment != 0 && !is_valid_delim(r.comment)) {
+		err := Reader_Error{
+			kind = .Invalid_Delim,
+			line = r.line_count,
+		};
+		return nil, err;
+	}
+
+	line, full_line: []byte;
+	err_read: io.Error;
+	for err_read == nil {
+		line, err_read = read_line(r);
+		if r.comment != 0 && next_rune(line) == r.comment {
+			line = nil;
+			continue;
+		}
+		if err_read == nil && len(line) == length_newline(line) {
+			line = nil;
+			continue;
+		}
+		full_line = line;
+		break;
+	}
+
+	if is_io_error(err_read, .EOF) {
+		return nil, err_read;
+	}
+
+	err: Error;
+	quote_len :: len(`"`);
+	comma_len := utf8.rune_size(r.comma);
+	record_line := r.line_count;
+	clear(&r.record_buffer);
+	clear(&r.field_indices);
+
+	parse_field: for {
+		if r.trim_leading_space {
+			line = bytes.trim_left_space(line);
+		}
+		if len(line) == 0 || line[0] != '"' {
+			i := bytes.index_rune(line, r.comma);
+			field := line;
+			if i >= 0 {
+				field = field[:i];
+			} else {
+				field = field[:len(field) - length_newline(field)];
+			}
+
+			if !r.lazy_quotes {
+				if j := bytes.index_byte(field, '"'); j >= 0 {
+					column := utf8.rune_count(full_line[:len(full_line) - len(line[j:])]);
+					err = Reader_Error{
+						kind = .Bare_Quote,
+						start_line = record_line,
+						line = r.line_count,
+						column = column,
+					};
+					break parse_field;
+				}
+			}
+			append(&r.record_buffer, ..field);
+			append(&r.field_indices, len(r.record_buffer));
+			if i >= 0 {
+				line = line[i+comma_len:];
+				continue parse_field;
+			}
+			break parse_field;
+
+		} else {
+			line = line[quote_len:];
+			for {
+				i := bytes.index_byte(line, '"');
+				switch {
+				case i >= 0:
+					append(&r.record_buffer, ..line[:i]);
+					line = line[i+quote_len:];
+					switch ch := next_rune(line); {
+					case ch == '"': // append quote
+						append(&r.record_buffer, '"');
+						line = line[quote_len:];
+					case ch == r.comma: // end of field
+						line = line[comma_len:];
+						append(&r.field_indices, len(r.record_buffer));
+						continue parse_field;
+					case length_newline(line) == len(line): // end of line
+						append(&r.field_indices, len(r.record_buffer));
+						break parse_field;
+					case r.lazy_quotes: // bare quote
+						append(&r.record_buffer, '"');
+					case: // invalid non-escaped quote
+						column := utf8.rune_count(full_line[:len(full_line) - len(line) - quote_len]);
+						err = Reader_Error{
+							kind = .Quote,
+							start_line = record_line,
+							line = r.line_count,
+							column = column,
+						};
+						break parse_field;
+					}
+
+				case len(line) > 0:
+					append(&r.record_buffer, ..line);
+					if err_read != nil {
+						break parse_field;
+					}
+					line, err_read = read_line(r);
+					if is_io_error(err_read, .EOF) {
+						err_read = nil;
+					}
+					full_line = line;
+
+				case:
+					if !r.lazy_quotes && err_read == nil {
+						column := utf8.rune_count(full_line);
+						err = Reader_Error{
+							kind = .Quote,
+							start_line = record_line,
+							line = r.line_count,
+							column = column,
+						};
+						break parse_field;
+					}
+					append(&r.field_indices, len(r.record_buffer));
+					break parse_field;
+				}
+			}
+		}
+	}
+
+	if err == nil && err_read != nil {
+		err = err_read;
+	}
+
+	context.allocator = allocator;
+	dst := dst;
+	str := string(r.record_buffer[:]);
+	if dst == nil {
+		// use local variable
+		dst = &([dynamic]string){};
+	}
+	clear(dst);
+	resize(dst, len(r.field_indices));
+	pre_idx: int;
+	for idx, i in r.field_indices {
+		field := str[pre_idx:idx];
+		if !r.reuse_record_buffer {
+			field = strings.clone(field);
+		}
+		dst[i] = field;
+		pre_idx = idx;
+	}
+
+	if r.fields_per_record > 0 {
+		if len(dst) != r.fields_per_record && err == nil {
+			err = Reader_Error{
+				kind = .Field_Count,
+				start_line = record_line,
+				line = r.line_count,
+				expected = r.fields_per_record,
+				got = len(dst),
+			};
+		}
+	} else if r.fields_per_record == 0 {
+		r.fields_per_record = len(dst);
+	}
+	return dst[:], err;
+
+}

core/encoding/csv/writer.odin

@@ -0,0 +1,147 @@
+package csv
+
+import "core:io"
+import "core:strings"
+import "core:unicode/utf8"
+
+// Writer is a data structure used for writing records using a CSV-encoding.
+Writer :: struct {
+	// Field delimiter (set to ',' with writer_init)
+	comma: rune,
+
+	// if set to true, \r\n will be used as the line terminator
+	use_crlf: bool,
+
+	w: io.Writer,
+}
+
+// writer_init initializes a Writer that writes to w
+writer_init :: proc(writer: ^Writer, w: io.Writer) {
+	writer.comma = ',';
+	writer.w = w;
+}
+
+// write writes a single CSV records to w with any of the necessarily quoting.
+// A record is a slice of strings, where each string is a single field.
+//
+// If the underlying io.Writer requires flushing, make sure to call io.flush
+write :: proc(w: ^Writer, record: []string) -> io.Error {
+	CHAR_SET :: "\n\r\"";
+
+	field_needs_quoting :: proc(w: ^Writer, field: string) -> bool {
+		switch {
+		case field == "": // No need to quote empty strings
+			return false;
+		case field == `\.`: // Postgres is weird
+			return true;
+		case w.comma < utf8.RUNE_SELF: // ASCII optimization
+			for i in 0..<len(field) {
+				switch field[i] {
+				case '\n', '\r', '"', byte(w.comma):
+					return true;
+				}
+			}
+		case:
+			if strings.contains_rune(field, w.comma) >= 0 {
+				return true;
+			}
+			if strings.contains_any(field, CHAR_SET) {
+				return true;
+			}
+		}
+
+		// Leading spaces need quoting
+		r, _ := utf8.decode_rune_in_string(field);
+		return strings.is_space(r);
+	}
+
+	if !is_valid_delim(w.comma) {
+		return .No_Progress; // TODO(bill): Is this a good error?
+	}
+
+	for _, field_idx in record {
+		// NOTE(bill): declared like this so that the field can be modified later if necessary
+		field := record[field_idx];
+
+		if field_idx > 0 {
+			if _, err := io.write_rune(w.w, w.comma); err != nil {
+				return err;
+			}
+		}
+
+		if !field_needs_quoting(w, field) {
+			if _, err := io.write_string(w.w, field); err != nil {
+				return err;
+			}
+			continue;
+		}
+
+		if err := io.write_byte(w.w, '"'); err != nil {
+			return err;
+		}
+
+		for len(field) > 0 {
+			i := strings.index_any(field, CHAR_SET);
+			if i < 0 {
+				i = len(field);
+			}
+
+			if _, err := io.write_string(w.w, field[:i]); err != nil {
+				return err;
+			}
+			field = field[i:];
+
+			if len(field) > 0 {
+				switch field[0] {
+				case '\r':
+					if !w.use_crlf {
+						if err := io.write_byte(w.w, '\r'); err != nil {
+							return err;
+						}
+					}
+				case '\n':
+					if w.use_crlf {
+						if _, err := io.write_string(w.w, "\r\n"); err != nil {
+							return err;
+						}
+					} else {
+						if err := io.write_byte(w.w, '\n'); err != nil {
+							return err;
+						}
+					}
+				case '"':
+					if _, err := io.write_string(w.w, `""`); err != nil {
+						return err;
+					}
+				}
+				field = field[1:];
+			}
+		}
+		if err := io.write_byte(w.w, '"'); err != nil {
+			return err;
+		}
+	}
+
+	if w.use_crlf {
+		_, err := io.write_string(w.w, "\r\n");
+		return err;
+	}
+	return io.write_byte(w.w, '\n');
+}
+
+// write_all writes multiple CSV records to w using write, and then flushes (if necessary).
+write_all :: proc(w: ^Writer, records: [][]string) -> io.Error {
+	for record in records {
+		err := write(w, record);
+		if err != nil {
+			return err;
+		}
+	}
+	return writer_flush(w);
+}
+
+// writer_flush flushes the underlying io.Writer.
+// If the underlying io.Writer does not support flush, nil is returned.
+writer_flush :: proc(w: ^Writer) -> io.Error {
+	return io.flush(auto_cast w.w);
+}

core/encoding/json/marshal.odin

@@ -0,0 +1,316 @@
+package json
+
+import "core:mem"
+import "core:math/bits"
+import "core:runtime"
+import "core:strconv"
+import "core:strings"
+
+Marshal_Error :: enum {
+	None,
+	Unsupported_Type,
+	Invalid_Data,
+}
+
+marshal :: proc(v: any, allocator := context.allocator) -> ([]byte, Marshal_Error) {
+	b: strings.Builder;
+	strings.init_builder(&b, allocator);
+
+	err := marshal_arg(&b, v);
+
+	if err != .None {
+		strings.destroy_builder(&b);
+		return nil, err;
+	}
+	if len(b.buf) == 0 {
+		strings.destroy_builder(&b);
+		return nil, err;
+	}
+	return b.buf[:], err;
+}
+
+
+marshal_arg :: proc(b: ^strings.Builder, v: any) -> Marshal_Error {
+	using strings;
+	using runtime;
+	if v == nil {
+		write_string(b, "null");
+		return .None;
+	}
+
+	ti := type_info_base(type_info_of(v.id));
+	a := any{v.data, ti.id};
+
+	switch info in ti.variant {
+	case Type_Info_Named:
+		unreachable();
+
+	case Type_Info_Integer:
+		buf: [21]byte;
+		u: u64;
+		switch i in a {
+		case i8:      u = u64(i);
+		case i16:     u = u64(i);
+		case i32:     u = u64(i);
+		case i64:     u = u64(i);
+		case int:     u = u64(i);
+		case u8:      u = u64(i);
+		case u16:     u = u64(i);
+		case u32:     u = u64(i);
+		case u64:     u = u64(i);
+		case uint:    u = u64(i);
+		case uintptr: u = u64(i);
+
+		case i16le: u = u64(i);
+		case i32le: u = u64(i);
+		case i64le: u = u64(i);
+		case u16le: u = u64(i);
+		case u32le: u = u64(i);
+		case u64le: u = u64(i);
+
+		case i16be: u = u64(i);
+		case i32be: u = u64(i);
+		case i64be: u = u64(i);
+		case u16be: u = u64(i);
+		case u32be: u = u64(i);
+		case u64be: u = u64(i);
+		}
+
+		s := strconv.append_bits(buf[:], u, 10, info.signed, 8*ti.size, "0123456789", nil);
+		write_string(b, s);
+
+
+	case Type_Info_Rune:
+		r := a.(rune);
+		write_byte(b, '"');
+		write_escaped_rune(b, r, '"', true);
+		write_byte(b, '"');
+
+	case Type_Info_Float:
+		val: f64;
+		switch f in a {
+		case f16: val = f64(f);
+		case f32: val = f64(f);
+		case f64: val = f64(f);
+		}
+
+		buf: [386]byte;
+
+		str := strconv.append_float(buf[1:], val, 'f', 2*ti.size, 8*ti.size);
+		s := buf[:len(str)+1];
+		if s[1] == '+' || s[1] == '-' {
+			s = s[1:];
+		} else {
+			s[0] = '+';
+		}
+		if s[0] == '+' {
+			s = s[1:];
+		}
+
+		write_string(b, string(s));
+
+	case Type_Info_Complex:
+		return .Unsupported_Type;
+
+	case Type_Info_Quaternion:
+		return .Unsupported_Type;
+
+	case Type_Info_String:
+		switch s in a {
+		case string:  write_quoted_string(b, s);
+		case cstring: write_quoted_string(b, string(s));
+		}
+
+	case Type_Info_Boolean:
+		val: bool;
+		switch b in a {
+		case bool: val = bool(b);
+		case b8:   val = bool(b);
+		case b16:  val = bool(b);
+		case b32:  val = bool(b);
+		case b64:  val = bool(b);
+		}
+		write_string_builder(b, val ? "true" : "false");
+
+	case Type_Info_Any:
+		return .Unsupported_Type;
+
+	case Type_Info_Type_Id:
+		return .Unsupported_Type;
+
+	case Type_Info_Pointer:
+		return .Unsupported_Type;
+
+	case Type_Info_Procedure:
+		return .Unsupported_Type;
+
+	case Type_Info_Tuple:
+		return .Unsupported_Type;
+
+	case Type_Info_Enumerated_Array:
+		return .Unsupported_Type;
+
+	case Type_Info_Simd_Vector:
+		return .Unsupported_Type;
+
+	case Type_Info_Relative_Pointer:
+		return .Unsupported_Type;
+
+	case Type_Info_Relative_Slice:
+		return .Unsupported_Type;
+
+	case Type_Info_Array:
+		write_byte(b, '[');
+		for i in 0..<info.count {
+			if i > 0 { write_string(b, ", "); }
+
+			data := uintptr(v.data) + uintptr(i*info.elem_size);
+			marshal_arg(b, any{rawptr(data), info.elem.id});
+		}
+		write_byte(b, ']');
+
+	case Type_Info_Dynamic_Array:
+		write_byte(b, '[');
+		array := cast(^mem.Raw_Dynamic_Array)v.data;
+		for i in 0..<array.len {
+			if i > 0 { write_string(b, ", "); }
+
+			data := uintptr(array.data) + uintptr(i*info.elem_size);
+			marshal_arg(b, any{rawptr(data), info.elem.id});
+		}
+		write_byte(b, ']');
+
+	case Type_Info_Slice:
+		write_byte(b, '[');
+		slice := cast(^mem.Raw_Slice)v.data;
+		for i in 0..<slice.len {
+			if i > 0 { write_string(b, ", "); }
+
+			data := uintptr(slice.data) + uintptr(i*info.elem_size);
+			marshal_arg(b, any{rawptr(data), info.elem.id});
+		}
+		write_byte(b, ']');
+
+	case Type_Info_Map:
+		m := (^mem.Raw_Map)(v.data);
+
+		write_byte(b, '{');
+		if m != nil {
+			if info.generated_struct == nil {
+				return .Unsupported_Type;
+			}
+			entries    := &m.entries;
+			gs         := type_info_base(info.generated_struct).variant.(Type_Info_Struct);
+			ed         := type_info_base(gs.types[1]).variant.(Type_Info_Dynamic_Array);
+			entry_type := ed.elem.variant.(Type_Info_Struct);
+			entry_size := ed.elem_size;
+
+			for i in 0..<entries.len {
+				if i > 0 { write_string(b, ", "); }
+
+				data := uintptr(entries.data) + uintptr(i*entry_size);
+				key   := rawptr(data + entry_type.offsets[2]);
+				value := rawptr(data + entry_type.offsets[3]);
+
+				marshal_arg(b, any{key, info.key.id});
+				write_string(b, ": ");
+				marshal_arg(b, any{value, info.value.id});
+			}
+		}
+		write_byte(b, '}');
+
+	case Type_Info_Struct:
+		write_byte(b, '{');
+		for name, i in info.names {
+			if i > 0 { write_string(b, ", "); }
+			write_quoted_string(b, name);
+			write_string(b, ": ");
+
+			id := info.types[i].id;
+			data := rawptr(uintptr(v.data) + info.offsets[i]);
+			marshal_arg(b, any{data, id});
+		}
+		write_byte(b, '}');
+
+	case Type_Info_Union:
+		tag_ptr := uintptr(v.data) + info.tag_offset;
+		tag_any := any{rawptr(tag_ptr), info.tag_type.id};
+
+		tag: i64 = -1;
+		switch i in tag_any {
+		case u8:   tag = i64(i);
+		case i8:   tag = i64(i);
+		case u16:  tag = i64(i);
+		case i16:  tag = i64(i);
+		case u32:  tag = i64(i);
+		case i32:  tag = i64(i);
+		case u64:  tag = i64(i);
+		case i64:  tag = i64(i);
+		case: panic("Invalid union tag type");
+		}
+
+		if v.data == nil || tag == 0 {
+			write_string(b, "null");
+		} else {
+			id := info.variants[tag-1].id;
+			marshal_arg(b, any{v.data, id});
+		}
+
+	case Type_Info_Enum:
+		return marshal_arg(b, any{v.data, info.base.id});
+
+	case Type_Info_Bit_Set:
+		is_bit_set_different_endian_to_platform :: proc(ti: ^runtime.Type_Info) -> bool {
+			if ti == nil {
+				return false;
+			}
+			t := runtime.type_info_base(ti);
+			#partial switch info in t.variant {
+			case runtime.Type_Info_Integer:
+				switch info.endianness {
+				case .Platform: return false;
+				case .Little:   return ODIN_ENDIAN != "little";
+				case .Big:      return ODIN_ENDIAN != "big";
+				}
+			}
+			return false;
+		}
+
+		bit_data: u64;
+		bit_size := u64(8*ti.size);
+
+		do_byte_swap := is_bit_set_different_endian_to_platform(info.underlying);
+
+		switch bit_size {
+		case  0: bit_data = 0;
+		case  8:
+			x := (^u8)(v.data)^;
+			bit_data = u64(x);
+		case 16:
+			x := (^u16)(v.data)^;
+			if do_byte_swap {
+				x = bits.byte_swap(x);
+			}
+			bit_data = u64(x);
+		case 32:
+			x := (^u32)(v.data)^;
+			if do_byte_swap {
+				x = bits.byte_swap(x);
+			}
+			bit_data = u64(x);
+		case 64:
+			x := (^u64)(v.data)^;
+			if do_byte_swap {
+				x = bits.byte_swap(x);
+			}
+			bit_data = u64(x);
+		case: panic("unknown bit_size size");
+		}
+		write_u64(b, bit_data);
+
+
+		return .Unsupported_Type;
+	}
+
+	return .None;
+}

core/encoding/json/parser.odin

@@ -0,0 +1,459 @@
+package json
+
+import "core:mem"
+import "core:unicode/utf8"
+import "core:strconv"
+
+Parser :: struct {
+	tok:            Tokenizer,
+	prev_token:     Token,
+	curr_token:     Token,
+	spec:           Specification,
+	allocator:      mem.Allocator,
+	unmarshal_data: any,
+	parse_integers: bool,
+}
+
+make_parser :: proc(data: []byte, spec := Specification.JSON, parse_integers := false, allocator := context.allocator) -> Parser {
+	p: Parser;
+	p.tok = make_tokenizer(data, spec, parse_integers);
+	p.spec = spec;
+	p.allocator = allocator;
+	assert(p.allocator.procedure != nil);
+	advance_token(&p);
+	return p;
+}
+
+parse :: proc(data: []byte, spec := Specification.JSON, parse_integers := false, allocator := context.allocator) -> (Value, Error) {
+	context.allocator = allocator;
+	p := make_parser(data, spec, parse_integers, allocator);
+
+	if p.spec == Specification.JSON5 {
+		return parse_value(&p);
+	}
+	return parse_object(&p);
+}
+
+token_end_pos :: proc(tok: Token) -> Pos {
+	end := tok.pos;
+	end.offset += len(tok.text);
+	return end;
+}
+
+advance_token :: proc(p: ^Parser) -> (Token, Error) {
+	err: Error;
+	p.prev_token = p.curr_token;
+	p.curr_token, err = get_token(&p.tok);
+	return p.prev_token, err;
+}
+
+
+allow_token :: proc(p: ^Parser, kind: Token_Kind) -> bool {
+	if p.curr_token.kind == kind {
+		advance_token(p);
+		return true;
+	}
+	return false;
+}
+
+expect_token :: proc(p: ^Parser, kind: Token_Kind) -> Error {
+	prev := p.curr_token;
+	advance_token(p);
+	if prev.kind == kind {
+		return .None;
+	}
+	return .Unexpected_Token;
+}
+
+
+
+parse_value :: proc(p: ^Parser) -> (value: Value, err: Error) {
+	value.pos = p.curr_token.pos;
+	defer value.end = token_end_pos(p.prev_token);
+
+	token := p.curr_token;
+	#partial switch token.kind {
+	case .Null:
+		value.value = Null{};
+		advance_token(p);
+		return;
+	case .False:
+		value.value = Boolean(false);
+		advance_token(p);
+		return;
+	case .True:
+		value.value = Boolean(true);
+		advance_token(p);
+		return;
+
+	case .Integer:
+		i, _ := strconv.parse_i64(token.text);
+		value.value = Integer(i);
+		advance_token(p);
+		return;
+	case .Float:
+		f, _ := strconv.parse_f64(token.text);
+		value.value = Float(f);
+		advance_token(p);
+		return;
+	case .String:
+		value.value = String(unquote_string(token, p.spec, p.allocator));
+		advance_token(p);
+		return;
+
+	case .Open_Brace:
+		return parse_object(p);
+
+	case .Open_Bracket:
+		return parse_array(p);
+
+	case:
+		if p.spec == Specification.JSON5 {
+			#partial switch token.kind {
+			case .Infinity:
+				inf: u64 = 0x7ff0000000000000;
+				if token.text[0] == '-' {
+					inf = 0xfff0000000000000;
+				}
+				value.value = transmute(f64)inf;
+				advance_token(p);
+				return;
+			case .NaN:
+				nan: u64 = 0x7ff7ffffffffffff;
+				if token.text[0] == '-' {
+					nan = 0xfff7ffffffffffff;
+				}
+				value.value = transmute(f64)nan;
+				advance_token(p);
+				return;
+			}
+		}
+	}
+
+	err = .Unexpected_Token;
+	advance_token(p);
+	return;
+}
+
+parse_array :: proc(p: ^Parser) -> (value: Value, err: Error) {
+	value.pos = p.curr_token.pos;
+	defer value.end = token_end_pos(p.prev_token);
+	if err = expect_token(p, .Open_Bracket); err != .None {
+		return;
+	}
+
+	array: Array;
+	array.allocator = p.allocator;
+	defer if err != .None {
+		for elem in array {
+			destroy_value(elem);
+		}
+		delete(array);
+	}
+
+	for p.curr_token.kind != .Close_Bracket {
+		elem, elem_err := parse_value(p);
+		if elem_err != .None {
+			err = elem_err;
+			return;
+		}
+		append(&array, elem);
+
+		// Disallow trailing commas for the time being
+		if allow_token(p, .Comma) {
+			continue;
+		} else {
+			break;
+		}
+	}
+
+	if err = expect_token(p, .Close_Bracket); err != .None {
+		return;
+	}
+
+	value.value = array;
+	return;
+}
+
+clone_string :: proc(s: string, allocator: mem.Allocator) -> string {
+	n := len(s);
+	b := make([]byte, n+1, allocator);
+	copy(b, s);
+	b[n] = 0;
+	return string(b[:n]);
+}
+
+parse_object_key :: proc(p: ^Parser) -> (key: string, err: Error) {
+	tok := p.curr_token;
+	if p.spec == Specification.JSON5 {
+		if tok.kind == .String {
+			expect_token(p, .String);
+			key = unquote_string(tok, p.spec, p.allocator);
+			return;
+		} else if tok.kind == .Ident {
+			expect_token(p, .Ident);
+			key = clone_string(tok.text, p.allocator);
+			return;
+		}
+	}
+	if tok_err := expect_token(p, .String); tok_err != .None {
+		err = .Expected_String_For_Object_Key;
+		return;
+	}
+	key = unquote_string(tok, p.spec, p.allocator);
+	return;
+}
+
+parse_object :: proc(p: ^Parser) -> (value: Value, err: Error) {
+	value.pos = p.curr_token.pos;
+	defer value.end = token_end_pos(p.prev_token);
+
+	if err = expect_token(p, .Open_Brace); err != .None {
+		value.pos = p.curr_token.pos;
+		return;
+	}
+
+	obj: Object;
+	obj.allocator = p.allocator;
+	defer if err != .None {
+		for key, elem in obj {
+			delete(key, p.allocator);
+			destroy_value(elem);
+		}
+		delete(obj);
+	}
+
+	for p.curr_token.kind != .Close_Brace {
+		key: string;
+		key, err = parse_object_key(p);
+		if err != .None {
+			delete(key, p.allocator);
+			value.pos = p.curr_token.pos;
+			return;
+		}
+
+		if colon_err := expect_token(p, .Colon); colon_err != .None {
+			err = .Expected_Colon_After_Key;
+			value.pos = p.curr_token.pos;
+			return;
+		}
+
+		elem, elem_err := parse_value(p);
+		if elem_err != .None {
+			err = elem_err;
+			value.pos = p.curr_token.pos;
+			return;
+		}
+
+		if key in obj {
+			err = .Duplicate_Object_Key;
+			value.pos = p.curr_token.pos;
+			delete(key, p.allocator);
+			return;
+		}
+
+		obj[key] = elem;
+
+		if p.spec == Specification.JSON5 {
+			// Allow trailing commas
+			if allow_token(p, .Comma) {
+				continue;
+			}
+		} else {
+			// Disallow trailing commas
+			if allow_token(p, .Comma) {
+				continue;
+			} else {
+				break;
+			}
+		}
+	}
+
+	if err = expect_token(p, .Close_Brace); err != .None {
+		value.pos = p.curr_token.pos;
+		return;
+	}
+
+	value.value = obj;
+	return;
+}
+
+
+// IMPORTANT NOTE(bill): unquote_string assumes a mostly valid string
+unquote_string :: proc(token: Token, spec: Specification, allocator := context.allocator) -> string {
+	get_u2_rune :: proc(s: string) -> rune {
+		if len(s) < 4 || s[0] != '\\' || s[1] != 'x' {
+			return -1;
+		}
+
+		r: rune;
+		for c in s[2:4] {
+			x: rune;
+			switch c {
+			case '0'..'9': x = c - '0';
+			case 'a'..'f': x = c - 'a' + 10;
+			case 'A'..'F': x = c - 'A' + 10;
+			case: return -1;
+			}
+			r = r*16 + x;
+		}
+		return r;
+	}
+	get_u4_rune :: proc(s: string) -> rune {
+		if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
+			return -1;
+		}
+
+		r: rune;
+		for c in s[2:6] {
+			x: rune;
+			switch c {
+			case '0'..'9': x = c - '0';
+			case 'a'..'f': x = c - 'a' + 10;
+			case 'A'..'F': x = c - 'A' + 10;
+			case: return -1;
+			}
+			r = r*16 + x;
+		}
+		return r;
+	}
+
+	if token.kind != .String {
+		return "";
+	}
+	s := token.text;
+	if len(s) <= 2 {
+		return "";
+	}
+	quote := s[0];
+	if s[0] != s[len(s)-1] {
+		// Invalid string
+		return "";
+	}
+	s = s[1:len(s)-1];
+
+	i := 0;
+	for i < len(s) {
+		c := s[i];
+		if c == '\\' || c == quote || c < ' ' {
+			break;
+		}
+		if c < utf8.RUNE_SELF {
+			i += 1;
+			continue;
+		}
+		r, w := utf8.decode_rune_in_string(s);
+		if r == utf8.RUNE_ERROR && w == 1 {
+			break;
+		}
+		i += w;
+	}
+	if i == len(s) {
+		return clone_string(s, allocator);
+	}
+
+	b := make([]byte, len(s) + 2*utf8.UTF_MAX, allocator);
+	w := copy(b, s[0:i]);
+	loop: for i < len(s) {
+		c := s[i];
+		switch {
+		case c == '\\':
+			i += 1;
+			if i >= len(s) {
+				break loop;
+			}
+			switch s[i] {
+			case: break loop;
+			case '"',  '\'', '\\', '/':
+				b[w] = s[i];
+				i += 1;
+				w += 1;
+
+			case 'b':
+				b[w] = '\b';
+				i += 1;
+				w += 1;
+			case 'f':
+				b[w] = '\f';
+				i += 1;
+				w += 1;
+			case 'r':
+				b[w] = '\r';
+				i += 1;
+				w += 1;
+			case 't':
+				b[w] = '\t';
+				i += 1;
+				w += 1;
+			case 'n':
+				b[w] = '\n';
+				i += 1;
+				w += 1;
+			case 'u':
+				i -= 1; // Include the \u in the check for sanity sake
+				r := get_u4_rune(s[i:]);
+				if r < 0 {
+					break loop;
+				}
+				i += 6;
+
+				buf, buf_width := utf8.encode_rune(r);
+				copy(b[w:], buf[:buf_width]);
+				w += buf_width;
+
+
+			case '0':
+				if spec == Specification.JSON5 {
+					b[w] = '\x00';
+					i += 1;
+					w += 1;
+				} else {
+					break loop;
+				}
+			case 'v':
+				if spec == Specification.JSON5 {
+					b[w] = '\v';
+					i += 1;
+					w += 1;
+				} else {
+					break loop;
+				}
+
+			case 'x':
+				if spec == Specification.JSON5 {
+					i -= 1; // Include the \x in the check for sanity sake
+					r := get_u2_rune(s[i:]);
+					if r < 0 {
+						break loop;
+					}
+					i += 4;
+
+					buf, buf_width := utf8.encode_rune(r);
+					copy(b[w:], buf[:buf_width]);
+					w += buf_width;
+				} else {
+					break loop;
+				}
+			}
+
+		case c == quote, c < ' ':
+			break loop;
+
+		case c < utf8.RUNE_SELF:
+			b[w] = c;
+			i += 1;
+			w += 1;
+
+		case:
+			r, width := utf8.decode_rune_in_string(s[i:]);
+			i += width;
+
+			buf, buf_width := utf8.encode_rune(r);
+			assert(buf_width <= width);
+			copy(b[w:], buf[:buf_width]);
+			w += buf_width;
+		}
+	}
+
+	return string(b[:w]);
+}

core/encoding/json/tokenizer.odin

@@ -0,0 +1,484 @@
+package json
+
+import "core:unicode/utf8"
+
+Token :: struct {
+	using pos: Pos,
+	kind: Token_Kind,
+	text: string,
+}
+
+Token_Kind :: enum {
+	Invalid,
+	EOF,
+
+	Null,
+	False,
+	True,
+
+	Infinity,
+	NaN,
+
+	Ident,
+
+	Integer,
+	Float,
+	String,
+
+	Colon,
+	Comma,
+
+	Open_Brace,
+	Close_Brace,
+
+	Open_Bracket,
+	Close_Bracket,
+}
+
+Tokenizer :: struct {
+	using pos:        Pos,
+	data:             []byte,
+	r:                rune, // current rune
+	w:                int,  // current rune width in bytes
+	curr_line_offset: int,
+	spec:             Specification,
+	parse_integers:   bool,
+}
+
+
+
+make_tokenizer :: proc(data: []byte, spec := Specification.JSON, parse_integers := false) -> Tokenizer {
+	t := Tokenizer{pos = {line=1}, data = data, spec = spec, parse_integers = parse_integers};
+	next_rune(&t);
+	if t.r == utf8.RUNE_BOM {
+		next_rune(&t);
+	}
+	return t;
+}
+
+next_rune :: proc(t: ^Tokenizer) -> rune #no_bounds_check {
+	if t.offset >= len(t.data) {
+		return utf8.RUNE_EOF;
+	}
+	t.offset += t.w;
+	t.r, t.w = utf8.decode_rune(t.data[t.offset:]);
+	t.pos.column = t.offset - t.curr_line_offset;
+	return t.r;
+}
+
+
+get_token :: proc(t: ^Tokenizer) -> (token: Token, err: Error) {
+	skip_digits :: proc(t: ^Tokenizer) {
+		for t.offset < len(t.data) {
+			if '0' <= t.r && t.r <= '9' {
+				// Okay
+			} else {
+				return;
+			}
+			next_rune(t);
+		}
+	}
+	skip_hex_digits :: proc(t: ^Tokenizer) {
+		for t.offset < len(t.data) {
+			next_rune(t);
+			switch t.r {
+			case '0'..'9', 'a'..'f', 'A'..'F':
+				// Okay
+			case:
+				return;
+			}
+		}
+	}
+
+	scan_espace :: proc(t: ^Tokenizer) -> bool {
+		switch t.r {
+		case '"', '\'', '\\', '/', 'b', 'n', 'r', 't', 'f':
+			next_rune(t);
+			return true;
+		case 'u':
+			// Expect 4 hexadecimal digits
+			for i := 0; i < 4; i += 1 {
+				r := next_rune(t);
+				switch r {
+				case '0'..'9', 'a'..'f', 'A'..'F':
+					// Okay
+				case:
+					return false;
+				}
+			}
+		case:
+			// Ignore the next rune regardless
+			next_rune(t);
+		}
+		return false;
+	}
+
+	skip_whitespace :: proc(t: ^Tokenizer) -> rune {
+		loop: for t.offset < len(t.data) {
+			switch t.r {
+			case ' ', '\t', '\v', '\f', '\r':
+				next_rune(t);
+			case '\n':
+				t.line += 1;
+				t.curr_line_offset = t.offset;
+				t.pos.column = 1;
+				next_rune(t);
+			case:
+				if t.spec == .JSON5 {
+					switch t.r {
+					case 0x2028, 0x2029, 0xFEFF:
+						next_rune(t);
+						continue loop;
+					}
+				}
+				break loop;
+			}
+		}
+		return t.r;
+	}
+
+	skip_to_next_line :: proc(t: ^Tokenizer) {
+		for t.offset < len(t.data) {
+			r := next_rune(t);
+			if r == '\n' {
+				return;
+			}
+		}
+	}
+
+	skip_alphanum :: proc(t: ^Tokenizer) {
+		for t.offset < len(t.data) {
+			switch next_rune(t) {
+			case 'A'..'Z', 'a'..'z', '0'..'9', '_':
+				continue;
+			}
+
+			return;
+		}
+	}
+
+	skip_whitespace(t);
+
+	token.pos = t.pos;
+
+	token.kind = .Invalid;
+
+	curr_rune := t.r;
+	next_rune(t);
+
+	block: switch curr_rune {
+	case utf8.RUNE_ERROR:
+		err = .Illegal_Character;
+	case utf8.RUNE_EOF, '\x00':
+		token.kind = .EOF;
+		err = .EOF;
+
+	case 'A'..'Z', 'a'..'z', '_':
+		token.kind = .Ident;
+
+		skip_alphanum(t);
+
+		switch str := string(t.data[token.offset:t.offset]); str {
+		case "null":  token.kind = .Null;
+		case "false": token.kind = .False;
+		case "true":  token.kind = .True;
+		case:
+			if t.spec == .JSON5 {
+				switch str {
+				case "Infinity": token.kind = .Infinity;
+				case "NaN":      token.kind = .NaN;
+				}
+			}
+		}
+
+	case '+':
+		err = .Illegal_Character;
+		if t.spec != .JSON5 {
+			break;
+		}
+		fallthrough;
+
+	case '-':
+		switch t.r {
+		case '0'..'9':
+			// Okay
+		case:
+			// Illegal use of +/-
+			err = .Illegal_Character;
+
+			if t.spec == .JSON5 {
+				if t.r == 'I' || t.r == 'N' {
+					skip_alphanum(t);
+				}
+				switch string(t.data[token.offset:t.offset]) {
+				case "-Infinity": token.kind = .Infinity;
+				case "-NaN":      token.kind = .NaN;
+				}
+			}
+			break block;
+		}
+		fallthrough;
+
+	case '0'..'9':
+		token.kind = t.parse_integers ? .Integer : .Float;
+		if t.spec == .JSON5 { // Hexadecimal Numbers
+			if curr_rune == '0' && (t.r == 'x' || t.r == 'X') {
+				next_rune(t);
+				skip_hex_digits(t);
+				break;
+			}
+		}
+
+		skip_digits(t);
+
+		if t.r == '.' {
+			token.kind = .Float;
+			next_rune(t);
+			skip_digits(t);
+		}
+		if t.r == 'e' || t.r == 'E' {
+			switch r := next_rune(t); r {
+			case '+', '-':
+				next_rune(t);
+			}
+			skip_digits(t);
+		}
+
+		str := string(t.data[token.offset:t.offset]);
+		if !is_valid_number(str, t.spec) {
+			err = .Invalid_Number;
+		}
+
+	case '.':
+		err = .Illegal_Character;
+		if t.spec == .JSON5 { // Allow leading decimal point
+			skip_digits(t);
+			if t.r == 'e' || t.r == 'E' {
+				switch r := next_rune(t); r {
+				case '+', '-':
+					next_rune(t);
+				}
+				skip_digits(t);
+			}
+			str := string(t.data[token.offset:t.offset]);
+			if !is_valid_number(str, t.spec) {
+				err = .Invalid_Number;
+			}
+		}
+
+
+	case '\'':
+		err = .Illegal_Character;
+		if t.spec != .JSON5 {
+			break;
+		}
+		fallthrough;
+	case '"':
+		token.kind = .String;
+		quote := curr_rune;
+		for t.offset < len(t.data) {
+			r := t.r;
+			if r == '\n' || r < 0 {
+				err = .String_Not_Terminated;
+				break;
+			}
+			next_rune(t);
+			if r == quote {
+				break;
+			}
+			if r == '\\' {
+				scan_espace(t);
+			}
+		}
+
+		str := string(t.data[token.offset : t.offset]);
+		if !is_valid_string_literal(str, t.spec) {
+			err = .Invalid_String;
+		}
+
+
+	case ',': token.kind = .Comma;
+	case ':': token.kind = .Colon;
+	case '{': token.kind = .Open_Brace;
+	case '}': token.kind = .Close_Brace;
+	case '[': token.kind = .Open_Bracket;
+	case ']': token.kind = .Close_Bracket;
+
+	case '/':
+		err = .Illegal_Character;
+		if t.spec == .JSON5 {
+			switch t.r {
+			case '/':
+				// Single-line comments
+				skip_to_next_line(t);
+				return get_token(t);
+			case '*':
+				// None-nested multi-line comments
+				for t.offset < len(t.data) {
+					next_rune(t);
+					if t.r == '*' {
+						next_rune(t);
+						if t.r == '/' {
+							next_rune(t);
+							return get_token(t);
+						}
+					}
+				}
+				err = .EOF;
+			}
+		}
+
+	case: err = .Illegal_Character;
+	}
+
+	token.text = string(t.data[token.offset : t.offset]);
+
+	return;
+}
+
+
+
+is_valid_number :: proc(str: string, spec: Specification) -> bool {
+	s := str;
+	if s == "" {
+		return false;
+	}
+
+	if s[0] == '-' {
+		s = s[1:];
+		if s == "" {
+			return false;
+		}
+	} else if spec == .JSON5 {
+		if s[0] == '+' { // Allow positive sign
+			s = s[1:];
+			if s == "" {
+				return false;
+			}
+		}
+	}
+
+	switch s[0] {
+	case '0':
+		s = s[1:];
+	case '1'..'9':
+		s = s[1:];
+		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
+			s = s[1:];
+		}
+	case '.':
+		if spec == .JSON5 { // Allow leading decimal point
+			s = s[1:];
+		} else {
+			return false;
+		}
+	case:
+		return false;
+	}
+
+	if spec == .JSON5 {
+		if len(s) == 1 && s[0] == '.' { // Allow trailing decimal point
+			return true;
+		}
+	}
+
+	if len(s) >= 2 && s[0] == '.' && '0' <= s[1] && s[1] <= '9' {
+		s = s[2:];
+		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
+			s = s[1:];
+		}
+	}
+
+	if len(s) >= 2 && (s[0] == 'e' || s[0] == 'E') {
+		s = s[1:];
+		switch s[0] {
+		case '+', '-':
+			s = s[1:];
+			if s == "" {
+				return false;
+			}
+		}
+		for len(s) > 0 && '0' <= s[0] && s[0] <= '9' {
+			s = s[1:];
+		}
+	}
+
+	// The string should be empty now to be valid
+	return s == "";
+}
+
+is_valid_string_literal :: proc(str: string, spec: Specification) -> bool {
+	s := str;
+	if len(s) < 2 {
+		return false;
+	}
+	quote := s[0];
+	if s[0] != s[len(s)-1] {
+		return false;
+	}
+	if s[0] != '"' || s[len(s)-1] != '"' {
+		if spec == .JSON5 {
+			if s[0] != '\'' || s[len(s)-1] != '\'' {
+				return false;
+			}
+		} else {
+			return false;
+		}
+	}
+	s = s[1 : len(s)-1];
+
+	i := 0;
+	for i < len(s) {
+		c := s[i];
+		switch {
+		case c == '\\':
+			i += 1;
+			if i >= len(s) {
+				return false;
+			}
+			switch s[i] {
+			case '"', '\'', '\\', '/', 'b', 'n', 'r', 't', 'f':
+				i += 1;
+			case 'u':
+				if i >= len(s) {
+					return false;
+				}
+				hex := s[i+1:];
+				if len(hex) < 4 {
+					return false;
+				}
+				hex = hex[:4];
+				i += 5;
+
+				for j := 0; j < 4; j += 1 {
+					c2 := hex[j];
+					switch c2 {
+					case '0'..'9', 'a'..'z', 'A'..'Z':
+						// Okay
+					case:
+						return false;
+					}
+				}
+
+			case: return false;
+			}
+
+		case c == quote, c < ' ':
+			return false;
+
+		case c < utf8.RUNE_SELF:
+			i += 1;
+
+		case:
+			r, width := utf8.decode_rune_in_string(s[i:]);
+			if r == utf8.RUNE_ERROR && width == 1 {
+				return false;
+			}
+			i += width;
+		}
+	}
+	if i == len(s) {
+		return true;
+	}
+	return true;
+}

core/encoding/json/types.odin

@@ -0,0 +1,76 @@
+package json
+
+Specification :: enum {
+	JSON,
+	JSON5, // https://json5.org/
+	// MJSON, // http://bitsquid.blogspot.com/2009/09/json-configuration-data.html
+}
+
+Null    :: distinct rawptr;
+Integer :: i64;
+Float   :: f64;
+Boolean :: bool;
+String  :: string;
+Array   :: distinct [dynamic]Value;
+Object  :: distinct map[string]Value;
+
+Value :: struct {
+	pos, end: Pos,
+	value: union {
+		Null,
+		Integer,
+		Float,
+		Boolean,
+		String,
+		Array,
+		Object,
+	},
+}
+
+Pos :: struct {
+	offset: int,
+	line:   int,
+	column: int,
+}
+
+
+Error :: enum {
+	None,
+
+	EOF, // Not necessarily an error
+
+	// Tokenizing Errors
+	Illegal_Character,
+	Invalid_Number,
+	String_Not_Terminated,
+	Invalid_String,
+
+
+	// Parsing Errors
+	Unexpected_Token,
+	Expected_String_For_Object_Key,
+	Duplicate_Object_Key,
+	Expected_Colon_After_Key,
+}
+
+
+
+
+destroy_value :: proc(value: Value) {
+	#partial switch v in value.value {
+	case Object:
+		for key, elem in v {
+			delete(key);
+			destroy_value(elem);
+		}
+		delete(v);
+	case Array:
+		for elem in v {
+			destroy_value(elem);
+		}
+		delete(v);
+	case String:
+		delete(v);
+	}
+}
+

core/encoding/json/validator.odin

@@ -0,0 +1,122 @@
+package json
+
+import "core:mem"
+
+// NOTE(bill): is_valid will not check for duplicate keys
+is_valid :: proc(data: []byte, spec := Specification.JSON, parse_integers := false) -> bool {
+	p := make_parser(data, spec, parse_integers, mem.nil_allocator());
+	if p.spec == Specification.JSON5 {
+		return validate_value(&p);
+	}
+	return validate_object(&p);
+}
+
+validate_object_key :: proc(p: ^Parser) -> bool {
+	tok := p.curr_token;
+	if p.spec == Specification.JSON5 {
+		if tok.kind == .String {
+			expect_token(p, .String);
+			return true;
+		} else if tok.kind == .Ident {
+			expect_token(p, .Ident);
+			return true;
+		}
+	}
+	err := expect_token(p, .String);
+	return err == Error.None;
+}
+validate_object :: proc(p: ^Parser) -> bool {
+	if err := expect_token(p, .Open_Brace); err != Error.None {
+		return false;
+	}
+
+	for p.curr_token.kind != .Close_Brace {
+		if !validate_object_key(p) {
+			return false;
+		}
+		if colon_err := expect_token(p, .Colon); colon_err != Error.None {
+			return false;
+		}
+
+		if !validate_value(p) {
+			return false;
+		}
+
+		if p.spec == Specification.JSON5 {
+			// Allow trailing commas
+			if allow_token(p, .Comma) {
+				continue;
+			}
+		} else {
+			// Disallow trailing commas
+			if allow_token(p, .Comma) {
+				continue;
+			} else {
+				break;
+			}
+		}
+	}
+
+	if err := expect_token(p, .Close_Brace); err != Error.None {
+		return false;
+	}
+	return true;
+}
+
+validate_array :: proc(p: ^Parser) -> bool {
+	if err := expect_token(p, .Open_Bracket); err != Error.None {
+		return false;
+	}
+
+	for p.curr_token.kind != .Close_Bracket {
+		if !validate_value(p) {
+			return false;
+		}
+
+		// Disallow trailing commas for the time being
+		if allow_token(p, .Comma) {
+			continue;
+		} else {
+			break;
+		}
+	}
+
+	if err := expect_token(p, .Close_Bracket); err != Error.None {
+		return false;
+	}
+
+	return true;
+}
+
+validate_value :: proc(p: ^Parser) -> bool {
+	token := p.curr_token;
+
+	#partial switch token.kind {
+	case .Null, .False, .True:
+		advance_token(p);
+		return true;
+	case .Integer, .Float:
+		advance_token(p);
+		return true;
+	case .String:
+		advance_token(p);
+		return is_valid_string_literal(token.text, p.spec);
+
+	case .Open_Brace:
+		return validate_object(p);
+
+	case .Open_Bracket:
+		return validate_array(p);
+
+	case:
+		if p.spec == Specification.JSON5 {
+			#partial switch token.kind {
+			case .Infinity, .NaN:
+				advance_token(p);
+				return true;
+			}
+		}
+	}
+
+	return false;
+}

core/fmt.odin

@@ -1,589 +0,0 @@
-#import "os.odin";
-#import "mem.odin";
-#import "utf8.odin";
-
-PRINT_BUF_SIZE :: 1<<12;
-
-Buffer :: struct {
-	data:   []byte;
-	length: int;
-}
-
-
-fprint :: proc(fd: os.Handle, args: ...any) -> int {
-	data: [PRINT_BUF_SIZE]byte;
-	buf := Buffer{data[:], 0};
-	bprint(^buf, ...args);
-	os.write(fd, buf.data[:buf.length]);
-	return buf.length;
-}
-
-fprintln :: proc(fd: os.Handle, args: ...any) -> int {
-	data: [PRINT_BUF_SIZE]byte;
-	buf := Buffer{data[:], 0};
-	bprintln(^buf, ...args);
-	os.write(fd, buf.data[:buf.length]);
-	return buf.length;
-}
-fprintf :: proc(fd: os.Handle, fmt: string, args: ...any) -> int {
-	data: [PRINT_BUF_SIZE]byte;
-	buf := Buffer{data[:], 0};
-	bprintf(^buf, fmt, ...args);
-	os.write(fd, buf.data[:buf.length]);
-	return buf.length;
-}
-
-
-print :: proc(args: ...any) -> int {
-	return fprint(os.stdout, ...args);
-}
-println :: proc(args: ...any) -> int {
-	return fprintln(os.stdout, ...args);
-}
-printf :: proc(fmt: string, args: ...any) -> int {
-	return fprintf(os.stdout, fmt, ...args);
-}
-
-
-
-fprint_type :: proc(fd: os.Handle, info: ^Type_Info) {
-	data: [PRINT_BUF_SIZE]byte;
-	buf := Buffer{data[:], 0};
-	bprint_type(^buf, info);
-	os.write(fd, buf.data[:buf.length]);
-}
-
-
-
-print_byte_buffer :: proc(buf: ^Buffer, b: []byte) {
-	if buf.length < buf.data.count {
-		n := min(buf.data.count-buf.length, b.count);
-		if n > 0 {
-			copy(buf.data[buf.length:], b[:n]);
-			buf.length += n;
-		}
-	}
-}
-
-bprint_string :: proc(buf: ^Buffer, s: string) {
-	print_byte_buffer(buf, s as []byte);
-}
-
-
-byte_reverse :: proc(b: []byte) {
-	n := b.count;
-	for i : 0..<n/2 {
-		b[i], b[n-1-i] = b[n-1-i], b[i];
-	}
-}
-
-bprint_rune :: proc(buf: ^Buffer, r: rune) {
-	b, n := utf8.encode_rune(r);
-	bprint_string(buf, b[:n] as string);
-}
-
-bprint_space :: proc(buf: ^Buffer) { bprint_rune(buf, ' '); }
-bprint_nl :: proc   (buf: ^Buffer) { bprint_rune(buf, '\n'); }
-
-__NUM_TO_CHAR_TABLE := "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@$";
-
-bprint_bool :: proc(buffer: ^Buffer, b: bool) {
-	if b {
-		bprint_string(buffer, "true");
-	} else {
-		bprint_string(buffer, "false");
-	}
-}
-
-bprint_pointer :: proc(buffer: ^Buffer, p: rawptr) #inline {
-	bprint_string(buffer, "0x");
-	bprint_u64(buffer, p as uint as u64);
-}
-
-// bprint_f16 :: proc (buffer: ^Buffer, f: f32)  #inline { print__f64(buffer, f as f64, 4); }
-bprint_f32 :: proc (buffer: ^Buffer, f: f32)  #inline { print__f64(buffer, f as f64, 7); }
-bprint_f64 :: proc (buffer: ^Buffer, f: f64)  #inline { print__f64(buffer, f as f64, 16); }
-bprint_u64 :: proc(buffer: ^Buffer, value: u64) {
-	i := value;
-	buf :[20]byte;
-	len := 0;
-	if i == 0 {
-		buf[len] = '0';
-		len += 1;
-	}
-	while i > 0 {
-		buf[len] = __NUM_TO_CHAR_TABLE[i % 10];
-		len += 1;
-		i /= 10;
-	}
-	byte_reverse(buf[:len]);
-	bprint_string(buffer, buf[:len] as string);
-}
-bprint_i64 :: proc(buffer: ^Buffer, value: i64) {
-	// TODO(bill): Cleanup printing
-	i := value;
-	if i < 0 {
-		i = -i;
-		bprint_rune(buffer, '-');
-	}
-	bprint_u64(buffer, i as u64);
-}
-
-/*
-bprint_u128 :: proc(buffer: ^Buffer, value u128) {
-	a := value transmute [2]u64;
-	if a[1] != 0 {
-		bprint_u64(buffer, a[1]);
-	}
-	bprint_u64(buffer, a[0]);
-}
-bprint_i128 :: proc(buffer: ^Buffer, value i128) {
-	i := value;
-	if i < 0 {
-		i = -i;
-		bprint_rune(buffer, '-');
-	}
-	bprint_u128(buffer, i as u128);
-}
-*/
-
-
-print__f64 :: proc(buffer: ^Buffer, value: f64, decimal_places: int) {
-	f := value;
-	if f == 0 {
-		bprint_rune(buffer, '0');
-		return;
-	}
-	if f < 0 {
-		bprint_rune(buffer, '-');
-		f = -f;
-	}
-
-	i := f as u64;
-	bprint_u64(buffer, i);
-	f -= i as f64;
-
-	bprint_rune(buffer, '.');
-
-	mult: f64 = 10.0;
-	while decimal_places >= 0 {
-		i = (f * mult) as u64;
-		bprint_u64(buffer, i as u64);
-		f -= i as f64 / mult;
-		mult *= 10;
-		decimal_places -= 1;
-	}
-}
-
-bprint_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
-	if ti == nil {
-		return;
-	}
-
-	using Type_Info;
-	match type info : ti {
-	case Named:
-		bprint_string(buf, info.name);
-	case Integer:
-		match {
-		case ti == type_info(int):  bprint_string(buf, "int");
-		case ti == type_info(uint): bprint_string(buf, "uint");
-		default:
-			if info.signed {
-				bprint_string(buf, "i");
-			} else {
-				bprint_string(buf, "u");
-			}
-			bprint_u64(buf, 8*info.size as u64);
-		}
-
-	case Float:
-		match info.size {
-		case 4: bprint_string(buf, "f32");
-		case 8: bprint_string(buf, "f64");
-		}
-	case String:  bprint_string(buf, "string");
-	case Boolean: bprint_string(buf, "bool");
-	case Pointer:
-		if info.elem == nil {
-			bprint_string(buf, "rawptr");
-		} else {
-			bprint_string(buf, "^");
-			bprint_type(buf, info.elem);
-		}
-	case Maybe:
-		bprint_string(buf, "?");
-		bprint_type(buf, info.elem);
-	case Procedure:
-		bprint_string(buf, "proc");
-		if info.params == nil {
-			bprint_string(buf, "()");
-		} else {
-			count := (info.params as ^Tuple).fields.count;
-			if count == 1 { bprint_string(buf, "("); }
-			bprint_type(buf, info.params);
-			if count == 1 { bprint_string(buf, ")"); }
-		}
-		if info.results != nil {
-			bprint_string(buf, " -> ");
-			bprint_type(buf, info.results);
-		}
-	case Tuple:
-		count := info.fields.count;
-		if count != 1 { bprint_string(buf, "("); }
-		for i : 0..<count {
-			if i > 0 { bprint_string(buf, ", "); }
-
-			f := info.fields[i];
-
-			if f.name.count > 0 {
-				bprint_string(buf, f.name);
-				bprint_string(buf, ": ");
-			}
-			bprint_type(buf, f.type_info);
-		}
-		if count != 1 { bprint_string(buf, ")"); }
-
-	case Array:
-		bprint_string(buf, "[");
-		bprint_i64(buf, info.count as i64);
-		bprint_string(buf, "]");
-		bprint_type(buf, info.elem);
-	case Slice:
-		bprint_string(buf, "[");
-		bprint_string(buf, "]");
-		bprint_type(buf, info.elem);
-	case Vector:
-		bprint_string(buf, "[vector ");
-		bprint_i64(buf, info.count as i64);
-		bprint_string(buf, "]");
-		bprint_type(buf, info.elem);
-
-	case Struct:
-		bprint_string(buf, "struct ");
-		if info.packed  { bprint_string(buf, "#packed "); }
-		if info.ordered { bprint_string(buf, "#ordered "); }
-		bprint_string(buf, "{");
-		for field, i : info.fields {
-			if i > 0 {
-				bprint_string(buf, ", ");
-			}
-			bprint_any(buf, field.name);
-			bprint_string(buf, ": ");
-			bprint_type(buf, field.type_info);
-		}
-		bprint_string(buf, "}");
-
-	case Union:
-		bprint_string(buf, "union {");
-		for field, i : info.fields {
-			if i > 0 {
-				bprint_string(buf, ", ");
-			}
-			bprint_any(buf, field.name);
-			bprint_string(buf, ": ");
-			bprint_type(buf, field.type_info);
-		}
-		bprint_string(buf, "}");
-
-	case Raw_Union:
-		bprint_string(buf, "raw_union {");
-		for field, i : info.fields {
-			if i > 0 {
-				bprint_string(buf, ", ");
-			}
-			bprint_any(buf, field.name);
-			bprint_string(buf, ": ");
-			bprint_type(buf, field.type_info);
-		}
-		bprint_string(buf, "}");
-
-	case Enum:
-		bprint_string(buf, "enum ");
-		bprint_type(buf, info.base);
-		bprint_string(buf, " {}");
-
-	}
-}
-
-
-make_any :: proc(type_info: ^Type_Info, data: rawptr) -> any {
-	a :any;
-	a.type_info = type_info;
-	a.data = data;
-	return a;
-}
-
-bprint_any :: proc(buf: ^Buffer, arg: any) {
-	if arg.type_info == nil {
-		bprint_string(buf, "<nil>");
-		return;
-	}
-
-	if arg.data == nil {
-		bprint_string(buf, "<nil>");
-		return;
-	}
-
-	using Type_Info;
-	match type info : arg.type_info {
-	case Named:
-		a := make_any(info.base, arg.data);
-		match type b : info.base {
-		case Struct:
-			bprint_string(buf, info.name);
-			bprint_string(buf, "{");
-			for f, i : b.fields {
-				if i > 0 {
-					bprint_string(buf, ", ");
-				}
-				bprint_string(buf, f.name);
-				// bprint_any(buf, f.offset);
-				bprint_string(buf, " = ");
-				data := arg.data as ^byte + f.offset;
-				bprint_any(buf, make_any(f.type_info, data));
-			}
-			bprint_string(buf, "}");
-
-		default:
-			bprint_any(buf, a);
-		}
-
-	case Integer:
-		match type i : arg {
-		case i8:   bprint_i64(buf, i as i64);
-		case u8:   bprint_u64(buf, i as u64);
-		case i16:  bprint_i64(buf, i as i64);
-		case u16:  bprint_u64(buf, i as u64);
-		case i32:  bprint_i64(buf, i as i64);
-		case u32:  bprint_u64(buf, i as u64);
-		case i64:  bprint_i64(buf, i);
-		case u64:  bprint_u64(buf, i);
-		// case i128: bprint_i128(buf, i);
-		// case u128: bprint_u128(buf, i);
-
-		case int:  bprint_i64(buf, i as i64);
-		case uint: bprint_u64(buf, i as u64);
-		}
-
-	case Float:
-		match type f : arg {
-		// case f16:  bprint_f64(buf, f as f64);
-		case f32:  bprint_f32(buf, f);
-		case f64:  bprint_f64(buf, f);
-		// case f128: bprint_f64(buf, f as f64);
-		}
-
-	case String:
-		match type s : arg {
-		case string: bprint_string(buf, s);
-		}
-
-	case Boolean:
-		match type b : arg {
-		case bool: bprint_bool(buf, b);
-		}
-
-	case Pointer:
-		match type p : arg {
-		case ^Type_Info: bprint_type(buf, p);
-		default:         bprint_pointer(buf, (arg.data as ^rawptr)^);
-		}
-
-	case Maybe:
-		size := mem.size_of_type_info(info.elem);
-		data := slice_ptr(arg.data as ^byte, size+1);
-		if data[size] != 0 {
-			bprint_any(buf, make_any(info.elem, arg.data));
-		} else {
-			bprint_string(buf, "nil");
-		}
-
-	case Array:
-		bprintf(buf, "[%]%{", info.count, info.elem);
-		defer bprint_string(buf, "}");
-
-		for i : 0..<info.count {
-			if i > 0 {
-				bprint_string(buf, ", ");
-			}
-
-			data := arg.data as ^byte + i*info.elem_size;
-			bprint_any(buf, make_any(info.elem, data));
-		}
-
-	case Slice:
-		slice := arg.data as ^[]byte;
-		bprintf(buf, "[]%{", info.elem);
-		defer bprint_string(buf, "}");
-
-		for i : 0..<slice.count {
-			if i > 0 {
-				bprint_string(buf, ", ");
-			}
-
-			data := slice.data + i*info.elem_size;
-			bprint_any(buf, make_any(info.elem, data));
-		}
-
-	case Vector:
-		is_bool :: proc(type_info: ^Type_Info) -> bool {
-			match type info : type_info {
-			case Named:
-				return is_bool(info.base);
-			case Boolean:
-				return true;
-			}
-			return false;
-		}
-
-		bprintf(buf, "[vector %]%{", info.count, info.elem);
-		defer bprint_string(buf, "}");
-
-		if is_bool(info.elem) {
-			return;
-		}
-
-		for i : 0..<info.count {
-			if i > 0 {
-				bprint_string(buf, ", ");
-			}
-
-			data := arg.data as ^byte + i*info.elem_size;
-			bprint_any(buf, make_any(info.elem, data));
-		}
-
-
-	case Struct:
-		bprintf(buf, "%{", arg.type_info);
-		defer bprint_string(buf, "}");
-
-		for f, i : info.fields {
-			if i > 0 {
-				bprint_string(buf, ", ");
-			}
-			bprint_string(buf, f.name);
-			bprint_string(buf, " = ");
-			data := arg.data as ^byte + f.offset;
-			ti := f.type_info;
-			bprint_any(buf, make_any(ti, data));
-		}
-
-	case Union:
-		bprint_string(buf, "(union)");
-	case Raw_Union:
-		bprint_string(buf, "(raw_union)");
-
-	case Enum:
-		bprint_any(buf, make_any(info.base, arg.data));
-
-	case Procedure:
-		bprint_type(buf, arg.type_info);
-		bprint_string(buf, " @ ");
-		bprint_pointer(buf, (arg.data as ^rawptr)^);
-	}
-}
-
-
-bprintf :: proc(buf: ^Buffer, fmt: string, args: ...any) -> int {
-	is_digit :: proc(r: rune) -> bool #inline {
-		return '0' <= r && r <= '9';
-	}
-
-	parse_int :: proc(s: string, offset: int) -> (int, int) {
-		result := 0;
-
-		for _ : offset..<s.count {
-			c := s[offset] as rune;
-			if !is_digit(c) {
-				break;
-			}
-
-			result *= 10;
-			result += (c - '0') as int;
-		}
-
-		return result, offset;
-	}
-
-	prev := 0;
-	implicit_index := 0;
-
-	while i := 0; i < fmt.count { defer i += 1;
-		r := fmt[i] as rune;
-		index := implicit_index;
-
-		if r != '%' {
-			continue;
-		}
-
-		bprint_string(buf, fmt[prev:i]);
-		i += 1; // Skip %
-		if i < fmt.count {
-			next := fmt[i] as rune;
-
-			if next == '%' {
-				bprint_string(buf, "%");
-				i += 1;
-				prev = i;
-				continue;
-			}
-
-			if is_digit(next) {
-				index, i = parse_int(fmt, i);
-			}
-		}
-
-		if 0 <= index && index < args.count {
-			bprint_any(buf, args[index]);
-			implicit_index = index+1;
-		} else {
-			// TODO(bill): Error check index out bounds
-			bprint_string(buf, "<invalid>");
-		}
-
-		prev = i;
-	}
-
-	bprint_string(buf, fmt[prev:]);
-	return buf.length;
-}
-
-
-bprint :: proc(buf: ^Buffer, args: ...any) -> int {
-	is_type_string :: proc(info: ^Type_Info) -> bool {
-		using Type_Info;
-		if info == nil {
-			return false;
-		}
-
-		match type i : type_info_base(info) {
-		case String:
-			return true;
-		}
-		return false;
-	}
-
-
-	prev_string := false;
-	for arg, i : args {
-		is_string := arg.data != nil && is_type_string(arg.type_info);
-		if i > 0 && !is_string && !prev_string {
-			bprint_space(buf);
-		}
-		bprint_any(buf, arg);
-		prev_string = is_string;
-	}
-	return buf.length;
-}
-
-bprintln :: proc(buf: ^Buffer, args: ...any) -> int {
-	for arg, i : args {
-		if i > 0 {
-			bprint_space(buf);
-		}
-		bprint_any(buf, arg);
-	}
-	bprint_nl(buf);
-	return buf.length;
-}

core/hash/crc.odin

@@ -1,170 +1,21 @@
-crc32 :: proc(data: rawptr, len: int) -> u32 {
-	result := ~(0 as u32);
-	s := slice_ptr(data as ^u8, len);
-	for i : 0..<len {
-		b := s[i] as u32;
-		result = result>>8 ~ __CRC32_TABLE[(result ~ b) & 0xff];
+package hash
+
+crc32 :: proc(data: []byte, seed := u32(0)) -> u32 #no_bounds_check {
+	result := ~u32(seed);
+	for b in data {
+		result = result>>8 ~ _crc32_table[(result ~ u32(b)) & 0xff];
 	}
 	return ~result;
 }
-crc64 :: proc(data: rawptr, len: int) -> u64 {
-	result := ~(0 as u64);
-	s := slice_ptr(data as ^u8, len);
-	for i : 0..<len {
-		b := s[i] as u64;
-		result = result>>8 ~ __CRC64_TABLE[(result ~ b) & 0xff];
+crc64 :: proc(data: []byte, seed := u32(0)) -> u64 #no_bounds_check {
+	result := ~u64(seed);
+	for b in data {
+		result = result>>8 ~ _crc64_table[(result ~ u64(b)) & 0xff];
 	}
 	return ~result;
 }
 
-fnv32 :: proc(data: rawptr, len: int) -> u32 {
-	s := slice_ptr(data as ^u8, len);
-
-	h: u32 = 0x811c9dc5;
-	for i : 0..<len {
-		h = (h * 0x01000193) ~ s[i] as u32;
-	}
-	return h;
-}
-
-fnv64 :: proc(data: rawptr, len: int) -> u64 {
-	s := slice_ptr(data as ^u8, len);
-
-	h: u64 = 0xcbf29ce484222325;
-	for i : 0..<len {
-		h = (h * 0x100000001b3) ~ s[i] as u64;
-	}
-	return h;
-}
-
-fnv32a :: proc(data: rawptr, len: int) -> u32 {
-	s := slice_ptr(data as ^u8, len);
-
-	h: u32 = 0x811c9dc5;
-	for i : 0..<len {
-		h = (h ~ s[i] as u32) * 0x01000193;
-	}
-	return h;
-}
-
-fnv64a :: proc(data: rawptr, len: int) -> u64 {
-	s := slice_ptr(data as ^u8, len);
-
-	h :u64 = 0xcbf29ce484222325;
-	for i : 0..<len {
-		h = (h ~ s[i] as u64) * 0x100000001b3;
-	}
-	return h;
-}
-
-
-murmur64 :: proc(data_: rawptr, len: int) -> u64 {
-	SEED :: 0x9747b28c;
-
-	when size_of(int) == 8 {
-		m :: 0xc6a4a7935bd1e995;
-		r :: 47;
-
-		h: u64 = SEED ~ (len as u64 * m);
-
-		data := slice_ptr(data_ as ^u64, len/size_of(u64));
-		data2 := slice_ptr(data_ as ^u8, len);
-
-		for i : 0 ..< data.count {
-			k := data[i];
-
-			k *= m;
-			k ~= k>>r;
-			k *= m;
-
-			h ~= k;
-			h *= m;
-		}
-
-		match len & 7 {
-		case 7: h ~= data2[6] as u64 << 48; fallthrough;
-		case 6: h ~= data2[5] as u64 << 40; fallthrough;
-		case 5: h ~= data2[4] as u64 << 32; fallthrough;
-		case 4: h ~= data2[3] as u64 << 24; fallthrough;
-		case 3: h ~= data2[2] as u64 << 16; fallthrough;
-		case 2: h ~= data2[1] as u64 << 8;  fallthrough;
-		case 1:
-			h ~= data2[0] as u64;
-			h *= m;
-		}
-
-		h ~= h>>r;
-		h *= m;
-		h ~= h>>r;
-
-		return h;
-	} else {
-		m :: 0x5bd1e995;
-		r :: 24;
-
-		h1: u32 = SEED as u32 ~ len as u32;
-		h2: u32 = SEED >> 32;
-
-		data := slice_ptr(data_ as ^u32, len/size_of(u32));
-
-		i := 0;
-		while len >= 8 {
-			k1, k2: u32;
-			k1 = data[i]; i += 1;
-			k1 *= m;
-			k1 ~= k1>>r;
-			k1 *= m;
-			h1 *= m;
-			h1 ~= k1;
-			len -= 4;
-
-			k2 = data[i]; i += 1;
-			k2 *= m;
-			k2 ~= k2>>r;
-			k2 *= m;
-			h2 *= m;
-			h2 ~= k2;
-			len -= 4;
-		}
-
-		if len >= 4 {
-			k1: u32;
-			k1 = data[i]; i += 1;
-			k1 *= m;
-			k1 ~= k1>>r;
-			k1 *= m;
-			h1 *= m;
-			h1 ~= k1;
-			len -= 4;
-		}
-
-		data8 := slice_ptr((data.data+i) as ^u8, 3); // NOTE(bill): This is unsafe
-
-		match len {
-		case 3: h2 ~= data8[2] as u32 << 16; fallthrough;
-		case 2: h2 ~= data8[1] as u32 << 8;  fallthrough;
-		case 1:
-			h2 ~= data8[0] as u32;
-			h2 *= m;
-		}
-
-		h1 ~= h2>>18;
-		h1 *= m;
-		h2 ~= h1>>22;
-		h2 *= m;
-		h1 ~= h2>>17;
-		h1 *= m;
-		h2 ~= h1>>19;
-		h2 *= m;
-
-		h := (h1 as u64)<<32 | h2 as u64;
-		return h;
-	}
-}
-
-
-
-__CRC32_TABLE := [256]u32{
+@private _crc32_table := [256]u32{
 	0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
 	0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
 	0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
@@ -230,7 +81,7 @@ __CRC32_TABLE := [256]u32{
 	0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
 	0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
 };
-__CRC64_TABLE := [256]u64{
+@private _crc64_table := [256]u64{
 	0x0000000000000000, 0x42f0e1eba9ea3693, 0x85e1c3d753d46d26, 0xc711223cfa3e5bb5,
 	0x493366450e42ecdf, 0x0bc387aea7a8da4c, 0xccd2a5925d9681f9, 0x8e224479f47cb76a,
 	0x9266cc8a1c85d9be, 0xd0962d61b56fef2d, 0x17870f5d4f51b498, 0x5577eeb6e6bb820b,

core/hash/hash.odin

@@ -0,0 +1,229 @@
+package hash
+
+import "core:mem"
+
+adler32 :: proc(data: []byte, seed := u32(1)) -> u32 {
+	ADLER_CONST :: 65521;
+	a, b: u32 = seed & 0xFFFF, seed >> 16;
+	for x in data {
+		a = (a + u32(x)) % ADLER_CONST;
+		b = (b + a) % ADLER_CONST;
+	}
+	return (b << 16) | a;
+}
+
+djb2 :: proc(data: []byte) -> u32 {
+	hash: u32 = 5381;
+	for b in data {
+		hash = (hash << 5) + hash + u32(b); // hash * 33 + u32(b)
+	}
+	return hash;
+}
+
+fnv32 :: proc(data: []byte) -> u32 {
+	h: u32 = 0x811c9dc5;
+	for b in data {
+		h = (h * 0x01000193) ~ u32(b);
+	}
+	return h;
+}
+
+fnv64 :: proc(data: []byte) -> u64 {
+	h: u64 = 0xcbf29ce484222325;
+	for b in data {
+		h = (h * 0x100000001b3) ~ u64(b);
+	}
+	return h;
+}
+
+fnv32a :: proc(data: []byte) -> u32 {
+	h: u32 = 0x811c9dc5;
+	for b in data {
+		h = (h ~ u32(b)) * 0x01000193;
+	}
+	return h;
+}
+
+fnv64a :: proc(data: []byte) -> u64 {
+	h: u64 = 0xcbf29ce484222325;
+	for b in data {
+		h = (h ~ u64(b)) * 0x100000001b3;
+	}
+	return h;
+}
+
+jenkins :: proc(data: []byte) -> u32 {
+	hash: u32 = 0;
+	for b in data {
+		hash += u32(b);
+		hash += hash << 10;
+		hash ~= hash >> 6;
+	}
+	hash += hash << 3;
+	hash ~= hash >> 11;
+	hash += hash << 15;
+	return hash;
+}
+
+murmur32 :: proc(data: []byte) -> u32 {
+	c1_32: u32 : 0xcc9e2d51;
+	c2_32: u32 : 0x1b873593;
+
+	h1: u32 = 0;
+	nblocks := len(data)/4;
+	p := raw_data(data);
+	p1 := mem.ptr_offset(p, 4*nblocks);
+
+	for ; p < p1; p = mem.ptr_offset(p, 4) {
+		k1 := (cast(^u32)p)^;
+
+		k1 *= c1_32;
+		k1 = (k1 << 15) | (k1 >> 17);
+		k1 *= c2_32;
+
+		h1 ~= k1;
+		h1 = (h1 << 13) | (h1 >> 19);
+		h1 = h1*5 + 0xe6546b64;
+	}
+
+	tail := data[nblocks*4:];
+	k1: u32;
+	switch len(tail)&3 {
+	case 3:
+		k1 ~= u32(tail[2]) << 16;
+		fallthrough;
+	case 2:
+		k1 ~= u32(tail[2]) << 8;
+		fallthrough;
+	case 1:
+		k1 ~= u32(tail[0]);
+		k1 *= c1_32;
+		k1 = (k1 << 15) | (k1 >> 17) ;
+		k1 *= c2_32;
+		h1 ~= k1;
+	}
+
+	h1 ~= u32(len(data));
+
+	h1 ~= h1 >> 16;
+	h1 *= 0x85ebca6b;
+	h1 ~= h1 >> 13;
+	h1 *= 0xc2b2ae35;
+	h1 ~= h1 >> 16;
+
+	return h1;
+}
+
+murmur64 :: proc(data: []byte) -> u64 {
+	SEED :: 0x9747b28c;
+
+	when size_of(int) == 8 {
+		m :: 0xc6a4a7935bd1e995;
+		r :: 47;
+
+		h: u64 = SEED ~ (u64(len(data)) * m);
+		data64 := mem.slice_ptr(cast(^u64)raw_data(data), len(data)/size_of(u64));
+
+		for _, i in data64 {
+			k := data64[i];
+
+			k *= m;
+			k ~= k>>r;
+			k *= m;
+
+			h ~= k;
+			h *= m;
+		}
+
+		switch len(data)&7 {
+		case 7: h ~= u64(data[6]) << 48; fallthrough;
+		case 6: h ~= u64(data[5]) << 40; fallthrough;
+		case 5: h ~= u64(data[4]) << 32; fallthrough;
+		case 4: h ~= u64(data[3]) << 24; fallthrough;
+		case 3: h ~= u64(data[2]) << 16; fallthrough;
+		case 2: h ~= u64(data[1]) << 8;  fallthrough;
+		case 1:
+			h ~= u64(data[0]);
+			h *= m;
+		}
+
+		h ~= h>>r;
+		h *= m;
+		h ~= h>>r;
+
+		return h;
+	} else {
+		m :: 0x5bd1e995;
+		r :: 24;
+
+		h1 := u32(SEED) ~ u32(len(data));
+		h2 := u32(SEED) >> 32;
+		data32 := mem.slice_ptr(cast(^u32)raw_data(data), len(data)/size_of(u32));
+		len := len(data);
+		i := 0;
+
+		for len >= 8 {
+			k1, k2: u32;
+			k1 = data32[i]; i += 1;
+			k1 *= m;
+			k1 ~= k1>>r;
+			k1 *= m;
+			h1 *= m;
+			h1 ~= k1;
+			len -= 4;
+
+			k2 = data32[i]; i += 1;
+			k2 *= m;
+			k2 ~= k2>>r;
+			k2 *= m;
+			h2 *= m;
+			h2 ~= k2;
+			len -= 4;
+		}
+
+		if len >= 4 {
+			k1: u32;
+			k1 = data32[i]; i += 1;
+			k1 *= m;
+			k1 ~= k1>>r;
+			k1 *= m;
+			h1 *= m;
+			h1 ~= k1;
+			len -= 4;
+		}
+
+		// TODO(bill): Fix this
+		#no_bounds_check data8 := mem.slice_to_bytes(data32[i:])[:3];
+		switch len {
+		case 3:
+			h2 ~= u32(data8[2]) << 16;
+			fallthrough;
+		case 2:
+			h2 ~= u32(data8[1]) << 8;
+			fallthrough;
+		case 1:
+			h2 ~= u32(data8[0]);
+			h2 *= m;
+		}
+
+		h1 ~= h2>>18;
+		h1 *= m;
+		h2 ~= h1>>22;
+		h2 *= m;
+		h1 ~= h2>>17;
+		h1 *= m;
+		h2 ~= h1>>19;
+		h2 *= m;
+
+		return u64(h1)<<32 | u64(h2);
+	}
+}
+
+
+sdbm :: proc(data: []byte) -> u32 {
+	hash: u32 = 0;
+	for b in data {
+		hash = u32(b) + (hash<<6) + (hash<<16) - hash;
+	}
+	return hash;
+}

core/hash/mini.odin

@@ -0,0 +1,40 @@
+package hash
+
+ginger_hash8 :: proc(x: u8) -> u8 {
+	h := x * 251;
+	h += ~(x << 3);
+	h ~=  (x >> 1);
+	h += ~(x << 7);
+	h ~=  (x >> 6);
+	h +=  (x << 2);
+	return h;
+}
+
+
+ginger_hash16 :: proc(x: u16) -> u16 {
+	z := (x << 8) | (x >> 8);
+	h := z;
+	h += ~(z << 5);
+	h ~=  (z >> 2);
+	h += ~(z << 13);
+	h ~=  (z >> 10);
+	h += ~(z << 4);
+	h = (h << 10) | (h >> 10);
+	return h;
+}
+
+
+ginger8 :: proc(data: []byte) -> u8 {
+	h := ginger_hash8(0);
+	for b in data {
+		h ~= ginger_hash8(b);
+	}
+	return h;
+}
+ginger16 :: proc(data: []byte) -> u16 {
+	h := ginger_hash16(0);
+	for b in data {
+		h ~= ginger_hash16(u16(b));
+	}
+	return h;
+}

core/intrinsics/intrinsics.odin

@@ -0,0 +1,163 @@
+// This is purely for documentation
+//+ignore
+package intrinsics
+
+// Types
+simd_vector :: proc($N: int, $T: typeid) -> type/#simd[N]T
+soa_struct :: proc($N: int, $T: typeid) -> type/#soa[N]T
+
+// Volatile
+volatile_load  :: proc(dst: ^$T) -> T ---
+volatile_store :: proc(dst: ^$T, val: T) -> T ---
+
+// Trapping
+debug_trap :: proc() ---
+trap :: proc() -> ! ---
+
+// Atomics
+atomic_fence        :: proc() ---
+atomic_fence_acq    :: proc() ---
+atomic_fence_rel    :: proc() ---
+atomic_fence_acqrel :: proc() ---
+
+atomic_store           :: proc(dst: ^$T, val: T) ---
+atomic_store_rel       :: proc(dst: ^$T, val: T) ---
+atomic_store_relaxed   :: proc(dst: ^$T, val: T) ---
+atomic_store_unordered :: proc(dst: ^$T, val: T) ---
+
+atomic_load           :: proc(dst: ^$T) -> T ---
+atomic_load_acq       :: proc(dst: ^$T) -> T ---
+atomic_load_relaxed   :: proc(dst: ^$T) -> T ---
+atomic_load_unordered :: proc(dst: ^$T) -> T ---
+
+atomic_add          :: proc(dst; ^$T, val: T) -> T ---
+atomic_add_acq      :: proc(dst; ^$T, val: T) -> T ---
+atomic_add_rel      :: proc(dst; ^$T, val: T) -> T ---
+atomic_add_acqrel   :: proc(dst; ^$T, val: T) -> T ---
+atomic_add_relaxed  :: proc(dst; ^$T, val: T) -> T ---
+atomic_sub          :: proc(dst; ^$T, val: T) -> T ---
+atomic_sub_acq      :: proc(dst; ^$T, val: T) -> T ---
+atomic_sub_rel      :: proc(dst; ^$T, val: T) -> T ---
+atomic_sub_acqrel   :: proc(dst; ^$T, val: T) -> T ---
+atomic_sub_relaxed  :: proc(dst; ^$T, val: T) -> T ---
+atomic_and          :: proc(dst; ^$T, val: T) -> T ---
+atomic_and_acq      :: proc(dst; ^$T, val: T) -> T ---
+atomic_and_rel      :: proc(dst; ^$T, val: T) -> T ---
+atomic_and_acqrel   :: proc(dst; ^$T, val: T) -> T ---
+atomic_and_relaxed  :: proc(dst; ^$T, val: T) -> T ---
+atomic_nand         :: proc(dst; ^$T, val: T) -> T ---
+atomic_nand_acq     :: proc(dst; ^$T, val: T) -> T ---
+atomic_nand_rel     :: proc(dst; ^$T, val: T) -> T ---
+atomic_nand_acqrel  :: proc(dst; ^$T, val: T) -> T ---
+atomic_nand_relaxed :: proc(dst; ^$T, val: T) -> T ---
+atomic_or           :: proc(dst; ^$T, val: T) -> T ---
+atomic_or_acq       :: proc(dst; ^$T, val: T) -> T ---
+atomic_or_rel       :: proc(dst; ^$T, val: T) -> T ---
+atomic_or_acqrel    :: proc(dst; ^$T, val: T) -> T ---
+atomic_or_relaxed   :: proc(dst; ^$T, val: T) -> T ---
+atomic_xor          :: proc(dst; ^$T, val: T) -> T ---
+atomic_xor_acq      :: proc(dst; ^$T, val: T) -> T ---
+atomic_xor_rel      :: proc(dst; ^$T, val: T) -> T ---
+atomic_xor_acqrel   :: proc(dst; ^$T, val: T) -> T ---
+atomic_xor_relaxed  :: proc(dst; ^$T, val: T) -> T ---
+
+atomic_xchg         :: proc(dst; ^$T, val: T) -> T ---
+atomic_xchg_acq     :: proc(dst; ^$T, val: T) -> T ---
+atomic_xchg_rel     :: proc(dst; ^$T, val: T) -> T ---
+atomic_xchg_acqrel  :: proc(dst; ^$T, val: T) -> T ---
+atomic_xchg_relaxed :: proc(dst; ^$T, val: T) -> T ---
+
+atomic_cxchg                    :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchg_acq                :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchg_rel                :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchg_acqrel             :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchg_relaxed            :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchg_failrelaxed        :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchg_failacq            :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchg_acq_failrelaxed    :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchg_acqrel_failrelaxed :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+
+atomic_cxchgweak                    :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchgweak_acq                :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchgweak_rel                :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchgweak_acqrel             :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchgweak_relaxed            :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchgweak_failrelaxed        :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchgweak_failacq            :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchgweak_acq_failrelaxed    :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+atomic_cxchgweak_acqrel_failrelaxed :: proc(dst: ^$T, old, new: T) -> (T, /*option*/bool) ---
+
+// Instructions
+
+alloca             :: proc(size, align: int) -> ^u8 ---
+cpu_relax          :: proc() ---
+read_cycle_counter :: proc() -> i64 ---
+
+
+// Compiler Hints
+expect :: proc(val, expected_val: T) -> T ---
+
+
+// Constant type tests
+
+type_base_type :: proc($T: typeid) -> type ---
+type_core_type :: proc($T: typeid) -> type ---
+type_elem_type :: proc($T: typeid) -> type ---
+
+type_is_boolean    :: proc($T: typeid) -> bool ---
+type_is_integer    :: proc($T: typeid) -> bool ---
+type_is_rune       :: proc($T: typeid) -> bool ---
+type_is_float      :: proc($T: typeid) -> bool ---
+type_is_complex    :: proc($T: typeid) -> bool ---
+type_is_quaternion :: proc($T: typeid) -> bool ---
+type_is_string     :: proc($T: typeid) -> bool ---
+type_is_typeid     :: proc($T: typeid) -> bool ---
+type_is_any        :: proc($T: typeid) -> bool ---
+
+type_is_endian_little   :: proc($T: typeid) -> bool ---
+type_is_endian_big      :: proc($T: typeid) -> bool ---
+type_is_unsigned        :: proc($T: typeid) -> bool ---
+type_is_numeric         :: proc($T: typeid) -> bool ---
+type_is_ordered         :: proc($T: typeid) -> bool ---
+type_is_ordered_numeric :: proc($T: typeid) -> bool ---
+type_is_indexable       :: proc($T: typeid) -> bool ---
+type_is_sliceable       :: proc($T: typeid) -> bool ---
+type_is_comparable      :: proc($T: typeid) -> bool ---
+type_is_simple_compare  :: proc($T: typeid) -> bool --- // easily compared using memcmp (== and !=)
+type_is_dereferenceable :: proc($T: typeid) -> bool ---
+type_is_valid_map_key   :: proc($T: typeid) -> bool ---
+
+type_is_named            :: proc($T: typeid) -> bool ---
+type_is_pointer          :: proc($T: typeid) -> bool ---
+type_is_array            :: proc($T: typeid) -> bool ---
+type_is_enumerated_array :: proc($T: typeid) -> bool ---
+type_is_slice            :: proc($T: typeid) -> bool ---
+type_is_dynamic_array    :: proc($T: typeid) -> bool ---
+type_is_map              :: proc($T: typeid) -> bool ---
+type_is_struct           :: proc($T: typeid) -> bool ---
+type_is_union            :: proc($T: typeid) -> bool ---
+type_is_enum             :: proc($T: typeid) -> bool ---
+type_is_proc             :: proc($T: typeid) -> bool ---
+type_is_bit_set          :: proc($T: typeid) -> bool ---
+type_is_simd_vector      :: proc($T: typeid) -> bool ---
+
+type_has_nil :: proc($T: typeid) -> bool ---
+
+type_is_specialization_of :: proc($T, $S: typeid) -> bool ---
+
+type_has_field :: proc($T: typeid, $name: string) -> bool ---
+
+type_proc_parameter_count :: proc($T: typeid) -> int where type_is_proc(T) ---
+type_proc_return_count    :: proc($T: typeid) -> int where type_is_proc(T) ---
+
+type_proc_parameter_type  :: proc($T: typeid, index: int) -> typeid where type_is_proc(T) ---
+type_proc_return_type     :: proc($T: typeid, index: int) -> typeid where type_is_proc(T) ---
+
+type_polymorphic_record_parameter_count :: proc($T: typeid) -> typeid ---
+type_polymorphic_record_parameter_value :: proc($T: typeid, index: int) -> $V ---
+
+
+type_field_index_of :: proc($T: typeid, $name: string) -> uintptr ---
+
+type_equal_proc  :: proc($T: typeid) -> (equal:  proc "contextless" (rawptr, rawptr) -> bool) ---
+type_hasher_proc :: proc($T: typeid) -> (hasher: proc "contextless" (data: rawptr, seed: uintptr) -> uintptr) ---

core/io/conv.odin

@@ -0,0 +1,194 @@
+package io
+
+to_reader :: proc(s: Stream) -> (r: Reader, ok: bool = true) {
+	r.stream = s;
+	if s.stream_vtable == nil || s.impl_read == nil {
+		ok = false;
+	}
+	return;
+}
+to_writer :: proc(s: Stream) -> (w: Writer, ok: bool = true) {
+	w.stream = s;
+	if s.stream_vtable == nil || s.impl_write == nil {
+		ok = false;
+	}
+	return;
+}
+
+to_closer :: proc(s: Stream) -> (c: Closer, ok: bool = true) {
+	c.stream = s;
+	if s.stream_vtable == nil || s.impl_close == nil {
+		ok = false;
+	}
+	return;
+}
+to_flusher :: proc(s: Stream) -> (f: Flusher, ok: bool = true) {
+	f.stream = s;
+	if s.stream_vtable == nil || s.impl_flush == nil {
+		ok = false;
+	}
+	return;
+}
+to_seeker :: proc(s: Stream) -> (seeker: Seeker, ok: bool = true) {
+	seeker.stream = s;
+	if s.stream_vtable == nil || s.impl_seek == nil {
+		ok = false;
+	}
+	return;
+}
+
+to_read_writer :: proc(s: Stream) -> (r: Read_Writer, ok: bool = true) {
+	r.stream = s;
+	if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil {
+		ok = false;
+	}
+	return;
+}
+to_read_closer :: proc(s: Stream) -> (r: Read_Closer, ok: bool = true) {
+	r.stream = s;
+	if s.stream_vtable == nil || s.impl_read == nil || s.impl_close == nil {
+		ok = false;
+	}
+	return;
+}
+to_read_write_closer :: proc(s: Stream) -> (r: Read_Write_Closer, ok: bool = true) {
+	r.stream = s;
+	if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil || s.impl_close == nil {
+		ok = false;
+	}
+	return;
+}
+to_read_write_seeker :: proc(s: Stream) -> (r: Read_Write_Seeker, ok: bool = true) {
+	r.stream = s;
+	if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil || s.impl_seek == nil {
+		ok = false;
+	}
+	return;
+}
+to_write_flusher :: proc(s: Stream) -> (w: Write_Flusher, ok: bool = true) {
+	w.stream = s;
+	if s.stream_vtable == nil || s.impl_write == nil || s.impl_flush == nil {
+		ok = false;
+	}
+	return;
+}
+to_write_flush_closer :: proc(s: Stream) -> (w: Write_Flush_Closer, ok: bool = true) {
+	w.stream = s;
+	if s.stream_vtable == nil || s.impl_write == nil || s.impl_flush == nil || s.impl_close == nil {
+		ok = false;
+	}
+	return;
+}
+
+to_reader_at :: proc(s: Stream) -> (r: Reader_At, ok: bool = true) {
+	r.stream = s;
+	if s.stream_vtable == nil || s.impl_read_at == nil {
+		ok = false;
+	}
+	return;
+}
+to_writer_at :: proc(s: Stream) -> (w: Writer_At, ok: bool = true) {
+	w.stream = s;
+	if s.stream_vtable == nil || s.impl_write_at == nil {
+		ok = false;
+	}
+	return;
+}
+to_reader_from :: proc(s: Stream) -> (r: Reader_From, ok: bool = true) {
+	r.stream = s;
+	if s.stream_vtable == nil || s.impl_read_from == nil {
+		ok = false;
+	}
+	return;
+}
+to_writer_to :: proc(s: Stream) -> (w: Writer_To, ok: bool = true) {
+	w.stream = s;
+	if s.stream_vtable == nil || s.impl_write_to == nil {
+		ok = false;
+	}
+	return;
+}
+to_write_closer :: proc(s: Stream) -> (w: Write_Closer, ok: bool = true) {
+	w.stream = s;
+	if s.stream_vtable == nil || s.impl_write == nil || s.impl_close == nil {
+		ok = false;
+	}
+	return;
+}
+to_write_seeker :: proc(s: Stream) -> (w: Write_Seeker, ok: bool = true) {
+	w.stream = s;
+	if s.stream_vtable == nil || s.impl_write == nil || s.impl_seek == nil {
+		ok = false;
+	}
+	return;
+}
+
+
+to_byte_reader :: proc(s: Stream) -> (b: Byte_Reader, ok: bool = true) {
+	b.stream = s;
+	if s.stream_vtable == nil || s.impl_read_byte == nil {
+		ok = false;
+		if s.stream_vtable != nil && s.impl_read != nil {
+			ok = true;
+		}
+	}
+	return;
+}
+to_byte_scanner :: proc(s: Stream) -> (b: Byte_Scanner, ok: bool = true) {
+	b.stream = s;
+	if s.stream_vtable != nil {
+		if s.impl_unread_byte == nil {
+			ok = false;
+			return;
+		}
+		if s.impl_read_byte != nil {
+			ok = true;
+		} else if s.impl_read != nil {
+			ok = true;
+		} else {
+			ok = false;
+		}
+	}
+	return;
+}
+to_byte_writer :: proc(s: Stream) -> (b: Byte_Writer, ok: bool = true) {
+	b.stream = s;
+	if s.stream_vtable == nil || s.impl_write_byte == nil {
+		ok = false;
+		if s.stream_vtable != nil && s.impl_write != nil {
+			ok = true;
+		}
+	}
+	return;
+}
+
+to_rune_reader :: proc(s: Stream) -> (r: Rune_Reader, ok: bool = true) {
+	r.stream = s;
+	if s.stream_vtable == nil || s.impl_read_rune == nil {
+		ok = false;
+		if s.stream_vtable != nil && s.impl_read != nil {
+			ok = true;
+		}
+	}
+	return;
+
+}
+to_rune_scanner :: proc(s: Stream) -> (r: Rune_Scanner, ok: bool = true) {
+	r.stream = s;
+	if s.stream_vtable != nil {
+		if s.impl_unread_rune == nil {
+			ok = false;
+			return;
+		}
+		if s.impl_read_rune != nil {
+			ok = true;
+		} else if s.impl_read != nil {
+			ok = true;
+		} else {
+			ok = false;
+		}
+	} else {
+		ok = false;
+	}
+	return;
+}

core/io/io.odin

@@ -0,0 +1,514 @@
+package io
+
+import "intrinsics"
+import "core:runtime"
+import "core:unicode/utf8"
+
+Seek_From :: enum {
+	Start   = 0, // seek relative to the origin of the file
+	Current = 1, // seek relative to the current offset
+	End     = 2, // seek relative to the end
+}
+
+Error :: enum i32 {
+	// No Error
+	None = 0,
+
+	// EOF is the error returned by `read` when no more input is available
+	EOF,
+
+	// Unexpected_EOF means that EOF was encountered in the middle of reading a fixed-sized block of data
+	Unexpected_EOF,
+
+	// Short_Write means that a write accepted fewer bytes than requested but failed to return an explicit error
+	Short_Write,
+
+	// Invalid_Write means that a write returned an impossible count
+	Invalid_Write,
+
+	// Short_Buffer means that a read required a longer buffer than was provided
+	Short_Buffer,
+
+	// No_Progress is returned by some implementations of `io.Reader` when many calls
+	// to `read` have failed to return any data or error.
+	// This is usually a signed of a broken `io.Reader` implementation
+	No_Progress,
+
+	Invalid_Whence,
+	Invalid_Offset,
+	Invalid_Unread,
+
+	Negative_Read,
+	Negative_Write,
+	Negative_Count,
+	Buffer_Full,
+
+	// Unknown means that an error has occurred but cannot be categorized
+	Unknown,
+
+	// Empty is returned when a procedure has not been implemented for an io.Stream
+	Empty = -1,
+}
+
+Close_Proc       :: proc(using s: Stream) -> Error;
+Flush_Proc       :: proc(using s: Stream) -> Error;
+Seek_Proc        :: proc(using s: Stream, offset: i64, whence: Seek_From) -> (n: i64, err: Error);
+Size_Proc        :: proc(using s: Stream) -> i64;
+Read_Proc        :: proc(using s: Stream, p: []byte) -> (n: int, err: Error);
+Read_At_Proc     :: proc(using s: Stream, p: []byte, off: i64) -> (n: int, err: Error);
+Read_From_Proc   :: proc(using s: Stream, r: Reader) -> (n: i64, err: Error);
+Read_Byte_Proc   :: proc(using s: Stream) -> (byte, Error);
+Read_Rune_Proc   :: proc(using s: Stream) -> (ch: rune, size: int, err: Error);
+Unread_Byte_Proc :: proc(using s: Stream) -> Error;
+Unread_Rune_Proc :: proc(using s: Stream) -> Error;
+Write_Proc       :: proc(using s: Stream, p: []byte) -> (n: int, err: Error);
+Write_At_Proc    :: proc(using s: Stream, p: []byte, off: i64) -> (n: int, err: Error);
+Write_To_Proc    :: proc(using s: Stream, w: Writer) -> (n: i64, err: Error);
+Write_Byte_Proc  :: proc(using s: Stream, c: byte) -> Error;
+Write_Rune_Proc  :: proc(using s: Stream, r: rune) -> (size: int, err: Error);
+Destroy_Proc     :: proc(using s: Stream) -> Error;
+
+
+Stream :: struct {
+	using stream_vtable: ^Stream_VTable,
+	stream_data:         rawptr,
+}
+Stream_VTable :: struct {
+	impl_close: Close_Proc,
+	impl_flush: Flush_Proc,
+
+	impl_seek:  Seek_Proc,
+	impl_size:  Size_Proc,
+
+	impl_read:      Read_Proc,
+	impl_read_at:   Read_At_Proc,
+	impl_read_byte: Read_Byte_Proc,
+	impl_read_rune: Read_Rune_Proc,
+	impl_write_to:  Write_To_Proc,
+
+	impl_write:      Write_Proc,
+	impl_write_at:   Write_At_Proc,
+	impl_write_byte: Write_Byte_Proc,
+	impl_write_rune: Write_Rune_Proc,
+	impl_read_from:  Read_From_Proc,
+
+	impl_unread_byte: Unread_Byte_Proc,
+	impl_unread_rune: Unread_Rune_Proc,
+
+	impl_destroy: Destroy_Proc,
+}
+
+
+Reader             :: struct {using stream: Stream};
+Writer             :: struct {using stream: Stream};
+Closer             :: struct {using stream: Stream};
+Flusher            :: struct {using stream: Stream};
+Seeker             :: struct {using stream: Stream};
+
+Read_Writer        :: struct {using stream: Stream};
+Read_Closer        :: struct {using stream: Stream};
+Read_Write_Closer  :: struct {using stream: Stream};
+Read_Write_Seeker  :: struct {using stream: Stream};
+
+Write_Closer       :: struct {using stream: Stream};
+Write_Seeker       :: struct {using stream: Stream};
+Write_Flusher      :: struct {using stream: Stream};
+Write_Flush_Closer :: struct {using stream: Stream};
+
+Reader_At          :: struct {using stream: Stream};
+Writer_At          :: struct {using stream: Stream};
+Reader_From        :: struct {using stream: Stream};
+Writer_To          :: struct {using stream: Stream};
+
+Byte_Reader        :: struct {using stream: Stream};
+Byte_Scanner       :: struct {using stream: Stream};
+Byte_Writer        :: struct {using stream: Stream};
+
+Rune_Reader        :: struct {using stream: Stream};
+Rune_Scanner       :: struct {using stream: Stream};
+
+
+destroy :: proc(s: Stream) -> Error {
+	close_err := close({s});
+	if s.stream_vtable != nil && s.impl_destroy != nil {
+		return s->impl_destroy();
+	}
+	if close_err != .None {
+		return close_err;
+	}
+	return .Empty;
+}
+
+read :: proc(s: Reader, p: []byte) -> (n: int, err: Error) {
+	if s.stream_vtable != nil && s.impl_read != nil {
+		return s->impl_read(p);
+	}
+	return 0, .Empty;
+}
+
+write :: proc(s: Writer, p: []byte) -> (n: int, err: Error) {
+	if s.stream_vtable != nil && s.impl_write != nil {
+		return s->impl_write(p);
+	}
+	return 0, .Empty;
+}
+
+seek :: proc(s: Seeker, offset: i64, whence: Seek_From) -> (n: i64, err: Error) {
+	if s.stream_vtable != nil && s.impl_seek != nil {
+		return s->impl_seek(offset, whence);
+	}
+	return 0, .Empty;
+}
+
+close :: proc(s: Closer) -> Error {
+	if s.stream_vtable != nil && s.impl_close != nil {
+		return s->impl_close();
+	}
+	// Instead of .Empty, .None is fine in this case
+	return .None;
+}
+
+flush :: proc(s: Flusher) -> Error {
+	if s.stream_vtable != nil && s.impl_flush != nil {
+		return s->impl_flush();
+	}
+	// Instead of .Empty, .None is fine in this case
+	return .None;
+}
+
+size :: proc(s: Stream) -> i64 {
+	if s.stream_vtable == nil {
+		return 0;
+	}
+	if s.impl_size != nil {
+		return s->impl_size();
+	}
+	if s.impl_seek == nil {
+		return 0;
+	}
+
+	curr, end: i64;
+	err: Error;
+	if curr, err = s->impl_seek(0, .Current); err != nil {
+		return 0;
+	}
+
+	if end, err = s->impl_seek(0, .End); err != nil {
+		return 0;
+	}
+
+	if _, err = s->impl_seek(curr, .Start); err != nil {
+		return 0;
+	}
+
+	return end;
+}
+
+
+
+
+read_at :: proc(r: Reader_At, p: []byte, offset: i64) -> (n: int, err: Error) {
+	if r.stream_vtable == nil {
+		return 0, .Empty;
+	}
+	if r.impl_read_at != nil {
+		return r->impl_read_at(p, offset);
+	}
+	if r.impl_seek == nil || r.impl_read == nil {
+		return 0, .Empty;
+	}
+
+	curr_offset: i64;
+	curr_offset, err = r->impl_seek(offset, .Current);
+	if err != nil {
+		return 0, err;
+	}
+
+	n, err = r->impl_read(p);
+	_, err1 := r->impl_seek(curr_offset, .Start);
+	if err1 != nil && err == nil {
+		err = err1;
+	}
+	return;
+
+}
+
+write_at :: proc(w: Writer_At, p: []byte, offset: i64) -> (n: int, err: Error) {
+	if w.stream_vtable == nil {
+		return 0, .Empty;
+	}
+	if w.impl_write_at != nil {
+		return w->impl_write_at(p, offset);
+	}
+	if w.impl_seek == nil || w.impl_write == nil {
+		return 0, .Empty;
+	}
+
+	curr_offset: i64;
+	curr_offset, err = w->impl_seek(offset, .Current);
+	if err != nil {
+		return 0, err;
+	}
+
+	n, err = w->impl_write(p);
+	_, err1 := w->impl_seek(curr_offset, .Start);
+	if err1 != nil && err == nil {
+		err = err1;
+	}
+	return;
+}
+
+write_to :: proc(r: Writer_To, w: Writer) -> (n: i64, err: Error) {
+	if r.stream_vtable == nil || w.stream_vtable == nil {
+		return 0, .Empty;
+	}
+	if r.impl_write_to != nil {
+		return r->impl_write_to(w);
+	}
+	return 0, .Empty;
+}
+read_from :: proc(w: Reader_From, r: Reader) -> (n: i64, err: Error) {
+	if r.stream_vtable == nil || w.stream_vtable == nil {
+		return 0, .Empty;
+	}
+	if r.impl_read_from != nil {
+		return w->impl_read_from(r);
+	}
+	return 0, .Empty;
+}
+
+
+read_byte :: proc(r: Byte_Reader) -> (byte, Error) {
+	if r.stream_vtable == nil {
+		return 0, .Empty;
+	}
+	if r.impl_read_byte != nil {
+		return r->impl_read_byte();
+	}
+	if r.impl_read == nil {
+		return 0, .Empty;
+	}
+
+	b: [1]byte;
+	_, err := r->impl_read(b[:]);
+	return b[0], err;
+}
+
+write_byte :: proc{
+	write_byte_to_byte_writer,
+	write_byte_to_writer,
+};
+
+write_byte_to_byte_writer :: proc(w: Byte_Writer, c: byte) -> Error {
+	return _write_byte(w, c);
+}
+
+write_byte_to_writer :: proc(w: Writer, c: byte) -> Error {
+	return _write_byte(auto_cast w, c);
+}
+
+@(private)
+_write_byte :: proc(w: Byte_Writer, c: byte) -> Error {
+	if w.stream_vtable == nil {
+		return .Empty;
+	}
+	if w.impl_write_byte != nil {
+		return w->impl_write_byte(c);
+	}
+	if w.impl_write == nil {
+		return .Empty;
+	}
+
+	b := [1]byte{c};
+	_, err := w->impl_write(b[:]);
+	return err;
+}
+
+read_rune :: proc(br: Rune_Reader) -> (ch: rune, size: int, err: Error) {
+	if br.stream_vtable == nil {
+		return 0, 0, .Empty;
+	}
+	if br.impl_read_rune != nil {
+		return br->impl_read_rune();
+	}
+	if br.impl_read == nil {
+		return 0, 0, .Empty;
+	}
+
+	b: [utf8.UTF_MAX]byte;
+	_, err = br->impl_read(b[:1]);
+
+	s0 := b[0];
+	ch = rune(s0);
+	size = 1;
+	if err != nil {
+		return;
+	}
+	if ch < utf8.RUNE_SELF {
+		return;
+	}
+	x := utf8.accept_sizes[s0];
+	if x >= 0xf0 {
+		mask := rune(x) << 31 >> 31;
+		ch = ch &~ mask | utf8.RUNE_ERROR&mask;
+		return;
+	}
+	sz := int(x&7);
+	n: int;
+	n, err = br->impl_read(b[1:sz]);
+	if err != nil || n+1 < sz {
+		ch = utf8.RUNE_ERROR;
+		return;
+	}
+
+	ch, size = utf8.decode_rune(b[:sz]);
+	return;
+}
+
+unread_byte :: proc(s: Byte_Scanner) -> Error {
+	if s.stream_vtable != nil && s.impl_unread_byte != nil {
+		return s->impl_unread_byte();
+	}
+	return .Empty;
+}
+unread_rune :: proc(s: Rune_Scanner) -> Error {
+	if s.stream_vtable != nil && s.impl_unread_rune != nil {
+		return s->impl_unread_rune();
+	}
+	return .Empty;
+}
+
+
+write_string :: proc(s: Writer, str: string) -> (n: int, err: Error) {
+	return write(s, transmute([]byte)str);
+}
+
+write_rune :: proc(s: Writer, r: rune) -> (size: int, err: Error) {
+	if s.stream_vtable != nil && s.impl_write_rune != nil {
+		return s->impl_write_rune(r);
+	}
+
+	if r < utf8.RUNE_SELF {
+		err = write_byte(s, byte(r));
+		if err == nil {
+			size = 1;
+		}
+		return;
+	}
+	buf, w := utf8.encode_rune(r);
+	return write(s, buf[:w]);
+}
+
+
+
+read_full :: proc(r: Reader, buf: []byte) -> (n: int, err: Error) {
+	return read_at_least(r, buf, len(buf));
+}
+
+
+read_at_least :: proc(r: Reader, buf: []byte, min: int) -> (n: int, err: Error) {
+	if len(buf) < min {
+		return 0, .Short_Buffer;
+	}
+	for n < min && err == nil {
+		nn: int;
+		nn, err = read(r, buf[n:]);
+		n += n;
+	}
+
+	if n >= min {
+		err = nil;
+	} else if n > 0 && err == .EOF {
+		err = .Unexpected_EOF;
+	}
+	return;
+}
+
+// copy copies from src to dst till either EOF is reached on src or an error occurs
+// It returns the number of bytes copied and the first error that occurred whilst copying, if any.
+copy :: proc(dst: Writer, src: Reader) -> (written: i64, err: Error) {
+	return _copy_buffer(dst, src, nil);
+}
+
+// copy_buffer is the same as copy except that it stages through the provided buffer (if one is required)
+// rather than allocating a temporary one on the stack through `intrinsics.alloca`
+// If buf is `nil`, it is allocate through `intrinsics.alloca`; otherwise if it has zero length, it will panic
+copy_buffer :: proc(dst: Writer, src: Reader, buf: []byte) -> (written: i64, err: Error) {
+	if buf != nil && len(buf) == 0 {
+		panic("empty buffer in io.copy_buffer");
+	}
+	return _copy_buffer(dst, src, buf);
+}
+
+
+
+// copy_n copies n bytes (or till an error) from src to dst.
+// It returns the number of bytes copied and the first error that occurred whilst copying, if any.
+// On return, written == n IFF err == nil
+copy_n :: proc(dst: Writer, src: Reader, n: i64) -> (written: i64, err: Error) {
+	nsrc := limited_reader_init(&Limited_Reader{}, src, n);
+	written, err = copy(dst, nsrc);
+	if written == n {
+		return n, nil;
+	}
+	if written < n && err == nil {
+		// src stopped early and must have been an EOF
+		err = .EOF;
+	}
+	return;
+}
+
+
+@(private)
+_copy_buffer :: proc(dst: Writer, src: Reader, buf: []byte) -> (written: i64, err: Error) {
+	if dst.stream_vtable == nil || src.stream_vtable == nil {
+		return 0, .Empty;
+	}
+	if src.impl_write_to != nil {
+		return src->impl_write_to(dst);
+	}
+	if src.impl_read_from != nil {
+		return dst->impl_read_from(src);
+	}
+	buf := buf;
+	if buf == nil {
+		DEFAULT_SIZE :: 4 * 1024;
+		size := DEFAULT_SIZE;
+		if src.stream_vtable == _limited_reader_vtable {
+			l := (^Limited_Reader)(src.stream_data);
+			if i64(size) > l.n {
+				if l.n < 1 {
+					size = 1;
+				} else {
+					size = int(l.n);
+				}
+			}
+		}
+		// NOTE(bill): alloca is fine here
+		buf = transmute([]byte)runtime.Raw_Slice{intrinsics.alloca(size, 2*align_of(rawptr)), size};
+	}
+	for {
+		nr, er := read(src, buf);
+		if nr > 0 {
+			nw, ew := write(dst, buf[0:nr]);
+			if nw > 0 {
+				written += i64(nw);
+			}
+			if ew != nil {
+				err = ew;
+				break;
+			}
+			if nr != nw {
+				err = .Short_Write;
+				break;
+			}
+		}
+		if er != nil {
+			if er != .EOF {
+				err = er;
+			}
+			break;
+		}
+	}
+	return;
+}

core/io/multi.odin

@@ -0,0 +1,95 @@
+package io
+
+Multi_Reader :: struct {
+	readers: [dynamic]Reader,
+}
+
+@(private)
+_multi_reader_vtable := &Stream_VTable{
+	impl_read = proc(s: Stream, p: []byte) -> (n: int, err: Error) {
+		mr := (^Multi_Reader)(s.stream_data);
+		for len(mr.readers) > 0 {
+			r := mr.readers[0];
+			n, err = read(r, p);
+			if err == .EOF {
+				ordered_remove(&mr.readers, 0);
+			}
+			if n > 0 || err != .EOF {
+				if err == .EOF && len(mr.readers) > 0 {
+					// Don't return EOF yet, more readers remain
+					err = nil;
+				}
+				return;
+			}
+		}
+		return 0, .EOF;
+	},
+};
+
+multi_reader_init :: proc(mr: ^Multi_Reader, readers: ..Reader, allocator := context.allocator) -> (r: Reader) {
+	all_readers := make([dynamic]Reader, 0, len(readers), allocator);
+
+	for w in readers {
+		if w.stream_vtable == _multi_reader_vtable {
+			other := (^Multi_Reader)(w.stream_data);
+			append(&all_readers, ..other.readers[:]);
+		} else {
+			append(&all_readers, w);
+		}
+	}
+
+	mr.readers = all_readers;
+
+	r.stream_vtable = _multi_reader_vtable;
+	r.stream_data = mr;
+	return;
+}
+
+multi_reader_destroy :: proc(mr: ^Multi_Reader) {
+	delete(mr.readers);
+}
+
+
+Multi_Writer :: struct {
+	writers: [dynamic]Writer,
+}
+
+@(private)
+_multi_writer_vtable := &Stream_VTable{
+	impl_write = proc(s: Stream, p: []byte) -> (n: int, err: Error) {
+		mw := (^Multi_Writer)(s.stream_data);
+		for w in mw.writers {
+			n, err = write(w, p);
+			if err != nil {
+				return;
+			}
+			if n != len(p) {
+				err = .Short_Write;
+				return;
+			}
+		}
+
+		return len(p), nil;
+	},
+};
+
+multi_writer_init :: proc(mw: ^Multi_Writer, writers: ..Writer, allocator := context.allocator) -> (out: Writer) {
+	mw.writers = make([dynamic]Writer, 0, len(writers), allocator);
+
+	for w in writers {
+		if w.stream_vtable == _multi_writer_vtable {
+			other := (^Multi_Writer)(w.stream_data);
+			append(&mw.writers, ..other.writers[:]);
+		} else {
+			append(&mw.writers, w);
+		}
+	}
+
+	out.stream_vtable = _multi_writer_vtable;
+	out.stream_data = mw;
+	return;
+}
+
+multi_writer_destroy :: proc(mw: ^Multi_Writer) {
+	delete(mw.writers);
+}

core/io/util.odin

@@ -0,0 +1,176 @@
+package io
+
+import "core:strconv"
+
+write_u64 :: proc(w: Writer, i: u64, base: int = 10) -> (n: int, err: Error) {
+	buf: [32]byte;
+	s := strconv.append_bits(buf[:], i, base, false, 64, strconv.digits, nil);
+	return write_string(w, s);
+}
+write_i64 :: proc(w: Writer, i: i64, base: int = 10) -> (n: int, err: Error) {
+	buf: [32]byte;
+	s := strconv.append_bits(buf[:], u64(i), base, true, 64, strconv.digits, nil);
+	return write_string(w, s);
+}
+
+write_uint :: proc(w: Writer, i: uint, base: int = 10) -> (n: int, err: Error) {
+	return write_u64(w, u64(i), base);
+}
+write_int :: proc(w: Writer, i: int, base: int = 10) -> (n: int, err: Error) {
+	return write_i64(w, i64(i), base);
+}
+
+Tee_Reader :: struct {
+	r: Reader,
+	w: Writer,
+}
+
+@(private)
+_tee_reader_vtable := &Stream_VTable{
+	impl_read = proc(s: Stream, p: []byte) -> (n: int, err: Error) {
+		t := (^Tee_Reader)(s.stream_data);
+		n, err = read(t.r, p);
+		if n > 0 {
+			if wn, werr := write(t.w, p[:n]); werr != nil {
+				return wn, werr;
+			}
+		}
+		return;
+	},
+};
+
+// tee_reader_init returns a Reader that writes to 'w' what it reads from 'r'
+// All reads from 'r' performed through it are matched with a corresponding write to 'w'
+// There is no internal buffering done
+// The write must complete before th read completes
+// Any error encountered whilst writing is reported as a 'read' error
+// tee_reader_init must call io.destroy when done with
+tee_reader_init :: proc(t: ^Tee_Reader, r: Reader, w: Writer, allocator := context.allocator) -> Reader {
+	t.r, t.w = r, w;
+	return tee_reader_to_reader(t);
+}
+
+tee_reader_to_reader :: proc(t: ^Tee_Reader) -> (r: Reader) {
+	r.stream_data = t;
+	r.stream_vtable = _tee_reader_vtable;
+	return;
+}
+
+
+// A Limited_Reader reads from r but limits the amount of data returned to just n bytes.
+// Each call to read updates n to reflect the new amount remaining.
+// read returns EOF when n <= 0 or when the underlying r returns EOF.
+Limited_Reader :: struct {
+	r: Reader, // underlying reader
+	n: i64,    // max_bytes
+}
+
+@(private)
+_limited_reader_vtable := &Stream_VTable{
+	impl_read = proc(s: Stream, p: []byte) -> (n: int, err: Error) {
+		l := (^Limited_Reader)(s.stream_data);
+		if l.n <= 0 {
+			return 0, .EOF;
+		}
+		p := p;
+		if i64(len(p)) > l.n {
+			p = p[0:l.n];
+		}
+		n, err = read(l.r, p);
+		l.n -= i64(n);
+		return;
+	},
+};
+
+limited_reader_init :: proc(l: ^Limited_Reader, r: Reader, n: i64) -> Reader {
+	l.r = r;
+	l.n = n;
+	return limited_reader_to_reader(l);
+}
+
+limited_reader_to_reader :: proc(l: ^Limited_Reader) -> (r: Reader) {
+	r.stream_vtable = _limited_reader_vtable;
+	r.stream_data = l;
+	return;
+}
+
+// Section_Reader implements read, seek, and read_at on a section of an underlying Reader_At
+Section_Reader :: struct {
+	r: Reader_At,
+	base:  i64,
+	off:   i64,
+	limit: i64,
+}
+
+section_reader_init :: proc(s: ^Section_Reader, r: Reader_At, off: i64, n: i64) {
+	s.r = r;
+	s.off = off;
+	s.limit = off + n;
+	return;
+}
+section_reader_to_stream :: proc(s: ^Section_Reader) -> (out: Stream) {
+	out.stream_data = s;
+	out.stream_vtable = _section_reader_vtable;
+	return;
+}
+
+@(private)
+_section_reader_vtable := &Stream_VTable{
+	impl_read = proc(stream: Stream, p: []byte) -> (n: int, err: Error) {
+		s := (^Section_Reader)(stream.stream_data);
+		if s.off >= s.limit {
+			return 0, .EOF;
+		}
+		p := p;
+		if max := s.limit - s.off; i64(len(p)) > max {
+			p = p[0:max];
+		}
+		n, err = read_at(s.r, p, s.off);
+		s.off += i64(n);
+		return;
+	},
+	impl_read_at = proc(stream: Stream, p: []byte, off: i64) -> (n: int, err: Error) {
+		s := (^Section_Reader)(stream.stream_data);
+		p, off := p, off;
+
+		if off < 0 || off >= s.limit - s.base {
+			return 0, .EOF;
+		}
+		off += s.base;
+		if max := s.limit - off; i64(len(p)) > max {
+			p = p[0:max];
+			n, err = read_at(s.r, p, off);
+			if err == nil {
+				err = .EOF;
+			}
+			return;
+		}
+		return read_at(s.r, p, off);
+	},
+	impl_seek = proc(stream: Stream, offset: i64, whence: Seek_From) -> (n: i64, err: Error) {
+		s := (^Section_Reader)(stream.stream_data);
+
+		offset := offset;
+		switch whence {
+		case:
+			return 0, .Invalid_Whence;
+		case .Start:
+			offset += s.base;
+		case .Current:
+			offset += s.off;
+		case .End:
+			offset += s.limit;
+		}
+		if offset < s.base {
+			return 0, .Invalid_Offset;
+		}
+		s.off = offset;
+		n = offset - s.base;
+		return;
+	},
+	impl_size = proc(stream: Stream) -> i64 {
+		s := (^Section_Reader)(stream.stream_data);
+		return s.limit - s.base;
+	},
+};
+

core/log/file_console_logger.odin

@@ -0,0 +1,162 @@
+package log
+
+import "core:fmt";
+import "core:strings";
+import "core:os";
+import "core:time";
+
+Level_Headers := [?]string{
+	 0..<10 = "[DEBUG] --- ",
+	10..<20 = "[INFO ] --- ",
+	20..<30 = "[WARN ] --- ",
+	30..<40 = "[ERROR] --- ",
+	40..<50 = "[FATAL] --- ",
+};
+
+Default_Console_Logger_Opts :: Options{
+	.Level,
+	.Terminal_Color,
+	.Short_File_Path,
+	.Line,
+	.Procedure,
+} | Full_Timestamp_Opts;
+
+Default_File_Logger_Opts :: Options{
+	.Level,
+	.Short_File_Path,
+	.Line,
+	.Procedure,
+} | Full_Timestamp_Opts;
+
+
+File_Console_Logger_Data :: struct {
+	file_handle:  os.Handle,
+	ident: string,
+}
+
+create_file_logger :: proc(h: os.Handle, lowest := Level.Debug, opt := Default_File_Logger_Opts, ident := "") -> Logger {
+	data := new(File_Console_Logger_Data);
+	data.file_handle = h;
+	data.ident = ident;
+	return Logger{file_console_logger_proc, data, lowest, opt};
+}
+
+destroy_file_logger :: proc(log: ^Logger) {
+	data := cast(^File_Console_Logger_Data)log.data;
+	if data.file_handle != os.INVALID_HANDLE {
+		os.close(data.file_handle);
+	}
+	free(data);
+}
+
+create_console_logger :: proc(lowest := Level.Debug, opt := Default_Console_Logger_Opts, ident := "") -> Logger {
+	data := new(File_Console_Logger_Data);
+	data.file_handle = os.INVALID_HANDLE;
+	data.ident = ident;
+	return Logger{file_console_logger_proc, data, lowest, opt};
+}
+
+destroy_console_logger :: proc(log: ^Logger) {
+	free(log.data);
+}
+
+file_console_logger_proc :: proc(logger_data: rawptr, level: Level, text: string, options: Options, location := #caller_location) {
+	data := cast(^File_Console_Logger_Data)logger_data;
+	h: os.Handle = os.stdout if level <= Level.Error else os.stderr;
+	if data.file_handle != os.INVALID_HANDLE {
+		h = data.file_handle;
+	}
+	backing: [1024]byte; //NOTE(Hoej): 1024 might be too much for a header backing, unless somebody has really long paths.
+	buf := strings.builder_from_slice(backing[:]);
+
+	do_level_header(options, level, &buf);
+
+	when time.IS_SUPPORTED {
+		if Full_Timestamp_Opts & options != nil {
+			fmt.sbprint(&buf, "[");
+			t := time.now();
+			y, m, d := time.date(t);
+			h, min, s := time.clock(t);
+			if .Date in options { fmt.sbprintf(&buf, "%d-%02d-%02d ", y, m, d);    }
+			if .Time in options { fmt.sbprintf(&buf, "%02d:%02d:%02d", h, min, s); }
+			fmt.sbprint(&buf, "] ");
+		}
+	}
+
+	do_location_header(options, &buf, location);
+
+	if .Thread_Id in options {
+		// NOTE(Oskar): not using context.thread_id here since that could be
+		// incorrect when replacing context for a thread.
+		fmt.sbprintf(&buf, "[{}] ", os.current_thread_id());
+	}
+
+	if data.ident != "" {
+		fmt.sbprintf(&buf, "[%s] ", data.ident);
+	}
+	//TODO(Hoej): When we have better atomics and such, make this thread-safe
+	fmt.fprintf(h, "%s %s\n", strings.to_string(buf), text);
+}
+
+do_level_header :: proc(opts: Options, level: Level, str: ^strings.Builder) {
+
+	RESET     :: "\x1b[0m";
+	RED       :: "\x1b[31m";
+	YELLOW    :: "\x1b[33m";
+	DARK_GREY :: "\x1b[90m";
+
+	col := RESET;
+	switch level {
+	case .Debug:   col = DARK_GREY;
+	case .Info:    col = RESET;
+	case .Warning: col = YELLOW;
+	case .Error, .Fatal: col = RED;
+	}
+
+	if .Level in opts {
+		if .Terminal_Color in opts {
+			fmt.sbprint(str, col);
+		}
+		fmt.sbprint(str, Level_Headers[level]);
+		if .Terminal_Color in opts {
+			fmt.sbprint(str, RESET);
+		}
+	}
+}
+
+do_location_header :: proc(opts: Options, buf: ^strings.Builder, location := #caller_location) {
+	if Location_Header_Opts & opts == nil {
+		return;
+	}
+	fmt.sbprint(buf, "[");
+
+	file := location.file_path;
+	if .Short_File_Path in opts {
+		last := 0;
+		for r, i in location.file_path {
+			if r == '/' {
+				last = i+1;
+			}
+		}
+		file = location.file_path[last:];
+	}
+
+	if Location_File_Opts & opts != nil {
+		fmt.sbprint(buf, file);
+	}
+	if .Line in opts {
+		if Location_File_Opts & opts != nil {
+			fmt.sbprint(buf, ":");
+		}
+		fmt.sbprint(buf, location.line);
+	}
+
+	if .Procedure in opts {
+		if (Location_File_Opts | {.Line}) & opts != nil {
+			fmt.sbprint(buf, ":");
+		}
+		fmt.sbprintf(buf, "%s()", location.procedure);
+	}
+
+	fmt.sbprint(buf, "] ");
+}

core/log/log.odin

@@ -0,0 +1,145 @@
+package log
+
+import "core:runtime"
+import "core:fmt"
+
+
+// NOTE(bill, 2019-12-31): These are defined in `package runtime` as they are used in the `context`. This is to prevent an import definition cycle.
+
+Level :: runtime.Logger_Level;
+/*
+Logger_Level :: enum {
+	Debug   = 0,
+	Info    = 10,
+	Warning = 20,
+	Error   = 30,
+	Fatal   = 40,
+}
+*/
+
+Option :: runtime.Logger_Option;
+/*
+Option :: enum {
+	Level,
+	Date,
+	Time,
+	Short_File_Path,
+	Long_File_Path,
+	Line,
+	Procedure,
+	Terminal_Color
+}
+*/
+
+Options :: runtime.Logger_Options;
+/*
+Options :: bit_set[Option];
+*/
+
+Full_Timestamp_Opts :: Options{
+	.Date,
+	.Time,
+};
+Location_Header_Opts :: Options{
+	.Short_File_Path,
+	.Long_File_Path,
+	.Line,
+	.Procedure,
+};
+Location_File_Opts :: Options{
+	.Short_File_Path,
+	.Long_File_Path,
+};
+
+
+Logger_Proc :: runtime.Logger_Proc;
+/*
+Logger_Proc :: #type proc(data: rawptr, level: Level, text: string, options: Options, location := #caller_location);
+*/
+
+Logger :: runtime.Logger;
+/*
+Logger :: struct {
+	procedure:    Logger_Proc,
+	data:      	  rawptr,
+	lowest_level: Level,
+	options:   	  Logger_Options,
+}
+*/
+
+nil_logger_proc :: proc(data: rawptr, level: Level, text: string, options: Options, location := #caller_location) {
+	// Do nothing
+}
+
+nil_logger :: proc() -> Logger {
+	return Logger{nil_logger_proc, nil, Level.Debug, nil};
+}
+
+// TODO(bill): Should these be redesigned so that they are do not rely upon `package fmt`?
+debugf :: proc(fmt_str: string, args: ..any, location := #caller_location) {
+	logf(level=.Debug,   fmt_str=fmt_str, args=args, location=location);
+}
+infof  :: proc(fmt_str: string, args: ..any, location := #caller_location) {
+	logf(level=.Info,    fmt_str=fmt_str, args=args, location=location);
+}
+warnf  :: proc(fmt_str: string, args: ..any, location := #caller_location) {
+	logf(level=.Warning, fmt_str=fmt_str, args=args, location=location);
+}
+errorf :: proc(fmt_str: string, args: ..any, location := #caller_location) {
+	logf(level=.Error,   fmt_str=fmt_str, args=args, location=location);
+}
+fatalf :: proc(fmt_str: string, args: ..any, location := #caller_location) {
+	logf(level=.Fatal,   fmt_str=fmt_str, args=args, location=location);
+}
+
+debug :: proc(args: ..any, sep := " ", location := #caller_location) {
+	log(level=.Debug,   args=args, sep=sep, location=location);
+}
+info  :: proc(args: ..any, sep := " ", location := #caller_location) {
+	log(level=.Info,    args=args, sep=sep, location=location);
+}
+warn  :: proc(args: ..any, sep := " ", location := #caller_location) {
+	log(level=.Warning, args=args, sep=sep, location=location);
+}
+error :: proc(args: ..any, sep := " ", location := #caller_location) {
+	log(level=.Error,   args=args, sep=sep, location=location);
+}
+fatal :: proc(args: ..any, sep := " ", location := #caller_location) {
+	log(level=.Fatal,   args=args, sep=sep, location=location);
+}
+
+panic :: proc(args: ..any, location := #caller_location) -> ! {
+	log(level=.Fatal, args=args, location=location);
+	runtime.panic("log.panic", location);
+}
+panicf :: proc(fmt_str: string, args: ..any, location := #caller_location) -> ! {
+	logf(level=.Fatal, fmt_str=fmt_str, args=args, location=location);
+	runtime.panic("log.panicf", location);
+}
+
+
+
+
+log :: proc(level: Level, args: ..any, sep := " ", location := #caller_location) {
+	logger := context.logger;
+	if logger.procedure == nil {
+		return;
+	}
+	if level < logger.lowest_level {
+		return;
+	}
+	str := fmt.tprint(args=args, sep=sep); //NOTE(Hoej): While tprint isn't thread-safe, no logging is.
+	logger.procedure(logger.data, level, str, logger.options, location);
+}
+
+logf :: proc(level: Level, fmt_str: string, args: ..any, location := #caller_location) {
+	logger := context.logger;
+	if logger.procedure == nil {
+		return;
+	}
+	if level < logger.lowest_level {
+		return;
+	}
+	str := fmt.tprintf(fmt_str, ..args);
+	logger.procedure(logger.data, level, str, logger.options, location);
+}

core/log/multi_logger.odin

@@ -0,0 +1,29 @@
+package log
+
+
+Multi_Logger_Data :: struct {
+	loggers: []Logger,
+}
+
+create_multi_logger :: proc(logs: ..Logger) -> Logger {
+	data := new(Multi_Logger_Data);
+	data.loggers = make([]Logger, len(logs));
+	copy(data.loggers, logs);
+	return Logger{multi_logger_proc, data, Level.Debug, nil};
+}
+
+destroy_multi_logger :: proc(log : ^Logger) {
+	free(log.data);
+	log^ = nil_logger();
+}
+
+multi_logger_proc :: proc(logger_data: rawptr, level: Level, text: string,
+                          options: Options, location := #caller_location) {
+	data := cast(^Multi_Logger_Data)logger_data;
+	for log in data.loggers {
+		if level < log.lowest_level {
+			return;
+		}
+		log.procedure(log.data, level, text, log.options, location);
+	}
+}

core/math.odin

@@ -1,366 +0,0 @@
-TAU          :: 6.28318530717958647692528676655900576;
-PI           :: 3.14159265358979323846264338327950288;
-ONE_OVER_TAU :: 0.636619772367581343075535053490057448;
-ONE_OVER_PI  :: 0.159154943091895335768883763372514362;
-
-E            :: 2.71828182845904523536;
-SQRT_TWO     :: 1.41421356237309504880168872420969808;
-SQRT_THREE   :: 1.73205080756887729352744634150587236;
-SQRT_FIVE    :: 2.23606797749978969640917366873127623;
-
-LOG_TWO      :: 0.693147180559945309417232121458176568;
-LOG_TEN      :: 2.30258509299404568401799145468436421;
-
-EPSILON      :: 1.19209290e-7;
-
-τ :: TAU;
-π :: PI;
-
-Vec2 :: [vector 2]f32;
-Vec3 :: [vector 3]f32;
-Vec4 :: [vector 4]f32;
-
-Mat2 :: [2]Vec2;
-Mat3 :: [3]Vec3;
-Mat4 :: [4]Vec4;
-
-sqrt32 :: proc(x: f32) -> f32 #foreign "llvm.sqrt.f32"
-sqrt64 :: proc(x: f64) -> f64 #foreign "llvm.sqrt.f64"
-
-sin32 :: proc(x: f32) -> f32 #foreign "llvm.sin.f32"
-sin64 :: proc(x: f64) -> f64 #foreign "llvm.sin.f64"
-
-cos32 :: proc(x: f32) -> f32 #foreign "llvm.cos.f32"
-cos64 :: proc(x: f64) -> f64 #foreign "llvm.cos.f64"
-
-tan32 :: proc(x: f32) -> f32 #inline { return sin32(x)/cos32(x); }
-tan64 :: proc(x: f64) -> f64 #inline { return sin64(x)/cos64(x); }
-
-lerp32 :: proc(a, b, t: f32) -> f32 { return a*(1-t) + b*t; }
-lerp64 :: proc(a, b, t: f64) -> f64 { return a*(1-t) + b*t; }
-
-sign32 :: proc(x: f32) -> f32 { if x >= 0 { return +1; } return -1; }
-sign64 :: proc(x: f64) -> f64 { if x >= 0 { return +1; } return -1; }
-
-
-
-copy_sign32 :: proc(x, y: f32) -> f32 {
-	ix := x transmute u32;
-	iy := y transmute u32;
-	ix &= 0x7fffffff;
-	ix |= iy & 0x80000000;
-	return ix transmute f32;
-}
-round32 :: proc(x: f32) -> f32 {
-	if x >= 0 {
-		return floor32(x + 0.5);
-	}
-	return ceil32(x - 0.5);
-}
-floor32 :: proc(x: f32) -> f32 {
-	if x >= 0 {
-		return x as int as f32;
-	}
-	return (x-0.5) as int as f32;
-}
-ceil32 :: proc(x: f32) -> f32 {
-	if x < 0 {
-		return x as int as f32;
-	}
-	return ((x as int)+1) as f32;
-}
-
-remainder32 :: proc(x, y: f32) -> f32 {
-	return x - round32(x/y) * y;
-}
-
-fmod32 :: proc(x, y: f32) -> f32 {
-	y = abs(y);
-	result := remainder32(abs(x), y);
-	if sign32(result) < 0 {
-		result += y;
-	}
-	return copy_sign32(result, x);
-}
-
-
-to_radians :: proc(degrees: f32) -> f32 { return degrees * TAU / 360; }
-to_degrees :: proc(radians: f32) -> f32 { return radians * 360 / TAU; }
-
-
-
-
-dot2 :: proc(a, b: Vec2) -> f32 { c := a*b; return c.x + c.y; }
-dot3 :: proc(a, b: Vec3) -> f32 { c := a*b; return c.x + c.y + c.z; }
-dot4 :: proc(a, b: Vec4) -> f32 { c := a*b; return c.x + c.y + c.z + c.w; }
-
-cross3 :: proc(x, y: Vec3) -> Vec3 {
-	a := swizzle(x, 1, 2, 0) * swizzle(y, 2, 0, 1);
-	b := swizzle(x, 2, 0, 1) * swizzle(y, 1, 2, 0);
-	return a - b;
-}
-
-
-vec2_mag :: proc(v: Vec2) -> f32 { return sqrt32(dot2(v, v)); }
-vec3_mag :: proc(v: Vec3) -> f32 { return sqrt32(dot3(v, v)); }
-vec4_mag :: proc(v: Vec4) -> f32 { return sqrt32(dot4(v, v)); }
-
-vec2_norm :: proc(v: Vec2) -> Vec2 { return v / Vec2{vec2_mag(v)}; }
-vec3_norm :: proc(v: Vec3) -> Vec3 { return v / Vec3{vec3_mag(v)}; }
-vec4_norm :: proc(v: Vec4) -> Vec4 { return v / Vec4{vec4_mag(v)}; }
-
-vec2_norm0 :: proc(v: Vec2) -> Vec2 {
-	m := vec2_mag(v);
-	if m == 0 {
-		return Vec2{0};
-	}
-	return v / Vec2{m};
-}
-
-vec3_norm0 :: proc(v: Vec3) -> Vec3 {
-	m := vec3_mag(v);
-	if m == 0 {
-		return Vec3{0};
-	}
-	return v / Vec3{m};
-}
-
-vec4_norm0 :: proc(v: Vec4) -> Vec4 {
-	m := vec4_mag(v);
-	if m == 0 {
-		return Vec4{0};
-	}
-	return v / Vec4{m};
-}
-
-
-
-mat4_identity :: proc() -> Mat4 {
-	return Mat4{
-		{1, 0, 0, 0},
-		{0, 1, 0, 0},
-		{0, 0, 1, 0},
-		{0, 0, 0, 1},
-	};
-}
-
-mat4_transpose :: proc(m: Mat4) -> Mat4 {
-	for j : 0..<4 {
-		for i : 0..<4 {
-			m[i][j], m[j][i] = m[j][i], m[i][j];
-		}
-	}
-	return m;
-}
-
-mat4_mul :: proc(a, b: Mat4) -> Mat4 {
-	c: Mat4;
-	for j : 0..<4 {
-		for i : 0..<4 {
-			c[j][i] = a[0][i]*b[j][0] +
-			          a[1][i]*b[j][1] +
-			          a[2][i]*b[j][2] +
-			          a[3][i]*b[j][3];
-		}
-	}
-	return c;
-}
-
-mat4_mul_vec4 :: proc(m: Mat4, v: Vec4) -> Vec4 {
-	return Vec4{
-		m[0][0]*v.x + m[1][0]*v.y + m[2][0]*v.z + m[3][0]*v.w,
-		m[0][1]*v.x + m[1][1]*v.y + m[2][1]*v.z + m[3][1]*v.w,
-		m[0][2]*v.x + m[1][2]*v.y + m[2][2]*v.z + m[3][2]*v.w,
-		m[0][3]*v.x + m[1][3]*v.y + m[2][3]*v.z + m[3][3]*v.w,
-	};
-}
-
-mat4_inverse :: proc(m: Mat4) -> Mat4 {
-	o: Mat4;
-
-	sf00 := m[2][2] * m[3][3] - m[3][2] * m[2][3];
-	sf01 := m[2][1] * m[3][3] - m[3][1] * m[2][3];
-	sf02 := m[2][1] * m[3][2] - m[3][1] * m[2][2];
-	sf03 := m[2][0] * m[3][3] - m[3][0] * m[2][3];
-	sf04 := m[2][0] * m[3][2] - m[3][0] * m[2][2];
-	sf05 := m[2][0] * m[3][1] - m[3][0] * m[2][1];
-	sf06 := m[1][2] * m[3][3] - m[3][2] * m[1][3];
-	sf07 := m[1][1] * m[3][3] - m[3][1] * m[1][3];
-	sf08 := m[1][1] * m[3][2] - m[3][1] * m[1][2];
-	sf09 := m[1][0] * m[3][3] - m[3][0] * m[1][3];
-	sf10 := m[1][0] * m[3][2] - m[3][0] * m[1][2];
-	sf11 := m[1][1] * m[3][3] - m[3][1] * m[1][3];
-	sf12 := m[1][0] * m[3][1] - m[3][0] * m[1][1];
-	sf13 := m[1][2] * m[2][3] - m[2][2] * m[1][3];
-	sf14 := m[1][1] * m[2][3] - m[2][1] * m[1][3];
-	sf15 := m[1][1] * m[2][2] - m[2][1] * m[1][2];
-	sf16 := m[1][0] * m[2][3] - m[2][0] * m[1][3];
-	sf17 := m[1][0] * m[2][2] - m[2][0] * m[1][2];
-	sf18 := m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-	o[0][0] = +(m[1][1] * sf00 - m[1][2] * sf01 + m[1][3] * sf02);
-	o[0][1] = -(m[1][0] * sf00 - m[1][2] * sf03 + m[1][3] * sf04);
-	o[0][2] = +(m[1][0] * sf01 - m[1][1] * sf03 + m[1][3] * sf05);
-	o[0][3] = -(m[1][0] * sf02 - m[1][1] * sf04 + m[1][2] * sf05);
-
-	o[1][0] = -(m[0][1] * sf00 - m[0][2] * sf01 + m[0][3] * sf02);
-	o[1][1] = +(m[0][0] * sf00 - m[0][2] * sf03 + m[0][3] * sf04);
-	o[1][2] = -(m[0][0] * sf01 - m[0][1] * sf03 + m[0][3] * sf05);
-	o[1][3] = +(m[0][0] * sf02 - m[0][1] * sf04 + m[0][2] * sf05);
-
-	o[2][0] = +(m[0][1] * sf06 - m[0][2] * sf07 + m[0][3] * sf08);
-	o[2][1] = -(m[0][0] * sf06 - m[0][2] * sf09 + m[0][3] * sf10);
-	o[2][2] = +(m[0][0] * sf11 - m[0][1] * sf09 + m[0][3] * sf12);
-	o[2][3] = -(m[0][0] * sf08 - m[0][1] * sf10 + m[0][2] * sf12);
-
-	o[3][0] = -(m[0][1] * sf13 - m[0][2] * sf14 + m[0][3] * sf15);
-	o[3][1] = +(m[0][0] * sf13 - m[0][2] * sf16 + m[0][3] * sf17);
-	o[3][2] = -(m[0][0] * sf14 - m[0][1] * sf16 + m[0][3] * sf18);
-	o[3][3] = +(m[0][0] * sf15 - m[0][1] * sf17 + m[0][2] * sf18);
-
-	ood := 1.0 / (m[0][0] * o[0][0] +
-	              m[0][1] * o[0][1] +
-	              m[0][2] * o[0][2] +
-	              m[0][3] * o[0][3]);
-
-	o[0][0] *= ood;
-	o[0][1] *= ood;
-	o[0][2] *= ood;
-	o[0][3] *= ood;
-	o[1][0] *= ood;
-	o[1][1] *= ood;
-	o[1][2] *= ood;
-	o[1][3] *= ood;
-	o[2][0] *= ood;
-	o[2][1] *= ood;
-	o[2][2] *= ood;
-	o[2][3] *= ood;
-	o[3][0] *= ood;
-	o[3][1] *= ood;
-	o[3][2] *= ood;
-	o[3][3] *= ood;
-
-	return o;
-}
-
-
-mat4_translate :: proc(v: Vec3) -> Mat4 {
-	m := mat4_identity();
-	m[3][0] = v.x;
-	m[3][1] = v.y;
-	m[3][2] = v.z;
-	m[3][3] = 1;
-	return m;
-}
-
-mat4_rotate :: proc(v: Vec3, angle_radians: f32) -> Mat4 {
-	c := cos32(angle_radians);
-	s := sin32(angle_radians);
-
-	a := vec3_norm(v);
-	t := a * Vec3{1-c};
-
-	rot := mat4_identity();
-
-	rot[0][0] = c + t.x*a.x;
-	rot[0][1] = 0 + t.x*a.y + s*a.z;
-	rot[0][2] = 0 + t.x*a.z - s*a.y;
-	rot[0][3] = 0;
-
-	rot[1][0] = 0 + t.y*a.x - s*a.z;
-	rot[1][1] = c + t.y*a.y;
-	rot[1][2] = 0 + t.y*a.z + s*a.x;
-	rot[1][3] = 0;
-
-	rot[2][0] = 0 + t.z*a.x + s*a.y;
-	rot[2][1] = 0 + t.z*a.y - s*a.x;
-	rot[2][2] = c + t.z*a.z;
-	rot[2][3] = 0;
-
-	return rot;
-}
-
-mat4_scale :: proc(m: Mat4, v: Vec3) -> Mat4 {
-	m[0][0] *= v.x;
-	m[1][1] *= v.y;
-	m[2][2] *= v.z;
-	return m;
-}
-
-mat4_scalef :: proc(m: Mat4, s: f32) -> Mat4 {
-	m[0][0] *= s;
-	m[1][1] *= s;
-	m[2][2] *= s;
-	return m;
-}
-
-
-mat4_look_at :: proc(eye, centre, up: Vec3) -> Mat4 {
-	f := vec3_norm(centre - eye);
-	s := vec3_norm(cross3(f, up));
-	u := cross3(s, f);
-
-	m: Mat4;
-
-	m[0] = Vec4{+s.x, +s.y, +s.z, 0};
-	m[1] = Vec4{+u.x, +u.y, +u.z, 0};
-	m[2] = Vec4{-f.x, -f.y, -f.z, 0};
-	m[3] = Vec4{dot3(s, eye), dot3(u, eye), dot3(f, eye), 1};
-
-	return m;
-}
-mat4_perspective :: proc(fovy, aspect, near, far: f32) -> Mat4 {
-	m: Mat4;
-	tan_half_fovy := tan32(0.5 * fovy);
-	m[0][0] = 1.0 / (aspect*tan_half_fovy);
-	m[1][1] = 1.0 / (tan_half_fovy);
-	m[2][2] = -(far + near) / (far - near);
-	m[2][3] = -1.0;
-	m[3][2] = -2.0*far*near / (far - near);
-	return m;
-}
-
-
-mat4_ortho3d :: proc(left, right, bottom, top, near, far: f32) -> Mat4 {
-	m := mat4_identity();
-	m[0][0] = +2.0 / (right - left);
-	m[1][1] = +2.0 / (top - bottom);
-	m[2][2] = -2.0 / (far - near);
-	m[3][0] = -(right + left)   / (right - left);
-	m[3][1] = -(top   + bottom) / (top   - bottom);
-	m[3][2] = -(far + near) / (far - near);
-	return m;
-}
-
-
-
-
-
-F32_DIG        :: 6;
-F32_EPSILON    :: 1.192092896e-07;
-F32_GUARD      :: 0;
-F32_MANT_DIG   :: 24;
-F32_MAX        :: 3.402823466e+38;
-F32_MAX_10_EXP :: 38;
-F32_MAX_EXP    :: 128;
-F32_MIN        :: 1.175494351e-38;
-F32_MIN_10_EXP :: -37;
-F32_MIN_EXP    :: -125;
-F32_NORMALIZE  :: 0;
-F32_RADIX      :: 2;
-F32_ROUNDS     :: 1;
-
-F64_DIG        :: 15;                       // # of decimal digits of precision
-F64_EPSILON    :: 2.2204460492503131e-016;  // smallest such that 1.0+F64_EPSILON != 1.0
-F64_MANT_DIG   :: 53;                       // # of bits in mantissa
-F64_MAX        :: 1.7976931348623158e+308;  // max value
-F64_MAX_10_EXP :: 308;                      // max decimal exponent
-F64_MAX_EXP    :: 1024;                     // max binary exponent
-F64_MIN        :: 2.2250738585072014e-308;  // min positive value
-F64_MIN_10_EXP :: -307;                     // min decimal exponent
-F64_MIN_EXP    :: -1021;                    // min binary exponent
-F64_RADIX      :: 2;                        // exponent radix
-F64_ROUNDS     :: 1;                        // addition rounding: near
-
-
-

core/math/bits/bits.odin

@@ -0,0 +1,656 @@
+package math_bits
+
+import "core:runtime"
+
+U8_MIN  :: 0;
+U16_MIN :: 0;
+U32_MIN :: 0;
+U64_MIN :: 0;
+
+U8_MAX  :: 1 <<  8 - 1;
+U16_MAX :: 1 << 16 - 1;
+U32_MAX :: 1 << 32 - 1;
+U64_MAX :: 1 << 64 - 1;
+
+I8_MIN  :: - 1 << 7;
+I16_MIN :: - 1 << 15;
+I32_MIN :: - 1 << 31;
+I64_MIN :: - 1 << 63;
+
+I8_MAX  :: 1 <<  7 - 1;
+I16_MAX :: 1 << 15 - 1;
+I32_MAX :: 1 << 31 - 1;
+I64_MAX :: 1 << 63 - 1;
+
+@(default_calling_convention="none")
+foreign {
+	@(link_name="llvm.ctpop.i8")        count_ones8  :: proc(i:  u8) ->  u8 ---
+	@(link_name="llvm.ctpop.i16")       count_ones16 :: proc(i: u16) -> u16 ---
+	@(link_name="llvm.ctpop.i32")       count_ones32 :: proc(i: u32) -> u32 ---
+	@(link_name="llvm.ctpop.i64")       count_ones64 :: proc(i: u64) -> u64 ---
+
+	@(link_name="llvm.cttz.i8")         trailing_zeros8  :: proc(i:  u8,  is_zero_undef := false) ->  u8 ---
+	@(link_name="llvm.cttz.i16")        trailing_zeros16 :: proc(i: u16,  is_zero_undef := false) -> u16 ---
+	@(link_name="llvm.cttz.i32")        trailing_zeros32 :: proc(i: u32,  is_zero_undef := false) -> u32 ---
+	@(link_name="llvm.cttz.i64")        trailing_zeros64 :: proc(i: u64,  is_zero_undef := false) -> u64 ---
+
+	@(link_name="llvm.bitreverse.i8")   reverse_bits8  :: proc(i:  u8) ->  u8 ---
+	@(link_name="llvm.bitreverse.i16")  reverse_bits16 :: proc(i: u16) -> u16 ---
+	@(link_name="llvm.bitreverse.i32")  reverse_bits32 :: proc(i: u32) -> u32 ---
+	@(link_name="llvm.bitreverse.i64")  reverse_bits64 :: proc(i: u64) -> u64 ---
+}
+
+
+trailing_zeros_uint :: proc(i: uint) -> uint {
+	when size_of(uint) == size_of(u64) {
+		return uint(trailing_zeros64(u64(i)));
+	} else {
+		return uint(trailing_zeros32(u32(i)));
+	}
+}
+
+
+leading_zeros_u8  :: proc(i:  u8) -> int {
+	return 8*size_of(i) - len_u8(i);
+}
+leading_zeros_u16 :: proc(i: u16) -> int {
+	return 8*size_of(i) - len_u16(i);
+}
+leading_zeros_u32 :: proc(i: u32) -> int {
+	return 8*size_of(i) - len_u32(i);
+}
+leading_zeros_u64 :: proc(i: u64) -> int {
+	return 8*size_of(i) - len_u64(i);
+}
+
+
+byte_swap_u16 :: proc(x: u16) -> u16 {
+	return runtime.bswap_16(x);
+}
+byte_swap_u32 :: proc(x: u32) -> u32 {
+	return runtime.bswap_32(x);
+}
+byte_swap_u64 :: proc(x: u64) -> u64 {
+	return runtime.bswap_64(x);
+}
+byte_swap_i16 :: proc(x: i16) -> i16 {
+	return i16(runtime.bswap_16(u16(x)));
+}
+byte_swap_i32 :: proc(x: i32) -> i32 {
+	return i32(runtime.bswap_32(u32(x)));
+}
+byte_swap_i64 :: proc(x: i64) -> i64 {
+	return i64(runtime.bswap_64(u64(x)));
+}
+byte_swap_u128 :: proc(x: u128) -> u128 {
+	return runtime.bswap_128(x);
+}
+byte_swap_i128 :: proc(x: i128) -> i128 {
+	return i128(runtime.bswap_128(u128(x)));
+}
+
+byte_swap_uint :: proc(i: uint) -> uint {
+	when size_of(uint) == size_of(u32) {
+		return uint(byte_swap_u32(u32(i)));
+	} else {
+		return uint(byte_swap_u64(u64(i)));
+	}
+}
+byte_swap_int :: proc(i: int) -> int {
+	when size_of(int) == size_of(i32) {
+		return int(byte_swap_i32(i32(i)));
+	} else {
+		return int(byte_swap_i64(i64(i)));
+	}
+}
+
+byte_swap :: proc{
+	byte_swap_u16,
+	byte_swap_u32,
+	byte_swap_u64,
+	byte_swap_u128,
+	byte_swap_i16,
+	byte_swap_i32,
+	byte_swap_i64,
+	byte_swap_i128,
+	byte_swap_uint,
+	byte_swap_int,
+};
+
+count_zeros8   :: proc(i:   u8) ->   u8 { return   8 - count_ones8(i); }
+count_zeros16  :: proc(i:  u16) ->  u16 { return  16 - count_ones16(i); }
+count_zeros32  :: proc(i:  u32) ->  u32 { return  32 - count_ones32(i); }
+count_zeros64  :: proc(i:  u64) ->  u64 { return  64 - count_ones64(i); }
+
+
+rotate_left8 :: proc(x: u8,  k: int) -> u8 {
+	n :: 8;
+	s := uint(k) & (n-1);
+	return x <<s | x>>(n-s);
+}
+rotate_left16 :: proc(x: u16, k: int) -> u16 {
+	n :: 16;
+	s := uint(k) & (n-1);
+	return x <<s | x>>(n-s);
+}
+rotate_left32 :: proc(x: u32, k: int) -> u32 {
+	n :: 32;
+	s := uint(k) & (n-1);
+	return x <<s | x>>(n-s);
+}
+rotate_left64 :: proc(x: u64, k: int) -> u64 {
+	n :: 64;
+	s := uint(k) & (n-1);
+	return x <<s | x>>(n-s);
+}
+
+rotate_left :: proc(x: uint, k: int) -> uint {
+	n :: 8*size_of(uint);
+	s := uint(k) & (n-1);
+	return x <<s | x>>(n-s);
+}
+
+from_be_u8   :: proc(i:   u8) ->   u8 { return i; }
+from_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+from_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+from_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+from_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+
+from_le_u8   :: proc(i:   u8) ->   u8 { return i; }
+from_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+from_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+from_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+from_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+
+to_be_u8   :: proc(i:   u8) ->   u8 { return i; }
+to_be_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+to_be_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+to_be_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+to_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "big" { return i; } else { return byte_swap(i); } }
+
+
+to_le_u8   :: proc(i:   u8) ->   u8 { return i; }
+to_le_u16  :: proc(i:  u16) ->  u16 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+to_le_u32  :: proc(i:  u32) ->  u32 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+to_le_u64  :: proc(i:  u64) ->  u64 { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+to_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i; } else { return byte_swap(i); } }
+
+
+@(default_calling_convention="none")
+foreign {
+	@(link_name="llvm.uadd.with.overflow.i8")  overflowing_add_u8  :: proc(lhs, rhs:  u8) -> (u8, bool)  ---
+	@(link_name="llvm.sadd.with.overflow.i8")  overflowing_add_i8  :: proc(lhs, rhs:  i8) -> (i8, bool)  ---
+	@(link_name="llvm.uadd.with.overflow.i16") overflowing_add_u16 :: proc(lhs, rhs: u16) -> (u16, bool) ---
+	@(link_name="llvm.sadd.with.overflow.i16") overflowing_add_i16 :: proc(lhs, rhs: i16) -> (i16, bool) ---
+	@(link_name="llvm.uadd.with.overflow.i32") overflowing_add_u32 :: proc(lhs, rhs: u32) -> (u32, bool) ---
+	@(link_name="llvm.sadd.with.overflow.i32") overflowing_add_i32 :: proc(lhs, rhs: i32) -> (i32, bool) ---
+	@(link_name="llvm.uadd.with.overflow.i64") overflowing_add_u64 :: proc(lhs, rhs: u64) -> (u64, bool) ---
+	@(link_name="llvm.sadd.with.overflow.i64") overflowing_add_i64 :: proc(lhs, rhs: i64) -> (i64, bool) ---
+}
+
+overflowing_add_uint :: proc(lhs, rhs: uint) -> (uint, bool) {
+	when size_of(uint) == size_of(u32) {
+		x, ok := overflowing_add_u32(u32(lhs), u32(rhs));
+		return uint(x), ok;
+	} else {
+		x, ok := overflowing_add_u64(u64(lhs), u64(rhs));
+		return uint(x), ok;
+	}
+}
+overflowing_add_int :: proc(lhs, rhs: int) -> (int, bool) {
+	when size_of(int) == size_of(i32) {
+		x, ok := overflowing_add_i32(i32(lhs), i32(rhs));
+		return int(x), ok;
+	} else {
+		x, ok := overflowing_add_i64(i64(lhs), i64(rhs));
+		return int(x), ok;
+	}
+}
+
+overflowing_add :: proc{
+	overflowing_add_u8,   overflowing_add_i8,
+	overflowing_add_u16,  overflowing_add_i16,
+	overflowing_add_u32,  overflowing_add_i32,
+	overflowing_add_u64,  overflowing_add_i64,
+	overflowing_add_uint, overflowing_add_int,
+};
+
+@(default_calling_convention="none")
+foreign {
+	@(link_name="llvm.usub.with.overflow.i8")  overflowing_sub_u8  :: proc(lhs, rhs:  u8) -> (u8, bool)  ---
+	@(link_name="llvm.ssub.with.overflow.i8")  overflowing_sub_i8  :: proc(lhs, rhs:  i8) -> (i8, bool)  ---
+	@(link_name="llvm.usub.with.overflow.i16") overflowing_sub_u16 :: proc(lhs, rhs: u16) -> (u16, bool) ---
+	@(link_name="llvm.ssub.with.overflow.i16") overflowing_sub_i16 :: proc(lhs, rhs: i16) -> (i16, bool) ---
+	@(link_name="llvm.usub.with.overflow.i32") overflowing_sub_u32 :: proc(lhs, rhs: u32) -> (u32, bool) ---
+	@(link_name="llvm.ssub.with.overflow.i32") overflowing_sub_i32 :: proc(lhs, rhs: i32) -> (i32, bool) ---
+	@(link_name="llvm.usub.with.overflow.i64") overflowing_sub_u64 :: proc(lhs, rhs: u64) -> (u64, bool) ---
+	@(link_name="llvm.ssub.with.overflow.i64") overflowing_sub_i64 :: proc(lhs, rhs: i64) -> (i64, bool) ---
+}
+overflowing_sub_uint :: proc(lhs, rhs: uint) -> (uint, bool) {
+	when size_of(uint) == size_of(u32) {
+		x, ok := overflowing_sub_u32(u32(lhs), u32(rhs));
+		return uint(x), ok;
+	} else {
+		x, ok := overflowing_sub_u64(u64(lhs), u64(rhs));
+		return uint(x), ok;
+	}
+}
+overflowing_sub_int :: proc(lhs, rhs: int) -> (int, bool) {
+	when size_of(int) == size_of(i32) {
+		x, ok := overflowing_sub_i32(i32(lhs), i32(rhs));
+		return int(x), ok;
+	} else {
+		x, ok := overflowing_sub_i64(i64(lhs), i64(rhs));
+		return int(x), ok;
+	}
+}
+
+overflowing_sub :: proc{
+	overflowing_sub_u8,   overflowing_sub_i8,
+	overflowing_sub_u16,  overflowing_sub_i16,
+	overflowing_sub_u32,  overflowing_sub_i32,
+	overflowing_sub_u64,  overflowing_sub_i64,
+	overflowing_sub_uint, overflowing_sub_int,
+};
+
+@(default_calling_convention="none")
+foreign {
+	@(link_name="llvm.umul.with.overflow.i8")  overflowing_mul_u8  :: proc(lhs, rhs:  u8) -> (u8, bool)  ---
+	@(link_name="llvm.smul.with.overflow.i8")  overflowing_mul_i8  :: proc(lhs, rhs:  i8) -> (i8, bool)  ---
+	@(link_name="llvm.umul.with.overflow.i16") overflowing_mul_u16 :: proc(lhs, rhs: u16) -> (u16, bool) ---
+	@(link_name="llvm.smul.with.overflow.i16") overflowing_mul_i16 :: proc(lhs, rhs: i16) -> (i16, bool) ---
+	@(link_name="llvm.umul.with.overflow.i32") overflowing_mul_u32 :: proc(lhs, rhs: u32) -> (u32, bool) ---
+	@(link_name="llvm.smul.with.overflow.i32") overflowing_mul_i32 :: proc(lhs, rhs: i32) -> (i32, bool) ---
+	@(link_name="llvm.umul.with.overflow.i64") overflowing_mul_u64 :: proc(lhs, rhs: u64) -> (u64, bool) ---
+	@(link_name="llvm.smul.with.overflow.i64") overflowing_mul_i64 :: proc(lhs, rhs: i64) -> (i64, bool) ---
+}
+overflowing_mul_uint :: proc(lhs, rhs: uint) -> (uint, bool) {
+	when size_of(uint) == size_of(u32) {
+		x, ok := overflowing_mul_u32(u32(lhs), u32(rhs));
+		return uint(x), ok;
+	} else {
+		x, ok := overflowing_mul_u64(u64(lhs), u64(rhs));
+		return uint(x), ok;
+	}
+}
+overflowing_mul_int :: proc(lhs, rhs: int) -> (int, bool) {
+	when size_of(int) == size_of(i32) {
+		x, ok := overflowing_mul_i32(i32(lhs), i32(rhs));
+		return int(x), ok;
+	} else {
+		x, ok := overflowing_mul_i64(i64(lhs), i64(rhs));
+		return int(x), ok;
+	}
+}
+
+overflowing_mul :: proc{
+	overflowing_mul_u8,   overflowing_mul_i8,
+	overflowing_mul_u16,  overflowing_mul_i16,
+	overflowing_mul_u32,  overflowing_mul_i32,
+	overflowing_mul_u64,  overflowing_mul_i64,
+	overflowing_mul_uint, overflowing_mul_int,
+};
+
+
+len_u8 :: proc(x: u8) -> int {
+	return int(len_u8_table[x]);
+}
+len_u16 :: proc(x: u16) -> (n: int) {
+	x := x;
+	if x >= 1<<8 {
+		x >>= 8;
+		n = 8;
+	}
+	return n + int(len_u8_table[x]);
+}
+len_u32 :: proc(x: u32) -> (n: int) {
+	x := x;
+	if x >= 1<<16 {
+		x >>= 16;
+		n = 16;
+	}
+	if x >= 1<<8 {
+		x >>= 8;
+		n += 8;
+	}
+	return n + int(len_u8_table[x]);
+}
+len_u64 :: proc(x: u64) -> (n: int) {
+	x := x;
+	if x >= 1<<32 {
+		x >>= 32;
+		n = 32;
+	}
+	if x >= 1<<16 {
+		x >>= 16;
+		n += 16;
+	}
+	if x >= 1<<8 {
+		x >>= 8;
+		n += 8;
+	}
+	return n + int(len_u8_table[x]);
+}
+len_uint :: proc(x: uint) -> (n: int) {
+	when size_of(uint) == size_of(u64) {
+		return len_u64(u64(x));
+	} else {
+		return len_u32(u32(x));
+	}
+}
+
+// returns the minimum number of bits required to represent x
+len :: proc{len_u8, len_u16, len_u32, len_u64, len_uint};
+
+
+add_u32 :: proc(x, y, carry: u32) -> (sum, carry_out: u32) {
+	yc := y + carry;
+	sum = x + yc;
+	if sum < x || yc < y {
+		carry_out = 1;
+	}
+	return;
+}
+add_u64 :: proc(x, y, carry: u64) -> (sum, carry_out: u64) {
+	yc := y + carry;
+	sum = x + yc;
+	if sum < x || yc < y {
+		carry_out = 1;
+	}
+	return;
+}
+add_uint :: proc(x, y, carry: uint) -> (sum, carry_out: uint) {
+	yc := y + carry;
+	sum = x + yc;
+	if sum < x || yc < y {
+		carry_out = 1;
+	}
+	return;
+}
+add :: proc{add_u32, add_u64, add_uint};
+
+
+sub_u32 :: proc(x, y, borrow: u32) -> (diff, borrow_out: u32) {
+	yb := y + borrow;
+	diff = x - yb;
+	if diff > x || yb < y {
+		borrow_out = 1;
+	}
+	return;
+}
+sub_u64 :: proc(x, y, borrow: u64) -> (diff, borrow_out: u64) {
+	yb := y + borrow;
+	diff = x - yb;
+	if diff > x || yb < y {
+		borrow_out = 1;
+	}
+	return;
+}
+sub_uint :: proc(x, y, borrow: uint) -> (diff, borrow_out: uint) {
+	yb := y + borrow;
+	diff = x - yb;
+	if diff > x || yb < y {
+		borrow_out = 1;
+	}
+	return;
+}
+sub :: proc{sub_u32, sub_u64, sub_uint};
+
+
+mul_u32 :: proc(x, y: u32) -> (hi, lo: u32) {
+	z := u64(x) * u64(y);
+	hi, lo = u32(z>>32), u32(z);
+	return;
+}
+mul_u64 :: proc(x, y: u64) -> (hi, lo: u64) {
+	mask :: 1<<32 - 1;
+
+	x0, x1 := x & mask, x >> 32;
+	y0, y1 := y & mask, y >> 32;
+
+	w0 := x0 * y0;
+	t := x1*y0 + w0>>32;
+
+	w1, w2 := t & mask, t >> 32;
+	w1 += x0 * y1;
+	hi = x1*y1 + w2 + w1>>32;
+	lo = x * y;
+	return;
+}
+
+mul_uint :: proc(x, y: uint) -> (hi, lo: uint) {
+	when size_of(uint) == size_of(u32) {
+		a, b := mul_u32(u32(x), u32(y));
+	} else {
+		#assert(size_of(uint) == size_of(u64));
+		a, b := mul_u64(u64(x), u64(y));
+	}
+	return uint(a), uint(b);
+}
+
+mul :: proc{mul_u32, mul_u64, mul_uint};
+
+
+div_u32 :: proc(hi, lo, y: u32) -> (quo, rem: u32) {
+	assert(y != 0 && y <= hi);
+	z := u64(hi)<<32 | u64(lo);
+	quo, rem = u32(z/u64(y)), u32(z%u64(y));
+	return;
+}
+div_u64 :: proc(hi, lo, y: u64) -> (quo, rem: u64) {
+	y := y;
+	two32  :: 1 << 32;
+	mask32 :: two32 - 1;
+	if y == 0 {
+		panic("divide error");
+	}
+	if y <= hi {
+		panic("overflow error");
+	}
+
+	s := uint(leading_zeros_u64(y));
+	y <<= s;
+
+	yn1 := y >> 32;
+	yn0 := y & mask32;
+	un32 := hi<<s | lo>>(64-s);
+	un10 := lo << s;
+	un1 := un10 >> 32;
+	un0 := un10 & mask32;
+	q1 := un32 / yn1;
+	rhat := un32 - q1*yn1;
+
+	for q1 >= two32 || q1*yn0 > two32*rhat+un1 {
+		q1 -= 1;
+		rhat += yn1;
+		if rhat >= two32 {
+			break;
+		}
+	}
+
+	un21 := un32*two32 + un1 - q1*y;
+	q0 := un21 / yn1;
+	rhat = un21 - q0*yn1;
+
+	for q0 >= two32 || q0*yn0 > two32*rhat+un0 {
+		q0 -= 1;
+		rhat += yn1;
+		if rhat >= two32 {
+			break;
+		}
+	}
+
+	return q1*two32 + q0, (un21*two32 + un0 - q0*y) >> s;
+}
+div_uint :: proc(hi, lo, y: uint) -> (quo, rem: uint) {
+	when size_of(uint) == size_of(u32) {
+		a, b := div_u32(u32(hi), u32(lo), u32(y));
+	} else {
+		#assert(size_of(uint) == size_of(u64));
+		a, b := div_u64(u64(hi), u64(lo), u64(y));
+	}
+	return uint(a), uint(b);
+}
+div :: proc{div_u32, div_u64, div_uint};
+
+
+
+is_power_of_two_u8   :: proc(i:   u8) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_i8   :: proc(i:   i8) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_u16  :: proc(i:  u16) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_i16  :: proc(i:  i16) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_u32  :: proc(i:  u32) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_i32  :: proc(i:  i32) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_u64  :: proc(i:  u64) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_i64  :: proc(i:  i64) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_uint :: proc(i: uint) -> bool { return i > 0 && (i & (i-1)) == 0; }
+is_power_of_two_int  :: proc(i:  int) -> bool { return i > 0 && (i & (i-1)) == 0; }
+
+is_power_of_two :: proc{
+	is_power_of_two_u8,   is_power_of_two_i8,
+	is_power_of_two_u16,  is_power_of_two_i16,
+	is_power_of_two_u32,  is_power_of_two_i32,
+	is_power_of_two_u64,  is_power_of_two_i64,
+	is_power_of_two_uint, is_power_of_two_int,
+};
+
+
+@private
+len_u8_table := [256]u8{
+	0         = 0,
+	1         = 1,
+	2..<4     = 2,
+	4..<8     = 3,
+	8..<16    = 4,
+	16..<32   = 5,
+	32..<64   = 6,
+	64..<128  = 7,
+	128..<256 = 8,
+};
+
+
+bitfield_extract_u8   :: proc(value:   u8, offset, bits: uint) ->   u8 { return (value >> offset) &   u8(1<<bits - 1); }
+bitfield_extract_u16  :: proc(value:  u16, offset, bits: uint) ->  u16 { return (value >> offset) &  u16(1<<bits - 1); }
+bitfield_extract_u32  :: proc(value:  u32, offset, bits: uint) ->  u32 { return (value >> offset) &  u32(1<<bits - 1); }
+bitfield_extract_u64  :: proc(value:  u64, offset, bits: uint) ->  u64 { return (value >> offset) &  u64(1<<bits - 1); }
+bitfield_extract_u128 :: proc(value: u128, offset, bits: uint) -> u128 { return (value >> offset) & u128(1<<bits - 1); }
+bitfield_extract_uint :: proc(value: uint, offset, bits: uint) -> uint { return (value >> offset) & uint(1<<bits - 1); }
+
+bitfield_extract_i8 :: proc(value: i8, offset, bits: uint) -> i8 {
+	v := (u8(value) >> offset) & u8(1<<bits - 1);
+	m := u8(1<<(bits-1));
+	r := (v~m) - m;
+	return i8(r);
+}
+bitfield_extract_i16 :: proc(value: i16, offset, bits: uint) -> i16 {
+	v := (u16(value) >> offset) & u16(1<<bits - 1);
+	m := u16(1<<(bits-1));
+	r := (v~m) - m;
+	return i16(r);
+}
+bitfield_extract_i32 :: proc(value: i32, offset, bits: uint) -> i32 {
+	v := (u32(value) >> offset) & u32(1<<bits - 1);
+	m := u32(1<<(bits-1));
+	r := (v~m) - m;
+	return i32(r);
+}
+bitfield_extract_i64 :: proc(value: i64, offset, bits: uint) -> i64 {
+	v := (u64(value) >> offset) & u64(1<<bits - 1);
+	m := u64(1<<(bits-1));
+	r := (v~m) - m;
+	return i64(r);
+}
+bitfield_extract_i128 :: proc(value: i128, offset, bits: uint) -> i128 {
+	v := (u128(value) >> offset) & u128(1<<bits - 1);
+	m := u128(1<<(bits-1));
+	r := (v~m) - m;
+	return i128(r);
+}
+bitfield_extract_int :: proc(value: int, offset, bits: uint) -> int {
+	v := (uint(value) >> offset) & uint(1<<bits - 1);
+	m := uint(1<<(bits-1));
+	r := (v~m) - m;
+	return int(r);
+}
+
+
+bitfield_extract :: proc{
+	bitfield_extract_u8,
+	bitfield_extract_u16,
+	bitfield_extract_u32,
+	bitfield_extract_u64,
+	bitfield_extract_u128,
+	bitfield_extract_uint,
+	bitfield_extract_i8,
+	bitfield_extract_i16,
+	bitfield_extract_i32,
+	bitfield_extract_i64,
+	bitfield_extract_i128,
+	bitfield_extract_int,
+};
+
+
+bitfield_insert_u8 :: proc(base, insert: u8, offset, bits: uint) -> u8 {
+	mask := u8(1<<bits - 1);
+	return (base &~ (mask<<offset)) | ((insert&mask) << offset);
+}
+bitfield_insert_u16 :: proc(base, insert: u16, offset, bits: uint) -> u16 {
+	mask := u16(1<<bits - 1);
+	return (base &~ (mask<<offset)) | ((insert&mask) << offset);
+}
+bitfield_insert_u32 :: proc(base, insert: u32, offset, bits: uint) -> u32 {
+	mask := u32(1<<bits - 1);
+	return (base &~ (mask<<offset)) | ((insert&mask) << offset);
+}
+bitfield_insert_u64 :: proc(base, insert: u64, offset, bits: uint) -> u64 {
+	mask := u64(1<<bits - 1);
+	return (base &~ (mask<<offset)) | ((insert&mask) << offset);
+}
+bitfield_insert_u128 :: proc(base, insert: u128, offset, bits: uint) -> u128 {
+	mask := u128(1<<bits - 1);
+	return (base &~ (mask<<offset)) | ((insert&mask) << offset);
+}
+bitfield_insert_uint :: proc(base, insert: uint, offset, bits: uint) -> uint {
+	mask := uint(1<<bits - 1);
+	return (base &~ (mask<<offset)) | ((insert&mask) << offset);
+}
+
+bitfield_insert_i8 :: proc(base, insert: i8, offset, bits: uint) -> i8 {
+	mask := i8(1<<bits - 1);
+	return (base &~ (mask<<offset)) | ((insert&mask) << offset);
+}
+bitfield_insert_i16 :: proc(base, insert: i16, offset, bits: uint) -> i16 {
+	mask := i16(1<<bits - 1);
+	return (base &~ (mask<<offset)) | ((insert&mask) << offset);
+}
+bitfield_insert_i32 :: proc(base, insert: i32, offset, bits: uint) -> i32 {
+	mask := i32(1<<bits - 1);
+	return (base &~ (mask<<offset)) | ((insert&mask) << offset);
+}
+bitfield_insert_i64 :: proc(base, insert: i64, offset, bits: uint) -> i64 {
+	mask := i64(1<<bits - 1);
+	return (base &~ (mask<<offset)) | ((insert&mask) << offset);
+}
+bitfield_insert_i128 :: proc(base, insert: i128, offset, bits: uint) -> i128 {
+	mask := i128(1<<bits - 1);
+	return (base &~ (mask<<offset)) | ((insert&mask) << offset);
+}
+bitfield_insert_int :: proc(base, insert: int, offset, bits: uint) -> int {
+	mask := int(1<<bits - 1);
+	return (base &~ (mask<<offset)) | ((insert&mask) << offset);
+}
+
+bitfield_insert :: proc{
+	bitfield_insert_u8,
+	bitfield_insert_u16,
+	bitfield_insert_u32,
+	bitfield_insert_u64,
+	bitfield_insert_u128,
+	bitfield_insert_uint,
+	bitfield_insert_i8,
+	bitfield_insert_i16,
+	bitfield_insert_i32,
+	bitfield_insert_i64,
+	bitfield_insert_i128,
+	bitfield_insert_int,
+};

core/math/fixed/fixed.odin

@@ -0,0 +1,133 @@
+package math_fixed
+
+import "core:math"
+import "core:strconv"
+
+import "intrinsics"
+_ :: intrinsics;
+
+Fixed :: struct($Backing: typeid, Fraction_Width: uint)
+	where
+		intrinsics.type_is_integer(Backing),
+		0 <= Fraction_Width,
+		Fraction_Width <= 8*size_of(Backing) {
+	i: Backing,
+}
+
+Fixed4_4  :: distinct Fixed(i8, 4);
+Fixed5_3  :: distinct Fixed(i8, 3);
+Fixed6_2  :: distinct Fixed(i8, 2);
+Fixed7_1  :: distinct Fixed(i8, 1);
+
+Fixed8_8  :: distinct Fixed(i16, 8);
+Fixed13_3 :: distinct Fixed(i16, 3);
+
+Fixed16_16 :: distinct Fixed(i32, 16);
+Fixed26_6  :: distinct Fixed(i32,  6);
+
+Fixed32_32 :: distinct Fixed(i64, 32);
+Fixed52_12 :: distinct Fixed(i64, 12);
+
+
+init_from_f64 :: proc(x: ^$T/Fixed($Backing, $Fraction_Width), val: f64) {
+	i, f := math.modf(val);
+	x.i  = Backing(f * (1<<Fraction_Width));
+	x.i &= 1<<Fraction_Width - 1;
+	x.i |= Backing(i) << Fraction_Width;
+}
+
+
+init_from_parts :: proc(x: ^$T/Fixed($Backing, $Fraction_Width), integer, fraction: Backing) {
+	i, f := math.modf(val);
+	x.i  = fraction;
+	x.i &= 1<<Fraction_Width - 1;
+	x.i |= integer;
+}
+
+to_f64 :: proc(x: $T/Fixed($Backing, $Fraction_Width)) -> f64 {
+	res := f64(x.i >> Fraction_Width);
+	res += f64(x.i & (1<<Fraction_Width-1)) / f64(1<<Fraction_Width);
+	return res;
+}
+
+
+add :: proc(x, y: $T/Fixed) -> T {
+	return {x.i + y.i};
+}
+sub :: proc(x, y: $T/Fixed) -> T {
+	return {x.i - y.i};
+}
+
+mul :: proc(x, y: $T/Fixed($Backing, $Fraction_Width)) -> (z: T) {
+	z.i = intrinsics.fixed_point_mul(x.i, y.i, Fraction_Width);
+	return;
+}
+mul_sat :: proc(x, y: $T/Fixed($Backing, $Fraction_Width)) -> (z: T) {
+	z.i = intrinsics.fixed_point_mul_sat(x.i, y.i, Fraction_Width);
+	return;
+}
+
+div :: proc(x, y: $T/Fixed($Backing, $Fraction_Width)) -> (z: T) {
+	z.i = intrinsics.fixed_point_div(x.i, y.i, Fraction_Width);
+	return;
+}
+div_sat :: proc(x, y: $T/Fixed($Backing, $Fraction_Width)) -> (z: T) {
+	z.i = intrinsics.fixed_point_div_sat(x.i, y.i, Fraction_Width);
+	return;
+}
+
+
+floor :: proc(x: $T/Fixed($Backing, $Fraction_Width)) -> Backing {
+	return x.i >> Fraction_Width;
+}
+ceil :: proc(x: $T/Fixed($Backing, $Fraction_Width)) -> Backing {
+	Integer :: 8*size_of(Backing) - Fraction_Width;
+	return (x.i + (1 << Integer-1)) >> Fraction_Width;
+}
+round :: proc(x: $T/Fixed($Backing, $Fraction_Width)) -> Backing {
+	Integer :: 8*size_of(Backing) - Fraction_Width;
+	return (x.i + (1 << (Integer - 1))) >> Fraction_Width;
+}
+
+
+
+append :: proc(dst: []byte, x: $T/Fixed($Backing, $Fraction_Width)) -> string {
+	x := x;
+	buf: [48]byte;
+	i := 0;
+	if x.i < 0 {
+		buf[i] = '-';
+		i += 1;
+		x.i = -x.i;
+	}
+
+	integer := x.i >> Fraction_Width;
+	fraction := x.i & (1<<Fraction_Width - 1);
+
+	s := strconv.append_uint(buf[i:], u64(integer), 10);
+	i += len(s);
+	if fraction != 0 {
+		buf[i] = '.';
+		i += 1;
+		for fraction > 0 {
+			fraction *= 10;
+			buf[i] = byte('0' + (fraction>>Fraction_Width));
+			i += 1;
+			fraction &= 1<<Fraction_Width - 1;
+		}
+	}
+
+
+
+	n := copy(dst, buf[:i]);
+	return string(dst[:i]);
+}
+
+
+to_string :: proc(x: $T/Fixed($Backing, $Fraction_Width), allocator := context.allocator) -> string {
+	buf: [48]byte;
+	s := append(buf[:], x);
+	str := make([]byte, len(s), allocator);
+	copy(str, s);
+	return string(str);
+}

core/math/linalg/extended.odin

@@ -0,0 +1,553 @@
+package linalg
+
+import "builtin"
+import "core:math"
+
+radians :: proc(degrees: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = degrees * RAD_PER_DEG;
+		}
+	} else {
+		out = degrees * RAD_PER_DEG;
+	}
+	return;
+}
+degrees :: proc(radians: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = radians * DEG_PER_RAD;
+		}
+	} else {
+		out = radians * DEG_PER_RAD;
+	}
+	return;
+}
+
+min_double :: proc(a, b: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = builtin.min(a[i], b[i]);
+		}
+	} else {
+		out = builtin.min(a, b);
+	}
+	return;
+}
+
+min_single :: proc(a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		N :: len(T);
+
+		when N == 1 {
+			out = a[0];
+		} else when N == 2 {
+			out = builtin.min(a[0], a[1]);
+		} else {
+			out = builtin.min(a[0], a[1]);
+			for i in 2..<N {
+				out = builtin.min(out, a[i]);
+			}
+		}
+	} else {
+		out = a;
+	}
+	return;
+}
+
+min_triple :: proc(a, b, c: $T) -> T where IS_NUMERIC(ELEM_TYPE(T)) {
+	return min_double(a, min_double(b, c));
+}
+
+min :: proc{min_single, min_double, min_triple};
+
+max_double :: proc(a, b: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = builtin.max(a[i], b[i]);
+		}
+	} else {
+		out = builtin.max(a, b);
+	}
+	return;
+}
+
+max_single :: proc(a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		N :: len(T);
+
+		when N == 1 {
+			out = a[0];
+		} else when N == 2 {
+			out = builtin.max(a[0], a[1]);
+		} else when N == 3 {
+			out = builtin.max(a[0], a[1], a[3]);
+		}else {
+			out = builtin.max(a[0], a[1]);
+			for i in 2..<N {
+				out = builtin.max(out, a[i]);
+			}
+		}
+	} else {
+		out = a;
+	}
+	return;
+}
+
+max_triple :: proc(a, b, c: $T) -> T where IS_NUMERIC(ELEM_TYPE(T)) {
+	return max_double(a, max_double(b, c));
+}
+
+max :: proc{max_single, max_double, max_triple};
+
+abs :: proc(a: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = builtin.abs(a[i]);
+		}
+	} else {
+		out = builtin.abs(a);
+	}
+	return;
+}
+
+sign :: proc(a: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = #force_inline math.sign(a[i]);
+		}
+	} else {
+		out = #force_inline math.sign(a);
+	}
+	return;
+}
+
+clamp :: proc(x, a, b: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = builtin.clamp(x[i], a[i], b[i]);
+		}
+	} else {
+		out = builtin.clamp(x, a, b);
+	}
+	return;
+}
+
+
+saturate :: proc(x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) {
+	return clamp(x, 0.0, 1.0);
+}
+
+lerp :: proc(a, b, t: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = a[i]*(1-t[i]) + b[i]*t[i];
+		}
+	} else {
+		out = a * (1.0 - t) + b * t;
+	}
+	return;
+}
+mix :: proc(a, b, t: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = a[i]*(1-t[i]) + b[i]*t[i];
+		}
+	} else {
+		out = a * (1.0 - t) + b * t;
+	}
+	return;
+}
+
+unlerp :: proc(a, b, x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) {
+	return (x - a) / (b - a);
+}
+
+step :: proc(e, x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = x[i] < e[i] ? 0.0 : 1.0;
+		}
+	} else {
+		out = x < e ? 0.0 : 1.0;
+	}
+	return;
+}
+
+smoothstep :: proc(e0, e1, x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) {
+	t := saturate(unlerp(e0, e1, x));
+	return t * t * (3.0 - 2.0 * t);
+}
+
+smootherstep :: proc(e0, e1, x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) {
+	t := saturate(unlerp(e0, e1, x));
+	return t * t * t * (t * (6*t - 15) + 10);
+}
+
+
+sqrt :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = math.sqrt(x[i]);
+		}
+	} else {
+		out = math.sqrt(x);
+	}
+	return;
+}
+
+inverse_sqrt :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = 1.0/math.sqrt(x[i]);
+		}
+	} else {
+		out = 1.0/math.sqrt(x);
+	}
+	return;
+}
+
+cos :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = math.cos(x[i]);
+		}
+	} else {
+		out = math.cos(x);
+	}
+	return;
+}
+
+sin :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = math.sin(x[i]);
+		}
+	} else {
+		out = math.sin(x);
+	}
+	return;
+}
+
+tan :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = math.tan(x[i]);
+		}
+	} else {
+		out = math.tan(x);
+	}
+	return;
+}
+
+acos :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = math.acos(x[i]);
+		}
+	} else {
+		out = math.acos(x);
+	}
+	return;
+}
+
+asin :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = math.asin(x[i]);
+		}
+	} else {
+		out = math.asin(x);
+	}
+	return;
+}
+
+atan :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = math.atan(x[i]);
+		}
+	} else {
+		out = math.atan(x);
+	}
+	return;
+}
+atan2 :: proc(y, x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = math.atan2(y[i], x[i]);
+		}
+	} else {
+		out = math.atan2(y, x);
+	}
+	return;
+}
+
+
+ln :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = math.ln(x[i]);
+		}
+	} else {
+		out = math.ln(x);
+	}
+	return;
+}
+
+log2 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = INVLN2 * math.ln(x[i]);
+		}
+	} else {
+		out = INVLN2 * math.ln(x);
+	}
+	return;
+}
+
+log10 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = INVLN10 * math.ln(x[i]);
+		}
+	} else {
+		out = INVLN10 * math.ln(x);
+	}
+	return;
+}
+
+log :: proc(x, b: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = math.ln(x[i]) / math.ln(cast(ELEM_TYPE(T))b[i]);
+		}
+	} else {
+		out = INVLN10 * math.ln(x) / math.ln(cast(ELEM_TYPE(T))b);
+	}
+	return;
+}
+
+exp :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = math.exp(x[i]);
+		}
+	} else {
+		out = math.exp(x);
+	}
+	return;
+}
+
+exp2 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = math.exp(LN2 * x[i]);
+		}
+	} else {
+		out = math.exp(LN2 * x);
+	}
+	return;
+}
+
+exp10 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = math.exp(LN10 * x[i]);
+		}
+	} else {
+		out = math.exp(LN10 * x);
+	}
+	return;
+}
+
+pow :: proc(x, e: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = math.pow(x[i], e[i]);
+		}
+	} else {
+		out = math.pow(x, e);
+	}
+	return;
+}
+
+
+ceil :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = #force_inline math.ceil(x[i]);
+		}
+	} else {
+		out = #force_inline math.ceil(x);
+	}
+	return;
+}
+
+floor :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = #force_inline math.floor(x[i]);
+		}
+	} else {
+		out = #force_inline math.floor(x);
+	}
+	return;
+}
+
+round :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) {
+	when IS_ARRAY(T) {
+		for i in 0..<len(T) {
+			out[i] = #force_inline math.round(x[i]);
+		}
+	} else {
+		out = #force_inline math.round(x);
+	}
+	return;
+}
+
+fract :: proc(x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) {
+	f := #force_inline floor(x);
+	return x - f;
+}
+
+mod :: proc(x, m: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) {
+	f := #force_inline floor(x / m);
+	return x - f * m;
+}
+
+
+face_forward :: proc(N, I, N_ref: $T) -> (out: T) where IS_ARRAY(T), IS_FLOAT(ELEM_TYPE(T)) {
+	return dot(N_ref, I) < 0 ? N : -N;
+}
+
+distance :: proc(p0, p1: $V/[$N]$E) -> E where IS_NUMERIC(E) {
+	return length(p1 - p0);
+}
+
+reflect :: proc(I, N: $T) -> (out: T) where IS_ARRAY(T), IS_FLOAT(ELEM_TYPE(T)) {
+	b := n * (2 * dot(n, i));
+	return i - b;
+}
+refract :: proc(I, N: $T) -> (out: T) where IS_ARRAY(T), IS_FLOAT(ELEM_TYPE(T)) {
+	dv := dot(n, i);
+	k := 1 - eta*eta - (1 - dv*dv);
+	a := i * eta;
+	b := n * eta*dv*math.sqrt(k);
+	return (a - b) * E(int(k >= 0));
+}
+
+
+
+
+is_nan_single :: proc(x: $T) -> bool where IS_FLOAT(T) {
+	return #force_inline math.is_nan(x);
+}
+
+is_nan_array :: proc(x: $A/[$N]$T) -> (out: [N]bool) where IS_FLOAT(T) {
+	for i in 0..<N {
+		out[i] = #force_inline is_nan(x[i]);
+	}
+	return;
+}
+
+is_inf_single :: proc(x: $T) -> bool where IS_FLOAT(T) {
+	return #force_inline math.is_inf(x);
+}
+
+is_inf_array :: proc(x: $A/[$N]$T) -> (out: [N]bool) where IS_FLOAT(T) {
+	for i in 0..<N {
+		out[i] = #force_inline is_inf(x[i]);
+	}
+	return;
+}
+
+classify_single :: proc(x: $T) -> math.Float_Class where IS_FLOAT(T) {
+	return #force_inline math.classify(x);
+}
+
+classify_array :: proc(x: $A/[$N]$T) -> (out: [N]math.Float_Class) where IS_FLOAT(T) {
+	for i in 0..<N {
+		out[i] = #force_inline classify_single(x[i]);
+	}
+	return;
+}
+
+is_nan :: proc{is_nan_single, is_nan_array};
+is_inf :: proc{is_inf_single, is_inf_array};
+classify :: proc{classify_single, classify_array};
+
+
+less_than_single          :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x < y; }
+less_than_equal_single    :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x <= y; }
+greater_than_single       :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x > y; }
+greater_than_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x >= y; }
+equal_single              :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x == y; }
+not_equal_single          :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x != y; }
+
+less_than_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) {
+	for i in 0..<N {
+		out[i] = x[i] < y[i];
+	}
+	return;
+}
+less_than_equal_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) {
+	for i in 0..<N {
+		out[i] = x[i] <= y[i];
+	}
+	return;
+}
+greater_than_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) {
+	for i in 0..<N {
+		out[i] = x[i] > y[i];
+	}
+	return;
+}
+greater_than_equal_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) {
+	for i in 0..<N {
+		out[i] = x[i] >= y[i];
+	}
+	return;
+}
+equal_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) {
+	for i in 0..<N {
+		out[i] = x[i] == y[i];
+	}
+	return;
+}
+not_equal_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) {
+	for i in 0..<N {
+		out[i] = x[i] != y[i];
+	}
+	return;
+}
+
+less_than          :: proc{less_than_single, less_than_array};
+less_than_equal    :: proc{less_than_equal_single, less_than_equal_array};
+greater_than       :: proc{greater_than_single, greater_than_array};
+greater_than_equal :: proc{greater_than_equal_single, greater_than_equal_array};
+equal              :: proc{equal_single, equal_array};
+not_equal          :: proc{not_equal_single, not_equal_array};
+
+any :: proc(x: $A/[$N]bool) -> (out: bool) {
+	for e in x {
+		if x {
+			return true;
+		}
+	}
+	return false;
+}
+all :: proc(x: $A/[$N]bool) -> (out: bool) {
+	for e in x {
+		if !e {
+			return false;
+		}
+	}
+	return true;
+}
+not :: proc(x: $A/[$N]bool) -> (out: A) {
+	for e, i in x {
+		out[i] = !e;
+	}
+	return;
+}

core/math/linalg/general.odin

@@ -0,0 +1,368 @@
+package linalg
+
+import "core:math"
+import "intrinsics"
+
+// Generic
+
+TAU          :: 6.28318530717958647692528676655900576;
+PI           :: 3.14159265358979323846264338327950288;
+
+E            :: 2.71828182845904523536;
+
+τ :: TAU;
+π :: PI;
+e :: E;
+
+SQRT_TWO     :: 1.41421356237309504880168872420969808;
+SQRT_THREE   :: 1.73205080756887729352744634150587236;
+SQRT_FIVE    :: 2.23606797749978969640917366873127623;
+
+LN2          :: 0.693147180559945309417232121458176568;
+LN10         :: 2.30258509299404568401799145468436421;
+
+MAX_F64_PRECISION :: 16; // Maximum number of meaningful digits after the decimal point for 'f64'
+MAX_F32_PRECISION ::  8; // Maximum number of meaningful digits after the decimal point for 'f32'
+
+RAD_PER_DEG :: TAU/360.0;
+DEG_PER_RAD :: 360.0/TAU;
+
+
+
+@private IS_NUMERIC :: intrinsics.type_is_numeric;
+@private IS_QUATERNION :: intrinsics.type_is_quaternion;
+@private IS_ARRAY :: intrinsics.type_is_array;
+@private IS_FLOAT :: intrinsics.type_is_float;
+@private BASE_TYPE :: intrinsics.type_base_type;
+@private ELEM_TYPE :: intrinsics.type_elem_type;
+
+
+scalar_dot :: proc(a, b: $T) -> T where IS_FLOAT(T), !IS_ARRAY(T) {
+	return a * b;
+}
+
+vector_dot :: proc(a, b: $T/[$N]$E) -> (c: E) where IS_NUMERIC(E) {
+	for i in 0..<N {
+		c += a[i] * b[i];
+	}
+	return;
+}
+quaternion64_dot :: proc(a, b: $T/quaternion64) -> (c: f16) {
+	return a.w*a.w + a.x*b.x + a.y*b.y + a.z*b.z;
+}
+quaternion128_dot :: proc(a, b: $T/quaternion128) -> (c: f32) {
+	return a.w*a.w + a.x*b.x + a.y*b.y + a.z*b.z;
+}
+quaternion256_dot :: proc(a, b: $T/quaternion256) -> (c: f64) {
+	return a.w*a.w + a.x*b.x + a.y*b.y + a.z*b.z;
+}
+
+dot :: proc{scalar_dot, vector_dot, quaternion64_dot, quaternion128_dot, quaternion256_dot};
+
+inner_product :: dot;
+outer_product :: proc(a: $A/[$M]$E, b: $B/[$N]E) -> (out: [M][N]E) where IS_NUMERIC(E) {
+	for i in 0..<M {
+		for j in 0..<N {
+			out[i][j] = a[i]*b[j];
+		}
+	}
+	return;
+}
+
+quaternion_inverse :: proc(q: $Q) -> Q where IS_QUATERNION(Q) {
+	return conj(q) * quaternion(1.0/dot(q, q), 0, 0, 0);
+}
+
+
+scalar_cross :: proc(a, b: $T) -> T where IS_FLOAT(T), !IS_ARRAY(T) {
+	return a * b;
+}
+
+vector_cross2 :: proc(a, b: $T/[2]$E) -> E where IS_NUMERIC(E) {
+	return a[0]*b[1] - b[0]*a[1];
+}
+
+vector_cross3 :: proc(a, b: $T/[3]$E) -> (c: T) where IS_NUMERIC(E) {
+	c[0] = a[1]*b[2] - b[1]*a[2];
+	c[1] = a[2]*b[0] - b[2]*a[0];
+	c[2] = a[0]*b[1] - b[0]*a[1];
+	return;
+}
+
+quaternion_cross :: proc(q1, q2: $Q) -> (q3: Q) where IS_QUATERNION(Q) {
+	q3.x = q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y;
+	q3.y = q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z;
+	q3.z = q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x;
+	q3.w = q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z;
+	return;
+}
+
+vector_cross :: proc{scalar_cross, vector_cross2, vector_cross3};
+cross :: proc{scalar_cross, vector_cross2, vector_cross3, quaternion_cross};
+
+vector_normalize :: proc(v: $T/[$N]$E) -> T where IS_NUMERIC(E) {
+	return v / length(v);
+}
+quaternion_normalize :: proc(q: $Q) -> Q where IS_QUATERNION(Q) {
+	return q/abs(q);
+}
+normalize :: proc{vector_normalize, quaternion_normalize};
+
+vector_normalize0 :: proc(v: $T/[$N]$E) -> T where IS_NUMERIC(E) {
+	m := length(v);
+	return 0 if m == 0 else v/m;
+}
+quaternion_normalize0 :: proc(q: $Q) -> Q  where IS_QUATERNION(Q) {
+	m := abs(q);
+	return 0 if m == 0 else q/m;
+}
+normalize0 :: proc{vector_normalize0, quaternion_normalize0};
+
+
+vector_length :: proc(v: $T/[$N]$E) -> E where IS_NUMERIC(E) {
+	return math.sqrt(dot(v, v));
+}
+
+vector_length2 :: proc(v: $T/[$N]$E) -> E where IS_NUMERIC(E) {
+	return dot(v, v);
+}
+
+quaternion_length :: proc(q: $Q) -> Q where IS_QUATERNION(Q) {
+	return abs(q);
+}
+
+quaternion_length2 :: proc(q: $Q) -> Q where IS_QUATERNION(Q) {
+	return dot(q, q);
+}
+
+scalar_triple_product :: proc(a, b, c: $T/[$N]$E) -> E where IS_NUMERIC(E) {
+	// a . (b x c)
+	// b . (c x a)
+	// c . (a x b)
+	return dot(a, cross(b, c));
+}
+
+vector_triple_product :: proc(a, b, c: $T/[$N]$E) -> T where IS_NUMERIC(E) {
+	// a x (b x c)
+	// (a . c)b - (a . b)c
+	return cross(a, cross(b, c));
+}
+
+
+length :: proc{vector_length, quaternion_length};
+length2 :: proc{vector_length2, quaternion_length2};
+
+projection :: proc(x, normal: $T/[$N]$E) -> T where IS_NUMERIC(E) {
+	return dot(x, normal) / dot(normal, normal) * normal;
+}
+
+identity :: proc($T: typeid/[$N][N]$E) -> (m: T) {
+	for i in 0..<N {
+		m[i][i] = E(1);
+	}
+	return m;
+}
+
+trace :: proc(m: $T/[$N][N]$E) -> (tr: E) {
+	for i in 0..<N {
+		tr += m[i][i];
+	}
+	return;
+}
+
+
+transpose :: proc(a: $T/[$N][$M]$E) -> (m: T) {
+	for j in 0..<M {
+		for i in 0..<N {
+			m[j][i] = a[i][j];
+		}
+	}
+	return;
+}
+
+matrix_mul :: proc(a, b: $M/[$N][N]$E) -> (c: M)
+	where !IS_ARRAY(E),
+		  IS_NUMERIC(E) {
+	for i in 0..<N {
+		for k in 0..<N {
+			for j in 0..<N {
+				c[k][i] += a[j][i] * b[k][j];
+			}
+		}
+	}
+	return;
+}
+
+matrix_comp_mul :: proc(a, b: $M/[$J][$I]$E) -> (c: M)
+	where !IS_ARRAY(E),
+	     IS_NUMERIC(E) {
+	for j in 0..<J {
+		for i in 0..<I {
+			c[j][i] = a[j][i] * b[j][i];
+		}
+	}
+	return;
+}
+
+matrix_mul_differ :: proc(a: $A/[$J][$I]$E, b: $B/[$K][J]E) -> (c: [K][I]E)
+	where !IS_ARRAY(E),
+		  IS_NUMERIC(E),
+		  I != K {
+	for k in 0..<K {
+		for j in 0..<J {
+			for i in 0..<I {
+				c[k][i] += a[j][i] * b[k][j];
+			}
+		}
+	}
+	return;
+}
+
+
+matrix_mul_vector :: proc(a: $A/[$I][$J]$E, b: $B/[I]E) -> (c: B)
+	where !IS_ARRAY(E),
+		  IS_NUMERIC(E) {
+	for i in 0..<I {
+		for j in 0..<J {
+			c[j] += a[i][j] * b[i];
+		}
+	}
+	return;
+}
+
+quaternion_mul_quaternion :: proc(q1, q2: $Q) -> Q where IS_QUATERNION(Q) {
+	return q1 * q2;
+}
+
+quaternion64_mul_vector3 :: proc(q: $Q/quaternion64, v: $V/[3]$F/f16) -> V {
+	Raw_Quaternion :: struct {xyz: [3]f16, r: f16};
+
+	q := transmute(Raw_Quaternion)q;
+	v := transmute([3]f16)v;
+
+	t := cross(2*q.xyz, v);
+	return V(v + q.r*t + cross(q.xyz, t));
+}
+quaternion128_mul_vector3 :: proc(q: $Q/quaternion128, v: $V/[3]$F/f32) -> V {
+	Raw_Quaternion :: struct {xyz: [3]f32, r: f32};
+
+	q := transmute(Raw_Quaternion)q;
+	v := transmute([3]f32)v;
+
+	t := cross(2*q.xyz, v);
+	return V(v + q.r*t + cross(q.xyz, t));
+}
+quaternion256_mul_vector3 :: proc(q: $Q/quaternion256, v: $V/[3]$F/f64) -> V {
+	Raw_Quaternion :: struct {xyz: [3]f64, r: f64};
+
+	q := transmute(Raw_Quaternion)q;
+	v := transmute([3]f64)v;
+
+	t := cross(2*q.xyz, v);
+	return V(v + q.r*t + cross(q.xyz, t));
+}
+quaternion_mul_vector3 :: proc{quaternion64_mul_vector3, quaternion128_mul_vector3, quaternion256_mul_vector3};
+
+mul :: proc{
+	matrix_mul,
+	matrix_mul_differ,
+	matrix_mul_vector,
+	quaternion64_mul_vector3,
+	quaternion128_mul_vector3,
+	quaternion256_mul_vector3,
+	quaternion_mul_quaternion,
+};
+
+vector_to_ptr :: proc(v: ^$V/[$N]$E) -> ^E where IS_NUMERIC(E), N > 0 #no_bounds_check {
+	return &v[0];
+}
+matrix_to_ptr :: proc(m: ^$A/[$I][$J]$E) -> ^E where IS_NUMERIC(E), I > 0, J > 0 #no_bounds_check {
+	return &m[0][0];
+}
+
+to_ptr :: proc{vector_to_ptr, matrix_to_ptr};
+
+
+
+
+
+// Splines
+
+vector_slerp :: proc(x, y: $T/[$N]$E, a: E) -> T {
+	cos_alpha := dot(x, y);
+	alpha := math.acos(cos_alpha);
+	sin_alpha := math.sin(alpha);
+
+	t1 := math.sin((1 - a) * alpha) / sin_alpha;
+	t2 := math.sin(a * alpha) / sin_alpha;
+
+	return x * t1 + y * t2;
+}
+
+catmull_rom :: proc(v1, v2, v3, v4: $T/[$N]$E, s: E) -> T {
+	s2 := s*s;
+	s3 := s2*s;
+
+	f1 := -s3 + 2 * s2 - s;
+	f2 := 3 * s3 - 5 * s2 + 2;
+	f3 := -3 * s3 + 4 * s2 + s;
+	f4 := s3 - s2;
+
+	return (f1 * v1 + f2 * v2 + f3 * v3 + f4 * v4) * 0.5;
+}
+
+hermite :: proc(v1, t1, v2, t2: $T/[$N]$E, s: E) -> T {
+	s2 := s*s;
+	s3 := s2*s;
+
+	f1 := 2 * s3 - 3 * s2 + 1;
+	f2 := -2 * s3 + 3 * s2;
+	f3 := s3 - 2 * s2 + s;
+	f4 := s3 - s2;
+
+	return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2;
+}
+
+cubic :: proc(v1, v2, v3, v4: $T/[$N]$E, s: E) -> T {
+	return ((v1 * s + v2) * s + v3) * s + v4;
+}
+
+
+
+array_cast :: proc(v: $A/[$N]$T, $Elem_Type: typeid) -> (w: [N]Elem_Type) {
+	for i in 0..<N {
+		w[i] = Elem_Type(v[i]);
+	}
+	return;
+}
+
+matrix_cast :: proc(v: $A/[$M][$N]$T, $Elem_Type: typeid) -> (w: [M][N]Elem_Type) {
+	for i in 0..<M {
+		for j in 0..<N {
+			w[i][j] = Elem_Type(v[i][j]);
+		}
+	}
+	return;
+}
+
+to_f32  :: #force_inline proc(v: $A/[$N]$T) -> [N]f32  { return array_cast(v, f32);  }
+to_f64  :: #force_inline proc(v: $A/[$N]$T) -> [N]f64  { return array_cast(v, f64);  }
+
+to_i8   :: #force_inline proc(v: $A/[$N]$T) -> [N]i8   { return array_cast(v, i8);   }
+to_i16  :: #force_inline proc(v: $A/[$N]$T) -> [N]i16  { return array_cast(v, i16);  }
+to_i32  :: #force_inline proc(v: $A/[$N]$T) -> [N]i32  { return array_cast(v, i32);  }
+to_i64  :: #force_inline proc(v: $A/[$N]$T) -> [N]i64  { return array_cast(v, i64);  }
+to_int  :: #force_inline proc(v: $A/[$N]$T) -> [N]int  { return array_cast(v, int);  }
+
+to_u8   :: #force_inline proc(v: $A/[$N]$T) -> [N]u8   { return array_cast(v, u8);   }
+to_u16  :: #force_inline proc(v: $A/[$N]$T) -> [N]u16  { return array_cast(v, u16);  }
+to_u32  :: #force_inline proc(v: $A/[$N]$T) -> [N]u32  { return array_cast(v, u32);  }
+to_u64  :: #force_inline proc(v: $A/[$N]$T) -> [N]u64  { return array_cast(v, u64);  }
+to_uint :: #force_inline proc(v: $A/[$N]$T) -> [N]uint { return array_cast(v, uint); }
+
+to_complex32     :: #force_inline proc(v: $A/[$N]$T) -> [N]complex32     { return array_cast(v, complex32);     }
+to_complex64     :: #force_inline proc(v: $A/[$N]$T) -> [N]complex64     { return array_cast(v, complex64);     }
+to_complex128    :: #force_inline proc(v: $A/[$N]$T) -> [N]complex128    { return array_cast(v, complex128);    }
+to_quaternion64  :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion64 { return array_cast(v, quaternion64); }
+to_quaternion128 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion128 { return array_cast(v, quaternion128); }
+to_quaternion256 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion256 { return array_cast(v, quaternion256); }

core/math/linalg/specific_euler_angles.odin

@@ -0,0 +1,127 @@
+package linalg
+
+Euler_Angle_Order :: enum {
+	// Tait-Bryan
+	XYZ,
+	XZY,
+	YXZ,
+	YZX,
+	ZXY,
+	ZYX,
+
+	// Proper Euler
+	XYX,
+	XZX,
+	YXY,
+	YZY,
+	ZXZ,
+	ZYZ,
+}
+
+
+quaternion_from_euler_angles       :: proc{quaternion_from_euler_angles_f16,       quaternion_from_euler_angles_f32,       quaternion_from_euler_angles_f64};
+quaternion_from_euler_angle_x      :: proc{quaternion_from_euler_angle_x_f16,      quaternion_from_euler_angle_x_f32,      quaternion_from_euler_angle_x_f64};
+quaternion_from_euler_angle_y      :: proc{quaternion_from_euler_angle_y_f16,      quaternion_from_euler_angle_y_f32,      quaternion_from_euler_angle_y_f64};
+quaternion_from_euler_angle_z      :: proc{quaternion_from_euler_angle_z_f16,      quaternion_from_euler_angle_z_f32,      quaternion_from_euler_angle_z_f64};
+quaternion_from_pitch_yaw_roll     :: proc{quaternion_from_pitch_yaw_roll_f16,     quaternion_from_pitch_yaw_roll_f32,     quaternion_from_pitch_yaw_roll_f64};
+
+euler_angles_from_quaternion       :: proc{euler_angles_from_quaternion_f16,       euler_angles_from_quaternion_f32,       euler_angles_from_quaternion_f64};
+euler_angles_xyz_from_quaternion   :: proc{euler_angles_xyz_from_quaternion_f16,   euler_angles_xyz_from_quaternion_f32,   euler_angles_xyz_from_quaternion_f64};
+euler_angles_yxz_from_quaternion   :: proc{euler_angles_yxz_from_quaternion_f16,   euler_angles_yxz_from_quaternion_f32,   euler_angles_yxz_from_quaternion_f64};
+euler_angles_xzx_from_quaternion   :: proc{euler_angles_xzx_from_quaternion_f16,   euler_angles_xzx_from_quaternion_f32,   euler_angles_xzx_from_quaternion_f64};
+euler_angles_xyx_from_quaternion   :: proc{euler_angles_xyx_from_quaternion_f16,   euler_angles_xyx_from_quaternion_f32,   euler_angles_xyx_from_quaternion_f64};
+euler_angles_yxy_from_quaternion   :: proc{euler_angles_yxy_from_quaternion_f16,   euler_angles_yxy_from_quaternion_f32,   euler_angles_yxy_from_quaternion_f64};
+euler_angles_yzy_from_quaternion   :: proc{euler_angles_yzy_from_quaternion_f16,   euler_angles_yzy_from_quaternion_f32,   euler_angles_yzy_from_quaternion_f64};
+euler_angles_zyz_from_quaternion   :: proc{euler_angles_zyz_from_quaternion_f16,   euler_angles_zyz_from_quaternion_f32,   euler_angles_zyz_from_quaternion_f64};
+euler_angles_zxz_from_quaternion   :: proc{euler_angles_zxz_from_quaternion_f16,   euler_angles_zxz_from_quaternion_f32,   euler_angles_zxz_from_quaternion_f64};
+euler_angles_xzy_from_quaternion   :: proc{euler_angles_xzy_from_quaternion_f16,   euler_angles_xzy_from_quaternion_f32,   euler_angles_xzy_from_quaternion_f64};
+euler_angles_yzx_from_quaternion   :: proc{euler_angles_yzx_from_quaternion_f16,   euler_angles_yzx_from_quaternion_f32,   euler_angles_yzx_from_quaternion_f64};
+euler_angles_zyx_from_quaternion   :: proc{euler_angles_zyx_from_quaternion_f16,   euler_angles_zyx_from_quaternion_f32,   euler_angles_zyx_from_quaternion_f64};
+euler_angles_zxy_from_quaternion   :: proc{euler_angles_zxy_from_quaternion_f16,   euler_angles_zxy_from_quaternion_f32,   euler_angles_zxy_from_quaternion_f64};
+
+roll_from_quaternion               :: proc{roll_from_quaternion_f16,               roll_from_quaternion_f32,               roll_from_quaternion_f64};
+pitch_from_quaternion              :: proc{pitch_from_quaternion_f16,              pitch_from_quaternion_f32,              pitch_from_quaternion_f64};
+yaw_from_quaternion                :: proc{yaw_from_quaternion_f16,                yaw_from_quaternion_f32,                yaw_from_quaternion_f64};
+pitch_yaw_roll_from_quaternion     :: proc{pitch_yaw_roll_from_quaternion_f16,     pitch_yaw_roll_from_quaternion_f32,     pitch_yaw_roll_from_quaternion_f64};
+
+matrix3_from_euler_angles          :: proc{matrix3_from_euler_angles_f16,          matrix3_from_euler_angles_f32,          matrix3_from_euler_angles_f64};
+matrix3_from_euler_angle_x         :: proc{matrix3_from_euler_angle_x_f16,         matrix3_from_euler_angle_x_f32,         matrix3_from_euler_angle_x_f64};
+matrix3_from_euler_angle_y         :: proc{matrix3_from_euler_angle_y_f16,         matrix3_from_euler_angle_y_f32,         matrix3_from_euler_angle_y_f64};
+matrix3_from_euler_angle_z         :: proc{matrix3_from_euler_angle_z_f16,         matrix3_from_euler_angle_z_f32,         matrix3_from_euler_angle_z_f64};
+matrix3_from_derived_euler_angle_x :: proc{matrix3_from_derived_euler_angle_x_f16, matrix3_from_derived_euler_angle_x_f32, matrix3_from_derived_euler_angle_x_f64};
+matrix3_from_derived_euler_angle_y :: proc{matrix3_from_derived_euler_angle_y_f16, matrix3_from_derived_euler_angle_y_f32, matrix3_from_derived_euler_angle_y_f64};
+matrix3_from_derived_euler_angle_z :: proc{matrix3_from_derived_euler_angle_z_f16, matrix3_from_derived_euler_angle_z_f32, matrix3_from_derived_euler_angle_z_f64};
+matrix3_from_euler_angles_xy       :: proc{matrix3_from_euler_angles_xy_f16,       matrix3_from_euler_angles_xy_f32,       matrix3_from_euler_angles_xy_f64};
+matrix3_from_euler_angles_yx       :: proc{matrix3_from_euler_angles_yx_f16,       matrix3_from_euler_angles_yx_f32,       matrix3_from_euler_angles_yx_f64};
+matrix3_from_euler_angles_xz       :: proc{matrix3_from_euler_angles_xz_f16,       matrix3_from_euler_angles_xz_f32,       matrix3_from_euler_angles_xz_f64};
+matrix3_from_euler_angles_zx       :: proc{matrix3_from_euler_angles_zx_f16,       matrix3_from_euler_angles_zx_f32,       matrix3_from_euler_angles_zx_f64};
+matrix3_from_euler_angles_yz       :: proc{matrix3_from_euler_angles_yz_f16,       matrix3_from_euler_angles_yz_f32,       matrix3_from_euler_angles_yz_f64};
+matrix3_from_euler_angles_zy       :: proc{matrix3_from_euler_angles_zy_f16,       matrix3_from_euler_angles_zy_f32,       matrix3_from_euler_angles_zy_f64};
+matrix3_from_euler_angles_xyz      :: proc{matrix3_from_euler_angles_xyz_f16,      matrix3_from_euler_angles_xyz_f32,      matrix3_from_euler_angles_xyz_f64};
+matrix3_from_euler_angles_yxz      :: proc{matrix3_from_euler_angles_yxz_f16,      matrix3_from_euler_angles_yxz_f32,      matrix3_from_euler_angles_yxz_f64};
+matrix3_from_euler_angles_xzx      :: proc{matrix3_from_euler_angles_xzx_f16,      matrix3_from_euler_angles_xzx_f32,      matrix3_from_euler_angles_xzx_f64};
+matrix3_from_euler_angles_xyx      :: proc{matrix3_from_euler_angles_xyx_f16,      matrix3_from_euler_angles_xyx_f32,      matrix3_from_euler_angles_xyx_f64};
+matrix3_from_euler_angles_yxy      :: proc{matrix3_from_euler_angles_yxy_f16,      matrix3_from_euler_angles_yxy_f32,      matrix3_from_euler_angles_yxy_f64};
+matrix3_from_euler_angles_yzy      :: proc{matrix3_from_euler_angles_yzy_f16,      matrix3_from_euler_angles_yzy_f32,      matrix3_from_euler_angles_yzy_f64};
+matrix3_from_euler_angles_zyz      :: proc{matrix3_from_euler_angles_zyz_f16,      matrix3_from_euler_angles_zyz_f32,      matrix3_from_euler_angles_zyz_f64};
+matrix3_from_euler_angles_zxz      :: proc{matrix3_from_euler_angles_zxz_f16,      matrix3_from_euler_angles_zxz_f32,      matrix3_from_euler_angles_zxz_f64};
+matrix3_from_euler_angles_xzy      :: proc{matrix3_from_euler_angles_xzy_f16,      matrix3_from_euler_angles_xzy_f32,      matrix3_from_euler_angles_xzy_f64};
+matrix3_from_euler_angles_yzx      :: proc{matrix3_from_euler_angles_yzx_f16,      matrix3_from_euler_angles_yzx_f32,      matrix3_from_euler_angles_yzx_f64};
+matrix3_from_euler_angles_zyx      :: proc{matrix3_from_euler_angles_zyx_f16,      matrix3_from_euler_angles_zyx_f32,      matrix3_from_euler_angles_zyx_f64};
+matrix3_from_euler_angles_zxy      :: proc{matrix3_from_euler_angles_zxy_f16,      matrix3_from_euler_angles_zxy_f32,      matrix3_from_euler_angles_zxy_f64};
+matrix3_from_yaw_pitch_roll        :: proc{matrix3_from_yaw_pitch_roll_f16,        matrix3_from_yaw_pitch_roll_f32,        matrix3_from_yaw_pitch_roll_f64};
+
+euler_angles_from_matrix3          :: proc{euler_angles_from_matrix3_f16,          euler_angles_from_matrix3_f32,          euler_angles_from_matrix3_f64};
+euler_angles_xyz_from_matrix3      :: proc{euler_angles_xyz_from_matrix3_f16,      euler_angles_xyz_from_matrix3_f32,      euler_angles_xyz_from_matrix3_f64};
+euler_angles_yxz_from_matrix3      :: proc{euler_angles_yxz_from_matrix3_f16,      euler_angles_yxz_from_matrix3_f32,      euler_angles_yxz_from_matrix3_f64};
+euler_angles_xzx_from_matrix3      :: proc{euler_angles_xzx_from_matrix3_f16,      euler_angles_xzx_from_matrix3_f32,      euler_angles_xzx_from_matrix3_f64};
+euler_angles_xyx_from_matrix3      :: proc{euler_angles_xyx_from_matrix3_f16,      euler_angles_xyx_from_matrix3_f32,      euler_angles_xyx_from_matrix3_f64};
+euler_angles_yxy_from_matrix3      :: proc{euler_angles_yxy_from_matrix3_f16,      euler_angles_yxy_from_matrix3_f32,      euler_angles_yxy_from_matrix3_f64};
+euler_angles_yzy_from_matrix3      :: proc{euler_angles_yzy_from_matrix3_f16,      euler_angles_yzy_from_matrix3_f32,      euler_angles_yzy_from_matrix3_f64};
+euler_angles_zyz_from_matrix3      :: proc{euler_angles_zyz_from_matrix3_f16,      euler_angles_zyz_from_matrix3_f32,      euler_angles_zyz_from_matrix3_f64};
+euler_angles_zxz_from_matrix3      :: proc{euler_angles_zxz_from_matrix3_f16,      euler_angles_zxz_from_matrix3_f32,      euler_angles_zxz_from_matrix3_f64};
+euler_angles_xzy_from_matrix3      :: proc{euler_angles_xzy_from_matrix3_f16,      euler_angles_xzy_from_matrix3_f32,      euler_angles_xzy_from_matrix3_f64};
+euler_angles_yzx_from_matrix3      :: proc{euler_angles_yzx_from_matrix3_f16,      euler_angles_yzx_from_matrix3_f32,      euler_angles_yzx_from_matrix3_f64};
+euler_angles_zyx_from_matrix3      :: proc{euler_angles_zyx_from_matrix3_f16,      euler_angles_zyx_from_matrix3_f32,      euler_angles_zyx_from_matrix3_f64};
+euler_angles_zxy_from_matrix3      :: proc{euler_angles_zxy_from_matrix3_f16,      euler_angles_zxy_from_matrix3_f32,      euler_angles_zxy_from_matrix3_f64};
+
+matrix4_from_euler_angles          :: proc{matrix4_from_euler_angles_f16,          matrix4_from_euler_angles_f32,          matrix4_from_euler_angles_f64};
+matrix4_from_euler_angle_x         :: proc{matrix4_from_euler_angle_x_f16,         matrix4_from_euler_angle_x_f32,         matrix4_from_euler_angle_x_f64};
+matrix4_from_euler_angle_y         :: proc{matrix4_from_euler_angle_y_f16,         matrix4_from_euler_angle_y_f32,         matrix4_from_euler_angle_y_f64};
+matrix4_from_euler_angle_z         :: proc{matrix4_from_euler_angle_z_f16,         matrix4_from_euler_angle_z_f32,         matrix4_from_euler_angle_z_f64};
+matrix4_from_derived_euler_angle_x :: proc{matrix4_from_derived_euler_angle_x_f16, matrix4_from_derived_euler_angle_x_f32, matrix4_from_derived_euler_angle_x_f64};
+matrix4_from_derived_euler_angle_y :: proc{matrix4_from_derived_euler_angle_y_f16, matrix4_from_derived_euler_angle_y_f32, matrix4_from_derived_euler_angle_y_f64};
+matrix4_from_derived_euler_angle_z :: proc{matrix4_from_derived_euler_angle_z_f16, matrix4_from_derived_euler_angle_z_f32, matrix4_from_derived_euler_angle_z_f64};
+matrix4_from_euler_angles_xy       :: proc{matrix4_from_euler_angles_xy_f16,       matrix4_from_euler_angles_xy_f32,       matrix4_from_euler_angles_xy_f64};
+matrix4_from_euler_angles_yx       :: proc{matrix4_from_euler_angles_yx_f16,       matrix4_from_euler_angles_yx_f32,       matrix4_from_euler_angles_yx_f64};
+matrix4_from_euler_angles_xz       :: proc{matrix4_from_euler_angles_xz_f16,       matrix4_from_euler_angles_xz_f32,       matrix4_from_euler_angles_xz_f64};
+matrix4_from_euler_angles_zx       :: proc{matrix4_from_euler_angles_zx_f16,       matrix4_from_euler_angles_zx_f32,       matrix4_from_euler_angles_zx_f64};
+matrix4_from_euler_angles_yz       :: proc{matrix4_from_euler_angles_yz_f16,       matrix4_from_euler_angles_yz_f32,       matrix4_from_euler_angles_yz_f64};
+matrix4_from_euler_angles_zy       :: proc{matrix4_from_euler_angles_zy_f16,       matrix4_from_euler_angles_zy_f32,       matrix4_from_euler_angles_zy_f64};
+matrix4_from_euler_angles_xyz      :: proc{matrix4_from_euler_angles_xyz_f16,      matrix4_from_euler_angles_xyz_f32,      matrix4_from_euler_angles_xyz_f64};
+matrix4_from_euler_angles_yxz      :: proc{matrix4_from_euler_angles_yxz_f16,      matrix4_from_euler_angles_yxz_f32,      matrix4_from_euler_angles_yxz_f64};
+matrix4_from_euler_angles_xzx      :: proc{matrix4_from_euler_angles_xzx_f16,      matrix4_from_euler_angles_xzx_f32,      matrix4_from_euler_angles_xzx_f64};
+matrix4_from_euler_angles_xyx      :: proc{matrix4_from_euler_angles_xyx_f16,      matrix4_from_euler_angles_xyx_f32,      matrix4_from_euler_angles_xyx_f64};
+matrix4_from_euler_angles_yxy      :: proc{matrix4_from_euler_angles_yxy_f16,      matrix4_from_euler_angles_yxy_f32,      matrix4_from_euler_angles_yxy_f64};
+matrix4_from_euler_angles_yzy      :: proc{matrix4_from_euler_angles_yzy_f16,      matrix4_from_euler_angles_yzy_f32,      matrix4_from_euler_angles_yzy_f64};
+matrix4_from_euler_angles_zyz      :: proc{matrix4_from_euler_angles_zyz_f16,      matrix4_from_euler_angles_zyz_f32,      matrix4_from_euler_angles_zyz_f64};
+matrix4_from_euler_angles_zxz      :: proc{matrix4_from_euler_angles_zxz_f16,      matrix4_from_euler_angles_zxz_f32,      matrix4_from_euler_angles_zxz_f64};
+matrix4_from_euler_angles_xzy      :: proc{matrix4_from_euler_angles_xzy_f16,      matrix4_from_euler_angles_xzy_f32,      matrix4_from_euler_angles_xzy_f64};
+matrix4_from_euler_angles_yzx      :: proc{matrix4_from_euler_angles_yzx_f16,      matrix4_from_euler_angles_yzx_f32,      matrix4_from_euler_angles_yzx_f64};
+matrix4_from_euler_angles_zyx      :: proc{matrix4_from_euler_angles_zyx_f16,      matrix4_from_euler_angles_zyx_f32,      matrix4_from_euler_angles_zyx_f64};
+matrix4_from_euler_angles_zxy      :: proc{matrix4_from_euler_angles_zxy_f16,      matrix4_from_euler_angles_zxy_f32,      matrix4_from_euler_angles_zxy_f64};
+matrix4_from_yaw_pitch_roll        :: proc{matrix4_from_yaw_pitch_roll_f16,        matrix4_from_yaw_pitch_roll_f32,        matrix4_from_yaw_pitch_roll_f64};
+
+euler_angles_from_matrix4          :: proc{euler_angles_from_matrix4_f16,          euler_angles_from_matrix4_f32,          euler_angles_from_matrix4_f64};
+euler_angles_xyz_from_matrix4      :: proc{euler_angles_xyz_from_matrix4_f16,      euler_angles_xyz_from_matrix4_f32,      euler_angles_xyz_from_matrix4_f64};
+euler_angles_yxz_from_matrix4      :: proc{euler_angles_yxz_from_matrix4_f16,      euler_angles_yxz_from_matrix4_f32,      euler_angles_yxz_from_matrix4_f64};
+euler_angles_xzx_from_matrix4      :: proc{euler_angles_xzx_from_matrix4_f16,      euler_angles_xzx_from_matrix4_f32,      euler_angles_xzx_from_matrix4_f64};
+euler_angles_xyx_from_matrix4      :: proc{euler_angles_xyx_from_matrix4_f16,      euler_angles_xyx_from_matrix4_f32,      euler_angles_xyx_from_matrix4_f64};
+euler_angles_yxy_from_matrix4      :: proc{euler_angles_yxy_from_matrix4_f16,      euler_angles_yxy_from_matrix4_f32,      euler_angles_yxy_from_matrix4_f64};
+euler_angles_yzy_from_matrix4      :: proc{euler_angles_yzy_from_matrix4_f16,      euler_angles_yzy_from_matrix4_f32,      euler_angles_yzy_from_matrix4_f64};
+euler_angles_zyz_from_matrix4      :: proc{euler_angles_zyz_from_matrix4_f16,      euler_angles_zyz_from_matrix4_f32,      euler_angles_zyz_from_matrix4_f64};
+euler_angles_zxz_from_matrix4      :: proc{euler_angles_zxz_from_matrix4_f16,      euler_angles_zxz_from_matrix4_f32,      euler_angles_zxz_from_matrix4_f64};
+euler_angles_xzy_from_matrix4      :: proc{euler_angles_xzy_from_matrix4_f16,      euler_angles_xzy_from_matrix4_f32,      euler_angles_xzy_from_matrix4_f64};
+euler_angles_yzx_from_matrix4      :: proc{euler_angles_yzx_from_matrix4_f16,      euler_angles_yzx_from_matrix4_f32,      euler_angles_yzx_from_matrix4_f64};
+euler_angles_zyx_from_matrix4      :: proc{euler_angles_zyx_from_matrix4_f16,      euler_angles_zyx_from_matrix4_f32,      euler_angles_zyx_from_matrix4_f64};
+euler_angles_zxy_from_matrix4      :: proc{euler_angles_zxy_from_matrix4_f16,      euler_angles_zxy_from_matrix4_f32,      euler_angles_zxy_from_matrix4_f64};

core/math/linalg/swizzle.odin

@@ -0,0 +1,222 @@
+package linalg
+
+Scalar_Components :: enum u8 {
+	x = 0,
+	r = 0,
+}
+
+Vector2_Components :: enum u8 {
+	x = 0,
+	y = 1,
+	r = 0,
+	g = 1,
+}
+
+Vector3_Components :: enum u8 {
+	x = 0,
+	y = 1,
+	z = 2,
+	r = 0,
+	g = 1,
+	b = 2,
+}
+
+Vector4_Components :: enum u8 {
+	x = 0,
+	y = 1,
+	z = 2,
+	w = 3,
+	r = 0,
+	g = 1,
+	b = 2,
+	a = 3,
+}
+
+scalar_f32_swizzle1 :: proc(f: f32, c0: Scalar_Components) -> f32 {
+	return f;
+}
+scalar_f32_swizzle2 :: proc(f: f32, c0, c1: Scalar_Components) -> Vector2f32 {
+	return {f, f};
+}
+scalar_f32_swizzle3 :: proc(f: f32, c0, c1, c2: Scalar_Components) -> Vector3f32 {
+	return {f, f, f};
+}
+scalar_f32_swizzle4 :: proc(f: f32, c0, c1, c2, c3: Scalar_Components) -> Vector4f32 {
+	return {f, f, f, f};
+}
+
+vector2f32_swizzle1 :: proc(v: Vector2f32, c0: Vector2_Components) -> f32 {
+	return v[c0];
+}
+vector2f32_swizzle2 :: proc(v: Vector2f32, c0, c1: Vector2_Components) -> Vector2f32 {
+	return {v[c0], v[c1]};
+}
+vector2f32_swizzle3 :: proc(v: Vector2f32, c0, c1, c2: Vector2_Components) -> Vector3f32 {
+	return {v[c0], v[c1], v[c2]};
+}
+vector2f32_swizzle4 :: proc(v: Vector2f32, c0, c1, c2, c3: Vector2_Components) -> Vector4f32 {
+	return {v[c0], v[c1], v[c2], v[c3]};
+}
+
+
+vector3f32_swizzle1 :: proc(v: Vector3f32, c0: Vector3_Components) -> f32 {
+	return v[c0];
+}
+vector3f32_swizzle2 :: proc(v: Vector3f32, c0, c1: Vector3_Components) -> Vector2f32 {
+	return {v[c0], v[c1]};
+}
+vector3f32_swizzle3 :: proc(v: Vector3f32, c0, c1, c2: Vector3_Components) -> Vector3f32 {
+	return {v[c0], v[c1], v[c2]};
+}
+vector3f32_swizzle4 :: proc(v: Vector3f32, c0, c1, c2, c3: Vector3_Components) -> Vector4f32 {
+	return {v[c0], v[c1], v[c2], v[c3]};
+}
+
+vector4f32_swizzle1 :: proc(v: Vector4f32, c0: Vector4_Components) -> f32 {
+	return v[c0];
+}
+vector4f32_swizzle2 :: proc(v: Vector4f32, c0, c1: Vector4_Components) -> Vector2f32 {
+	return {v[c0], v[c1]};
+}
+vector4f32_swizzle3 :: proc(v: Vector4f32, c0, c1, c2: Vector4_Components) -> Vector3f32 {
+	return {v[c0], v[c1], v[c2]};
+}
+vector4f32_swizzle4 :: proc(v: Vector4f32, c0, c1, c2, c3: Vector4_Components) -> Vector4f32 {
+	return {v[c0], v[c1], v[c2], v[c3]};
+}
+
+
+scalar_f64_swizzle1 :: proc(f: f64, c0: Scalar_Components) -> f64 {
+	return f;
+}
+scalar_f64_swizzle2 :: proc(f: f64, c0, c1: Scalar_Components) -> Vector2f64 {
+	return {f, f};
+}
+scalar_f64_swizzle3 :: proc(f: f64, c0, c1, c2: Scalar_Components) -> Vector3f64 {
+	return {f, f, f};
+}
+scalar_f64_swizzle4 :: proc(f: f64, c0, c1, c2, c3: Scalar_Components) -> Vector4f64 {
+	return {f, f, f, f};
+}
+
+vector2f64_swizzle1 :: proc(v: Vector2f64, c0: Vector2_Components) -> f64 {
+	return v[c0];
+}
+vector2f64_swizzle2 :: proc(v: Vector2f64, c0, c1: Vector2_Components) -> Vector2f64 {
+	return {v[c0], v[c1]};
+}
+vector2f64_swizzle3 :: proc(v: Vector2f64, c0, c1, c2: Vector2_Components) -> Vector3f64 {
+	return {v[c0], v[c1], v[c2]};
+}
+vector2f64_swizzle4 :: proc(v: Vector2f64, c0, c1, c2, c3: Vector2_Components) -> Vector4f64 {
+	return {v[c0], v[c1], v[c2], v[c3]};
+}
+
+
+vector3f64_swizzle1 :: proc(v: Vector3f64, c0: Vector3_Components) -> f64 {
+	return v[c0];
+}
+vector3f64_swizzle2 :: proc(v: Vector3f64, c0, c1: Vector3_Components) -> Vector2f64 {
+	return {v[c0], v[c1]};
+}
+vector3f64_swizzle3 :: proc(v: Vector3f64, c0, c1, c2: Vector3_Components) -> Vector3f64 {
+	return {v[c0], v[c1], v[c2]};
+}
+vector3f64_swizzle4 :: proc(v: Vector3f64, c0, c1, c2, c3: Vector3_Components) -> Vector4f64 {
+	return {v[c0], v[c1], v[c2], v[c3]};
+}
+
+vector4f64_swizzle1 :: proc(v: Vector4f64, c0: Vector4_Components) -> f64 {
+	return v[c0];
+}
+vector4f64_swizzle2 :: proc(v: Vector4f64, c0, c1: Vector4_Components) -> Vector2f64 {
+	return {v[c0], v[c1]};
+}
+vector4f64_swizzle3 :: proc(v: Vector4f64, c0, c1, c2: Vector4_Components) -> Vector3f64 {
+	return {v[c0], v[c1], v[c2]};
+}
+vector4f64_swizzle4 :: proc(v: Vector4f64, c0, c1, c2, c3: Vector4_Components) -> Vector4f64 {
+	return {v[c0], v[c1], v[c2], v[c3]};
+}
+
+
+
+
+scalar_swizzle :: proc{
+	scalar_f32_swizzle1,
+	scalar_f32_swizzle2,
+	scalar_f32_swizzle3,
+	scalar_f32_swizzle4,
+	scalar_f64_swizzle1,
+	scalar_f64_swizzle2,
+	scalar_f64_swizzle3,
+	scalar_f64_swizzle4,
+};
+
+vector2_swizzle :: proc{
+	vector2f32_swizzle1,
+	vector2f32_swizzle2,
+	vector2f32_swizzle3,
+	vector2f32_swizzle4,
+	vector2f64_swizzle1,
+	vector2f64_swizzle2,
+	vector2f64_swizzle3,
+	vector2f64_swizzle4,
+};
+
+vector3_swizzle :: proc{
+	vector3f32_swizzle1,
+	vector3f32_swizzle2,
+	vector3f32_swizzle3,
+	vector3f32_swizzle4,
+	vector3f64_swizzle1,
+	vector3f64_swizzle2,
+	vector3f64_swizzle3,
+	vector3f64_swizzle4,
+};
+
+vector4_swizzle :: proc{
+	vector4f32_swizzle1,
+	vector4f32_swizzle2,
+	vector4f32_swizzle3,
+	vector4f32_swizzle4,
+	vector4f64_swizzle1,
+	vector4f64_swizzle2,
+	vector4f64_swizzle3,
+	vector4f64_swizzle4,
+};
+
+swizzle :: proc{
+	scalar_f32_swizzle1,
+	scalar_f32_swizzle2,
+	scalar_f32_swizzle3,
+	scalar_f32_swizzle4,
+	scalar_f64_swizzle1,
+	scalar_f64_swizzle2,
+	scalar_f64_swizzle3,
+	scalar_f64_swizzle4,
+	vector2f32_swizzle1,
+	vector2f32_swizzle2,
+	vector2f32_swizzle3,
+	vector2f32_swizzle4,
+	vector2f64_swizzle1,
+	vector2f64_swizzle2,
+	vector2f64_swizzle3,
+	vector2f64_swizzle4,
+	vector3f32_swizzle1,
+	vector3f32_swizzle2,
+	vector3f32_swizzle3,
+	vector3f32_swizzle4,
+	vector3f64_swizzle1,
+	vector3f64_swizzle2,
+	vector3f64_swizzle3,
+	vector3f64_swizzle4,
+	vector4f32_swizzle1,
+	vector4f32_swizzle2,
+	vector4f32_swizzle3,
+	vector4f32_swizzle4,
+	vector4f64_swizzle1,
+	vector4f64_swizzle2,
+	vector4f64_swizzle3,
+	vector4f64_swizzle4,
+};