Correct index to offset calculation for matrix compound literals

`odin report` add Windows 10 Education Edition.

.github/workflows/ci.yml

@@ -10,12 +10,26 @@ jobs:
         run: sudo apt-get install llvm-11 clang-11 llvm
       - name: build odin
         run: make release
-      - name: Odin run
-        run: ./odin run examples/demo/demo.odin
-      - name: Odin check
-        run: ./odin check examples/demo/demo.odin -vet
       - name: Odin version
         run: ./odin version
+        timeout-minutes: 1
+      - name: Odin report
+        run: ./odin report
+        timeout-minutes: 1
+      - name: Odin check
+        run: ./odin check examples/demo/demo.odin -vet
+        timeout-minutes: 10
+      - name: Odin run
+        run: ./odin run examples/demo/demo.odin
+        timeout-minutes: 10
+      - name: Odin run -debug
+        run: ./odin run examples/demo/demo.odin -debug
+        timeout-minutes: 10
+      - name: Core library tests
+        run: |
+          cd tests/core
+          make
+        timeout-minutes: 10
   build_macOS:
     runs-on: macos-latest
     steps:
@@ -28,12 +42,21 @@ jobs:
           echo "CPATH=$TMP_PATH" >> $GITHUB_ENV
       - name: build odin
         run: make release
-      - name: Odin run
-        run: ./odin run examples/demo/demo.odin
-      - name: Odin check
-        run: ./odin check examples/demo/demo.odin -vet
       - name: Odin version
         run: ./odin version
+        timeout-minutes: 1
+      - name: Odin report
+        run: ./odin report
+        timeout-minutes: 1
+      - name: Odin check
+        run: ./odin check examples/demo/demo.odin -vet
+        timeout-minutes: 10
+      - name: Odin run
+        run: ./odin run examples/demo/demo.odin
+        timeout-minutes: 10
+      - name: Odin run -debug
+        run: ./odin run examples/demo/demo.odin -debug
+        timeout-minutes: 10
   build_windows:
     runs-on: windows-latest
     steps:
@@ -43,17 +66,41 @@ jobs:
         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 version
+        run: ./odin version
+        timeout-minutes: 1
+      - name: Odin report
+        run: ./odin report
+        timeout-minutes: 1
       - 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
-      - name: Odin version
-        run: ./odin version
-
-
+        timeout-minutes: 10
+      - 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
+        timeout-minutes: 10
+      - name: Odin run -debug
+        shell: cmd
+        run: |
+          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          odin run examples/demo/demo.odin -debug
+        timeout-minutes: 10
+      - name: Core library tests
+        shell: cmd
+        run: |
+          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          cd tests\core
+          call build.bat
+        timeout-minutes: 10
+      - name: core:math/big tests
+        shell: cmd
+        run: |
+          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+          cd tests\core\math\big
+          call build.bat
+        timeout-minutes: 10

.github/workflows/nightly.yml

@@ -28,6 +28,7 @@ jobs:
           cp LLVM-C.dll dist
           cp -r shared dist
           cp -r core dist
+          cp -r vendor dist
           cp -r bin dist
           cp -r examples dist
       - name: Upload artifact
@@ -51,6 +52,7 @@ jobs:
           cp odin dist
           cp -r shared dist
           cp -r core dist
+          cp -r vendor dist
           cp -r examples dist
       - name: Upload artifact
         uses: actions/upload-artifact@v1
@@ -77,6 +79,7 @@ jobs:
           cp odin dist
           cp -r shared dist
           cp -r core dist
+          cp -r vendor dist
           cp -r examples dist
       - name: Upload artifact
         uses: actions/upload-artifact@v1
@@ -90,7 +93,7 @@ jobs:
       - uses: actions/checkout@v1
       - uses: actions/setup-python@v2
         with:
-          python-version: '3.x'
+          python-version: '3.8.x'
 
       - name: Install B2 CLI
         shell: bash
@@ -124,16 +127,23 @@ jobs:
           BUCKET: ${{ secrets.B2_BUCKET }}
           DAYS_TO_KEEP: ${{ secrets.B2_DAYS_TO_KEEP }}
         run: |
+          echo Authorizing B2 account
           b2 authorize-account "$APPID" "$APPKEY"
-
+          
+          echo Uploading artifcates to B2
           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/
 
+          echo Deleting old artifacts in B2
           python3 ci/delete_old_binaries.py "$BUCKET" "$DAYS_TO_KEEP"
 
+          echo Creating nightly.json
           python3 ci/create_nightly_json.py "$BUCKET" > nightly.json
+          
+          echo Uploading nightly.json
           b2 upload-file "$BUCKET" nightly.json nightly.json
 
+          echo Clear B2 account info
           b2 clear-account

LICENSE

@@ -3,12 +3,16 @@ Copyright (c) 2016-2021 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:
 
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
 
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

Makefile

@@ -1,5 +1,5 @@
 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 -Wno-unused-value
+DISABLED_WARNINGS=-Wno-switch -Wno-macro-redefined -Wno-unused-value
 LDFLAGS=-pthread -ldl -lm -lstdc++
 CFLAGS=-std=c++14 -DGIT_SHA=\"$(GIT_SHA)\"
 CFLAGS:=$(CFLAGS) -DODIN_VERSION_RAW=\"dev-$(shell date +"%Y-%m")\"
@@ -8,31 +8,33 @@ CC=clang
 OS=$(shell uname)
 
 ifeq ($(OS), Darwin)
-	LLVM_CONFIG=llvm-config
-	ifneq ($(shell llvm-config --version | grep '^11\.'),)
-		LLVM_CONFIG=llvm-config
-	else
-		$(error "Requirement: llvm-config must be version 11")
-	endif
+    LLVM_CONFIG=llvm-config
+    ifneq ($(shell llvm-config --version | grep '^11\.'),)
+        LLVM_CONFIG=llvm-config
+    else
+        $(error "Requirement: llvm-config must be version 11")
+    endif
 
-	LDFLAGS:=$(LDFLAGS) -liconv
-	CFLAGS:=$(CFLAGS) $(shell $(LLVM_CONFIG) --cxxflags --ldflags)
-	LDFLAGS:=$(LDFLAGS) -lLLVM-C
+    LDFLAGS:=$(LDFLAGS) -liconv
+    CFLAGS:=$(CFLAGS) $(shell $(LLVM_CONFIG) --cxxflags --ldflags)
+    LDFLAGS:=$(LDFLAGS) -lLLVM-C
 endif
 ifeq ($(OS), Linux)
-	LLVM_CONFIG=llvm-config-11
-	ifneq ($(shell which llvm-config-11 2>/dev/null),)
-		LLVM_CONFIG=llvm-config-11
-	else
-		ifneq ($(shell llvm-config --version | grep '^11\.'),)
-			LLVM_CONFIG=llvm-config
-		else
-			$(error "Requirement: llvm-config must be version 11")
-		endif
-	endif
+    LLVM_CONFIG=llvm-config-11
+    ifneq ($(shell which llvm-config-11 2>/dev/null),)
+        LLVM_CONFIG=llvm-config-11
+    else ifneq ($(shell which llvm-config-11-64 2>/dev/null),)
+        LLVM_CONFIG=llvm-config-11-64
+    else
+        ifneq ($(shell llvm-config --version | grep '^11\.'),)
+            LLVM_CONFIG=llvm-config
+        else
+            $(error "Requirement: llvm-config must be version 11")
+        endif
+    endif
 
-	CFLAGS:=$(CFLAGS) $(shell $(LLVM_CONFIG) --cxxflags --ldflags)
-	LDFLAGS:=$(LDFLAGS) $(shell $(LLVM_CONFIG) --libs core native --system-libs)
+    CFLAGS:=$(CFLAGS) $(shell $(LLVM_CONFIG) --cxxflags --ldflags)
+    LDFLAGS:=$(LDFLAGS) $(shell $(LLVM_CONFIG) --libs core native --system-libs)
 endif
 
 all: debug demo
@@ -40,6 +42,9 @@ all: debug demo
 demo:
 	./odin run examples/demo/demo.odin
 
+report:
+	./odin report
+
 debug:
 	$(CC) src/main.cpp src/libtommath.cpp $(DISABLED_WARNINGS) $(CFLAGS) -g $(LDFLAGS) -o odin
 
@@ -51,6 +56,3 @@ release_native:
 
 nightly:
 	$(CC) src/main.cpp src/libtommath.cpp $(DISABLED_WARNINGS) $(CFLAGS) -DNIGHTLY -O3 $(LDFLAGS) -o odin
-
-
-

README.md

@@ -1,7 +1,7 @@
 <p align="center">
-    <img src="misc/logo-slim.png" alt="Odin logo" height="120">
+    <img src="misc/logo-slim.png" alt="Odin logo" style="width:65%">
     <br/>
-    A fast, concise, readable, pragmatic and open sourced programming language.
+   The Data-Oriented Language for Sane Software Development.
     <br/>
     <br/>
     <a href="https://github.com/odin-lang/odin/releases/latest">
@@ -21,11 +21,8 @@
 
 # The Odin Programming Language
 
-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
+
+Odin is a general-purpose programming language with distinct typing, built for high performance, modern systems, and built-in data-oriented data types. The Odin Programming Language, the C alternative for the joy of programming.
 
 Website: [https://odin-lang.org/](https://odin-lang.org/)
 
@@ -35,27 +32,26 @@ package main
 import "core:fmt"
 
 main :: proc() {
-	program := "+ + * 😃 - /";
-	accumulator := 0;
+	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 '+': 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);
+	           program, accumulator)
 }
 
 ```
 
-
 ## Documentation
 
 #### [Getting Started](https://odin-lang.org/docs/install)
@@ -82,7 +78,7 @@ Get live support and talk with other odiners on the Odin Discord.
 
 ### References
 
-#### [Language Specification](https://odin-lang.org/ref/spec)
+#### [Language Specification](https://odin-lang.org/docs/spec/)
 
 The official Odin Language specification.
 
@@ -92,80 +88,6 @@ The official Odin Language specification.
 
 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)
-    * 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)
-	* 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
-	- [Talk](https://youtu.be/TMCkT-uASaE?t=338)
-	- [Demo](https://youtu.be/TMCkT-uASaE?t=1800)
-	- [Q&A](https://youtu.be/TMCkT-uASaE?t=5749)
-* [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)
-* [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)
-

build.bat

@@ -3,7 +3,7 @@
 setlocal EnableDelayedExpansion
 
 for /f "usebackq tokens=1,2 delims=,=- " %%i in (`wmic os get LocalDateTime /value`) do @if %%i==LocalDateTime (
-     set CURR_DATE_TIME=%%j
+	set CURR_DATE_TIME=%%j
 )
 
 set curr_year=%CURR_DATE_TIME:~0,4%
@@ -23,9 +23,9 @@ if "%1" == "1" (
 
 :: Normal = 0, CI Nightly = 1
 if "%2" == "1" (
-    set nightly=1
+	set nightly=1
 ) else (
-    set nightly=0
+	set nightly=0
 )
 
 set odin_version_raw="dev-%curr_year%-%curr_month%"
@@ -46,12 +46,11 @@ if %release_mode% EQU 0 ( rem Debug
 
 set compiler_warnings= ^
 	-W4 -WX ^
-	-wd4100 -wd4101 -wd4127 -wd4146 -wd4189 ^
-	-wd4201 -wd4204 ^
-	-wd4456 -wd4457 -wd4480 ^
-	-wd4512
+	-wd4100 -wd4101 -wd4127 -wd4146 ^
+	-wd4456 -wd4457
 
-set compiler_includes=
+set compiler_includes= ^
+	/Isrc\
 set libs= ^
 	kernel32.lib ^
 	bin\llvm\windows\LLVM-C.lib
@@ -71,9 +70,12 @@ del *.pdb > NUL 2> NUL
 del *.ilk > NUL 2> NUL
 
 cl %compiler_settings% "src\main.cpp" "src\libtommath.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
+
+call build_vendor.bat
+if %errorlevel% neq 0 goto end_of_build
+
+if %release_mode% EQU 0 odin run examples/demo
 
 del *.obj > NUL 2> NUL
 

build_vendor.bat

@@ -0,0 +1,17 @@
+@echo off
+
+setlocal EnableDelayedExpansion
+
+rem build the .lib files already exist
+
+if not exist "vendor\stb\lib\*.lib" (
+	pushd vendor\stb\src
+		call build.bat
+	popd
+)
+
+if not exist "vendor\miniaudio\lib\*.lib" (
+	pushd vendor\miniaudio\src
+		call build.bat
+	popd
+)

ci/create_nightly_json.py

@@ -18,7 +18,7 @@ def main():
             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'])
+            size = int(data['size'])
             ts = int(data['fileInfo']['src_last_modified_millis'])
             date = datetime.datetime.fromtimestamp(ts/1000).strftime('%Y-%m-%d')
             

core/bufio/lookahead_reader.odin

@@ -14,14 +14,14 @@ Loadahead_Reader :: struct {
 }
 
 lookahead_reader_init :: proc(lr: ^Loadahead_Reader, r: io.Reader, buf: []byte) -> ^Loadahead_Reader {
-	lr.r = r;
-	lr.buf = buf;
-	lr.n = 0;
-	return lr;
+	lr.r = r
+	lr.buf = buf
+	lr.n = 0
+	return lr
 }
 
 lookahead_reader_buffer :: proc(lr: ^Loadahead_Reader) -> []byte {
-	return lr.buf[:lr.n];
+	return lr.buf[:lr.n]
 }
 
 
@@ -31,35 +31,35 @@ lookahead_reader_buffer :: proc(lr: ^Loadahead_Reader) -> []byte {
 lookahead_reader_peek :: proc(lr: ^Loadahead_Reader, n: int) -> ([]byte, io.Error) {
 	switch {
 	case n < 0:
-		return nil, .Negative_Read;
+		return nil, .Negative_Read
 	case n > len(lr.buf):
-		return nil, .Buffer_Full;
+		return nil, .Buffer_Full
 	}
 
-	n := n;
-	err: io.Error;
-	read_count: int;
+	n := n
+	err: io.Error
+	read_count: int
 
 	if lr.n < n {
-		read_count, err = io.read_at_least(lr.r, lr.buf[lr.n:], n-lr.n);
+		read_count, err = io.read_at_least(lr.r, lr.buf[lr.n:], n-lr.n)
 		if err == .Unexpected_EOF {
-			err = .EOF;
+			err = .EOF
 		}
 	}
 
-	lr.n += read_count;
+	lr.n += read_count
 
 	if n > lr.n {
-		n = lr.n;
+		n = lr.n
 	}
-	return lr.buf[:n], err;
+	return lr.buf[:n], err
 }
 
 // lookahead_reader_peek_all returns a slice of the Lookahead_Reader populating the full buffer
 // If the Lookahead_Reader cannot hold enough bytes, it will read from the underlying reader to populate the rest.
 // NOTE: The returned buffer is not a copy of the underlying buffer
 lookahead_reader_peek_all :: proc(lr: ^Loadahead_Reader) -> ([]byte, io.Error) {
-	return lookahead_reader_peek(lr, len(lr.buf));
+	return lookahead_reader_peek(lr, len(lr.buf))
 }
 
 
@@ -67,17 +67,17 @@ lookahead_reader_peek_all :: proc(lr: ^Loadahead_Reader) -> ([]byte, io.Error) {
 lookahead_reader_consume :: proc(lr: ^Loadahead_Reader, n: int) -> io.Error {
 	switch {
 	case n == 0:
-		return nil;
+		return nil
 	case n < 0:
-		return .Negative_Read;
+		return .Negative_Read
 	case lr.n < n:
-		return .Short_Buffer;
+		return .Short_Buffer
 	}
-	copy(lr.buf, lr.buf[n:lr.n]);
-	lr.n -= n;
-	return nil;
+	copy(lr.buf, lr.buf[n:lr.n])
+	lr.n -= n
+	return nil
 }
 
 lookahead_reader_consume_all :: proc(lr: ^Loadahead_Reader) -> io.Error {
-	return lookahead_reader_consume(lr, lr.n);
+	return lookahead_reader_consume(lr, lr.n)
 }

core/bufio/read_writer.odin

@@ -10,59 +10,59 @@ Read_Writer :: struct {
 
 
 read_writer_init :: proc(rw: ^Read_Writer, r: ^Reader, w: ^Writer) {
-	rw.r, rw.w = r, w;
+	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;
+	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);
+		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);
+		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);
+		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);
+		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);
+		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);
+		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);
+		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);
+		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);
+		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);
+		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);
+		b := (^Read_Writer)(s.stream_data).w
+		return writer_read_from(b, r)
 	},
-};
+}

core/bufio/reader.odin

@@ -22,85 +22,85 @@ Reader :: struct {
 }
 
 
-DEFAULT_BUF_SIZE :: 4096;
+DEFAULT_BUF_SIZE :: 4096
 
 @(private)
-MIN_READ_BUFFER_SIZE :: 16;
+MIN_READ_BUFFER_SIZE :: 16
 @(private)
-DEFAULT_MAX_CONSECUTIVE_EMPTY_READS :: 128;
+DEFAULT_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);
+	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_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^ = {};
+	delete(b.buf, b.buf_allocator)
+	b^ = {}
 }
 
 reader_size :: proc(b: ^Reader) -> int {
-	return len(b.buf);
+	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;
+	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;
+		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;
+		return .Buffer_Full
 	}
 
 	if b.max_consecutive_empty_reads <= 0 {
-		b.max_consecutive_empty_reads = DEFAULT_MAX_CONSECUTIVE_EMPTY_READS;
+		b.max_consecutive_empty_reads = DEFAULT_MAX_CONSECUTIVE_EMPTY_READS
 	}
 
 	// read new data, and try a limited number of times
 	for i := b.max_consecutive_empty_reads; i > 0; i -= 1 {
-		n, err := io.read(b.rd, b.buf[b.w:]);
+		n, err := io.read(b.rd, b.buf[b.w:])
 		if n < 0 {
-			return .Negative_Read;
+			return .Negative_Read
 		}
-		b.w += n;
+		b.w += n
 		if err != nil {
-			b.err = err;
-			return nil;
+			b.err = err
+			return nil
 		}
 		if n > 0 {
-			return nil;
+			return nil
 		}
 	}
-	b.err = .No_Progress;
-	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;
+	err := b.err
+	b.err = nil
+	return err
 }
 
 // reader_peek returns the next n bytes without advancing the reader
@@ -109,151 +109,151 @@ _reader_consume_err :: proc(b: ^Reader) -> io.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;
+	n := n
 
 	if n < 0 {
-		return nil, .Negative_Count;
+		return nil, .Negative_Count
 	}
-	b.last_byte = -1;
-	b.last_rune_size = -1;
+	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;
+			return nil, fill_err
 		}
 	}
 
 	if n > len(b.buf) {
-		return b.buf[b.r : b.w], .Buffer_Full;
+		return b.buf[b.r : b.w], .Buffer_Full
 	}
 
 	if available := b.w - b.r; available < n {
-		n = available;
-		err = _reader_consume_err(b);
+		n = available
+		err = _reader_consume_err(b)
 		if err == nil {
-			err = .Buffer_Full;
+			err = .Buffer_Full
 		}
 	}
 
-	return b.buf[b.r : b.r+n], err;
+	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;
+	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;
+		return 0, .Negative_Count
 	}
 	if n == 0 {
-		return;
+		return
 	}
 
-	remaining := n;
+	remaining := n
 	for {
-		skip := reader_buffered(b);
+		skip := reader_buffered(b)
 		if skip == 0 {
 			if fill_err := _reader_read_new_chunk(b); fill_err != nil {
-				return 0, fill_err;
+				return 0, fill_err
 			}
-			skip = reader_buffered(b);
+			skip = reader_buffered(b)
 		}
-		skip = min(skip, remaining);
-		b.r += skip;
-		remaining -= skip;
+		skip = min(skip, remaining)
+		b.r += skip
+		remaining -= skip
 		if remaining == 0 {
-			return n, nil;
+			return n, nil
 		}
 		if b.err != nil {
-			return n - remaining, _reader_consume_err(b);
+			return n - remaining, _reader_consume_err(b)
 		}
 	}
 
-	return;
+	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);
+	n = len(p)
 	if n == 0 {
 		if reader_buffered(b) > 0 {
-			return 0, nil;
+			return 0, nil
 		}
-		return 0, _reader_consume_err(b);
+		return 0, _reader_consume_err(b)
 	}
 	if b.r == b.w {
 		if b.err != nil {
-			return 0, _reader_consume_err(b);
+			return 0, _reader_consume_err(b)
 		}
 
 		if len(p) >= len(b.buf) {
-			n, b.err = io.read(b.rd, p);
+			n, b.err = io.read(b.rd, p)
 			if n < 0 {
-				return 0, .Negative_Read;
+				return 0, .Negative_Read
 			}
 
 			if n > 0 {
-				b.last_byte = int(p[n-1]);
-				b.last_rune_size = -1;
+				b.last_byte = int(p[n-1])
+				b.last_rune_size = -1
 			}
-			return n, _reader_consume_err(b);
+			return n, _reader_consume_err(b)
 		}
 
-		b.r, b.w = 0, 0;
-		n, b.err = io.read(b.rd, b.buf);
+		b.r, b.w = 0, 0
+		n, b.err = io.read(b.rd, b.buf)
 		if n < 0 {
-			return 0, .Negative_Read;
+			return 0, .Negative_Read
 		}
 		if n == 0 {
-			return 0, _reader_consume_err(b);
+			return 0, _reader_consume_err(b)
 		}
-		b.w += n;
+		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;
+	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;
+	b.last_rune_size = -1
 	for b.r == b.w {
 		if b.err != nil {
-			return 0, _reader_consume_err(b);
+			return 0, _reader_consume_err(b)
 		}
 		if err := _reader_read_new_chunk(b); err != nil {
-			return 0, err;
+			return 0, err
 		}
 	}
-	c := b.buf[b.r];
-	b.r += 1;
-	b.last_byte = int(c);
-	return c, nil;
+	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;
+		return .Invalid_Unread
 	}
 	if b.r > 0 {
-		b.r -= 1;
+		b.r -= 1
 	} else {
 		// b.r == 0 && b.w == 0
-		b.w = 1;
+		b.w = 1
 	}
-	b.buf[b.r] = byte(b.last_byte);
-	b.last_byte = -1;
-	b.last_rune_size = -1;
-	return nil;
+	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
@@ -265,96 +265,96 @@ reader_read_rune :: proc(b: ^Reader) -> (r: rune, size: int, err: io.Error) {
 	    b.err == nil &&
 	    b.w-b.w < len(b.buf) {
 		if err = _reader_read_new_chunk(b); err != nil {
-			return;
+			return
 		}
 	}
 
-	b.last_rune_size = -1;
+	b.last_rune_size = -1
 	if b.r == b.w {
-		err = _reader_consume_err(b);
-		return;
+		err = _reader_consume_err(b)
+		return
 	}
-	r, size = rune(b.buf[b.r]), 1;
+	r, size = rune(b.buf[b.r]), 1
 	if r >= utf8.RUNE_SELF {
-		r, size = utf8.decode_rune(b.buf[b.r : b.w]);
+		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;
+	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;
+		return .Invalid_Unread
 	}
-	b.r -= b.last_rune_size;
-	b.last_byte = -1;
-	b.last_rune_size = -1;
-	return nil;
+	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]);
+		n, err := io.write(w, b.buf[b.r:b.w])
 		if n < 0 {
-			return 0, .Negative_Write;
+			return 0, .Negative_Write
 		}
-		b.r += n;
-		return i64(n), err;
+		b.r += n
+		return i64(n), err
 	}
 
-	n, err = write_buf(b, w);
+	n, err = write_buf(b, w)
 	if err != nil {
-		return;
+		return
 	}
 
-	m: i64;
+	m: i64
 	if nr, ok := io.to_writer_to(b.rd); ok {
-		m, err = io.write_to(nr, w);
-		n += m;
-		return n, err;
+		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;
+		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;
+			return
 		}
 	}
 
 	for b.r < b.w {
-		m, err = write_buf(b, w);
-		n += m;
+		m, err = write_buf(b, w)
+		n += m
 		if err != nil {
-			return;
+			return
 		}
 		if err = _reader_read_new_chunk(b); err != nil {
-			return;
+			return
 		}
 	}
 
 	if b.err == .EOF {
-		b.err = nil;
+		b.err = nil
 	}
 
-	err = _reader_consume_err(b);
-	return;
+	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;
+	s.stream_data = b
+	s.stream_vtable = _reader_vtable
+	return
 }
 
 
@@ -362,35 +362,35 @@ reader_to_stream :: proc(b: ^Reader) -> (s: io.Stream) {
 @(private)
 _reader_vtable := &io.Stream_VTable{
 	impl_destroy = proc(s: io.Stream) -> io.Error {
-		b := (^Reader)(s.stream_data);
-		reader_destroy(b);
-		return nil;
+		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);
+		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);
+		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);
+		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);
+		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);
+		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);
+		b := (^Reader)(s.stream_data)
+		return reader_write_to(b, w)
 	},
-};
+}
 
 
 
@@ -410,71 +410,71 @@ _reader_vtable := &io.Stream_VTable{
 // 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;
+	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;
+			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;
+			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;
+			b.r = b.w
+			line = b.buf
+			err = .Buffer_Full
+			break
 		}
 
-		s = b.w - b.r;
+		s = b.w - b.r
 
 		if err = _reader_read_new_chunk(b); err != nil {
-			break;
+			break
 		}
 	}
 
 	if i := len(line)-1; i >= 0 {
-		b.last_byte = int(line[i]);
-		b.last_rune_size = -1;
+		b.last_byte = int(line[i])
+		b.last_rune_size = -1
 	}
 
-	return;
+	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;
+	full: [dynamic]byte
+	full.allocator = allocator
 
-	frag: []byte;
+	frag: []byte
 	for {
-		e: io.Error;
-		frag, e = reader_read_slice(b, delim);
+		e: io.Error
+		frag, e = reader_read_slice(b, delim)
 		if e == nil {
-			break;
+			break
 		}
 		if e != .Buffer_Full {
-			err = e;
-			break;
+			err = e
+			break
 		}
 
-		append(&full, ..frag);
+		append(&full, ..frag)
 	}
-	append(&full, ..frag);
-	return full[:], err;
+	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;
+	buf, err := reader_read_bytes(b, delim, allocator)
+	return string(buf), err
 }

core/bufio/scanner.odin

@@ -4,7 +4,7 @@ import "core:bytes"
 import "core:io"
 import "core:mem"
 import "core:unicode/utf8"
-import "intrinsics"
+import "core:intrinsics"
 
 // Extra errors returns by scanning procedures
 Scanner_Extra_Error :: enum i32 {
@@ -21,7 +21,7 @@ Scanner_Error :: union {
 }
 
 // Split_Proc is the signature of the split procedure used to tokenize the input.
-Split_Proc :: proc(data: []byte, at_eof: bool) -> (advance: int, token: []byte, err: Scanner_Error, final_token: bool);
+Split_Proc :: proc(data: []byte, at_eof: bool) -> (advance: int, token: []byte, err: Scanner_Error, final_token: bool)
 
 Scanner :: struct {
 	r:              io.Reader,
@@ -40,28 +40,28 @@ Scanner :: struct {
 	done:        bool,
 }
 
-DEFAULT_MAX_SCAN_TOKEN_SIZE :: 1<<16;
+DEFAULT_MAX_SCAN_TOKEN_SIZE :: 1<<16
 
 @(private)
-_INIT_BUF_SIZE :: 4096;
+_INIT_BUF_SIZE :: 4096
 
 scanner_init :: proc(s: ^Scanner, r: io.Reader, buf_allocator := context.allocator) -> ^Scanner {
-	s.r = r;
-	s.split = scan_lines;
-	s.max_token_size = DEFAULT_MAX_SCAN_TOKEN_SIZE;
-	s.buf.allocator = buf_allocator;
-	return s;
+	s.r = r
+	s.split = scan_lines
+	s.max_token_size = DEFAULT_MAX_SCAN_TOKEN_SIZE
+	s.buf.allocator = buf_allocator
+	return s
 }
 scanner_init_with_buffer :: proc(s: ^Scanner, r: io.Reader, buf: []byte) -> ^Scanner {
-	s.r = r;
-	s.split = scan_lines;
-	s.max_token_size = DEFAULT_MAX_SCAN_TOKEN_SIZE;
-	s.buf = mem.buffer_from_slice(buf);
-	resize(&s.buf, cap(s.buf));
-	return s;
+	s.r = r
+	s.split = scan_lines
+	s.max_token_size = DEFAULT_MAX_SCAN_TOKEN_SIZE
+	s.buf = mem.buffer_from_slice(buf)
+	resize(&s.buf, cap(s.buf))
+	return s
 }
 scanner_destroy :: proc(s: ^Scanner) {
-	delete(s.buf);
+	delete(s.buf)
 }
 
 
@@ -69,9 +69,9 @@ scanner_destroy :: proc(s: ^Scanner) {
 scanner_error :: proc(s: ^Scanner) -> Scanner_Error {
 	switch s._err {
 	case .EOF, .None:
-		return nil;
+		return nil
 	}
-	return s._err;
+	return s._err
 }
 
 // Returns the most recent token created by scanner_scan.
@@ -79,7 +79,7 @@ scanner_error :: proc(s: ^Scanner) -> Scanner_Error {
 // by another call to scanner_scan.
 // Treat the returned value as if it is immutable.
 scanner_bytes :: proc(s: ^Scanner) -> []byte {
-	return s.token;
+	return s.token
 }
 
 // Returns the most recent token created by scanner_scan.
@@ -87,146 +87,146 @@ scanner_bytes :: proc(s: ^Scanner) -> []byte {
 // by another call to scanner_scan.
 // Treat the returned value as if it is immutable.
 scanner_text :: proc(s: ^Scanner) -> string {
-	return string(s.token);
+	return string(s.token)
 }
 
 // scanner_scan advances the scanner
 scanner_scan :: proc(s: ^Scanner) -> bool {
 	set_err :: proc(s: ^Scanner, err: Scanner_Error) {
-		err := err;
+		err := err
 		if err == .None {
-			err = nil;
+			err = nil
 		}
 		switch s._err {
 		case nil, .EOF:
-			s._err = err;
+			s._err = err
 		}
 	}
 
 	if s.done {
-		return false;
+		return false
 	}
-	s.scan_called = true;
+	s.scan_called = true
 
 	for {
 		// Check if a token is possible with what is available
 		// Allow the split procedure to recover if it fails
 		if s.start < s.end || s._err != nil {
-			advance, token, err, final_token := s.split(s.buf[s.start:s.end], s._err != nil);
+			advance, token, err, final_token := s.split(s.buf[s.start:s.end], s._err != nil)
 			if final_token {
-				s.token = token;
-				s.done = true;
-				return true;
+				s.token = token
+				s.done = true
+				return true
 			}
 			if err != nil {
-				set_err(s, err);
-				return false;
+				set_err(s, err)
+				return false
 			}
 
 			// Do advance
 			if advance < 0 {
-				set_err(s, .Negative_Advance);
-				return false;
+				set_err(s, .Negative_Advance)
+				return false
 			}
 			if advance > s.end-s.start {
-				set_err(s, .Advanced_Too_Far);
-				return false;
+				set_err(s, .Advanced_Too_Far)
+				return false
 			}
-			s.start += advance;
+			s.start += advance
 
-			s.token = token;
+			s.token = token
 			if s.token != nil {
 				if s._err == nil || advance > 0 {
-					s.successive_empty_token_count = 0;
+					s.successive_empty_token_count = 0
 				} else {
-					s.successive_empty_token_count += 1;
+					s.successive_empty_token_count += 1
 
 					if s.max_consecutive_empty_reads <= 0 {
-						s.max_consecutive_empty_reads = DEFAULT_MAX_CONSECUTIVE_EMPTY_READS;
+						s.max_consecutive_empty_reads = DEFAULT_MAX_CONSECUTIVE_EMPTY_READS
 					}
 					if s.successive_empty_token_count > s.max_consecutive_empty_reads {
-						set_err(s, .No_Progress);
-						return false;
+						set_err(s, .No_Progress)
+						return false
 					}
 				}
-				return true;
+				return true
 			}
 		}
 
 		// If an error is hit, no token can be created
 		if s._err != nil {
-			s.start = 0;
-			s.end = 0;
-			return false;
+			s.start = 0
+			s.end = 0
+			return false
 		}
 
 		// More data must be required to be read
 		if s.start > 0 && (s.end == len(s.buf) || s.start > len(s.buf)/2) {
-			copy(s.buf[:], s.buf[s.start:s.end]);
-			s.end -= s.start;
-			s.start = 0;
+			copy(s.buf[:], s.buf[s.start:s.end])
+			s.end -= s.start
+			s.start = 0
 		}
 
-		could_be_too_short := false;
+		could_be_too_short := false
 
 		// Resize the buffer if full
 		if s.end == len(s.buf) {
 			if s.max_token_size <= 0 {
-				s.max_token_size = DEFAULT_MAX_SCAN_TOKEN_SIZE;
+				s.max_token_size = DEFAULT_MAX_SCAN_TOKEN_SIZE
 			}
 			if len(s.buf) >= s.max_token_size {
-				set_err(s, .Too_Long);
-				return false;
+				set_err(s, .Too_Long)
+				return false
 			}
 			// overflow check
-			new_size := _INIT_BUF_SIZE;
+			new_size := _INIT_BUF_SIZE
 			if len(s.buf) > 0 {
-				overflowed: bool;
+				overflowed: bool
 				if new_size, overflowed = intrinsics.overflow_mul(len(s.buf), 2); overflowed {
-					set_err(s, .Too_Long);
-					return false;
+					set_err(s, .Too_Long)
+					return false
 				}
 			}
 
-			old_size := len(s.buf);
-			new_size = min(new_size, s.max_token_size);
-			resize(&s.buf, new_size);
-			s.end -= s.start;
-			s.start = 0;
+			old_size := len(s.buf)
+			new_size = min(new_size, s.max_token_size)
+			resize(&s.buf, new_size)
+			s.end -= s.start
+			s.start = 0
 
-			could_be_too_short = old_size >= len(s.buf);
+			could_be_too_short = old_size >= len(s.buf)
 
 		}
 
 		// Read data into the buffer
-		loop := 0;
+		loop := 0
 		for {
-			n, err := io.read(s.r, s.buf[s.end:len(s.buf)]);
+			n, err := io.read(s.r, s.buf[s.end:len(s.buf)])
 			if n < 0 || len(s.buf)-s.end < n {
-				set_err(s, .Bad_Read_Count);
-				break;
+				set_err(s, .Bad_Read_Count)
+				break
 			}
-			s.end += n;
+			s.end += n
 			if err != nil {
-				set_err(s, err);
-				break;
+				set_err(s, err)
+				break
 			}
 			if n > 0 {
-				s.successive_empty_token_count = 0;
-				break;
+				s.successive_empty_token_count = 0
+				break
 			}
-			loop += 1;
+			loop += 1
 
 			if s.max_consecutive_empty_reads <= 0 {
-				s.max_consecutive_empty_reads = DEFAULT_MAX_CONSECUTIVE_EMPTY_READS;
+				s.max_consecutive_empty_reads = DEFAULT_MAX_CONSECUTIVE_EMPTY_READS
 			}
 			if loop > s.max_consecutive_empty_reads {
 				if could_be_too_short {
-					set_err(s, .Too_Short);
+					set_err(s, .Too_Short)
 				} else {
-					set_err(s, .No_Progress);
+					set_err(s, .No_Progress)
 				}
-				break;
+				break
 			}
 		}
 	}
@@ -234,38 +234,38 @@ scanner_scan :: proc(s: ^Scanner) -> bool {
 
 scan_bytes :: proc(data: []byte, at_eof: bool) -> (advance: int, token: []byte, err: Scanner_Error, final_token: bool) {
 	if at_eof && len(data) == 0 {
-		return;
+		return
 	}
-	return 1, data[0:1], nil, false;
+	return 1, data[0:1], nil, false
 }
 
 scan_runes :: proc(data: []byte, at_eof: bool) -> (advance: int, token: []byte, err: Scanner_Error, final_token: bool) {
 	if at_eof && len(data) == 0 {
-		return;
+		return
 	}
 
 	if data[0] < utf8.RUNE_SELF {
-		advance = 1;
-		token = data[0:1];
-		return;
+		advance = 1
+		token = data[0:1]
+		return
 	}
 
-	_, width := utf8.decode_rune(data);
+	_, width := utf8.decode_rune(data)
 	if width > 1 {
-		advance = width;
-		token = data[0:width];
-		return;
+		advance = width
+		token = data[0:width]
+		return
 	}
 
 	if !at_eof && !utf8.full_rune(data) {
-		return;
+		return
 	}
 
-	@thread_local ERROR_RUNE := []byte{0xef, 0xbf, 0xbd};
+	@thread_local ERROR_RUNE := []byte{0xef, 0xbf, 0xbd}
 
-	advance = 1;
-	token = ERROR_RUNE;
-	return;
+	advance = 1
+	token = ERROR_RUNE
+	return
 }
 
 scan_words :: proc(data: []byte, at_eof: bool) -> (advance: int, token: []byte, err: Scanner_Error, final_token: bool) {
@@ -273,68 +273,68 @@ scan_words :: proc(data: []byte, at_eof: bool) -> (advance: int, token: []byte,
 		switch r {
 		// lower ones
 		case ' ', '\t', '\n', '\v', '\f', '\r':
-			return true;
+			return true
 		case '\u0085', '\u00a0':
-			return true;
+			return true
 		// higher ones
 		case '\u2000' ..= '\u200a':
-			return true;
+			return true
 		case '\u1680', '\u2028', '\u2029', '\u202f', '\u205f', '\u3000':
-			return true;
+			return true
 		}
-		return false;
+		return false
 	}
 
 	// skip spaces at the beginning
-	start := 0;
+	start := 0
 	for width := 0; start < len(data); start += width {
-		r: rune;
-		r, width = utf8.decode_rune(data[start:]);
+		r: rune
+		r, width = utf8.decode_rune(data[start:])
 		if !is_space(r) {
-			break;
+			break
 		}
 	}
 
 	for width, i := 0, start; i < len(data); i += width {
-		r: rune;
-		r, width = utf8.decode_rune(data[i:]);
+		r: rune
+		r, width = utf8.decode_rune(data[i:])
 		if is_space(r) {
-			advance = i+width;
-			token = data[start:i];
-			return;
+			advance = i+width
+			token = data[start:i]
+			return
 		}
 	}
 
 	if at_eof && len(data) > start {
-		advance = len(data);
-		token = data[start:];
-		return;
+		advance = len(data)
+		token = data[start:]
+		return
 	}
 
-	advance = start;
-	return;
+	advance = start
+	return
 }
 
 scan_lines :: proc(data: []byte, at_eof: bool) -> (advance: int, token: []byte, err: Scanner_Error, final_token: bool) {
 	trim_carriage_return :: proc "contextless" (data: []byte) -> []byte {
 		if len(data) > 0 && data[len(data)-1] == '\r' {
-			return data[0:len(data)-1];
+			return data[0:len(data)-1]
 		}
-		return data;
+		return data
 	}
 
 	if at_eof && len(data) == 0 {
-		return;
+		return
 	}
 	if i := bytes.index_byte(data, '\n'); i >= 0 {
-		advance = i+1;
-		token = trim_carriage_return(data[0:i]);
-		return;
+		advance = i+1
+		token = trim_carriage_return(data[0:i])
+		return
 	}
 
 	if at_eof {
-		advance = len(data);
-		token = trim_carriage_return(data);
+		advance = len(data)
+		token = trim_carriage_return(data)
 	}
-	return;
+	return
 }

core/bufio/writer.odin

@@ -20,150 +20,150 @@ Writer :: struct {
 }
 
 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);
+	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_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^ = {};
+	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);
+	return len(b.buf)
 }
 
 writer_reset :: proc(b: ^Writer, w: io.Writer) {
-	b.wr = w;
-	b.n = 0;
-	b.err = nil;
+	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;
+		return b.err
 	}
 	if b.n == 0 {
-		return nil;
+		return nil
 	}
 
-	n, err := io.write(b.wr, b.buf[0:b.n]);
+	n, err := io.write(b.wr, b.buf[0:b.n])
 	if n < b.n && err == nil {
-		err = .Short_Write;
+		err = .Short_Write
 	}
 	if err != nil {
 		if n > 0 && n < b.n {
-			copy(b.buf[:b.n-n], b.buf[n : b.n]);
+			copy(b.buf[:b.n-n], b.buf[n : b.n])
 		}
-		b.n -= n;
-		b.err = err;
-		return err;
+		b.n -= n
+		b.err = err
+		return err
 	}
-	b.n = 0;
-	return nil;
+	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;
+	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;
+	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;
+	p := p
 	for len(p) > writer_available(b) && b.err == nil {
-		m: int;
+		m: int
 		if writer_buffered(b) == 0 {
-			m, b.err = io.write(b.wr, p);
+			m, b.err = io.write(b.wr, p)
 		} else {
-			m = copy(b.buf[b.n:], p);
-			b.n += m;
-			writer_flush(b);
+			m = copy(b.buf[b.n:], p)
+			b.n += m
+			writer_flush(b)
 		}
-		n += m;
-		p = p[m:];
+		n += m
+		p = p[m:]
 	}
 	if b.err != nil {
-		return n, b.err;
+		return n, b.err
 	}
-	m := copy(b.buf[b.n:], p);
-	b.n += m;
-	m += n;
-	return m, nil;
+	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;
+		return b.err
 	}
 	if writer_available(b) <= 0 && writer_flush(b) != nil {
-		return b.err;
+		return b.err
 	}
-	b.buf[b.n] = c;
-	b.n += 1;
-	return nil;
+	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;
+		err = writer_write_byte(b, byte(r))
+		size = 0 if err != nil else 1
+		return
 	}
 	if b.err != nil {
-		return 0, b.err;
+		return 0, b.err
 	}
 
-	buf: [4]u8;
+	buf: [4]u8
 
-	n := writer_available(b);
+	n := writer_available(b)
 	if n < utf8.UTF_MAX {
-		writer_flush(b);
+		writer_flush(b)
 		if b.err != nil {
-			return 0, b.err;
+			return 0, b.err
 		}
-		n = writer_available(b);
+		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]);
+			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;
+	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);
+	return writer_write(b, transmute([]byte)s)
 }
 
 // writer_read_from is to support io.Reader_From types
@@ -171,62 +171,60 @@ writer_write_string :: proc(b: ^Writer, s: string) -> (int, io.Error) {
 // 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;
+		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;
+			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;
-			}
+			writer_flush(b) or_return
 		}
 		if b.max_consecutive_empty_writes <= 0 {
-			b.max_consecutive_empty_writes = DEFAULT_MAX_CONSECUTIVE_EMPTY_READS;
+			b.max_consecutive_empty_writes = DEFAULT_MAX_CONSECUTIVE_EMPTY_READS
 		}
 
-		m: int;
-		nr := 0;
+		m: int
+		nr := 0
 		for nr < b.max_consecutive_empty_writes {
-			m, err = io.read(r, b.buf[b.n:]);
+			m, err = io.read(r, b.buf[b.n:])
 			if m != 0 || err != nil {
-				break;
+				break
 			}
-			nr += 1;
+			nr += 1
 		}
 		if nr == b.max_consecutive_empty_writes {
-			return n, .No_Progress;
+			return n, .No_Progress
 		}
-		b.n += m;
-		n += i64(m);
+		b.n += m
+		n += i64(m)
 		if err != nil {
-			break;
+			break
 		}
 	}
 
 	if err == .EOF {
 		if writer_available(b) == 0 {
-			err = writer_flush(b);
+			err = writer_flush(b)
 		} else {
-			err = nil;
+			err = nil
 		}
 	}
-	return;
+	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;
+	s.stream_data = b
+	s.stream_vtable = _writer_vtable
+	return
 }
 
 
@@ -234,28 +232,28 @@ writer_to_stream :: proc(b: ^Writer) -> (s: io.Stream) {
 @(private)
 _writer_vtable := &io.Stream_VTable{
 	impl_destroy = proc(s: io.Stream) -> io.Error {
-		b := (^Writer)(s.stream_data);
-		writer_destroy(b);
-		return nil;
+		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);
+		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);
+		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);
+		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);
+		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);
+		b := (^Writer)(s.stream_data)
+		return writer_read_from(b, r)
 	},
-};
+}

core/bytes/buffer.odin

@@ -3,10 +3,10 @@ package bytes
 import "core:io"
 import "core:unicode/utf8"
 
-MIN_READ :: 512;
+MIN_READ :: 512
 
 @(private)
-SMALL_BUFFER_SIZE :: 64;
+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.
@@ -28,406 +28,406 @@ Read_Op :: enum i8 {
 
 
 buffer_init :: proc(b: ^Buffer, buf: []byte) {
-	resize(&b.buf, len(buf));
-	copy(b.buf[:], buf);
+	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);
+	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);
+	b.buf.allocator = allocator
+	reserve(&b.buf, cap)
+	resize(&b.buf, len)
 }
 
 buffer_destroy :: proc(b: ^Buffer) {
-	delete(b.buf);
-	buffer_reset(b);
+	delete(b.buf)
+	buffer_reset(b)
 }
 
 buffer_to_bytes :: proc(b: ^Buffer) -> []byte {
-	return b.buf[b.off:];
+	return b.buf[b.off:]
 }
 
 buffer_to_string :: proc(b: ^Buffer) -> string {
 	if b == nil {
-		return "<nil>";
+		return "<nil>"
 	}
-	return string(b.buf[b.off:]);
+	return string(b.buf[b.off:])
 }
 
 buffer_is_empty :: proc(b: ^Buffer) -> bool {
-	return len(b.buf) <= b.off;
+	return len(b.buf) <= b.off
 }
 
 buffer_length :: proc(b: ^Buffer) -> int {
-	return len(b.buf) - b.off;
+	return len(b.buf) - b.off
 }
 
 buffer_capacity :: proc(b: ^Buffer) -> int {
-	return cap(b.buf);
+	return cap(b.buf)
 }
 
 buffer_reset :: proc(b: ^Buffer) {
-	clear(&b.buf);
-	b.off = 0;
-	b.last_read = .Invalid;
+	clear(&b.buf)
+	b.off = 0
+	b.last_read = .Invalid
 }
 
 
 buffer_truncate :: proc(b: ^Buffer, n: int) {
 	if n == 0 {
-		buffer_reset(b);
-		return;
+		buffer_reset(b)
+		return
 	}
-	b.last_read = .Invalid;
+	b.last_read = .Invalid
 	if n < 0 || n > buffer_length(b) {
-		panic("bytes.truncate: truncation out of range");
+		panic("bytes.truncate: truncation out of range")
 	}
-	resize(&b.buf, b.off+n);
+	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;
+		resize(&b.buf, l+n)
+		return l, true
 	}
-	return 0, false;
+	return 0, false
 }
 
 @(private)
 _buffer_grow :: proc(b: ^Buffer, n: int) -> int {
-	m := buffer_length(b);
+	m := buffer_length(b)
 	if m == 0 && b.off != 0 {
-		buffer_reset(b);
+		buffer_reset(b)
 	}
 	if i, ok := _buffer_try_grow(b, n); ok {
-		return i;
+		return i
 	}
 	if b.buf == nil && n <= SMALL_BUFFER_SIZE {
-		b.buf = make([dynamic]byte, n, SMALL_BUFFER_SIZE);
-		return 0;
+		b.buf = make([dynamic]byte, n, SMALL_BUFFER_SIZE)
+		return 0
 	}
 
-	c := cap(b.buf);
+	c := cap(b.buf)
 	if n <= c/2 - m {
-		copy(b.buf[:], b.buf[b.off:]);
+		copy(b.buf[:], b.buf[b.off:])
 	} else if c > max(int) - c - n {
-		panic("bytes.Buffer: too large");
+		panic("bytes.Buffer: too large")
 	} else {
-		resize(&b.buf, 2*c + n);
-		copy(b.buf[:], b.buf[b.off:]);
+		resize(&b.buf, 2*c + n)
+		copy(b.buf[:], b.buf[b.off:])
 	}
-	b.off = 0;
-	resize(&b.buf, m+n);
-	return m;
+	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");
+		panic("bytes.buffer_grow: negative count")
 	}
-	m := _buffer_grow(b, n);
-	resize(&b.buf, m);
+	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;
+	b.last_read = .Invalid
 	if offset < 0 {
-		err = .Invalid_Offset;
-		return;
+		err = .Invalid_Offset
+		return
 	}
-	_, ok := _buffer_try_grow(b, offset+len(p));
+	_, ok := _buffer_try_grow(b, offset+len(p))
 	if !ok {
-		_ = _buffer_grow(b, offset+len(p));
+		_ = _buffer_grow(b, offset+len(p))
 	}
 	if len(b.buf) <= offset {
-		return 0, .Short_Write;
+		return 0, .Short_Write
 	}
-	return copy(b.buf[offset:], p), nil;
+	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));
+	b.last_read = .Invalid
+	m, ok := _buffer_try_grow(b, len(p))
 	if !ok {
-		m = _buffer_grow(b, len(p));
+		m = _buffer_grow(b, len(p))
 	}
-	return copy(b.buf[m:], p), nil;
+	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));
+	b.last_read = .Invalid
+	m, ok := _buffer_try_grow(b, len(s))
 	if !ok {
-		m = _buffer_grow(b, len(s));
+		m = _buffer_grow(b, len(s))
 	}
-	return copy(b.buf[m:], s), nil;
+	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);
+	b.last_read = .Invalid
+	m, ok := _buffer_try_grow(b, 1)
 	if !ok {
-		m = _buffer_grow(b, 1);
+		m = _buffer_grow(b, 1)
 	}
-	b.buf[m] = c;
-	return nil;
+	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;
+		buffer_write_byte(b, byte(r))
+		return 1, nil
 	}
-	b.last_read = .Invalid;
-	m, ok := _buffer_try_grow(b, utf8.UTF_MAX);
+	b.last_read = .Invalid
+	m, ok := _buffer_try_grow(b, utf8.UTF_MAX)
 	if !ok {
-		m = _buffer_grow(b, utf8.UTF_MAX);
+		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;
+	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);
+	n := n
+	b.last_read = .Invalid
+	m := buffer_length(b)
 	if n > m {
-		n = m;
+		n = m
 	}
-	data := b.buf[b.off : b.off + n];
-	b.off += n;
+	data := b.buf[b.off : b.off + n]
+	b.off += n
 	if n > 0 {
-		b.last_read = .Read;
+		b.last_read = .Read
 	}
-	return data;
+	return data
 }
 
 buffer_read :: proc(b: ^Buffer, p: []byte) -> (n: int, err: io.Error) {
-	b.last_read = .Invalid;
+	b.last_read = .Invalid
 	if buffer_is_empty(b) {
-		buffer_reset(b);
+		buffer_reset(b)
 		if len(p) == 0 {
-			return 0, nil;
+			return 0, nil
 		}
-		return 0, .EOF;
+		return 0, .EOF
 	}
-	n = copy(p, b.buf[b.off:]);
-	b.off += n;
+	n = copy(p, b.buf[b.off:])
+	b.off += n
 	if n > 0 {
-		b.last_read = .Read;
+		b.last_read = .Read
 	}
-	return;
+	return
 }
 
 buffer_read_at :: proc(b: ^Buffer, p: []byte, offset: int) -> (n: int, err: io.Error) {
-	b.last_read = .Invalid;
+	b.last_read = .Invalid
 
 	if offset < 0 || offset >= len(b.buf) {
-		err = .Invalid_Offset;
-		return;
+		err = .Invalid_Offset
+		return
 	}
 
 	if 0 <= offset && offset < len(b.buf) {
-		n = copy(p, b.buf[offset:]);
+		n = copy(p, b.buf[offset:])
 	}
 	if n > 0 {
-		b.last_read = .Read;
+		b.last_read = .Read
 	}
-	return;
+	return
 }
 
 
 buffer_read_byte :: proc(b: ^Buffer) -> (byte, io.Error) {
 	if buffer_is_empty(b) {
-		buffer_reset(b);
-		return 0, .EOF;
+		buffer_reset(b)
+		return 0, .EOF
 	}
-	c := b.buf[b.off];
-	b.off += 1;
-	b.last_read = .Read;
-	return c, nil;
+	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;
+		buffer_reset(b)
+		return 0, 0, .EOF
 	}
-	c := b.buf[b.off];
+	c := b.buf[b.off]
 	if c < utf8.RUNE_SELF {
-		b.off += 1;
-		b.last_read = .Read_Rune1;
-		return rune(c), 1, nil;
+		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;
+	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;
+		return .Invalid_Unread
 	}
-	b.last_read = .Invalid;
+	b.last_read = .Invalid
 	if b.off > 0 {
-		b.off -= 1;
+		b.off -= 1
 	}
-	return nil;
+	return nil
 }
 
 buffer_unread_rune :: proc(b: ^Buffer) -> io.Error {
 	if b.last_read <= .Invalid {
-		return .Invalid_Unread;
+		return .Invalid_Unread
 	}
 	if b.off >= int(b.last_read) {
-		b.off -= int(i8(b.last_read));
+		b.off -= int(i8(b.last_read))
 	}
-	b.last_read = .Invalid;
-	return nil;
+	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;
+	i := index_byte(b.buf[b.off:], delim)
+	end := b.off + i + 1
 	if i < 0 {
-		end = len(b.buf);
-		err = .EOF;
+		end = len(b.buf)
+		err = .EOF
 	}
-	line = b.buf[b.off:end];
-	b.off = end;
-	b.last_read = .Read;
-	return;
+	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;
+	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;
+	b.last_read = .Invalid
 	if byte_count := buffer_length(b); byte_count > 0 {
-		m, e := io.write(w, b.buf[b.off:]);
+		m, e := io.write(w, b.buf[b.off:])
 		if m > byte_count {
-			panic("bytes.buffer_write_to: invalid io.write count");
+			panic("bytes.buffer_write_to: invalid io.write count")
 		}
-		b.off += m;
-		n = i64(m);
+		b.off += m
+		n = i64(m)
 		if e != nil {
-			err = e;
-			return;
+			err = e
+			return
 		}
 		if m != byte_count {
-			err = .Short_Write;
-			return;
+			err = .Short_Write
+			return
 		}
 	}
-	buffer_reset(b);
-	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;
+	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)]);
+		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;
+			err = .Negative_Read
+			return
 		}
 
-		resize(&b.buf, i+m);
-		n += i64(m);
+		resize(&b.buf, i+m)
+		n += i64(m)
 		if e == .EOF {
-			return;
+			return
 		}
 		if e != nil {
-			err = e;
-			return;
+			err = e
+			return
 		}
 	}
-	return;
+	return
 }
 
 
 buffer_to_stream :: proc(b: ^Buffer) -> (s: io.Stream) {
-	s.stream_data = b;
-	s.stream_vtable = _buffer_vtable;
-	return;
+	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));
+		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);
+		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));
+		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);
+		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);
+		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);
+		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));
+		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);
+		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);
+		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);
+		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);
+		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;
+		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);
+		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);
+		b := (^Buffer)(s.stream_data)
+		return buffer_read_from(b, r)
 	},
-};
+}
 

core/bytes/reader.odin

@@ -10,168 +10,168 @@ Reader :: struct {
 }
 
 reader_init :: proc(r: ^Reader, s: []byte) {
-	r.s = s;
-	r.i = 0;
-	r.prev_rune = -1;
+	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;
+	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 0
 	}
-	return int(i64(len(r.s)) - r.i);
+	return int(i64(len(r.s)) - r.i)
 }
 
 reader_size :: proc(r: ^Reader) -> i64 {
-	return i64(len(r.s));
+	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;
+		return 0, .EOF
 	}
-	r.prev_rune = -1;
-	n = copy(p, r.s[r.i:]);
-	r.i += i64(n);
-	return;
+	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;
+		return 0, .Invalid_Offset
 	}
 	if off >= i64(len(r.s)) {
-		return 0, .EOF;
+		return 0, .EOF
 	}
-	n = copy(p, r.s[off:]);
+	n = copy(p, r.s[off:])
 	if n < len(p) {
-		err = .EOF;
+		err = .EOF
 	}
-	return;
+	return
 }
 reader_read_byte :: proc(r: ^Reader) -> (byte, io.Error) {
-	r.prev_rune = -1;
+	r.prev_rune = -1
 	if r.i >= i64(len(r.s)) {
-		return 0, .EOF;
+		return 0, .EOF
 	}
-	b := r.s[r.i];
-	r.i += 1;
-	return b, nil;
+	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;
+		return .Invalid_Unread
 	}
-	r.prev_rune = -1;
-	r.i -= 1;
-	return nil;
+	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 = -1
+		return 0, 0, .EOF
 	}
-	r.prev_rune = int(r.i);
+	r.prev_rune = int(r.i)
 	if c := r.s[r.i]; c < utf8.RUNE_SELF {
-		r.i += 1;
-		return rune(c), 1, nil;
+		r.i += 1
+		return rune(c), 1, nil
 	}
-	ch, size = utf8.decode_rune(r.s[r.i:]);
-	r.i += i64(size);
-	return;
+	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;
+		return .Invalid_Unread
 	}
 	if r.prev_rune < 0 {
-		return .Invalid_Unread;
+		return .Invalid_Unread
 	}
-	r.i = i64(r.prev_rune);
-	r.prev_rune = -1;
-	return nil;
+	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;
+	r.prev_rune = -1
+	abs: i64
 	switch whence {
 	case .Start:
-		abs = offset;
+		abs = offset
 	case .Current:
-		abs = r.i + offset;
+		abs = r.i + offset
 	case .End:
-		abs = i64(len(r.s)) + offset;
+		abs = i64(len(r.s)) + offset
 	case:
-		return 0, .Invalid_Whence;
+		return 0, .Invalid_Whence
 	}
 
 	if abs < 0 {
-		return 0, .Invalid_Offset;
+		return 0, .Invalid_Offset
 	}
-	r.i = abs;
-	return abs, nil;
+	r.i = abs
+	return abs, nil
 }
 reader_write_to :: proc(r: ^Reader, w: io.Writer) -> (n: i64, err: io.Error) {
-	r.prev_rune = -1;
+	r.prev_rune = -1
 	if r.i >= i64(len(r.s)) {
-		return 0, nil;
+		return 0, nil
 	}
-	s := r.s[r.i:];
-	m: int;
-	m, err = io.write(w, s);
+	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");
+		panic("bytes.Reader.write_to: invalid io.write_string count")
 	}
-	r.i += i64(m);
-	n = i64(m);
+	r.i += i64(m)
+	n = i64(m)
 	if m != len(s) && err == nil {
-		err = .Short_Write;
+		err = .Short_Write
 	}
-	return;
+	return
 }
 
 
 @(private)
 _reader_vtable := &io.Stream_VTable{
 	impl_size = proc(s: io.Stream) -> i64 {
-		r := (^Reader)(s.stream_data);
-		return reader_size(r);
+		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);
+		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);
+		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);
+		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);
+		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);
+		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);
+		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);
+		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);
+		r := (^Reader)(s.stream_data)
+		return reader_write_to(r, w)
 	},
-};
+}

core/c/c.odin

@@ -1,35 +1,104 @@
 package c
 
-import b "core:builtin"
+import builtin "core:builtin"
 
-CHAR_BIT :: 8;
+char           :: builtin.u8  // assuming -funsigned-char
+short          :: builtin.i16
+int            :: builtin.i32
+long           :: builtin.i32 when (ODIN_OS == "windows" || size_of(builtin.rawptr) == 4) else builtin.i64
+longlong       :: builtin.i64
 
-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;
+uchar          :: builtin.u8
+ushort         :: builtin.u16
+uint           :: builtin.u32
+ulong          :: builtin.u32 when (ODIN_OS == "windows" || size_of(builtin.rawptr) == 4) else builtin.u64
+ulonglong      :: builtin.u64
 
-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;
+bool           :: builtin.bool
 
-longlong       :: b.i64;
-ulonglong      :: b.u64;
-float          :: b.f32;
-double         :: b.f64;
-complex_float  :: b.complex64;
-complex_double :: b.complex128;
+size_t         :: builtin.uint
+ssize_t        :: builtin.int
+wchar_t        :: builtin.u16 when (ODIN_OS == "windows") else builtin.u32
 
-#assert(size_of(b.uintptr) == size_of(b.int));
+float          :: builtin.f32
+double         :: builtin.f64
+complex_float  :: builtin.complex64
+complex_double :: builtin.complex128
 
-size_t    :: b.uint;
-ssize_t   :: b.int;
-ptrdiff_t :: b.int;
-uintptr_t :: b.uintptr;
-intptr_t  :: b.int;
+// 7.20.1 Integer types
+int8_t         :: builtin.i8
+uint8_t        :: builtin.u8
+int16_t        :: builtin.i16
+uint16_t       :: builtin.u16
+int32_t        :: builtin.i32
+uint32_t       :: builtin.u32
+int64_t        :: builtin.i64
+uint64_t       :: builtin.u64
 
-wchar_t :: b.u16 when (ODIN_OS == "windows") else b.u32;
+// These are all the same in multiple libc's for multiple architectures.
+int_least8_t   :: builtin.i8
+uint_least8_t  :: builtin.u8
+int_least16_t  :: builtin.i16
+uint_least16_t :: builtin.u16
+int_least32_t  :: builtin.i32
+uint_least32_t :: builtin.u32
+int_least64_t  :: builtin.i64
+uint_least64_t :: builtin.u64
+
+// Same on Windows, Linux, and FreeBSD
+when ODIN_ARCH == "386" || ODIN_ARCH == "amd64" {
+	int_fast8_t    :: builtin.i8
+	uint_fast8_t   :: builtin.u8
+	int_fast16_t   :: builtin.i32
+	uint_fast16_t  :: builtin.u32
+	int_fast32_t   :: builtin.i32
+	uint_fast32_t  :: builtin.u32
+	int_fast64_t   :: builtin.i64
+	uint_fast64_t  :: builtin.u64
+} else {
+	int_fast8_t    :: builtin.i8
+	uint_fast8_t   :: builtin.u8
+	int_fast16_t   :: builtin.i16
+	uint_fast16_t  :: builtin.u16
+	int_fast32_t   :: builtin.i32
+	uint_fast32_t  :: builtin.u32
+	int_fast64_t   :: builtin.i64
+	uint_fast64_t  :: builtin.u64
+}
+
+intptr_t       :: builtin.int
+uintptr_t      :: builtin.uintptr
+ptrdiff_t      :: distinct intptr_t
+
+intmax_t       :: builtin.i64
+uintmax_t      :: builtin.u64
+
+// Copy C's rules for type promotion here by forcing the type on the literals.
+INT8_MAX       :: int(0x7f)
+INT16_MAX      :: int(0x7fff)
+INT32_MAX      :: int(0x7fffffff)
+INT64_MAX      :: longlong(0x7fffffffffffffff)
+
+UINT8_MAX      :: int(0xff)
+UINT16_MAX     :: int(0xffff)
+UINT32_MAX     :: uint(0xffffffff)
+UINT64_MAX     :: ulonglong(0xffffffffffffffff)
+
+INT8_MIN       :: ~INT8_MAX
+INT16_MIN      :: ~INT16_MAX
+INT32_MIN      :: ~INT32_MAX
+INT64_MIN      :: ~INT64_MAX
+
+SIZE_MAX       :: max(size_t)
+
+PTRDIFF_MIN    :: min(ptrdiff_t)
+PTRDIFF_MAX    :: max(ptrdiff_t)
+
+WCHAR_MIN      :: min(wchar_t)
+WCHAR_MAX      :: max(wchar_t)
+
+NULL           :: rawptr(uintptr(0))
+
+NDEBUG         :: !ODIN_DEBUG
+
+CHAR_BIT :: 8

core/c/frontend/preprocessor/const_expr.odin

@@ -6,20 +6,20 @@ 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);
+	assert(rest != nil)
+	assert(tok != nil)
+	rest^ = tokenizer.new_eof(tok)
 	switch v in tok.val {
 	case i64:
-		return v;
+		return v
 	case f64:
-		return i64(v);
+		return i64(v)
 	case string:
-		return 0;
+		return 0
 	case []u16:
 		// TODO
 	case []u32:
 		// TODO
 	}
-	return 0;
+	return 0
 }

core/c/frontend/preprocessor/unquote.odin

@@ -5,150 +5,150 @@ 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;
+		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;
+		return -1
 	}
-	w: int;
+	w: int
 
 	if str[0] == quote && quote == '"' {
-		return;
+		return
 	} else if str[0] >= 0x80 {
-		r, w = utf8.decode_rune_in_string(str);
-		return r, true, str[w:], true;
+		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;
+		return rune(str[0]), false, str[1:], true
 	}
 
 	if len(str) <= 1 {
-		return;
+		return
 	}
-	s := str;
-	c := s[1];
-	s = s[2:];
+	s := str
+	c := s[1]
+	s = s[2:]
 
 	switch c {
-	case: r = rune(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 '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 '"':  r = '"'
+	case '\'': r = '\''
 
 	case '0'..='7':
-		v := int(c-'0');
+		v := int(c-'0')
 		if len(s) < 2 {
-			return;
+			return
 		}
 		for i in 0..<len(s) {
-			d := int(s[i]-'0');
+			d := int(s[i]-'0')
 			if d < 0 || d > 7 {
-				return;
+				return
 			}
-			v = (v<<3) | d;
+			v = (v<<3) | d
 		}
-		s = s[2:];
+		s = s[2:]
 		if v > 0xff {
-			return;
+			return
 		}
-		r = rune(v);
+		r = rune(v)
 
 	case 'x', 'u', 'U':
-		count: int;
+		count: int
 		switch c {
-		case 'x': count = 2;
-		case 'u': count = 4;
-		case 'U': count = 8;
+		case 'x': count = 2
+		case 'u': count = 4
+		case 'U': count = 8
 		}
 
 		if len(s) < count {
-			return;
+			return
 		}
 
 		for i in 0..<count {
-			d := hex_to_int(s[i]);
+			d := hex_to_int(s[i])
 			if d < 0 {
-				return;
+				return
 			}
-			r = (r<<4) | rune(d);
+			r = (r<<4) | rune(d)
 		}
-		s = s[count:];
+		s = s[count:]
 		if c == 'x' {
-			break;
+			break
 		}
 		if r > utf8.MAX_RUNE {
-			return;
+			return
 		}
-		multiple_bytes = true;
+		multiple_bytes = true
 	}
 
-	success = true;
-	tail_string = s;
-	return;
+	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 offset
 			}
 		}
-		return -1;
+		return -1
 	}
 
-	assert(len(lit) >= 2);
+	assert(len(lit) >= 2)
 
-	s := lit;
-	quote := '"';
+	s := lit
+	quote := '"'
 
 	if s == `""` {
-		return "", false, true;
+		return "", false, true
 	}
 
 	if contains_rune(s, '\n') >= 0 {
-		return s, false, false;
+		return s, false, false
 	}
 
 	if contains_rune(s, '\\') < 0 && contains_rune(s, quote) < 0 {
 		if quote == '"' {
-			return s, false, true;
+			return s, false, true
 		}
 	}
-	s = s[1:len(s)-1];
+	s = s[1:len(s)-1]
 
 
-	buf_len := 3*len(s) / 2;
-	buf := make([]byte, buf_len, allocator);
-	offset := 0;
+	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));
+		r, multiple_bytes, tail_string, ok := unquote_char(s, byte(quote))
 		if !ok {
-			delete(buf);
-			return s, false, false;
+			delete(buf)
+			return s, false, false
 		}
-		s = tail_string;
+		s = tail_string
 		if r < 0x80 || !multiple_bytes {
-			buf[offset] = byte(r);
-			offset += 1;
+			buf[offset] = byte(r)
+			offset += 1
 		} else {
-			b, w := utf8.encode_rune(r);
-			copy(buf[offset:], b[:w]);
-			offset += w;
+			b, w := utf8.encode_rune(r)
+			copy(buf[offset:], b[:w])
+			offset += w
 		}
 	}
 
-	new_string := string(buf[:offset]);
+	new_string := string(buf[:offset])
 
-	return new_string, true, true;
+	return new_string, true, true
 }

core/c/frontend/tokenizer/hide_set.odin

@@ -11,58 +11,58 @@ Hide_Set :: struct {
 
 
 new_hide_set :: proc(name: string) -> ^Hide_Set {
-	hs := new(Hide_Set);
-	hs.name = name;
-	return hs;
+	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 true
 		}
 	}
-	return false;
+	return false
 }
 
 
 hide_set_union :: proc(a, b: ^Hide_Set) -> ^Hide_Set {
-	head: Hide_Set;
-	curr := &head;
+	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 = new_hide_set(h.name)
+		curr = curr.next
 	}
-	curr.next = b;
-	return head.next;
+	curr.next = b
+	return head.next
 }
 
 
 hide_set_intersection :: proc(a, b: ^Hide_Set) -> ^Hide_Set {
-	head: Hide_Set;
-	curr := &head;
+	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;
+			curr.next = new_hide_set(h.name)
+			curr = curr.next
 		}
 	}
-	return head.next;
+	return head.next
 }
 
 
 add_hide_set :: proc(tok: ^Token, hs: ^Hide_Set) -> ^Token {
-	head: Token;
-	curr := &head;
+	head: Token
+	curr := &head
 
-	tok := tok;
+	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;
+		t := copy_token(tok)
+		t.hide_set = hide_set_union(t.hide_set, hs)
+		curr.next = t
+		curr = curr.next
 	}
-	return head.next;
+	return head.next
 }

core/c/frontend/tokenizer/token.odin

@@ -80,29 +80,29 @@ Token :: struct {
 	origin:   ^Token,
 }
 
-Is_Keyword_Proc :: #type proc(tok: ^Token) -> bool;
+Is_Keyword_Proc :: #type proc(tok: ^Token) -> bool
 
 copy_token :: proc(tok: ^Token) -> ^Token {
-	t := new_clone(tok^);
-	t.next = nil;
-	return t;
+	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;
+	t, _ := new_clone(tok^)
+	t.kind = .EOF
+	t.lit = ""
+	return t
 }
 
 default_is_keyword :: proc(tok: ^Token) -> bool {
 	if tok.kind == .Keyword {
-		return true;
+		return true
 	}
 	if len(tok.lit) > 0 {
-		return default_keyword_set[tok.lit];
+		return default_keyword_set[tok.lit]
 	}
-	return false;
+	return false
 }
 
 
@@ -117,7 +117,7 @@ token_name := [Token_Kind]string {
 	.PP_Number = "preprocessor number",
 	.Comment   = "comment",
 	.EOF       = "eof",
-};
+}
 
 default_keyword_set := map[string]bool{
 	"auto"          = true,
@@ -166,4 +166,4 @@ default_keyword_set := map[string]bool{
 	"__restrict__"  = true,
 	"__thread"      = true,
 	"__attribute__" = true,
-};
+}

core/c/frontend/tokenizer/tokenizer.odin

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

core/c/frontend/tokenizer/unicode.odin

@@ -4,10 +4,10 @@ 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 true
 		}
 	}
-	return false;
+	return false
 }
 
 
@@ -15,11 +15,11 @@ in_range :: proc(range: []rune, c: rune) -> bool #no_bounds_check {
 //
 // 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);
+	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);
+	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.
@@ -27,18 +27,18 @@ is_ident1 :: proc(c: rune) -> bool {
 char_width :: proc(c: rune) -> int {
 	switch {
 	case in_range(_range_width0, c):
-		return 0;
+		return 0
 	case in_range(_range_width2, c):
-		return 2;
+		return 2
 	}
-	return 1;
+	return 1
 }
 
 display_width :: proc(str: string) -> (w: int) {
 	for c in str {
-		w += char_width(c);
+		w += char_width(c)
 	}
-	return;
+	return
 }
 
 
@@ -59,12 +59,12 @@ _range_ident0 := []rune{
 	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{
@@ -105,7 +105,7 @@ _range_width0 := []rune{
 	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,
@@ -113,4 +113,4 @@ _range_width2 := []rune{
 	0xFE30, 0xFE6F, 0xFF00, 0xFF60, 0xFFE0, 0xFFE6, 0x1F000, 0x1F644,
 	0x20000, 0x2FFFD, 0x30000, 0x3FFFD,
 	-1,
-};
+}

core/c/libc/README.md

@@ -0,0 +1,73 @@
+# C support
+
+The following is a mostly-complete projection of the C11 standard library as defined by the C11 specification: N1570, or ISO/IEC 9899:2011. Only the macros, types, and functions as required by the standard are projected. Extensions to C, such as POSIX are not handled by these bindings, this is otherwise portable to any implementation which can support a hosted C runtime.
+
+## Support matrix
+| Header            | Status                                             |
+|:------------------|:---------------------------------------------------|
+| `<assert.h>`      | Not applicable, use Odin's `#assert`               |
+| `<complex.h>`     | Mostly projected, see [limitations](#Limitations)  |
+| `<ctype.h>`       | Fully projected                                    |
+| `<errno.h>`       | Fully projected                                    |
+| `<fenv.h>`        | Not projected                                      |
+| `<float.h>`       | Not projected                                      |
+| `<inttypes.h>`    | Fully projected                                    |
+| `<iso646.h>`      | Not applicable, use Odin's operators               |
+| `<limits.h>`      | Not projected                                      |
+| `<locale.h>`      | Not projected                                      |
+| `<math.h>`        | Mostly projected, see [limitations](#Limitations)  |
+| `<setjmp.h>`      | Fully projected                                    |
+| `<signal.h>`      | Fully projected                                    |
+| `<stdalign.h>`    | Not applicable, use Odin's `#align`                |
+| `<stdarg.h>`      | Mostly projected, see [limitations](#Limitations)  |
+| `<stdatomic.h>`   | Fully projected                                    |
+| `<stdbool.h>`     | Not applicable, use Odin's `b32`                   |
+| `<stddef.h>`      | Mostly projected, see [limitations](#Limitations)  |
+| `<stdint.h>`      | Fully projected                                    |
+| `<stdio.h>`       | Fully projected                                    |
+| `<stdlib.h>`      | Fully projected                                    |
+| `<stdnoreturn.h>` | Not applicable, use Odin's divergent return `!`    |
+| `<string.h>`      | Fully projected                                    |
+| `<tgmath.h>`      | Mostly projected, see [limitations](#Limitations)  |
+| `<threads.h>`     | Fully projected                                    |
+| `<time.h>`        | Fully projected                                    |
+| `<uchar.h>`       | Fully projected                                    |
+| `<wchar.h>`       | Fully projected                                    |
+| `<wctype.h>`      | Fully projected                                    |
+
+## Limitations
+Not all C standard library functionality can be fully projected due to language differences. These limitations are listed here.
+
+### `long double`
+As Odin lacks a means to interact with `long double` in it's foreign interface, this projection effort does not bind or define anything requiring `long double` which is permitted by the C standard.
+
+### `<complex.h>`
+The special values `_Complex_I`, `_Imaginary_I` and the appropriate definition of `I` cannot be realized with the same type in Odin as it would be in C. The literal `1i` is tempting to use for these definitions but the semantics differ from C and would be confusing to use.
+
+### `<math.h>`
+The classification functions, e.g: `fpclassify` are required by C to be implemented as macros, meaning no implementation would expose functions in their library we could bind. Instead, we provide native Odin implementations with functionally equivalent semantics and behavior as the C ones. Unfortunately, since classification returns unspecified constant values this may be an ABI break where the value of those constants enter and exit native C code.
+
+### `<stdarg.h>`
+While Odin can interact with variable argument C functions through the use of the `#c_vararg` attribute within a foreign block, it's not actually possible to create procedures in Odin with bodies that have the same ABI as that of variable argument C functions, as a result `va_arg` is not projected.
+
+### `<stddef.h>`
+`offsetof` is not realizable in Odin, however you can use `offset_of` instead.
+
+### `<tgmath.h>`
+C has some strange promotion and type-coercion behavior for `<tgmath.h>` which isn't correctly handled by this projection, specifically involving the use of complex arithmetic and kernels. We do mostly support type-generic math through the use of Odin's explicit procedure overloading, however the semantic behavior of that doesn't match C and so literal expressions of complex type in C may not call the same underlying math kernel functions as they do in Odin through this projection.
+
+## Caveats
+
+In addition to limitations, there are some minor caveats you should be aware when using this projection.
+
+* `errno()` is a function which returns `^int` rather than a macro.
+* `MB_CUR_MAX()` is a function which return `size_t` rather than a macro.
+* Currently only works on Windows (MSVCRT) and Linux (GLIBC or MUSL)
+
+## License
+Every file within this directory is made available under Odin's BSD-2 license
+with the following copyright.
+
+```
+Copyright 2021 Dale Weiler <weilercdale@gmail.com>.
+```

core/c/libc/complex.odin

@@ -0,0 +1,82 @@
+package libc
+
+// 7.3 Complex arithmetic
+
+when ODIN_OS == "windows" {
+	foreign import libc "system:libucrt.lib"
+} else {
+	foreign import libc "system:c"
+}
+
+@(default_calling_convention="c")
+foreign libc {
+	// 7.3.5 Trigonometric functions
+	cacos   :: proc(z: complex_double) -> complex_double ---
+	cacosf  :: proc(z: complex_float) -> complex_float ---
+	casin   :: proc(z: complex_double) -> complex_double ---
+	casinf  :: proc(z: complex_float) -> complex_float ---
+	catan   :: proc(z: complex_double) -> complex_double ---
+	catanf  :: proc(z: complex_float) -> complex_float ---
+	ccos    :: proc(z: complex_double) -> complex_double ---
+	ccosf   :: proc(z: complex_float) -> complex_float ---
+	csin    :: proc(z: complex_double) -> complex_double ---
+	csinf   :: proc(z: complex_float) -> complex_float ---
+	ctan    :: proc(z: complex_double) -> complex_double ---
+	ctanf   :: proc(z: complex_float) -> complex_float ---
+
+	// 7.3.6 Hyperbolic functions
+	cacosh  :: proc(z: complex_double) -> complex_double ---
+	cacoshf :: proc(z: complex_float) -> complex_float ---
+	casinh  :: proc(z: complex_double) -> complex_double ---
+	casinhf :: proc(z: complex_float) -> complex_float ---
+	catanh  :: proc(z: complex_double) -> complex_double ---
+	catanhf :: proc(z: complex_float) -> complex_float ---
+	ccosh   :: proc(z: complex_double) -> complex_double ---
+	ccoshf  :: proc(z: complex_float) -> complex_float ---
+	csinh   :: proc(z: complex_double) -> complex_double ---
+	csinhf  :: proc(z: complex_float) -> complex_float ---
+	ctanh   :: proc(z: complex_double) -> complex_double ---
+	ctanhf  :: proc(z: complex_float) -> complex_float ---
+
+	// 7.3.7 Exponential and logarithmic functions
+	cexp    :: proc(z: complex_double) -> complex_double ---
+	cexpf   :: proc(z: complex_float) -> complex_float ---
+	clog    :: proc(z: complex_double) -> complex_double ---
+	clogf   :: proc(z: complex_float) -> complex_float ---
+
+	// 7.3.8 Power and absolute-value functions
+	cabs    :: proc(z: complex_double) -> complex_double ---
+	cabsf   :: proc(z: complex_float) -> complex_float ---
+	cpow    :: proc(z: complex_double) -> complex_double ---
+	cpowf   :: proc(z: complex_float) -> complex_float ---
+	csqrt   :: proc(z: complex_double) -> complex_double ---
+	csqrtf  :: proc(z: complex_float) -> complex_float ---
+
+	// 7.3.9 Manipulation functions
+	carg    :: proc(z: complex_double) -> double ---
+	cargf   :: proc(z: complex_float) -> float ---
+	cimag   :: proc(z: complex_double) -> double ---
+	cimagf  :: proc(z: complex_float) -> float ---
+	conj    :: proc(z: complex_double) -> complex_double ---
+	conjf   :: proc(z: complex_float) -> complex_float ---
+	cproj   :: proc(z: complex_double) -> complex_double ---
+	cprojf  :: proc(z: complex_float) -> complex_float ---
+	creal   :: proc(z: complex_double) -> double ---
+	crealf  :: proc(z: complex_float) -> float ---
+}
+
+import builtin "core:builtin"
+
+complex_float  :: distinct builtin.complex64
+complex_double :: distinct builtin.complex128
+
+// Cannot implement _Complex_I or _Imaginary_I in Odin, thus
+// complex and imaginary cannot be implement either.
+
+CMPLX :: #force_inline proc(x, y: double) -> complex_double {
+	return builtin.complex(x, y)
+}
+
+CMPLXF :: #force_inline proc(x, y: float) -> complex_float {
+	return builtin.complex(x, y)
+}

core/c/libc/ctype.odin

@@ -0,0 +1,30 @@
+package libc
+
+when ODIN_OS == "windows" {
+	foreign import libc "system:libucrt.lib"
+} else {
+	foreign import libc "system:c"
+}
+
+// 7.4 Character handling
+
+@(default_calling_convention="c")
+foreign libc {
+	// 7.4.1 Character classification functions
+	isalnum  :: proc(c: int) -> int ---
+	isalpha  :: proc(c: int) -> int ---
+	isblank  :: proc(c: int) -> int ---
+	iscntrl  :: proc(c: int) -> int ---
+	isdigit  :: proc(c: int) -> int ---
+	isgraph  :: proc(c: int) -> int ---
+	islower  :: proc(c: int) -> int ---
+	isprint  :: proc(c: int) -> int ---
+	ispunct  :: proc(c: int) -> int ---
+	isspace  :: proc(c: int) -> int ---
+	isupper  :: proc(c: int) -> int ---
+	isxdigit :: proc(c: int) -> int ---
+
+	// 7.4.2 Character case mapping functions
+	tolower  :: proc(c: int) -> int ---
+	toupper  :: proc(c: int) -> int ---
+}

core/c/libc/errno.odin

@@ -0,0 +1,47 @@
+package libc
+
+// 7.5 Errors
+
+when ODIN_OS == "windows" {
+	foreign import libc "system:libucrt.lib"
+} else {
+	foreign import libc "system:c"
+}
+
+// C11 standard only requires the definition of:
+//	EDOM,
+//	EILSEQ
+//	ERANGE
+when ODIN_OS == "linux" || ODIN_OS == "freebsd" {
+	@(private="file")
+	@(default_calling_convention="c")
+	foreign libc {
+		@(link_name="__libc_errno_location")
+		_get_errno :: proc() -> ^int ---
+	}
+
+	EDOM   :: 33
+	EILSEQ :: 84
+	ERANGE :: 34
+}
+
+when ODIN_OS == "windows" {
+	@(private="file")
+	@(default_calling_convention="c")
+	foreign libc {
+		@(link_name="_errno")
+		_get_errno :: proc() -> ^int ---
+	}
+
+	EDOM   :: 33
+	EILSEQ :: 42
+	ERANGE :: 34
+}
+
+// Odin has no way to make an identifier "errno" behave as a function call to
+// read the value, or to produce an lvalue such that you can assign a different
+// error value to errno. To work around this, just expose it as a function like
+// it actually is.
+errno :: #force_inline proc() -> ^int {
+	return _get_errno()
+}

core/c/libc/math.odin

@@ -0,0 +1,402 @@
+package libc
+
+// 7.12 Mathematics
+
+import "core:intrinsics"
+
+when ODIN_OS == "windows" {
+	foreign import libc "system:libucrt.lib"
+} else {
+	foreign import libc "system:c"
+}
+
+// To support C's tgmath behavior we use Odin's explicit procedure overloading,
+// but we cannot use the same names as exported by libc so use @(link_name)
+// and keep them as private symbols of name "libc_"
+@(private="file")
+@(default_calling_convention="c")
+foreign libc {
+	// 7.12.4 Trigonometric functions
+	@(link_name="acos")       libc_acos       :: proc(x: double) -> double ---
+	@(link_name="acosf")      libc_acosf      :: proc(x: float) -> float ---
+	@(link_name="asin")       libc_asin       :: proc(x: double) -> double ---
+	@(link_name="asinf")      libc_asinf      :: proc(x: float) -> float ---
+	@(link_name="atan")       libc_atan       :: proc(x: double) -> double ---
+	@(link_name="atanf")      libc_atanf      :: proc(x: float) -> float ---
+	@(link_name="atan2")      libc_atan2      :: proc(y: double, x: double) -> double ---
+	@(link_name="atan2f")     libc_atan2f     :: proc(y: float, x: float) -> float ---
+	@(link_name="cos")        libc_cos        :: proc(x: double) -> double ---
+	@(link_name="cosf")       libc_cosf       :: proc(x: float) -> float ---
+	@(link_name="sin")        libc_sin        :: proc(x: double) -> double ---
+	@(link_name="sinf")       libc_sinf       :: proc(x: float) -> float ---
+	@(link_name="tan")        libc_tan        :: proc(x: double) -> double ---
+	@(link_name="tanf")       libc_tanf       :: proc(x: float) -> float ---
+
+	// 7.12.5 Hyperbolic functions
+	@(link_name="acosh")      libc_acosh      :: proc(x: double) -> double ---
+	@(link_name="acoshf")     libc_acoshf     :: proc(x: float) -> float ---
+	@(link_name="asinh")      libc_asinh      :: proc(x: double) -> double ---
+	@(link_name="asinhf")     libc_asinhf     :: proc(x: float) -> float ---
+	@(link_name="atanh")      libc_atanh      :: proc(x: double) -> double ---
+	@(link_name="atanhf")     libc_atanhf     :: proc(x: float) -> float ---
+	@(link_name="cosh")       libc_cosh       :: proc(x: double) -> double ---
+	@(link_name="coshf")      libc_coshf      :: proc(x: float) -> float ---
+	@(link_name="sinh")       libc_sinh       :: proc(x: double) -> double ---
+	@(link_name="sinhf")      libc_sinhf      :: proc(x: float) -> float ---
+	@(link_name="tanh")       libc_tanh       :: proc(x: double) -> double ---
+	@(link_name="tanhf")      libc_tanhf      :: proc(x: float) -> float ---
+
+	// 7.12.6 Exponential and logarithmic functions
+	@(link_name="exp")        libc_exp        :: proc(x: double) -> double ---
+	@(link_name="expf")       libc_expf       :: proc(x: float) -> float ---
+	@(link_name="exp2")       libc_exp2       :: proc(x: double) -> double ---
+	@(link_name="exp2f")      libc_exp2f      :: proc(x: float) -> float ---
+	@(link_name="expm1")      libc_expm1      :: proc(x: double) -> double ---
+	@(link_name="expm1f")     libc_expm1f     :: proc(x: float) -> float ---
+	@(link_name="frexp")      libc_frexp      :: proc(value: double, exp: ^int) -> double ---
+	@(link_name="frexpf")     libc_frexpf     :: proc(value: float, exp: ^int) -> float ---
+	@(link_name="ilogb")      libc_ilogb      :: proc(x: double) -> int ---
+	@(link_name="ilogbf")     libc_ilogbf     :: proc(x: float) -> int ---
+	@(link_name="ldexp")      libc_ldexp      :: proc(x: double, exp: int) -> double ---
+	@(link_name="ldexpf")     libc_ldexpf     :: proc(x: float, exp: int) -> float ---
+	@(link_name="log")        libc_log        :: proc(x: double) -> double ---
+	@(link_name="logf")       libc_logf       :: proc(x: float) -> float ---
+	@(link_name="log10")      libc_log10      :: proc(x: double) -> double ---
+	@(link_name="log10f")     libc_log10f     :: proc(x: float) -> float ---
+	@(link_name="log1p")      libc_log1p      :: proc(x: double) -> double ---
+	@(link_name="log1pf")     libc_log1pf     :: proc(x: float) -> float ---
+	@(link_name="log2")       libc_log2       :: proc(x: double) -> double ---
+	@(link_name="log2f")      libc_log2f      :: proc(x: float) -> float ---
+	@(link_name="logb")       libc_logb       :: proc(x: double) -> double ---
+	@(link_name="logbf")      libc_logbf      :: proc(x: float) -> float ---
+	@(link_name="modf")       libc_modf       :: proc(value: double, iptr: ^double) -> double ---
+	@(link_name="modff")      libc_modff      :: proc(value: float, iptr: ^float) -> float ---
+	@(link_name="scalbn")     libc_scalbn     :: proc(x: double, n: int) -> double ---
+	@(link_name="scalbnf")    libc_scalbnf    :: proc(x: float, n: int) -> float ---
+	@(link_name="scalbln")    libc_scalbln    :: proc(x: double, n: long) -> double ---
+	@(link_name="scalblnf")   libc_scalblnf   :: proc(x: float, n: long) -> float ---
+
+	// 7.12.7 Power and absolute-value functions
+	@(link_name="cbrt")       libc_cbrt       :: proc(x: double) -> double ---
+	@(link_name="cbrtf")      libc_cbrtf      :: proc(x: float) -> float ---
+	@(link_name="fabs")       libc_fabs       :: proc(x: double) -> double ---
+	@(link_name="fabsf")      libc_fabsf      :: proc(x: float) -> float ---
+	@(link_name="hypot")      libc_hypot      :: proc(x: double, y: double) -> double ---
+	@(link_name="hypotf")     libc_hypotf     :: proc(x: float, y: float) -> float ---
+	@(link_name="pow")        libc_pow        :: proc(x: double, y: double) -> double ---
+	@(link_name="powf")       libc_powf       :: proc(x: float, y: float) -> float ---
+	@(link_name="sqrt")       libc_sqrt       :: proc(x: double) -> double ---
+	@(link_name="sqrtf")      libc_sqrtf      :: proc(x: float) -> float ---
+
+	// 7.12.8 Error and gamma functions
+	@(link_name="erf")        libc_erf        :: proc(x: double) -> double ---
+	@(link_name="erff")       libc_erff       :: proc(x: float) -> float ---
+	@(link_name="erfc")       libc_erfc       :: proc(x: double) -> double ---
+	@(link_name="erfcf")      libc_erfcf      :: proc(x: float) -> float ---
+	@(link_name="lgamma")     libc_lgamma     :: proc(x: double) -> double ---
+	@(link_name="lgammaf")    libc_lgammaf    :: proc(x: float) -> float ---
+	@(link_name="tgamma")     libc_tgamma     :: proc(x: double) -> double ---
+	@(link_name="tgammaf")    libc_tgammaf    :: proc(x: float) -> float ---
+
+	// 7.12.9 Nearest integer functions
+	@(link_name="ceil")       libc_ceil       :: proc(x: double) -> double ---
+	@(link_name="ceilf")      libc_ceilf      :: proc(x: float) -> float ---
+	@(link_name="floor")      libc_floor      :: proc(x: double) -> double ---
+	@(link_name="floorf")     libc_floorf     :: proc(x: float) -> float ---
+	@(link_name="nearbyint")  libc_nearbyint  :: proc(x: double) -> double ---
+	@(link_name="nearbyintf") libc_nearbyintf :: proc(x: float) -> float ---
+	@(link_name="rint")       libc_rint       :: proc(x: double) -> double ---
+	@(link_name="rintf")      libc_rintf      :: proc(x: float) -> float ---
+	@(link_name="lrint")      libc_lrint      :: proc(x: double) -> long ---
+	@(link_name="lrintf")     libc_lrintf     :: proc(x: float) -> long ---
+	@(link_name="llrint")     libc_llrint     :: proc(x: double) -> longlong ---
+	@(link_name="llrintf")    libc_llrintf    :: proc(x: float) -> longlong ---
+	@(link_name="round")      libc_round      :: proc(x: double) -> double ---
+	@(link_name="roundf")     libc_roundf     :: proc(x: float) -> float ---
+	@(link_name="lround")     libc_lround     :: proc(x: double) -> long ---
+	@(link_name="lroundf")    libc_lroundf    :: proc(x: float) -> long ---
+	@(link_name="llround")    libc_llround    :: proc(x: double) -> longlong ---
+	@(link_name="llroundf")   libc_llroundf   :: proc(x: float) -> longlong ---
+	@(link_name="trunc")      libc_trunc      :: proc(x: double) -> double ---
+	@(link_name="truncf")     libc_truncf     :: proc(x: float) -> float ---
+
+	// 7.12.10 Remainder functions
+	@(link_name="fmod")       libc_fmod       :: proc(x: double, y: double) -> double ---
+	@(link_name="fmodf")      libc_fmodf      :: proc(x: float, y: float) -> float ---
+	@(link_name="remainder")  libc_remainder  :: proc(x: double, y: double) -> double ---
+	@(link_name="remainderf") libc_remainderf :: proc(x: float, y: float) -> float ---
+	@(link_name="remquo")     libc_remquo     :: proc(x: double, y: double, quo: ^int) -> double ---
+	@(link_name="remquof")    libc_remquof    :: proc(x: float, y: float, quo: ^int) -> float ---
+
+	// 7.12.11 Manipulation functions
+	@(link_name="copysign")   libc_copysign   :: proc(x: double, y: double) -> double ---
+	@(link_name="copysignf")  libc_copysignf  :: proc(x: float, y: float) -> float ---
+	@(link_name="nan")        libc_nan        :: proc(tagp: cstring) -> double ---
+	@(link_name="nanf")       libc_nanf       :: proc(tagp: cstring) -> float ---
+	@(link_name="nextafter")  libc_nextafter  :: proc(x: double, y: double) -> double ---
+	@(link_name="nextafterf") libc_nextafterf :: proc(x: float, y: float) -> float ---
+
+	// 7.12.12 Maximum, minimum, and positive difference functions
+	@(link_name="fdim")       libc_fdim       :: proc(x: double, y: double) -> double ---
+	@(link_name="fdimf")      libc_fdimf      :: proc(x: float, y: float) -> float ---
+	@(link_name="fmax")       libc_fmax       :: proc(x: double, y: double) -> double ---
+	@(link_name="fmaxf")      libc_fmaxf      :: proc(x: float, y: float) -> float ---
+	@(link_name="fmin")       libc_fmin       :: proc(x: double, y: double) -> double ---
+	@(link_name="fminf")      libc_fminf      :: proc(x: float, y: float) -> float ---
+	@(link_name="fma")        libc_fma        :: proc(x, y, z: double) -> double ---
+	@(link_name="fmaf")       libc_fmaf       :: proc(x, y, z: float) -> float ---
+}
+
+@(private="file")
+_nan_bit_pattern := ~u64(0)
+
+// On amd64 Windows and Linux, float_t and double_t are respectively both
+// their usual types. On x86 it's not possible to define these types correctly
+// since they would be long double which Odin does have support for.
+float_t          :: float
+double_t         :: double
+
+NAN              := transmute(double)(_nan_bit_pattern)
+INFINITY         :: 1e5000
+
+HUGE_VALF        :: INFINITY
+HUGE_VAL         :: double(INFINITY)
+
+MATH_ERRNO       :: 1
+MATH_ERREXCEPT   :: 2
+
+math_errhandling :: 2 // Windows, Linux, macOS all use this mode.
+
+FP_ILOGBNAN      :: -1 - int((~uint(0)) >> 1)
+FP_ILOGB0        :: FP_ILOGBNAN
+
+// Number classification constants. These do not have to match libc since we
+// implement our own classification functions as libc requires they be macros,
+// which means libc does not export standard functions for them.
+FP_NAN           :: 0
+FP_INFINITE      :: 1
+FP_ZERO          :: 2
+FP_NORMAL        :: 3
+FP_SUBNORMAL     :: 4
+
+@(private)
+_fpclassify :: #force_inline proc(x: double) -> int {
+	u := transmute(uint64_t)x
+	switch e := u >> 52 & 0x7ff; e {
+	case 0:     return FP_SUBNORMAL if (u << 1)  != 0 else FP_ZERO
+	case 0x7ff: return FP_NAN       if (u << 12) != 0 else FP_INFINITE
+	}
+	return FP_NORMAL
+}
+
+@(private)
+_fpclassifyf :: #force_inline proc(x: float) -> int {
+	u := transmute(uint32_t)x
+	switch e := u >> 23 & 0xff; e {
+	case 0:    return FP_SUBNORMAL if (u << 1)  != 0 else FP_ZERO
+	case 0xff: return FP_NAN       if (u << 9)  != 0 else FP_INFINITE
+	}
+	return FP_NORMAL
+}
+
+@(private)
+_signbit :: #force_inline proc(x: double) -> int {
+	return int(transmute(uint64_t)x >> 63)
+}
+
+@(private)
+_signbitf :: #force_inline proc(x: float) -> int {
+	return int(transmute(uint32_t)x >> 31)
+}
+
+isfinite :: #force_inline proc(x: $T) where intrinsics.type_is_float(T) {
+	return fpclassify(x) == FP_INFINITE
+}
+
+isinf :: #force_inline proc(x: $T) where intrinsics.type_is_float(T) {
+	return fpclassify(x) > FP_INFINITE
+}
+
+isnan :: #force_inline proc(x: $T) where intrinsics.type_is_float(T) {
+	return fpclassify(x) == FP_NAN
+}
+
+isnormal :: #force_inline proc(x: $T) where intrinsics.type_is_float(T) {
+	return fpclassify(x) == FP_NORMAL
+}
+
+// These are special in that they avoid float exceptions. They cannot just be
+// implemented as the relational comparisons, as that would produce an invalid
+// "sticky" state that propagates and affects maths results. These need
+// to be implemented natively in Odin assuming isunordered to prevent that.
+isgreater :: #force_inline proc(x, y: $T) where intrinsics.type_is_float(T) {
+	return !isunordered(x, y) && x > y
+}
+
+isgreaterequal :: #force_inline proc(x, y: $T) where intrinsics.type_is_float(T) {
+	return !isunordered(x, y) && x >= y
+}
+
+isless :: #force_inline proc(x, y: $T) where intrinsics.type_is_float(T) {
+	return !isunordered(x, y) && x < y
+}
+
+islessequal :: #force_inline proc(x, y: $T) where intrinsics.type_is_float(T) {
+	return !isunordered(x, y) && x <= y
+}
+
+islessgreater :: #force_inline proc(x, y: $T) where intrinsics.type_is_float(T) {
+	return !isunordered(x, y) && x <= y
+}
+
+isunordered :: #force_inline proc(x, y: $T) where intrinsics.type_is_float(T) {
+	if isnan(x) {
+		// Force evaluation of y to propagate exceptions for ordering semantics.
+		// To ensure correct semantics of IEEE 754 this cannot be compiled away.
+		sink: T
+		intrinsics.volatile_store(&sink, intrinsics.volatile_load(&y))
+		return true
+	}
+	return isnan(y)
+}
+
+fpclassify :: proc{_fpclassify, _fpclassifyf}
+signbit    :: proc{_signbit, _signbitf}
+
+// Emulate tgmath.h behavior with explicit procedure overloading here.
+acos       :: proc{libc_acos, libc_acosf, cacos, cacosf}
+asin       :: proc{libc_asin, libc_asinf, casin, casinf}
+atan       :: proc{libc_atan, libc_atanf, catan, catanf}
+atan2      :: proc{libc_atan2, libc_atan2f}
+cos        :: proc{libc_cos, libc_cosf, ccos, ccosf}
+sin        :: proc{libc_sin, libc_sinf, csin, csinf}
+tan        :: proc{libc_tan, libc_tanf, ctan, ctanf}
+
+acosh      :: proc{libc_acosh, libc_acoshf, cacosh, cacoshf}
+asinh      :: proc{libc_asinh, libc_asinhf, casinh, casinhf}
+atanh      :: proc{libc_atanh, libc_atanhf, catanh, catanhf}
+cosh       :: proc{libc_cosh, libc_coshf, ccosh, ccoshf}
+sinh       :: proc{libc_sinh, libc_sinhf, csinh, csinhf}
+tanh       :: proc{libc_tanh, libc_tanhf, ctanh, ctanhf}
+
+exp        :: proc{libc_exp, libc_expf, cexp, cexpf}
+exp2       :: proc{libc_exp2, libc_exp2f} 
+expm1      :: proc{libc_expm1, libc_expm1f}
+frexp      :: proc{libc_frexp, libc_frexpf}
+ilogb      :: proc{libc_ilogb, libc_ilogbf}
+ldexp      :: proc{libc_ldexp, libc_ldexpf}
+log        :: proc{libc_log, libc_logf, clog, clogf}
+log10      :: proc{libc_log10, libc_log10f}
+log1p      :: proc{libc_log1p, libc_log1pf}
+log2       :: proc{libc_log2, libc_log2f}
+logb       :: proc{libc_logb, libc_logbf}
+modf       :: proc{libc_modf, libc_modff}
+scalbn     :: proc{libc_scalbn, libc_scalbnf}
+scalbln    :: proc{libc_scalbln, libc_scalblnf}
+
+cbrt       :: proc{libc_cbrt, libc_cbrtf}
+fabs       :: proc{libc_fabs, libc_fabsf, cabs, cabsf}
+hypot      :: proc{libc_hypot, libc_hypotf}
+pow        :: proc{libc_pow, libc_powf, cpow, cpowf}
+sqrt       :: proc{libc_sqrt, libc_sqrtf, csqrt, csqrtf}
+
+erf        :: proc{libc_erf, libc_erff}
+erfc       :: proc{libc_erfc, libc_erfcf}
+lgamma     :: proc{libc_lgamma, libc_lgammaf}
+tgamma     :: proc{libc_tgamma, libc_tgammaf}
+
+ceil       :: proc{libc_ceil, libc_ceilf}
+floor      :: proc{libc_floor, libc_floorf}
+nearbyint  :: proc{libc_nearbyint, libc_nearbyintf}
+rint       :: proc{libc_rint, libc_rintf}
+lrint      :: proc{libc_lrint, libc_lrintf}
+llrint     :: proc{libc_llrint, libc_llrintf}
+round      :: proc{libc_round, libc_roundf}
+lround     :: proc{libc_lround, libc_lroundf}
+llround    :: proc{libc_llround, libc_llroundf}
+trunc      :: proc{libc_trunc, libc_truncf}
+
+fmod       :: proc{libc_fmod, libc_fmodf}
+remainder  :: proc{libc_remainder, libc_remainderf}
+remquo     :: proc{libc_remquo, libc_remquof}
+
+copysign   :: proc{libc_copysign, libc_copysignf}
+nextafter  :: proc{libc_nextafter, libc_nextafterf}
+
+fdim       :: proc{libc_fdim, libc_fdimf}
+fmax       :: proc{libc_fmax, libc_fmaxf}
+fmin       :: proc{libc_fmin, libc_fminf}
+fma        :: proc{libc_fma, libc_fmaf}
+
+// But retain the 'f' suffix-variant functions as well so they can be used,
+// a trick is used here where we use explicit procedrual overloading of one
+// procedure. This is done because the foreign block is marked @(private) and
+// aliasing functions does not remove privateness from the entity.
+acosf      :: proc{libc_acosf}
+asinf      :: proc{libc_asinf}
+atanf      :: proc{libc_atanf}
+atan2f     :: proc{libc_atan2f}
+cosf       :: proc{libc_cosf}
+sinf       :: proc{libc_sinf}
+tanf       :: proc{libc_tanf}
+
+acoshf     :: proc{libc_acoshf}
+asinhf     :: proc{libc_asinhf}
+atanhf     :: proc{libc_atanhf}
+coshf      :: proc{libc_coshf}
+sinhf      :: proc{libc_sinhf}
+tanhf      :: proc{libc_tanhf}
+
+expf       :: proc{libc_expf}
+exp2f      :: proc{libc_exp2f}
+expm1f     :: proc{libc_expm1f}
+frexpf     :: proc{libc_frexpf}
+ilogbf     :: proc{libc_ilogbf}
+ldexpf     :: proc{libc_ldexpf}
+logf       :: proc{libc_logf}
+log10f     :: proc{libc_log10f}
+log1pf     :: proc{libc_log1pf}
+log2f      :: proc{libc_log2f}
+logbf      :: proc{libc_logbf}
+modff      :: proc{libc_modff}
+scalbnf    :: proc{libc_scalbnf}
+scalblnf   :: proc{libc_scalblnf}
+
+cbrtf      :: proc{libc_cbrtf}
+fabsf      :: proc{libc_fabsf}
+hypotf     :: proc{libc_hypotf}
+powf       :: proc{libc_powf}
+sqrtf      :: proc{libc_sqrtf}
+
+erff       :: proc{libc_erff}
+erfcf      :: proc{libc_erfcf}
+lgammaf    :: proc{libc_lgammaf}
+tgammaf    :: proc{libc_tgammaf}
+
+ceilf      :: proc{libc_ceilf}
+floorf     :: proc{libc_floorf}
+nearbyintf :: proc{libc_nearbyintf}
+rintf      :: proc{libc_rintf}
+lrintf     :: proc{libc_lrintf}
+llrintf    :: proc{libc_llrintf}
+roundf     :: proc{libc_roundf}
+lroundf    :: proc{libc_lroundf}
+llroundf   :: proc{libc_llroundf}
+truncf     :: proc{libc_truncf}
+
+fmodf      :: proc{libc_fmodf}
+remainderf :: proc{libc_remainderf}
+remquof    :: proc{libc_remquof}
+
+copysignf  :: proc{libc_copysignf}
+nextafterf :: proc{libc_nextafterf}
+
+fdimf      :: proc{libc_fdimf} 
+fmaxf      :: proc{libc_fmaxf}
+fminf      :: proc{libc_fminf}
+fmaf       :: proc{libc_fmaf}
+
+// These two functions are special and not made type generic in tgmath.h since
+// they only differ by their return type.
+nan        :: proc{libc_nan}
+nanf       :: proc{libc_nanf}

core/c/libc/setjmp.odin

@@ -0,0 +1,65 @@
+package libc
+
+// 7.13 Nonlocal jumps
+
+when ODIN_OS == "windows" {
+	foreign import libc "system:libucrt.lib"
+} else {
+	foreign import libc "system:c"
+}
+
+when ODIN_OS == "windows" {
+	@(default_calling_convention="c")
+	foreign libc {
+		// 7.13.1 Save calling environment
+		//
+		// NOTE(dweiler): C11 requires setjmp be a macro, which means it won't
+		// necessarily export a symbol named setjmp but rather _setjmp in the case
+		// of musl, glibc, BSD libc, and msvcrt.
+		//
+		/// NOTE(dweiler): UCRT has two implementations of longjmp. One that performs
+		// stack unwinding and one that doesn't. The choice of which to use depends on a
+		// flag which is set inside the jmp_buf structure given to setjmp. The default
+		// behavior is to unwind the stack. Within Odin, we cannot use the stack
+		// unwinding version as the unwinding information isn't present. To opt-in to
+		// the regular non-unwinding version we need a way to set this flag. Since the
+		// location of the flag within the struct is not defined or part of the ABI and
+		// can change between versions of UCRT, we must rely on setjmp to set it. It
+		// turns out that setjmp receives this flag in the RDX register on Win64, this
+		// just so happens to coincide with the second argument of a function in the
+		// Win64 ABI. By giving our setjmp a second argument with the value of zero,
+		// the RDX register will contain zero and correctly set the flag to disable
+		// stack unwinding.
+		@(link_name="_setjmp")
+		setjmp  :: proc(env: ^jmp_buf, hack: rawptr = nil) -> int ---
+	}
+} else {
+	@(default_calling_convention="c")
+	foreign libc {
+		// 7.13.1 Save calling environment
+		//
+		// NOTE(dweiler): C11 requires setjmp be a macro, which means it won't
+		// necessarily export a symbol named setjmp but rather _setjmp in the case
+		// of musl, glibc, BSD libc, and msvcrt.
+		@(link_name="_setjmp")
+		setjmp  :: proc(env: ^jmp_buf) -> int ---
+	}
+}
+
+@(default_calling_convention="c")
+foreign libc {
+	// 7.13.2 Restore calling environment
+	longjmp :: proc(env: ^jmp_buf, val: int) -> ! ---
+}
+
+// The C99 Rationale describes jmp_buf as being an array type for backward
+// compatibility. Odin does not need to honor this and couldn't as arrays in
+// Odin don't decay to pointers. It is somewhat easy for us to bind this, we
+// just need to ensure the structure contains enough storage with appropriate
+// alignment. Since there are no types in C with an alignment larger than
+// that of max_align_t, which cannot be larger than sizeof(long double) as any
+// other exposed type wouldn't be valid C, the maximum alignment possible in a
+// strictly conformant C implementation is 16 on the platforms we care about.
+// The choice of 4096 bytes for storage of this type is more than enough on all
+// relevant platforms.
+jmp_buf :: struct #align 16 { _: [4096]char, }

core/c/libc/signal.odin

@@ -0,0 +1,46 @@
+package libc
+
+// 7.14 Signal handling
+
+when ODIN_OS == "windows" {
+	foreign import libc "system:libucrt.lib"
+} else {
+	foreign import libc "system:c"
+}
+
+sig_atomic_t :: distinct atomic_int
+
+SIG_ATOMIC_MIN :: min(sig_atomic_t)
+SIG_ATOMIC_MAX :: max(sig_atomic_t)
+
+@(default_calling_convention="c")
+foreign libc {
+	signal :: proc(sig: int, func: proc "c" (int)) -> proc "c" (int) ---
+	raise  :: proc(sig: int) -> int ---
+}
+
+when ODIN_OS == "windows" {
+	SIG_ERR :: rawptr(~uintptr(0)) 
+	SIG_DFL :: rawptr(uintptr(0))
+	SIG_IGN :: rawptr(uintptr(1))
+
+	SIGABRT :: 22
+	SIGFPE  :: 8
+	SIGILL  :: 4
+	SIGINT  :: 2
+	SIGSEGV :: 11
+	SIGTERM :: 15
+}
+
+when ODIN_OS == "linux" || ODIN_OS == "freebsd" || ODIN_OS == "darwin" {
+	SIG_ERR  :: rawptr(~uintptr(0))
+	SIG_DFL  :: rawptr(uintptr(0))
+	SIG_IGN  :: rawptr(uintptr(1)) 
+
+	SIGABRT  :: 6
+	SIGFPE   :: 8
+	SIGILL   :: 4
+	SIGINT   :: 2
+	SIGSEGV  :: 11
+	SIGTERM  :: 15
+}

core/c/libc/stdarg.odin

@@ -0,0 +1,41 @@
+package libc
+
+// 7.16 Variable arguments
+
+import "core:intrinsics"
+
+@(private="file")
+@(default_calling_convention="none")
+foreign _ {
+	@(link_name="llvm.va_start") _va_start :: proc(arglist: ^i8) ---
+	@(link_name="llvm.va_end")   _va_end   :: proc(arglist: ^i8) ---
+	@(link_name="llvm.va_copy")  _va_copy  :: proc(dst, src: ^i8) ---
+}
+
+// Since there are no types in C with an alignment larger than that of
+// max_align_t, which cannot be larger than sizeof(long double) as any other
+// exposed type wouldn't be valid C, the maximum alignment possible in a
+// strictly conformant C implementation is 16 on the platforms we care about.
+// The choice of 4096 bytes for storage of this type is more than enough on all
+// relevant platforms.
+va_list :: struct #align 16 {
+	_: [4096]u8,
+}
+
+va_start :: #force_inline proc(ap: ^va_list, _: any) {
+	_va_start(cast(^i8)ap)
+}
+
+va_end :: #force_inline proc(ap: ^va_list) {
+	_va_end(cast(^i8)ap)
+}
+
+va_copy :: #force_inline proc(dst, src: ^va_list) {
+	_va_copy(cast(^i8)dst, cast(^i8)src)
+}
+
+// We cannot provide va_arg as there is no way to create "C" style procedures
+// in Odin which take variable arguments the C way. The #c_vararg attribute only
+// exists for foreign imports. That being said, being able to copy a va_list,
+// as well as start and end one is necessary in some functions, the va_list
+// taking functions in libc as an example.

core/c/libc/stdatomic.odin

@@ -0,0 +1,416 @@
+package libc
+
+// 7.17 Atomics
+
+import "core:intrinsics"
+
+ATOMIC_BOOL_LOCK_FREE     :: true
+ATOMIC_CHAR_LOCK_FREE     :: true
+ATOMIC_CHAR16_T_LOCK_FREE :: true
+ATOMIC_CHAR32_T_LOCK_FREE :: true
+ATOMIC_WCHAR_T_LOCK_FREE  :: true
+ATOMIC_SHORT_LOCK_FREE    :: true
+ATOMIC_INT_LOCK_FREE      :: true
+ATOMIC_LONG_LOCK_FREE     :: true
+ATOMIC_LLONG_LOCK_FREE    :: true
+ATOMIC_POINTER_LOCK_FREE  :: true
+
+// 7.17.3 Order and consistency
+memory_order :: enum int {
+	relaxed,
+	consume,
+	acquire,
+	release,
+	acq_rel,
+	seq_cst,
+}
+
+memory_order_relaxed :: memory_order.relaxed
+memory_order_consume :: memory_order.consume
+memory_order_acquire :: memory_order.acquire
+memory_order_release :: memory_order.release
+memory_order_acq_rel :: memory_order.acq_rel
+memory_order_seq_cst :: memory_order.seq_cst
+
+// 7.17.2 Initialization
+ATOMIC_VAR_INIT :: #force_inline proc(value: $T) -> T {
+	return value
+}
+
+atomic_init :: #force_inline proc(obj: ^$T, value: T) {
+	intrinsics.atomic_store(obj, value)
+}
+
+kill_dependency :: #force_inline proc(value: $T) -> T {
+	return value
+}
+
+// 7.17.4 Fences
+atomic_thread_fence :: #force_inline proc(order: memory_order) {
+	switch (order) {
+	case .relaxed:
+		return
+	case .consume:
+		intrinsics.atomic_fence_acq()
+	case .acquire:
+		intrinsics.atomic_fence_acq()
+	case .release:
+		intrinsics.atomic_fence_rel()
+	case .acq_rel:
+		intrinsics.atomic_fence_acqrel()
+	case .seq_cst:
+		intrinsics.atomic_fence_acqrel()
+	}
+}
+
+atomic_signal_fence :: #force_inline proc(order: memory_order) {
+	atomic_thread_fence(order)
+}
+
+// 7.17.5 Lock-free property
+atomic_is_lock_free :: #force_inline proc(obj: ^$T) -> bool {
+	return size_of(T) <= 8 && (intrinsics.type_is_integer(T) || intrinsics.type_is_pointer(T))
+}
+
+// 7.17.6 Atomic integer types
+atomic_bool           :: distinct bool
+atomic_char           :: distinct char
+atomic_schar          :: distinct char
+atomic_uchar          :: distinct uchar
+atomic_short          :: distinct short
+atomic_ushort         :: distinct ushort
+atomic_int            :: distinct int
+atomic_uint           :: distinct uint
+atomic_long           :: distinct long
+atomic_ulong          :: distinct ulong
+atomic_llong          :: distinct longlong
+atomic_ullong         :: distinct ulonglong
+atomic_char16_t       :: distinct char16_t
+atomic_char32_t       :: distinct char32_t
+atomic_wchar_t        :: distinct wchar_t
+atomic_int_least8_t   :: distinct int_least8_t
+atomic_uint_least8_t  :: distinct uint_least8_t
+atomic_int_least16_t  :: distinct int_least16_t
+atomic_uint_least16_t :: distinct uint_least16_t
+atomic_int_least32_t  :: distinct int_least32_t
+atomic_uint_least32_t :: distinct uint_least32_t
+atomic_int_least64_t  :: distinct int_least64_t
+atomic_uint_least64_t :: distinct uint_least64_t
+atomic_int_fast8_t    :: distinct int_fast8_t
+atomic_uint_fast8_t   :: distinct uint_fast8_t
+atomic_int_fast16_t   :: distinct int_fast16_t
+atomic_uint_fast16_t  :: distinct uint_fast16_t
+atomic_int_fast32_t   :: distinct int_fast32_t
+atomic_uint_fast32_t  :: distinct uint_fast32_t
+atomic_int_fast64_t   :: distinct int_fast64_t
+atomic_uint_fast64_t  :: distinct uint_fast64_t
+atomic_intptr_t       :: distinct intptr_t
+atomic_uintptr_t      :: distinct uintptr_t
+atomic_size_t         :: distinct size_t
+atomic_ptrdiff_t      :: distinct ptrdiff_t
+atomic_intmax_t       :: distinct intmax_t
+atomic_uintmax_t      :: distinct uintmax_t
+
+// 7.17.7 Operations on atomic types
+atomic_store :: #force_inline proc(object: ^$T, desired: T) {
+	intrinsics.atomic_store(object, desired)
+}
+
+atomic_store_explicit :: #force_inline proc(object: ^$T, desired: T, order: memory_order) {
+	assert(order != .consume)
+	assert(order != .acquire)
+	assert(order != .acq_rel)
+
+	#partial switch (order) {
+	case .relaxed:
+		intrinsics.atomic_store_relaxed(object, desired)
+	case .release:
+		intrinsics.atomic_store_rel(object, desired)
+	case .seq_cst:
+		intrinsics.atomic_store(object, desired)
+	}
+}
+
+atomic_load :: #force_inline proc(object: ^$T) -> T {
+	return intrinsics.atomic_load(object)
+}
+
+atomic_load_explicit :: #force_inline proc(object: ^$T, order: memory_order) {
+	assert(order != .release)
+	assert(order != .acq_rel)
+
+	#partial switch (order) {
+	case .relaxed:
+		return intrinsics.atomic_load_relaxed(object)
+	case .consume:
+		return intrinsics.atomic_load_acq(object)
+	case .acquire:
+		return intrinsics.atomic_load_acq(object)
+	case .seq_cst:
+		return intrinsics.atomic_load(object)
+	}
+}
+
+atomic_exchange :: #force_inline proc(object: ^$T, desired: T) -> T {
+	return intrinsics.atomic_xchg(object, desired)
+}
+
+atomic_exchange_explicit :: #force_inline proc(object: ^$T, desired: T, order: memory_order) -> T {
+	switch (order) {
+	case .relaxed:
+		return intrinsics.atomic_xchg_relaxed(object, desired)
+	case .consume:
+		return intrinsics.atomic_xchg_acq(object, desired)
+	case .acquire:
+		return intrinsics.atomic_xchg_acq(object, desired)
+	case .release:
+		return intrinsics.atomic_xchg_rel(object, desired)
+	case .acq_rel:
+		return intrinsics.atomic_xchg_acqrel(object, desired)
+	case .seq_cst:
+		return intrinsics.atomic_xchg(object, desired)
+	}
+	return false
+}
+
+// C does not allow failure memory order to be order_release or acq_rel.
+// Similarly, it does not allow the failure order to be stronger than success
+// order. Since consume and acquire are both monotonic, we can count them as
+// one, for a total of three memory orders that are relevant in compare exchange.
+// 	relaxed, acquire (consume), seq_cst.
+// The requirement that the failure order cannot be stronger than success limits
+// the valid combinations for the failure order to this table:
+// 	[success = seq_cst, failure = seq_cst] => _
+// 	[success = acquire, failure = seq_cst] => acq
+// 	[success = release, failure = seq_cst] => rel
+// 	[success = acq_rel, failure = seq_cst] => acqrel
+// 	[success = relaxed, failure = relaxed] => relaxed
+// 	[success = seq_cst, failure = relaxed] => failrelaxed
+// 	[success = seq_cst, failure = acquire] => failacq
+// 	[success = acquire, failure = relaxed] => acq_failrelaxed
+// 	[success = acq_rel, failure = relaxed] => acqrel_failrelaxed
+atomic_compare_exchange_strong :: #force_inline proc(object, expected: ^$T, desired: T) {
+	value, ok := intrinsics.atomic_cxchg(object, expected^, desired)
+	if !ok { expected^ = value } 
+	return ok
+}
+
+atomic_compare_exchange_strong_explicit :: #force_inline proc(object, expected: ^$T, desired: T, success, failure: memory_order) {
+	assert(failure != .release)
+	assert(failure != .acq_rel)
+
+	value: T; ok: bool
+	#partial switch (failure) {
+	case .seq_cst:
+		assert(success != .relaxed)
+		#partial switch (success) {
+		case .seq_cst:
+			value, ok := intrinsics.atomic_cxchg(object, expected^, desired)
+		case .acquire:
+			value, ok := intrinsics.atomic_cxchg_acq(object, expected^, desired)
+		case .consume:
+			value, ok := intrinsics.atomic_cxchg_acq(object, expected^, desired)
+		case .release:
+			value, ok := intrinsics.atomic_cxchg_rel(object, expected^, desired)
+		case .acq_rel:
+			value, ok := intrinsics.atomic_cxchg_acqrel(object, expected^, desired)
+		}
+	case .relaxed:
+		assert(success != .release)
+		#partial switch (success) {
+		case .relaxed:
+			value, ok := intrinsics.atomic_cxchg_relaxed(object, expected^, desired)
+		case .seq_cst:
+			value, ok := intrinsics.atomic_cxchg_failrelaxed(object, expected^, desired)
+		case .acquire:
+			value, ok := intrinsics.atomic_cxchg_acq_failrelaxed(object, expected^, desired)
+		case .consume:
+			value, ok := intrinsics.atomic_cxchg_acq_failrelaxed(object, expected^, desired)
+		case .acq_rel:
+			value, ok := intrinsics.atomic_cxchg_acqrel_failrelaxed(object, expected^, desired)
+		}
+	case .consume:
+		fallthrough
+	case .acquire:
+		assert(success == .seq_cst)
+		value, ok := intrinsics.atomic_cxchg_failacq(object, expected^, desired)
+
+	}
+	if !ok { expected^ = value }
+	return ok
+}
+
+atomic_compare_exchange_weak :: #force_inline proc(object, expected: ^$T, desired: T) {
+	value, ok := intrinsics.atomic_cxchgweak(object, expected^, desired)
+	if !ok { expected^ = value }
+	return ok
+}
+
+atomic_compare_exchange_weak_explicit :: #force_inline proc(object, expected: ^$T, desited: T, success, failure: memory_order) {
+	assert(failure != .release)
+	assert(failure != .acq_rel)
+
+	value: T; ok: bool
+	#partial switch (failure) {
+	case .seq_cst:
+		assert(success != .relaxed)
+		#partial switch (success) {
+		case .seq_cst:
+			value, ok := intrinsics.atomic_cxchgweak(object, expected^, desired)
+		case .acquire:
+			value, ok := intrinsics.atomic_cxchgweak_acq(object, expected^, desired)
+		case .consume:
+			value, ok := intrinsics.atomic_cxchgweak_acq(object, expected^, desired)
+		case .release:
+			value, ok := intrinsics.atomic_cxchgweak_rel(object, expected^, desired)
+		case .acq_rel:
+			value, ok := intrinsics.atomic_cxchgweak_acqrel(object, expected^, desired)
+		}
+	case .relaxed:
+		assert(success != .release)
+		#partial switch (success) {
+		case .relaxed:
+			value, ok := intrinsics.atomic_cxchgweak_relaxed(object, expected^, desired)
+		case .seq_cst:
+			value, ok := intrinsics.atomic_cxchgweak_failrelaxed(object, expected^, desired)
+		case .acquire:
+			value, ok := intrinsics.atomic_cxchgweak_acq_failrelaxed(object, expected^, desired)
+		case .consume:
+			value, ok := intrinsics.atomic_cxchgweak_acq_failrelaxed(object, expected^, desired)
+		case .acq_rel:
+			value, ok := intrinsics.atomic_cxchgweak_acqrel_failrelaxed(object, expected^, desired)
+		}
+	case .consume:
+		fallthrough
+	case .acquire:
+		assert(success == .seq_cst)
+		value, ok := intrinsics.atomic_cxchgweak_failacq(object, expected^, desired)
+
+	}
+	if !ok { expected^ = value }
+	return ok
+}
+
+// 7.17.7.5 The atomic_fetch and modify generic functions
+atomic_fetch_add :: #force_inline proc(object: ^$T, operand: T) -> T {
+	return intrinsics.atomic_add(object, operand)
+}
+
+atomic_fetch_add_explicit :: #force_inline proc(object: ^$T, operand: T, order: memory_order) -> T {
+	switch (order) {
+	case .relaxed:
+		return intrinsics.atomic_add_relaxed(object, operand)
+	case .consume:
+		return intrinsics.atomic_add_acq(object, operand)
+	case .acquire:
+		return intrinsics.atomic_add_acq(object, operand)
+	case .release:
+		return intrinsics.atomic_add_rel(object, operand)
+	case .acq_rel:
+		return intrinsics.atomic_add_acqrel(object, operand)
+	case .seq_cst:
+		return intrinsics.atomic_add(object, operand)
+	}
+}
+
+atomic_fetch_sub :: #force_inline proc(object: ^$T, operand: T) -> T {
+	return intrinsics.atomic_sub(object, operand)
+}
+
+atomic_fetch_sub_explicit :: #force_inline proc(object: ^$T, operand: T, order: memory_order) -> T {
+	switch (order) {
+	case .relaxed:
+		return intrinsics.atomic_sub_relaxed(object, operand)
+	case .consume:
+		return intrinsics.atomic_sub_acq(object, operand)
+	case .acquire:
+		return intrinsics.atomic_sub_acq(object, operand)
+	case .release:
+		return intrinsics.atomic_sub_rel(object, operand)
+	case .acq_rel:
+		return intrinsics.atomic_sub_acqrel(object, operand)
+	case .seq_cst:
+		return intrinsics.atomic_sub(object, operand)
+	}
+}
+
+atomic_fetch_or :: #force_inline proc(object: ^$T, operand: T) -> T {
+	return intrinsics.atomic_or(object, operand)
+}
+
+atomic_fetch_or_explicit :: #force_inline proc(object: ^$T, operand: T, order: memory_order) -> T {
+	switch (order) {
+	case .relaxed:
+		return intrinsics.atomic_or_relaxed(object, operand)
+	case .consume:
+		return intrinsics.atomic_or_acq(object, operand)
+	case .acquire:
+		return intrinsics.atomic_or_acq(object, operand)
+	case .release:
+		return intrinsics.atomic_or_rel(object, operand)
+	case .acq_rel:
+		return intrinsics.atomic_or_acqrel(object, operand)
+	case .seq_cst:
+		return intrinsics.atomic_or(object, operand)
+	}
+}
+
+atomic_fetch_xor :: #force_inline proc(object: ^$T, operand: T) -> T {
+	return intrinsics.atomic_xor(object, operand)
+}
+
+atomic_fetch_xor_explicit :: #force_inline proc(object: ^$T, operand: T, order: memory_order) -> T {
+	switch (order) {
+	case .relaxed:
+		return intrinsics.atomic_xor_relaxed(object, operand)
+	case .consume:
+		return intrinsics.atomic_xor_acq(object, operand)
+	case .acquire:
+		return intrinsics.atomic_xor_acq(object, operand)
+	case .release:
+		return intrinsics.atomic_xor_rel(object, operand)
+	case .acq_rel:
+		return intrinsics.atomic_xor_acqrel(object, operand)
+	case .seq_cst:
+		return intrinsics.atomic_xor(object, operand)
+	}
+}
+
+atomic_fetch_and :: #force_inline proc(object: ^$T, operand: T) -> T {
+	return intrinsics.atomic_and(object, operand)
+}
+atomic_fetch_and_explicit :: #force_inline proc(object: ^$T, operand: T, order: memory_order) -> T {
+	switch (order) {
+	case .relaxed:
+		return intrinsics.atomic_and_relaxed(object, operand)
+	case .consume:
+		return intrinsics.atomic_and_acq(object, operand)
+	case .acquire:
+		return intrinsics.atomic_and_acq(object, operand)
+	case .release:
+		return intrinsics.atomic_and_rel(object, operand)
+	case .acq_rel:
+		return intrinsics.atomic_and_acqrel(object, operand)
+	case .seq_cst:
+		return intrinsics.atomic_and(object, operand)
+	}
+}
+
+// 7.17.8 Atomic flag type and operations
+atomic_flag :: distinct atomic_bool
+
+atomic_flag_test_and_set :: #force_inline proc(flag: ^atomic_flag) -> bool {
+	return bool(atomic_exchange(flag, atomic_flag(true)))
+}
+
+atomic_flag_test_and_set_explicit :: #force_inline proc(flag: ^atomic_flag, order: memory_order) -> bool {
+	return bool(atomic_exchange_explicit(flag, atomic_flag(true), order))
+}
+
+atomic_flag_clear :: #force_inline proc(flag: ^atomic_flag) {
+	atomic_store(flag, atomic_flag(false))
+}
+
+atomic_flag_clear_explicit :: #force_inline proc(flag: ^atomic_flag, order: memory_order) {
+	atomic_store_explicit(flag, atomic_flag(false), order)
+}

core/c/libc/stdio.odin

@@ -0,0 +1,135 @@
+package libc
+
+when ODIN_OS == "windows" {
+	foreign import libc "system:libucrt.lib"
+} else {
+	foreign import libc "system:c"
+}
+
+// 7.21 Input/output
+
+FILE :: struct {}
+
+// MSVCRT compatible.
+when ODIN_OS == "windows" {
+	_IOFBF       :: 0x0000
+	_IONBF       :: 0x0004
+	_IOLBF       :: 0x0040
+
+	BUFSIZ       :: 512
+
+	EOF          :: int(-1)
+
+	FOPEN_MAX    :: 20
+
+	FILENAME_MAX :: 260
+
+	L_tmpnam     :: 15 // "\\" + 12 + NUL
+
+	SEEK_SET     :: 0
+	SEEK_CUR     :: 1
+	SEEK_END     :: 2
+
+	TMP_MAX      :: 32767 // SHRT_MAX
+
+	fpos_t       :: distinct i64
+
+	@(private="file")
+	@(default_calling_convention="c")
+	foreign libc {
+		__acrt_iob_func :: proc (index: uint) -> ^FILE ---
+	}
+
+	stdin  := __acrt_iob_func(0)
+	stdout := __acrt_iob_func(1)
+	stderr := __acrt_iob_func(2)
+}
+
+// GLIBC and MUSL compatible.
+when ODIN_OS == "linux" {
+	fpos_t        :: struct #raw_union { _: [16]char, _: longlong, _: double, }
+
+	_IOFBF        :: 0
+	_IOLBF        :: 1
+	_IONBF        :: 2
+
+	BUFSIZ        :: 1024
+
+	EOF           :: int(-1)
+
+	FOPEN_MAX     :: 1000
+
+	FILENAME_MAX  :: 4096
+
+	L_tmpnam      :: 20
+
+	SEEK_SET      :: 0
+	SEEK_CUR      :: 1
+	SEEK_END      :: 2
+
+	TMP_MAX       :: 10000
+
+	foreign libc {
+		stderr: ^FILE
+		stdin:  ^FILE
+		stdout: ^FILE
+	}
+}
+
+@(default_calling_convention="c")
+foreign libc {
+	// 7.21.4 Operations on files
+	remove    :: proc(filename: cstring) -> int ---
+	rename    :: proc(old, new: cstring) -> int ---
+	tmpfile   :: proc() -> ^FILE ---
+	tmpnam    :: proc(s: [^]char) -> [^]char ---
+
+	// 7.21.5 File access functions
+	fclose    :: proc(stream: ^FILE) -> int ---
+	fflush    :: proc(stream: ^FILE) -> int ---
+	fopen     :: proc(filename, mode: cstring) -> ^FILE ---
+	freopen   :: proc(filename, mode: cstring, stream: ^FILE) -> ^FILE ---
+	setbuf    :: proc(stream: ^FILE, buf: [^]char) ---
+	setvbuf   :: proc(stream: ^FILE, buf: [^]char, mode: int, size: size_t) -> int ---
+
+	// 7.21.6 Formatted input/output functions
+	fprintf   :: proc(stream: ^FILE, format: cstring, #c_vararg args: ..any) -> int ---
+	fscanf    :: proc(stream: ^FILE, format: cstring, #c_vararg args: ..any) -> int ---
+	printf    :: proc(format: cstring, #c_vararg args: ..any) -> int ---
+	scanf     :: proc(format: cstring, #c_vararg args: ..any) -> int ---
+	snprintf  :: proc(s: [^]char, format: cstring, #c_vararg args: ..any) -> int ---
+	sscanf    :: proc(s, format: cstring, #c_vararg args: ..any) -> int ---
+	vfprintf  :: proc(stream: ^FILE, format: cstring, arg: ^va_list) -> int ---
+	vfscanf   :: proc(stream: ^FILE, format: cstring, arg: ^va_list) -> int ---
+	vprintf   :: proc(format: cstring, arg: ^va_list) -> int ---
+	vscanf    :: proc(format: cstring, arg: ^va_list) -> int ---
+	vsnprintf :: proc(s: [^]char, n: size_t, format: cstring, arg: ^va_list) -> int ---
+	vsprintf  :: proc(s: [^]char, format: cstring, arg: ^va_list) -> int ---
+	vsscanf   :: proc(s, format: cstring, arg: ^va_list) -> int ---
+
+	// 7.21.7 Character input/output functions
+	fgetc     :: proc(stream: ^FILE) -> int ---
+	fgets     :: proc(s: [^]char, n: int, stream: ^FILE) -> [^]char ---
+	fputc     :: proc(s: cstring, stream: ^FILE) -> int ---
+	getc      :: proc(stream: ^FILE) -> int ---
+	getchar   :: proc() -> int ---
+	putc      :: proc(c: int, stream: ^FILE) -> int ---
+	putchar   :: proc() -> int ---
+	puts      :: proc(s: cstring) -> int ---
+	ungetc    :: proc(c: int, stream: ^FILE) -> int ---
+	fread     :: proc(ptr: rawptr, size: size_t, stream: ^FILE) -> size_t ---
+	fwrite    :: proc(ptr: rawptr, size: size_t, nmemb: size_t, stream: ^FILE) -> size_t ---
+
+	// 7.21.9 File positioning functions
+	fgetpos   :: proc(stream: ^FILE, pos: ^fpos_t) -> int ---
+	fseek     :: proc(stream: ^FILE, offset: long, whence: int) -> int ---
+	fsetpos   :: proc(stream: ^FILE, pos: ^fpos_t) -> int ---
+	ftell     :: proc(stream: ^FILE) -> long ---
+	rewind    :: proc(stream: ^FILE) ---
+
+	// 7.21.10 Error-handling functions
+	clearerr  :: proc(stream: ^FILE) ---
+	feof      :: proc(stream: ^FILE) -> int ---
+	ferror    :: proc(stream: ^FILE) -> int ---
+	perror    :: proc(s: cstring) ---
+}

core/c/libc/stdlib.odin

@@ -0,0 +1,109 @@
+package libc
+
+// 7.22 General utilities
+
+when ODIN_OS == "windows" {
+	foreign import libc "system:libucrt.lib"
+} else {
+	foreign import libc "system:c"
+}
+
+when ODIN_OS == "windows" {
+	RAND_MAX :: 0x7fff
+
+	@(private="file")
+	@(default_calling_convention="c")
+	foreign libc {
+		___mb_cur_max_func :: proc() -> int ---
+	}
+
+	MB_CUR_MAX :: #force_inline proc() -> size_t {
+		return size_t(___mb_cur_max_func())
+	}
+}
+
+when ODIN_OS == "linux" {
+	RAND_MAX :: 0x7fffffff
+
+	// GLIBC and MUSL only
+	@(private="file")
+	@(default_calling_convention="c")
+	foreign libc {
+		__ctype_get_mb_cur_max :: proc() -> size_t ---
+	}
+
+	MB_CUR_MAX :: #force_inline proc() -> size_t {
+		return __ctype_get_mb_cur_max()
+	}
+}
+
+// C does not declare what these values should be, as an implementation is free
+// to use any two distinct values it wants to indicate success or failure.
+// However, nobody actually does and everyone appears to have agreed upon these
+// values.
+EXIT_SUCCESS :: 0
+EXIT_FAILURE :: 1
+
+// C does not declare which order 'quot' and 'rem' should be for the divide
+// structures. An implementation could put 'rem' first. However, nobody actually
+// does and everyone appears to have agreed upon this layout.
+div_t   :: struct { quot, rem: int, }
+ldiv_t  :: struct { quot, rem: long, }
+lldiv_t :: struct { quot, rem: longlong, }
+
+@(default_calling_convention="c")
+foreign libc {
+	// 7.22.1 Numeric conversion functions
+	atof          :: proc(nptr: cstring) -> double ---
+	atoi          :: proc(nptr: cstring) -> int ---
+	atol          :: proc(nptr: cstring) -> long ---
+	atoll         :: proc(nptr: cstring) -> longlong ---
+	strtod        :: proc(nptr: cstring, endptr: ^[^]char) -> double ---
+	strtof        :: proc(nptr: cstring, endptr: ^[^]char) -> float ---
+	strtol        :: proc(nptr: cstring, endptr: ^[^]char, base: int) -> long ---
+	strtoll       :: proc(nptr: cstring, endptr: ^[^]char, base: int) -> longlong ---
+	strtoul       :: proc(nptr: cstring, endptr: ^[^]char, base: int) -> ulong ---
+	strtoull      :: proc(nptr: cstring, endptr: ^[^]char, base: int) -> ulonglong ---
+
+	// 7.22.2 Pseudo-random sequence generation functions
+	rand          :: proc() -> int ---
+	srand         :: proc(seed: uint) ---
+
+	// 7.22.3 Memory management functions
+	aligned_alloc :: proc(aligment, size: size_t) -> rawptr ---
+	calloc        :: proc(nmemb, size: size_t) -> rawptr ---
+	free          :: proc(ptr: rawptr) ---
+	malloc        :: proc(size: size_t) -> rawptr ---
+	realloc       :: proc(ptr: rawptr, size: size_t) -> rawptr ---
+
+	// 7.22.4 Communication with the environment
+	abort         :: proc() -> ! ---
+	atexit        :: proc(func: proc "c" ()) -> int ---
+	at_quick_exit :: proc(func: proc "c" ()) -> int ---
+	exit          :: proc(status: int) -> ! ---
+	_Exit         :: proc(status: int) -> ! ---
+	getenv        :: proc(name: cstring) -> [^]char ---
+	quick_exit    :: proc(status: int) -> ! ---
+	system        :: proc(cmd: cstring) -> int ---
+
+	// 7.22.5 Searching and sorting utilities
+	bsearch       :: proc(key, base: rawptr, nmemb, size: size_t, compar: proc "c" (lhs, rhs: rawptr) -> int) -> rawptr ---
+	qsort         :: proc(base: rawptr, nmemb, size: size_t, compar: proc "c" (lhs, rhs: rawptr) -> int) ---
+
+	// 7.22.6 Integer arithmetic functions
+	abs           :: proc(j: int) -> int ---
+	labs          :: proc(j: long) -> long ---
+	llabs         :: proc(j: longlong) -> longlong ---
+	div           :: proc(numer, denom: int) -> div_t ---
+	ldiv          :: proc(numer, denom: long) -> ldiv_t ---
+	lldiv         :: proc(numer, denom: longlong) -> lldiv_t ---
+
+	// 7.22.7 Multibyte/wide character conversion functions
+	mblen         :: proc(s: cstring, n: size_t) -> int ---
+	mbtowc        :: proc(pwc: ^wchar_t, s: cstring, n: size_t) -> int ---
+	wctomb        :: proc(s: [^]char, wc: wchar_t) -> int ---
+
+	// 7.22.8 Multibyte/wide string conversion functions
+	mbstowcs      :: proc(pwcs: ^wchar_t, s: cstring, n: size_t) -> size_t ---
+	wcstombs      :: proc(s: [^]char, pwcs: ^wchar_t, n: size_t) -> size_t ---
+}

core/c/libc/string.odin

@@ -0,0 +1,46 @@
+package libc
+
+import "core:runtime"
+
+// 7.24 String handling
+
+when ODIN_OS == "windows" {
+	foreign import libc "system:libucrt.lib"
+} else {
+	foreign import libc "system:c"
+}
+
+foreign libc {
+	// 7.24.2 Copying functions
+	memcpy   :: proc(s1, s2: rawptr, n: size_t) -> rawptr ---
+	memmove  :: proc(s1, s2: rawptr, n: size_t) -> rawptr ---
+	strcpy   :: proc(s1: [^]char, s2: cstring) -> [^]char ---
+	strncpy  :: proc(s1: [^]char, s2: cstring, n: size_t) -> [^]char ---
+
+	// 7.24.3 Concatenation functions
+	strcat   :: proc(s1: [^]char, s2: cstring) -> [^]char ---
+	strncat  :: proc(s1: [^]char, s2: cstring, n: size_t) -> [^]char ---
+
+	// 7.24.4 Comparison functions
+	memcmp   :: proc(s1, s2: rawptr, n: size_t) -> int ---
+	strcmp   :: proc(s1, s2: cstring) -> int ---
+	strcoll  :: proc(s1, s2: cstring) -> int ---
+	strncmp  :: proc(s1, s2: cstring, n: size_t) -> int ---
+	strxfrm  :: proc(s1: [^]char, s2: cstring, n: size_t) -> size_t ---
+
+	// 7.24.5 Search functions
+	memchr   :: proc(s: rawptr, c: int, n: size_t) -> rawptr ---
+	strchr   :: proc(s: cstring, c: int) -> [^]char ---
+	strcspn  :: proc(s1, s2: cstring) -> size_t ---
+	strpbrk  :: proc(s1, s2: cstring) -> [^]char ---
+	strrchr  :: proc(s: [^]char, c: int) -> [^]char ---
+	strcpn   :: proc(s1, s2: cstring) -> [^]char ---
+	strtok   :: proc(s1: [^]char, s2: cstring) -> [^]char ---
+
+	// 7.24.6 Miscellaneous functions
+	strerror :: proc(errnum: int) -> [^]char ---
+	strlen   :: proc(s: cstring) -> size_t ---
+}
+memset :: proc "c" (s: rawptr, c: int, n: size_t) -> rawptr {
+	return runtime.memset(s, c, auto_cast n)
+}

core/c/libc/tests/general.odin

@@ -0,0 +1,50 @@
+package libc_tests
+
+import "core:c/libc"
+
+test_stdio :: proc() {
+    c: libc.char = 'C';
+    libc.puts("Hello from puts");
+    libc.printf("Hello from printf in %c\n", c);
+}
+test_thread :: proc() {
+    thread_proc :: proc "c" (rawptr) -> libc.int {
+        libc.printf("Hello from thread");
+        return 42;
+    }
+    thread: libc.thrd_t;
+    libc.thrd_create(&thread, thread_proc, nil);
+    result: libc.int;
+    libc.thrd_join(thread, &result);
+    libc.printf(" %d\n", result);
+}
+
+jmp: libc.jmp_buf;
+test_sjlj :: proc() {
+    if libc.setjmp(&jmp) != 0 {
+        libc.printf("Hello from longjmp\n");
+        return;
+    }
+    libc.printf("Hello from setjmp\n");
+    libc.longjmp(&jmp, 1);
+}
+test_signal :: proc() {
+    handler :: proc "c" (sig: libc.int) {
+        libc.printf("Hello from signal handler\n");
+    }
+    libc.signal(libc.SIGABRT, handler);
+    libc.raise(libc.SIGABRT);
+}
+test_atexit :: proc() {
+    handler :: proc "c" () {
+        libc.printf("Hello from atexit\n");
+    }
+    libc.atexit(handler);
+}
+main :: proc() {
+    test_stdio();
+    test_thread();
+    test_sjlj();
+    test_signal();
+    test_atexit();
+}

core/c/libc/threads.odin

@@ -0,0 +1,138 @@
+package libc
+
+// 7.26 Threads
+
+thrd_start_t :: proc "c" (rawptr) -> int
+tss_dtor_t   :: proc "c" (rawptr)
+
+when ODIN_OS == "windows" {
+	foreign import libc {
+		"system:libucrt.lib", 
+		"system:msvcprt.lib"
+	}
+
+	thrd_success        :: 0                             // _Thrd_success
+	thrd_nomem          :: 1                             // _Thrd_nomem
+	thrd_timedout       :: 2                             // _Thrd_timedout
+	thrd_busy           :: 3                             // _Thrd_busy
+	thrd_error          :: 4                             // _Thrd_error
+
+	mtx_plain           :: 1                             // _Mtx_plain
+	mtx_recursive       :: 0x100                         // _Mtx_recursive
+	mtx_timed           :: 4                             // _Mtx_timed
+
+	TSS_DTOR_ITERATIONS :: 4                             // _TSS_DTOR_ITERATIONS_IMP
+
+	once_flag           :: distinct i8                   // _Once_flag_imp_t
+	thrd_t              :: struct { _: rawptr, _: uint, } // _Thrd_t
+	tss_t               :: distinct int                  // _Tss_imp_t
+	cnd_t               :: distinct rawptr               // _Cnd_imp_t
+	mtx_t               :: distinct rawptr               // _Mtx_imp_t
+
+	// MSVCRT does not expose the C11 symbol names as what they are in C11
+	// because they held off implementing <threads.h> and C11 support for so
+	// long that people started implementing their own. To prevent symbol
+	// conflict with existing customers code they had to namespace them
+	// differently. Thus we need to alias the correct symbol names with Odin's
+	// link_name attribute.
+	@(default_calling_convention="c")
+	foreign libc {
+		// 7.26.2 Initialization functions
+		@(link_name="_Call_once")     call_once     :: proc(flag: ^once_flag, func: proc "c" ()) ---
+		// 7.26.3 Condition variable functions
+		@(link_name="_Cnd_broadcast") cnd_broadcast :: proc(cond: ^cnd_t) -> int ---
+		@(link_name="_Cnd_destroy")   cnd_destroy   :: proc(cond: ^cnd_t) ---
+		@(link_name="_Cnd_init")      cnd_init      :: proc(cond: ^cnd_t) -> int ---
+		@(link_name="_Cnd_signal")    cnd_signal    :: proc(cond: ^cnd_t) -> int ---
+		@(link_name="_Cnd_timedwait") cnd_timedwait :: proc(cond: ^cnd_t, ts: ^timespec) -> int ---
+		@(link_name="_Cnd_wait")      cnd_wait      :: proc(cond: ^cnd_t, mtx: ^mtx_t) -> int ---
+		
+		// 7.26.4 Mutex functions
+		@(link_name="_Mtx_destroy")   mtx_destroy   :: proc(mtx: ^mtx_t) ---
+		@(link_name="_Mtx_init")      mtx_init      :: proc(mtx: ^mtx_t, type: int) -> int ---
+		@(link_name="_Mtx_lock")      mtx_lock      :: proc(mtx: ^mtx_t) -> int ---
+		@(link_name="_Mtx_timedlock") mtx_timedlock :: proc(mtx: ^mtx_t, ts: ^timespec) -> int ---
+		@(link_name="_Mtx_trylock")   mtx_trylock   :: proc(mtx: ^mtx_t) -> int ---
+		@(link_name="_Mtx_unlock")    mtx_unlock    :: proc(mtx: ^mtx_t) -> int ---
+
+		// 7.26.5 Thread functions
+		@(link_name="_Thrd_create")   thrd_create   :: proc(thr: ^thrd_t, func: thrd_start_t, arg: rawptr) -> int ---
+		@(link_name="_Thrd_current")  thrd_current  :: proc() -> thrd_t ---
+		@(link_name="_Thrd_detach")   thrd_detach   :: proc(thr: thrd_t) -> int ---
+		@(link_name="_Thrd_equal")    thrd_equal    :: proc(lhs, rhs: thrd_t) -> int ---
+		@(link_name="_Thrd_exit")     thrd_exit     :: proc(res: int) -> ! ---
+		@(link_name="_Thrd_join")     thrd_join     :: proc(thr: thrd_t, res: ^int) -> int ---
+		@(link_name="_Thrd_sleep")    thrd_sleep    :: proc(duration, remaining: ^timespec) -> int ---
+		@(link_name="_Thrd_yield")    thrd_yield    :: proc() ---
+
+		// 7.26.6 Thread-specific storage functions
+		@(link_name="_Tss_create")    tss_create    :: proc(key: ^tss_t, dtor: tss_dtor_t) -> int ---
+		@(link_name="_Tss_delete")    tss_delete    :: proc(key: tss_t) ---
+		@(link_name="_Tss_get")       tss_get       :: proc(key: tss_t) -> rawptr ---
+		@(link_name="_Tss_set")       tss_set       :: proc(key: tss_t, val: rawptr) -> int ---
+	}
+}
+
+// GLIBC and MUSL compatible constants and types.
+when ODIN_OS == "linux" {
+	foreign import libc {
+		"system:c",
+		"system:pthread"
+	}
+
+	thrd_success        :: 0
+	thrd_busy           :: 1
+	thrd_error          :: 2
+	thrd_nomem          :: 3
+	thrd_timedout       :: 4
+
+	mtx_plain           :: 0
+	mtx_recursive       :: 1
+	mtx_timed           :: 2
+
+	TSS_DTOR_ITERATIONS :: 4
+
+	once_flag           :: distinct int
+	thrd_t              :: distinct ulong
+	tss_t               :: distinct uint
+	cnd_t               :: struct #raw_union { _: [12]int, _: [12 * size_of(int) / size_of(rawptr)]rawptr, }
+	mtx_t               :: struct #raw_union { _: [10 when size_of(long) == 8 else 6]int, _: [5 when size_of(long) == 8 else 6]rawptr, }
+
+	@(default_calling_convention="c")
+	foreign libc {
+		// 7.26.2 Initialization functions
+		call_once     :: proc(flag: ^once_flag, func: proc "c" ()) ---
+
+		// 7.26.3 Condition variable functions
+		cnd_broadcast :: proc(cond: ^cnd_t) -> int ---
+		cnd_destroy   :: proc(cond: ^cnd_t) ---
+		cnd_init      :: proc(cond: ^cnd_t) -> int ---
+		cnd_signal    :: proc(cond: ^cnd_t) -> int ---
+		cnd_timedwait :: proc(cond: ^cnd_t, ts: ^timespec) -> int ---
+		cnd_wait      :: proc(cond: ^cnd_t, mtx: ^mtx_t) -> int ---
+		
+		// 7.26.4 Mutex functions
+		mtx_destroy   :: proc(mtx: ^mtx_t) ---
+		mtx_init      :: proc(mtx: ^mtx_t, type: int) -> int ---
+		mtx_lock      :: proc(mtx: ^mtx_t) -> int ---
+		mtx_timedlock :: proc(mtx: ^mtx_t, ts: ^timespec) -> int ---
+		mtx_trylock   :: proc(mtx: ^mtx_t) -> int ---
+		mtx_unlock    :: proc(mtx: ^mtx_t) -> int ---
+
+		// 7.26.5 Thread functions
+		thrd_create   :: proc(thr: ^thrd_t, func: thrd_start_t, arg: rawptr) -> int ---
+		thrd_current  :: proc() -> thrd_t ---
+		thrd_detach   :: proc(thr: thrd_t) -> int ---
+		thrd_equal    :: proc(lhs, rhs: thrd_t) -> int ---
+		thrd_exit     :: proc(res: int) -> ! ---
+		thrd_join     :: proc(thr: thrd_t, res: ^int) -> int ---
+		thrd_sleep    :: proc(duration, remaining: ^timespec) -> int ---
+		thrd_yield    :: proc() ---
+
+		// 7.26.6 Thread-specific storage functions
+		tss_create    :: proc(key: ^tss_t, dtor: tss_dtor_t) -> int ---
+		tss_delete    :: proc(key: tss_t) ---
+		tss_get       :: proc(key: tss_t) -> rawptr ---
+		tss_set       :: proc(key: tss_t, val: rawptr) -> int ---
+	}
+}

core/c/libc/time.odin

@@ -0,0 +1,81 @@
+package libc
+
+// 7.27 Date and time
+
+when ODIN_OS == "windows" {
+	foreign import libc "system:libucrt.lib"
+} else {
+	foreign import libc "system:c"
+}
+
+// We enforce 64-bit time_t and timespec as there is no reason to use 32-bit as
+// we approach the 2038 problem. Windows has defaulted to this since VC8 (2005).
+when ODIN_OS == "windows" {
+	foreign libc {
+		// 7.27.2 Time manipulation functions
+		                               clock        :: proc() -> clock_t ---
+		@(link_name="_difftime64")     difftime     :: proc(time1, time2: time_t) -> double ---
+		                               mktime       :: proc(timeptr: ^tm) -> time_t ---
+		@(link_name="_time64")         time         :: proc(timer: ^time_t) -> time_t ---
+		@(link_name="_timespec64_get") timespec_get :: proc(ts: ^timespec, base: int) -> int ---
+
+		// 7.27.3 Time conversion functions
+		                               asctime      :: proc(timeptr: ^tm) -> [^]char ---
+		@(link_name="_ctime64")        ctime        :: proc(timer: ^time_t) -> [^]char ---
+		@(link_name="_gmtime64")       gmtime       :: proc(timer: ^time_t) -> ^tm ---
+		@(link_name="_localtime64")    localtime    :: proc(timer: ^time_t) -> ^tm ---
+		                               strftime     :: proc(s: [^]char, maxsize: size_t, format: cstring, timeptr: ^tm) -> size_t ---
+	}
+
+	CLOCKS_PER_SEC :: 1000
+	TIME_UTC       :: 1
+
+	clock_t        :: distinct long
+	time_t         :: distinct i64
+
+	timespec :: struct #align 8 {
+		tv_sec:  time_t,
+		tv_nsec: long,
+	}
+
+	tm :: struct #align 8 {
+		tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year, tm_wday, tm_yday, tm_isdst: int,
+	}
+}
+
+when ODIN_OS == "linux" || ODIN_OS == "freebsd" {
+	@(default_calling_convention="c")
+	foreign libc {
+		// 7.27.2 Time manipulation functions
+		clock        :: proc() -> clock_t ---
+		difftime     :: proc(time1, time2: time_t) -> double ---
+		mktime       :: proc(timeptr: ^tm) -> time_t ---
+		time         :: proc(timer: ^time_t) -> time_t ---
+		timespec_get :: proc(ts: ^timespec, base: int) -> int ---
+
+		// 7.27.3 Time conversion functions
+		asctime      :: proc(timeptr: ^tm) -> [^]char ---
+		ctime        :: proc(timer: ^time_t) -> [^]char ---
+		gmtime       :: proc(timer: ^time_t) -> ^tm ---
+		localtime    :: proc(timer: ^time_t) -> ^tm ---
+		strftime     :: proc(s: [^]char, maxsize: size_t, format: cstring, timeptr: ^tm) -> size_t ---
+	}
+
+	CLOCKS_PER_SEC :: 1000000
+	TIME_UTC       :: 1
+
+	time_t         :: distinct i64
+
+	clock_t        :: long
+
+	timespec :: struct {
+		tv_sec:  time_t,
+		tv_nsec: long,
+	}
+
+	tm :: struct {
+		tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year, tm_wday, tm_yday, tm_isdst: int,
+		_: long,
+		_: rawptr,
+	}
+}

core/c/libc/types.odin

@@ -0,0 +1,88 @@
+package libc
+
+import "core:c"
+
+char           :: c.char // assuming -funsigned-char
+short          :: c.short
+int            :: c.int
+long           :: c.long
+longlong       :: c.longlong
+
+uchar          :: c.uchar
+ushort         :: c.ushort
+uint           :: c.uint
+ulong          :: c.ulong
+ulonglong      :: c.ulonglong
+
+bool           :: c.bool
+
+size_t         :: c.size_t
+ssize_t        :: c.ssize_t
+wchar_t        :: c.wchar_t
+
+float          :: c.float
+double         :: c.double
+
+int8_t         :: c.int8_t
+uint8_t        :: c.uint8_t
+int16_t        :: c.int16_t
+uint16_t       :: c.uint16_t
+int32_t        :: c.int32_t
+uint32_t       :: c.uint32_t
+int64_t        :: c.int64_t
+uint64_t       :: c.uint64_t
+
+int_least8_t   :: c.int_least8_t
+uint_least8_t  :: c.uint_least8_t
+int_least16_t  :: c.int_least16_t
+uint_least16_t :: c.uint_least16_t
+int_least32_t  :: c.int_least32_t
+uint_least32_t :: c.uint_least32_t
+int_least64_t  :: c.int_least64_t
+uint_least64_t :: c.uint_least64_t
+
+int_fast8_t    :: c.int_fast8_t
+uint_fast8_t   :: c.uint_fast8_t
+int_fast16_t   :: c.int_fast16_t
+uint_fast16_t  :: c.uint_fast16_t
+int_fast32_t   :: c.int_fast32_t
+uint_fast32_t  :: c.uint_fast32_t
+int_fast64_t   :: c.int_fast64_t
+uint_fast64_t  :: c.uint_fast64_t
+
+intptr_t       :: c.intptr_t
+uintptr_t      :: c.uintptr_t
+ptrdiff_t      :: c.ptrdiff_t
+
+intmax_t       :: c.intmax_t
+uintmax_t      :: c.uintmax_t
+
+// Copy C's rules for type promotion here by forcing the type on the literals.
+INT8_MAX       :: c.INT8_MAX
+INT16_MAX      :: c.INT16_MAX
+INT32_MAX      :: c.INT32_MAX
+INT64_MAX      :: c.INT64_MAX
+
+UINT8_MAX      :: c.UINT8_MAX
+UINT16_MAX     :: c.UINT16_MAX
+UINT32_MAX     :: c.UINT32_MAX
+UINT64_MAX     :: c.UINT64_MAX
+
+INT8_MIN       :: c.INT8_MIN
+INT16_MIN      :: c.INT16_MIN
+INT32_MIN      :: c.INT32_MIN
+INT64_MIN      :: c.INT64_MIN
+
+SIZE_MAX       :: c.SIZE_MAX
+
+PTRDIFF_MIN    :: c.PTRDIFF_MIN
+PTRDIFF_MAX    :: c.PTRDIFF_MAX
+
+WCHAR_MIN      :: c.WCHAR_MIN
+WCHAR_MAX      :: c.WCHAR_MAX
+
+NULL           :: rawptr(uintptr(0))
+
+NDEBUG         :: !ODIN_DEBUG
+
+CHAR_BIT :: 8

core/c/libc/uchar.odin

@@ -0,0 +1,21 @@
+package libc
+
+// 7.28 Unicode utilities
+
+when ODIN_OS == "windows" {
+	foreign import libc "system:libucrt.lib"
+} else {
+	foreign import libc "system:c"
+}
+
+@(default_calling_convention="c")
+foreign libc {
+	// 7.28.1 Restartable multibyte/wide character conversion functions
+	mbrtoc16 :: proc(pc16: [^]char16_t, s: cstring, n: size_t, ps: ^mbstate_t) -> size_t ---
+	c16rtomb :: proc(s: ^char, c16: char16_t, ps: ^mbstate_t) -> size_t ---
+	mbrtoc32 :: proc(pc32: [^]char32_t, s: cstring, n: size_t, ps: ^mbstate_t) -> size_t ---
+	c32rtomb :: proc(s: ^char, c32: char32_t, ps: ^mbstate_t) -> size_t ---
+}
+
+char16_t :: uint_least16_t
+char32_t :: uint_least32_t

core/c/libc/wchar.odin

@@ -0,0 +1,108 @@
+package libc
+
+// 7.29 Extended multibyte and wide character utilities
+
+when ODIN_OS == "windows" {
+	foreign import libc "system:libucrt.lib"
+} else {
+	foreign import libc "system:c"
+}
+
+@(default_calling_convention="c")
+foreign libc {
+	// 7.29.2 Formatted wide character input/output functions
+	fwprintf  :: proc(stream: ^FILE, format: [^]wchar_t, #c_vararg arg: ..any) -> int ---
+	fwscanf   :: proc(stream: ^FILE, format: [^]wchar_t, #c_vararg arg: ..any) -> int ---
+	swprintf  :: proc(stream: ^FILE, n: size_t, format: [^]wchar_t, #c_vararg arg: ..any) -> int ---
+	swscanf   :: proc(s, format: [^]wchar_t, #c_vararg arg: ..any) -> int ---
+	vfwprintf :: proc(stream: ^FILE, format: [^]wchar_t, arg: va_list) -> int ---
+	vfwscanf  :: proc(stream: ^FILE, format: [^]wchar_t, arg: va_list) -> int ---
+	vswprintf :: proc(s: [^]wchar_t, n: size_t, format: [^]wchar_t, arg: va_list) -> int ---
+	vswscanf  :: proc(s, format: [^]wchar_t, arg: va_list) -> int ---
+	vwprintf  :: proc(format: [^]wchar_t, arg: va_list) -> int ---
+	vwscanf   :: proc(format: [^]wchar_t, arg: va_list) -> int ---
+	wprintf   :: proc(format: [^]wchar_t, #c_vararg arg: ..any) -> int ---
+	wscanf    :: proc(format: [^]wchar_t, #c_vararg arg: ..any) -> int ---
+
+	// 7.29.3 Wide character input/output functions
+	fwgetc    :: proc(stream: ^FILE) -> wint_t ---
+	fgetws    :: proc(s: [^]wchar_t, n: int, stream: ^FILE) -> wchar_t ---
+	fputwc    :: proc(c: wchar_t, stream: ^FILE) -> wint_t ---
+	fputws    :: proc(s: [^]wchar_t, stream: ^FILE) -> int ---
+	fwide     :: proc(stream: ^FILE, mode: int) -> int ---
+	getwc     :: proc(stream: ^FILE) -> wint_t ---
+	getwchar  :: proc() -> wint_t ---
+	putwc     :: proc(c: wchar_t, stream: ^FILE) -> wint_t ---
+	putwchar  :: proc(c: wchar_t) -> wint_t ---
+	ungetwc   :: proc(c: wchar_t, stream: ^FILE) -> wint_t ---
+
+	// 7.29.4 General wide string utilities
+	wcstod    :: proc(nptr: [^]wchar_t, endptr: ^[^]wchar_t) -> double ---
+	wcstof    :: proc(nptr: [^]wchar_t, endptr: ^[^]wchar_t) -> float ---
+	wcstol    :: proc(nptr: [^]wchar_t, endptr: ^[^]wchar_t, base: int) -> long ---
+	wcstoll   :: proc(nptr: [^]wchar_t, endptr: ^[^]wchar_t, base: int) -> longlong ---
+	wcstoul   :: proc(nptr: [^]wchar_t, endptr: ^[^]wchar_t, base: int) -> ulong ---
+	wcstoull  :: proc(nptr: [^]wchar_t, endptr: ^[^]wchar_t, base: int) -> ulonglong ---
+
+	// 7.29.4.2 Wide string copying functions
+	wcscpy    :: proc(s1, s2: [^]wchar_t) -> [^]wchar_t ---
+	wcsncpy   :: proc(s1, s2: [^]wchar_t, n: size_t) -> [^]wchar_t ---
+	wmemcpy   :: proc(s1, s2: [^]wchar_t, n: size_t) -> [^]wchar_t ---
+	wmemmove  :: proc(s1, s2: [^]wchar_t, n: size_t) -> [^]wchar_t ---
+
+	// 7.29.4.3 Wide string concatenation functions
+	wcscat    :: proc(s1, s2: [^]wchar_t) -> [^]wchar_t ---
+	wcsncat   :: proc(s1, s2: [^]wchar_t, n: size_t) -> [^]wchar_t ---
+
+	// 7.29.4.4 Wide string comparison functions
+	wcscmp    :: proc(s1, s2: [^]wchar_t) -> int ---
+	wcscoll   :: proc(s1, s2: [^]wchar_t) -> int ---
+	wcsncmp   :: proc(s1, s2: [^]wchar_t, n: size_t) -> int ---
+	wcsxfrm   :: proc(s1, s2: [^]wchar_t, n: size_t) -> size_t ---
+	wmemcmp   :: proc(s1, s2: [^]wchar_t, n: size_t) -> int ---
+
+	// 7.29.4.5 Wide string search functions
+	wcschr    :: proc(s: [^]wchar_t, c: wchar_t) -> [^]wchar_t ---
+	wcscspn   :: proc(s1, s2: [^]wchar_t) -> size_t ---
+	wcspbrk   :: proc(s1, s2: [^]wchar_t) -> [^]wchar_t ---
+	wcsrchr   :: proc(s: [^]wchar_t, c: wchar_t) -> [^]wchar_t ---
+	wcsspn    :: proc(s1, s2: [^]wchar_t) -> size_t ---
+	wcsstr    :: proc(s1, s2: [^]wchar_t) -> [^]wchar_t ---
+	wcstok    :: proc(s1, s2: [^]wchar_t, ptr: ^[^]wchar_t) -> [^]wchar_t ---
+	wmemchr   :: proc(s: [^]wchar_t, c: wchar_t, n: size_t) -> [^]wchar_t ---
+
+	// 7.29.4.6 Miscellaneous functions
+	wcslen    :: proc(s: [^]wchar_t) -> size_t ---
+	wmemset   :: proc(s: [^]wchar_t, c: wchar_t, n: size_t) -> [^]wchar_t ---
+
+	// 7.29.5 Wide character time conversion functions
+	wcsftime  :: proc(s: [^]wchar_t, maxsize: size_t, format: [^]wchar_t, timeptr: ^tm) -> size_t ---
+
+	// 7.29.6.1 Single-byte/wide character conversion functions
+	btowc     :: proc(c: int) -> wint_t ---
+	wctob     :: proc(c: wint_t) -> int ---
+
+	// 7.29.6.2 Conversion state functions
+	mbsinit   :: proc(ps: ^mbstate_t) -> int ---
+
+	// 7.29.6.3 Restartable multibyte/wide character conversion functions
+	mbrlen    :: proc(s: cstring, n: size_t, ps: ^mbstate_t) -> size_t ---
+	mbrtowc   :: proc(pwc: [^]wchar_t, s: cstring, n: size_t, ps: ^mbstate_t) -> size_t ---
+	wcrtomb   :: proc(s: ^char, wc: wchar_t, ps: ^mbstate_t) -> size_t ---
+
+	// 7.29.6.4 Restartable multibyte/wide string conversion functions
+	mbsrtowcs :: proc(dst: [^]wchar_t, src: ^cstring, len: size_t, ps: ^mbstate_t) -> size_t ---
+	wcsrtombs :: proc(dst: ^char, src: ^[^]wchar_t, len: size_t, ps: ^mbstate_t) -> size_t ---
+}
+
+// Large enough and aligned enough for any wide-spread in-use libc.
+mbstate_t :: struct #align 16 { _: [32]char, }
+
+// Odin does not have default argument promotion so the need for a separate type
+// here isn't necessary, though make it distinct just to be safe.
+wint_t    :: distinct wchar_t
+
+// Calculate these values correctly regardless of what type wchar_t actually is.
+WINT_MIN  :: 0
+WINT_MAX  :: 1 << (size_of(wint_t) * 8)
+WEOF      :: ~wint_t(0)

core/c/libc/wctype.odin

@@ -0,0 +1,48 @@
+package libc
+
+// 7.30 Wide character classification and mapping utilities
+
+when ODIN_OS == "windows" {
+	foreign import libc "system:libucrt.lib"
+} else {
+	foreign import libc "system:c"
+}
+
+when ODIN_OS == "windows" {
+	wctrans_t :: distinct wchar_t
+	wctype_t  :: distinct ushort
+}
+
+when ODIN_OS == "linux" {
+	wctrans_t :: distinct rawptr
+	wctype_t  :: distinct ulong
+}
+
+@(default_calling_convention="c")
+foreign libc {
+	// 7.30.2.1 Wide character classification functions
+	iswalnum  :: proc(wc: wint_t) -> int ---
+	iswalpha  :: proc(wc: wint_t) -> int ---
+	iswblank  :: proc(wc: wint_t) -> int ---
+	iswcntrl  :: proc(wc: wint_t) -> int ---
+	iswdigit  :: proc(wc: wint_t) -> int ---
+	iswgraph  :: proc(wc: wint_t) -> int ---
+	iswlower  :: proc(wc: wint_t) -> int ---
+	iswprint  :: proc(wc: wint_t) -> int ---
+	iswpunct  :: proc(wc: wint_t) -> int ---
+	iswspace  :: proc(wc: wint_t) -> int ---
+	iswupper  :: proc(wc: wint_t) -> int ---
+	iswxdigit :: proc(wc: wint_t) -> int ---
+
+	// 7.30.2.2 Extensible wide character classification functions
+	iswctype  :: proc(wc: wint_t, desc: wctype_t) -> int ---
+	wctype    :: proc(property: cstring) -> wctype_t ---
+
+	// 7.30.3 Wide character case mapping utilities
+	towlower  :: proc(wc: wint_t) -> wint_t ---
+	towupper  :: proc(wc: wint_t) -> wint_t ---
+
+	// 7.30.3.2 Extensible wide character case mapping functions
+	towctrans :: proc(wc: wint_t, desc: wctrans_t) -> wint_t ---
+	wctrans   :: proc(property: cstring) -> wctrans_t ---
+}

core/compress/common.odin

@@ -1,16 +1,15 @@
-package compress
-
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
-	Made available under Odin's BSD-2 license.
+	Made available under Odin's BSD-3 license.
 
 	List of contributors:
 		Jeroen van Rijn: Initial implementation, optimization.
 */
+package compress
 
 import "core:io"
-import "core:image"
 import "core:bytes"
+import "core:runtime"
 
 /*
 	These settings bound how much compression algorithms will allocate for their output buffer.
@@ -22,7 +21,7 @@ import "core:bytes"
 	When a decompression routine doesn't stream its output, but writes to a buffer,
 	we pre-allocate an output buffer to speed up decompression. The default is 1 MiB.
 */
-COMPRESS_OUTPUT_ALLOCATE_MIN :: int(#config(COMPRESS_OUTPUT_ALLOCATE_MIN, 1 << 20));
+COMPRESS_OUTPUT_ALLOCATE_MIN :: int(#config(COMPRESS_OUTPUT_ALLOCATE_MIN, 1 << 20))
 
 /*
 	This bounds the maximum a buffer will resize to as needed, or the maximum we'll
@@ -36,12 +35,12 @@ when size_of(uintptr) == 8 {
 		For 64-bit platforms, we set the default max buffer size to 4 GiB,
 		which is GZIP and PKZIP's max payload size.
 	*/	
-	COMPRESS_OUTPUT_ALLOCATE_MAX :: int(#config(COMPRESS_OUTPUT_ALLOCATE_MAX, 1 << 32));
+	COMPRESS_OUTPUT_ALLOCATE_MAX :: int(#config(COMPRESS_OUTPUT_ALLOCATE_MAX, 1 << 32))
 } else {
 	/*
 		For 32-bit platforms, we set the default max buffer size to 512 MiB.
 	*/
-	COMPRESS_OUTPUT_ALLOCATE_MAX :: int(#config(COMPRESS_OUTPUT_ALLOCATE_MAX, 1 << 29));
+	COMPRESS_OUTPUT_ALLOCATE_MAX :: int(#config(COMPRESS_OUTPUT_ALLOCATE_MAX, 1 << 29))
 }
 
 
@@ -51,11 +50,8 @@ Error :: union {
 	ZLIB_Error,
 	GZIP_Error,
 	ZIP_Error,
-	/*
-		This is here because png.load will return a this type of error union,
-		as it may involve an I/O error, a Deflate error, etc.
-	*/
-	image.Error,
+
+	runtime.Allocator_Error,
 }
 
 General_Error :: enum {
@@ -69,7 +65,6 @@ General_Error :: enum {
 	Incompatible_Options,
 	Unimplemented,
 
-
 	/*
 		Memory errors
 	*/
@@ -141,7 +136,7 @@ Context_Memory_Input :: struct #packed {
 	size_packed:       i64,
 	size_unpacked:     i64,
 }
-#assert(size_of(Context_Memory_Input) == 64);
+#assert(size_of(Context_Memory_Input) == 64)
 
 Context_Stream_Input :: struct #packed {
 	input_data:        []u8,
@@ -179,78 +174,78 @@ Context_Stream_Input :: struct #packed {
 // TODO: Make these return compress.Error errors.
 
 input_size_from_memory :: proc(z: ^Context_Memory_Input) -> (res: i64, err: Error) {
-	return i64(len(z.input_data)), nil;
+	return i64(len(z.input_data)), nil
 }
 
 input_size_from_stream :: proc(z: ^Context_Stream_Input) -> (res: i64, err: Error) {
-	return io.size(z.input), nil;
+	return io.size(z.input), nil
 }
 
-input_size :: proc{input_size_from_memory, input_size_from_stream};
+input_size :: proc{input_size_from_memory, input_size_from_stream}
 
 @(optimization_mode="speed")
 read_slice_from_memory :: #force_inline proc(z: ^Context_Memory_Input, size: int) -> (res: []u8, err: io.Error) {
 	#no_bounds_check {
 		if len(z.input_data) >= size {
-			res = z.input_data[:size];
-			z.input_data = z.input_data[size:];
-			return res, .None;
+			res = z.input_data[:size]
+			z.input_data = z.input_data[size:]
+			return res, .None
 		}
 	}
 
 	if len(z.input_data) == 0 {
-		return []u8{}, .EOF;
+		return []u8{}, .EOF
 	} else {
-		return []u8{}, .Short_Buffer;
+		return []u8{}, .Short_Buffer
 	}
 }
 
 @(optimization_mode="speed")
 read_slice_from_stream :: #force_inline proc(z: ^Context_Stream_Input, size: int) -> (res: []u8, err: io.Error) {
-	b := make([]u8, size, context.temp_allocator);
-	_, e := z.input->impl_read(b[:]);
+	b := make([]u8, size, context.temp_allocator)
+	_, e := z.input->impl_read(b[:])
 	if e == .None {
-		return b, .None;
+		return b, .None
 	}
 
-	return []u8{}, e;
+	return []u8{}, e
 }
 
-read_slice :: proc{read_slice_from_memory, read_slice_from_stream};
+read_slice :: proc{read_slice_from_memory, read_slice_from_stream}
 
 @(optimization_mode="speed")
 read_data :: #force_inline proc(z: ^$C, $T: typeid) -> (res: T, err: io.Error) {
-	b, e := read_slice(z, size_of(T));
+	b, e := read_slice(z, size_of(T))
 	if e == .None {
-		return (^T)(&b[0])^, .None;
+		return (^T)(&b[0])^, .None
 	}
 
-	return T{}, e;
+	return T{}, e
 }
 
 @(optimization_mode="speed")
 read_u8_from_memory :: #force_inline proc(z: ^Context_Memory_Input) -> (res: u8, err: io.Error) {
 	#no_bounds_check {
 		if len(z.input_data) >= 1 {
-			res = z.input_data[0];
-			z.input_data = z.input_data[1:];
-			return res, .None;
+			res = z.input_data[0]
+			z.input_data = z.input_data[1:]
+			return res, .None
 		}
 	}
-	return 0, .EOF;
+	return 0, .EOF
 }
 
 @(optimization_mode="speed")
 read_u8_from_stream :: #force_inline proc(z: ^Context_Stream_Input) -> (res: u8, err: io.Error) {
-	b, e := read_slice_from_stream(z, 1);
+	b, e := read_slice_from_stream(z, 1)
 	if e == .None {
-		return b[0], .None;
+		return b[0], .None
 	}
 
-	return 0, e;
+	return 0, e
 }
 
-read_u8 :: proc{read_u8_from_memory, read_u8_from_stream};
+read_u8 :: proc{read_u8_from_memory, read_u8_from_stream}
 
 /*
 	You would typically only use this at the end of Inflate, to drain bits from the code buffer
@@ -259,64 +254,64 @@ read_u8 :: proc{read_u8_from_memory, read_u8_from_stream};
 @(optimization_mode="speed")
 read_u8_prefer_code_buffer_lsb :: #force_inline proc(z: ^$C) -> (res: u8, err: io.Error) {
 	if z.num_bits >= 8 {
-		res = u8(read_bits_no_refill_lsb(z, 8));
+		res = u8(read_bits_no_refill_lsb(z, 8))
 	} else {
-		size, _ := input_size(z);
+		size, _ := input_size(z)
 		if size > 0 {
-			res, err = read_u8(z);
+			res, err = read_u8(z)
 		} else {
-			err = .EOF;
+			err = .EOF
 		}
 	}
-	return;
+	return
 }
 
 @(optimization_mode="speed")
 peek_data_from_memory :: #force_inline proc(z: ^Context_Memory_Input, $T: typeid) -> (res: T, err: io.Error) {
-	size :: size_of(T);
+	size :: size_of(T)
 
 	#no_bounds_check {
 		if len(z.input_data) >= size {
-			buf := z.input_data[:size];
-			return (^T)(&buf[0])^, .None;
+			buf := z.input_data[:size]
+			return (^T)(&buf[0])^, .None
 		}
 	}
 
 	if len(z.input_data) == 0 {
-		return T{}, .EOF;
+		return T{}, .EOF
 	} else {
-		return T{}, .Short_Buffer;
+		return T{}, .Short_Buffer
 	}
 }
 
 @(optimization_mode="speed")
 peek_data_from_stream :: #force_inline proc(z: ^Context_Stream_Input, $T: typeid) -> (res: T, err: io.Error) {
-	size :: size_of(T);
+	size :: size_of(T)
 
 	// Get current position to read from.
-	curr, e1 := z.input->impl_seek(0, .Current);
+	curr, e1 := z.input->impl_seek(0, .Current)
 	if e1 != .None {
-		return T{}, e1;
+		return T{}, e1
 	}
-	r, e2 := io.to_reader_at(z.input);
+	r, e2 := io.to_reader_at(z.input)
 	if !e2 {
-		return T{}, .Empty;
+		return T{}, .Empty
 	}
 	when size <= 128 {
-		b: [size]u8;
+		b: [size]u8
 	} else {
-		b := make([]u8, size, context.temp_allocator);
+		b := make([]u8, size, context.temp_allocator)
 	}
-	_, e3 := io.read_at(r, b[:], curr);
+	_, e3 := io.read_at(r, b[:], curr)
 	if e3 != .None {
-		return T{}, .Empty;
+		return T{}, .Empty
 	}
 
-	res = (^T)(&b[0])^;
-	return res, .None;
+	res = (^T)(&b[0])^
+	return res, .None
 }
 
-peek_data :: proc{peek_data_from_memory, peek_data_from_stream};
+peek_data :: proc{peek_data_from_memory, peek_data_from_stream}
 
 
 
@@ -324,31 +319,31 @@ peek_data :: proc{peek_data_from_memory, peek_data_from_stream};
 @(optimization_mode="speed")
 peek_back_byte :: #force_inline proc(z: ^$C, offset: i64) -> (res: u8, err: io.Error) {
 	// Look back into the sliding window.
-	return z.output.buf[z.bytes_written - offset], .None;
+	return z.output.buf[z.bytes_written - offset], .None
 }
 
 // Generalized bit reader LSB
 @(optimization_mode="speed")
 refill_lsb_from_memory :: #force_inline proc(z: ^Context_Memory_Input, width := i8(48)) {
-	refill := u64(width);
-	b      := u64(0);
+	refill := u64(width)
+	b      := u64(0)
 
 	if z.num_bits > refill {
-		return;
+		return
 	}
 
 	for {
 		if len(z.input_data) != 0 {
-			b = u64(z.input_data[0]);
-			z.input_data = z.input_data[1:];
+			b = u64(z.input_data[0])
+			z.input_data = z.input_data[1:]
 		} else {
-			b = 0;
+			b = 0
 		}
 
-		z.code_buffer |= b << u8(z.num_bits);
-		z.num_bits += 8;
+		z.code_buffer |= b << u8(z.num_bits)
+		z.num_bits += 8
 		if z.num_bits > refill {
-			break;
+			break
 		}
 	}
 }
@@ -356,123 +351,123 @@ refill_lsb_from_memory :: #force_inline proc(z: ^Context_Memory_Input, width :=
 // Generalized bit reader LSB
 @(optimization_mode="speed")
 refill_lsb_from_stream :: proc(z: ^Context_Stream_Input, width := i8(24)) {
-	refill := u64(width);
+	refill := u64(width)
 
 	for {
 		if z.num_bits > refill {
-			break;
+			break
 		}
 		if z.code_buffer == 0 && z.num_bits > 63 {
-			z.num_bits = 0;
+			z.num_bits = 0
 		}
 		if z.code_buffer >= 1 << uint(z.num_bits) {
 			// Code buffer is malformed.
-			z.num_bits = max(u64);
-			return;
+			z.num_bits = max(u64)
+			return
 		}
-		b, err := read_u8(z);
+		b, err := read_u8(z)
 		if err != .None {
 			// This is fine at the end of the file.
-			return;
+			return
 		}
-		z.code_buffer |= (u64(b) << u8(z.num_bits));
-		z.num_bits += 8;
+		z.code_buffer |= (u64(b) << u8(z.num_bits))
+		z.num_bits += 8
 	}
 }
 
-refill_lsb :: proc{refill_lsb_from_memory, refill_lsb_from_stream};
+refill_lsb :: proc{refill_lsb_from_memory, refill_lsb_from_stream}
 
 
 @(optimization_mode="speed")
 consume_bits_lsb_from_memory :: #force_inline proc(z: ^Context_Memory_Input, width: u8) {
-	z.code_buffer >>= width;
-	z.num_bits -= u64(width);
+	z.code_buffer >>= width
+	z.num_bits -= u64(width)
 }
 
 @(optimization_mode="speed")
 consume_bits_lsb_from_stream :: #force_inline proc(z: ^Context_Stream_Input, width: u8) {
-	z.code_buffer >>= width;
-	z.num_bits -= u64(width);
+	z.code_buffer >>= width
+	z.num_bits -= u64(width)
 }
 
-consume_bits_lsb :: proc{consume_bits_lsb_from_memory, consume_bits_lsb_from_stream};
+consume_bits_lsb :: proc{consume_bits_lsb_from_memory, consume_bits_lsb_from_stream}
 
 @(optimization_mode="speed")
 peek_bits_lsb_from_memory :: #force_inline proc(z: ^Context_Memory_Input, width: u8) -> u32 {
 	if z.num_bits < u64(width) {
-		refill_lsb(z);
+		refill_lsb(z)
 	}
-	return u32(z.code_buffer & ~(~u64(0) << width));
+	return u32(z.code_buffer & ~(~u64(0) << width))
 }
 
 @(optimization_mode="speed")
 peek_bits_lsb_from_stream :: #force_inline proc(z: ^Context_Stream_Input, width: u8) -> u32 {
 	if z.num_bits < u64(width) {
-		refill_lsb(z);
+		refill_lsb(z)
 	}
-	return u32(z.code_buffer & ~(~u64(0) << width));
+	return u32(z.code_buffer & ~(~u64(0) << width))
 }
 
-peek_bits_lsb :: proc{peek_bits_lsb_from_memory, peek_bits_lsb_from_stream};
+peek_bits_lsb :: proc{peek_bits_lsb_from_memory, peek_bits_lsb_from_stream}
 
 @(optimization_mode="speed")
 peek_bits_no_refill_lsb_from_memory :: #force_inline proc(z: ^Context_Memory_Input, width: u8) -> u32 {
-	assert(z.num_bits >= u64(width));
-	return u32(z.code_buffer & ~(~u64(0) << width));
+	assert(z.num_bits >= u64(width))
+	return u32(z.code_buffer & ~(~u64(0) << width))
 }
 
 @(optimization_mode="speed")
 peek_bits_no_refill_lsb_from_stream :: #force_inline proc(z: ^Context_Stream_Input, width: u8) -> u32 {
-	assert(z.num_bits >= u64(width));
-	return u32(z.code_buffer & ~(~u64(0) << width));
+	assert(z.num_bits >= u64(width))
+	return u32(z.code_buffer & ~(~u64(0) << width))
 }
 
-peek_bits_no_refill_lsb :: proc{peek_bits_no_refill_lsb_from_memory, peek_bits_no_refill_lsb_from_stream};
+peek_bits_no_refill_lsb :: proc{peek_bits_no_refill_lsb_from_memory, peek_bits_no_refill_lsb_from_stream}
 
 @(optimization_mode="speed")
 read_bits_lsb_from_memory :: #force_inline proc(z: ^Context_Memory_Input, width: u8) -> u32 {
-	k := #force_inline peek_bits_lsb(z, width);
-	#force_inline consume_bits_lsb(z, width);
-	return k;
+	k := #force_inline peek_bits_lsb(z, width)
+	#force_inline consume_bits_lsb(z, width)
+	return k
 }
 
 @(optimization_mode="speed")
 read_bits_lsb_from_stream :: #force_inline proc(z: ^Context_Stream_Input, width: u8) -> u32 {
-	k := peek_bits_lsb(z, width);
-	consume_bits_lsb(z, width);
-	return k;
+	k := peek_bits_lsb(z, width)
+	consume_bits_lsb(z, width)
+	return k
 }
 
-read_bits_lsb :: proc{read_bits_lsb_from_memory, read_bits_lsb_from_stream};
+read_bits_lsb :: proc{read_bits_lsb_from_memory, read_bits_lsb_from_stream}
 
 @(optimization_mode="speed")
 read_bits_no_refill_lsb_from_memory :: #force_inline proc(z: ^Context_Memory_Input, width: u8) -> u32 {
-	k := #force_inline peek_bits_no_refill_lsb(z, width);
-	#force_inline consume_bits_lsb(z, width);
-	return k;
+	k := #force_inline peek_bits_no_refill_lsb(z, width)
+	#force_inline consume_bits_lsb(z, width)
+	return k
 }
 
 @(optimization_mode="speed")
 read_bits_no_refill_lsb_from_stream :: #force_inline proc(z: ^Context_Stream_Input, width: u8) -> u32 {
-	k := peek_bits_no_refill_lsb(z, width);
-	consume_bits_lsb(z, width);
-	return k;
+	k := peek_bits_no_refill_lsb(z, width)
+	consume_bits_lsb(z, width)
+	return k
 }
 
-read_bits_no_refill_lsb :: proc{read_bits_no_refill_lsb_from_memory, read_bits_no_refill_lsb_from_stream};
+read_bits_no_refill_lsb :: proc{read_bits_no_refill_lsb_from_memory, read_bits_no_refill_lsb_from_stream}
 
 
 @(optimization_mode="speed")
 discard_to_next_byte_lsb_from_memory :: proc(z: ^Context_Memory_Input) {
-	discard := u8(z.num_bits & 7);
-	#force_inline consume_bits_lsb(z, discard);
+	discard := u8(z.num_bits & 7)
+	#force_inline consume_bits_lsb(z, discard)
 }
 
 
 @(optimization_mode="speed")
 discard_to_next_byte_lsb_from_stream :: proc(z: ^Context_Stream_Input) {
-	discard := u8(z.num_bits & 7);
-	consume_bits_lsb(z, discard);
+	discard := u8(z.num_bits & 7)
+	consume_bits_lsb(z, discard)
 }
 
 discard_to_next_byte_lsb :: proc{discard_to_next_byte_lsb_from_memory, discard_to_next_byte_lsb_from_stream};

core/compress/gzip/example.odin

@@ -3,7 +3,7 @@ package gzip
 
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
-	Made available under Odin's BSD-2 license.
+	Made available under Odin's BSD-3 license.
 
 	List of contributors:
 		Jeroen van Rijn: Initial implementation.
@@ -28,62 +28,62 @@ TEST: []u8 = {
 	0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x2b, 0x48,
 	0xac, 0xcc, 0xc9, 0x4f, 0x4c, 0x01, 0x00, 0x15,
 	0x6a, 0x2c, 0x42, 0x07, 0x00, 0x00, 0x00,
-};
+}
 
 main :: proc() {
 	// Set up output buffer.
-	buf := bytes.Buffer{};
+	buf := bytes.Buffer{}
 
 	stdout :: proc(s: string) {
-		os.write_string(os.stdout, s);
+		os.write_string(os.stdout, s)
 	}
 	stderr :: proc(s: string) {
-		os.write_string(os.stderr, s);
+		os.write_string(os.stderr, s)
 	}
 
-	args := os.args;
+	args := os.args
 
 	if len(args) < 2 {
-		stderr("No input file specified.\n");
-		err := load(slice=TEST, buf=&buf, known_gzip_size=len(TEST));
+		stderr("No input file specified.\n")
+		err := load(slice=TEST, buf=&buf, known_gzip_size=len(TEST))
 		if err == nil {
-			stdout("Displaying test vector: ");
-			stdout(bytes.buffer_to_string(&buf));
-			stdout("\n");
+			stdout("Displaying test vector: ")
+			stdout(bytes.buffer_to_string(&buf))
+			stdout("\n")
 		} else {
-			fmt.printf("gzip.load returned %v\n", err);
+			fmt.printf("gzip.load returned %v\n", err)
 		}
-		bytes.buffer_destroy(&buf);
-		os.exit(0);
+		bytes.buffer_destroy(&buf)
+		os.exit(0)
 	}
 
 	// The rest are all files.
-	args = args[1:];
-	err: Error;
+	args = args[1:]
+	err: Error
 
 	for file in args {
 		if file == "-" {
 			// Read from stdin
-			s := os.stream_from_handle(os.stdin);
+			s := os.stream_from_handle(os.stdin)
 			ctx := &compress.Context_Stream_Input{
 				input = s,
-			};
-			err = load(ctx, &buf);
+			}
+			err = load(ctx, &buf)
 		} else {
-			err = load(file, &buf);
+			err = load(file, &buf)
 		}
 		if err != nil {
 			if err != E_General.File_Not_Found {
-				stderr("File not found: ");
-				stderr(file);
-				stderr("\n");
-				os.exit(1);
+				stderr("File not found: ")
+				stderr(file)
+				stderr("\n")
+				os.exit(1)
 			}
-			stderr("GZIP returned an error.\n");
-				bytes.buffer_destroy(&buf);
-			os.exit(2);
+			stderr("GZIP returned an error.\n")
+				bytes.buffer_destroy(&buf)
+			os.exit(2)
 		}
-		stdout(bytes.buffer_to_string(&buf));
+		stdout(bytes.buffer_to_string(&buf))
 	}
-	bytes.buffer_destroy(&buf);
+	bytes.buffer_destroy(&buf)
 }

core/compress/gzip/gzip.odin

@@ -2,7 +2,7 @@ package gzip
 
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
-	Made available under Odin's BSD-2 license.
+	Made available under Odin's BSD-3 license.
 
 	List of contributors:
 		Jeroen van Rijn: Initial implementation.
@@ -33,7 +33,7 @@ Header :: struct #packed {
 	xfl: Compression_Flags,
 	os: OS,
 }
-#assert(size_of(Header) == 10);
+#assert(size_of(Header) == 10)
 
 Header_Flag :: enum u8 {
 	// Order is important
@@ -46,7 +46,7 @@ Header_Flag :: enum u8 {
 	reserved_2 = 6,
 	reserved_3 = 7,
 }
-Header_Flags :: distinct bit_set[Header_Flag; u8];
+Header_Flags :: distinct bit_set[Header_Flag; u8]
 
 OS :: enum u8 {
 	FAT          = 0,
@@ -82,7 +82,7 @@ OS_Name :: #partial [OS]string{
 	.QDOS         = "QDOS",
 	.Acorn_RISCOS = "Acorn RISCOS",
 	.Unknown      = "Unknown",
-};
+}
 
 Compression :: enum u8 {
 	DEFLATE = 8,
@@ -93,74 +93,77 @@ Compression_Flags :: enum u8 {
 	Fastest_Compression = 4,
 }
 
-Error     :: compress.Error;
-E_General :: compress.General_Error;
-E_GZIP    :: compress.GZIP_Error;
-E_ZLIB    :: compress.ZLIB_Error;
-E_Deflate :: compress.Deflate_Error;
+Error     :: compress.Error
+E_General :: compress.General_Error
+E_GZIP    :: compress.GZIP_Error
+E_ZLIB    :: compress.ZLIB_Error
+E_Deflate :: compress.Deflate_Error
 
-GZIP_MAX_PAYLOAD_SIZE :: int(max(u32le));
+GZIP_MAX_PAYLOAD_SIZE :: int(max(u32le))
 
-load :: proc{load_from_slice, load_from_file, load_from_context};
+load :: proc{load_from_slice, load_from_file, load_from_context}
 
 load_from_file :: proc(filename: string, buf: ^bytes.Buffer, expected_output_size := -1, allocator := context.allocator) -> (err: Error) {
-	data, ok := os.read_entire_file(filename, allocator);
-	defer delete(data);
+	context.allocator = allocator
 
-	err = E_General.File_Not_Found;
+	data, ok := os.read_entire_file(filename)
+	defer delete(data)
+
+	err = E_General.File_Not_Found
 	if ok {
-		err = load_from_slice(data, buf, len(data), expected_output_size, allocator);
+		err = load_from_slice(data, buf, len(data), expected_output_size)
 	}
-	return;
+	return
 }
 
 load_from_slice :: proc(slice: []u8, buf: ^bytes.Buffer, known_gzip_size := -1, expected_output_size := -1, allocator := context.allocator) -> (err: Error) {
-	buf := buf;
+	buf := buf
 
 	z := &compress.Context_Memory_Input{
 		input_data = slice,
 		output = buf,
-	};
-	return load_from_context(z, buf, known_gzip_size, expected_output_size, allocator);
+	}
+	return load_from_context(z, buf, known_gzip_size, expected_output_size, allocator)
 }
 
 load_from_context :: proc(z: ^$C, buf: ^bytes.Buffer, known_gzip_size := -1, expected_output_size := -1, allocator := context.allocator) -> (err: Error) {
-	buf := buf;
-	expected_output_size := expected_output_size;
+	context.allocator = allocator
+	buf := buf
+	expected_output_size := expected_output_size
 
-	input_data_consumed := 0;
+	input_data_consumed := 0
 
-	z.output = buf;
+	z.output = buf
 
 	if expected_output_size > GZIP_MAX_PAYLOAD_SIZE {
-		return E_GZIP.Payload_Size_Exceeds_Max_Payload;
+		return E_GZIP.Payload_Size_Exceeds_Max_Payload
 	}
 
 	if expected_output_size > compress.COMPRESS_OUTPUT_ALLOCATE_MAX {
-		return E_GZIP.Output_Exceeds_COMPRESS_OUTPUT_ALLOCATE_MAX;
+		return E_GZIP.Output_Exceeds_COMPRESS_OUTPUT_ALLOCATE_MAX
 	}
 
-	b: []u8;
+	b: []u8
 
-	header, e := compress.read_data(z, Header);
+	header, e := compress.read_data(z, Header)
 	if e != .None {
-		return E_General.File_Too_Short;
+		return E_General.File_Too_Short
 	}
-	input_data_consumed += size_of(Header);
+	input_data_consumed += size_of(Header)
 
 	if header.magic != .GZIP {
-		return E_GZIP.Invalid_GZIP_Signature;
+		return E_GZIP.Invalid_GZIP_Signature
 	}
 	if header.compression_method != .DEFLATE {
-		return E_General.Unknown_Compression_Method;
+		return E_General.Unknown_Compression_Method
 	}
 
 	if header.os >= ._Unknown {
-		header.os = .Unknown;
+		header.os = .Unknown
 	}
 
 	if .reserved_1 in header.flags || .reserved_2 in header.flags || .reserved_3 in header.flags {
-		return E_GZIP.Reserved_Flag_Set;
+		return E_GZIP.Reserved_Flag_Set
 	}
 
 	// printf("signature: %v\n", header.magic);
@@ -171,84 +174,84 @@ load_from_context :: proc(z: ^$C, buf: ^bytes.Buffer, known_gzip_size := -1, exp
 	// printf("os: %v\n", OS_Name[header.os]);
 
 	if .extra in header.flags {
-		xlen, e_extra := compress.read_data(z, u16le);
-		input_data_consumed += 2;
+		xlen, e_extra := compress.read_data(z, u16le)
+		input_data_consumed += 2
 
 		if e_extra != .None {
-			return E_General.Stream_Too_Short;
+			return E_General.Stream_Too_Short
 		}
 		// printf("Extra data present (%v bytes)\n", xlen);
 		if xlen < 4 {
 			// Minimum length is 2 for ID + 2 for a field length, if set to zero.
-			return E_GZIP.Invalid_Extra_Data;
+			return E_GZIP.Invalid_Extra_Data
 		}
 
-		field_id:     [2]u8;
-		field_length: u16le;
-		field_error: io.Error;
+		field_id:     [2]u8
+		field_length: u16le
+		field_error: io.Error
 
 		for xlen >= 4 {
 			// println("Parsing Extra field(s).");
-			field_id, field_error = compress.read_data(z, [2]u8);
+			field_id, field_error = compress.read_data(z, [2]u8)
 			if field_error != .None {
 				// printf("Parsing Extra returned: %v\n", field_error);
-				return E_General.Stream_Too_Short;
+				return E_General.Stream_Too_Short
 			}
-			xlen -= 2;
-			input_data_consumed += 2;
+			xlen -= 2
+			input_data_consumed += 2
 
-			field_length, field_error = compress.read_data(z, u16le);
+			field_length, field_error = compress.read_data(z, u16le)
 			if field_error != .None {
 				// printf("Parsing Extra returned: %v\n", field_error);
-				return E_General.Stream_Too_Short;
+				return E_General.Stream_Too_Short
 			}
-			xlen -= 2;
-			input_data_consumed += 2;
+			xlen -= 2
+			input_data_consumed += 2
 
 			if xlen <= 0 {
 				// We're not going to try and recover by scanning for a ZLIB header.
 				// Who knows what else is wrong with this file.
-				return E_GZIP.Invalid_Extra_Data;
+				return E_GZIP.Invalid_Extra_Data
 			}
 
 			// printf("    Field \"%v\" of length %v found: ", string(field_id[:]), field_length);
 			if field_length > 0 {
-				b, field_error = compress.read_slice(z, int(field_length));
+				b, field_error = compress.read_slice(z, int(field_length))
 				if field_error != .None {
 					// printf("Parsing Extra returned: %v\n", field_error);
-					return E_General.Stream_Too_Short;
+					return E_General.Stream_Too_Short
 				}
-				xlen -= field_length;
-				input_data_consumed += int(field_length);
+				xlen -= field_length
+				input_data_consumed += int(field_length)
 
 				// printf("%v\n", string(field_data));
 			}
 
 			if xlen != 0 {
-				return E_GZIP.Invalid_Extra_Data;
+				return E_GZIP.Invalid_Extra_Data
 			}
 		}
 	}
 
 	if .name in header.flags {
 		// Should be enough.
-		name: [1024]u8;
-		i := 0;
-		name_error: io.Error;
+		name: [1024]u8
+		i := 0
+		name_error: io.Error
 
 		for i < len(name) {
-			b, name_error = compress.read_slice(z, 1);
+			b, name_error = compress.read_slice(z, 1)
 			if name_error != .None {
-				return E_General.Stream_Too_Short;
+				return E_General.Stream_Too_Short
 			}
-			input_data_consumed += 1;
+			input_data_consumed += 1
 			if b[0] == 0 {
-				break;
+				break
 			}
-			name[i] = b[0];
-			i += 1;
+			name[i] = b[0]
+			i += 1
 			if i >= len(name) {
-				return E_GZIP.Original_Name_Too_Long;
+				return E_GZIP.Original_Name_Too_Long
 			}
 		}
 		// printf("Original filename: %v\n", string(name[:i]));
@@ -256,34 +259,34 @@ load_from_context :: proc(z: ^$C, buf: ^bytes.Buffer, known_gzip_size := -1, exp
 
 	if .comment in header.flags {
 		// Should be enough.
-		comment: [1024]u8;
-		i := 0;
-		comment_error: io.Error;
+		comment: [1024]u8
+		i := 0
+		comment_error: io.Error
 
 		for i < len(comment) {
-			b, comment_error = compress.read_slice(z, 1);
+			b, comment_error = compress.read_slice(z, 1)
 			if comment_error != .None {
-				return E_General.Stream_Too_Short;
+				return E_General.Stream_Too_Short
 			}
-			input_data_consumed += 1;
+			input_data_consumed += 1
 			if b[0] == 0 {
-				break;
+				break
 			}
-			comment[i] = b[0];
-			i += 1;
+			comment[i] = b[0]
+			i += 1
 			if i >= len(comment) {
-				return E_GZIP.Comment_Too_Long;
+				return E_GZIP.Comment_Too_Long
 			}
 		}
 		// printf("Comment: %v\n", string(comment[:i]));
 	}
 
 	if .header_crc in header.flags {
-		crc_error: io.Error;
-		_, crc_error = compress.read_slice(z, 2);
-		input_data_consumed += 2;
+		crc_error: io.Error
+		_, crc_error = compress.read_slice(z, 2)
+		input_data_consumed += 2
 		if crc_error != .None {
-			return E_General.Stream_Too_Short;
+			return E_General.Stream_Too_Short
 		}
 		/*
 			We don't actually check the CRC16 (lower 2 bytes of CRC32 of header data until the CRC field).
@@ -294,7 +297,7 @@ load_from_context :: proc(z: ^$C, buf: ^bytes.Buffer, known_gzip_size := -1, exp
 	/*
 		We should have arrived at the ZLIB payload.
 	*/
-	payload_u32le: u32le;
+	payload_u32le: u32le
 
 	// fmt.printf("known_gzip_size: %v | expected_output_size: %v\n", known_gzip_size, expected_output_size);
 
@@ -314,12 +317,12 @@ load_from_context :: proc(z: ^$C, buf: ^bytes.Buffer, known_gzip_size := -1, exp
 
 		*/
 		if known_gzip_size > -1 {
-			offset := i64(known_gzip_size - input_data_consumed - 4);
-			size, _ := compress.input_size(z);
+			offset := i64(known_gzip_size - input_data_consumed - 4)
+			size, _ := compress.input_size(z)
 			if size >= offset + 4 {
-				length_bytes         := z.input_data[offset:][:4];
-				payload_u32le         = (^u32le)(&length_bytes[0])^;
-				expected_output_size = int(payload_u32le);
+				length_bytes         := z.input_data[offset:][:4]
+				payload_u32le         = (^u32le)(&length_bytes[0])^
+				expected_output_size = int(payload_u32le)
 			}
 		} else {
 			/*
@@ -331,37 +334,37 @@ load_from_context :: proc(z: ^$C, buf: ^bytes.Buffer, known_gzip_size := -1, exp
 
 	// fmt.printf("GZIP: Expected Payload Size: %v\n", expected_output_size);
 
-	zlib_error := zlib.inflate_raw(z=z, expected_output_size=expected_output_size);
+	zlib_error := zlib.inflate_raw(z=z, expected_output_size=expected_output_size)
 	if zlib_error != nil {
-		return zlib_error;
+		return zlib_error
 	}
 	/*
 		Read CRC32 using the ctx bit reader because zlib may leave bytes in there.
 	*/
-	compress.discard_to_next_byte_lsb(z);
+	compress.discard_to_next_byte_lsb(z)
 
-	footer_error: io.Error;
+	footer_error: io.Error
 
-	payload_crc_b: [4]u8;
+	payload_crc_b: [4]u8
 	for _, i in payload_crc_b {
-		payload_crc_b[i], footer_error = compress.read_u8_prefer_code_buffer_lsb(z);
+		payload_crc_b[i], footer_error = compress.read_u8_prefer_code_buffer_lsb(z)
 	}
-	payload_crc := transmute(u32le)payload_crc_b;
+	payload_crc := transmute(u32le)payload_crc_b
 
-	payload := bytes.buffer_to_bytes(buf);
-	crc32   := u32le(hash.crc32(payload));
+	payload := bytes.buffer_to_bytes(buf)
+	crc32   := u32le(hash.crc32(payload))
 	if crc32 != payload_crc {
-		return E_GZIP.Payload_CRC_Invalid;
+		return E_GZIP.Payload_CRC_Invalid
 	}
 
-	payload_len_b: [4]u8;
+	payload_len_b: [4]u8
 	for _, i in payload_len_b {
-		payload_len_b[i], footer_error = compress.read_u8_prefer_code_buffer_lsb(z);
+		payload_len_b[i], footer_error = compress.read_u8_prefer_code_buffer_lsb(z)
 	}
-	payload_len := transmute(u32le)payload_len_b;
+	payload_len := transmute(u32le)payload_len_b
 
 	if len(payload) != int(payload_len) {
-		return E_GZIP.Payload_Length_Invalid;
+		return E_GZIP.Payload_Length_Invalid
 	}
-	return nil;
+	return nil
 }

core/compress/zlib/example.odin

@@ -3,7 +3,7 @@ package zlib
 
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
-	Made available under Odin's BSD-2 license.
+	Made available under Odin's BSD-3 license.
 
 	List of contributors:
 		Jeroen van Rijn: Initial implementation.
@@ -15,38 +15,33 @@ import "core:bytes"
 import "core:fmt"
 
 main :: proc() {
-
 	ODIN_DEMO := []u8{
-		120, 156, 101, 144,  77, 110, 131,  48,  16, 133, 215, 204,  41, 158,  44,
-		 69,  73,  32, 148, 182,  75,  35,  14, 208, 125,  47,  96, 185, 195, 143,
-		130,  13,  50,  38,  81,  84, 101, 213,  75, 116, 215,  43, 246,   8,  53,
-		 82, 126,   8, 181, 188, 152, 153, 111, 222, 147, 159, 123, 165, 247, 170,
-		 98,  24, 213,  88, 162, 198, 244, 157, 243,  16, 186, 115,  44,  75, 227,
-		  5,  77, 115,  72, 137, 222, 117, 122, 179, 197,  39,  69, 161, 170, 156,
-		 50, 144,   5,  68, 130,   4,  49, 126, 127, 190, 191, 144,  34,  19,  57,
-		 69,  74, 235, 209, 140, 173, 242, 157, 155,  54, 158, 115, 162, 168,  12,
-		181, 239, 246, 108,  17, 188, 174, 242, 224,  20,  13, 199, 198, 235, 250,
-		194, 166, 129,  86,   3,  99, 157, 172,  37, 230,  62,  73, 129, 151, 252,
-		 70, 211,   5,  77,  31, 104, 188, 160, 113, 129, 215,  59, 205,  22,  52,
-		123, 160,  83, 142, 255, 242,  89, 123,  93, 149, 200,  50, 188,  85,  54,
-		252,  18, 248, 192, 238, 228, 235, 198,  86, 224, 118, 224, 176, 113, 166,
-		112,  67, 106, 227, 159, 122, 215,  88,  95, 110, 196, 123, 205, 183, 224,
-		 98,  53,   8, 104, 213, 234, 201, 147,   7, 248, 192,  14, 170,  29,  25,
-		171,  15,  18,  59, 138, 112,  63,  23, 205, 110, 254, 136, 109,  78, 231,
-		 63, 234, 138, 133, 204,
-	};
-	OUTPUT_SIZE :: 438;
+		120, 218, 101, 144,  65, 110, 131,  48,  16,  69, 215, 246,  41, 190,  44,  69,  73,  32, 148, 182,
+		 75,  75,  28,  32, 251,  46, 217,  88, 238,   0,  86, 192,  32, 219,  36, 170, 170, 172, 122, 137,
+		238, 122, 197,  30, 161,  70, 162,  20,  81, 203, 139,  25, 191, 255, 191,  60,  51,  40, 125,  81,
+		 53,  33, 144,  15, 156, 155, 110, 232,  93, 128, 208, 189,  35,  89, 117,  65, 112, 222,  41,  99,
+		 33,  37,   6, 215, 235, 195,  17, 239, 156, 197, 170, 118, 170, 131,  44,  32,  82, 164,  72, 240,
+		253, 245, 249, 129,  12, 185, 224,  76, 105,  61, 118,  99, 171,  66, 239,  38, 193,  35, 103,  85,
+		172,  66, 127,  33, 139,  24, 244, 235, 141,  49, 204, 223,  76, 208, 205, 204, 166,   7, 173,  60,
+		 97, 159, 238,  37, 214,  41, 105, 129, 167,   5, 102,  27, 152, 173,  97, 178, 129,  73, 129, 231,
+		  5, 230,  27, 152, 175, 225,  52, 192, 127, 243, 170, 157, 149,  18, 121, 142, 115, 109, 227, 122,
+		 64,  87, 114, 111, 161,  49, 182,   6, 181, 158, 162, 226, 206, 167,  27, 215, 246,  48,  56,  99,
+		 67, 117,  16,  47,  13,  45,  35, 151,  98, 231,  75,   1, 173,  90,  61, 101, 146,  71, 136, 244,
+		170, 218, 145, 176, 123,  45, 173,  56, 113, 134, 191,  51, 219,  78, 235,  95,  28, 249, 253,   7,
+		159, 150, 133, 125,
+	}
+	OUTPUT_SIZE :: 432
 
-	buf: bytes.Buffer;
+	buf: bytes.Buffer
 
 	// We can pass ", true" to inflate a raw DEFLATE stream instead of a ZLIB wrapped one.
-	err := inflate(input=ODIN_DEMO, buf=&buf, expected_output_size=OUTPUT_SIZE);
-	defer bytes.buffer_destroy(&buf);
+	err := inflate(input=ODIN_DEMO, buf=&buf, expected_output_size=OUTPUT_SIZE)
+	defer bytes.buffer_destroy(&buf)
 
 	if err != nil {
-		fmt.printf("\nError: %v\n", err);
+		fmt.printf("\nError: %v\n", err)
 	}
-	s := bytes.buffer_to_string(&buf);
-	fmt.printf("Input: %v bytes, output (%v bytes):\n%v\n", len(ODIN_DEMO), len(s), s);
-	assert(len(s) == OUTPUT_SIZE);
+	s := bytes.buffer_to_string(&buf)
+	fmt.printf("Input: %v bytes, output (%v bytes):\n%v\n", len(ODIN_DEMO), len(s), s)
+	assert(len(s) == OUTPUT_SIZE)
 }

core/compress/zlib/zlib.odin

@@ -2,7 +2,7 @@ package zlib
 
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
-	Made available under Odin's BSD-2 license.
+	Made available under Odin's BSD-3 license.
 
 	List of contributors:
 		Jeroen van Rijn: Initial implementation, optimization.
@@ -47,41 +47,41 @@ Options :: struct {
 	level: u8,
 }
 
-Error     :: compress.Error;
-E_General :: compress.General_Error;
-E_ZLIB    :: compress.ZLIB_Error;
-E_Deflate :: compress.Deflate_Error;
+Error     :: compress.Error
+E_General :: compress.General_Error
+E_ZLIB    :: compress.ZLIB_Error
+E_Deflate :: compress.Deflate_Error
 
-DEFLATE_MAX_CHUNK_SIZE   :: 65535;
-DEFLATE_MAX_LITERAL_SIZE :: 65535;
-DEFLATE_MAX_DISTANCE     :: 32768;
-DEFLATE_MAX_LENGTH       :: 258;
+DEFLATE_MAX_CHUNK_SIZE   :: 65535
+DEFLATE_MAX_LITERAL_SIZE :: 65535
+DEFLATE_MAX_DISTANCE     :: 32768
+DEFLATE_MAX_LENGTH       :: 258
 
-HUFFMAN_MAX_BITS  :: 16;
-HUFFMAN_FAST_BITS :: 9;
-HUFFMAN_FAST_MASK :: ((1 << HUFFMAN_FAST_BITS) - 1);
+HUFFMAN_MAX_BITS  :: 16
+HUFFMAN_FAST_BITS :: 9
+HUFFMAN_FAST_MASK :: ((1 << HUFFMAN_FAST_BITS) - 1)
 
 Z_LENGTH_BASE := [31]u16{
 	3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,
 	67,83,99,115,131,163,195,227,258,0,0,
-};
+}
 
 Z_LENGTH_EXTRA := [31]u8{
 	0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0,
-};
+}
 
 Z_DIST_BASE := [32]u16{
 	1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,
 	257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0,
-};
+}
 
 Z_DIST_EXTRA := [32]u8{
 	0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,0,0,
-};
+}
 
 Z_LENGTH_DEZIGZAG := []u8{
 	16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15,
-};
+}
 
 Z_FIXED_LENGTH := [288]u8{
 	8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
@@ -93,17 +93,17 @@ Z_FIXED_LENGTH := [288]u8{
 	9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
 	9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,
 	7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,
-};
+}
 
 Z_FIXED_DIST := [32]u8{
 	5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
-};
+}
 
 /*
 	Accelerate all cases in default tables.
 */
-ZFAST_BITS :: 9;
-ZFAST_MASK :: ((1 << ZFAST_BITS) - 1);
+ZFAST_BITS :: 9
+ZFAST_MASK :: ((1 << ZFAST_BITS) - 1)
 
 /*
 	ZLIB-style Huffman encoding.
@@ -116,22 +116,22 @@ Huffman_Table :: struct {
 	firstsymbol: [16]u16,
 	size:        [288]u8,
 	value:       [288]u16,
-};
+}
 
 // Implementation starts here
 @(optimization_mode="speed")
 z_bit_reverse :: #force_inline proc(n: u16, bits: u8) -> (r: u16) {
-	assert(bits <= 16);
+	assert(bits <= 16)
 	// NOTE: Can optimize with llvm.bitreverse.i64 or some bit twiddling
 	// by reversing all of the bits and masking out the unneeded ones.
-	r = n;
-	r = ((r & 0xAAAA) >>  1) | ((r & 0x5555) << 1);
-	r = ((r & 0xCCCC) >>  2) | ((r & 0x3333) << 2);
-	r = ((r & 0xF0F0) >>  4) | ((r & 0x0F0F) << 4);
-	r = ((r & 0xFF00) >>  8) | ((r & 0x00FF) << 8);
+	r = n
+	r = ((r & 0xAAAA) >>  1) | ((r & 0x5555) << 1)
+	r = ((r & 0xCCCC) >>  2) | ((r & 0x3333) << 2)
+	r = ((r & 0xF0F0) >>  4) | ((r & 0x0F0F) << 4)
+	r = ((r & 0xFF00) >>  8) | ((r & 0x00FF) << 8)
 
-	r >>= (16 - bits);
-	return;
+	r >>= (16 - bits)
+	return
 }
 
 
@@ -145,16 +145,16 @@ grow_buffer :: proc(buf: ^[dynamic]u8) -> (err: compress.Error) {
 	/*
 		Double until we reach the maximum allowed.
 	*/
-	new_size := min(len(buf) << 1, compress.COMPRESS_OUTPUT_ALLOCATE_MAX);
-	resize(buf, new_size);
+	new_size := min(len(buf) << 1, compress.COMPRESS_OUTPUT_ALLOCATE_MAX)
+	resize(buf, new_size)
 	if len(buf) != new_size {
 		/*
 			Resize failed.
 		*/
-		return .Resize_Failed;
+		return .Resize_Failed
 	}
 
-	return nil;
+	return nil
 }
 
 /*
@@ -167,17 +167,17 @@ write_byte :: #force_inline proc(z: ^$C, c: u8) -> (err: io.Error) #no_bounds_ch
 		Resize if needed.
 	*/
 	if int(z.bytes_written) + 1 >= len(z.output.buf) {
-		e := grow_buffer(&z.output.buf);
+		e := grow_buffer(&z.output.buf)
 		if e != nil {
-			return .Short_Write;
+			return .Short_Write
 		}
 	}
 
 	#no_bounds_check {
-		z.output.buf[z.bytes_written] = c;
+		z.output.buf[z.bytes_written] = c
 	}
-	z.bytes_written += 1;
-	return .None;
+	z.bytes_written += 1
+	return .None
 }
 
 @(optimization_mode="speed")
@@ -192,20 +192,20 @@ repl_byte :: proc(z: ^$C, count: u16, c: u8) -> (err: io.Error) 	#no_bounds_chec
 	Resize if needed.
 	*/
 	if int(z.bytes_written) + int(count) >= len(z.output.buf) {
-		e := grow_buffer(&z.output.buf);
+		e := grow_buffer(&z.output.buf)
 		if e != nil {
-			return .Short_Write;
+			return .Short_Write
 		}
 	}
 
 	#no_bounds_check {
 		for _ in 0..<count {
-			z.output.buf[z.bytes_written] = c;
-			z.bytes_written += 1;
+			z.output.buf[z.bytes_written] = c
+			z.bytes_written += 1
 		}
 	}
 
-	return .None;
+	return .None
 }
 
 @(optimization_mode="speed")
@@ -216,178 +216,178 @@ repl_bytes :: proc(z: ^$C, count: u16, distance: u16) -> (err: io.Error) {
 		the output stream, just give it _that_ slice.
 	*/
 
-	offset := i64(distance);
+	offset := i64(distance)
 
 	if int(z.bytes_written) + int(count) >= len(z.output.buf) {
-		e := grow_buffer(&z.output.buf);
+		e := grow_buffer(&z.output.buf)
 		if e != nil {
-			return .Short_Write;
+			return .Short_Write
 		}
 	}
 
 	#no_bounds_check {
 		for _ in 0..<count {
-			c := z.output.buf[z.bytes_written - offset];
-			z.output.buf[z.bytes_written] = c;
-			z.bytes_written += 1;
+			c := z.output.buf[z.bytes_written - offset]
+			z.output.buf[z.bytes_written] = c
+			z.bytes_written += 1
 		}
 	}
 
-	return .None;
+	return .None
 }
 
 
 allocate_huffman_table :: proc(allocator := context.allocator) -> (z: ^Huffman_Table, err: Error) {
-	return new(Huffman_Table, allocator), nil;
+	return new(Huffman_Table, allocator), nil
 }
 
 @(optimization_mode="speed")
 build_huffman :: proc(z: ^Huffman_Table, code_lengths: []u8) -> (err: Error) {
-	sizes:     [HUFFMAN_MAX_BITS+1]int;
-	next_code: [HUFFMAN_MAX_BITS]int;
+	sizes:     [HUFFMAN_MAX_BITS+1]int
+	next_code: [HUFFMAN_MAX_BITS]int
 
-	k := int(0);
+	k := int(0)
 
-	mem.zero_slice(sizes[:]);
-	mem.zero_slice(z.fast[:]);
+	mem.zero_slice(sizes[:])
+	mem.zero_slice(z.fast[:])
 
 	for v in code_lengths {
-		sizes[v] += 1;
+		sizes[v] += 1
 	}
-	sizes[0] = 0;
+	sizes[0] = 0
 
 	for i in 1..<(HUFFMAN_MAX_BITS+1) {
 		if sizes[i] > (1 << uint(i)) {
-			return E_Deflate.Huffman_Bad_Sizes;
+			return E_Deflate.Huffman_Bad_Sizes
 		}
 	}
-	code := int(0);
+	code := int(0)
 
 	for i in 1..<HUFFMAN_MAX_BITS {
-		next_code[i]     = code;
-		z.firstcode[i]   = u16(code);
-		z.firstsymbol[i] = u16(k);
-		code = code + sizes[i];
+		next_code[i]     = code
+		z.firstcode[i]   = u16(code)
+		z.firstsymbol[i] = u16(k)
+		code = code + sizes[i]
 		if sizes[i] != 0 {
 			if code - 1 >= (1 << u16(i)) {
-				return E_Deflate.Huffman_Bad_Code_Lengths;
+				return E_Deflate.Huffman_Bad_Code_Lengths
 			}
 		}
-		z.maxcode[i] = code << (HUFFMAN_MAX_BITS - uint(i));
-		code <<= 1;
-		k += int(sizes[i]);
+		z.maxcode[i] = code << (HUFFMAN_MAX_BITS - uint(i))
+		code <<= 1
+		k += int(sizes[i])
 	}
 
-	z.maxcode[HUFFMAN_MAX_BITS] = 0x10000; // Sentinel
-	c: int;
+	z.maxcode[HUFFMAN_MAX_BITS] = 0x10000 // Sentinel
+	c: int
 
 	for v, ci in code_lengths {
 		if v != 0 {
-			c = next_code[v] - int(z.firstcode[v]) + int(z.firstsymbol[v]);
-			fastv := u16((u16(v) << 9) | u16(ci));
-			z.size[c]  = u8(v);
-			z.value[c] = u16(ci);
+			c = next_code[v] - int(z.firstcode[v]) + int(z.firstsymbol[v])
+			fastv := u16((u16(v) << 9) | u16(ci))
+			z.size[c]  = u8(v)
+			z.value[c] = u16(ci)
 			if v <= ZFAST_BITS {
-				j := z_bit_reverse(u16(next_code[v]), v);
+				j := z_bit_reverse(u16(next_code[v]), v)
 				for j < (1 << ZFAST_BITS) {
-					z.fast[j] = fastv;
-					j += (1 << v);
+					z.fast[j] = fastv
+					j += (1 << v)
 				}
 			}
-			next_code[v] += 1;
+			next_code[v] += 1
 		}
 	}
-	return nil;
+	return nil
 }
 
 @(optimization_mode="speed")
 decode_huffman_slowpath :: proc(z: ^$C, t: ^Huffman_Table) -> (r: u16, err: Error) #no_bounds_check {
-	code := u16(compress.peek_bits_lsb(z,16));
+	code := u16(compress.peek_bits_lsb(z,16))
 
-	k := int(z_bit_reverse(code, 16));
-	s: u8;
+	k := int(z_bit_reverse(code, 16))
+	s: u8
 
 	#no_bounds_check for s = HUFFMAN_FAST_BITS+1; ; {
 		if k < t.maxcode[s] {
-			break;
+			break
 		}
-		s += 1;
+		s += 1
 	}
 	if s >= 16 {
-		return 0, E_Deflate.Bad_Huffman_Code;
+		return 0, E_Deflate.Bad_Huffman_Code
 	}
 	// code size is s, so:
-	b := (k >> (16-s)) - int(t.firstcode[s]) + int(t.firstsymbol[s]);
+	b := (k >> (16-s)) - int(t.firstcode[s]) + int(t.firstsymbol[s])
 	if b >= size_of(t.size) {
-		return 0, E_Deflate.Bad_Huffman_Code;
+		return 0, E_Deflate.Bad_Huffman_Code
 	}
 	if t.size[b] != s {
-		return 0, E_Deflate.Bad_Huffman_Code;
+		return 0, E_Deflate.Bad_Huffman_Code
 	}
 
-	compress.consume_bits_lsb(z, s);
+	compress.consume_bits_lsb(z, s)
 
-	r = t.value[b];
-	return r, nil;
+	r = t.value[b]
+	return r, nil
 }
 
 @(optimization_mode="speed")
 decode_huffman :: proc(z: ^$C, t: ^Huffman_Table) -> (r: u16, err: Error) #no_bounds_check {
 	if z.num_bits < 16 {
 		if z.num_bits > 63 {
-			return 0, E_ZLIB.Code_Buffer_Malformed;
+			return 0, E_ZLIB.Code_Buffer_Malformed
 		}
-		compress.refill_lsb(z);
+		compress.refill_lsb(z)
 		if z.num_bits > 63 {
-			return 0, E_General.Stream_Too_Short;
+			return 0, E_General.Stream_Too_Short
 		}
 	}
-	#no_bounds_check b := t.fast[z.code_buffer & ZFAST_MASK];
+	#no_bounds_check b := t.fast[z.code_buffer & ZFAST_MASK]
 	if b != 0 {
-		s := u8(b >> ZFAST_BITS);
-		compress.consume_bits_lsb(z, s);
-		return b & 511, nil;
+		s := u8(b >> ZFAST_BITS)
+		compress.consume_bits_lsb(z, s)
+		return b & 511, nil
 	}
-	return decode_huffman_slowpath(z, t);
+	return decode_huffman_slowpath(z, t)
 }
 
 @(optimization_mode="speed")
 parse_huffman_block :: proc(z: ^$C, z_repeat, z_offset: ^Huffman_Table) -> (err: Error) #no_bounds_check {
 	#no_bounds_check for {
-		value, e := decode_huffman(z, z_repeat);
+		value, e := decode_huffman(z, z_repeat)
 		if e != nil {
-			return err;
+			return err
 		}
 		if value < 256 {
-			e := write_byte(z, u8(value));
+			e := write_byte(z, u8(value))
 			if e != .None {
-				return E_General.Output_Too_Short;
+				return E_General.Output_Too_Short
 			}
 		} else {
 			if value == 256 {
 					// End of block
-					return nil;
+					return nil
 			}
 
-			value -= 257;
-			length := Z_LENGTH_BASE[value];
+			value -= 257
+			length := Z_LENGTH_BASE[value]
 			if Z_LENGTH_EXTRA[value] > 0 {
-				length += u16(compress.read_bits_lsb(z, Z_LENGTH_EXTRA[value]));
+				length += u16(compress.read_bits_lsb(z, Z_LENGTH_EXTRA[value]))
 			}
 
-			value, e = decode_huffman(z, z_offset);
+			value, e = decode_huffman(z, z_offset)
 			if e != nil {
-				return E_Deflate.Bad_Huffman_Code;
+				return E_Deflate.Bad_Huffman_Code
 			}
 
-			distance := Z_DIST_BASE[value];
+			distance := Z_DIST_BASE[value]
 			if Z_DIST_EXTRA[value] > 0 {
-				distance += u16(compress.read_bits_lsb(z, Z_DIST_EXTRA[value]));
+				distance += u16(compress.read_bits_lsb(z, Z_DIST_EXTRA[value]))
 			}
 
 			if z.bytes_written < i64(distance) {
 				// Distance is longer than we've decoded so far.
-				return E_Deflate.Bad_Distance;
+				return E_Deflate.Bad_Distance
 			}
 
 			/*
@@ -402,17 +402,17 @@ parse_huffman_block :: proc(z: ^$C, z_repeat, z_offset: ^Huffman_Table) -> (err:
 					Replicate the last outputted byte, length times.
 				*/
 				if length > 0 {
-					c := z.output.buf[z.bytes_written - i64(distance)];
-					e := repl_byte(z, length, c);
+					c := z.output.buf[z.bytes_written - i64(distance)]
+					e := repl_byte(z, length, c)
 					if e != .None {
-						return E_General.Output_Too_Short;
+						return E_General.Output_Too_Short
 					}
 				}
 			} else {
 				if length > 0 {
-					e := repl_bytes(z, length, distance);
+					e := repl_bytes(z, length, distance)
 					if e != .None {
-						return E_General.Output_Too_Short;
+						return E_General.Output_Too_Short
 					}
 				}
 			}
@@ -430,37 +430,35 @@ inflate_from_context :: proc(using ctx: ^compress.Context_Memory_Input, raw := f
 	*/
 
 	if !raw {
-		size, size_err := compress.input_size(ctx);
+		size, size_err := compress.input_size(ctx)
 		if size < 6 || size_err != nil {
-			return E_General.Stream_Too_Short;
+			return E_General.Stream_Too_Short
 		}
 
-		cmf, _ := compress.read_u8(ctx);
+		cmf, _ := compress.read_u8(ctx)
 
-		method := Compression_Method(cmf & 0xf);
+		method := Compression_Method(cmf & 0xf)
 		if method != .DEFLATE {
-			return E_General.Unknown_Compression_Method;
+			return E_General.Unknown_Compression_Method
 		}
 
-		cinfo  := (cmf >> 4) & 0xf;
-		if cinfo > 7 {
-			return E_ZLIB.Unsupported_Window_Size;
+		if cinfo := (cmf >> 4) & 0xf; cinfo > 7 {
+			return E_ZLIB.Unsupported_Window_Size
 		}
-		flg, _ := compress.read_u8(ctx);
+		flg, _ := compress.read_u8(ctx)
 
-		fcheck  := flg & 0x1f;
-		fcheck_computed := (cmf << 8 | flg) & 0x1f;
+		fcheck := flg & 0x1f
+		fcheck_computed := (cmf << 8 | flg) & 0x1f
 		if fcheck != fcheck_computed {
-			return E_General.Checksum_Failed;
+			return E_General.Checksum_Failed
 		}
 
-		fdict   := (flg >> 5) & 1;
 		/*
 			We don't handle built-in dictionaries for now.
 			They're application specific and PNG doesn't use them.
 		*/
-		if fdict != 0 {
-			return E_ZLIB.FDICT_Unsupported;
+		if fdict := (flg >> 5) & 1; fdict != 0 {
+			return E_ZLIB.FDICT_Unsupported
 		}
 
 		// flevel  := Compression_Level((flg >> 6) & 3);
@@ -473,39 +471,37 @@ inflate_from_context :: proc(using ctx: ^compress.Context_Memory_Input, raw := f
 	}
 
 	// Parse ZLIB stream without header.
-	err = inflate_raw(z=ctx, expected_output_size=expected_output_size);
-	if err != nil {
-		return err;
-	}
+	inflate_raw(z=ctx, expected_output_size=expected_output_size) or_return
 
 	if !raw {
-		compress.discard_to_next_byte_lsb(ctx);
+		compress.discard_to_next_byte_lsb(ctx)
 
-		adler_b: [4]u8;
+		adler_b: [4]u8
 		for _, i in adler_b {
-			adler_b[i], _ = compress.read_u8_prefer_code_buffer_lsb(ctx);
+			adler_b[i], _ = compress.read_u8_prefer_code_buffer_lsb(ctx)
 		}
-		adler := transmute(u32be)adler_b;
+		adler := transmute(u32be)adler_b
 
-		output_hash := hash.adler32(ctx.output.buf[:]);
+		output_hash := hash.adler32(ctx.output.buf[:])
 
 		if output_hash != u32(adler) {
-			return E_General.Checksum_Failed;
+			return E_General.Checksum_Failed
 		}
 	}
-	return nil;
+	return nil
 }
 
 // TODO: Check alignment of reserve/resize.
 
 @(optimization_mode="speed")
 inflate_raw :: proc(z: ^$C, expected_output_size := -1, allocator := context.allocator) -> (err: Error) #no_bounds_check {
-	expected_output_size := expected_output_size;
+	context.allocator = allocator
+	expected_output_size := expected_output_size
 
 	/*
 		Always set up a minimum allocation size.
 	*/
-	expected_output_size = max(max(expected_output_size, compress.COMPRESS_OUTPUT_ALLOCATE_MIN), 512);
+	expected_output_size = max(max(expected_output_size, compress.COMPRESS_OUTPUT_ALLOCATE_MIN), 512)
 
 	// fmt.printf("\nZLIB: Expected Payload Size: %v\n\n", expected_output_size);
 
@@ -513,43 +509,34 @@ inflate_raw :: proc(z: ^$C, expected_output_size := -1, allocator := context.all
 		/*
 			Try to pre-allocate the output buffer.
 		*/
-		reserve(&z.output.buf, expected_output_size);
-		resize (&z.output.buf, expected_output_size);
-	};
+		reserve(&z.output.buf, expected_output_size)
+		resize (&z.output.buf, expected_output_size)
+	}
 
 	if len(z.output.buf) != expected_output_size {
-		return .Resize_Failed;
+		return .Resize_Failed
 	}
 
-	z.num_bits    = 0;
-	z.code_buffer = 0;
+	z.num_bits    = 0
+	z.code_buffer = 0
 
-	z_repeat:      ^Huffman_Table;
-	z_offset:      ^Huffman_Table;
-	codelength_ht: ^Huffman_Table;
+	z_repeat:      ^Huffman_Table
+	z_offset:      ^Huffman_Table
+	codelength_ht: ^Huffman_Table
+	defer free(z_repeat)
+	defer free(z_offset)
+	defer free(codelength_ht)
 
-	z_repeat, err = allocate_huffman_table(allocator=context.allocator);
-	if err != nil {
-		return err;
-	}
-	z_offset, err = allocate_huffman_table(allocator=context.allocator);
-	if err != nil {
-		return err;
-	}
-	codelength_ht, err = allocate_huffman_table(allocator=context.allocator);
-	if err != nil {
-		return err;
-	}
-	defer free(z_repeat);
-	defer free(z_offset);
-	defer free(codelength_ht);
+	z_repeat      = allocate_huffman_table() or_return
+	z_offset      = allocate_huffman_table() or_return
+	codelength_ht = allocate_huffman_table() or_return
 
-	final := u32(0);
-	type  := u32(0);
+	final := u32(0)
+	type  := u32(0)
 
 	for {
-		final = compress.read_bits_lsb(z, 1);
-		type  = compress.read_bits_lsb(z, 2);
+		final = compress.read_bits_lsb(z, 1)
+		type  = compress.read_bits_lsb(z, 2)
 
 		// fmt.printf("Final: %v | Type: %v\n", final, type);
 
@@ -558,16 +545,16 @@ inflate_raw :: proc(z: ^$C, expected_output_size := -1, allocator := context.all
 			// Uncompressed block
 
 			// Discard bits until next byte boundary
-			compress.discard_to_next_byte_lsb(z);
+			compress.discard_to_next_byte_lsb(z)
 
-			uncompressed_len  := i16(compress.read_bits_lsb(z, 16));
-			length_check      := i16(compress.read_bits_lsb(z, 16));
+			uncompressed_len := i16(compress.read_bits_lsb(z, 16))
+			length_check     := i16(compress.read_bits_lsb(z, 16))
 
 			// fmt.printf("LEN: %v, ~LEN: %v, NLEN: %v, ~NLEN: %v\n", uncompressed_len, ~uncompressed_len, length_check, ~length_check);
 
 
 			if ~uncompressed_len != length_check {
-				return E_Deflate.Len_Nlen_Mismatch;
+				return E_Deflate.Len_Nlen_Mismatch
 			}
 
 			/*
@@ -575,141 +562,116 @@ inflate_raw :: proc(z: ^$C, expected_output_size := -1, allocator := context.all
 				and a single Adler32 update after.
 			*/
 			#no_bounds_check for uncompressed_len > 0 {
-				compress.refill_lsb(z);
-				lit := compress.read_bits_lsb(z, 8);
-				write_byte(z, u8(lit));
-				uncompressed_len -= 1;
+				compress.refill_lsb(z)
+				lit := compress.read_bits_lsb(z, 8)
+				write_byte(z, u8(lit))
+				uncompressed_len -= 1
 			}
 		case 3:
-			return E_Deflate.BType_3;
+			return E_Deflate.BType_3
 		case:
 			// log.debugf("Err: %v | Final: %v | Type: %v\n", err, final, type);
 			if type == 1 {
 				// Use fixed code lengths.
-				err = build_huffman(z_repeat, Z_FIXED_LENGTH[:]);
-				if err != nil {
-					return err;
-				}
-				err = build_huffman(z_offset, Z_FIXED_DIST[:]);
-				if err != nil {
-					return err;
-				}
+				build_huffman(z_repeat, Z_FIXED_LENGTH[:]) or_return
+				build_huffman(z_offset, Z_FIXED_DIST[:])  or_return
 			} else {
-				lencodes: [286+32+137]u8;
-				codelength_sizes: [19]u8;
+				lencodes: [286+32+137]u8
+				codelength_sizes: [19]u8
 
 				//i: u32;
-				n: u32;
+				n: u32
 
-				compress.refill_lsb(z, 14);
-				hlit  := compress.read_bits_no_refill_lsb(z, 5) + 257;
-				hdist := compress.read_bits_no_refill_lsb(z, 5) + 1;
-				hclen := compress.read_bits_no_refill_lsb(z, 4) + 4;
-				ntot  := hlit + hdist;
+				compress.refill_lsb(z, 14)
+				hlit  := compress.read_bits_no_refill_lsb(z, 5) + 257
+				hdist := compress.read_bits_no_refill_lsb(z, 5) + 1
+				hclen := compress.read_bits_no_refill_lsb(z, 4) + 4
+				ntot  := hlit + hdist
 
 				#no_bounds_check for i in 0..<hclen {
-					s := compress.read_bits_lsb(z, 3);
-					codelength_sizes[Z_LENGTH_DEZIGZAG[i]] = u8(s);
-				}
-				err = build_huffman(codelength_ht, codelength_sizes[:]);
-				if err != nil {
-					return err;
+					s := compress.read_bits_lsb(z, 3)
+					codelength_sizes[Z_LENGTH_DEZIGZAG[i]] = u8(s)
 				}
+				build_huffman(codelength_ht, codelength_sizes[:]) or_return
 
-				n = 0;
-				c: u16;
+				n = 0
+				c: u16
 
 				for n < ntot {
-					c, err = decode_huffman(z, codelength_ht);
-					if err != nil {
-						return err;
-					}
+					c = decode_huffman(z, codelength_ht) or_return
 
 					if c < 0 || c >= 19 {
-						return E_Deflate.Huffman_Bad_Code_Lengths;
+						return E_Deflate.Huffman_Bad_Code_Lengths
 					}
 					if c < 16 {
-						lencodes[n] = u8(c);
-						n += 1;
+						lencodes[n] = u8(c)
+						n += 1
 					} else {
-						fill := u8(0);
-						compress.refill_lsb(z, 7);
+						fill := u8(0)
+						compress.refill_lsb(z, 7)
 						switch c {
 						case 16:
-							c = u16(compress.read_bits_no_refill_lsb(z, 2) + 3);
+							c = u16(compress.read_bits_no_refill_lsb(z, 2) + 3)
 							if n == 0 {
-								return E_Deflate.Huffman_Bad_Code_Lengths;
+								return E_Deflate.Huffman_Bad_Code_Lengths
 							}
-							fill = lencodes[n - 1];
+							fill = lencodes[n - 1]
 						case 17:
-							c = u16(compress.read_bits_no_refill_lsb(z, 3) + 3);
+							c = u16(compress.read_bits_no_refill_lsb(z, 3) + 3)
 						case 18:
-							c = u16(compress.read_bits_no_refill_lsb(z, 7) + 11);
+							c = u16(compress.read_bits_no_refill_lsb(z, 7) + 11)
 						case:
-								return E_Deflate.Huffman_Bad_Code_Lengths;
+								return E_Deflate.Huffman_Bad_Code_Lengths
 						}
 
 						if ntot - n < u32(c) {
-							return E_Deflate.Huffman_Bad_Code_Lengths;
+							return E_Deflate.Huffman_Bad_Code_Lengths
 						}
 
-						nc := n + u32(c);
+						nc := n + u32(c)
 						#no_bounds_check for ; n < nc; n += 1 {
-							lencodes[n] = fill;
+							lencodes[n] = fill
 						}
 					}
 				}
 
 				if n != ntot {
-					return E_Deflate.Huffman_Bad_Code_Lengths;
+					return E_Deflate.Huffman_Bad_Code_Lengths
 				}
 
-				err = build_huffman(z_repeat, lencodes[:hlit]);
-				if err != nil {
-					return err;
-				}
-
-				err = build_huffman(z_offset, lencodes[hlit:ntot]);
-				if err != nil {
-					return err;
-				}
-			}
-			err = parse_huffman_block(z, z_repeat, z_offset);
-			// log.debugf("Err: %v | Final: %v | Type: %v\n", err, final, type);
-			if err != nil {
-				return err;
+				build_huffman(z_repeat, lencodes[:hlit])     or_return
+				build_huffman(z_offset, lencodes[hlit:ntot]) or_return
 			}
+			parse_huffman_block(z, z_repeat, z_offset) or_return
 		}
 		if final == 1 {
-			break;
+			break
 		}
 	}
 
 	if int(z.bytes_written) != len(z.output.buf) {
-		resize(&z.output.buf, int(z.bytes_written));
+		resize(&z.output.buf, int(z.bytes_written))
 	}
 
-	return nil;
+	return nil
 }
 
 inflate_from_byte_array :: proc(input: []u8, buf: ^bytes.Buffer, raw := false, expected_output_size := -1) -> (err: Error) {
-	ctx := compress.Context_Memory_Input{};
+	ctx := compress.Context_Memory_Input{}
 
-	ctx.input_data = input;
-	ctx.output = buf;
+	ctx.input_data = input
+	ctx.output = buf
 
-	err = inflate_from_context(ctx=&ctx, raw=raw, expected_output_size=expected_output_size);
-
-	return err;
+	return inflate_from_context(ctx=&ctx, raw=raw, expected_output_size=expected_output_size)
 }
 
 inflate_from_byte_array_raw :: proc(input: []u8, buf: ^bytes.Buffer, raw := false, expected_output_size := -1) -> (err: Error) {
-	ctx := compress.Context_Memory_Input{};
+	ctx := compress.Context_Memory_Input{}
 
-	ctx.input_data = input;
-	ctx.output = buf;
+	ctx.input_data = input
+	ctx.output = buf
 
-	return inflate_raw(z=&ctx, expected_output_size=expected_output_size);
+	return inflate_raw(z=&ctx, expected_output_size=expected_output_size)
 }
 
-inflate     :: proc{inflate_from_context, inflate_from_byte_array};
+inflate :: proc{inflate_from_context, inflate_from_byte_array};

core/container/array.odin

@@ -10,7 +10,7 @@ Array :: struct($T: typeid) {
 	allocator: mem.Allocator,
 }
 
-ARRAY_DEFAULT_CAPACITY :: 16;
+ARRAY_DEFAULT_CAPACITY :: 16
 
 /*
 array_init :: proc {
@@ -46,171 +46,171 @@ 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_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(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;
+	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_init :: proc{array_init_none, array_init_len, array_init_len_cap}
 
 array_delete :: proc(a: $A/Array) {
-	mem.free(a.data, a.allocator);
+	mem.free(a.data, a.allocator)
 }
 
 array_len :: proc(a: $A/Array) -> int {
-	return a.len;
+	return a.len
 }
 
 array_cap :: proc(a: $A/Array) -> int {
-	return a.cap;
+	return a.cap
 }
 
 array_space :: proc(a: $A/Array) -> int {
-	return a.cap - a.len;
+	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;
+	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;
+	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))^;
+	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));
+	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;
+	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_set_capacity(a, capacity)
 	}
 }
 
 array_resize :: proc(a: ^$A/Array, length: int) {
 	if length > a.len {
-		array_set_capacity(a, length);
+		array_set_capacity(a, length)
 	}
-	a.len = length;
+	a.len = length
 }
 
 
 
 array_push_back :: proc(a: ^$A/Array($T), item: T) {
 	if array_space(a^) == 0 {
-		array_grow(a);
+		array_grow(a)
 	}
 
-	a.len += 1;
-	array_set(a, a.len-1, item);
+	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);
+		array_grow(a)
 	}
 
-	a.len += 1;
-	data := array_slice(a^);
-	copy(data[1:], data[:]);
-	data[0] = item;
+	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;
+	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;
+	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;
+	assert(condition=a.len >= count, loc=loc)
+	a.len -= count
 }
 
 
 array_trim :: proc(a: ^$A/Array($T)) {
-	array_set_capacity(a, a.len);
+	array_set_capacity(a, a.len)
 }
 
 array_clear :: proc(a: ^$A/Array($T)) {
-	array_resize(a, 0);
+	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;
+	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));
+		array_grow(a, a.len + len(items))
 	}
-	offset := a.len;
-	data := array_cap_slice(a^);
-	n := copy(data[a.len:], items);
-	a.len += n;
+	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_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;
+		return
 	}
 
 	if new_capacity < a.len {
-		array_resize(a, new_capacity);
+		array_resize(a, new_capacity)
 	}
 
-	new_data: ^T;
+	new_data: ^T
 	if new_capacity > 0 {
 		if a.allocator.procedure == nil {
-			a.allocator = context.allocator;
+			a.allocator = context.allocator
 		}
-		new_data = (^T)(mem.alloc(size_of(T)*new_capacity, align_of(T), a.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.copy(new_data, a.data, size_of(T)*a.len)
 		}
 	}
-	mem.free(a.data, a.allocator);
-	a.data = new_data;
-	a.cap = new_capacity;
+	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);
+	new_capacity := max(array_len(a^)*2 + 8, min_capacity)
+	array_set_capacity(a, new_capacity)
 }

core/container/bloom_filter.odin

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

core/container/map.odin

@@ -1,7 +1,7 @@
 package container
 
-import "intrinsics"
-_ :: intrinsics;
+import "core:intrinsics"
+_ :: intrinsics
 
 
 Map :: struct($Key, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {
@@ -49,187 +49,187 @@ multi_map_remove_all
 
 */
 
-map_init :: proc{map_init_none, map_init_cap};
+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;
+	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);
+	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);
+	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;
+	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);
+	i := _map_find_or_fail(m, key)
 	if i < 0 {
-		return {}, false;
+		return {}, false
 	}
-	return array_get(m.entries, i).value, true;
+	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);
+	i := _map_find_or_fail(m, key)
 	if i < 0 {
-		return default, false;
+		return default, false
 	}
-	return array_get(m.entries, i).value, true;
+	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);
+	i := _map_find_or_fail(m, key)
 	if i < 0 {
-		return nil;
+		return nil
 	}
-	return array_get_ptr(m.entries, i).value;
+	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);
+		_map_grow(m)
 	}
 
-	i := _map_find_or_make(m, key);
-	array_get_ptr(m.entries, i).value = value;
+	i := _map_find_or_make(m, key)
+	array_get_ptr(m.entries, i).value = value
 	if _map_full(m^) {
-		_map_grow(m);
+		_map_grow(m)
 	}
 }
 
 map_remove :: proc(m: ^$M/Map($Key, $Value), key: Key) {
-	fr := _map_find_key(m^, key);
+	fr := _map_find_key(m^, key)
 	if fr.entry_index >= 0 {
-		_map_erase(m, fr);
+		_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));
+	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);
+		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);
+		e := array_get(m.entries, i)
+		multi_map_insert(&nm, e.key, e.value)
 	}
 
-	map_delete(m^);
-	m^ = nm;
+	map_delete(m^)
+	m^ = nm
 }
 
 map_clear :: proc(m: ^$M/Map($Key, $Value)) {
-	array_clear(&m.hash);
-	array_clear(&m.entries);
+	array_clear(&m.hash)
+	array_clear(&m.entries)
 }
 
 
 
 multi_map_find_first :: proc(m: $M/Map($Key, $Value), key: Key) -> ^Map_Entry(Key, Value) {
-	i := _map_find_or_fail(m, key);
+	i := _map_find_or_fail(m, key)
 	if i < 0 {
-		return nil;
+		return nil
 	}
-	return array_get_ptr(m.entries, i);
+	return array_get_ptr(m.entries, i)
 }
 
 multi_map_find_next :: proc(m: $M/Map($Key, $Value), e: ^Map_Entry(Key, Value)) -> ^Map_Entry(Key, Value) {
-	i := e.next;
+	i := e.next
 	for i >= 0 {
-		it := array_get_ptr(m.entries, i);
+		it := array_get_ptr(m.entries, i)
 		if it.hash == e.hash && it.key == e.key {
-			return it;
+			return it
 		}
-		i = it.next;
+		i = it.next
 	}
-	return nil;
+	return nil
 }
 
 multi_map_count :: proc(m: $M/Map($Key, $Value), key: Key) -> int {
-	n := 0;
-	e := multi_map_find_first(m, key);
+	n := 0
+	e := multi_map_find_first(m, key)
 	for e != nil {
-		n += 1;
-		e = multi_map_find_next(m, e);
+		n += 1
+		e = multi_map_find_next(m, e)
 	}
-	return n;
+	return n
 }
 
-multi_map_get :: proc{multi_map_get_array, multi_map_get_slice};
+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;
+		return
 	}
-	e := multi_map_find_first(m, key);
+	e := multi_map_find_first(m, key)
 	for e != nil {
-		array_append(items, e.value);
-		e = multi_map_find_next(m, e);
+		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;
+	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);
+		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);
+	items: Array(Value)
+	array_init(&items, 0)
 
-	e := multi_map_find_first(m, key);
+	e := multi_map_find_first(m, key)
 	for e != nil {
-		array_append(&items, e.value);
-		e = multi_map_find_next(m, e);
+		array_append(&items, e.value)
+		e = multi_map_find_next(m, e)
 	}
 
-	return array_slice(items);
+	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);
+		_map_grow(m)
 	}
 
-	i := _map_make(m, key);
-	array_get_ptr(m.entries, i).value = value;
+	i := _map_make(m, key)
+	array_get_ptr(m.entries, i).value = value
 	if _map_full(m^) {
-		_map_grow(m);
+		_map_grow(m)
 	}
 }
 
 multi_map_remove :: proc(m: ^$M/Map($Key, $Value), e: ^Map_Entry(Key, Value)) {
-	fr := _map_find_entry(m, e);
+	fr := _map_find_entry(m, e)
 	if fr.entry_index >= 0 {
-		_map_erase(m, fr);
+		_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);
+		map_remove(m, key)
 	}
 }
 
@@ -244,134 +244,134 @@ Map_Find_Result :: struct {
 }
 
 _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);
+	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;
+	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);
+		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;
+		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_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);
+	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;
+		array_get_ptr(m.entries, last.entry_prev).next = fr.entry_index
 	} else {
-		array_set(&m.hash, last.hash_index, fr.entry_index);
+		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;
+	fr: Map_Find_Result
+	fr.hash_index = -1
+	fr.entry_prev = -1
+	fr.entry_index = -1
 
 	if array_len(m.hash) == 0 {
-		return fr;
+		return fr
 	}
 
-	hasher := intrinsics.type_hasher_proc(Key);
+	hasher := intrinsics.type_hasher_proc(Key)
 
-	key := key;
-	hash := hasher(&key, 0);
+	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);
+	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);
+		it := array_get_ptr(m.entries, fr.entry_index)
 		if it.hash == hash && it.key == key {
-			return fr;
+			return fr
 		}
-		fr.entry_prev = fr.entry_index;
-		fr.entry_index = it.next;
+		fr.entry_prev = fr.entry_index
+		fr.entry_index = it.next
 	}
-	return fr;
+	return fr
 }
 
 _map_find_entry :: proc(m: ^$M/Map($Key, $Value), e: ^Map_Entry(Key, Value)) -> Map_Find_Result {
-	fr: Map_Find_Result;
-	fr.hash_index = -1;
-	fr.entry_prev = -1;
-	fr.entry_index = -1;
+	fr: Map_Find_Result
+	fr.hash_index = -1
+	fr.entry_prev = -1
+	fr.entry_index = -1
 
 	if array_len(m.hash) == 0 {
-		return fr;
+		return fr
 	}
 
-	fr.hash_index = int(e.hash % uintptr(array_len(m.hash)));
-	fr.entry_index = array_get(m.hash, fr.hash_index);
+	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);
+		it := array_get_ptr(m.entries, fr.entry_index)
 		if it == e {
-			return fr;
+			return fr
 		}
-		fr.entry_prev = fr.entry_index;
-		fr.entry_index = it.next;
+		fr.entry_prev = fr.entry_index
+		fr.entry_index = it.next
 	}
-	return fr;
+	return fr
 }
 
 _map_find_or_fail :: proc(m: $M/Map($Key, $Value), key: Key) -> int {
-	return _map_find_key(m, key).entry_index;
+	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);
+	fr := _map_find_key(m^, key)
 	if fr.entry_index >= 0 {
-		return fr.entry_index;
+		return fr.entry_index
 	}
 
-	i := _map_add_entry(m, key);
+	i := _map_add_entry(m, key)
 	if fr.entry_prev < 0 {
-		array_set(&m.hash, fr.hash_index, i);
+		array_set(&m.hash, fr.hash_index, i)
 	} else {
-		array_get_ptr(m.entries, fr.entry_prev).next = i;
+		array_get_ptr(m.entries, fr.entry_prev).next = i
 	}
-	return 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);
+	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);
+		array_set(&m.hash, fr.hash_index, i)
 	} else {
-		array_get_ptr(m.entries, fr.entry_prev).next = i;
+		array_get_ptr(m.entries, fr.entry_prev).next = i
 	}
 
-	array_get_ptr(m.entries, i).next = fr.entry_index;
+	array_get_ptr(m.entries, i).next = fr.entry_index
 
-	return i;
+	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;
+	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);
+	new_size := array_len(m.entries) * 4 + 7 // TODO(bill): Determine good grow rate
+	map_reserve(m, new_size)
 }
 
 

core/container/priority_queue.odin

@@ -7,107 +7,115 @@ Priority_Queue :: struct($T: typeid) {
 }
 
 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);
+	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);
+	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;
+	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_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);
+	array_delete(q.data)
 }
 
 priority_queue_clear :: proc(q: ^$Q/Priority_Queue($T)) {
-	q.len = 0;
+	q.len = 0
 }
 
 priority_queue_len :: proc(q: $Q/Priority_Queue($T)) -> int {
-	return q.len;
+	return q.len
 }
 
 priority_queue_cap :: proc(q: $Q/Priority_Queue($T)) -> int {
-	return array_cap(q.data);
+	return array_cap(q.data)
 }
 
 priority_queue_space :: proc(q: $Q/Priority_Queue($T)) -> int {
-	return array_len(q.data) - q.len;
+	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);
+		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);
+		array_resize(&q.data, new_capacity)
 	}
-	q.len = length;
+	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);
+	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);
+		_priority_queue_grow(q)
 	}
 
-	s := array_slice(q.data);
-	s[q.len] = item;
+	s := array_slice(q.data)
+	s[q.len] = item
 
-	i := q.len;
+	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;
+		p := (i - 1) / 2
+		if q.priority(s[p]) <= q.priority(item) { 
+			break 
+		}
+		s[i] = s[p]
+		i = p
 	}
 
-	q.len += 1;
-	if q.len > 0 do s[i] = item;
+	q.len += 1
+	if q.len > 0 { 
+		s[i] = item 
+	} 
 }
 
 
 
 priority_queue_pop :: proc(q: ^$Q/Priority_Queue($T)) -> T {
-	assert(q.len > 0);
+	assert(q.len > 0)
 
-	s := array_slice(q.data);
-	min := s[0];
-	root := s[q.len-1];
-	q.len -= 1;
+	s := array_slice(q.data)
+	min := s[0]
+	root := s[q.len-1]
+	q.len -= 1
 
-	i := 0;
+	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;
+		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.priority(s[c]) >= q.priority(root) {
+			break
+		}
+		s[i] = s[c]
+		i = c
 	}
 
-	if q.len > 0 do s[i] = root;
-	return min;
+	if q.len > 0 {
+		s[i] = root
+	}
+	return min
 }
 
 priority_queue_peek :: proc(q: ^$Q/Priority_Queue($T)) -> T {
-	assert(q.len > 0);
+	assert(q.len > 0)
 
-	s := array_slice(q.data);
-	return s[0];
+	s := array_slice(q.data)
+	return s[0]
 }

core/container/queue.odin

@@ -32,144 +32,144 @@ queue_consume
 */
 
 queue_init_none :: proc(q: ^$Q/Queue($T), allocator := context.allocator) {
-	queue_init_len(q, 0, 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(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;
+	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_init :: proc{queue_init_none, queue_init_len, queue_init_len_cap}
 
 queue_delete :: proc(q: $Q/Queue($T)) {
-	array_delete(q.data);
+	array_delete(q.data)
 }
 
 queue_clear :: proc(q: ^$Q/Queue($T)) {
-	q.len = 0;
+	q.len = 0
 }
 
 queue_len :: proc(q: $Q/Queue($T)) -> int {
-	return q.len;
+	return q.len
 }
 
 queue_cap :: proc(q: $Q/Queue($T)) -> int {
-	return array_cap(q.data);
+	return array_cap(q.data)
 }
 
 queue_space :: proc(q: $Q/Queue($T)) -> int {
-	return array_len(q.data) - q.len;
+	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];
+	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;
+	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_increase_capacity(q, capacity)
 	}
 }
 
 queue_resize :: proc(q: ^$Q/Queue($T), length: int) {
 	if length > q.len {
-		_queue_increase_capacity(q, length);
+		_queue_increase_capacity(q, length)
 	}
-	q.len = length;
+	q.len = length
 }
 
 queue_push_back :: proc(q: ^$Q/Queue($T), item: T) {
 	if queue_space(q^) == 0 {
-		_queue_grow(q);
+		_queue_grow(q)
 	}
 
-	queue_set(q, q.len, item);
-	q.len += 1;
+	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);
+		_queue_grow(q)
 	}
 
-	q.offset = (q.offset - 1 + array_len(q.data)) % array_len(q.data);
-	q.len += 1;
-	queue_set(q, 0, item);
+	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;
+	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;
+		q.offset = 0
 	}
-	return item;
+	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;
+	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;
+	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));
+		_queue_grow(q, q.len + len(items))
 	}
-	size := array_len(q.data);
-	insert := (q.offset + q.len) % size;
+	size := array_len(q.data)
+	insert := (q.offset + q.len) % size
 
-	to_insert := len(items);
+	to_insert := len(items)
 	if insert + to_insert > size {
-		to_insert = size - insert;
+		to_insert = size - insert
 	}
 
-	the_items := items[:];
+	the_items := items[:]
 
-	data := array_slice(q.data);
+	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);
+	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_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);
+	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;
+		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);
+	new_capacity := max(array_len(q.data)*2 + 8, min_capacity)
+	_queue_increase_capacity(q, new_capacity)
 }

core/container/ring.odin

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

core/container/set.odin

@@ -26,88 +26,88 @@ set_reserve
 set_clear
 */
 
-set_init :: proc{set_init_none, set_init_cap};
+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;
+	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);
+	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);
+	array_delete(m.hash)
+	array_delete(m.entries)
 }
 
 
 set_in :: proc(m: Set, key: u64) -> bool {
-	return _set_find_or_fail(m, key) >= 0;
+	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;
+	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_grow(m)
 	}
 
-	_ = _set_find_or_make(m, key);
+	_ = _set_find_or_make(m, key)
 	if _set_full(m^) {
-		_set_grow(m);
+		_set_grow(m)
 	}
 }
 
 set_remove :: proc(m: ^Set, key: u64) {
-	fr := _set_find_key(m^, key);
+	fr := _set_find_key(m^, key)
 	if fr.entry_index >= 0 {
-		_set_erase(m, fr);
+		_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));
+	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);
+		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);
+		e := array_get(m.entries, i)
+		set_add(&nm, e.key)
 	}
 
-	set_delete(m^);
-	m^ = nm;
+	set_delete(m^)
+	m^ = nm
 }
 
 set_clear :: proc(m: ^Set) {
-	array_clear(&m.hash);
-	array_clear(&m.entries);
+	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);
+	a_entries := array_slice(a.entries)
+	b_entries := array_slice(b.entries)
 	if len(a_entries) != len(b_entries) {
-		return false;
+		return false
 	}
 	for e in a_entries {
 		if set_not_in(b, e.key) {
-			return false;
+			return false
 		}
 	}
 
-	return true;
+	return true
 }
 
 
@@ -115,126 +115,126 @@ set_equal :: proc(a, b: Set) -> bool {
 /// 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;
+	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);
+		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;
+		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_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);
+	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;
+		array_get_ptr(m.entries, last.entry_prev).next = fr.entry_index
 	} else {
-		array_set(&m.hash, last.hash_index, fr.entry_index);
+		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;
+	fr: Map_Find_Result
+	fr.hash_index = -1
+	fr.entry_prev = -1
+	fr.entry_index = -1
 
 	if array_len(m.hash) == 0 {
-		return fr;
+		return fr
 	}
 
-	fr.hash_index = int(key % u64(array_len(m.hash)));
-	fr.entry_index = array_get(m.hash, fr.hash_index);
+	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);
+		it := array_get_ptr(m.entries, fr.entry_index)
 		if it.key == key {
-			return fr;
+			return fr
 		}
-		fr.entry_prev = fr.entry_index;
-		fr.entry_index = it.next;
+		fr.entry_prev = fr.entry_index
+		fr.entry_index = it.next
 	}
-	return fr;
+	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;
+	fr: Map_Find_Result
+	fr.hash_index = -1
+	fr.entry_prev = -1
+	fr.entry_index = -1
 
 	if array_len(m.hash) == 0 {
-		return fr;
+		return fr
 	}
 
-	fr.hash_index = int(e.key % u64(array_len(m.hash)));
-	fr.entry_index = array_get(m.hash, fr.hash_index);
+	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);
+		it := array_get_ptr(m.entries, fr.entry_index)
 		if it == e {
-			return fr;
+			return fr
 		}
-		fr.entry_prev = fr.entry_index;
-		fr.entry_index = it.next;
+		fr.entry_prev = fr.entry_index
+		fr.entry_index = it.next
 	}
-	return fr;
+	return fr
 }
 
 _set_find_or_fail :: proc(m: Set, key: u64) -> int {
-	return _set_find_key(m, key).entry_index;
+	return _set_find_key(m, key).entry_index
 }
 _set_find_or_make :: proc(m: ^Set, key: u64) -> int {
-	fr := _set_find_key(m^, key);
+	fr := _set_find_key(m^, key)
 	if fr.entry_index >= 0 {
-		return fr.entry_index;
+		return fr.entry_index
 	}
 
-	i := _set_add_entry(m, key);
+	i := _set_add_entry(m, key)
 	if fr.entry_prev < 0 {
-		array_set(&m.hash, fr.hash_index, i);
+		array_set(&m.hash, fr.hash_index, i)
 	} else {
-		array_get_ptr(m.entries, fr.entry_prev).next = i;
+		array_get_ptr(m.entries, fr.entry_prev).next = i
 	}
-	return i;
+	return i
 }
 
 
 _set_make :: proc(m: ^Set, key: u64) -> int {
-	fr := _set_find_key(m^, key);
-	i := _set_add_entry(m, key);
+	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);
+		array_set(&m.hash, fr.hash_index, i)
 	} else {
-		array_get_ptr(m.entries, fr.entry_prev).next = i;
+		array_get_ptr(m.entries, fr.entry_prev).next = i
 	}
 
-	array_get_ptr(m.entries, i).next = fr.entry_index;
+	array_get_ptr(m.entries, i).next = fr.entry_index
 
-	return i;
+	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;
+	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);
+	new_size := array_len(m.entries) * 4 + 7 // TODO(bill): Determine good grow rate
+	set_reserve(m, new_size)
 }
 
 

core/container/small_array.odin

@@ -7,89 +7,89 @@ Small_Array :: struct($N: int, $T: typeid) where N >= 0 {
 
 
 small_array_len :: proc(a: $A/Small_Array) -> int {
-	return a.len;
+	return a.len
 }
 
 small_array_cap :: proc(a: $A/Small_Array) -> int {
-	return len(a.data);
+	return len(a.data)
 }
 
 small_array_space :: proc(a: $A/Small_Array) -> int {
-	return len(a.data) - a.len;
+	return len(a.data) - a.len
 }
 
 small_array_slice :: proc(a: ^$A/Small_Array($N, $T)) -> []T {
-	return a.data[:a.len];
+	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];
+	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];
+	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;
+	a.data[index] = item
 }
 
 small_array_resize :: proc(a: ^$A/Small_Array, length: int) {
-	a.len = min(length, len(a.data));
+	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;
+		a.len += 1
+		a.data[a.len-1] = item
+		return true
 	}
-	return false;
+	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;
+		a.len += 1
+		data := small_array_slice(a)
+		copy(data[1:], data[:])
+		data[0] = item
+		return true
 	}
-	return false;
+	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;
+	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;
+	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;
+	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_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;
+	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};
+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/crypto/README.md

@@ -0,0 +1,97 @@
+# crypto
+A crypto library for the Odin language
+
+## Supported
+This library offers various algorithms available in either native Odin or via bindings to the [Botan](https://botan.randombit.net/) crypto library.
+Please see the chart below for the options.  
+**Note:** All crypto hash algorithms, offered by [Botan\'s FFI](https://botan.randombit.net/handbook/api_ref/hash.html), have been added.
+
+## Hashing algorithms
+| Algorithm                                                                                                    | Odin             | Botan                |
+|:-------------------------------------------------------------------------------------------------------------|:-----------------|:---------------------|
+| [BLAKE](https://web.archive.org/web/20190915215948/https://131002.net/blake)                                 | ✔️ |                      |
+| [BLAKE2B](https://datatracker.ietf.org/doc/html/rfc7693)                                                     | ✔️ | ✔️     |
+| [BLAKE2S](https://datatracker.ietf.org/doc/html/rfc7693)                                                     | ✔️ |                      |
+| [GOST](https://datatracker.ietf.org/doc/html/rfc5831)                                                        | ✔️ | ✔️     |
+| [Grøstl](http://www.groestl.info/Groestl.zip)                                                                | ✔️ |                      |
+| [HAVAL](https://web.archive.org/web/20150111210116/http://labs.calyptix.com/haval.php)                       | ✔️ |                      |
+| [JH](https://www3.ntu.edu.sg/home/wuhj/research/jh/index.html)                                               | ✔️ |                      |
+| [Keccak](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf)                                           | ✔️ | ✔️     |
+| [MD2](https://datatracker.ietf.org/doc/html/rfc1319)                                                         | ✔️ |                      |
+| [MD4](https://datatracker.ietf.org/doc/html/rfc1320)                                                         | ✔️ | ✔️     |
+| [MD5](https://datatracker.ietf.org/doc/html/rfc1321)                                                         | ✔️ | ✔️     |
+| [RIPEMD](https://homes.esat.kuleuven.be/~bosselae/ripemd160.html)                                            | ✔️ | ✔️\*   |
+| [SHA-1](https://datatracker.ietf.org/doc/html/rfc3174)                                                       | ✔️ | ✔️     |
+| [SHA-2](https://csrc.nist.gov/csrc/media/publications/fips/180/2/archive/2002-08-01/documents/fips180-2.pdf) | ✔️ | ✔️     |
+| [SHA-3](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf)                                            | ✔️ | ✔️     |
+| [SHAKE](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf)                                            | ✔️ | ✔️     |
+| [Skein](https://www.schneier.com/academic/skein/)                                                            |                  | ✔️\*\* |
+| [SM3](https://datatracker.ietf.org/doc/html/draft-sca-cfrg-sm3-02)                                           | ✔️ | ✔️     |
+| [Streebog](https://datatracker.ietf.org/doc/html/rfc6986)                                                    | ✔️ | ✔️     |
+| [Tiger](https://www.cs.technion.ac.il/~biham/Reports/Tiger/)                                                 | ✔️ | ✔️     |
+| [Tiger2](https://www.cs.technion.ac.il/~biham/Reports/Tiger/)                                                | ✔️ |                      |
+| [Whirlpool](https://web.archive.org/web/20171129084214/http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html)  | ✔️ | ✔️     |
+
+\* Only `RIPEMD-160`  
+\*\* Only `SKEIN-512`
+
+#### High level API
+Each hash algorithm contains a procedure group named `hash`, or if the algorithm provides more than one digest size `hash_<size>`\*\*\*.  
+Included in these groups are four procedures.
+* `hash_string` - Hash a given string and return the computed hash. Just calls `hash_bytes` internally
+* `hash_bytes` - Hash a given byte slice and return the computed hash
+* `hash_stream` - Takes a stream from io.Stream and returns the computed hash from it
+* `hash_file` - Takes a file handle and returns the computed hash from it. A second optional boolean parameter controls if the file is streamed (this is the default) or read at once (set to true)
+
+\*\*\* On some algorithms there is another part to the name, since they might offer control about additional parameters.  
+For instance, `HAVAL` offers different sizes as well as three different round amounts.  
+Computing a 256-bit hash with 3 rounds is therefore achieved by calling `haval.hash_256_3(...)`.
+
+#### Low level API
+The above mentioned procedures internally call three procedures: `init`, `update` and `final`.
+You may also directly call them, if you wish.
+
+#### Context system
+The library uses a context system internally to be able to switch between Odin / Botan implementations freely.  
+When an Odin implementation is available, it is the default.
+You may change what is used during runtime by calling `foo.use_botan()` or `foo.use_odin()`.  
+It is also possible to set this during compile time via `USE_BOTAN_LIB=true`.  
+Internally a vtable is used to set the appropriate procedures when switching. This works for all the procedures mentioned in the APIs above.
+
+#### Example
+```odin
+package crypto_example
+
+// Import the desired package
+import "core:crypto/md4"
+
+main :: proc() {
+    input := "foo"
+    // Compute the hash via Odin implementation
+    computed_hash := md4.hash(input)
+    // Switch to Botan
+    md4.use_botan()
+    // Compute the hash via Botan bindings
+    computed_hash_botan := md4.hash(input)
+}
+```
+For example uses of all available algorithms, please see the tests within `tests/core/crypto`.
+
+#### Thread safety
+The crypto package is not thread-safe at the moment. This may change in the future.
+
+### Disclaimer
+The algorithms were ported out of curiosity and due to interest in the field.
+We have not had any of the code verified by a third party or tested/fuzzed by any automatic means.
+Whereever we were able to find official test vectors, those were used to verify the implementation.
+We do not recommend using them in a production environment, without any additional testing and/or verification.
+
+### ToDo
+* Ciphers (Symmetric, Asymmetric)
+* MACs (Message Authentication Code)
+* CSPRNGs (Cryptographically Secure PseudoRandom Number Generator)
+* KDFs (Key Derivation Function)
+* KEAs (Key Exchange Algorithm)
+
+### License
+This library is made available under the BSD-3 license.

core/crypto/_ctx/_ctx.odin

@@ -0,0 +1,79 @@
+package _ctx
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog: Initial creation and testing of the bindings.
+
+    Implementation of the context, used internally by the crypto library.
+*/
+
+import "core:io"
+import "core:os"
+
+Hash_Size :: enum {
+    _16,
+    _20,
+    _24,
+    _28,
+    _32,
+    _40,
+    _48,
+    _64,
+    _128,
+}
+
+Hash_Context :: struct {
+    botan_hash_algo: cstring,
+    external_ctx:    any,
+    internal_ctx:    any,
+    hash_size:       Hash_Size,
+    hash_size_val:   int,
+    is_using_odin:   bool,
+    using vtbl:      ^Hash_Context_Vtable,
+}
+
+Hash_Context_Vtable :: struct {
+    hash_bytes_16     : proc (ctx: ^Hash_Context, input: []byte) -> [16]byte,
+    hash_bytes_20     : proc (ctx: ^Hash_Context, input: []byte) -> [20]byte,
+    hash_bytes_24     : proc (ctx: ^Hash_Context, input: []byte) -> [24]byte,
+    hash_bytes_28     : proc (ctx: ^Hash_Context, input: []byte) -> [28]byte,
+    hash_bytes_32     : proc (ctx: ^Hash_Context, input: []byte) -> [32]byte,
+    hash_bytes_40     : proc (ctx: ^Hash_Context, input: []byte) -> [40]byte,
+    hash_bytes_48     : proc (ctx: ^Hash_Context, input: []byte) -> [48]byte,
+    hash_bytes_64     : proc (ctx: ^Hash_Context, input: []byte) -> [64]byte,
+    hash_bytes_128    : proc (ctx: ^Hash_Context, input: []byte) -> [128]byte,
+    hash_file_16      : proc (ctx: ^Hash_Context, hd: os.Handle, load_at_once := false) -> ([16]byte,  bool),
+    hash_file_20      : proc (ctx: ^Hash_Context, hd: os.Handle, load_at_once := false) -> ([20]byte,  bool),
+    hash_file_24      : proc (ctx: ^Hash_Context, hd: os.Handle, load_at_once := false) -> ([24]byte,  bool),
+    hash_file_28      : proc (ctx: ^Hash_Context, hd: os.Handle, load_at_once := false) -> ([28]byte,  bool),
+    hash_file_32      : proc (ctx: ^Hash_Context, hd: os.Handle, load_at_once := false) -> ([32]byte,  bool),
+    hash_file_40      : proc (ctx: ^Hash_Context, hd: os.Handle, load_at_once := false) -> ([40]byte,  bool),
+    hash_file_48      : proc (ctx: ^Hash_Context, hd: os.Handle, load_at_once := false) -> ([48]byte,  bool),
+    hash_file_64      : proc (ctx: ^Hash_Context, hd: os.Handle, load_at_once := false) -> ([64]byte,  bool),
+    hash_file_128     : proc (ctx: ^Hash_Context, hd: os.Handle, load_at_once := false) -> ([128]byte, bool),
+    hash_stream_16    : proc (ctx: ^Hash_Context, s: io.Stream)  -> ([16]byte,  bool),
+    hash_stream_20    : proc (ctx: ^Hash_Context, s: io.Stream)  -> ([20]byte,  bool),
+    hash_stream_24    : proc (ctx: ^Hash_Context, s: io.Stream)  -> ([24]byte,  bool),
+    hash_stream_28    : proc (ctx: ^Hash_Context, s: io.Stream)  -> ([28]byte,  bool),
+    hash_stream_32    : proc (ctx: ^Hash_Context, s: io.Stream)  -> ([32]byte,  bool),
+    hash_stream_40    : proc (ctx: ^Hash_Context, s: io.Stream)  -> ([40]byte,  bool),
+    hash_stream_48    : proc (ctx: ^Hash_Context, s: io.Stream)  -> ([48]byte,  bool),
+    hash_stream_64    : proc (ctx: ^Hash_Context, s: io.Stream)  -> ([64]byte,  bool),
+    hash_stream_128   : proc (ctx: ^Hash_Context, s: io.Stream)  -> ([128]byte, bool),
+    hash_bytes_slice  : proc (ctx: ^Hash_Context, input: []byte, out_size: int, allocator := context.allocator) -> []byte,
+    hash_file_slice   : proc (ctx: ^Hash_Context, hd: os.Handle, out_size: int, load_at_once := false, allocator := context.allocator) -> ([]byte, bool),
+    hash_stream_slice : proc (ctx: ^Hash_Context, s: io.Stream,  out_size: int, allocator := context.allocator) -> ([]byte, bool),
+    init              : proc (ctx: ^Hash_Context),
+    update            : proc (ctx: ^Hash_Context, data: []byte),
+    final             : proc (ctx: ^Hash_Context, hash: []byte),
+}
+
+_init_vtable :: #force_inline proc() -> ^Hash_Context {
+    ctx     := new(Hash_Context)
+    vtbl    := new(Hash_Context_Vtable)
+    ctx.vtbl = vtbl
+    return ctx
+}

core/crypto/_sha3/_sha3.odin

@@ -0,0 +1,170 @@
+package _sha3
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Implementation of the Keccak hashing algorithm, standardized as SHA3 in <https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf>
+    To use the original Keccak padding, set the is_keccak bool to true, otherwise it will use SHA3 padding.
+*/
+
+import "../util"
+
+ROUNDS :: 24
+
+Sha3_Context :: struct {
+    st: struct #raw_union {
+        b: [200]u8,
+        q: [25]u64,
+    },
+    pt:        int,
+    rsiz:      int,
+    mdlen:     int,
+    is_keccak: bool,
+}
+
+keccakf :: proc "contextless" (st: ^[25]u64) {
+    keccakf_rndc := [?]u64 {
+        0x0000000000000001, 0x0000000000008082, 0x800000000000808a,
+        0x8000000080008000, 0x000000000000808b, 0x0000000080000001,
+        0x8000000080008081, 0x8000000000008009, 0x000000000000008a,
+        0x0000000000000088, 0x0000000080008009, 0x000000008000000a,
+        0x000000008000808b, 0x800000000000008b, 0x8000000000008089,
+        0x8000000000008003, 0x8000000000008002, 0x8000000000000080,
+        0x000000000000800a, 0x800000008000000a, 0x8000000080008081,
+        0x8000000000008080, 0x0000000080000001, 0x8000000080008008,
+    }
+
+    keccakf_rotc := [?]i32 {
+        1,  3,  6,  10, 15, 21, 28, 36, 45, 55, 2,  14,
+        27, 41, 56, 8,  25, 43, 62, 18, 39, 61, 20, 44,
+    }
+
+    keccakf_piln := [?]i32 {
+        10, 7,  11, 17, 18, 3, 5,  16, 8,  21, 24, 4,
+        15, 23, 19, 13, 12, 2, 20, 14, 22, 9,  6,  1,
+    }
+
+    i, j, r: i32 = ---, ---, ---
+    t: u64       = ---
+    bc: [5]u64   = ---
+
+    when ODIN_ENDIAN != "little" {
+        v: uintptr = ---
+        for i = 0; i < 25; i += 1 {
+            v := uintptr(&st[i])
+            st[i] = u64((^u8)(v + 0)^ << 0)  | u64((^u8)(v + 1)^ << 8)  |
+                    u64((^u8)(v + 2)^ << 16) | u64((^u8)(v + 3)^ << 24) |
+                    u64((^u8)(v + 4)^ << 32) | u64((^u8)(v + 5)^ << 40) |
+                    u64((^u8)(v + 6)^ << 48) | u64((^u8)(v + 7)^ << 56)
+        }
+    }
+
+    for r = 0; r < ROUNDS; r += 1 {
+        // theta
+        for i = 0; i < 5; i += 1 {
+            bc[i] = st[i] ~ st[i + 5] ~ st[i + 10] ~ st[i + 15] ~ st[i + 20]
+        }
+
+        for i = 0; i < 5; i += 1 {
+            t = bc[(i + 4) % 5] ~ util.ROTL64(bc[(i + 1) % 5], 1)
+            for j = 0; j < 25; j += 5 {
+                st[j + i] ~= t
+            }
+        }
+
+        // rho pi
+        t = st[1]
+        for i = 0; i < 24; i += 1 {
+            j = keccakf_piln[i]
+            bc[0] = st[j]
+            st[j] = util.ROTL64(t, u64(keccakf_rotc[i]))
+            t = bc[0]
+        }
+
+        // chi
+        for j = 0; j < 25; j += 5 {
+            for i = 0; i < 5; i += 1 {
+                bc[i] = st[j + i]
+            }
+            for i = 0; i < 5; i += 1 {
+                st[j + i] ~= ~bc[(i + 1) % 5] & bc[(i + 2) % 5]
+            }
+        }
+
+        st[0] ~= keccakf_rndc[r]
+    }
+
+    when ODIN_ENDIAN != "little" {
+        for i = 0; i < 25; i += 1 {
+            v = uintptr(&st[i])
+            t = st[i]
+            (^u8)(v + 0)^ = (t >> 0)  & 0xff
+            (^u8)(v + 1)^ = (t >> 8)  & 0xff
+            (^u8)(v + 2)^ = (t >> 16) & 0xff
+            (^u8)(v + 3)^ = (t >> 24) & 0xff
+            (^u8)(v + 4)^ = (t >> 32) & 0xff
+            (^u8)(v + 5)^ = (t >> 40) & 0xff
+            (^u8)(v + 6)^ = (t >> 48) & 0xff
+            (^u8)(v + 7)^ = (t >> 56) & 0xff
+        }
+    }
+}
+
+init_odin :: proc "contextless" (c: ^Sha3_Context) {
+    for i := 0; i < 25; i += 1 {
+        c.st.q[i] = 0
+    }
+    c.rsiz = 200 - 2 * c.mdlen
+}
+
+update_odin :: proc "contextless" (c: ^Sha3_Context, data: []byte) {
+    j := c.pt
+    for i := 0; i < len(data); i += 1 {
+        c.st.b[j] ~= data[i]
+        j += 1
+        if j >= c.rsiz {
+            keccakf(&c.st.q)
+            j = 0
+        }
+    }
+    c.pt = j
+}
+
+final_odin :: proc "contextless" (c: ^Sha3_Context, hash: []byte) {
+    if c.is_keccak {
+        c.st.b[c.pt] ~= 0x01
+    } else {
+        c.st.b[c.pt] ~= 0x06
+    }
+    
+    c.st.b[c.rsiz - 1] ~= 0x80
+    keccakf(&c.st.q)
+    for i := 0; i < c.mdlen; i += 1 {
+        hash[i] = c.st.b[i]
+    }
+}
+
+shake_xof_odin :: proc "contextless" (c: ^Sha3_Context) {
+    c.st.b[c.pt]       ~= 0x1F
+    c.st.b[c.rsiz - 1] ~= 0x80
+    keccakf(&c.st.q)
+    c.pt = 0
+}
+
+shake_out_odin :: proc "contextless" (c: ^Sha3_Context, hash: []byte) {
+    j := c.pt
+    for i := 0; i < len(hash); i += 1 {
+        if j >= c.rsiz {
+            keccakf(&c.st.q)
+            j = 0
+        }
+        hash[i] = c.st.b[j]
+        j += 1
+    }
+    c.pt = j
+}

core/crypto/_tiger/_tiger.odin

@@ -0,0 +1,411 @@
+package _tiger
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Implementation of the Tiger hashing algorithm, as defined in <https://www.cs.technion.ac.il/~biham/Reports/Tiger/>
+*/
+
+import "../util"
+
+T1 := [?]u64 {
+	0x02aab17cf7e90c5e, 0xac424b03e243a8ec, 0x72cd5be30dd5fcd3, 0x6d019b93f6f97f3a,
+	0xcd9978ffd21f9193, 0x7573a1c9708029e2, 0xb164326b922a83c3, 0x46883eee04915870,
+	0xeaace3057103ece6, 0xc54169b808a3535c, 0x4ce754918ddec47c, 0x0aa2f4dfdc0df40c,
+	0x10b76f18a74dbefa, 0xc6ccb6235ad1ab6a, 0x13726121572fe2ff, 0x1a488c6f199d921e,
+	0x4bc9f9f4da0007ca, 0x26f5e6f6e85241c7, 0x859079dbea5947b6, 0x4f1885c5c99e8c92,
+	0xd78e761ea96f864b, 0x8e36428c52b5c17d, 0x69cf6827373063c1, 0xb607c93d9bb4c56e,
+	0x7d820e760e76b5ea, 0x645c9cc6f07fdc42, 0xbf38a078243342e0, 0x5f6b343c9d2e7d04,
+	0xf2c28aeb600b0ec6, 0x6c0ed85f7254bcac, 0x71592281a4db4fe5, 0x1967fa69ce0fed9f,
+	0xfd5293f8b96545db, 0xc879e9d7f2a7600b, 0x860248920193194e, 0xa4f9533b2d9cc0b3,
+	0x9053836c15957613, 0xdb6dcf8afc357bf1, 0x18beea7a7a370f57, 0x037117ca50b99066,
+	0x6ab30a9774424a35, 0xf4e92f02e325249b, 0x7739db07061ccae1, 0xd8f3b49ceca42a05,
+	0xbd56be3f51382f73, 0x45faed5843b0bb28, 0x1c813d5c11bf1f83, 0x8af0e4b6d75fa169,
+	0x33ee18a487ad9999, 0x3c26e8eab1c94410, 0xb510102bc0a822f9, 0x141eef310ce6123b,
+	0xfc65b90059ddb154, 0xe0158640c5e0e607, 0x884e079826c3a3cf, 0x930d0d9523c535fd,
+	0x35638d754e9a2b00, 0x4085fccf40469dd5, 0xc4b17ad28be23a4c, 0xcab2f0fc6a3e6a2e,
+	0x2860971a6b943fcd, 0x3dde6ee212e30446, 0x6222f32ae01765ae, 0x5d550bb5478308fe,
+	0xa9efa98da0eda22a, 0xc351a71686c40da7, 0x1105586d9c867c84, 0xdcffee85fda22853,
+	0xccfbd0262c5eef76, 0xbaf294cb8990d201, 0xe69464f52afad975, 0x94b013afdf133e14,
+	0x06a7d1a32823c958, 0x6f95fe5130f61119, 0xd92ab34e462c06c0, 0xed7bde33887c71d2,
+	0x79746d6e6518393e, 0x5ba419385d713329, 0x7c1ba6b948a97564, 0x31987c197bfdac67,
+	0xde6c23c44b053d02, 0x581c49fed002d64d, 0xdd474d6338261571, 0xaa4546c3e473d062,
+	0x928fce349455f860, 0x48161bbacaab94d9, 0x63912430770e6f68, 0x6ec8a5e602c6641c,
+	0x87282515337ddd2b, 0x2cda6b42034b701b, 0xb03d37c181cb096d, 0xe108438266c71c6f,
+	0x2b3180c7eb51b255, 0xdf92b82f96c08bbc, 0x5c68c8c0a632f3ba, 0x5504cc861c3d0556,
+	0xabbfa4e55fb26b8f, 0x41848b0ab3baceb4, 0xb334a273aa445d32, 0xbca696f0a85ad881,
+	0x24f6ec65b528d56c, 0x0ce1512e90f4524a, 0x4e9dd79d5506d35a, 0x258905fac6ce9779,
+	0x2019295b3e109b33, 0xf8a9478b73a054cc, 0x2924f2f934417eb0, 0x3993357d536d1bc4,
+	0x38a81ac21db6ff8b, 0x47c4fbf17d6016bf, 0x1e0faadd7667e3f5, 0x7abcff62938beb96,
+	0xa78dad948fc179c9, 0x8f1f98b72911e50d, 0x61e48eae27121a91, 0x4d62f7ad31859808,
+	0xeceba345ef5ceaeb, 0xf5ceb25ebc9684ce, 0xf633e20cb7f76221, 0xa32cdf06ab8293e4,
+	0x985a202ca5ee2ca4, 0xcf0b8447cc8a8fb1, 0x9f765244979859a3, 0xa8d516b1a1240017,
+	0x0bd7ba3ebb5dc726, 0xe54bca55b86adb39, 0x1d7a3afd6c478063, 0x519ec608e7669edd,
+	0x0e5715a2d149aa23, 0x177d4571848ff194, 0xeeb55f3241014c22, 0x0f5e5ca13a6e2ec2,
+	0x8029927b75f5c361, 0xad139fabc3d6e436, 0x0d5df1a94ccf402f, 0x3e8bd948bea5dfc8,
+	0xa5a0d357bd3ff77e, 0xa2d12e251f74f645, 0x66fd9e525e81a082, 0x2e0c90ce7f687a49,
+	0xc2e8bcbeba973bc5, 0x000001bce509745f, 0x423777bbe6dab3d6, 0xd1661c7eaef06eb5,
+	0xa1781f354daacfd8, 0x2d11284a2b16affc, 0xf1fc4f67fa891d1f, 0x73ecc25dcb920ada,
+	0xae610c22c2a12651, 0x96e0a810d356b78a, 0x5a9a381f2fe7870f, 0xd5ad62ede94e5530,
+	0xd225e5e8368d1427, 0x65977b70c7af4631, 0x99f889b2de39d74f, 0x233f30bf54e1d143,
+	0x9a9675d3d9a63c97, 0x5470554ff334f9a8, 0x166acb744a4f5688, 0x70c74caab2e4aead,
+	0xf0d091646f294d12, 0x57b82a89684031d1, 0xefd95a5a61be0b6b, 0x2fbd12e969f2f29a,
+	0x9bd37013feff9fe8, 0x3f9b0404d6085a06, 0x4940c1f3166cfe15, 0x09542c4dcdf3defb,
+	0xb4c5218385cd5ce3, 0xc935b7dc4462a641, 0x3417f8a68ed3b63f, 0xb80959295b215b40,
+	0xf99cdaef3b8c8572, 0x018c0614f8fcb95d, 0x1b14accd1a3acdf3, 0x84d471f200bb732d,
+	0xc1a3110e95e8da16, 0x430a7220bf1a82b8, 0xb77e090d39df210e, 0x5ef4bd9f3cd05e9d,
+	0x9d4ff6da7e57a444, 0xda1d60e183d4a5f8, 0xb287c38417998e47, 0xfe3edc121bb31886,
+	0xc7fe3ccc980ccbef, 0xe46fb590189bfd03, 0x3732fd469a4c57dc, 0x7ef700a07cf1ad65,
+	0x59c64468a31d8859, 0x762fb0b4d45b61f6, 0x155baed099047718, 0x68755e4c3d50baa6,
+	0xe9214e7f22d8b4df, 0x2addbf532eac95f4, 0x32ae3909b4bd0109, 0x834df537b08e3450,
+	0xfa209da84220728d, 0x9e691d9b9efe23f7, 0x0446d288c4ae8d7f, 0x7b4cc524e169785b,
+	0x21d87f0135ca1385, 0xcebb400f137b8aa5, 0x272e2b66580796be, 0x3612264125c2b0de,
+	0x057702bdad1efbb2, 0xd4babb8eacf84be9, 0x91583139641bc67b, 0x8bdc2de08036e024,
+	0x603c8156f49f68ed, 0xf7d236f7dbef5111, 0x9727c4598ad21e80, 0xa08a0896670a5fd7,
+	0xcb4a8f4309eba9cb, 0x81af564b0f7036a1, 0xc0b99aa778199abd, 0x959f1ec83fc8e952,
+	0x8c505077794a81b9, 0x3acaaf8f056338f0, 0x07b43f50627a6778, 0x4a44ab49f5eccc77,
+	0x3bc3d6e4b679ee98, 0x9cc0d4d1cf14108c, 0x4406c00b206bc8a0, 0x82a18854c8d72d89,
+	0x67e366b35c3c432c, 0xb923dd61102b37f2, 0x56ab2779d884271d, 0xbe83e1b0ff1525af,
+	0xfb7c65d4217e49a9, 0x6bdbe0e76d48e7d4, 0x08df828745d9179e, 0x22ea6a9add53bd34,
+	0xe36e141c5622200a, 0x7f805d1b8cb750ee, 0xafe5c7a59f58e837, 0xe27f996a4fb1c23c,
+	0xd3867dfb0775f0d0, 0xd0e673de6e88891a, 0x123aeb9eafb86c25, 0x30f1d5d5c145b895,
+	0xbb434a2dee7269e7, 0x78cb67ecf931fa38, 0xf33b0372323bbf9c, 0x52d66336fb279c74,
+	0x505f33ac0afb4eaa, 0xe8a5cd99a2cce187, 0x534974801e2d30bb, 0x8d2d5711d5876d90,
+	0x1f1a412891bc038e, 0xd6e2e71d82e56648, 0x74036c3a497732b7, 0x89b67ed96361f5ab,
+	0xffed95d8f1ea02a2, 0xe72b3bd61464d43d, 0xa6300f170bdc4820, 0xebc18760ed78a77a,
+}
+
+T2 := [?]u64 {
+	0xe6a6be5a05a12138, 0xb5a122a5b4f87c98, 0x563c6089140b6990, 0x4c46cb2e391f5dd5,
+	0xd932addbc9b79434, 0x08ea70e42015aff5, 0xd765a6673e478cf1, 0xc4fb757eab278d99,
+	0xdf11c6862d6e0692, 0xddeb84f10d7f3b16, 0x6f2ef604a665ea04, 0x4a8e0f0ff0e0dfb3,
+	0xa5edeef83dbcba51, 0xfc4f0a2a0ea4371e, 0xe83e1da85cb38429, 0xdc8ff882ba1b1ce2,
+	0xcd45505e8353e80d, 0x18d19a00d4db0717, 0x34a0cfeda5f38101, 0x0be77e518887caf2,
+	0x1e341438b3c45136, 0xe05797f49089ccf9, 0xffd23f9df2591d14, 0x543dda228595c5cd,
+	0x661f81fd99052a33, 0x8736e641db0f7b76, 0x15227725418e5307, 0xe25f7f46162eb2fa,
+	0x48a8b2126c13d9fe, 0xafdc541792e76eea, 0x03d912bfc6d1898f, 0x31b1aafa1b83f51b,
+	0xf1ac2796e42ab7d9, 0x40a3a7d7fcd2ebac, 0x1056136d0afbbcc5, 0x7889e1dd9a6d0c85,
+	0xd33525782a7974aa, 0xa7e25d09078ac09b, 0xbd4138b3eac6edd0, 0x920abfbe71eb9e70,
+	0xa2a5d0f54fc2625c, 0xc054e36b0b1290a3, 0xf6dd59ff62fe932b, 0x3537354511a8ac7d,
+	0xca845e9172fadcd4, 0x84f82b60329d20dc, 0x79c62ce1cd672f18, 0x8b09a2add124642c,
+	0xd0c1e96a19d9e726, 0x5a786a9b4ba9500c, 0x0e020336634c43f3, 0xc17b474aeb66d822,
+	0x6a731ae3ec9baac2, 0x8226667ae0840258, 0x67d4567691caeca5, 0x1d94155c4875adb5,
+	0x6d00fd985b813fdf, 0x51286efcb774cd06, 0x5e8834471fa744af, 0xf72ca0aee761ae2e,
+	0xbe40e4cdaee8e09a, 0xe9970bbb5118f665, 0x726e4beb33df1964, 0x703b000729199762,
+	0x4631d816f5ef30a7, 0xb880b5b51504a6be, 0x641793c37ed84b6c, 0x7b21ed77f6e97d96,
+	0x776306312ef96b73, 0xae528948e86ff3f4, 0x53dbd7f286a3f8f8, 0x16cadce74cfc1063,
+	0x005c19bdfa52c6dd, 0x68868f5d64d46ad3, 0x3a9d512ccf1e186a, 0x367e62c2385660ae,
+	0xe359e7ea77dcb1d7, 0x526c0773749abe6e, 0x735ae5f9d09f734b, 0x493fc7cc8a558ba8,
+	0xb0b9c1533041ab45, 0x321958ba470a59bd, 0x852db00b5f46c393, 0x91209b2bd336b0e5,
+	0x6e604f7d659ef19f, 0xb99a8ae2782ccb24, 0xccf52ab6c814c4c7, 0x4727d9afbe11727b,
+	0x7e950d0c0121b34d, 0x756f435670ad471f, 0xf5add442615a6849, 0x4e87e09980b9957a,
+	0x2acfa1df50aee355, 0xd898263afd2fd556, 0xc8f4924dd80c8fd6, 0xcf99ca3d754a173a,
+	0xfe477bacaf91bf3c, 0xed5371f6d690c12d, 0x831a5c285e687094, 0xc5d3c90a3708a0a4,
+	0x0f7f903717d06580, 0x19f9bb13b8fdf27f, 0xb1bd6f1b4d502843, 0x1c761ba38fff4012,
+	0x0d1530c4e2e21f3b, 0x8943ce69a7372c8a, 0xe5184e11feb5ce66, 0x618bdb80bd736621,
+	0x7d29bad68b574d0b, 0x81bb613e25e6fe5b, 0x071c9c10bc07913f, 0xc7beeb7909ac2d97,
+	0xc3e58d353bc5d757, 0xeb017892f38f61e8, 0xd4effb9c9b1cc21a, 0x99727d26f494f7ab,
+	0xa3e063a2956b3e03, 0x9d4a8b9a4aa09c30, 0x3f6ab7d500090fb4, 0x9cc0f2a057268ac0,
+	0x3dee9d2dedbf42d1, 0x330f49c87960a972, 0xc6b2720287421b41, 0x0ac59ec07c00369c,
+	0xef4eac49cb353425, 0xf450244eef0129d8, 0x8acc46e5caf4deb6, 0x2ffeab63989263f7,
+	0x8f7cb9fe5d7a4578, 0x5bd8f7644e634635, 0x427a7315bf2dc900, 0x17d0c4aa2125261c,
+	0x3992486c93518e50, 0xb4cbfee0a2d7d4c3, 0x7c75d6202c5ddd8d, 0xdbc295d8e35b6c61,
+	0x60b369d302032b19, 0xce42685fdce44132, 0x06f3ddb9ddf65610, 0x8ea4d21db5e148f0,
+	0x20b0fce62fcd496f, 0x2c1b912358b0ee31, 0xb28317b818f5a308, 0xa89c1e189ca6d2cf,
+	0x0c6b18576aaadbc8, 0xb65deaa91299fae3, 0xfb2b794b7f1027e7, 0x04e4317f443b5beb,
+	0x4b852d325939d0a6, 0xd5ae6beefb207ffc, 0x309682b281c7d374, 0xbae309a194c3b475,
+	0x8cc3f97b13b49f05, 0x98a9422ff8293967, 0x244b16b01076ff7c, 0xf8bf571c663d67ee,
+	0x1f0d6758eee30da1, 0xc9b611d97adeb9b7, 0xb7afd5887b6c57a2, 0x6290ae846b984fe1,
+	0x94df4cdeacc1a5fd, 0x058a5bd1c5483aff, 0x63166cc142ba3c37, 0x8db8526eb2f76f40,
+	0xe10880036f0d6d4e, 0x9e0523c9971d311d, 0x45ec2824cc7cd691, 0x575b8359e62382c9,
+	0xfa9e400dc4889995, 0xd1823ecb45721568, 0xdafd983b8206082f, 0xaa7d29082386a8cb,
+	0x269fcd4403b87588, 0x1b91f5f728bdd1e0, 0xe4669f39040201f6, 0x7a1d7c218cf04ade,
+	0x65623c29d79ce5ce, 0x2368449096c00bb1, 0xab9bf1879da503ba, 0xbc23ecb1a458058e,
+	0x9a58df01bb401ecc, 0xa070e868a85f143d, 0x4ff188307df2239e, 0x14d565b41a641183,
+	0xee13337452701602, 0x950e3dcf3f285e09, 0x59930254b9c80953, 0x3bf299408930da6d,
+	0xa955943f53691387, 0xa15edecaa9cb8784, 0x29142127352be9a0, 0x76f0371fff4e7afb,
+	0x0239f450274f2228, 0xbb073af01d5e868b, 0xbfc80571c10e96c1, 0xd267088568222e23,
+	0x9671a3d48e80b5b0, 0x55b5d38ae193bb81, 0x693ae2d0a18b04b8, 0x5c48b4ecadd5335f,
+	0xfd743b194916a1ca, 0x2577018134be98c4, 0xe77987e83c54a4ad, 0x28e11014da33e1b9,
+	0x270cc59e226aa213, 0x71495f756d1a5f60, 0x9be853fb60afef77, 0xadc786a7f7443dbf,
+	0x0904456173b29a82, 0x58bc7a66c232bd5e, 0xf306558c673ac8b2, 0x41f639c6b6c9772a,
+	0x216defe99fda35da, 0x11640cc71c7be615, 0x93c43694565c5527, 0xea038e6246777839,
+	0xf9abf3ce5a3e2469, 0x741e768d0fd312d2, 0x0144b883ced652c6, 0xc20b5a5ba33f8552,
+	0x1ae69633c3435a9d, 0x97a28ca4088cfdec, 0x8824a43c1e96f420, 0x37612fa66eeea746,
+	0x6b4cb165f9cf0e5a, 0x43aa1c06a0abfb4a, 0x7f4dc26ff162796b, 0x6cbacc8e54ed9b0f,
+	0xa6b7ffefd2bb253e, 0x2e25bc95b0a29d4f, 0x86d6a58bdef1388c, 0xded74ac576b6f054,
+	0x8030bdbc2b45805d, 0x3c81af70e94d9289, 0x3eff6dda9e3100db, 0xb38dc39fdfcc8847,
+	0x123885528d17b87e, 0xf2da0ed240b1b642, 0x44cefadcd54bf9a9, 0x1312200e433c7ee6,
+	0x9ffcc84f3a78c748, 0xf0cd1f72248576bb, 0xec6974053638cfe4, 0x2ba7b67c0cec4e4c,
+	0xac2f4df3e5ce32ed, 0xcb33d14326ea4c11, 0xa4e9044cc77e58bc, 0x5f513293d934fcef,
+	0x5dc9645506e55444, 0x50de418f317de40a, 0x388cb31a69dde259, 0x2db4a83455820a86,
+	0x9010a91e84711ae9, 0x4df7f0b7b1498371, 0xd62a2eabc0977179, 0x22fac097aa8d5c0e,
+}
+
+T3 := [?]u64 {
+	0xf49fcc2ff1daf39b, 0x487fd5c66ff29281, 0xe8a30667fcdca83f, 0x2c9b4be3d2fcce63,
+	0xda3ff74b93fbbbc2, 0x2fa165d2fe70ba66, 0xa103e279970e93d4, 0xbecdec77b0e45e71,
+	0xcfb41e723985e497, 0xb70aaa025ef75017, 0xd42309f03840b8e0, 0x8efc1ad035898579,
+	0x96c6920be2b2abc5, 0x66af4163375a9172, 0x2174abdcca7127fb, 0xb33ccea64a72ff41,
+	0xf04a4933083066a5, 0x8d970acdd7289af5, 0x8f96e8e031c8c25e, 0xf3fec02276875d47,
+	0xec7bf310056190dd, 0xf5adb0aebb0f1491, 0x9b50f8850fd58892, 0x4975488358b74de8,
+	0xa3354ff691531c61, 0x0702bbe481d2c6ee, 0x89fb24057deded98, 0xac3075138596e902,
+	0x1d2d3580172772ed, 0xeb738fc28e6bc30d, 0x5854ef8f63044326, 0x9e5c52325add3bbe,
+	0x90aa53cf325c4623, 0xc1d24d51349dd067, 0x2051cfeea69ea624, 0x13220f0a862e7e4f,
+	0xce39399404e04864, 0xd9c42ca47086fcb7, 0x685ad2238a03e7cc, 0x066484b2ab2ff1db,
+	0xfe9d5d70efbf79ec, 0x5b13b9dd9c481854, 0x15f0d475ed1509ad, 0x0bebcd060ec79851,
+	0xd58c6791183ab7f8, 0xd1187c5052f3eee4, 0xc95d1192e54e82ff, 0x86eea14cb9ac6ca2,
+	0x3485beb153677d5d, 0xdd191d781f8c492a, 0xf60866baa784ebf9, 0x518f643ba2d08c74,
+	0x8852e956e1087c22, 0xa768cb8dc410ae8d, 0x38047726bfec8e1a, 0xa67738b4cd3b45aa,
+	0xad16691cec0dde19, 0xc6d4319380462e07, 0xc5a5876d0ba61938, 0x16b9fa1fa58fd840,
+	0x188ab1173ca74f18, 0xabda2f98c99c021f, 0x3e0580ab134ae816, 0x5f3b05b773645abb,
+	0x2501a2be5575f2f6, 0x1b2f74004e7e8ba9, 0x1cd7580371e8d953, 0x7f6ed89562764e30,
+	0xb15926ff596f003d, 0x9f65293da8c5d6b9, 0x6ecef04dd690f84c, 0x4782275fff33af88,
+	0xe41433083f820801, 0xfd0dfe409a1af9b5, 0x4325a3342cdb396b, 0x8ae77e62b301b252,
+	0xc36f9e9f6655615a, 0x85455a2d92d32c09, 0xf2c7dea949477485, 0x63cfb4c133a39eba,
+	0x83b040cc6ebc5462, 0x3b9454c8fdb326b0, 0x56f56a9e87ffd78c, 0x2dc2940d99f42bc6,
+	0x98f7df096b096e2d, 0x19a6e01e3ad852bf, 0x42a99ccbdbd4b40b, 0xa59998af45e9c559,
+	0x366295e807d93186, 0x6b48181bfaa1f773, 0x1fec57e2157a0a1d, 0x4667446af6201ad5,
+	0xe615ebcacfb0f075, 0xb8f31f4f68290778, 0x22713ed6ce22d11e, 0x3057c1a72ec3c93b,
+	0xcb46acc37c3f1f2f, 0xdbb893fd02aaf50e, 0x331fd92e600b9fcf, 0xa498f96148ea3ad6,
+	0xa8d8426e8b6a83ea, 0xa089b274b7735cdc, 0x87f6b3731e524a11, 0x118808e5cbc96749,
+	0x9906e4c7b19bd394, 0xafed7f7e9b24a20c, 0x6509eadeeb3644a7, 0x6c1ef1d3e8ef0ede,
+	0xb9c97d43e9798fb4, 0xa2f2d784740c28a3, 0x7b8496476197566f, 0x7a5be3e6b65f069d,
+	0xf96330ed78be6f10, 0xeee60de77a076a15, 0x2b4bee4aa08b9bd0, 0x6a56a63ec7b8894e,
+	0x02121359ba34fef4, 0x4cbf99f8283703fc, 0x398071350caf30c8, 0xd0a77a89f017687a,
+	0xf1c1a9eb9e423569, 0x8c7976282dee8199, 0x5d1737a5dd1f7abd, 0x4f53433c09a9fa80,
+	0xfa8b0c53df7ca1d9, 0x3fd9dcbc886ccb77, 0xc040917ca91b4720, 0x7dd00142f9d1dcdf,
+	0x8476fc1d4f387b58, 0x23f8e7c5f3316503, 0x032a2244e7e37339, 0x5c87a5d750f5a74b,
+	0x082b4cc43698992e, 0xdf917becb858f63c, 0x3270b8fc5bf86dda, 0x10ae72bb29b5dd76,
+	0x576ac94e7700362b, 0x1ad112dac61efb8f, 0x691bc30ec5faa427, 0xff246311cc327143,
+	0x3142368e30e53206, 0x71380e31e02ca396, 0x958d5c960aad76f1, 0xf8d6f430c16da536,
+	0xc8ffd13f1be7e1d2, 0x7578ae66004ddbe1, 0x05833f01067be646, 0xbb34b5ad3bfe586d,
+	0x095f34c9a12b97f0, 0x247ab64525d60ca8, 0xdcdbc6f3017477d1, 0x4a2e14d4decad24d,
+	0xbdb5e6d9be0a1eeb, 0x2a7e70f7794301ab, 0xdef42d8a270540fd, 0x01078ec0a34c22c1,
+	0xe5de511af4c16387, 0x7ebb3a52bd9a330a, 0x77697857aa7d6435, 0x004e831603ae4c32,
+	0xe7a21020ad78e312, 0x9d41a70c6ab420f2, 0x28e06c18ea1141e6, 0xd2b28cbd984f6b28,
+	0x26b75f6c446e9d83, 0xba47568c4d418d7f, 0xd80badbfe6183d8e, 0x0e206d7f5f166044,
+	0xe258a43911cbca3e, 0x723a1746b21dc0bc, 0xc7caa854f5d7cdd3, 0x7cac32883d261d9c,
+	0x7690c26423ba942c, 0x17e55524478042b8, 0xe0be477656a2389f, 0x4d289b5e67ab2da0,
+	0x44862b9c8fbbfd31, 0xb47cc8049d141365, 0x822c1b362b91c793, 0x4eb14655fb13dfd8,
+	0x1ecbba0714e2a97b, 0x6143459d5cde5f14, 0x53a8fbf1d5f0ac89, 0x97ea04d81c5e5b00,
+	0x622181a8d4fdb3f3, 0xe9bcd341572a1208, 0x1411258643cce58a, 0x9144c5fea4c6e0a4,
+	0x0d33d06565cf620f, 0x54a48d489f219ca1, 0xc43e5eac6d63c821, 0xa9728b3a72770daf,
+	0xd7934e7b20df87ef, 0xe35503b61a3e86e5, 0xcae321fbc819d504, 0x129a50b3ac60bfa6,
+	0xcd5e68ea7e9fb6c3, 0xb01c90199483b1c7, 0x3de93cd5c295376c, 0xaed52edf2ab9ad13,
+	0x2e60f512c0a07884, 0xbc3d86a3e36210c9, 0x35269d9b163951ce, 0x0c7d6e2ad0cdb5fa,
+	0x59e86297d87f5733, 0x298ef221898db0e7, 0x55000029d1a5aa7e, 0x8bc08ae1b5061b45,
+	0xc2c31c2b6c92703a, 0x94cc596baf25ef42, 0x0a1d73db22540456, 0x04b6a0f9d9c4179a,
+	0xeffdafa2ae3d3c60, 0xf7c8075bb49496c4, 0x9cc5c7141d1cd4e3, 0x78bd1638218e5534,
+	0xb2f11568f850246a, 0xedfabcfa9502bc29, 0x796ce5f2da23051b, 0xaae128b0dc93537c,
+	0x3a493da0ee4b29ae, 0xb5df6b2c416895d7, 0xfcabbd25122d7f37, 0x70810b58105dc4b1,
+	0xe10fdd37f7882a90, 0x524dcab5518a3f5c, 0x3c9e85878451255b, 0x4029828119bd34e2,
+	0x74a05b6f5d3ceccb, 0xb610021542e13eca, 0x0ff979d12f59e2ac, 0x6037da27e4f9cc50,
+	0x5e92975a0df1847d, 0xd66de190d3e623fe, 0x5032d6b87b568048, 0x9a36b7ce8235216e,
+	0x80272a7a24f64b4a, 0x93efed8b8c6916f7, 0x37ddbff44cce1555, 0x4b95db5d4b99bd25,
+	0x92d3fda169812fc0, 0xfb1a4a9a90660bb6, 0x730c196946a4b9b2, 0x81e289aa7f49da68,
+	0x64669a0f83b1a05f, 0x27b3ff7d9644f48b, 0xcc6b615c8db675b3, 0x674f20b9bcebbe95,
+	0x6f31238275655982, 0x5ae488713e45cf05, 0xbf619f9954c21157, 0xeabac46040a8eae9,
+	0x454c6fe9f2c0c1cd, 0x419cf6496412691c, 0xd3dc3bef265b0f70, 0x6d0e60f5c3578a9e,
+}
+
+T4 := [?]u64 {
+	0x5b0e608526323c55, 0x1a46c1a9fa1b59f5, 0xa9e245a17c4c8ffa, 0x65ca5159db2955d7,
+	0x05db0a76ce35afc2, 0x81eac77ea9113d45, 0x528ef88ab6ac0a0d, 0xa09ea253597be3ff,
+	0x430ddfb3ac48cd56, 0xc4b3a67af45ce46f, 0x4ececfd8fbe2d05e, 0x3ef56f10b39935f0,
+	0x0b22d6829cd619c6, 0x17fd460a74df2069, 0x6cf8cc8e8510ed40, 0xd6c824bf3a6ecaa7,
+	0x61243d581a817049, 0x048bacb6bbc163a2, 0xd9a38ac27d44cc32, 0x7fddff5baaf410ab,
+	0xad6d495aa804824b, 0xe1a6a74f2d8c9f94, 0xd4f7851235dee8e3, 0xfd4b7f886540d893,
+	0x247c20042aa4bfda, 0x096ea1c517d1327c, 0xd56966b4361a6685, 0x277da5c31221057d,
+	0x94d59893a43acff7, 0x64f0c51ccdc02281, 0x3d33bcc4ff6189db, 0xe005cb184ce66af1,
+	0xff5ccd1d1db99bea, 0xb0b854a7fe42980f, 0x7bd46a6a718d4b9f, 0xd10fa8cc22a5fd8c,
+	0xd31484952be4bd31, 0xc7fa975fcb243847, 0x4886ed1e5846c407, 0x28cddb791eb70b04,
+	0xc2b00be2f573417f, 0x5c9590452180f877, 0x7a6bddfff370eb00, 0xce509e38d6d9d6a4,
+	0xebeb0f00647fa702, 0x1dcc06cf76606f06, 0xe4d9f28ba286ff0a, 0xd85a305dc918c262,
+	0x475b1d8732225f54, 0x2d4fb51668ccb5fe, 0xa679b9d9d72bba20, 0x53841c0d912d43a5,
+	0x3b7eaa48bf12a4e8, 0x781e0e47f22f1ddf, 0xeff20ce60ab50973, 0x20d261d19dffb742,
+	0x16a12b03062a2e39, 0x1960eb2239650495, 0x251c16fed50eb8b8, 0x9ac0c330f826016e,
+	0xed152665953e7671, 0x02d63194a6369570, 0x5074f08394b1c987, 0x70ba598c90b25ce1,
+	0x794a15810b9742f6, 0x0d5925e9fcaf8c6c, 0x3067716cd868744e, 0x910ab077e8d7731b,
+	0x6a61bbdb5ac42f61, 0x93513efbf0851567, 0xf494724b9e83e9d5, 0xe887e1985c09648d,
+	0x34b1d3c675370cfd, 0xdc35e433bc0d255d, 0xd0aab84234131be0, 0x08042a50b48b7eaf,
+	0x9997c4ee44a3ab35, 0x829a7b49201799d0, 0x263b8307b7c54441, 0x752f95f4fd6a6ca6,
+	0x927217402c08c6e5, 0x2a8ab754a795d9ee, 0xa442f7552f72943d, 0x2c31334e19781208,
+	0x4fa98d7ceaee6291, 0x55c3862f665db309, 0xbd0610175d53b1f3, 0x46fe6cb840413f27,
+	0x3fe03792df0cfa59, 0xcfe700372eb85e8f, 0xa7be29e7adbce118, 0xe544ee5cde8431dd,
+	0x8a781b1b41f1873e, 0xa5c94c78a0d2f0e7, 0x39412e2877b60728, 0xa1265ef3afc9a62c,
+	0xbcc2770c6a2506c5, 0x3ab66dd5dce1ce12, 0xe65499d04a675b37, 0x7d8f523481bfd216,
+	0x0f6f64fcec15f389, 0x74efbe618b5b13c8, 0xacdc82b714273e1d, 0xdd40bfe003199d17,
+	0x37e99257e7e061f8, 0xfa52626904775aaa, 0x8bbbf63a463d56f9, 0xf0013f1543a26e64,
+	0xa8307e9f879ec898, 0xcc4c27a4150177cc, 0x1b432f2cca1d3348, 0xde1d1f8f9f6fa013,
+	0x606602a047a7ddd6, 0xd237ab64cc1cb2c7, 0x9b938e7225fcd1d3, 0xec4e03708e0ff476,
+	0xfeb2fbda3d03c12d, 0xae0bced2ee43889a, 0x22cb8923ebfb4f43, 0x69360d013cf7396d,
+	0x855e3602d2d4e022, 0x073805bad01f784c, 0x33e17a133852f546, 0xdf4874058ac7b638,
+	0xba92b29c678aa14a, 0x0ce89fc76cfaadcd, 0x5f9d4e0908339e34, 0xf1afe9291f5923b9,
+	0x6e3480f60f4a265f, 0xeebf3a2ab29b841c, 0xe21938a88f91b4ad, 0x57dfeff845c6d3c3,
+	0x2f006b0bf62caaf2, 0x62f479ef6f75ee78, 0x11a55ad41c8916a9, 0xf229d29084fed453,
+	0x42f1c27b16b000e6, 0x2b1f76749823c074, 0x4b76eca3c2745360, 0x8c98f463b91691bd,
+	0x14bcc93cf1ade66a, 0x8885213e6d458397, 0x8e177df0274d4711, 0xb49b73b5503f2951,
+	0x10168168c3f96b6b, 0x0e3d963b63cab0ae, 0x8dfc4b5655a1db14, 0xf789f1356e14de5c,
+	0x683e68af4e51dac1, 0xc9a84f9d8d4b0fd9, 0x3691e03f52a0f9d1, 0x5ed86e46e1878e80,
+	0x3c711a0e99d07150, 0x5a0865b20c4e9310, 0x56fbfc1fe4f0682e, 0xea8d5de3105edf9b,
+	0x71abfdb12379187a, 0x2eb99de1bee77b9c, 0x21ecc0ea33cf4523, 0x59a4d7521805c7a1,
+	0x3896f5eb56ae7c72, 0xaa638f3db18f75dc, 0x9f39358dabe9808e, 0xb7defa91c00b72ac,
+	0x6b5541fd62492d92, 0x6dc6dee8f92e4d5b, 0x353f57abc4beea7e, 0x735769d6da5690ce,
+	0x0a234aa642391484, 0xf6f9508028f80d9d, 0xb8e319a27ab3f215, 0x31ad9c1151341a4d,
+	0x773c22a57bef5805, 0x45c7561a07968633, 0xf913da9e249dbe36, 0xda652d9b78a64c68,
+	0x4c27a97f3bc334ef, 0x76621220e66b17f4, 0x967743899acd7d0b, 0xf3ee5bcae0ed6782,
+	0x409f753600c879fc, 0x06d09a39b5926db6, 0x6f83aeb0317ac588, 0x01e6ca4a86381f21,
+	0x66ff3462d19f3025, 0x72207c24ddfd3bfb, 0x4af6b6d3e2ece2eb, 0x9c994dbec7ea08de,
+	0x49ace597b09a8bc4, 0xb38c4766cf0797ba, 0x131b9373c57c2a75, 0xb1822cce61931e58,
+	0x9d7555b909ba1c0c, 0x127fafdd937d11d2, 0x29da3badc66d92e4, 0xa2c1d57154c2ecbc,
+	0x58c5134d82f6fe24, 0x1c3ae3515b62274f, 0xe907c82e01cb8126, 0xf8ed091913e37fcb,
+	0x3249d8f9c80046c9, 0x80cf9bede388fb63, 0x1881539a116cf19e, 0x5103f3f76bd52457,
+	0x15b7e6f5ae47f7a8, 0xdbd7c6ded47e9ccf, 0x44e55c410228bb1a, 0xb647d4255edb4e99,
+	0x5d11882bb8aafc30, 0xf5098bbb29d3212a, 0x8fb5ea14e90296b3, 0x677b942157dd025a,
+	0xfb58e7c0a390acb5, 0x89d3674c83bd4a01, 0x9e2da4df4bf3b93b, 0xfcc41e328cab4829,
+	0x03f38c96ba582c52, 0xcad1bdbd7fd85db2, 0xbbb442c16082ae83, 0xb95fe86ba5da9ab0,
+	0xb22e04673771a93f, 0x845358c9493152d8, 0xbe2a488697b4541e, 0x95a2dc2dd38e6966,
+	0xc02c11ac923c852b, 0x2388b1990df2a87b, 0x7c8008fa1b4f37be, 0x1f70d0c84d54e503,
+	0x5490adec7ece57d4, 0x002b3c27d9063a3a, 0x7eaea3848030a2bf, 0xc602326ded2003c0,
+	0x83a7287d69a94086, 0xc57a5fcb30f57a8a, 0xb56844e479ebe779, 0xa373b40f05dcbce9,
+	0xd71a786e88570ee2, 0x879cbacdbde8f6a0, 0x976ad1bcc164a32f, 0xab21e25e9666d78b,
+	0x901063aae5e5c33c, 0x9818b34448698d90, 0xe36487ae3e1e8abb, 0xafbdf931893bdcb4,
+	0x6345a0dc5fbbd519, 0x8628fe269b9465ca, 0x1e5d01603f9c51ec, 0x4de44006a15049b7,
+	0xbf6c70e5f776cbb1, 0x411218f2ef552bed, 0xcb0c0708705a36a3, 0xe74d14754f986044,
+	0xcd56d9430ea8280e, 0xc12591d7535f5065, 0xc83223f1720aef96, 0xc3a0396f7363a51f,
+}
+
+Tiger_Context :: struct {
+    a:      u64,
+	b:      u64,
+	c:      u64,
+	x:      [64]byte,
+	nx:     int,
+	length: u64,
+	ver:    int,
+}
+
+round :: #force_inline proc "contextless"(a, b, c, x, mul: u64) -> (u64, u64, u64) {
+	a, b, c := a, b, c
+	c ~= x
+	a -= T1[c & 0xff] ~ T2[(c >> 16) & 0xff] ~ T3[(c >> 32) & 0xff] ~ T4[(c >> 48) & 0xff]
+	b += T4[(c >> 8) & 0xff] ~ T3[(c >> 24) & 0xff] ~ T2[(c >> 40) & 0xff] ~ T1[(c >> 56) & 0xff]
+	b *= mul
+	return a, b, c
+}
+
+pass :: #force_inline proc "contextless"(a, b, c: u64, d: []u64, mul: u64) -> (x, y, z: u64) {
+	x, y, z = round(a, b, c, d[0], mul)
+	y, z, x = round(y, z, x, d[1], mul)
+	z, x, y = round(z, x, y, d[2], mul)
+	x, y, z = round(x, y, z, d[3], mul)
+	y, z, x = round(y, z, x, d[4], mul)
+	z, x, y = round(z, x, y, d[5], mul)
+	x, y, z = round(x, y, z, d[6], mul)
+	y, z, x = round(y, z, x, d[7], mul)
+	return
+}
+
+key_schedule :: #force_inline proc "contextless"(x: []u64) {
+	x[0] -= x[7] ~ 0xa5a5a5a5a5a5a5a5
+	x[1] ~= x[0]
+	x[2] += x[1]
+	x[3] -= x[2] ~ ((~x[1]) << 19)
+	x[4] ~= x[3]
+	x[5] += x[4]
+	x[6] -= x[5] ~ ((~x[4]) >> 23)
+	x[7] ~= x[6]
+	x[0] += x[7]
+	x[1] -= x[0] ~ ((~x[7]) << 19)
+	x[2] ~= x[1]
+	x[3] += x[2]
+	x[4] -= x[3] ~ ((~x[2]) >> 23)
+	x[5] ~= x[4]
+	x[6] += x[5]
+	x[7] -= x[6] ~ 0x0123456789abcdef
+}
+
+compress :: #force_inline proc "contextless"(ctx: ^Tiger_Context, data: []byte) {
+	a := ctx.a
+	b := ctx.b
+	c := ctx.c
+	x := util.cast_slice([]u64, data)
+	ctx.a, ctx.b, ctx.c = pass(ctx.a, ctx.b, ctx.c, x, 5)
+	key_schedule(x)
+	ctx.c, ctx.a, ctx.b = pass(ctx.c, ctx.a, ctx.b, x, 7)
+	key_schedule(x)
+	ctx.b, ctx.c, ctx.a = pass(ctx.b, ctx.c, ctx.a, x, 9)
+	ctx.a ~= a
+	ctx.b -= b
+	ctx.c += c
+}
+
+init_odin :: proc(ctx: ^Tiger_Context) {
+	ctx.a = 0x0123456789abcdef
+	ctx.b = 0xfedcba9876543210
+	ctx.c = 0xf096a5b4c3b2e187
+}
+
+update_odin :: proc(ctx: ^Tiger_Context, input: []byte) {
+	p := make([]byte, len(input))
+	copy(p, input)
+
+	length     := len(p)
+	ctx.length += u64(length)
+	if ctx.nx > 0 {
+		n := len(p)
+		if n > 64 - ctx.nx {
+			n = 64 - ctx.nx
+		}
+		copy(ctx.x[ctx.nx:ctx.nx + n], p[:n])
+		ctx.nx += n
+		if ctx.nx == 64 {
+			compress(ctx, ctx.x[:64 - 1])
+			ctx.nx = 0
+		}
+		p = p[n:]
+	}
+	for len(p) >= 64 {
+		compress(ctx, p[:64])
+		p = p[64:]
+	}
+	if len(p) > 0 {
+		ctx.nx = copy(ctx.x[:], p)
+	}
+}
+
+final_odin :: proc(ctx: ^Tiger_Context, hash: []byte) {
+	length := ctx.length
+	tmp: [64]byte
+	if ctx.ver == 1 {
+		tmp[0] = 0x01
+	} else {
+		tmp[0] = 0x80
+	}
+
+	size := length & 0x3f
+	if size < 56 {
+		update_odin(ctx, tmp[:56 - size])
+	} else {
+		update_odin(ctx, tmp[:64 + 56 - size])
+	}
+
+	length <<= 3
+	for i := uint(0); i < 8; i += 1 {
+		tmp[i] = byte(length >> (8 * i))
+	}
+	update_odin(ctx, tmp[:8])
+
+	for i := uint(0); i < 8; i += 1 {
+		tmp[i]      = byte(ctx.a >> (8 * i))
+		tmp[i + 8]  = byte(ctx.b >> (8 * i))
+		tmp[i + 16] = byte(ctx.c >> (8 * i))
+	}
+	copy(hash[:], tmp[:len(hash)])
+}

core/crypto/blake/blake.odin

@@ -0,0 +1,834 @@
+package blake
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Implementation of the BLAKE hashing algorithm, as defined in <https://web.archive.org/web/20190915215948/https://131002.net/blake>
+*/
+
+import "core:os"
+import "core:io"
+
+import "../_ctx"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_28  = hash_bytes_odin_28
+    ctx.hash_file_28   = hash_file_odin_28
+    ctx.hash_stream_28 = hash_stream_odin_28
+    ctx.hash_bytes_32  = hash_bytes_odin_32
+    ctx.hash_file_32   = hash_file_odin_32
+    ctx.hash_stream_32 = hash_stream_odin_32
+    ctx.hash_bytes_48  = hash_bytes_odin_48
+    ctx.hash_file_48   = hash_file_odin_48
+    ctx.hash_stream_48 = hash_stream_odin_48
+    ctx.hash_bytes_64  = hash_bytes_odin_64
+    ctx.hash_file_64   = hash_file_odin_64
+    ctx.hash_stream_64 = hash_stream_odin_64
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan does nothing, since BLAKE is not available in Botan
+@(warning="BLAKE is not provided by the Botan API. Odin implementation will be used")
+use_botan :: #force_inline proc() {
+    use_odin()
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+@(private)
+_create_blake256_ctx :: #force_inline proc(is224: bool, size: _ctx.Hash_Size) {
+    ctx: Blake256_Context
+    ctx.is224               = is224
+    _hash_impl.internal_ctx = ctx
+    _hash_impl.hash_size    = size
+}
+
+@(private)
+_create_blake512_ctx :: #force_inline proc(is384: bool, size: _ctx.Hash_Size) {
+    ctx: Blake512_Context
+    ctx.is384               = is384
+    _hash_impl.internal_ctx = ctx
+    _hash_impl.hash_size    = size
+}
+
+/*
+    High level API
+*/
+
+// hash_string_224 will hash the given input and return the
+// computed hash
+hash_string_224 :: proc(data: string) -> [28]byte {
+    return hash_bytes_224(transmute([]byte)(data))
+}
+
+// hash_bytes_224 will hash the given input and return the
+// computed hash
+hash_bytes_224 :: proc(data: []byte) -> [28]byte {
+    _create_blake256_ctx(true, ._28)
+    return _hash_impl->hash_bytes_28(data)
+}
+
+// hash_stream_224 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_224 :: proc(s: io.Stream) -> ([28]byte, bool) {
+    _create_blake256_ctx(true, ._28)
+    return _hash_impl->hash_stream_28(s)
+}
+
+// hash_file_224 will read the file provided by the given handle
+// and compute a hash
+hash_file_224 :: proc(hd: os.Handle, load_at_once := false) -> ([28]byte, bool) {
+    _create_blake256_ctx(true, ._28)
+    return _hash_impl->hash_file_28(hd, load_at_once)
+}
+
+hash_224 :: proc {
+    hash_stream_224,
+    hash_file_224,
+    hash_bytes_224,
+    hash_string_224,
+}
+
+// hash_string_256 will hash the given input and return the
+// computed hash
+hash_string_256 :: proc(data: string) -> [32]byte {
+    return hash_bytes_256(transmute([]byte)(data))
+}
+
+// hash_bytes_256 will hash the given input and return the
+// computed hash
+hash_bytes_256 :: proc(data: []byte) -> [32]byte {
+    _create_blake256_ctx(false, ._32)
+    return _hash_impl->hash_bytes_32(data)
+}
+
+// hash_stream_256 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_256 :: proc(s: io.Stream) -> ([32]byte, bool) {
+    _create_blake256_ctx(false, ._32)
+    return _hash_impl->hash_stream_32(s)
+}
+
+// hash_file_256 will read the file provided by the given handle
+// and compute a hash
+hash_file_256 :: proc(hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    _create_blake256_ctx(false, ._32)
+    return _hash_impl->hash_file_32(hd, load_at_once)
+}
+
+hash_256 :: proc {
+    hash_stream_256,
+    hash_file_256,
+    hash_bytes_256,
+    hash_string_256,
+}
+
+// hash_string_384 will hash the given input and return the
+// computed hash
+hash_string_384 :: proc(data: string) -> [48]byte {
+    return hash_bytes_384(transmute([]byte)(data))
+}
+
+// hash_bytes_384 will hash the given input and return the
+// computed hash
+hash_bytes_384 :: proc(data: []byte) -> [48]byte {
+    _create_blake512_ctx(true, ._48)
+    return _hash_impl->hash_bytes_48(data)
+}
+
+// hash_stream_384 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_384 :: proc(s: io.Stream) -> ([48]byte, bool) {
+    _create_blake512_ctx(true, ._48)
+    return _hash_impl->hash_stream_48(s)
+}
+
+// hash_file_384 will read the file provided by the given handle
+// and compute a hash
+hash_file_384 :: proc(hd: os.Handle, load_at_once := false) -> ([48]byte, bool) {
+    _create_blake512_ctx(true, ._48)
+    return _hash_impl->hash_file_48(hd, load_at_once)
+}
+
+hash_384 :: proc {
+    hash_stream_384,
+    hash_file_384,
+    hash_bytes_384,
+    hash_string_384,
+}
+
+// hash_string_512 will hash the given input and return the
+// computed hash
+hash_string_512 :: proc(data: string) -> [64]byte {
+    return hash_bytes_512(transmute([]byte)(data))
+}
+
+// hash_bytes_512 will hash the given input and return the
+// computed hash
+hash_bytes_512 :: proc(data: []byte) -> [64]byte {
+    _create_blake512_ctx(false, ._64)
+    return _hash_impl->hash_bytes_64(data)
+}
+
+// hash_stream_512 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_512 :: proc(s: io.Stream) -> ([64]byte, bool) {
+    _create_blake512_ctx(false, ._64)
+    return _hash_impl->hash_stream_64(s)
+}
+
+// hash_file_512 will read the file provided by the given handle
+// and compute a hash
+hash_file_512 :: proc(hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    _create_blake512_ctx(false, ._64)
+    return _hash_impl->hash_file_64(hd, load_at_once)
+}
+
+hash_512 :: proc {
+    hash_stream_512,
+    hash_file_512,
+    hash_bytes_512,
+    hash_string_512,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [28]byte {
+    hash: [28]byte
+    if c, ok := ctx.internal_ctx.(Blake256_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([28]byte, bool) {
+    hash: [28]byte
+    if c, ok := ctx.internal_ctx.(Blake256_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([28]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_28(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_28(ctx, buf[:]), ok
+        }
+    }
+    return [28]byte{}, false
+}
+
+hash_bytes_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [32]byte {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(Blake256_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([32]byte, bool) {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(Blake256_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_32(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_32(ctx, buf[:]), ok
+        }
+    }
+    return [32]byte{}, false
+}
+
+hash_bytes_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [48]byte {
+    hash: [48]byte
+    if c, ok := ctx.internal_ctx.(Blake512_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([48]byte, bool) {
+    hash: [48]byte
+    if c, ok := ctx.internal_ctx.(Blake512_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([48]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_48(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_48(ctx, buf[:]), ok
+        }
+    }
+    return [48]byte{}, false
+}
+
+hash_bytes_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [64]byte {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(Blake512_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([64]byte, bool) {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(Blake512_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_64(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_64(ctx, buf[:]), ok
+        }
+    }
+    return [64]byte{}, false
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    if ctx.hash_size == ._28 || ctx.hash_size == ._32 {
+        _create_blake256_ctx(ctx.hash_size == ._28, ctx.hash_size)
+        if c, ok := ctx.internal_ctx.(Blake256_Context); ok {
+            init_odin(&c)
+        }
+        return
+    }
+    if ctx.hash_size == ._48 || ctx.hash_size == ._64 {
+        _create_blake512_ctx(ctx.hash_size == ._48, ctx.hash_size)
+        if c, ok := ctx.internal_ctx.(Blake512_Context); ok {
+            init_odin(&c)
+        }
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    #partial switch ctx.hash_size {
+        case ._28, ._32:
+            if c, ok := ctx.internal_ctx.(Blake256_Context); ok {
+                update_odin(&c, data)
+            }
+        case ._48, ._64:
+            if c, ok := ctx.internal_ctx.(Blake512_Context); ok {
+                update_odin(&c, data)
+            }
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    #partial switch ctx.hash_size {
+        case ._28, ._32:
+            if c, ok := ctx.internal_ctx.(Blake256_Context); ok {
+                final_odin(&c, hash)
+            }
+        case ._48, ._64:
+            if c, ok := ctx.internal_ctx.(Blake512_Context); ok {
+                final_odin(&c, hash)
+            }
+    }
+}
+
+/*
+    BLAKE implementation
+*/
+
+SIZE_224 :: 28
+SIZE_256 :: 32
+SIZE_384 :: 48
+SIZE_512 :: 64
+BLOCKSIZE_256 :: 64
+BLOCKSIZE_512 :: 128
+
+Blake256_Context :: struct {
+    h:     [8]u32,
+    s:     [4]u32,
+    t:     u64,
+    x:     [64]byte,
+    nx:    int,
+    is224: bool,
+    nullt: bool,
+}
+
+Blake512_Context :: struct {
+    h:     [8]u64,
+    s:     [4]u64,
+    t:     u64,
+    x:     [128]byte,
+    nx:    int,
+    is384: bool,
+    nullt: bool,
+}
+
+SIGMA := [?]int {
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+    11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+    7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+    9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+    2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+    12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11,
+    13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10,
+    6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5,
+    10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0,
+}
+
+U256 := [16]u32 {
+    0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
+    0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+    0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
+    0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
+}
+
+U512 := [16]u64 {
+    0x243f6a8885a308d3, 0x13198a2e03707344, 0xa4093822299f31d0, 0x082efa98ec4e6c89,
+    0x452821e638d01377, 0xbe5466cf34e90c6c, 0xc0ac29b7c97c50dd, 0x3f84d5b5b5470917,
+    0x9216d5d98979fb1b, 0xd1310ba698dfb5ac, 0x2ffd72dbd01adfb7, 0xb8e1afed6a267e96,
+    0xba7c9045f12c7f99, 0x24a19947b3916cf7, 0x0801f2e2858efc16, 0x636920d871574e69,
+}
+
+G256 :: #force_inline proc "contextless" (a, b, c, d: u32, m: [16]u32, i, j: int) -> (u32, u32, u32, u32) {
+    a, b, c, d := a, b, c, d
+    a += m[SIGMA[(i % 10) * 16 + (2 * j)]] ~ U256[SIGMA[(i % 10) * 16 + (2 * j + 1)]]
+    a += b
+    d ~= a
+    d = d << (32 - 16) | d >> 16
+    c += d
+    b ~= c
+    b = b << (32 - 12) | b >> 12
+    a += m[SIGMA[(i % 10) * 16 + (2 * j + 1)]] ~ U256[SIGMA[(i % 10) * 16 + (2 * j)]]
+    a += b
+    d ~= a
+    d = d << (32 - 8) | d >> 8
+    c += d
+    b ~= c
+    b = b << (32 - 7) | b >> 7
+    return a, b, c, d
+}
+
+G512 :: #force_inline proc "contextless" (a, b, c, d: u64, m: [16]u64, i, j: int) -> (u64, u64, u64, u64) {
+    a, b, c, d := a, b, c, d
+    a += m[SIGMA[(i % 10) * 16 + (2 * j)]] ~ U512[SIGMA[(i % 10) * 16 + (2 * j + 1)]]
+    a += b
+    d ~= a
+    d = d << (64 - 32) | d >> 32
+    c += d
+    b ~= c
+    b = b << (64 - 25) | b >> 25
+    a += m[SIGMA[(i % 10) * 16 + (2 * j + 1)]] ~ U512[SIGMA[(i % 10) * 16 + (2 * j)]]
+    a += b
+    d ~= a
+    d = d << (64 - 16) | d >> 16
+    c += d
+    b ~= c
+    b = b << (64 - 11) | b >> 11
+    return a, b, c, d
+}
+
+block256 :: proc "contextless" (ctx: ^Blake256_Context, p: []byte) {
+    i, j: int = ---, ---
+    v, m: [16]u32 = ---, ---
+    p := p
+    for len(p) >= BLOCKSIZE_256 {
+        v[0]  = ctx.h[0]
+        v[1]  = ctx.h[1]
+        v[2]  = ctx.h[2]
+        v[3]  = ctx.h[3]
+        v[4]  = ctx.h[4]
+        v[5]  = ctx.h[5]
+        v[6]  = ctx.h[6]
+        v[7]  = ctx.h[7]
+        v[8]  = ctx.s[0] ~ U256[0]
+        v[9]  = ctx.s[1] ~ U256[1]
+        v[10] = ctx.s[2] ~ U256[2]
+        v[11] = ctx.s[3] ~ U256[3]
+        v[12] = U256[4]
+        v[13] = U256[5]
+        v[14] = U256[6]
+        v[15] = U256[7]
+
+        ctx.t += 512
+        if !ctx.nullt {
+            v[12] ~= u32(ctx.t)
+            v[13] ~= u32(ctx.t)
+            v[14] ~= u32(ctx.t >> 32)
+            v[15] ~= u32(ctx.t >> 32)
+        }
+
+        for i, j = 0, 0; i < 16; i, j = i+1, j+4 {
+            m[i] = u32(p[j]) << 24 | u32(p[j + 1]) << 16 | u32(p[j + 2]) << 8 | u32(p[j + 3])
+        }
+
+        for i = 0; i < 14; i += 1 {
+            v[0], v[4], v[8],  v[12] = G256(v[0], v[4], v[8],  v[12], m, i, 0)
+            v[1], v[5], v[9],  v[13] = G256(v[1], v[5], v[9],  v[13], m, i, 1)
+            v[2], v[6], v[10], v[14] = G256(v[2], v[6], v[10], v[14], m, i, 2)
+            v[3], v[7], v[11], v[15] = G256(v[3], v[7], v[11], v[15], m, i, 3)
+            v[0], v[5], v[10], v[15] = G256(v[0], v[5], v[10], v[15], m, i, 4)
+            v[1], v[6], v[11], v[12] = G256(v[1], v[6], v[11], v[12], m, i, 5)
+            v[2], v[7], v[8],  v[13] = G256(v[2], v[7], v[8],  v[13], m, i, 6)
+            v[3], v[4], v[9],  v[14] = G256(v[3], v[4], v[9],  v[14], m, i, 7)
+        }
+
+        for i = 0; i < 8; i += 1 {
+            ctx.h[i] ~= ctx.s[i % 4] ~ v[i] ~ v[i + 8]
+        }
+        p = p[BLOCKSIZE_256:]
+    }
+}
+
+block512 :: proc "contextless" (ctx: ^Blake512_Context, p: []byte) #no_bounds_check {
+    i, j: int = ---, ---
+    v, m: [16]u64 = ---, ---
+    p := p
+    for len(p) >= BLOCKSIZE_512 {
+        v[0]  = ctx.h[0]
+        v[1]  = ctx.h[1]
+        v[2]  = ctx.h[2]
+        v[3]  = ctx.h[3]
+        v[4]  = ctx.h[4]
+        v[5]  = ctx.h[5]
+        v[6]  = ctx.h[6]
+        v[7]  = ctx.h[7]
+        v[8]  = ctx.s[0] ~ U512[0]
+        v[9]  = ctx.s[1] ~ U512[1]
+        v[10] = ctx.s[2] ~ U512[2]
+        v[11] = ctx.s[3] ~ U512[3]
+        v[12] = U512[4]
+        v[13] = U512[5]
+        v[14] = U512[6]
+        v[15] = U512[7]
+
+        ctx.t += 1024
+        if !ctx.nullt {
+            v[12] ~= ctx.t
+            v[13] ~= ctx.t
+            v[14] ~= 0
+            v[15] ~= 0
+        }
+
+        for i, j = 0, 0; i < 16; i, j = i + 1, j + 8 {
+            m[i] = u64(p[j]) << 56     | u64(p[j + 1]) << 48 | u64(p[j + 2]) << 40 | u64(p[j + 3]) << 32 | 
+                   u64(p[j + 4]) << 24 | u64(p[j + 5]) << 16 | u64(p[j + 6]) << 8  | u64(p[j + 7])
+        }
+        for i = 0; i < 16; i += 1 {
+            v[0], v[4], v[8],  v[12] = G512(v[0], v[4], v[8],  v[12], m, i, 0)
+            v[1], v[5], v[9],  v[13] = G512(v[1], v[5], v[9],  v[13], m, i, 1)
+            v[2], v[6], v[10], v[14] = G512(v[2], v[6], v[10], v[14], m, i, 2)
+            v[3], v[7], v[11], v[15] = G512(v[3], v[7], v[11], v[15], m, i, 3)
+            v[0], v[5], v[10], v[15] = G512(v[0], v[5], v[10], v[15], m, i, 4)
+            v[1], v[6], v[11], v[12] = G512(v[1], v[6], v[11], v[12], m, i, 5)
+            v[2], v[7], v[8],  v[13] = G512(v[2], v[7], v[8],  v[13], m, i, 6)
+            v[3], v[4], v[9],  v[14] = G512(v[3], v[4], v[9],  v[14], m, i, 7)
+        }
+
+        for i = 0; i < 8; i += 1 {
+            ctx.h[i] ~= ctx.s[i % 4] ~ v[i] ~ v[i + 8]
+        }
+        p = p[BLOCKSIZE_512:]
+    }
+}
+
+init_odin :: proc(ctx: ^$T) {
+    when T == Blake256_Context {
+        if ctx.is224 {
+            ctx.h[0] = 0xc1059ed8
+            ctx.h[1] = 0x367cd507
+            ctx.h[2] = 0x3070dd17
+            ctx.h[3] = 0xf70e5939
+            ctx.h[4] = 0xffc00b31
+            ctx.h[5] = 0x68581511
+            ctx.h[6] = 0x64f98fa7
+            ctx.h[7] = 0xbefa4fa4
+        } else {
+            ctx.h[0] = 0x6a09e667
+            ctx.h[1] = 0xbb67ae85
+            ctx.h[2] = 0x3c6ef372
+            ctx.h[3] = 0xa54ff53a
+            ctx.h[4] = 0x510e527f
+            ctx.h[5] = 0x9b05688c
+            ctx.h[6] = 0x1f83d9ab
+            ctx.h[7] = 0x5be0cd19
+        }
+    } else when T == Blake512_Context {
+        if ctx.is384 {
+            ctx.h[0] = 0xcbbb9d5dc1059ed8
+            ctx.h[1] = 0x629a292a367cd507
+            ctx.h[2] = 0x9159015a3070dd17
+            ctx.h[3] = 0x152fecd8f70e5939
+            ctx.h[4] = 0x67332667ffc00b31
+            ctx.h[5] = 0x8eb44a8768581511
+            ctx.h[6] = 0xdb0c2e0d64f98fa7
+            ctx.h[7] = 0x47b5481dbefa4fa4
+        } else {
+            ctx.h[0] = 0x6a09e667f3bcc908
+            ctx.h[1] = 0xbb67ae8584caa73b
+            ctx.h[2] = 0x3c6ef372fe94f82b
+            ctx.h[3] = 0xa54ff53a5f1d36f1
+            ctx.h[4] = 0x510e527fade682d1
+            ctx.h[5] = 0x9b05688c2b3e6c1f
+            ctx.h[6] = 0x1f83d9abfb41bd6b
+            ctx.h[7] = 0x5be0cd19137e2179
+        }
+    }
+}
+
+update_odin :: proc(ctx: ^$T, data: []byte) {
+    data := data
+    when T == Blake256_Context {
+        if ctx.nx > 0 {
+            n := copy(ctx.x[ctx.nx:], data)
+            ctx.nx += n
+            if ctx.nx == BLOCKSIZE_256 {
+                block256(ctx, ctx.x[:])
+                ctx.nx = 0
+            }
+            data = data[n:]
+        }
+        if len(data) >= BLOCKSIZE_256 {
+            n := len(data) &~ (BLOCKSIZE_256 - 1)
+            block256(ctx, data[:n])
+            data = data[n:]
+        }
+        if len(data) > 0 {
+            ctx.nx = copy(ctx.x[:], data)
+        }
+    } else when T == Blake512_Context {
+        if ctx.nx > 0 {
+            n := copy(ctx.x[ctx.nx:], data)
+            ctx.nx += n
+            if ctx.nx == BLOCKSIZE_512 {
+                block512(ctx, ctx.x[:])
+                ctx.nx = 0
+            }
+            data = data[n:]
+        }
+        if len(data) >= BLOCKSIZE_512 {
+            n := len(data) &~ (BLOCKSIZE_512 - 1)
+            block512(ctx, data[:n])
+            data = data[n:]
+        }
+        if len(data) > 0 {
+            ctx.nx = copy(ctx.x[:], data)
+        }
+    }
+}
+
+final_odin :: proc(ctx: ^$T, hash: []byte) {
+	when T == Blake256_Context {
+		tmp: [65]byte
+	} else when T == Blake512_Context {
+		tmp: [129]byte
+	}
+	nx 	   := u64(ctx.nx)
+    tmp[0]  = 0x80
+    length := (ctx.t + nx) << 3
+
+    when T == Blake256_Context {
+        if nx == 55 {
+	        if ctx.is224 {
+	            write_additional(ctx, {0x80})
+	        } else {
+	            write_additional(ctx, {0x81})
+	        }
+	    } else {
+	        if nx < 55 {
+	            if nx == 0 {
+	                ctx.nullt = true
+	            }
+	            write_additional(ctx, tmp[0 : 55 - nx])
+	        } else { 
+	            write_additional(ctx, tmp[0 : 64 - nx])
+	            write_additional(ctx, tmp[1:56])
+	            ctx.nullt = true
+	        }
+	        if ctx.is224 {
+	            write_additional(ctx, {0x00})
+	        } else {
+	            write_additional(ctx, {0x01})
+	        }
+	    }
+
+	    for i : uint = 0; i < 8; i += 1 {
+	        tmp[i] = byte(length >> (56 - 8 * i))
+	    }
+	    write_additional(ctx, tmp[0:8])
+
+	    h := ctx.h[:]
+	    if ctx.is224 {
+	        h = h[0:7]
+	    }
+	    for s, i in h {
+	        hash[i * 4]     = byte(s >> 24)
+	        hash[i * 4 + 1] = byte(s >> 16)
+	        hash[i * 4 + 2] = byte(s >> 8)
+	        hash[i * 4 + 3] = byte(s)
+	    }
+    } else when T == Blake512_Context {
+        if nx == 111 {
+	        if ctx.is384 {
+	            write_additional(ctx, {0x80})
+	        } else {
+	            write_additional(ctx, {0x81})
+	        }
+	    } else {
+	        if nx < 111 {
+	            if nx == 0 {
+	                ctx.nullt = true
+	            }
+	            write_additional(ctx, tmp[0 : 111 - nx])
+	        } else { 
+	            write_additional(ctx, tmp[0 : 128 - nx])
+	            write_additional(ctx, tmp[1:112])
+	            ctx.nullt = true
+	        }
+	        if ctx.is384 {
+	            write_additional(ctx, {0x00})
+	        } else {
+	            write_additional(ctx, {0x01})
+	        }
+	    }
+
+	    for i : uint = 0; i < 16; i += 1 {
+	        tmp[i] = byte(length >> (120 - 8 * i))
+	    }
+	    write_additional(ctx, tmp[0:16])
+
+	    h := ctx.h[:]
+	    if ctx.is384 {
+	        h = h[0:6]
+	    }
+	    for s, i in h {
+	        hash[i * 8]     = byte(s >> 56)
+	        hash[i * 8 + 1] = byte(s >> 48)
+	        hash[i * 8 + 2] = byte(s >> 40)
+	        hash[i * 8 + 3] = byte(s >> 32)
+	        hash[i * 8 + 4] = byte(s >> 24)
+	        hash[i * 8 + 5] = byte(s >> 16)
+	        hash[i * 8 + 6] = byte(s >> 8)
+	        hash[i * 8 + 7] = byte(s)
+	    }
+    }
+}
+
+write_additional :: proc(ctx: ^$T, data: []byte) {
+	ctx.t -= u64(len(data)) << 3
+    update_odin(ctx, data)
+}

core/crypto/blake2b/blake2b.odin

@@ -0,0 +1,186 @@
+package blake2b
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Interface for the BLAKE2B hashing algorithm.
+    BLAKE2B and BLAKE2B share the implementation in the _blake2 package.
+*/
+
+import "core:os"
+import "core:io"
+
+import "../botan"
+import "../_ctx"
+import "../_blake2"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_64  = hash_bytes_odin
+    ctx.hash_file_64   = hash_file_odin
+    ctx.hash_stream_64 = hash_stream_odin
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan assigns the internal vtable of the hash context to use the Botan bindings
+use_botan :: #force_inline proc() {
+    botan.assign_hash_vtable(_hash_impl, botan.HASH_BLAKE2B)
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+/*
+    High level API
+*/
+
+// hash_string will hash the given input and return the
+// computed hash
+hash_string :: proc(data: string) -> [64]byte {
+    return hash_bytes(transmute([]byte)(data))
+}
+
+// hash_bytes will hash the given input and return the
+// computed hash
+hash_bytes :: proc(data: []byte) -> [64]byte {
+    _create_blake2b_ctx()
+    return _hash_impl->hash_bytes_64(data)
+}
+
+// hash_stream will read the stream in chunks and compute a
+// hash from its contents
+hash_stream :: proc(s: io.Stream) -> ([64]byte, bool) {
+    _create_blake2b_ctx()
+    return _hash_impl->hash_stream_64(s)
+}
+
+// hash_file will read the file provided by the given handle
+// and compute a hash
+hash_file :: proc(hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    _create_blake2b_ctx()
+    return _hash_impl->hash_file_64(hd, load_at_once)
+}
+
+hash :: proc {
+    hash_stream,
+    hash_file,
+    hash_bytes,
+    hash_string,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [64]byte {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(_blake2.Blake2b_Context); ok {
+        _blake2.init_odin(&c)
+        _blake2.update_odin(&c, data)
+        _blake2.blake2b_final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([64]byte, bool) {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(_blake2.Blake2b_Context); ok {
+        _blake2.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _blake2.update_odin(&c, buf[:read])
+            } 
+        }
+        _blake2.blake2b_final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin(ctx, buf[:]), ok
+        }
+    }
+    return [64]byte{}, false
+}
+
+@(private)
+_create_blake2b_ctx :: #force_inline proc() {
+    ctx: _blake2.Blake2b_Context
+    cfg: _blake2.Blake2_Config
+    cfg.size = _blake2.BLAKE2B_SIZE
+    ctx.cfg  = cfg
+    _hash_impl.internal_ctx = ctx
+    _hash_impl.hash_size    = ._64
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    _create_blake2b_ctx()
+    if c, ok := ctx.internal_ctx.(_blake2.Blake2b_Context); ok {
+        _blake2.init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(_blake2.Blake2b_Context); ok {
+        _blake2.update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(_blake2.Blake2b_Context); ok {
+        _blake2.blake2b_final_odin(&c, hash)
+    }
+}

core/crypto/blake2s/blake2s.odin

@@ -0,0 +1,186 @@
+package blake2s
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Interface for the BLAKE2S hashing algorithm.
+    BLAKE2B and BLAKE2B share the implementation in the _blake2 package.
+*/
+
+import "core:os"
+import "core:io"
+
+import "../_ctx"
+import "../_blake2"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_32  = hash_bytes_odin
+    ctx.hash_file_32   = hash_file_odin
+    ctx.hash_stream_32 = hash_stream_odin
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan does nothing, since Blake2s is not available in Botan
+@(warning="Blake2s is not provided by the Botan API. Odin implementation will be used")
+use_botan :: #force_inline proc() {
+	use_odin()
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+/*
+    High level API
+*/
+
+// hash_string will hash the given input and return the
+// computed hash
+hash_string :: proc(data: string) -> [32]byte {
+    return hash_bytes(transmute([]byte)(data))
+}
+
+// hash_bytes will hash the given input and return the
+// computed hash
+hash_bytes :: proc(data: []byte) -> [32]byte {
+    _create_blake2s_ctx()
+    return _hash_impl->hash_bytes_32(data)
+}
+
+// hash_stream will read the stream in chunks and compute a
+// hash from its contents
+hash_stream :: proc(s: io.Stream) -> ([32]byte, bool) {
+    _create_blake2s_ctx()
+    return _hash_impl->hash_stream_32(s)
+}
+
+// hash_file will read the file provided by the given handle
+// and compute a hash
+hash_file :: proc(hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    _create_blake2s_ctx()
+    return _hash_impl->hash_file_32(hd, load_at_once)
+}
+
+hash :: proc {
+    hash_stream,
+    hash_file,
+    hash_bytes,
+    hash_string,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [32]byte {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(_blake2.Blake2s_Context); ok {
+        _blake2.init_odin(&c)
+        _blake2.update_odin(&c, data)
+        _blake2.blake2s_final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([32]byte, bool) {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(_blake2.Blake2s_Context); ok {
+        _blake2.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _blake2.update_odin(&c, buf[:read])
+            } 
+        }
+        _blake2.blake2s_final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin(ctx, buf[:]), ok
+        }
+    }
+    return [32]byte{}, false
+}
+
+@(private)
+_create_blake2s_ctx :: #force_inline proc() {
+    ctx: _blake2.Blake2s_Context
+    cfg: _blake2.Blake2_Config
+    cfg.size = _blake2.BLAKE2S_SIZE
+    ctx.cfg  = cfg
+    _hash_impl.internal_ctx = ctx
+    _hash_impl.hash_size    = ._32
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    _create_blake2s_ctx()
+    if c, ok := ctx.internal_ctx.(_blake2.Blake2s_Context); ok {
+        _blake2.init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(_blake2.Blake2s_Context); ok {
+        _blake2.update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(_blake2.Blake2s_Context); ok {
+        _blake2.blake2s_final_odin(&c, hash)
+    }
+}

core/crypto/botan/botan.odin

@@ -0,0 +1,480 @@
+package botan
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog: Initial creation and testing of the bindings.
+
+    Bindings for the Botan crypto library.
+    Created for version 2.18.1, using the provided FFI header within Botan.
+
+    The "botan_" prefix has been stripped from the identifiers to remove redundancy,
+    since the package is already named botan.
+*/
+
+import "core:c"
+
+FFI_ERROR                           :: #type c.int
+FFI_SUCCESS                         :: FFI_ERROR(0)
+FFI_INVALID_VERIFIER                :: FFI_ERROR(1)
+FFI_ERROR_INVALID_INPUT             :: FFI_ERROR(-1)
+FFI_ERROR_BAD_MAC                   :: FFI_ERROR(-2)
+FFI_ERROR_INSUFFICIENT_BUFFER_SPACE :: FFI_ERROR(-10)
+FFI_ERROR_EXCEPTION_THROWN          :: FFI_ERROR(-20)
+FFI_ERROR_OUT_OF_MEMORY             :: FFI_ERROR(-21)
+FFI_ERROR_BAD_FLAG                  :: FFI_ERROR(-30)
+FFI_ERROR_NULL_POINTER              :: FFI_ERROR(-31)
+FFI_ERROR_BAD_PARAMETER             :: FFI_ERROR(-32)
+FFI_ERROR_KEY_NOT_SET               :: FFI_ERROR(-33)
+FFI_ERROR_INVALID_KEY_LENGTH        :: FFI_ERROR(-34)
+FFI_ERROR_NOT_IMPLEMENTED           :: FFI_ERROR(-40)
+FFI_ERROR_INVALID_OBJECT            :: FFI_ERROR(-50)
+FFI_ERROR_UNKNOWN_ERROR             :: FFI_ERROR(-100)
+
+FFI_HEX_LOWER_CASE              :: 1
+
+CIPHER_INIT_FLAG_MASK_DIRECTION :: 1
+CIPHER_INIT_FLAG_ENCRYPT        :: 0
+CIPHER_INIT_FLAG_DECRYPT        :: 1
+
+CIPHER_UPDATE_FLAG_FINAL        :: 1 << 0
+
+CHECK_KEY_EXPENSIVE_TESTS       :: 1
+
+PRIVKEY_EXPORT_FLAG_DER         :: 0
+PRIVKEY_EXPORT_FLAG_PEM         :: 1
+
+PUBKEY_DER_FORMAT_SIGNATURE     :: 1
+
+FPE_FLAG_FE1_COMPAT_MODE        :: 1
+
+x509_cert_key_constraints :: #type c.int
+NO_CONSTRAINTS            :: x509_cert_key_constraints(0)
+DIGITAL_SIGNATURE         :: x509_cert_key_constraints(32768)
+NON_REPUDIATION           :: x509_cert_key_constraints(16384)
+KEY_ENCIPHERMENT          :: x509_cert_key_constraints(8192)
+DATA_ENCIPHERMENT         :: x509_cert_key_constraints(4096)
+KEY_AGREEMENT             :: x509_cert_key_constraints(2048)
+KEY_CERT_SIGN             :: x509_cert_key_constraints(1024)
+CRL_SIGN                  :: x509_cert_key_constraints(512)
+ENCIPHER_ONLY             :: x509_cert_key_constraints(256)
+DECIPHER_ONLY             :: x509_cert_key_constraints(128)
+
+HASH_SHA1           :: "SHA1"
+HASH_SHA_224        :: "SHA-224"
+HASH_SHA_256        :: "SHA-256"
+HASH_SHA_384        :: "SHA-384"
+HASH_SHA_512        :: "SHA-512"
+HASH_SHA3_224       :: "SHA-3(224)"
+HASH_SHA3_256       :: "SHA-3(256)"
+HASH_SHA3_384       :: "SHA-3(384)"
+HASH_SHA3_512       :: "SHA-3(512)"
+HASH_SHAKE_128      :: "SHAKE-128"
+HASH_SHAKE_256      :: "SHAKE-256"
+HASH_KECCAK_224     :: "KECCAK(224)"
+HASH_KECCAK_256     :: "KECCAK(256)"
+HASH_KECCAK_384     :: "KECCAK(384)"
+HASH_KECCAK_512     :: "KECCAK(512)"
+HASH_RIPEMD_160     :: "RIPEMD-160"
+HASH_WHIRLPOOL      :: "Whirlpool"
+HASH_BLAKE2B        :: "BLAKE2b"
+HASH_MD4            :: "MD4"
+HASH_MD5            :: "MD5"
+HASH_TIGER_128      :: "Tiger(16,3)"
+HASH_TIGER_160      :: "Tiger(20,3)"
+HASH_TIGER_192      :: "Tiger(24,3)"
+HASH_GOST           :: "GOST-34.11"
+HASH_STREEBOG_256   :: "Streebog-256"
+HASH_STREEBOG_512   :: "Streebog-512"
+HASH_SM3            :: "SM3"
+HASH_SKEIN_512_256  :: "Skein-512(256)"
+HASH_SKEIN_512_512  :: "Skein-512(512)"
+HASH_SKEIN_512_1024 :: "Skein-512(1024)"
+
+// Not real values from Botan, only used for context setup within the crypto lib
+HASH_SHA2        :: "SHA2"
+HASH_SHA3        :: "SHA3"
+HASH_SHAKE       :: "SHAKE"
+HASH_KECCAK      :: "KECCAK"
+HASH_STREEBOG    :: "STREEBOG"
+HASH_TIGER       :: "TIGER"
+HASH_SKEIN_512   :: "SKEIN_512"
+
+MAC_HMAC_SHA1    :: "HMAC(SHA1)"
+MAC_HMAC_SHA_224 :: "HMAC(SHA-224)"
+MAC_HMAC_SHA_256 :: "HMAC(SHA-256)"
+MAC_HMAC_SHA_384 :: "HMAC(SHA-384)"
+MAC_HMAC_SHA_512 :: "HMAC(SHA-512)"
+MAC_HMAC_MD5     :: "HMAC(MD5)"
+
+hash_struct          :: struct{}
+hash_t               :: ^hash_struct
+rng_struct           :: struct{}
+rng_t                :: ^rng_struct
+mac_struct           :: struct{}
+mac_t                :: ^mac_struct
+cipher_struct        :: struct{}
+cipher_t             :: ^cipher_struct
+block_cipher_struct  :: struct{}
+block_cipher_t       :: ^block_cipher_struct
+mp_struct            :: struct{}
+mp_t                 :: ^mp_struct
+privkey_struct       :: struct{}
+privkey_t            :: ^privkey_struct
+pubkey_struct        :: struct{}
+pubkey_t             :: ^pubkey_struct
+pk_op_encrypt_struct :: struct{}
+pk_op_encrypt_t      :: ^pk_op_encrypt_struct
+pk_op_decrypt_struct :: struct{}
+pk_op_decrypt_t      :: ^pk_op_decrypt_struct
+pk_op_sign_struct    :: struct{}
+pk_op_sign_t         :: ^pk_op_sign_struct
+pk_op_verify_struct  :: struct{}
+pk_op_verify_t       :: ^pk_op_verify_struct
+pk_op_ka_struct      :: struct{}
+pk_op_ka_t           :: ^pk_op_ka_struct
+x509_cert_struct     :: struct{}
+x509_cert_t          :: ^x509_cert_struct
+x509_crl_struct      :: struct{}
+x509_crl_t           :: ^x509_crl_struct
+hotp_struct          :: struct{}
+hotp_t               :: ^hotp_struct
+totp_struct          :: struct{}
+totp_t               :: ^totp_struct
+fpe_struct           :: struct{}
+fpe_t                :: ^fpe_struct
+
+when ODIN_OS == "windows" {
+    foreign import botan_lib "botan.lib"
+} else when ODIN_OS == "linux" {
+    foreign import botan_lib "system:botan-2"
+} else when ODIN_OS == "darwin" {
+    foreign import botan_lib "system:botan-2"
+}
+
+@(default_calling_convention="c")
+@(link_prefix="botan_")
+foreign botan_lib {
+    error_description                   :: proc(err: c.int) -> cstring ---
+    ffi_api_version                     :: proc() -> c.int ---
+    ffi_supports_api                    :: proc(api_version: c.int) -> c.int ---
+    version_string                      :: proc() -> cstring ---
+    version_major                       :: proc() -> c.int ---
+    version_minor                       :: proc() -> c.int ---
+    version_patch                       :: proc() -> c.int ---
+    version_datestamp                   :: proc() -> c.int ---
+
+    constant_time_compare               :: proc(x, y: ^c.char, length: c.size_t) -> c.int ---
+    same_mem                            :: proc(x, y: ^c.char, length: c.size_t) -> c.int ---
+    scrub_mem                           :: proc(mem: rawptr, bytes: c.size_t) -> c.int ---
+
+    hex_encode                          :: proc(x: ^c.char, length: c.size_t, out: ^c.char, flags: c.uint) -> c.int ---
+    hex_decode                          :: proc(hex_str: cstring, in_len: c.size_t, out: ^c.char, out_len: c.size_t) -> c.int ---
+
+    base64_encode                       :: proc(x: ^c.char, length: c.size_t, out: ^c.char, out_len: c.size_t) -> c.int ---
+    base64_decode                       :: proc(base64_str: cstring, in_len: c.size_t, out: ^c.char, out_len: c.size_t) -> c.int ---
+
+    rng_init                            :: proc(rng: ^rng_t, rng_type: cstring) -> c.int ---
+    rng_init_custom                     :: proc(rng_out: ^rng_t, rng_name: cstring, ctx: rawptr, 
+                                                get_cb:         proc(ctx: rawptr, out: ^c.char, out_len: c.size_t) -> ^c.int,
+                                                add_entropy_cb: proc(ctx: rawptr, input: ^c.char, length: c.size_t) -> ^c.int,
+                                                destroy_cb:     proc(ctx: rawptr) -> rawptr) -> c.int ---
+    rng_get                             :: proc(rng: rng_t, out: ^c.char, out_len: c.size_t) -> c.int ---
+    rng_reseed                          :: proc(rng: rng_t, bits: c.size_t) -> c.int ---
+    rng_reseed_from_rng                 :: proc(rng, source_rng: rng_t, bits: c.size_t) -> c.int ---
+    rng_add_entropy                     :: proc(rng: rng_t, entropy: ^c.char, entropy_len: c.size_t) -> c.int ---
+    rng_destroy                         :: proc(rng: rng_t) -> c.int ---
+
+    hash_init                           :: proc(hash: ^hash_t, hash_name: cstring, flags: c.uint) -> c.int ---
+    hash_copy_state                     :: proc(dest: ^hash_t, source: hash_t) -> c.int ---
+    hash_output_length                  :: proc(hash: hash_t, output_length: ^c.size_t) -> c.int ---
+    hash_block_size                     :: proc(hash: hash_t, block_size: ^c.size_t) -> c.int ---
+    hash_update                         :: proc(hash: hash_t, input: ^c.char, input_len: c.size_t) -> c.int ---
+    hash_final                          :: proc(hash: hash_t, out: ^c.char) -> c.int ---
+    hash_clear                          :: proc(hash: hash_t) -> c.int ---
+    hash_destroy                        :: proc(hash: hash_t) -> c.int ---
+    hash_name                           :: proc(hash: hash_t, name: ^c.char, name_len: ^c.size_t) -> c.int ---
+
+    mac_init                            :: proc(mac: ^mac_t, hash_name: cstring, flags: c.uint) -> c.int ---
+    mac_output_length                   :: proc(mac: mac_t, output_length: ^c.size_t) -> c.int ---
+    mac_set_key                         :: proc(mac: mac_t, key: ^c.char, key_len: c.size_t) -> c.int ---
+    mac_update                          :: proc(mac: mac_t, buf: ^c.char, length: c.size_t) -> c.int ---
+    mac_final                           :: proc(mac: mac_t, out: ^c.char) -> c.int ---
+    mac_clear                           :: proc(mac: mac_t) -> c.int ---
+    mac_name                            :: proc(mac: mac_t, name: ^c.char, name_len: ^c.size_t) -> c.int ---
+    mac_get_keyspec                     :: proc(mac: mac_t, out_minimum_keylength, out_maximum_keylength, out_keylength_modulo: ^c.size_t) -> c.int ---
+    mac_destroy                         :: proc(mac: mac_t) -> c.int ---
+
+    cipher_init                         :: proc(cipher: ^cipher_t, name: cstring, flags: c.uint) -> c.int ---
+    cipher_name                         :: proc(cipher: cipher_t, name: ^c.char, name_len: ^c.size_t) -> c.int ---
+    cipher_output_length                :: proc(cipher: cipher_t, output_length: ^c.size_t) -> c.int ---
+    cipher_valid_nonce_length           :: proc(cipher: cipher_t, nl: c.size_t) -> c.int ---
+    cipher_get_tag_length               :: proc(cipher: cipher_t, tag_size: ^c.size_t) -> c.int ---
+    cipher_get_default_nonce_length     :: proc(cipher: cipher_t, nl: ^c.size_t) -> c.int ---
+    cipher_get_update_granularity       :: proc(cipher: cipher_t, ug: ^c.size_t) -> c.int ---
+    cipher_query_keylen                 :: proc(cipher: cipher_t, out_minimum_keylength, out_maximum_keylength: ^c.size_t) -> c.int ---
+    cipher_get_keyspec                  :: proc(cipher: cipher_t, min_keylen, max_keylen, mod_keylen: ^c.size_t) -> c.int ---
+    cipher_set_key                      :: proc(cipher: cipher_t, key: ^c.char, key_len: c.size_t) -> c.int ---
+    cipher_reset                        :: proc(cipher: cipher_t) -> c.int ---
+    cipher_set_associated_data          :: proc(cipher: cipher_t, ad: ^c.char, ad_len: c.size_t) -> c.int ---
+    cipher_start                        :: proc(cipher: cipher_t, nonce: ^c.char, nonce_len: c.size_t) -> c.int ---
+    cipher_update                       :: proc(cipher: cipher_t, flags: c.uint, output: ^c.char, output_size: c.size_t, output_written: ^c.size_t, 
+                                                input_bytes: ^c.char, input_size: c.size_t, input_consumed: ^c.size_t) -> c.int ---
+    cipher_clear                        :: proc(hash: cipher_t) -> c.int ---
+    cipher_destroy                      :: proc(cipher: cipher_t) -> c.int ---
+
+    @(deprecated="Use botan.pwdhash")
+    pbkdf                               :: proc(pbkdf_algo: cstring, out: ^c.char, out_len: c.size_t, passphrase: cstring, salt: ^c.char,
+                                                salt_len, iterations: c.size_t) -> c.int ---
+    @(deprecated="Use botan.pwdhash_timed")
+    pbkdf_timed                         :: proc(pbkdf_algo: cstring, out: ^c.char, out_len: c.size_t, passphrase: cstring, salt: ^c.char,
+                                                salt_len, milliseconds_to_run: c.size_t, out_iterations_used: ^c.size_t) -> c.int ---
+    pwdhash                             :: proc(algo: cstring, param1, param2, param3: c.size_t, out: ^c.char, out_len: c.size_t, passphrase: cstring,
+                                                passphrase_len: c.size_t, salt: ^c.char, salt_len: c.size_t) -> c.int ---
+    pwdhash_timed                       :: proc(algo: cstring, msec: c.uint, param1, param2, param3: c.size_t, out: ^c.char, out_len: c.size_t,
+                                                passphrase: cstring, passphrase_len: c.size_t, salt: ^c.char, salt_len: c.size_t) -> c.int ---
+    @(deprecated="Use botan.pwdhash")
+    scrypt                              :: proc(out: ^c.char, out_len: c.size_t, passphrase: cstring, salt: ^c.char, salt_len, N, r, p: c.size_t) -> c.int ---
+    kdf                                 :: proc(kdf_algo: cstring, out: ^c.char, out_len: c.size_t, secret: ^c.char, secret_lent: c.size_t, salt: ^c.char,
+                                                salt_len: c.size_t, label: ^c.char, label_len: c.size_t) -> c.int ---
+
+    block_cipher_init                   :: proc(bc: ^block_cipher_t, name: cstring) -> c.int ---
+    block_cipher_destroy                :: proc(bc: block_cipher_t) -> c.int ---
+    block_cipher_clear                  :: proc(bc: block_cipher_t) -> c.int ---
+    block_cipher_set_key                :: proc(bc: block_cipher_t, key: ^c.char, key_len: c.size_t) -> c.int ---
+    block_cipher_block_size             :: proc(bc: block_cipher_t) -> c.int ---
+    block_cipher_encrypt_blocks         :: proc(bc: block_cipher_t, input, out: ^c.char, blocks: c.size_t) -> c.int ---
+    block_cipher_decrypt_blocks         :: proc(bc: block_cipher_t, input, out: ^c.char, blocks: c.size_t) -> c.int ---
+    block_cipher_name                   :: proc(bc: block_cipher_t, name: ^c.char, name_len: ^c.size_t) -> c.int ---
+    block_cipher_get_keyspec            :: proc(bc: block_cipher_t, out_minimum_keylength, out_maximum_keylength, out_keylength_modulo: ^c.size_t) -> c.int ---
+    
+    mp_init                             :: proc(mp: ^mp_t) -> c.int ---
+    mp_destroy                          :: proc(mp: mp_t) -> c.int ---
+    mp_to_hex                           :: proc(mp: mp_t, out: ^c.char) -> c.int ---
+    mp_to_str                           :: proc(mp: mp_t, base: c.char, out: ^c.char, out_len: ^c.size_t) -> c.int ---
+    mp_clear                            :: proc(mp: mp_t) -> c.int ---
+    mp_set_from_int                     :: proc(mp: mp_t, initial_value: c.int) -> c.int ---
+    mp_set_from_mp                      :: proc(dest, source: mp_t) -> c.int ---
+    mp_set_from_str                     :: proc(dest: mp_t, str: cstring) -> c.int ---
+    mp_set_from_radix_str               :: proc(mp: mp_t, str: cstring, radix: c.size_t) -> c.int ---
+    mp_num_bits                         :: proc(n: mp_t, bits: ^c.size_t) -> c.int ---
+    mp_num_bytes                        :: proc(n: mp_t, bytes: ^c.size_t) -> c.int ---
+    mp_to_bin                           :: proc(mp: mp_t, vec: ^c.char) -> c.int ---
+    mp_from_bin                         :: proc(mp: mp_t, vec: ^c.char, vec_len: c.size_t) -> c.int ---
+    mp_to_uint32                        :: proc(mp: mp_t, val: ^c.uint) -> c.int ---
+    mp_is_positive                      :: proc(mp: mp_t) -> c.int ---
+    mp_is_negative                      :: proc(mp: mp_t) -> c.int ---
+    mp_flip_sign                        :: proc(mp: mp_t) -> c.int ---
+    mp_is_zero                          :: proc(mp: mp_t) -> c.int ---
+    @(deprecated="Use botan.mp_get_bit(0)")
+    mp_is_odd                           :: proc(mp: mp_t) -> c.int ---
+    @(deprecated="Use botan.mp_get_bit(0)")
+    mp_is_even                          :: proc(mp: mp_t) -> c.int ---
+    mp_add_u32                          :: proc(result, x: mp_t, y: c.uint) -> c.int ---
+    mp_sub_u32                          :: proc(result, x: mp_t, y: c.uint) -> c.int ---
+    mp_add                              :: proc(result, x, y: mp_t) -> c.int ---
+    mp_sub                              :: proc(result, x, y: mp_t) -> c.int ---
+    mp_mul                              :: proc(result, x, y: mp_t) -> c.int ---
+    mp_div                              :: proc(quotient, remainder, x, y: mp_t) -> c.int ---
+    mp_mod_mul                          :: proc(result, x, y, mod: mp_t) -> c.int ---
+    mp_equal                            :: proc(x, y: mp_t) -> c.int ---
+    mp_cmp                              :: proc(result: ^c.int, x, y: mp_t) -> c.int ---
+    mp_swap                             :: proc(x, y: mp_t) -> c.int ---
+    mp_powmod                           :: proc(out, base, exponent, modulus: mp_t) -> c.int ---
+    mp_lshift                           :: proc(out, input: mp_t, shift: c.size_t) -> c.int ---
+    mp_rshift                           :: proc(out, input: mp_t, shift: c.size_t) -> c.int ---
+    mp_mod_inverse                      :: proc(out, input, modulus: mp_t) -> c.int ---
+    mp_rand_bits                        :: proc(rand_out: mp_t, rng: rng_t, bits: c.size_t) -> c.int ---
+    mp_rand_range                       :: proc(rand_out: mp_t, rng: rng_t, lower_bound, upper_bound: mp_t) -> c.int ---
+    mp_gcd                              :: proc(out, x, y: mp_t) -> c.int ---
+    mp_is_prime                         :: proc(n: mp_t, rng: rng_t, test_prob: c.size_t) -> c.int ---
+    mp_get_bit                          :: proc(n: mp_t, bit: c.size_t) -> c.int ---
+    mp_set_bit                          :: proc(n: mp_t, bit: c.size_t) -> c.int ---
+    mp_clear_bit                        :: proc(n: mp_t, bit: c.size_t) -> c.int ---
+
+    bcrypt_generate                     :: proc(out: ^c.char, out_len: ^c.size_t, password: cstring, rng: rng_t, work_factor: c.size_t, flags: c.uint) -> c.int --- 
+    bcrypt_is_valid                     :: proc(pass, hash: cstring) -> c.int ---
+
+    privkey_create                      :: proc(key: ^privkey_t, algo_name, algo_params: cstring, rng: rng_t) -> c.int ---
+    @(deprecated="Use botan.privkey_create")
+    privkey_check_key                   :: proc(key: privkey_t, rng: rng_t, flags: c.uint) -> c.int ---
+    @(deprecated="Use botan.privkey_create")
+    privkey_create_rsa                  :: proc(key: ^privkey_t, rng: rng_t, bits: c.size_t) -> c.int ---
+    @(deprecated="Use botan.privkey_create")
+    privkey_create_ecdsa                :: proc(key: ^privkey_t, rng: rng_t, params: cstring) -> c.int ---
+    @(deprecated="Use botan.privkey_create")
+    privkey_create_ecdh                 :: proc(key: ^privkey_t, rng: rng_t, params: cstring) -> c.int ---
+    @(deprecated="Use botan.privkey_create")
+    privkey_create_mceliece             :: proc(key: ^privkey_t, rng: rng_t, n, t: c.size_t) -> c.int ---
+    @(deprecated="Use botan.privkey_create")
+    privkey_create_dh                   :: proc(key: ^privkey_t, rng: rng_t, param: cstring) -> c.int ---
+    privkey_create_dsa                  :: proc(key: ^privkey_t, rng: rng_t, pbits, qbits: c.size_t) -> c.int ---
+    privkey_create_elgamal              :: proc(key: ^privkey_t, rng: rng_t, pbits, qbits: c.size_t) -> c.int ---
+    privkey_load                        :: proc(key: ^privkey_t, rng: rng_t, bits: ^c.char, length: c.size_t, password: cstring) -> c.int ---
+    privkey_destroy                     :: proc(key: privkey_t) -> c.int ---
+    privkey_export                      :: proc(key: privkey_t, out: ^c.char, out_len: ^c.size_t, flags: c.uint) -> c.int ---
+    privkey_algo_name                   :: proc(key: privkey_t, out: ^c.char, out_len: ^c.size_t) -> c.int ---
+    @(deprecated="Use botan.privkey_export_encrypted_pbkdf_{msec,iter}")
+    privkey_export_encrypted            :: proc(key: privkey_t, out: ^c.char, out_len: ^c.size_t, rng: rng_t, passphrase, encryption_algo: cstring, flags: c.uint) -> c.int ---
+    privkey_export_encrypted_pbkdf_msec :: proc(key: privkey_t, out: ^c.char, out_len: ^c.size_t, rng: rng_t, passphrase: cstring, pbkdf_msec_runtime: c.uint,
+                                                pbkdf_iterations_out: ^c.size_t, cipher_algo, pbkdf_algo: cstring, flags: c.uint) -> c.int ---
+    privkey_export_encrypted_pbkdf_iter :: proc(key: privkey_t, out: ^c.char, out_len: ^c.size_t, rng: rng_t, passphrase: cstring, pbkdf_iterations: c.size_t,
+                                                cipher_algo, pbkdf_algo: cstring, flags: c.uint) -> c.int ---
+    pubkey_load                         :: proc(key: ^pubkey_t, bits: ^c.char, length: c.size_t) -> c.int ---
+    privkey_export_pubkey               :: proc(out: ^pubkey_t, input: privkey_t) -> c.int ---
+    pubkey_export                       :: proc(key: pubkey_t, out: ^c.char, out_len: ^c.size_t, flags: c.uint) -> c.int ---
+    pubkey_algo_name                    :: proc(key: pubkey_t, out: ^c.char, out_len: ^c.size_t) -> c.int ---
+    pubkey_check_key                    :: proc(key: pubkey_t, rng: rng_t, flags: c.uint) -> c.int ---
+    pubkey_estimated_strength           :: proc(key: pubkey_t, estimate: ^c.size_t) -> c.int ---
+    pubkey_fingerprint                  :: proc(key: pubkey_t, hash: cstring, out: ^c.char, out_len: ^c.size_t) -> c.int ---
+    pubkey_destroy                      :: proc(key: pubkey_t) -> c.int ---
+    pubkey_get_field                    :: proc(output: mp_t, key: pubkey_t, field_name: cstring) -> c.int ---
+    privkey_get_field                   :: proc(output: mp_t, key: privkey_t, field_name: cstring) -> c.int ---
+
+    privkey_load_rsa                    :: proc(key: ^privkey_t, p, q, e: mp_t) -> c.int ---
+    privkey_load_rsa_pkcs1              :: proc(key: ^privkey_t, bits: ^c.char, length: c.size_t) -> c.int ---
+    @(deprecated="Use botan.privkey_get_field")
+    privkey_rsa_get_p                   :: proc(p: mp_t, rsa_key: privkey_t) -> c.int ---
+    @(deprecated="Use botan.privkey_get_field")
+    privkey_rsa_get_q                   :: proc(q: mp_t, rsa_key: privkey_t) -> c.int ---
+    @(deprecated="Use botan.privkey_get_field")
+    privkey_rsa_get_d                   :: proc(d: mp_t, rsa_key: privkey_t) -> c.int ---
+    @(deprecated="Use botan.privkey_get_field")
+    privkey_rsa_get_n                   :: proc(n: mp_t, rsa_key: privkey_t) -> c.int ---
+    @(deprecated="Use botan.privkey_get_field")
+    privkey_rsa_get_e                   :: proc(e: mp_t, rsa_key: privkey_t) -> c.int ---
+    privkey_rsa_get_privkey             :: proc(rsa_key: privkey_t, out: ^c.char, out_len: ^c.size_t, flags: c.uint) -> c.int ---
+    pubkey_load_rsa                     :: proc(key: ^pubkey_t, n, e: mp_t) -> c.int ---
+    @(deprecated="Use botan.pubkey_get_field")
+    pubkey_rsa_get_e                    :: proc(e: mp_t, rsa_key: pubkey_t) -> c.int ---
+    @(deprecated="Use botan.pubkey_get_field")
+    pubkey_rsa_get_n                    :: proc(n: mp_t, rsa_key: pubkey_t) -> c.int ---
+
+    privkey_load_dsa                    :: proc(key: ^privkey_t, p, q, g, x: mp_t) -> c.int ---
+    pubkey_load_dsa                     :: proc(key: ^pubkey_t, p, q, g, y: mp_t) -> c.int ---
+    @(deprecated="Use botan.pubkey_get_field")
+    privkey_dsa_get_x                   :: proc(n: mp_t, key: privkey_t) -> c.int ---
+    @(deprecated="Use botan.pubkey_get_field")
+    pubkey_dsa_get_p                    :: proc(p: mp_t, key: pubkey_t) -> c.int ---
+    @(deprecated="Use botan.pubkey_get_field")
+    pubkey_dsa_get_q                    :: proc(q: mp_t, key: pubkey_t) -> c.int ---
+    @(deprecated="Use botan.pubkey_get_field")
+    pubkey_dsa_get_g                    :: proc(d: mp_t, key: pubkey_t) -> c.int ---
+    @(deprecated="Use botan.pubkey_get_field")
+    pubkey_dsa_get_y                    :: proc(y: mp_t, key: pubkey_t) -> c.int ---
+
+    privkey_load_dh                     :: proc(key: ^privkey_t, p, g, y: mp_t) -> c.int ---
+    pubkey_load_dh                      :: proc(key: ^pubkey_t, p, g, x: mp_t) -> c.int ---
+
+    privkey_load_elgamal                :: proc(key: ^privkey_t, p, g, y: mp_t) -> c.int ---
+    pubkey_load_elgamal                 :: proc(key: ^pubkey_t, p, g, x: mp_t) -> c.int ---
+
+    privkey_load_ed25519                :: proc(key: ^privkey_t, privkey: [32]c.char) -> c.int ---
+    pubkey_load_ed25519                 :: proc(key: ^pubkey_t, pubkey: [32]c.char) -> c.int ---
+    privkey_ed25519_get_privkey         :: proc(key: ^privkey_t, output: [64]c.char) -> c.int ---
+    pubkey_ed25519_get_pubkey           :: proc(key: ^pubkey_t, pubkey: [32]c.char) -> c.int ---
+
+    privkey_load_x25519                 :: proc(key: ^privkey_t, privkey: [32]c.char) -> c.int ---
+    pubkey_load_x25519                  :: proc(key: ^pubkey_t, pubkey: [32]c.char) -> c.int ---
+    privkey_x25519_get_privkey          :: proc(key: ^privkey_t, output: [32]c.char) -> c.int ---
+    pubkey_x25519_get_pubkey            :: proc(key: ^pubkey_t, pubkey: [32]c.char) -> c.int ---
+
+    privkey_load_ecdsa                  :: proc(key: ^privkey_t, scalar: mp_t, curve_name: cstring) -> c.int ---
+    pubkey_load_ecdsa                   :: proc(key: ^pubkey_t, public_x, public_y: mp_t, curve_name: cstring) -> c.int ---
+    pubkey_load_ecdh                    :: proc(key: ^pubkey_t, public_x, public_y: mp_t, curve_name: cstring) -> c.int ---
+    privkey_load_ecdh                   :: proc(key: ^privkey_t, scalar: mp_t, curve_name: cstring) -> c.int ---
+    pubkey_load_sm2                     :: proc(key: ^pubkey_t, public_x, public_y: mp_t, curve_name: cstring) -> c.int ---
+    privkey_load_sm2                    :: proc(key: ^privkey_t, scalar: mp_t, curve_name: cstring) -> c.int ---
+    @(deprecated="Use botan.pubkey_load_sm2")
+    pubkey_load_sm2_enc                 :: proc(key: ^pubkey_t, public_x, public_y: mp_t, curve_name: cstring) -> c.int ---
+    @(deprecated="Use botan.privkey_load_sm2")
+    privkey_load_sm2_enc                :: proc(key: ^privkey_t, scalar: mp_t, curve_name: cstring) -> c.int ---
+    pubkey_sm2_compute_za               :: proc(out: ^c.char, out_len: ^c.size_t, ident, hash_algo: cstring, key: pubkey_t) -> c.int ---
+
+    pk_op_encrypt_create                :: proc(op: ^pk_op_encrypt_t, key: pubkey_t, padding: cstring, flags: c.uint) -> c.int ---
+    pk_op_encrypt_destroy               :: proc(op: pk_op_encrypt_t) -> c.int ---
+    pk_op_encrypt_output_length         :: proc(op: pk_op_encrypt_t, ptext_len: c.size_t, ctext_len: ^c.size_t) -> c.int ---
+    pk_op_encrypt                       :: proc(op: pk_op_encrypt_t, rng: rng_t, out: ^c.char, out_len: ^c.size_t, plaintext: cstring, plaintext_len: c.size_t) -> c.int ---
+
+    pk_op_decrypt_create                :: proc(op: ^pk_op_decrypt_t, key: privkey_t, padding: cstring, flags: c.uint) -> c.int ---
+    pk_op_decrypt_destroy               :: proc(op: pk_op_decrypt_t) -> c.int ---
+    pk_op_decrypt_output_length         :: proc(op: pk_op_decrypt_t, ptext_len: c.size_t, ctext_len: ^c.size_t) -> c.int ---
+    pk_op_decrypt                       :: proc(op: pk_op_decrypt_t, rng: rng_t, out: ^c.char, out_len: ^c.size_t, ciphertext: cstring, ciphertext_len: c.size_t) -> c.int ---
+
+    pk_op_sign_create                   :: proc(op: ^pk_op_sign_t, key: privkey_t, hash_and_padding: cstring, flags: c.uint) -> c.int ---
+    pk_op_sign_destroy                  :: proc(op: pk_op_sign_t) -> c.int ---
+    pk_op_sign_output_length            :: proc(op: pk_op_sign_t, olen: ^c.size_t) -> c.int ---
+    pk_op_sign_update                   :: proc(op: pk_op_sign_t, input: ^c.char, input_len: c.size_t) -> c.int ---
+    pk_op_sign_finish                   :: proc(op: pk_op_sign_t, rng: rng_t, sig: ^c.char, sig_len: ^c.size_t) -> c.int ---
+
+    pk_op_verify_create                 :: proc(op: ^pk_op_verify_t, hash_and_padding: cstring, flags: c.uint) -> c.int ---
+    pk_op_verify_destroy                :: proc(op: pk_op_verify_t) -> c.int ---
+    pk_op_verify_update                 :: proc(op: pk_op_verify_t, input: ^c.char, input_len: c.size_t) -> c.int ---
+    pk_op_verify_finish                 :: proc(op: pk_op_verify_t, sig: ^c.char, sig_len: c.size_t) -> c.int ---
+
+    pk_op_key_agreement_create          :: proc(op: ^pk_op_ka_t, kdf: cstring, flags: c.uint) -> c.int ---
+    pk_op_key_agreement_destroy         :: proc(op: pk_op_ka_t) -> c.int ---
+    pk_op_key_agreement_export_public   :: proc(key: privkey_t, out: ^c.char, out_len: ^c.size_t) -> c.int ---
+    pk_op_key_agreement_size            :: proc(op: pk_op_ka_t, out_len: ^c.size_t) -> c.int ---
+    pk_op_key_agreement                 :: proc(op: pk_op_ka_t, out: ^c.char, out_len: ^c.size_t, other_key: ^c.char, other_key_len: c.size_t, salt: ^c.char,
+                                                salt_len: c.size_t) -> c.int ---
+
+    pkcs_hash_id                        :: proc(hash_name: cstring, pkcs_id: ^c.char, pkcs_id_len: ^c.size_t) -> c.int ---
+
+    @(deprecated="Poorly specified, avoid in new code")
+    mceies_encrypt                      :: proc(mce_key: pubkey_t, rng: rng_t, aead: cstring, pt: ^c.char, pt_len: c.size_t, ad: ^c.char, ad_len: c.size_t,
+                                                ct: ^c.char, ct_len: ^c.size_t) -> c.int ---
+    @(deprecated="Poorly specified, avoid in new code")
+    mceies_decrypt                      :: proc(mce_key: privkey_t, aead: cstring, ct: ^c.char, ct_len: c.size_t, ad: ^c.char, ad_len: c.size_t, pt: ^c.char,
+                                                pt_len: ^c.size_t) -> c.int ---
+
+    x509_cert_load                      :: proc(cert_obj: ^x509_cert_t, cert: ^c.char, cert_len: c.size_t) -> c.int ---
+    x509_cert_load_file                 :: proc(cert_obj: ^x509_cert_t, filename: cstring) -> c.int ---
+    x509_cert_destroy                   :: proc(cert: x509_cert_t) -> c.int ---
+    x509_cert_dup                       :: proc(new_cert: ^x509_cert_t, cert: x509_cert_t) -> c.int ---
+    x509_cert_get_time_starts           :: proc(cert: x509_cert_t, out: ^c.char, out_len: ^c.size_t) -> c.int ---
+    x509_cert_get_time_expires          :: proc(cert: x509_cert_t, out: ^c.char, out_len: ^c.size_t) -> c.int ---
+    x509_cert_not_before                :: proc(cert: x509_cert_t, time_since_epoch: ^c.ulonglong) -> c.int ---
+    x509_cert_not_after                 :: proc(cert: x509_cert_t, time_since_epoch: ^c.ulonglong) -> c.int ---
+    x509_cert_get_fingerprint           :: proc(cert: x509_cert_t, hash: cstring, out: ^c.char, out_len: ^c.size_t) -> c.int ---
+    x509_cert_get_serial_number         :: proc(cert: x509_cert_t, out: ^c.char, out_len: ^c.size_t) -> c.int ---
+    x509_cert_get_authority_key_id      :: proc(cert: x509_cert_t, out: ^c.char, out_len: ^c.size_t) -> c.int ---
+    x509_cert_get_subject_key_id        :: proc(cert: x509_cert_t, out: ^c.char, out_len: ^c.size_t) -> c.int ---
+    x509_cert_get_public_key_bits       :: proc(cert: x509_cert_t, out: ^c.char, out_len: ^c.size_t) -> c.int ---
+    x509_cert_get_public_key            :: proc(cert: x509_cert_t, key: ^pubkey_t) -> c.int ---
+    x509_cert_get_issuer_dn             :: proc(cert: x509_cert_t, key: ^c.char, index: c.size_t, out: ^c.char, out_len: ^c.size_t) -> c.int ---
+    x509_cert_get_subject_dn            :: proc(cert: x509_cert_t, key: ^c.char, index: c.size_t, out: ^c.char, out_len: ^c.size_t) -> c.int ---
+    x509_cert_to_string                 :: proc(cert: x509_cert_t, out: ^c.char, out_len: ^c.size_t) -> c.int ---
+    x509_cert_allowed_usage             :: proc(cert: x509_cert_t, key_usage: c.uint) -> c.int ---
+    x509_cert_hostname_match            :: proc(cert: x509_cert_t, hostname: cstring) -> c.int ---
+    x509_cert_verify                    :: proc(validation_result: ^c.int, cert: x509_cert_t, intermediates: ^x509_cert_t, intermediates_len: c.size_t, trusted: ^x509_cert_t,
+                                                trusted_len: c.size_t, trusted_path: cstring, required_strength: c.size_t, hostname: cstring, reference_time: c.ulonglong) -> c.int ---
+    x509_cert_validation_status         :: proc(code: c.int) -> cstring ---
+    x509_crl_load_file                  :: proc(crl_obj: ^x509_crl_t, crl_path: cstring) -> c.int ---
+    x509_crl_load                       :: proc(crl_obj: ^x509_crl_t, crl_bits: ^c.char, crl_bits_len: c.size_t) -> c.int ---
+    x509_crl_destroy                    :: proc(crl: x509_crl_t) -> c.int ---
+    x509_is_revoked                     :: proc(crl: x509_crl_t, cert: x509_cert_t) -> c.int ---
+    x509_cert_verify_with_crl           :: proc(validation_result: ^c.int, cert: x509_cert_t, intermediates: ^x509_cert_t, intermediates_len: c.size_t, trusted: ^x509_cert_t,
+                                                trusted_len: c.size_t, crls: ^x509_crl_t, crls_len: c.size_t, trusted_path: cstring, required_strength: c.size_t, 
+                                                hostname: cstring, reference_time: c.ulonglong) -> c.int ---
+
+    key_wrap3394                        :: proc(key: ^c.char, key_len: c.size_t, kek: ^c.char, kek_len: c.size_t, wrapped_key: ^c.char, wrapped_key_len: ^c.size_t) -> c.int ---
+    key_unwrap3394                      :: proc(wrapped_key: ^c.char, wrapped_key_len: c.size_t, kek: ^c.char, kek_len: c.size_t, key: ^c.char, key_len: ^c.size_t) -> c.int ---
+
+    hotp_init                           :: proc(hotp: ^hotp_t, key: ^c.char, key_len: c.size_t, hash_algo: cstring, digits: c.size_t) -> c.int ---
+    hotp_destroy                        :: proc(hotp: hotp_t) -> c.int ---
+    hotp_generate                       :: proc(hotp: hotp_t, hotp_code: ^c.uint, hotp_counter: c.ulonglong) -> c.int ---
+    hotp_check                          :: proc(hotp: hotp_t, next_hotp_counter: ^c.ulonglong, hotp_code: c.uint, hotp_counter: c.ulonglong, resync_range: c.size_t) -> c.int ---
+
+    totp_init                           :: proc(totp: ^totp_t, key: ^c.char, key_len: c.size_t, hash_algo: cstring, digits, time_step: c.size_t) -> c.int ---
+    totp_destroy                        :: proc(totp: totp_t) -> c.int ---
+    totp_generate                       :: proc(totp: totp_t, totp_code: ^c.uint, timestamp: c.ulonglong) -> c.int ---
+    totp_check                          :: proc(totp: totp_t, totp_code: ^c.uint, timestamp: c.ulonglong, acceptable_clock_drift: c.size_t) -> c.int ---
+
+    fpe_fe1_init                        :: proc(fpe: ^fpe_t, n: mp_t, key: ^c.char, key_len, rounds: c.size_t, flags: c.uint) -> c.int ---
+    fpe_destroy                         :: proc(fpe: fpe_t) -> c.int ---
+    fpe_encrypt                         :: proc(fpe: fpe_t, x: mp_t, tweak: ^c.char, tweak_len: c.size_t) -> c.int ---
+    fpe_decrypt                         :: proc(fpe: fpe_t, x: mp_t, tweak: ^c.char, tweak_len: c.size_t) -> c.int ---
+}

core/crypto/botan/hash.odin

@@ -0,0 +1,498 @@
+package botan
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog: Initial creation and testing of the bindings.
+
+    Implementation of the context for the Botan side.
+*/
+
+import "core:os"
+import "core:io"
+import "core:fmt"
+import "core:strings"
+
+import "../_ctx"
+
+hash_bytes_16 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [16]byte {
+    hash: [16]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._16, 16), 0)
+    hash_update(c, len(data) == 0 ? nil : &data[0], uint(len(data)))
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash
+}
+
+hash_bytes_20 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [20]byte {
+    hash: [20]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._20, 20), 0)
+    hash_update(c, len(data) == 0 ? nil : &data[0], uint(len(data)))
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash
+}
+
+hash_bytes_24 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [24]byte {
+    hash: [24]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._24, 24), 0)
+    hash_update(c, len(data) == 0 ? nil : &data[0], uint(len(data)))
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash
+}
+
+hash_bytes_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [28]byte {
+    hash: [28]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._28, 28), 0)
+    hash_update(c, len(data) == 0 ? nil : &data[0], uint(len(data)))
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash
+}
+
+hash_bytes_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [32]byte {
+    hash: [32]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._32, 32), 0)
+    hash_update(c, len(data) == 0 ? nil : &data[0], uint(len(data)))
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash
+}
+
+hash_bytes_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [48]byte {
+    hash: [48]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._48, 48), 0)
+    hash_update(c, len(data) == 0 ? nil : &data[0], uint(len(data)))
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash
+}
+
+hash_bytes_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [64]byte {
+    hash: [64]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._64, 64), 0)
+    hash_update(c, len(data) == 0 ? nil : &data[0], uint(len(data)))
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash
+}
+
+hash_bytes_128 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [128]byte {
+    hash: [128]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._128, 128), 0)
+    hash_update(c, len(data) == 0 ? nil : &data[0], uint(len(data)))
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash
+}
+
+hash_bytes_slice :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte, bit_size: int, allocator := context.allocator) -> []byte {
+    hash := make([]byte, bit_size, allocator)
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, nil, bit_size), 0)
+    hash_update(c, len(data) == 0 ? nil : &data[0], uint(len(data)))
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash[:]
+}
+
+hash_file_16 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([16]byte, bool) {
+    if !load_at_once {
+        return hash_stream_16(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_16(ctx, buf[:]), ok
+        }
+    }
+    return [16]byte{}, false
+}
+
+hash_file_20 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([20]byte, bool) {
+    if !load_at_once {
+        return hash_stream_20(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_20(ctx, buf[:]), ok
+        }
+    }
+    return [20]byte{}, false
+}
+
+hash_file_24 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([24]byte, bool) {
+    if !load_at_once {
+        return hash_stream_24(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_24(ctx, buf[:]), ok
+        }
+    }
+    return [24]byte{}, false
+}
+
+hash_file_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([28]byte, bool) {
+    if !load_at_once {
+        return hash_stream_28(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_28(ctx, buf[:]), ok
+        }
+    }
+    return [28]byte{}, false
+}
+
+hash_file_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    if !load_at_once {
+        return hash_stream_32(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_32(ctx, buf[:]), ok
+        }
+    }
+    return [32]byte{}, false
+}
+
+hash_file_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([48]byte, bool) {
+    if !load_at_once {
+        return hash_stream_48(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_48(ctx, buf[:]), ok
+        }
+    }
+    return [48]byte{}, false
+}
+
+hash_file_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    if !load_at_once {
+        return hash_stream_64(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_64(ctx, buf[:]), ok
+        }
+    }
+    return [64]byte{}, false
+}
+
+hash_file_128 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([128]byte, bool) {
+    if !load_at_once {
+        return hash_stream_128(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_128(ctx, buf[:]), ok
+        }
+    }
+    return [128]byte{}, false
+}
+
+hash_file_slice :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, bit_size: int, load_at_once := false, allocator := context.allocator) -> ([]byte, bool) {
+    if !load_at_once {
+        return hash_stream_slice(ctx, os.stream_from_handle(hd), bit_size, allocator)
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_slice(ctx, buf[:], bit_size, allocator), ok
+        }
+    }
+    return nil, false
+}
+
+hash_stream_16 :: #force_inline proc(ctx: ^_ctx.Hash_Context, s: io.Stream) -> ([16]byte, bool) {
+    hash: [16]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._16, 16), 0)
+    buf := make([]byte, 512)
+    defer delete(buf)
+    i := 1
+    for i > 0 {
+        i, _ = s->impl_read(buf)
+        if i > 0 {
+            hash_update(c, len(buf) == 0 ? nil : &buf[0], uint(i))
+        } 
+    }
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash, true
+}
+
+hash_stream_20 :: #force_inline proc(ctx: ^_ctx.Hash_Context, s: io.Stream) -> ([20]byte, bool) {
+    hash: [20]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._20, 20), 0)
+    buf := make([]byte, 512)
+    defer delete(buf)
+    i := 1
+    for i > 0 {
+        i, _ = s->impl_read(buf)
+        if i > 0 {
+            hash_update(c, len(buf) == 0 ? nil : &buf[0], uint(i))
+        } 
+    }
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash, true
+}
+
+hash_stream_24 :: #force_inline proc(ctx: ^_ctx.Hash_Context, s: io.Stream) -> ([24]byte, bool) {
+    hash: [24]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._24, 24), 0)
+    buf := make([]byte, 512)
+    defer delete(buf)
+    i := 1
+    for i > 0 {
+        i, _ = s->impl_read(buf)
+        if i > 0 {
+            hash_update(c, len(buf) == 0 ? nil : &buf[0], uint(i))
+        } 
+    }
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash, true
+}
+
+hash_stream_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, s: io.Stream) -> ([28]byte, bool) {
+    hash: [28]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._28, 28), 0)
+    buf := make([]byte, 512)
+    defer delete(buf)
+    i := 1
+    for i > 0 {
+        i, _ = s->impl_read(buf)
+        if i > 0 {
+            hash_update(c, len(buf) == 0 ? nil : &buf[0], uint(i))
+        } 
+    }
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash, true
+}
+
+hash_stream_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, s: io.Stream) -> ([32]byte, bool) {
+    hash: [32]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._32, 32), 0)
+    buf := make([]byte, 512)
+    defer delete(buf)
+    i := 1
+    for i > 0 {
+        i, _ = s->impl_read(buf)
+        if i > 0 {
+            hash_update(c, len(buf) == 0 ? nil : &buf[0], uint(i))
+        } 
+    }
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash, true
+}
+
+hash_stream_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, s: io.Stream) -> ([48]byte, bool) {
+    hash: [48]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._48, 48), 0)
+    buf := make([]byte, 512)
+    defer delete(buf)
+    i := 1
+    for i > 0 {
+        i, _ = s->impl_read(buf)
+        if i > 0 {
+            hash_update(c, len(buf) == 0 ? nil : &buf[0], uint(i))
+        } 
+    }
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash, true
+}
+
+hash_stream_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, s: io.Stream) -> ([64]byte, bool) {
+    hash: [64]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._64, 64), 0)
+    buf := make([]byte, 512)
+    defer delete(buf)
+    i := 1
+    for i > 0 {
+        i, _ = s->impl_read(buf)
+        if i > 0 {
+            hash_update(c, len(buf) == 0 ? nil : &buf[0], uint(i))
+        } 
+    }
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash, true
+}
+
+hash_stream_128 :: #force_inline proc(ctx: ^_ctx.Hash_Context, s: io.Stream) -> ([128]byte, bool) {
+    hash: [128]byte
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, _ctx.Hash_Size._128, 128), 0)
+    buf := make([]byte, 512)
+    defer delete(buf)
+    i := 1
+    for i > 0 {
+        i, _ = s->impl_read(buf)
+        if i > 0 {
+            hash_update(c, len(buf) == 0 ? nil : &buf[0], uint(i))
+        } 
+    }
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash, true
+}
+
+hash_stream_slice :: #force_inline proc(ctx: ^_ctx.Hash_Context, s: io.Stream, bit_size: int, allocator := context.allocator) -> ([]byte, bool) {
+    hash := make([]byte, bit_size, allocator)
+    c: hash_t
+    hash_init(&c, _check_ctx(ctx, nil, bit_size), 0)
+    buf := make([]byte, 512)
+    defer delete(buf)
+    i := 1
+    for i > 0 {
+        i, _ = s->impl_read(buf)
+        if i > 0 {
+            hash_update(c, len(buf) == 0 ? nil : &buf[0], uint(i))
+        } 
+    }
+    hash_final(c, &hash[0])
+    hash_destroy(c)
+    return hash[:], true
+}
+
+init :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    c: hash_t
+    hash_init(&c, ctx.botan_hash_algo, 0)
+    ctx.external_ctx = c
+}
+
+update :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.external_ctx.(hash_t); ok {
+        hash_update(c, len(data) == 0 ? nil : &data[0], uint(len(data)))
+    }
+}
+
+final :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.external_ctx.(hash_t); ok {
+        hash_final(c, &hash[0])
+        hash_destroy(c)
+    }
+}
+
+assign_hash_vtable :: proc(ctx: ^_ctx.Hash_Context, hash_algo: cstring) {
+    ctx.init            = init
+    ctx.update          = update
+    ctx.final           = final
+    ctx.botan_hash_algo = hash_algo
+
+    switch hash_algo {
+        case HASH_MD4, HASH_MD5:
+            ctx.hash_bytes_16  = hash_bytes_16
+            ctx.hash_file_16   = hash_file_16
+            ctx.hash_stream_16 = hash_stream_16
+
+        case HASH_SHA1, HASH_RIPEMD_160:
+            ctx.hash_bytes_20  = hash_bytes_20
+            ctx.hash_file_20   = hash_file_20
+            ctx.hash_stream_20 = hash_stream_20
+
+        case HASH_SHA2, HASH_SHA3:
+            ctx.hash_bytes_28  = hash_bytes_28
+            ctx.hash_file_28   = hash_file_28
+            ctx.hash_stream_28 = hash_stream_28
+            ctx.hash_bytes_32  = hash_bytes_32
+            ctx.hash_file_32   = hash_file_32
+            ctx.hash_stream_32 = hash_stream_32
+            ctx.hash_bytes_48  = hash_bytes_48
+            ctx.hash_file_48   = hash_file_48
+            ctx.hash_stream_48 = hash_stream_48
+            ctx.hash_bytes_64  = hash_bytes_64
+            ctx.hash_file_64   = hash_file_64
+            ctx.hash_stream_64 = hash_stream_64
+
+        case HASH_GOST, HASH_WHIRLPOOL, HASH_SM3:
+            ctx.hash_bytes_32  = hash_bytes_32
+            ctx.hash_file_32   = hash_file_32
+            ctx.hash_stream_32 = hash_stream_32
+
+        case HASH_STREEBOG:
+            ctx.hash_bytes_32  = hash_bytes_32
+            ctx.hash_file_32   = hash_file_32
+            ctx.hash_stream_32 = hash_stream_32
+            ctx.hash_bytes_64  = hash_bytes_64
+            ctx.hash_file_64   = hash_file_64
+            ctx.hash_stream_64 = hash_stream_64
+
+        case HASH_BLAKE2B:
+            ctx.hash_bytes_64  = hash_bytes_64
+            ctx.hash_file_64   = hash_file_64
+            ctx.hash_stream_64 = hash_stream_64
+
+        case HASH_TIGER:
+            ctx.hash_bytes_16  = hash_bytes_16
+            ctx.hash_file_16   = hash_file_16
+            ctx.hash_stream_16 = hash_stream_16
+            ctx.hash_bytes_20  = hash_bytes_20
+            ctx.hash_file_20   = hash_file_20
+            ctx.hash_stream_20 = hash_stream_20
+            ctx.hash_bytes_24  = hash_bytes_24
+            ctx.hash_file_24   = hash_file_24
+            ctx.hash_stream_24 = hash_stream_24
+
+        case HASH_SKEIN_512:
+            ctx.hash_bytes_slice  = hash_bytes_slice
+            ctx.hash_file_slice   = hash_file_slice
+            ctx.hash_stream_slice = hash_stream_slice
+    }
+}
+
+_check_ctx :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash_size: _ctx.Hash_Size, hash_size_val: int) -> cstring {
+    ctx.hash_size     = hash_size
+    ctx.hash_size_val = hash_size_val
+    switch ctx.botan_hash_algo {
+        case HASH_SHA2:
+            #partial switch hash_size {
+                case ._28: return HASH_SHA_224
+                case ._32: return HASH_SHA_256
+                case ._48: return HASH_SHA_384
+                case ._64: return HASH_SHA_512
+            }
+        case HASH_SHA3:
+            #partial switch hash_size {
+                case ._28: return HASH_SHA3_224
+                case ._32: return HASH_SHA3_256
+                case ._48: return HASH_SHA3_384
+                case ._64: return HASH_SHA3_512
+            }
+        case HASH_KECCAK:
+            #partial switch hash_size {
+                case ._28: return HASH_KECCAK_224
+                case ._32: return HASH_KECCAK_256
+                case ._48: return HASH_KECCAK_384
+                case ._64: return HASH_KECCAK_512
+            }
+        case HASH_STREEBOG:
+            #partial switch hash_size {
+                case ._32: return HASH_STREEBOG_256
+                case ._64: return HASH_STREEBOG_512
+            }
+        case HASH_TIGER:
+            #partial switch hash_size {
+                case ._16: return HASH_TIGER_128
+                case ._20: return HASH_TIGER_160
+                case ._24: return HASH_TIGER_192
+            }
+        case HASH_SKEIN_512:
+            return strings.unsafe_string_to_cstring(fmt.tprintf("Skein-512(%d)", hash_size_val * 8))
+        case: return ctx.botan_hash_algo
+    }
+    return nil
+}

core/crypto/gost/gost.odin

@@ -0,0 +1,457 @@
+package gost
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Implementation of the GOST hashing algorithm, as defined in RFC 5831 <https://datatracker.ietf.org/doc/html/rfc5831>
+*/
+
+import "core:mem"
+import "core:os"
+import "core:io"
+
+import "../botan"
+import "../_ctx"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    _assign_hash_vtable(ctx)
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_32  = hash_bytes_odin
+    ctx.hash_file_32   = hash_file_odin
+    ctx.hash_stream_32 = hash_stream_odin
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan does nothing, since MD2 is not available in Botan
+use_botan :: #force_inline proc() {
+    botan.assign_hash_vtable(_hash_impl, botan.HASH_GOST)
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+/*
+    High level API
+*/
+
+// hash_string will hash the given input and return the
+// computed hash
+hash_string :: proc(data: string) -> [32]byte {
+    return hash_bytes(transmute([]byte)(data))
+}
+
+// hash_bytes will hash the given input and return the
+// computed hash
+hash_bytes :: proc(data: []byte) -> [32]byte {
+    _create_gost_ctx()
+    return _hash_impl->hash_bytes_32(data)
+}
+
+// hash_stream will read the stream in chunks and compute a
+// hash from its contents
+hash_stream :: proc(s: io.Stream) -> ([32]byte, bool) {
+    _create_gost_ctx()
+    return _hash_impl->hash_stream_32(s)
+}
+
+// hash_file will read the file provided by the given handle
+// and compute a hash
+hash_file :: proc(hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    _create_gost_ctx()
+    return _hash_impl->hash_file_32(hd, load_at_once)
+}
+
+hash :: proc {
+    hash_stream,
+    hash_file,
+    hash_bytes,
+    hash_string,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [32]byte {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(Gost_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([32]byte, bool) {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(Gost_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin(ctx, buf[:]), ok
+        }
+    }
+    return [32]byte{}, false
+}
+
+@(private)
+_create_gost_ctx :: #force_inline proc() {
+    ctx: Gost_Context
+    _hash_impl.internal_ctx = ctx
+    _hash_impl.hash_size    = ._32
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    _create_gost_ctx()
+    if c, ok := ctx.internal_ctx.(Gost_Context); ok {
+        init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(Gost_Context); ok {
+        update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(Gost_Context); ok {
+        final_odin(&c, hash)
+    }
+}
+
+/*
+    GOST implementation
+*/
+
+Gost_Context :: struct {
+    sum:           [8]u32,
+    hash:          [8]u32,
+    len:           [8]u32,
+    partial:       [32]byte,
+    partial_bytes: byte,
+}
+
+SBOX_1 : [256]u32
+SBOX_2 : [256]u32
+SBOX_3 : [256]u32
+SBOX_4 : [256]u32
+
+GOST_ENCRYPT_ROUND :: #force_inline proc "contextless"(l, r, t, k1, k2: u32) -> (u32, u32, u32) {
+    l, r, t := l, r, t
+    t  = (k1) + r
+    l ~= SBOX_1[t & 0xff] ~ SBOX_2[(t >> 8) & 0xff] ~ SBOX_3[(t >> 16) & 0xff] ~ SBOX_4[t >> 24]
+    t  = (k2) + l
+    r ~= SBOX_1[t & 0xff] ~ SBOX_2[(t >> 8) & 0xff] ~ SBOX_3[(t >> 16) & 0xff] ~ SBOX_4[t >> 24]
+    return l, r, t
+}
+
+GOST_ENCRYPT :: #force_inline proc "contextless"(a, b, c: u32, key: []u32) -> (l, r, t: u32) {
+    l, r, t = GOST_ENCRYPT_ROUND(a, b, c, key[0], key[1])
+    l, r, t = GOST_ENCRYPT_ROUND(l, r, t, key[2], key[3])
+    l, r, t = GOST_ENCRYPT_ROUND(l, r, t, key[4], key[5])
+    l, r, t = GOST_ENCRYPT_ROUND(l, r, t, key[6], key[7])
+    l, r, t = GOST_ENCRYPT_ROUND(l, r, t, key[0], key[1])
+    l, r, t = GOST_ENCRYPT_ROUND(l, r, t, key[2], key[3])
+    l, r, t = GOST_ENCRYPT_ROUND(l, r, t, key[4], key[5])
+    l, r, t = GOST_ENCRYPT_ROUND(l, r, t, key[6], key[7])
+    l, r, t = GOST_ENCRYPT_ROUND(l, r, t, key[0], key[1])
+    l, r, t = GOST_ENCRYPT_ROUND(l, r, t, key[2], key[3])
+    l, r, t = GOST_ENCRYPT_ROUND(l, r, t, key[4], key[5])
+    l, r, t = GOST_ENCRYPT_ROUND(l, r, t, key[6], key[7])
+    l, r, t = GOST_ENCRYPT_ROUND(l, r, t, key[7], key[6])
+    l, r, t = GOST_ENCRYPT_ROUND(l, r, t, key[5], key[4])
+    l, r, t = GOST_ENCRYPT_ROUND(l, r, t, key[3], key[2])
+    l, r, t = GOST_ENCRYPT_ROUND(l, r, t, key[1], key[0])
+    t = r
+    r = l
+    l = t
+    return
+}
+
+gost_bytes :: proc(ctx: ^Gost_Context, buf: []byte, bits: u32) {
+    a, c: u32
+    m: [8]u32
+
+    for i, j := 0, 0; i < 8; i += 1 {
+        a = u32(buf[j]) | u32(buf[j + 1]) << 8 | u32(buf[j + 2]) << 16 | u32(buf[j + 3]) << 24
+        j += 4
+        m[i] = a
+        c = a + c + ctx.sum[i]
+        ctx.sum[i] = c
+        c = c < a ? 1 : 0
+    }
+
+    gost_compress(ctx.hash[:], m[:])
+    ctx.len[0] += bits
+    if ctx.len[0] < bits {
+        ctx.len[1] += 1
+    }
+}
+
+gost_compress :: proc(h, m: []u32) {
+    key, u, v, w, s: [8]u32
+
+    copy(u[:], h)
+    copy(v[:], m)
+
+    for i := 0; i < 8; i += 2 {
+        w[0] = u[0] ~ v[0]
+        w[1] = u[1] ~ v[1]
+        w[2] = u[2] ~ v[2]
+        w[3] = u[3] ~ v[3]
+        w[4] = u[4] ~ v[4]
+        w[5] = u[5] ~ v[5]
+        w[6] = u[6] ~ v[6]
+        w[7] = u[7] ~ v[7]
+
+        key[0] = (w[0] & 0x000000ff)       | (w[2] & 0x000000ff) <<  8 | (w[4] & 0x000000ff) << 16 | (w[6] & 0x000000ff) << 24
+        key[1] = (w[0] & 0x0000ff00) >>  8 | (w[2] & 0x0000ff00)       | (w[4] & 0x0000ff00) <<  8 | (w[6] & 0x0000ff00) << 16
+        key[2] = (w[0] & 0x00ff0000) >> 16 | (w[2] & 0x00ff0000) >>  8 | (w[4] & 0x00ff0000)       | (w[6] & 0x00ff0000) <<  8
+        key[3] = (w[0] & 0xff000000) >> 24 | (w[2] & 0xff000000) >> 16 | (w[4] & 0xff000000) >>  8 | (w[6] & 0xff000000)
+        key[4] = (w[1] & 0x000000ff)       | (w[3] & 0x000000ff) <<  8 | (w[5] & 0x000000ff) << 16 | (w[7] & 0x000000ff) << 24
+        key[5] = (w[1] & 0x0000ff00) >>  8 | (w[3] & 0x0000ff00)       | (w[5] & 0x0000ff00) <<  8 | (w[7] & 0x0000ff00) << 16
+        key[6] = (w[1] & 0x00ff0000) >> 16 | (w[3] & 0x00ff0000) >>  8 | (w[5] & 0x00ff0000)       | (w[7] & 0x00ff0000) <<  8
+        key[7] = (w[1] & 0xff000000) >> 24 | (w[3] & 0xff000000) >> 16 | (w[5] & 0xff000000) >>  8 | (w[7] & 0xff000000)
+
+        r := h[i]
+        l := h[i + 1]
+        t: u32
+        l, r, t = GOST_ENCRYPT(l, r, 0, key[:])
+
+        s[i] = r
+        s[i + 1] = l
+
+        if i == 6 {
+            break
+        }
+
+        l    = u[0] ~ u[2]
+        r    = u[1] ~ u[3]
+        u[0] = u[2]
+        u[1] = u[3]
+        u[2] = u[4]
+        u[3] = u[5]
+        u[4] = u[6]
+        u[5] = u[7]
+        u[6] = l
+        u[7] = r
+
+        if i == 2 {
+            u[0] ~= 0xff00ff00
+            u[1] ~= 0xff00ff00
+            u[2] ~= 0x00ff00ff
+            u[3] ~= 0x00ff00ff
+            u[4] ~= 0x00ffff00
+            u[5] ~= 0xff0000ff
+            u[6] ~= 0x000000ff
+            u[7] ~= 0xff00ffff
+        }
+
+        l    = v[0]
+        r    = v[2]
+        v[0] = v[4]
+        v[2] = v[6]
+        v[4] = l ~ r
+        v[6] = v[0] ~ r
+        l    = v[1]
+        r    = v[3]
+        v[1] = v[5]
+        v[3] = v[7]
+        v[5] = l ~ r
+        v[7] = v[1] ~ r
+    }
+
+    u[0] = m[0] ~ s[6]
+    u[1] = m[1] ~ s[7]
+    u[2] = m[2] ~ (s[0] << 16) ~ (s[0] >> 16) ~ (s[0] & 0xffff) ~ 
+        (s[1] & 0xffff) ~ (s[1] >> 16) ~ (s[2] << 16) ~ s[6] ~ (s[6] << 16) ~
+        (s[7] & 0xffff0000) ~ (s[7] >> 16)
+    u[3] = m[3] ~ (s[0] & 0xffff) ~ (s[0] << 16) ~ (s[1] & 0xffff) ~
+        (s[1] << 16) ~ (s[1] >> 16) ~ (s[2] << 16) ~ (s[2] >> 16) ~
+        (s[3] << 16) ~ s[6] ~ (s[6] << 16) ~ (s[6] >> 16) ~ (s[7] & 0xffff) ~
+        (s[7] << 16) ~ (s[7] >> 16)
+    u[4] = m[4] ~
+        (s[0] & 0xffff0000) ~ (s[0] << 16) ~ (s[0] >> 16) ~
+        (s[1] & 0xffff0000) ~ (s[1] >> 16) ~ (s[2] << 16) ~ (s[2] >> 16) ~
+        (s[3] << 16) ~ (s[3] >> 16) ~ (s[4] << 16) ~ (s[6] << 16) ~
+        (s[6] >> 16) ~(s[7] & 0xffff) ~ (s[7] << 16) ~ (s[7] >> 16)
+    u[5] = m[5] ~ (s[0] << 16) ~ (s[0] >> 16) ~ (s[0] & 0xffff0000) ~
+        (s[1] & 0xffff) ~ s[2] ~ (s[2] >> 16) ~ (s[3] << 16) ~ (s[3] >> 16) ~
+        (s[4] << 16) ~ (s[4] >> 16) ~ (s[5] << 16) ~  (s[6] << 16) ~
+        (s[6] >> 16) ~ (s[7] & 0xffff0000) ~ (s[7] << 16) ~ (s[7] >> 16)
+    u[6] = m[6] ~ s[0] ~ (s[1] >> 16) ~ (s[2] << 16) ~ s[3] ~ (s[3] >> 16) ~
+        (s[4] << 16) ~ (s[4] >> 16) ~ (s[5] << 16) ~ (s[5] >> 16) ~ s[6] ~
+        (s[6] << 16) ~ (s[6] >> 16) ~ (s[7] << 16)
+    u[7] = m[7] ~ (s[0] & 0xffff0000) ~ (s[0] << 16) ~ (s[1] & 0xffff) ~
+        (s[1] << 16) ~ (s[2] >> 16) ~ (s[3] << 16) ~ s[4] ~ (s[4] >> 16) ~
+        (s[5] << 16) ~ (s[5] >> 16) ~ (s[6] >> 16) ~ (s[7] & 0xffff) ~
+        (s[7] << 16) ~ (s[7] >> 16)
+
+    v[0] = h[0] ~ (u[1] << 16) ~ (u[0] >> 16)
+    v[1] = h[1] ~ (u[2] << 16) ~ (u[1] >> 16)
+    v[2] = h[2] ~ (u[3] << 16) ~ (u[2] >> 16)
+    v[3] = h[3] ~ (u[4] << 16) ~ (u[3] >> 16)
+    v[4] = h[4] ~ (u[5] << 16) ~ (u[4] >> 16)
+    v[5] = h[5] ~ (u[6] << 16) ~ (u[5] >> 16)
+    v[6] = h[6] ~ (u[7] << 16) ~ (u[6] >> 16)
+    v[7] = h[7] ~ (u[0] & 0xffff0000) ~ (u[0] << 16) ~ (u[7] >> 16) ~ (u[1] & 0xffff0000) ~ (u[1] << 16) ~ (u[6] << 16) ~ (u[7] & 0xffff0000)
+
+    h[0] = (v[0] & 0xffff0000) ~ (v[0] << 16) ~ (v[0] >> 16) ~ (v[1] >> 16) ~
+        (v[1] & 0xffff0000) ~ (v[2] << 16) ~ (v[3] >> 16) ~ (v[4] << 16) ~
+        (v[5] >> 16) ~ v[5] ~ (v[6] >> 16) ~ (v[7] << 16) ~ (v[7] >> 16) ~
+        (v[7] & 0xffff)
+    h[1] = (v[0] << 16) ~ (v[0] >> 16) ~ (v[0] & 0xffff0000) ~ (v[1] & 0xffff) ~
+        v[2] ~ (v[2] >> 16) ~ (v[3] << 16) ~ (v[4] >> 16) ~ (v[5] << 16) ~
+        (v[6] << 16) ~ v[6] ~ (v[7] & 0xffff0000) ~ (v[7] >> 16)
+    h[2] = (v[0] & 0xffff) ~ (v[0] << 16) ~ (v[1] << 16) ~ (v[1] >> 16) ~
+        (v[1] & 0xffff0000) ~ (v[2] << 16) ~ (v[3] >> 16) ~ v[3] ~ (v[4] << 16) ~
+        (v[5] >> 16) ~ v[6] ~ (v[6] >> 16) ~ (v[7] & 0xffff) ~ (v[7] << 16) ~
+        (v[7] >> 16)
+    h[3] = (v[0] << 16) ~ (v[0] >> 16) ~ (v[0] & 0xffff0000) ~
+        (v[1] & 0xffff0000) ~ (v[1] >> 16) ~ (v[2] << 16) ~ (v[2] >> 16) ~ v[2] ~
+        (v[3] << 16) ~ (v[4] >> 16) ~ v[4] ~ (v[5] << 16) ~ (v[6] << 16) ~
+        (v[7] & 0xffff) ~ (v[7] >> 16)
+    h[4] = (v[0] >> 16) ~ (v[1] << 16) ~ v[1] ~ (v[2] >> 16) ~ v[2] ~
+        (v[3] << 16) ~ (v[3] >> 16) ~ v[3] ~ (v[4] << 16) ~ (v[5] >> 16) ~
+        v[5] ~ (v[6] << 16) ~ (v[6] >> 16) ~ (v[7] << 16)
+    h[5] = (v[0] << 16) ~ (v[0] & 0xffff0000) ~ (v[1] << 16) ~ (v[1] >> 16) ~
+        (v[1] & 0xffff0000) ~ (v[2] << 16) ~ v[2] ~ (v[3] >> 16) ~ v[3] ~
+        (v[4] << 16) ~ (v[4] >> 16) ~ v[4] ~ (v[5] << 16) ~ (v[6] << 16) ~
+        (v[6] >> 16) ~ v[6] ~ (v[7] << 16) ~ (v[7] >> 16) ~ (v[7] & 0xffff0000)
+    h[6] = v[0] ~ v[2] ~ (v[2] >> 16) ~ v[3] ~ (v[3] << 16) ~ v[4] ~
+        (v[4] >> 16) ~ (v[5] << 16) ~ (v[5] >> 16) ~ v[5] ~ (v[6] << 16) ~
+        (v[6] >> 16) ~ v[6] ~ (v[7] << 16) ~ v[7]
+    h[7] = v[0] ~ (v[0] >> 16) ~ (v[1] << 16) ~ (v[1] >> 16) ~ (v[2] << 16) ~
+        (v[3] >> 16) ~ v[3] ~ (v[4] << 16) ~ v[4] ~ (v[5] >> 16) ~ v[5] ~
+        (v[6] << 16) ~ (v[6] >> 16) ~ (v[7] << 16) ~ v[7]
+}
+
+init_odin :: proc(ctx: ^Gost_Context) {
+    sbox: [8][16]u32 = {
+        { 10, 4,  5,  6,  8,  1,  3,  7,  13, 12, 14, 0,  9,  2,  11, 15 },
+        { 5,  15, 4,  0,  2,  13, 11, 9,  1,  7,  6,  3,  12, 14, 10, 8  },
+        { 7,  15, 12, 14, 9,  4,  1,  0,  3,  11, 5,  2,  6,  10, 8,  13 },
+        { 4,  10, 7,  12, 0,  15, 2,  8,  14, 1,  6,  5,  13, 11, 9,  3  },
+        { 7,  6,  4,  11, 9,  12, 2,  10, 1,  8,  0,  14, 15, 13, 3,  5  },
+        { 7,  6,  2,  4,  13, 9,  15, 0,  10, 1,  5,  11, 8,  14, 12, 3  },
+        { 13, 14, 4,  1,  7,  0,  5,  10, 3,  12, 8,  15, 6,  2,  9,  11 },
+        { 1,  3,  10, 9,  5,  11, 4,  15, 8,  6,  7,  14, 13, 0,  2,  12 },
+    }
+
+    i := 0
+    for a := 0; a < 16; a += 1 {
+        ax := sbox[1][a] << 15
+        bx := sbox[3][a] << 23
+        cx := sbox[5][a]
+        cx = (cx >> 1) | (cx << 31)
+        dx := sbox[7][a] << 7
+        for b := 0; b < 16; b, i = b + 1, i + 1 {
+            SBOX_1[i] = ax | (sbox[0][b] << 11)
+            SBOX_2[i] = bx | (sbox[2][b] << 19)
+            SBOX_3[i] = cx | (sbox[4][b] << 27)
+            SBOX_4[i] = dx | (sbox[6][b] << 3)
+        }
+    }
+}
+
+update_odin :: proc(ctx: ^Gost_Context, data: []byte) {
+    length := byte(len(data))
+    j: byte
+
+    i := ctx.partial_bytes
+    for i < 32 && j < length {
+        ctx.partial[i] = data[j]
+        i, j = i + 1, j + 1
+    }
+
+    if i < 32 {
+        ctx.partial_bytes = i
+        return
+    }
+    gost_bytes(ctx, ctx.partial[:], 256)
+
+    for (j + 32) < length {
+        gost_bytes(ctx, data[j:], 256)
+        j += 32
+    }
+
+    i = 0
+    for j < length {
+        ctx.partial[i] = data[j]
+        i, j = i + 1, j + 1
+    }
+    ctx.partial_bytes = i
+}
+
+final_odin :: proc(ctx: ^Gost_Context, hash: []byte) {
+    if ctx.partial_bytes > 0 {
+        mem.set(&ctx.partial[ctx.partial_bytes], 0, 32 - int(ctx.partial_bytes))
+        gost_bytes(ctx, ctx.partial[:], u32(ctx.partial_bytes) << 3)
+    }
+  
+    gost_compress(ctx.hash[:], ctx.len[:])
+    gost_compress(ctx.hash[:], ctx.sum[:])
+
+    for i, j := 0, 0; i < 8; i, j = i + 1, j + 4 {
+        hash[j]     = byte(ctx.hash[i])
+        hash[j + 1] = byte(ctx.hash[i] >> 8)
+        hash[j + 2] = byte(ctx.hash[i] >> 16)
+        hash[j + 3] = byte(ctx.hash[i] >> 24)
+    }
+}

core/crypto/groestl/groestl.odin

@@ -0,0 +1,730 @@
+package groestl
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Implementation of the GROESTL hashing algorithm, as defined in <http://www.groestl.info/Groestl.zip>
+*/
+
+import "core:os"
+import "core:io"
+
+import "../_ctx"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_28  = hash_bytes_odin_28
+    ctx.hash_file_28   = hash_file_odin_28
+    ctx.hash_stream_28 = hash_stream_odin_28
+    ctx.hash_bytes_32  = hash_bytes_odin_32
+    ctx.hash_file_32   = hash_file_odin_32
+    ctx.hash_stream_32 = hash_stream_odin_32
+    ctx.hash_bytes_48  = hash_bytes_odin_48
+    ctx.hash_file_48   = hash_file_odin_48
+    ctx.hash_stream_48 = hash_stream_odin_48
+    ctx.hash_bytes_64  = hash_bytes_odin_64
+    ctx.hash_file_64   = hash_file_odin_64
+    ctx.hash_stream_64 = hash_stream_odin_64
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan does nothing, since GROESTL is not available in Botan
+@(warning="GROESTL is not provided by the Botan API. Odin implementation will be used")
+use_botan :: #force_inline proc() {
+    use_odin()
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+@(private)
+_create_groestl_ctx :: #force_inline proc(size: _ctx.Hash_Size) {
+    ctx: Groestl_Context
+    _hash_impl.internal_ctx = ctx
+    _hash_impl.hash_size    = size
+    #partial switch size {
+        case ._28: ctx.hashbitlen = 224
+        case ._32: ctx.hashbitlen = 256
+        case ._48: ctx.hashbitlen = 384
+        case ._64: ctx.hashbitlen = 512
+    }
+}
+
+/*
+    High level API
+*/
+
+// hash_string_224 will hash the given input and return the
+// computed hash
+hash_string_224 :: proc(data: string) -> [28]byte {
+    return hash_bytes_224(transmute([]byte)(data))
+}
+
+// hash_bytes_224 will hash the given input and return the
+// computed hash
+hash_bytes_224 :: proc(data: []byte) -> [28]byte {
+    _create_groestl_ctx(._28)
+    return _hash_impl->hash_bytes_28(data)
+}
+
+// hash_stream_224 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_224 :: proc(s: io.Stream) -> ([28]byte, bool) {
+    _create_groestl_ctx(._28)
+    return _hash_impl->hash_stream_28(s)
+}
+
+// hash_file_224 will read the file provided by the given handle
+// and compute a hash
+hash_file_224 :: proc(hd: os.Handle, load_at_once := false) -> ([28]byte, bool) {
+    _create_groestl_ctx(._28)
+    return _hash_impl->hash_file_28(hd, load_at_once)
+}
+
+hash_224 :: proc {
+    hash_stream_224,
+    hash_file_224,
+    hash_bytes_224,
+    hash_string_224,
+}
+
+// hash_string_256 will hash the given input and return the
+// computed hash
+hash_string_256 :: proc(data: string) -> [32]byte {
+    return hash_bytes_256(transmute([]byte)(data))
+}
+
+// hash_bytes_256 will hash the given input and return the
+// computed hash
+hash_bytes_256 :: proc(data: []byte) -> [32]byte {
+    _create_groestl_ctx(._32)
+    return _hash_impl->hash_bytes_32(data)
+}
+
+// hash_stream_256 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_256 :: proc(s: io.Stream) -> ([32]byte, bool) {
+    _create_groestl_ctx(._32)
+    return _hash_impl->hash_stream_32(s)
+}
+
+// hash_file_256 will read the file provided by the given handle
+// and compute a hash
+hash_file_256 :: proc(hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    _create_groestl_ctx(._32)
+    return _hash_impl->hash_file_32(hd, load_at_once)
+}
+
+hash_256 :: proc {
+    hash_stream_256,
+    hash_file_256,
+    hash_bytes_256,
+    hash_string_256,
+}
+
+// hash_string_384 will hash the given input and return the
+// computed hash
+hash_string_384 :: proc(data: string) -> [48]byte {
+    return hash_bytes_384(transmute([]byte)(data))
+}
+
+// hash_bytes_384 will hash the given input and return the
+// computed hash
+hash_bytes_384 :: proc(data: []byte) -> [48]byte {
+    _create_groestl_ctx(._48)
+    return _hash_impl->hash_bytes_48(data)
+}
+
+// hash_stream_384 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_384 :: proc(s: io.Stream) -> ([48]byte, bool) {
+    _create_groestl_ctx(._48)
+    return _hash_impl->hash_stream_48(s)
+}
+
+// hash_file_384 will read the file provided by the given handle
+// and compute a hash
+hash_file_384 :: proc(hd: os.Handle, load_at_once := false) -> ([48]byte, bool) {
+    _create_groestl_ctx(._48)
+    return _hash_impl->hash_file_48(hd, load_at_once)
+}
+
+hash_384 :: proc {
+    hash_stream_384,
+    hash_file_384,
+    hash_bytes_384,
+    hash_string_384,
+}
+
+// hash_string_512 will hash the given input and return the
+// computed hash
+hash_string_512 :: proc(data: string) -> [64]byte {
+    return hash_bytes_512(transmute([]byte)(data))
+}
+
+// hash_bytes_512 will hash the given input and return the
+// computed hash
+hash_bytes_512 :: proc(data: []byte) -> [64]byte {
+    _create_groestl_ctx(._64)
+    return _hash_impl->hash_bytes_64(data)
+}
+
+// hash_stream_512 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_512 :: proc(s: io.Stream) -> ([64]byte, bool) {
+    _create_groestl_ctx(._64)
+    return _hash_impl->hash_stream_64(s)
+}
+
+// hash_file_512 will read the file provided by the given handle
+// and compute a hash
+hash_file_512 :: proc(hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    _create_groestl_ctx(._64)
+    return _hash_impl->hash_file_64(hd, load_at_once)
+}
+
+hash_512 :: proc {
+    hash_stream_512,
+    hash_file_512,
+    hash_bytes_512,
+    hash_string_512,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [28]byte {
+    hash: [28]byte
+    if c, ok := ctx.internal_ctx.(Groestl_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([28]byte, bool) {
+    hash: [28]byte
+    if c, ok := ctx.internal_ctx.(Groestl_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([28]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_28(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_28(ctx, buf[:]), ok
+        }
+    }
+    return [28]byte{}, false
+}
+
+hash_bytes_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [32]byte {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(Groestl_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([32]byte, bool) {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(Groestl_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_32(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_32(ctx, buf[:]), ok
+        }
+    }
+    return [32]byte{}, false
+}
+
+hash_bytes_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [48]byte {
+    hash: [48]byte
+    if c, ok := ctx.internal_ctx.(Groestl_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([48]byte, bool) {
+    hash: [48]byte
+    if c, ok := ctx.internal_ctx.(Groestl_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([48]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_48(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_48(ctx, buf[:]), ok
+        }
+    }
+    return [48]byte{}, false
+}
+
+hash_bytes_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [64]byte {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(Groestl_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([64]byte, bool) {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(Groestl_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_64(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_64(ctx, buf[:]), ok
+        }
+    }
+    return [64]byte{}, false
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    _create_groestl_ctx(ctx.hash_size)
+    if c, ok := ctx.internal_ctx.(Groestl_Context); ok {
+        init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(Groestl_Context); ok {
+        update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(Groestl_Context); ok {
+        final_odin(&c, hash)
+    }
+}
+
+/*
+    GROESTL implementation
+*/
+
+SBOX := [256]byte {
+    0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
+    0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
+    0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
+    0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
+    0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc,
+    0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
+    0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a,
+    0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
+    0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
+    0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
+    0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b,
+    0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
+    0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85,
+    0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
+    0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
+    0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
+    0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17,
+    0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
+    0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88,
+    0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
+    0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
+    0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
+    0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9,
+    0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
+    0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6,
+    0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
+    0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
+    0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
+    0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94,
+    0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
+    0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
+    0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16,
+}
+
+SHIFT := [2][2][8]int {
+    {{0, 1, 2, 3, 4, 5, 6, 7},  {1, 3, 5, 7,  0, 2, 4, 6}},
+    {{0, 1, 2, 3, 4, 5, 6, 11}, {1, 3, 5, 11, 0, 2, 4, 6}},
+}
+
+Groestl_Context :: struct {
+    chaining:          [8][16]byte,
+    block_counter:     u64,
+    hashbitlen:        int,
+    buffer:            [128]byte,
+    buf_ptr:           int,
+    bits_in_last_byte: int,
+    columns:           int,
+    rounds:            int,
+    statesize:         int,
+}
+
+Groestl_Variant :: enum {
+    P512  = 0, 
+    Q512  = 1, 
+    P1024 = 2, 
+    Q1024 = 3,
+}
+
+MUL2 :: #force_inline proc "contextless"(b: byte) -> byte {
+    return (b >> 7) != 0 ? (b << 1) ~ 0x1b : (b << 1)
+}
+
+MUL3 :: #force_inline proc "contextless"(b: byte) -> byte {
+    return MUL2(b) ~ b
+}
+
+MUL4 :: #force_inline proc "contextless"(b: byte) -> byte {
+    return MUL2(MUL2(b))
+}
+
+MUL5 :: #force_inline proc "contextless"(b: byte) -> byte {
+    return MUL4(b) ~ b
+}
+
+MUL6 :: #force_inline proc "contextless"(b: byte) -> byte {
+    return MUL4(b) ~ MUL2(b)
+}
+
+MUL7 :: #force_inline proc "contextless"(b: byte) -> byte {
+    return MUL4(b) ~ MUL2(b) ~ b
+}
+
+sub_bytes :: #force_inline proc (x: [][16]byte, columns: int) {
+    for i := 0; i < 8; i += 1 {
+        for j := 0; j < columns; j += 1 {
+            x[i][j] = SBOX[x[i][j]]
+        }
+    }
+}
+
+shift_bytes :: #force_inline proc (x: [][16]byte, columns: int, v: Groestl_Variant) {
+    temp: [16]byte
+    R := &SHIFT[int(v) / 2][int(v) & 1]
+
+    for i := 0; i < 8; i += 1 {
+        for j := 0; j < columns; j += 1 {
+            temp[j] = x[i][(j + R[i]) % columns]
+        }
+        for j := 0; j < columns; j += 1 {
+            x[i][j] = temp[j]
+        }
+    }
+}
+
+mix_bytes :: #force_inline proc (x: [][16]byte, columns: int) {
+    temp: [8]byte
+
+    for i := 0; i < columns; i += 1 {
+        for j := 0; j < 8; j += 1 {
+            temp[j] =  MUL2(x[(j + 0) % 8][i]) ~
+                       MUL2(x[(j + 1) % 8][i]) ~
+                       MUL3(x[(j + 2) % 8][i]) ~
+                       MUL4(x[(j + 3) % 8][i]) ~
+                       MUL5(x[(j + 4) % 8][i]) ~
+                       MUL3(x[(j + 5) % 8][i]) ~
+                       MUL5(x[(j + 6) % 8][i]) ~
+                       MUL7(x[(j + 7) % 8][i])
+        }
+        for j := 0; j < 8; j += 1 {
+            x[j][i] = temp[j]
+        }
+    }
+}
+
+p :: #force_inline proc (ctx: ^Groestl_Context, x: [][16]byte) {
+    v := ctx.columns == 8 ? Groestl_Variant.P512 : Groestl_Variant.P1024
+    for i := 0; i < ctx.rounds; i += 1 {
+        add_roundconstant(x, ctx.columns, byte(i), v)
+        sub_bytes(x, ctx.columns)
+        shift_bytes(x, ctx.columns, v)
+        mix_bytes(x, ctx.columns)
+    }
+}
+
+q :: #force_inline proc (ctx: ^Groestl_Context, x: [][16]byte) {
+    v := ctx.columns == 8 ? Groestl_Variant.Q512 : Groestl_Variant.Q1024
+    for i := 0; i < ctx.rounds; i += 1 {
+        add_roundconstant(x, ctx.columns, byte(i), v)
+        sub_bytes(x, ctx.columns)
+        shift_bytes(x, ctx.columns, v)
+        mix_bytes(x, ctx.columns)
+    }
+}
+
+transform :: proc(ctx: ^Groestl_Context, input: []byte, msglen: u32) {
+    tmp1, tmp2: [8][16]byte
+    input, msglen := input, msglen
+
+    for msglen >= u32(ctx.statesize) {
+        for i := 0; i < 8; i += 1 {
+            for j := 0; j < ctx.columns; j += 1 {
+                tmp1[i][j] = ctx.chaining[i][j] ~ input[j * 8 + i]
+                tmp2[i][j] = input[j * 8 + i]
+            }
+        }
+
+        p(ctx, tmp1[:])
+        q(ctx, tmp2[:])
+
+        for i := 0; i < 8; i += 1 {
+            for j := 0; j < ctx.columns; j += 1 {
+                ctx.chaining[i][j] ~= tmp1[i][j] ~ tmp2[i][j]
+            }
+        }
+
+        ctx.block_counter += 1
+        msglen            -= u32(ctx.statesize)
+        input              = input[ctx.statesize:]
+    }
+}
+
+output_transformation :: proc(ctx: ^Groestl_Context) {
+    temp: [8][16]byte
+
+    for i := 0; i < 8; i += 1 {
+        for j := 0; j < ctx.columns; j += 1 {
+            temp[i][j] = ctx.chaining[i][j]
+        }
+    }
+
+    p(ctx, temp[:])
+
+    for i := 0; i < 8; i += 1 {
+        for j := 0; j < ctx.columns; j += 1 {
+            ctx.chaining[i][j] ~= temp[i][j]
+        }
+    }
+}
+
+add_roundconstant :: proc(x: [][16]byte, columns: int, round: byte, v: Groestl_Variant) {
+    switch (i32(v) & 1) {
+        case 0: 
+            for i := 0; i < columns; i += 1 {
+                x[0][i] ~= byte(i << 4) ~ round
+            }
+        case 1:
+            for i := 0; i < columns; i += 1 {
+                for j := 0; j < 7; j += 1 {
+                    x[j][i] ~= 0xff
+                }
+            }
+            for i := 0; i < columns; i += 1 {
+                x[7][i] ~= byte(i << 4) ~ 0xff ~ round
+            }
+    }
+}
+
+init_odin :: proc(ctx: ^Groestl_Context) {
+    if ctx.hashbitlen <= 256 {
+        ctx.rounds    = 10
+        ctx.columns   = 8
+        ctx.statesize = 64
+    } else {
+        ctx.rounds    = 14
+        ctx.columns   = 16
+        ctx.statesize = 128
+    }
+    for i := 8 - size_of(i32); i < 8; i += 1 {
+        ctx.chaining[i][ctx.columns - 1] = byte(ctx.hashbitlen >> (8 * (7 - uint(i))))
+    }
+}
+
+update_odin :: proc(ctx: ^Groestl_Context, data: []byte) {
+    databitlen := len(data) * 8
+    msglen     := databitlen / 8
+    rem        := databitlen % 8
+
+    i: int
+    assert(ctx.bits_in_last_byte == 0)
+
+    if ctx.buf_ptr != 0 {
+        for i = 0; ctx.buf_ptr < ctx.statesize && i < msglen; i, ctx.buf_ptr =  i + 1, ctx.buf_ptr + 1 {
+            ctx.buffer[ctx.buf_ptr] = data[i]
+        }
+
+        if ctx.buf_ptr < ctx.statesize {
+            if rem != 0 {
+                ctx.bits_in_last_byte    = rem
+                ctx.buffer[ctx.buf_ptr]  = data[i]
+                ctx.buf_ptr             += 1
+            }
+            return
+        }
+
+        ctx.buf_ptr = 0
+        transform(ctx, ctx.buffer[:], u32(ctx.statesize))
+    }
+
+    transform(ctx, data[i:], u32(msglen - i))
+    i += ((msglen - i) / ctx.statesize) * ctx.statesize
+    for i < msglen {
+        ctx.buffer[ctx.buf_ptr] = data[i]
+        i, ctx.buf_ptr          = i + 1, ctx.buf_ptr + 1
+    }
+    
+    if rem != 0 {
+        ctx.bits_in_last_byte    = rem
+        ctx.buffer[ctx.buf_ptr]  = data[i]
+        ctx.buf_ptr             += 1
+    }
+}
+
+final_odin :: proc(ctx: ^Groestl_Context, hash: []byte) {
+    hashbytelen := ctx.hashbitlen / 8
+
+    if ctx.bits_in_last_byte != 0 {
+        ctx.buffer[ctx.buf_ptr - 1] &= ((1 << uint(ctx.bits_in_last_byte)) - 1) << (8 - uint(ctx.bits_in_last_byte))
+        ctx.buffer[ctx.buf_ptr - 1] ~= 0x1 << (7 - uint(ctx.bits_in_last_byte))
+    } else {
+        ctx.buffer[ctx.buf_ptr]  = 0x80
+        ctx.buf_ptr             += 1
+    }
+
+    if ctx.buf_ptr > ctx.statesize - 8 {
+        for ctx.buf_ptr < ctx.statesize {
+            ctx.buffer[ctx.buf_ptr]  = 0
+            ctx.buf_ptr             += 1
+        }
+        transform(ctx, ctx.buffer[:], u32(ctx.statesize))
+        ctx.buf_ptr = 0
+    }
+
+    for ctx.buf_ptr < ctx.statesize - 8 {
+        ctx.buffer[ctx.buf_ptr]  = 0
+        ctx.buf_ptr             += 1
+    }
+
+    ctx.block_counter += 1
+    ctx.buf_ptr        = ctx.statesize
+
+    for ctx.buf_ptr > ctx.statesize - 8 {
+        ctx.buf_ptr              -= 1
+        ctx.buffer[ctx.buf_ptr]   = byte(ctx.block_counter)
+        ctx.block_counter       >>= 8
+    }
+
+    transform(ctx, ctx.buffer[:], u32(ctx.statesize))
+    output_transformation(ctx)
+
+    for i, j := ctx.statesize - hashbytelen , 0; i < ctx.statesize; i, j = i + 1, j + 1 {
+        hash[j] = ctx.chaining[i % 8][i / 8]
+    }
+}

core/crypto/jh/jh.odin

@@ -0,0 +1,661 @@
+package jh
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Implementation of the JH hashing algorithm, as defined in <https://www3.ntu.edu.sg/home/wuhj/research/jh/index.html>
+*/
+
+import "core:os"
+import "core:io"
+
+import "../_ctx"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_28  = hash_bytes_odin_28
+    ctx.hash_file_28   = hash_file_odin_28
+    ctx.hash_stream_28 = hash_stream_odin_28
+    ctx.hash_bytes_32  = hash_bytes_odin_32
+    ctx.hash_file_32   = hash_file_odin_32
+    ctx.hash_stream_32 = hash_stream_odin_32
+    ctx.hash_bytes_48  = hash_bytes_odin_48
+    ctx.hash_file_48   = hash_file_odin_48
+    ctx.hash_stream_48 = hash_stream_odin_48
+    ctx.hash_bytes_64  = hash_bytes_odin_64
+    ctx.hash_file_64   = hash_file_odin_64
+    ctx.hash_stream_64 = hash_stream_odin_64
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan does nothing, since JH is not available in Botan
+@(warning="JH is not provided by the Botan API. Odin implementation will be used")
+use_botan :: #force_inline proc() {
+    use_odin()
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+@(private)
+_create_jh_ctx :: #force_inline proc(size: _ctx.Hash_Size) {
+    ctx: Jh_Context
+    _hash_impl.internal_ctx = ctx
+    _hash_impl.hash_size    = size
+    #partial switch size {
+        case ._28: ctx.hashbitlen = 224
+        case ._32: ctx.hashbitlen = 256
+        case ._48: ctx.hashbitlen = 384
+        case ._64: ctx.hashbitlen = 512
+    }
+}
+
+/*
+    High level API
+*/
+
+// hash_string_224 will hash the given input and return the
+// computed hash
+hash_string_224 :: proc(data: string) -> [28]byte {
+    return hash_bytes_224(transmute([]byte)(data))
+}
+
+// hash_bytes_224 will hash the given input and return the
+// computed hash
+hash_bytes_224 :: proc(data: []byte) -> [28]byte {
+    _create_jh_ctx(._28)
+    return _hash_impl->hash_bytes_28(data)
+}
+
+// hash_stream_224 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_224 :: proc(s: io.Stream) -> ([28]byte, bool) {
+    _create_jh_ctx(._28)
+    return _hash_impl->hash_stream_28(s)
+}
+
+// hash_file_224 will read the file provided by the given handle
+// and compute a hash
+hash_file_224 :: proc(hd: os.Handle, load_at_once := false) -> ([28]byte, bool) {
+    _create_jh_ctx(._28)
+    return _hash_impl->hash_file_28(hd, load_at_once)
+}
+
+hash_224 :: proc {
+    hash_stream_224,
+    hash_file_224,
+    hash_bytes_224,
+    hash_string_224,
+}
+
+// hash_string_256 will hash the given input and return the
+// computed hash
+hash_string_256 :: proc(data: string) -> [32]byte {
+    return hash_bytes_256(transmute([]byte)(data))
+}
+
+// hash_bytes_256 will hash the given input and return the
+// computed hash
+hash_bytes_256 :: proc(data: []byte) -> [32]byte {
+    _create_jh_ctx(._32)
+    return _hash_impl->hash_bytes_32(data)
+}
+
+// hash_stream_256 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_256 :: proc(s: io.Stream) -> ([32]byte, bool) {
+    _create_jh_ctx(._32)
+    return _hash_impl->hash_stream_32(s)
+}
+
+// hash_file_256 will read the file provided by the given handle
+// and compute a hash
+hash_file_256 :: proc(hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    _create_jh_ctx(._32)
+    return _hash_impl->hash_file_32(hd, load_at_once)
+}
+
+hash_256 :: proc {
+    hash_stream_256,
+    hash_file_256,
+    hash_bytes_256,
+    hash_string_256,
+}
+
+// hash_string_384 will hash the given input and return the
+// computed hash
+hash_string_384 :: proc(data: string) -> [48]byte {
+    return hash_bytes_384(transmute([]byte)(data))
+}
+
+// hash_bytes_384 will hash the given input and return the
+// computed hash
+hash_bytes_384 :: proc(data: []byte) -> [48]byte {
+    _create_jh_ctx(._48)
+    return _hash_impl->hash_bytes_48(data)
+}
+
+// hash_stream_384 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_384 :: proc(s: io.Stream) -> ([48]byte, bool) {
+    _create_jh_ctx(._48)
+    return _hash_impl->hash_stream_48(s)
+}
+
+// hash_file_384 will read the file provided by the given handle
+// and compute a hash
+hash_file_384 :: proc(hd: os.Handle, load_at_once := false) -> ([48]byte, bool) {
+    _create_jh_ctx(._48)
+    return _hash_impl->hash_file_48(hd, load_at_once)
+}
+
+hash_384 :: proc {
+    hash_stream_384,
+    hash_file_384,
+    hash_bytes_384,
+    hash_string_384,
+}
+
+// hash_string_512 will hash the given input and return the
+// computed hash
+hash_string_512 :: proc(data: string) -> [64]byte {
+    return hash_bytes_512(transmute([]byte)(data))
+}
+
+// hash_bytes_512 will hash the given input and return the
+// computed hash
+hash_bytes_512 :: proc(data: []byte) -> [64]byte {
+    _create_jh_ctx(._64)
+    return _hash_impl->hash_bytes_64(data)
+}
+
+// hash_stream_512 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_512 :: proc(s: io.Stream) -> ([64]byte, bool) {
+    _create_jh_ctx(._64)
+    return _hash_impl->hash_stream_64(s)
+}
+
+// hash_file_512 will read the file provided by the given handle
+// and compute a hash
+hash_file_512 :: proc(hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    _create_jh_ctx(._64)
+    return _hash_impl->hash_file_64(hd, load_at_once)
+}
+
+hash_512 :: proc {
+    hash_stream_512,
+    hash_file_512,
+    hash_bytes_512,
+    hash_string_512,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [28]byte {
+    hash: [28]byte
+    if c, ok := ctx.internal_ctx.(Jh_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([28]byte, bool) {
+    hash: [28]byte
+    if c, ok := ctx.internal_ctx.(Jh_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([28]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_28(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_28(ctx, buf[:]), ok
+        }
+    }
+    return [28]byte{}, false
+}
+
+hash_bytes_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [32]byte {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(Jh_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([32]byte, bool) {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(Jh_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_32(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_32(ctx, buf[:]), ok
+        }
+    }
+    return [32]byte{}, false
+}
+
+hash_bytes_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [48]byte {
+    hash: [48]byte
+    if c, ok := ctx.internal_ctx.(Jh_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([48]byte, bool) {
+    hash: [48]byte
+    if c, ok := ctx.internal_ctx.(Jh_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([48]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_48(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_48(ctx, buf[:]), ok
+        }
+    }
+    return [48]byte{}, false
+}
+
+hash_bytes_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [64]byte {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(Jh_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([64]byte, bool) {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(Jh_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_64(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_64(ctx, buf[:]), ok
+        }
+    }
+    return [64]byte{}, false
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    _create_jh_ctx(ctx.hash_size)
+    if c, ok := ctx.internal_ctx.(Jh_Context); ok {
+        init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(Jh_Context); ok {
+        update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(Jh_Context); ok {
+        final_odin(&c, hash)
+    }
+}
+
+/*
+    JH implementation
+*/
+
+JH_ROUNDCONSTANT_ZERO := [64]byte {
+    0x6, 0xa, 0x0, 0x9, 0xe, 0x6, 0x6, 0x7,
+    0xf, 0x3, 0xb, 0xc, 0xc, 0x9, 0x0, 0x8,
+    0xb, 0x2, 0xf, 0xb, 0x1, 0x3, 0x6, 0x6,
+    0xe, 0xa, 0x9, 0x5, 0x7, 0xd, 0x3, 0xe,
+    0x3, 0xa, 0xd, 0xe, 0xc, 0x1, 0x7, 0x5,
+    0x1, 0x2, 0x7, 0x7, 0x5, 0x0, 0x9, 0x9,
+    0xd, 0xa, 0x2, 0xf, 0x5, 0x9, 0x0, 0xb,
+    0x0, 0x6, 0x6, 0x7, 0x3, 0x2, 0x2, 0xa,
+}
+
+JH_S := [2][16]byte {
+    {9, 0,  4, 11, 13, 12, 3, 15, 1,  10, 2, 6, 7,  5,  8,  14},
+    {3, 12, 6, 13, 5,  7,  1, 9,  15, 2,  0, 4, 11, 10, 14, 8},
+}
+
+Jh_Context :: struct {
+    hashbitlen:    int,
+    databitlen:    u64,
+    buffer_size:   u64,
+    H:             [128]byte,
+    A:             [256]byte,
+    roundconstant: [64]byte,
+    buffer:        [64]byte,
+}
+
+JH_E8_finaldegroup :: proc(ctx: ^Jh_Context) {
+    t0,t1,t2,t3: byte
+    tem: [256]byte
+    for i := 0; i < 128; i += 1 {
+        tem[i]       = ctx.A[i << 1]
+        tem[i + 128] = ctx.A[(i << 1) + 1]
+    }
+    for i := 0; i < 128; i += 1 {
+        ctx.H[i] = 0
+    }
+    for i := 0; i < 256; i += 1 {
+        t0 = (tem[i] >> 3) & 1
+        t1 = (tem[i] >> 2) & 1
+        t2 = (tem[i] >> 1) & 1
+        t3 = (tem[i] >> 0) & 1
+
+        ctx.H[uint(i) >> 3]         |= t0 << (7 - (uint(i) & 7))
+        ctx.H[(uint(i) + 256) >> 3] |= t1 << (7 - (uint(i) & 7))
+        ctx.H[(uint(i) + 512) >> 3] |= t2 << (7 - (uint(i) & 7))
+        ctx.H[(uint(i) + 768) >> 3] |= t3 << (7 - (uint(i) & 7))
+    }
+}
+
+jh_update_roundconstant :: proc(ctx: ^Jh_Context) {
+    tem: [64]byte
+    t: byte
+    for i := 0; i < 64; i += 1 {
+        tem[i] = JH_S[0][ctx.roundconstant[i]]
+    }
+    for i := 0; i < 64; i += 2 {
+        tem[i + 1] ~= ((tem[i]   << 1)   ~ (tem[i]   >> 3)   ~ ((tem[i]   >> 2) & 2))   & 0xf
+        tem[i]     ~= ((tem[i + 1] << 1) ~ (tem[i + 1] >> 3) ~ ((tem[i + 1] >> 2) & 2)) & 0xf
+    }
+    for i := 0; i < 64; i += 4 {
+        t          = tem[i + 2]
+        tem[i + 2] = tem[i + 3]
+        tem[i + 3] = t
+    }
+    for i := 0; i < 32; i += 1 {
+        ctx.roundconstant[i]      = tem[i << 1]
+        ctx.roundconstant[i + 32] = tem[(i << 1) + 1]
+    }
+    for i := 32; i < 64; i += 2 {
+        t                        = ctx.roundconstant[i]
+        ctx.roundconstant[i]     = ctx.roundconstant[i + 1]
+        ctx.roundconstant[i + 1] = t
+    }
+}
+
+JH_R8 :: proc(ctx: ^Jh_Context) {
+    t: byte
+    tem, roundconstant_expanded: [256]byte
+    for i := u32(0); i < 256; i += 1 {
+        roundconstant_expanded[i] = (ctx.roundconstant[i >> 2] >> (3 - (i & 3)) ) & 1
+    }
+    for i := 0; i < 256; i += 1 {
+        tem[i] = JH_S[roundconstant_expanded[i]][ctx.A[i]]
+    }
+    for i := 0; i < 256; i += 2 {
+        tem[i+1] ~= ((tem[i]   << 1)   ~ (tem[i]   >> 3)   ~ ((tem[i]   >> 2) & 2))   & 0xf
+        tem[i]   ~= ((tem[i + 1] << 1) ~ (tem[i + 1] >> 3) ~ ((tem[i + 1] >> 2) & 2)) & 0xf
+    }
+    for i := 0; i < 256; i += 4 {
+        t        = tem[i + 2]
+        tem[i+2] = tem[i + 3]
+        tem[i+3] = t
+    }
+    for i := 0; i < 128; i += 1 {
+        ctx.A[i]       = tem[i << 1]
+        ctx.A[i + 128] = tem[(i << 1) + 1]
+    }
+    for i := 128; i < 256; i += 2 {
+        t            = ctx.A[i]
+        ctx.A[i]     = ctx.A[i + 1]
+        ctx.A[i + 1] = t
+    }
+}
+
+JH_E8_initialgroup :: proc(ctx: ^Jh_Context) {
+    t0, t1, t2, t3: byte
+    tem:            [256]byte
+    for i := u32(0); i < 256; i += 1 {
+        t0     = (ctx.H[i >> 3]   >> (7 - (i & 7)))       & 1
+        t1     = (ctx.H[(i + 256) >> 3] >> (7 - (i & 7))) & 1
+        t2     = (ctx.H[(i + 512) >> 3] >> (7 - (i & 7))) & 1
+        t3     = (ctx.H[(i + 768) >> 3] >> (7 - (i & 7))) & 1
+        tem[i] = (t0 << 3) | (t1 << 2) | (t2 << 1) | (t3 << 0)
+    }
+    for i := 0; i < 128; i += 1 {
+        ctx.A[i << 1]       = tem[i]
+        ctx.A[(i << 1) + 1] = tem[i + 128]
+    }
+}
+
+JH_E8 :: proc(ctx: ^Jh_Context) {
+    for i := 0; i < 64; i += 1 {
+        ctx.roundconstant[i] = JH_ROUNDCONSTANT_ZERO[i]
+    }
+    JH_E8_initialgroup(ctx)
+    for i := 0; i < 42; i += 1 {
+        JH_R8(ctx)
+        jh_update_roundconstant(ctx)
+    }
+    JH_E8_finaldegroup(ctx)
+}
+
+JH_F8 :: proc(ctx: ^Jh_Context) {
+    for i := 0; i < 64; i += 1 {
+        ctx.H[i] ~= ctx.buffer[i]
+    }
+    JH_E8(ctx)
+    for i := 0; i < 64; i += 1 {
+        ctx.H[i + 64] ~= ctx.buffer[i]
+    }
+}
+
+init_odin :: proc(ctx: ^Jh_Context) {
+    ctx.H[1] = byte(ctx.hashbitlen)      & 0xff
+    ctx.H[0] = byte(ctx.hashbitlen >> 8) & 0xff
+    JH_F8(ctx)
+}
+
+update_odin :: proc(ctx: ^Jh_Context, data: []byte) {
+    databitlen     := u64(len(data)) * 8
+    ctx.databitlen += databitlen
+    i              := u64(0)
+
+    if (ctx.buffer_size > 0) && ((ctx.buffer_size + databitlen) < 512) {
+        if (databitlen & 7) == 0 {
+            copy(ctx.buffer[ctx.buffer_size >> 3:], data[:64 - (ctx.buffer_size >> 3)])
+		} else {
+            copy(ctx.buffer[ctx.buffer_size >> 3:], data[:64 - (ctx.buffer_size >> 3) + 1])
+        } 
+        ctx.buffer_size += databitlen
+        databitlen = 0
+    }
+
+    if (ctx.buffer_size > 0 ) && ((ctx.buffer_size + databitlen) >= 512) {
+        copy(ctx.buffer[ctx.buffer_size >> 3:], data[:64 - (ctx.buffer_size >> 3)])
+	    i      = 64 - (ctx.buffer_size >> 3)
+	    databitlen = databitlen - (512 - ctx.buffer_size)
+	    JH_F8(ctx)
+	    ctx.buffer_size = 0
+    }
+
+    for databitlen >= 512 {
+        copy(ctx.buffer[:], data[i:i + 64])
+        JH_F8(ctx)
+        i += 64
+        databitlen -= 512
+    }
+
+    if databitlen > 0 {
+        if (databitlen & 7) == 0 {
+            copy(ctx.buffer[:], data[i:i + ((databitlen & 0x1ff) >> 3)])
+        } else {
+            copy(ctx.buffer[:], data[i:i + ((databitlen & 0x1ff) >> 3) + 1])
+        }
+        ctx.buffer_size = databitlen
+    }
+}
+
+final_odin :: proc(ctx: ^Jh_Context, hash: []byte) {
+    if ctx.databitlen & 0x1ff == 0 {
+        for i := 0; i < 64; i += 1 {
+            ctx.buffer[i] = 0
+        }
+        ctx.buffer[0]  = 0x80
+        ctx.buffer[63] = byte(ctx.databitlen)       & 0xff
+        ctx.buffer[62] = byte(ctx.databitlen >> 8)  & 0xff
+        ctx.buffer[61] = byte(ctx.databitlen >> 16) & 0xff
+        ctx.buffer[60] = byte(ctx.databitlen >> 24) & 0xff
+        ctx.buffer[59] = byte(ctx.databitlen >> 32) & 0xff
+        ctx.buffer[58] = byte(ctx.databitlen >> 40) & 0xff
+        ctx.buffer[57] = byte(ctx.databitlen >> 48) & 0xff
+        ctx.buffer[56] = byte(ctx.databitlen >> 56) & 0xff
+        JH_F8(ctx)
+    } else {
+        if ctx.buffer_size & 7 == 0 {
+            for i := (ctx.databitlen & 0x1ff) >> 3; i < 64; i += 1 {
+                ctx.buffer[i] = 0
+            }
+        } else {
+            for i := ((ctx.databitlen & 0x1ff) >> 3) + 1; i < 64; i += 1 {
+                ctx.buffer[i] = 0
+            }
+        }
+        ctx.buffer[(ctx.databitlen & 0x1ff) >> 3] |= 1 << (7 - (ctx.databitlen & 7))
+        JH_F8(ctx)
+        for i := 0; i < 64; i += 1 {
+            ctx.buffer[i] = 0
+        }
+        ctx.buffer[63] = byte(ctx.databitlen)       & 0xff
+        ctx.buffer[62] = byte(ctx.databitlen >> 8)  & 0xff
+        ctx.buffer[61] = byte(ctx.databitlen >> 16) & 0xff
+        ctx.buffer[60] = byte(ctx.databitlen >> 24) & 0xff
+        ctx.buffer[59] = byte(ctx.databitlen >> 32) & 0xff
+        ctx.buffer[58] = byte(ctx.databitlen >> 40) & 0xff
+        ctx.buffer[57] = byte(ctx.databitlen >> 48) & 0xff
+        ctx.buffer[56] = byte(ctx.databitlen >> 56) & 0xff
+        JH_F8(ctx)
+    }
+    switch ctx.hashbitlen {
+        case 224: copy(hash[:], ctx.H[100:128])
+        case 256: copy(hash[:], ctx.H[96:128])
+        case 384: copy(hash[:], ctx.H[80:128])
+        case 512: copy(hash[:], ctx.H[64:128])
+    }
+}

core/crypto/keccak/keccak.odin

@@ -0,0 +1,429 @@
+package keccak
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Interface for the Keccak hashing algorithm.
+    This is done because the padding in the SHA3 standard was changed by the NIST, resulting in a different output.
+*/
+
+import "core:os"
+import "core:io"
+
+import "../botan"
+import "../_ctx"
+import "../_sha3"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_28  = hash_bytes_odin_28
+    ctx.hash_file_28   = hash_file_odin_28
+    ctx.hash_stream_28 = hash_stream_odin_28
+    ctx.hash_bytes_32  = hash_bytes_odin_32
+    ctx.hash_file_32   = hash_file_odin_32
+    ctx.hash_stream_32 = hash_stream_odin_32
+    ctx.hash_bytes_48  = hash_bytes_odin_48
+    ctx.hash_file_48   = hash_file_odin_48
+    ctx.hash_stream_48 = hash_stream_odin_48
+    ctx.hash_bytes_64  = hash_bytes_odin_64
+    ctx.hash_file_64   = hash_file_odin_64
+    ctx.hash_stream_64 = hash_stream_odin_64
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan assigns the internal vtable of the hash context to use the Botan bindings
+use_botan :: #force_inline proc() {
+    botan.assign_hash_vtable(_hash_impl, botan.HASH_KECCAK)
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+/*
+    High level API
+*/
+
+// hash_string_224 will hash the given input and return the
+// computed hash
+hash_string_224 :: proc(data: string) -> [28]byte {
+    return hash_bytes_224(transmute([]byte)(data))
+}
+
+// hash_bytes_224 will hash the given input and return the
+// computed hash
+hash_bytes_224 :: proc(data: []byte) -> [28]byte {
+    _create_keccak_ctx(28)
+    return _hash_impl->hash_bytes_28(data)
+}
+
+// hash_stream_224 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_224 :: proc(s: io.Stream) -> ([28]byte, bool) {
+    _create_keccak_ctx(28)
+    return _hash_impl->hash_stream_28(s)
+}
+
+// hash_file_224 will read the file provided by the given handle
+// and compute a hash
+hash_file_224 :: proc(hd: os.Handle, load_at_once := false) -> ([28]byte, bool) {
+    _create_keccak_ctx(28)
+    return _hash_impl->hash_file_28(hd, load_at_once)
+}
+
+hash_224 :: proc {
+    hash_stream_224,
+    hash_file_224,
+    hash_bytes_224,
+    hash_string_224,
+}
+
+// hash_string_256 will hash the given input and return the
+// computed hash
+hash_string_256 :: proc(data: string) -> [32]byte {
+    return hash_bytes_256(transmute([]byte)(data))
+}
+
+// hash_bytes_256 will hash the given input and return the
+// computed hash
+hash_bytes_256 :: proc(data: []byte) -> [32]byte {
+    _create_keccak_ctx(32)
+    return _hash_impl->hash_bytes_32(data)
+}
+
+// hash_stream_256 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_256 :: proc(s: io.Stream) -> ([32]byte, bool) {
+    _create_keccak_ctx(32)
+    return _hash_impl->hash_stream_32(s)
+}
+
+// hash_file_256 will read the file provided by the given handle
+// and compute a hash
+hash_file_256 :: proc(hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    _create_keccak_ctx(32)
+    return _hash_impl->hash_file_32(hd, load_at_once)
+}
+
+hash_256 :: proc {
+    hash_stream_256,
+    hash_file_256,
+    hash_bytes_256,
+    hash_string_256,
+}
+
+// hash_string_384 will hash the given input and return the
+// computed hash
+hash_string_384 :: proc(data: string) -> [48]byte {
+    return hash_bytes_384(transmute([]byte)(data))
+}
+
+// hash_bytes_384 will hash the given input and return the
+// computed hash
+hash_bytes_384 :: proc(data: []byte) -> [48]byte {
+    _create_keccak_ctx(48)
+    return _hash_impl->hash_bytes_48(data)
+}
+
+// hash_stream_384 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_384 :: proc(s: io.Stream) -> ([48]byte, bool) {
+    _create_keccak_ctx(48)
+    return _hash_impl->hash_stream_48(s)
+}
+
+// hash_file_384 will read the file provided by the given handle
+// and compute a hash
+hash_file_384 :: proc(hd: os.Handle, load_at_once := false) -> ([48]byte, bool) {
+    _create_keccak_ctx(48)
+    return _hash_impl->hash_file_48(hd, load_at_once)
+}
+
+hash_384 :: proc {
+    hash_stream_384,
+    hash_file_384,
+    hash_bytes_384,
+    hash_string_384,
+}
+
+// hash_string_512 will hash the given input and return the
+// computed hash
+hash_string_512 :: proc(data: string) -> [64]byte {
+    return hash_bytes_512(transmute([]byte)(data))
+}
+
+// hash_bytes_512 will hash the given input and return the
+// computed hash
+hash_bytes_512 :: proc(data: []byte) -> [64]byte {
+    _create_keccak_ctx(64)
+    return _hash_impl->hash_bytes_64(data)
+}
+
+// hash_stream_512 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_512 :: proc(s: io.Stream) -> ([64]byte, bool) {
+    _create_keccak_ctx(64)
+    return _hash_impl->hash_stream_64(s)
+}
+
+// hash_file_512 will read the file provided by the given handle
+// and compute a hash
+hash_file_512 :: proc(hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    _create_keccak_ctx(64)
+    return _hash_impl->hash_file_64(hd, load_at_once)
+}
+
+hash_512 :: proc {
+    hash_stream_512,
+    hash_file_512,
+    hash_bytes_512,
+    hash_string_512,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [28]byte {
+    hash: [28]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        _sha3.update_odin(&c, data)
+        _sha3.final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([28]byte, bool) {
+    hash: [28]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _sha3.update_odin(&c, buf[:read])
+            } 
+        }
+        _sha3.final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([28]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_28(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_28(ctx, buf[:]), ok
+        }
+    }
+    return [28]byte{}, false
+}
+
+hash_bytes_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [32]byte {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        _sha3.update_odin(&c, data)
+        _sha3.final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([32]byte, bool) {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _sha3.update_odin(&c, buf[:read])
+            } 
+        }
+        _sha3.final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_32(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_32(ctx, buf[:]), ok
+        }
+    }
+    return [32]byte{}, false
+}
+
+hash_bytes_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [48]byte {
+    hash: [48]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        _sha3.update_odin(&c, data)
+        _sha3.final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([48]byte, bool) {
+    hash: [48]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _sha3.update_odin(&c, buf[:read])
+            } 
+        }
+        _sha3.final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([48]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_48(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_48(ctx, buf[:]), ok
+        }
+    }
+    return [48]byte{}, false
+}
+
+hash_bytes_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [64]byte {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        _sha3.update_odin(&c, data)
+        _sha3.final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([64]byte, bool) {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _sha3.update_odin(&c, buf[:read])
+            } 
+        }
+        _sha3.final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_64(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_64(ctx, buf[:]), ok
+        }
+    }
+    return [64]byte{}, false
+}
+
+@(private)
+_create_keccak_ctx :: #force_inline proc(mdlen: int) {
+    ctx: _sha3.Sha3_Context
+    ctx.mdlen               = mdlen
+    ctx.is_keccak           = true
+    _hash_impl.internal_ctx = ctx
+    switch mdlen {
+        case 28: _hash_impl.hash_size = ._28
+        case 32: _hash_impl.hash_size = ._32
+        case 48: _hash_impl.hash_size = ._48
+        case 64: _hash_impl.hash_size = ._64
+    }
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    #partial switch ctx.hash_size {
+        case ._28: _create_keccak_ctx(28)
+        case ._32: _create_keccak_ctx(32)
+        case ._48: _create_keccak_ctx(48)
+        case ._64: _create_keccak_ctx(64)
+    }
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.final_odin(&c, hash)
+    }
+}

core/crypto/md2/md2.odin

@@ -0,0 +1,262 @@
+package md2
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Implementation of the MD2 hashing algorithm, as defined in RFC 1319 <https://datatracker.ietf.org/doc/html/rfc1319>
+*/
+
+import "core:os"
+import "core:io"
+
+import "../_ctx"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_16  = hash_bytes_odin
+    ctx.hash_file_16   = hash_file_odin
+    ctx.hash_stream_16 = hash_stream_odin
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan does nothing, since MD2 is not available in Botan
+@(warning="MD2 is not provided by the Botan API. Odin implementation will be used")
+use_botan :: #force_inline proc() {
+    use_odin()
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+/*
+    High level API
+*/
+
+// hash_string will hash the given input and return the
+// computed hash
+hash_string :: proc(data: string) -> [16]byte {
+    return hash_bytes(transmute([]byte)(data))
+}
+
+// hash_bytes will hash the given input and return the
+// computed hash
+hash_bytes :: proc(data: []byte) -> [16]byte {
+	_create_md2_ctx()
+    return _hash_impl->hash_bytes_16(data)
+}
+
+// hash_stream will read the stream in chunks and compute a
+// hash from its contents
+hash_stream :: proc(s: io.Stream) -> ([16]byte, bool) {
+	_create_md2_ctx()
+    return _hash_impl->hash_stream_16(s)
+}
+
+// hash_file will read the file provided by the given handle
+// and compute a hash
+hash_file :: proc(hd: os.Handle, load_at_once := false) -> ([16]byte, bool) {
+	_create_md2_ctx()
+    return _hash_impl->hash_file_16(hd, load_at_once)
+}
+
+hash :: proc {
+    hash_stream,
+    hash_file,
+    hash_bytes,
+    hash_string,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [16]byte {
+    hash: [16]byte
+    if c, ok := ctx.internal_ctx.(Md2_Context); ok {
+    	init_odin(&c)
+    	update_odin(&c, data)
+    	final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([16]byte, bool) {
+    hash: [16]byte
+    if c, ok := ctx.internal_ctx.(Md2_Context); ok {
+    	init_odin(&c)
+	    buf := make([]byte, 512)
+	    defer delete(buf)
+	    read := 1
+	    for read > 0 {
+	        read, _ = fs->impl_read(buf)
+	        if read > 0 {
+	            update_odin(&c, buf[:read])
+	        } 
+	    }
+	    final_odin(&c, hash[:])
+	    return hash, true
+    } else {
+    	return hash, false
+    }
+}
+
+hash_file_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([16]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin(ctx, buf[:]), ok
+        }
+    }
+    return [16]byte{}, false
+}
+
+@(private)
+_create_md2_ctx :: #force_inline proc() {
+	ctx: Md2_Context
+	_hash_impl.internal_ctx = ctx
+	_hash_impl.hash_size    = ._16
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    _create_md2_ctx()
+    if c, ok := ctx.internal_ctx.(Md2_Context); ok {
+    	init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(Md2_Context); ok {
+    	update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(Md2_Context); ok {
+    	final_odin(&c, hash)
+    }
+}
+
+/*
+    MD2 implementation
+*/
+
+Md2_Context :: struct {
+    data:     [16]byte,
+    state:    [16 * 3]byte,
+    checksum: [16]byte,
+    datalen:  int,
+}
+
+PI_TABLE := [?]byte {
+	41,  46,  67,  201, 162, 216, 124, 1,   61,  54,  84,  161, 236, 240, 6,
+	19,  98,  167, 5,   243, 192, 199, 115, 140, 152, 147, 43,  217, 188, 76,
+	130, 202, 30,  155, 87,  60,  253, 212, 224, 22,  103, 66,  111, 24,  138, 
+	23,  229, 18,  190, 78,  196, 214, 218, 158, 222, 73,  160, 251, 245, 142,
+	187, 47,  238, 122, 169, 104, 121, 145, 21,  178, 7,   63,  148, 194, 16,
+	137, 11,  34,  95,  33,  128, 127, 93,  154, 90,  144, 50,  39,  53,  62, 
+	204, 231, 191, 247, 151, 3,   255, 25,  48,  179, 72,  165, 181, 209, 215,
+	94,  146, 42,  172, 86,  170, 198, 79,  184, 56,  210, 150, 164, 125, 182,
+	118, 252, 107, 226, 156, 116, 4,   241, 69,  157, 112, 89,  100, 113, 135,
+	32,  134, 91,  207, 101, 230, 45,  168, 2,   27,  96,  37,  173, 174, 176,
+	185, 246, 28,  70,  97,  105, 52,  64,  126, 15,  85,  71,  163, 35,  221,
+	81,  175, 58,  195, 92,  249, 206, 186, 197, 234, 38,  44,  83,  13,  110,
+	133, 40,  132, 9,   211, 223, 205, 244, 65,  129, 77,  82,  106, 220, 55,
+	200, 108, 193, 171, 250, 36,  225, 123, 8,   12,  189, 177, 74,  120, 136,
+	149, 139, 227, 99,  232, 109, 233, 203, 213, 254, 59,  0,   29,  57,  242,
+	239, 183, 14,  102, 88,  208, 228, 166, 119, 114, 248, 235, 117, 75,  10,
+	49,  68,  80,  180, 143, 237, 31,  26,  219, 153, 141, 51,  159, 17,  131,
+	20,
+}
+
+transform :: proc(ctx: ^Md2_Context, data: []byte) {
+    j,k,t: byte
+	for j = 0; j < 16; j += 1 {
+		ctx.state[j + 16] = data[j]
+		ctx.state[j + 16 * 2] = (ctx.state[j + 16] ~ ctx.state[j])
+	}
+	t = 0
+	for j = 0; j < 16 + 2; j += 1 {
+		for k = 0; k < 16 * 3; k += 1 {
+			ctx.state[k] ~= PI_TABLE[t]
+			t = ctx.state[k]
+		}
+		t = (t + j) & 0xff
+	}
+	t = ctx.checksum[16 - 1]
+	for j = 0; j < 16; j += 1 {
+		ctx.checksum[j] ~= PI_TABLE[data[j] ~ t]
+		t = ctx.checksum[j]
+	}
+}
+
+init_odin :: proc(ctx: ^Md2_Context) {
+	// No action needed here
+}
+
+update_odin :: proc(ctx: ^Md2_Context, data: []byte) {
+	for i := 0; i < len(data); i += 1 {
+		ctx.data[ctx.datalen] = data[i]
+		ctx.datalen += 1
+		if (ctx.datalen == 16) {
+			transform(ctx, ctx.data[:])
+			ctx.datalen = 0
+		}
+	}
+}
+
+final_odin :: proc(ctx: ^Md2_Context, hash: []byte) {
+	to_pad := byte(16 - ctx.datalen)
+    for ctx.datalen < 16 {
+        ctx.data[ctx.datalen] = to_pad
+		ctx.datalen += 1
+    }
+	transform(ctx, ctx.data[:])
+	transform(ctx, ctx.checksum[:])
+    for i := 0; i < 16; i += 1 {
+        hash[i] = ctx.state[i]
+    }
+}

core/crypto/md4/md4.odin

@@ -0,0 +1,342 @@
+package md4
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Implementation of the MD4 hashing algorithm, as defined in RFC 1320 <https://datatracker.ietf.org/doc/html/rfc1320>
+*/
+
+import "core:mem"
+import "core:os"
+import "core:io"
+
+import "../util"
+import "../botan"
+import "../_ctx"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_16  = hash_bytes_odin
+    ctx.hash_file_16   = hash_file_odin
+    ctx.hash_stream_16 = hash_stream_odin
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan assigns the internal vtable of the hash context to use the Botan bindings
+use_botan :: #force_inline proc() {
+    botan.assign_hash_vtable(_hash_impl, botan.HASH_MD4)
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+/*
+    High level API
+*/
+
+// hash_string will hash the given input and return the
+// computed hash
+hash_string :: proc(data: string) -> [16]byte {
+    return hash_bytes(transmute([]byte)(data))
+}
+
+// hash_bytes will hash the given input and return the
+// computed hash
+hash_bytes :: proc(data: []byte) -> [16]byte {
+    _create_md4_ctx()
+    return _hash_impl->hash_bytes_16(data)
+}
+
+// hash_stream will read the stream in chunks and compute a
+// hash from its contents
+hash_stream :: proc(s: io.Stream) -> ([16]byte, bool) {
+    _create_md4_ctx()
+    return _hash_impl->hash_stream_16(s)
+}
+
+// hash_file will read the file provided by the given handle
+// and compute a hash
+hash_file :: proc(hd: os.Handle, load_at_once := false) -> ([16]byte, bool) {
+    _create_md4_ctx()
+    return _hash_impl->hash_file_16(hd, load_at_once)
+}
+
+hash :: proc {
+    hash_stream,
+    hash_file,
+    hash_bytes,
+    hash_string,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [16]byte {
+    hash: [16]byte
+    if c, ok := ctx.internal_ctx.(Md4_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([16]byte, bool) {
+    hash: [16]byte
+    if c, ok := ctx.internal_ctx.(Md4_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([16]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin(ctx, buf[:]), ok
+        }
+    }
+    return [16]byte{}, false
+}
+
+@(private)
+_create_md4_ctx :: #force_inline proc() {
+    ctx: Md4_Context
+    _hash_impl.internal_ctx = ctx
+    _hash_impl.hash_size    = ._16
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    _create_md4_ctx()
+    if c, ok := ctx.internal_ctx.(Md4_Context); ok {
+        init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(Md4_Context); ok {
+        update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(Md4_Context); ok {
+        final_odin(&c, hash)
+    }
+}
+
+/*
+    MD4 implementation
+*/
+
+BLOCK_SIZE  :: 64
+
+Md4_Context :: struct {
+    data:    [64]byte,
+    state:   [4]u32,
+    bitlen:  u64,
+    datalen: u32,
+}
+
+/*
+    @note(zh): F, G and H, as mentioned in the RFC, have been inlined into FF, GG 
+    and HH respectively, instead of declaring them separately.
+*/
+
+FF :: #force_inline proc "contextless"(a, b, c, d, x: u32, s : int) -> u32 {
+    return util.ROTL32(a + ((b & c) | (~b & d)) + x, s)
+}
+
+GG :: #force_inline proc "contextless"(a, b, c, d, x: u32, s : int) -> u32 {
+    return util.ROTL32(a + ((b & c) | (b & d) | (c & d)) + x + 0x5a827999, s)
+}
+
+HH :: #force_inline proc "contextless"(a, b, c, d, x: u32, s : int) -> u32 {
+    return util.ROTL32(a + (b ~ c ~ d) + x + 0x6ed9eba1, s)
+}
+
+transform :: proc(ctx: ^Md4_Context, data: []byte) {
+    a, b, c, d, i, j: u32
+    m: [16]u32
+
+    for i, j = 0, 0; i < 16; i += 1 {
+        m[i] = u32(data[j]) | (u32(data[j + 1]) << 8) | (u32(data[j + 2]) << 16) | (u32(data[j + 3]) << 24)
+        j += 4
+    }
+
+    a = ctx.state[0]
+    b = ctx.state[1]
+    c = ctx.state[2]
+    d = ctx.state[3]
+
+    a = FF(a, b, c, d, m[0],  3)
+    d = FF(d, a, b, c, m[1],  7)
+    c = FF(c, d, a, b, m[2],  11)
+    b = FF(b, c, d, a, m[3],  19)
+    a = FF(a, b, c, d, m[4],  3)
+    d = FF(d, a, b, c, m[5],  7)
+    c = FF(c, d, a, b, m[6],  11)
+    b = FF(b, c, d, a, m[7],  19)
+    a = FF(a, b, c, d, m[8],  3)
+    d = FF(d, a, b, c, m[9],  7)
+    c = FF(c, d, a, b, m[10], 11)
+    b = FF(b, c, d, a, m[11], 19)
+    a = FF(a, b, c, d, m[12], 3)
+    d = FF(d, a, b, c, m[13], 7)
+    c = FF(c, d, a, b, m[14], 11)
+    b = FF(b, c, d, a, m[15], 19)
+
+    a = GG(a, b, c, d, m[0],  3)
+    d = GG(d, a, b, c, m[4],  5)
+    c = GG(c, d, a, b, m[8],  9)
+    b = GG(b, c, d, a, m[12], 13)
+    a = GG(a, b, c, d, m[1],  3)
+    d = GG(d, a, b, c, m[5],  5)
+    c = GG(c, d, a, b, m[9],  9)
+    b = GG(b, c, d, a, m[13], 13)
+    a = GG(a, b, c, d, m[2],  3)
+    d = GG(d, a, b, c, m[6],  5)
+    c = GG(c, d, a, b, m[10], 9)
+    b = GG(b, c, d, a, m[14], 13)
+    a = GG(a, b, c, d, m[3],  3)
+    d = GG(d, a, b, c, m[7],  5)
+    c = GG(c, d, a, b, m[11], 9)
+    b = GG(b, c, d, a, m[15], 13)
+
+    a = HH(a, b, c, d, m[0],  3)
+    d = HH(d, a, b, c, m[8],  9)
+    c = HH(c, d, a, b, m[4],  11)
+    b = HH(b, c, d, a, m[12], 15)
+    a = HH(a, b, c, d, m[2],  3)
+    d = HH(d, a, b, c, m[10], 9)
+    c = HH(c, d, a, b, m[6],  11)
+    b = HH(b, c, d, a, m[14], 15)
+    a = HH(a, b, c, d, m[1],  3)
+    d = HH(d, a, b, c, m[9],  9)
+    c = HH(c, d, a, b, m[5],  11)
+    b = HH(b, c, d, a, m[13], 15)
+    a = HH(a, b, c, d, m[3],  3)
+    d = HH(d, a, b, c, m[11], 9)
+    c = HH(c, d, a, b, m[7],  11)
+    b = HH(b, c, d, a, m[15], 15)
+
+    ctx.state[0] += a
+    ctx.state[1] += b
+    ctx.state[2] += c
+    ctx.state[3] += d
+}
+
+init_odin :: proc(ctx: ^Md4_Context) {
+    ctx.state[0] = 0x67452301
+    ctx.state[1] = 0xefcdab89
+    ctx.state[2] = 0x98badcfe
+    ctx.state[3] = 0x10325476
+}
+
+update_odin :: proc(ctx: ^Md4_Context, data: []byte) {
+    for i := 0; i < len(data); i += 1 {
+        ctx.data[ctx.datalen] = data[i]
+        ctx.datalen += 1
+        if(ctx.datalen == BLOCK_SIZE) {
+            transform(ctx, ctx.data[:])
+            ctx.bitlen += 512
+            ctx.datalen = 0
+        }
+    }
+}
+
+final_odin :: proc(ctx: ^Md4_Context, hash: []byte) {
+    i := ctx.datalen
+    if ctx.datalen < 56 {
+        ctx.data[i] = 0x80
+        i += 1
+        for i < 56 {
+            ctx.data[i] = 0x00
+            i += 1
+        }
+    } else if ctx.datalen >= 56 {
+        ctx.data[i] = 0x80
+        i += 1
+        for i < BLOCK_SIZE {
+            ctx.data[i] = 0x00
+            i += 1
+        }
+        transform(ctx, ctx.data[:])
+        mem.set(&ctx.data, 0, 56)
+    }
+
+    ctx.bitlen  += u64(ctx.datalen * 8)
+    ctx.data[56] = byte(ctx.bitlen)
+    ctx.data[57] = byte(ctx.bitlen >> 8)
+    ctx.data[58] = byte(ctx.bitlen >> 16)
+    ctx.data[59] = byte(ctx.bitlen >> 24)
+    ctx.data[60] = byte(ctx.bitlen >> 32)
+    ctx.data[61] = byte(ctx.bitlen >> 40)
+    ctx.data[62] = byte(ctx.bitlen >> 48)
+    ctx.data[63] = byte(ctx.bitlen >> 56)
+    transform(ctx, ctx.data[:])
+
+    for i = 0; i < 4; i += 1 {
+		hash[i]      = byte(ctx.state[0] >> (i * 8)) & 0x000000ff
+		hash[i + 4]  = byte(ctx.state[1] >> (i * 8)) & 0x000000ff
+		hash[i + 8]  = byte(ctx.state[2] >> (i * 8)) & 0x000000ff
+		hash[i + 12] = byte(ctx.state[3] >> (i * 8)) & 0x000000ff
+    }
+}

core/crypto/md5/md5.odin

@@ -0,0 +1,365 @@
+package md5
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Implementation of the MD5 hashing algorithm, as defined in RFC 1321 <https://datatracker.ietf.org/doc/html/rfc1321>
+*/
+
+import "core:mem"
+import "core:os"
+import "core:io"
+
+import "../util"
+import "../botan"
+import "../_ctx"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_16  = hash_bytes_odin
+    ctx.hash_file_16   = hash_file_odin
+    ctx.hash_stream_16 = hash_stream_odin
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan assigns the internal vtable of the hash context to use the Botan bindings
+use_botan :: #force_inline proc() {
+    botan.assign_hash_vtable(_hash_impl, botan.HASH_MD5)
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+/*
+    High level API
+*/
+
+// hash_string will hash the given input and return the
+// computed hash
+hash_string :: proc(data: string) -> [16]byte {
+    return hash_bytes(transmute([]byte)(data))
+}
+
+// hash_bytes will hash the given input and return the
+// computed hash
+hash_bytes :: proc(data: []byte) -> [16]byte {
+    _create_md5_ctx()
+    return _hash_impl->hash_bytes_16(data)
+}
+
+// hash_stream will read the stream in chunks and compute a
+// hash from its contents
+hash_stream :: proc(s: io.Stream) -> ([16]byte, bool) {
+    _create_md5_ctx()
+    return _hash_impl->hash_stream_16(s)
+}
+
+// hash_file will read the file provided by the given handle
+// and compute a hash
+hash_file :: proc(hd: os.Handle, load_at_once := false) -> ([16]byte, bool) {
+    _create_md5_ctx()
+    return _hash_impl->hash_file_16(hd, load_at_once)
+}
+
+hash :: proc {
+    hash_stream,
+    hash_file,
+    hash_bytes,
+    hash_string,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [16]byte {
+    hash: [16]byte
+    if c, ok := ctx.internal_ctx.(Md5_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([16]byte, bool) {
+    hash: [16]byte
+    if c, ok := ctx.internal_ctx.(Md5_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([16]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin(ctx, buf[:]), ok
+        }
+    }
+    return [16]byte{}, false
+}
+
+@(private)
+_create_md5_ctx :: #force_inline proc() {
+    ctx: Md5_Context
+    _hash_impl.internal_ctx = ctx
+    _hash_impl.hash_size    = ._16
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    _create_md5_ctx()
+    if c, ok := ctx.internal_ctx.(Md5_Context); ok {
+        init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(Md5_Context); ok {
+        update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(Md5_Context); ok {
+        final_odin(&c, hash)
+    }
+}
+
+/*
+    MD4 implementation
+*/
+
+BLOCK_SIZE  :: 64
+
+Md5_Context :: struct {
+    data:    [BLOCK_SIZE]byte,
+    state:   [4]u32,
+    bitlen:  u64,
+    datalen: u32,
+}
+
+/*
+    @note(zh): F, G, H and I, as mentioned in the RFC, have been inlined into FF, GG, HH 
+    and II respectively, instead of declaring them separately.
+*/
+
+FF :: #force_inline proc "contextless" (a, b, c, d, m: u32, s: int, t: u32) -> u32 {
+    return b + util.ROTL32(a + ((b & c) | (~b & d)) + m + t, s)
+}
+
+GG :: #force_inline proc "contextless" (a, b, c, d, m: u32, s: int, t: u32) -> u32 {
+    return b + util.ROTL32(a + ((b & d) | (c & ~d)) + m + t, s)
+}
+
+HH :: #force_inline proc "contextless" (a, b, c, d, m: u32, s: int, t: u32) -> u32 {
+    return b + util.ROTL32(a + (b ~ c ~ d) + m + t, s)
+}
+
+II :: #force_inline proc "contextless" (a, b, c, d, m: u32, s: int, t: u32) -> u32 {
+    return b + util.ROTL32(a + (c ~ (b | ~d)) + m + t, s)
+}
+
+transform :: proc(ctx: ^Md5_Context, data: []byte) {
+    i, j: u32
+    m: [16]u32
+
+    for i, j = 0, 0; i < 16; i+=1 {
+        m[i] = u32(data[j]) + u32(data[j + 1]) << 8 + u32(data[j + 2]) << 16 + u32(data[j + 3]) << 24
+        j += 4
+    }
+
+    a := ctx.state[0]
+    b := ctx.state[1]
+    c := ctx.state[2]
+    d := ctx.state[3]
+
+    a = FF(a, b, c, d, m[0],   7, 0xd76aa478)
+    d = FF(d, a, b, c, m[1],  12, 0xe8c7b756)
+    c = FF(c, d, a, b, m[2],  17, 0x242070db)
+    b = FF(b, c, d, a, m[3],  22, 0xc1bdceee)
+    a = FF(a, b, c, d, m[4],   7, 0xf57c0faf)
+    d = FF(d, a, b, c, m[5],  12, 0x4787c62a)
+    c = FF(c, d, a, b, m[6],  17, 0xa8304613)
+    b = FF(b, c, d, a, m[7],  22, 0xfd469501)
+    a = FF(a, b, c, d, m[8],   7, 0x698098d8)
+    d = FF(d, a, b, c, m[9],  12, 0x8b44f7af)
+    c = FF(c, d, a, b, m[10], 17, 0xffff5bb1)
+    b = FF(b, c, d, a, m[11], 22, 0x895cd7be)
+    a = FF(a, b, c, d, m[12],  7, 0x6b901122)
+    d = FF(d, a, b, c, m[13], 12, 0xfd987193)
+    c = FF(c, d, a, b, m[14], 17, 0xa679438e)
+    b = FF(b, c, d, a, m[15], 22, 0x49b40821)
+
+    a = GG(a, b, c, d, m[1],   5, 0xf61e2562)
+    d = GG(d, a, b, c, m[6],   9, 0xc040b340)
+    c = GG(c, d, a, b, m[11], 14, 0x265e5a51)
+    b = GG(b, c, d, a, m[0],  20, 0xe9b6c7aa)
+    a = GG(a, b, c, d, m[5],   5, 0xd62f105d)
+    d = GG(d, a, b, c, m[10],  9, 0x02441453)
+    c = GG(c, d, a, b, m[15], 14, 0xd8a1e681)
+    b = GG(b, c, d, a, m[4],  20, 0xe7d3fbc8)
+    a = GG(a, b, c, d, m[9],   5, 0x21e1cde6)
+    d = GG(d, a, b, c, m[14],  9, 0xc33707d6)
+    c = GG(c, d, a, b, m[3],  14, 0xf4d50d87)
+    b = GG(b, c, d, a, m[8],  20, 0x455a14ed)
+    a = GG(a, b, c, d, m[13],  5, 0xa9e3e905)
+    d = GG(d, a, b, c, m[2],   9, 0xfcefa3f8)
+    c = GG(c, d, a, b, m[7],  14, 0x676f02d9)
+    b = GG(b, c, d, a, m[12], 20, 0x8d2a4c8a)
+
+    a = HH(a, b, c, d, m[5],   4, 0xfffa3942)
+    d = HH(d, a, b, c, m[8],  11, 0x8771f681)
+    c = HH(c, d, a, b, m[11], 16, 0x6d9d6122)
+    b = HH(b, c, d, a, m[14], 23, 0xfde5380c)
+    a = HH(a, b, c, d, m[1],   4, 0xa4beea44)
+    d = HH(d, a, b, c, m[4],  11, 0x4bdecfa9)
+    c = HH(c, d, a, b, m[7],  16, 0xf6bb4b60)
+    b = HH(b, c, d, a, m[10], 23, 0xbebfbc70)
+    a = HH(a, b, c, d, m[13],  4, 0x289b7ec6)
+    d = HH(d, a, b, c, m[0],  11, 0xeaa127fa)
+    c = HH(c, d, a, b, m[3],  16, 0xd4ef3085)
+    b = HH(b, c, d, a, m[6],  23, 0x04881d05)
+    a = HH(a, b, c, d, m[9],   4, 0xd9d4d039)
+    d = HH(d, a, b, c, m[12], 11, 0xe6db99e5)
+    c = HH(c, d, a, b, m[15], 16, 0x1fa27cf8)
+    b = HH(b, c, d, a, m[2],  23, 0xc4ac5665)
+
+    a = II(a, b, c, d, m[0],   6, 0xf4292244)
+    d = II(d, a, b, c, m[7],  10, 0x432aff97)
+    c = II(c, d, a, b, m[14], 15, 0xab9423a7)
+    b = II(b, c, d, a, m[5],  21, 0xfc93a039)
+    a = II(a, b, c, d, m[12],  6, 0x655b59c3)
+    d = II(d, a, b, c, m[3],  10, 0x8f0ccc92)
+    c = II(c, d, a, b, m[10], 15, 0xffeff47d)
+    b = II(b, c, d, a, m[1],  21, 0x85845dd1)
+    a = II(a, b, c, d, m[8],   6, 0x6fa87e4f)
+    d = II(d, a, b, c, m[15], 10, 0xfe2ce6e0)
+    c = II(c, d, a, b, m[6],  15, 0xa3014314)
+    b = II(b, c, d, a, m[13], 21, 0x4e0811a1)
+    a = II(a, b, c, d, m[4],   6, 0xf7537e82)
+    d = II(d, a, b, c, m[11], 10, 0xbd3af235)
+    c = II(c, d, a, b, m[2],  15, 0x2ad7d2bb)
+    b = II(b, c, d, a, m[9],  21, 0xeb86d391)
+
+    ctx.state[0] += a
+    ctx.state[1] += b
+    ctx.state[2] += c
+    ctx.state[3] += d
+}
+
+init_odin :: proc(ctx: ^Md5_Context) {
+    ctx.state[0] = 0x67452301
+    ctx.state[1] = 0xefcdab89
+    ctx.state[2] = 0x98badcfe
+    ctx.state[3] = 0x10325476
+}
+
+update_odin :: proc(ctx: ^Md5_Context, data: []byte) {
+    for i := 0; i < len(data); i += 1 {
+        ctx.data[ctx.datalen] = data[i]
+        ctx.datalen += 1
+        if(ctx.datalen == BLOCK_SIZE) {
+            transform(ctx, ctx.data[:])
+            ctx.bitlen += 512
+            ctx.datalen = 0
+        }
+    }
+}
+
+final_odin :: proc(ctx: ^Md5_Context, hash: []byte){
+    i : u32
+    i = ctx.datalen
+
+    if ctx.datalen < 56 {
+        ctx.data[i] = 0x80
+        i += 1
+        for i < 56 {
+            ctx.data[i] = 0x00
+            i += 1
+        }
+    } else if ctx.datalen >= 56 {
+        ctx.data[i] = 0x80
+        i += 1
+        for i < BLOCK_SIZE {
+            ctx.data[i] = 0x00
+            i += 1
+        }
+        transform(ctx, ctx.data[:])
+        mem.set(&ctx.data, 0, 56)
+    }
+
+    ctx.bitlen  += u64(ctx.datalen * 8)
+    ctx.data[56] = byte(ctx.bitlen)
+    ctx.data[57] = byte(ctx.bitlen >> 8)
+    ctx.data[58] = byte(ctx.bitlen >> 16)
+    ctx.data[59] = byte(ctx.bitlen >> 24)
+    ctx.data[60] = byte(ctx.bitlen >> 32)
+    ctx.data[61] = byte(ctx.bitlen >> 40)
+    ctx.data[62] = byte(ctx.bitlen >> 48)
+    ctx.data[63] = byte(ctx.bitlen >> 56)
+    transform(ctx, ctx.data[:])
+
+    for i = 0; i < 4; i += 1 {
+        hash[i]      = byte(ctx.state[0] >> (i * 8)) & 0x000000ff
+        hash[i + 4]  = byte(ctx.state[1] >> (i * 8)) & 0x000000ff
+        hash[i + 8]  = byte(ctx.state[2] >> (i * 8)) & 0x000000ff
+        hash[i + 12] = byte(ctx.state[3] >> (i * 8)) & 0x000000ff
+    }
+}

core/crypto/sha1/sha1.odin

@@ -0,0 +1,326 @@
+package sha1
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Implementation of the SHA1 hashing algorithm, as defined in RFC 3174 <https://datatracker.ietf.org/doc/html/rfc3174>
+*/
+
+import "core:mem"
+import "core:os"
+import "core:io"
+
+import "../util"
+import "../botan"
+import "../_ctx"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_20  = hash_bytes_odin
+    ctx.hash_file_20   = hash_file_odin
+    ctx.hash_stream_20 = hash_stream_odin
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan assigns the internal vtable of the hash context to use the Botan bindings
+use_botan :: #force_inline proc() {
+    botan.assign_hash_vtable(_hash_impl, botan.HASH_SHA1)
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+/*
+    High level API
+*/
+
+// hash_string will hash the given input and return the
+// computed hash
+hash_string :: proc(data: string) -> [20]byte {
+    return hash_bytes(transmute([]byte)(data))
+}
+
+// hash_bytes will hash the given input and return the
+// computed hash
+hash_bytes :: proc(data: []byte) -> [20]byte {
+	_create_sha1_ctx()
+    return _hash_impl->hash_bytes_20(data)
+}
+
+// hash_stream will read the stream in chunks and compute a
+// hash from its contents
+hash_stream :: proc(s: io.Stream) -> ([20]byte, bool) {
+	_create_sha1_ctx()
+    return _hash_impl->hash_stream_20(s)
+}
+
+// hash_file will read the file provided by the given handle
+// and compute a hash
+hash_file :: proc(hd: os.Handle, load_at_once := false) -> ([20]byte, bool) {
+	_create_sha1_ctx()
+    return _hash_impl->hash_file_20(hd, load_at_once)
+}
+
+hash :: proc {
+    hash_stream,
+    hash_file,
+    hash_bytes,
+    hash_string,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [20]byte {
+    hash: [20]byte
+    if c, ok := ctx.internal_ctx.(Sha1_Context); ok {
+    	init_odin(&c)
+    	update_odin(&c, data)
+    	final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([20]byte, bool) {
+    hash: [20]byte
+    if c, ok := ctx.internal_ctx.(Sha1_Context); ok {
+    	init_odin(&c)
+	    buf := make([]byte, 512)
+	    defer delete(buf)
+	    read := 1
+	    for read > 0 {
+	        read, _ = fs->impl_read(buf)
+	        if read > 0 {
+	            update_odin(&c, buf[:read])
+	        } 
+	    }
+	    final_odin(&c, hash[:])
+	    return hash, true
+    } else {
+    	return hash, false
+    }
+}
+
+hash_file_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([20]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin(ctx, buf[:]), ok
+        }
+    }
+    return [20]byte{}, false
+}
+
+@(private)
+_create_sha1_ctx :: #force_inline proc() {
+	ctx: Sha1_Context
+	_hash_impl.internal_ctx = ctx
+	_hash_impl.hash_size    = ._20
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    _create_sha1_ctx()
+    if c, ok := ctx.internal_ctx.(Sha1_Context); ok {
+    	init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(Sha1_Context); ok {
+    	update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(Sha1_Context); ok {
+    	final_odin(&c, hash)
+    }
+}
+
+/*
+    SHA1 implementation
+*/
+
+BLOCK_SIZE  :: 64
+
+Sha1_Context :: struct {
+    data:    [BLOCK_SIZE]byte,
+    datalen: u32,
+    bitlen:  u64,
+    state:   [5]u32,
+    k:       [4]u32,
+}
+
+transform :: proc(ctx: ^Sha1_Context, data: []byte) {
+    a, b, c, d, e, i, j, t: u32
+    m: [80]u32
+
+	for i, j = 0, 0; i < 16; i += 1 {
+        m[i] = u32(data[j]) << 24 + u32(data[j + 1]) << 16 + u32(data[j + 2]) << 8 + u32(data[j + 3])
+        j += 4
+    }
+	for i < 80 {
+		m[i] = (m[i - 3] ~ m[i - 8] ~ m[i - 14] ~ m[i - 16])
+		m[i] = (m[i] << 1) | (m[i] >> 31)
+        i += 1
+	}
+
+	a = ctx.state[0]
+	b = ctx.state[1]
+	c = ctx.state[2]
+	d = ctx.state[3]
+	e = ctx.state[4]
+
+	for i = 0; i < 20; i += 1 {
+		t = util.ROTL32(a, 5) + ((b & c) ~ (~b & d)) + e + ctx.k[0] + m[i]
+		e = d
+		d = c
+		c = util.ROTL32(b, 30)
+		b = a
+		a = t
+	}
+	for i < 40 {
+		t = util.ROTL32(a, 5) + (b ~ c ~ d) + e + ctx.k[1] + m[i]
+		e = d
+		d = c
+		c = util.ROTL32(b, 30)
+		b = a
+		a = t
+        i += 1
+	}
+	for i < 60 {
+		t = util.ROTL32(a, 5) + ((b & c) ~ (b & d) ~ (c & d)) + e + ctx.k[2] + m[i]
+		e = d
+		d = c
+		c = util.ROTL32(b, 30)
+		b = a
+		a = t
+        i += 1
+	}
+	for i < 80 {
+		t = util.ROTL32(a, 5) + (b ~ c ~ d) + e + ctx.k[3] + m[i]
+		e = d
+		d = c
+		c = util.ROTL32(b, 30)
+		b = a
+		a = t
+        i += 1
+	}
+
+	ctx.state[0] += a
+	ctx.state[1] += b
+	ctx.state[2] += c
+	ctx.state[3] += d
+	ctx.state[4] += e
+}
+
+init_odin :: proc(ctx: ^Sha1_Context) {
+	ctx.state[0] = 0x67452301
+	ctx.state[1] = 0xefcdab89
+	ctx.state[2] = 0x98badcfe
+	ctx.state[3] = 0x10325476
+	ctx.state[4] = 0xc3d2e1f0
+	ctx.k[0]     = 0x5a827999
+	ctx.k[1]     = 0x6ed9eba1
+	ctx.k[2]     = 0x8f1bbcdc
+	ctx.k[3]     = 0xca62c1d6
+}
+
+update_odin :: proc(ctx: ^Sha1_Context, data: []byte) {
+	for i := 0; i < len(data); i += 1 {
+		ctx.data[ctx.datalen] = data[i]
+		ctx.datalen += 1
+		if (ctx.datalen == BLOCK_SIZE) {
+			transform(ctx, ctx.data[:])
+			ctx.bitlen += 512
+			ctx.datalen = 0
+		}
+	}
+}
+
+final_odin :: proc(ctx: ^Sha1_Context, hash: []byte) {
+	i := ctx.datalen
+
+	if ctx.datalen < 56 {
+		ctx.data[i] = 0x80
+        i += 1
+        for i < 56 {
+            ctx.data[i] = 0x00
+            i += 1
+        }
+	}
+	else {
+		ctx.data[i] = 0x80
+        i += 1
+        for i < BLOCK_SIZE {
+            ctx.data[i] = 0x00
+            i += 1
+        }
+		transform(ctx, ctx.data[:])
+		mem.set(&ctx.data, 0, 56)
+	}
+
+	ctx.bitlen  += u64(ctx.datalen * 8)
+	ctx.data[63] = u8(ctx.bitlen)
+	ctx.data[62] = u8(ctx.bitlen >> 8)
+	ctx.data[61] = u8(ctx.bitlen >> 16)
+	ctx.data[60] = u8(ctx.bitlen >> 24)
+	ctx.data[59] = u8(ctx.bitlen >> 32)
+	ctx.data[58] = u8(ctx.bitlen >> 40)
+	ctx.data[57] = u8(ctx.bitlen >> 48)
+	ctx.data[56] = u8(ctx.bitlen >> 56)
+	transform(ctx, ctx.data[:])
+
+	for j: u32 = 0; j < 4; j += 1 {
+		hash[j]      = u8(ctx.state[0] >> (24 - j * 8)) & 0x000000ff
+		hash[j + 4]  = u8(ctx.state[1] >> (24 - j * 8)) & 0x000000ff
+		hash[j + 8]  = u8(ctx.state[2] >> (24 - j * 8)) & 0x000000ff
+		hash[j + 12] = u8(ctx.state[3] >> (24 - j * 8)) & 0x000000ff
+		hash[j + 16] = u8(ctx.state[4] >> (24 - j * 8)) & 0x000000ff
+	}
+}

core/crypto/sha2/sha2.odin

@@ -0,0 +1,785 @@
+package sha2
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Implementation of the SHA2 hashing algorithm, as defined in <https://csrc.nist.gov/csrc/media/publications/fips/180/2/archive/2002-08-01/documents/fips180-2.pdf>
+    and in RFC 3874 <https://datatracker.ietf.org/doc/html/rfc3874>
+*/
+
+import "core:mem"
+import "core:os"
+import "core:io"
+
+import "../util"
+import "../botan"
+import "../_ctx"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_28  = hash_bytes_odin_28
+    ctx.hash_file_28   = hash_file_odin_28
+    ctx.hash_stream_28 = hash_stream_odin_28
+    ctx.hash_bytes_32  = hash_bytes_odin_32
+    ctx.hash_file_32   = hash_file_odin_32
+    ctx.hash_stream_32 = hash_stream_odin_32
+    ctx.hash_bytes_48  = hash_bytes_odin_48
+    ctx.hash_file_48   = hash_file_odin_48
+    ctx.hash_stream_48 = hash_stream_odin_48
+    ctx.hash_bytes_64  = hash_bytes_odin_64
+    ctx.hash_file_64   = hash_file_odin_64
+    ctx.hash_stream_64 = hash_stream_odin_64
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan assigns the internal vtable of the hash context to use the Botan bindings
+use_botan :: #force_inline proc() {
+    botan.assign_hash_vtable(_hash_impl, botan.HASH_SHA2)
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+@(private)
+_create_sha256_ctx :: #force_inline proc(is224: bool) {
+	ctx: Sha256_Context
+	ctx.is224 = is224
+	_hash_impl.internal_ctx = ctx
+	_hash_impl.hash_size    = is224 ? ._28 : ._32
+}
+
+@(private)
+_create_sha512_ctx :: #force_inline proc(is384: bool) {
+	ctx: Sha512_Context
+	ctx.is384 = is384
+	_hash_impl.internal_ctx = ctx
+	_hash_impl.hash_size    = is384 ? ._48 : ._64
+}
+
+/*
+    High level API
+*/
+
+// hash_string_224 will hash the given input and return the
+// computed hash
+hash_string_224 :: proc(data: string) -> [28]byte {
+    return hash_bytes_224(transmute([]byte)(data))
+}
+
+// hash_bytes_224 will hash the given input and return the
+// computed hash
+hash_bytes_224 :: proc(data: []byte) -> [28]byte {
+	_create_sha256_ctx(true)
+    return _hash_impl->hash_bytes_28(data)
+}
+
+// hash_stream_224 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_224 :: proc(s: io.Stream) -> ([28]byte, bool) {
+	_create_sha256_ctx(true)
+    return _hash_impl->hash_stream_28(s)
+}
+
+// hash_file_224 will read the file provided by the given handle
+// and compute a hash
+hash_file_224 :: proc(hd: os.Handle, load_at_once := false) -> ([28]byte, bool) {
+	_create_sha256_ctx(true)
+    return _hash_impl->hash_file_28(hd, load_at_once)
+}
+
+hash_224 :: proc {
+    hash_stream_224,
+    hash_file_224,
+    hash_bytes_224,
+    hash_string_224,
+}
+
+// hash_string_256 will hash the given input and return the
+// computed hash
+hash_string_256 :: proc(data: string) -> [32]byte {
+    return hash_bytes_256(transmute([]byte)(data))
+}
+
+// hash_bytes_256 will hash the given input and return the
+// computed hash
+hash_bytes_256 :: proc(data: []byte) -> [32]byte {
+	_create_sha256_ctx(false)
+    return _hash_impl->hash_bytes_32(data)
+}
+
+// hash_stream_256 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_256 :: proc(s: io.Stream) -> ([32]byte, bool) {
+	_create_sha256_ctx(false)
+    return _hash_impl->hash_stream_32(s)
+}
+
+// hash_file_256 will read the file provided by the given handle
+// and compute a hash
+hash_file_256 :: proc(hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+	_create_sha256_ctx(false)
+    return _hash_impl->hash_file_32(hd, load_at_once)
+}
+
+hash_256 :: proc {
+    hash_stream_256,
+    hash_file_256,
+    hash_bytes_256,
+    hash_string_256,
+}
+
+// hash_string_384 will hash the given input and return the
+// computed hash
+hash_string_384 :: proc(data: string) -> [48]byte {
+    return hash_bytes_384(transmute([]byte)(data))
+}
+
+// hash_bytes_384 will hash the given input and return the
+// computed hash
+hash_bytes_384 :: proc(data: []byte) -> [48]byte {
+	_create_sha512_ctx(true)
+    return _hash_impl->hash_bytes_48(data)
+}
+
+// hash_stream_384 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_384 :: proc(s: io.Stream) -> ([48]byte, bool) {
+	_create_sha512_ctx(true)
+    return _hash_impl->hash_stream_48(s)
+}
+
+// hash_file_384 will read the file provided by the given handle
+// and compute a hash
+hash_file_384 :: proc(hd: os.Handle, load_at_once := false) -> ([48]byte, bool) {
+	_create_sha512_ctx(true)
+    return _hash_impl->hash_file_48(hd, load_at_once)
+}
+
+hash_384 :: proc {
+    hash_stream_384,
+    hash_file_384,
+    hash_bytes_384,
+    hash_string_384,
+}
+
+// hash_string_512 will hash the given input and return the
+// computed hash
+hash_string_512 :: proc(data: string) -> [64]byte {
+    return hash_bytes_512(transmute([]byte)(data))
+}
+
+// hash_bytes_512 will hash the given input and return the
+// computed hash
+hash_bytes_512 :: proc(data: []byte) -> [64]byte {
+	_create_sha512_ctx(false)
+    return _hash_impl->hash_bytes_64(data)
+}
+
+// hash_stream_512 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_512 :: proc(s: io.Stream) -> ([64]byte, bool) {
+	_create_sha512_ctx(false)
+    return _hash_impl->hash_stream_64(s)
+}
+
+// hash_file_512 will read the file provided by the given handle
+// and compute a hash
+hash_file_512 :: proc(hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+	_create_sha512_ctx(false)
+    return _hash_impl->hash_file_64(hd, load_at_once)
+}
+
+hash_512 :: proc {
+    hash_stream_512,
+    hash_file_512,
+    hash_bytes_512,
+    hash_string_512,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [28]byte {
+    hash: [28]byte
+    if c, ok := ctx.internal_ctx.(Sha256_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([28]byte, bool) {
+    hash: [28]byte
+    if c, ok := ctx.internal_ctx.(Sha256_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([28]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_28(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_28(ctx, buf[:]), ok
+        }
+    }
+    return [28]byte{}, false
+}
+
+hash_bytes_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [32]byte {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(Sha256_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([32]byte, bool) {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(Sha256_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_32(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_32(ctx, buf[:]), ok
+        }
+    }
+    return [32]byte{}, false
+}
+
+hash_bytes_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [48]byte {
+    hash: [48]byte
+    if c, ok := ctx.internal_ctx.(Sha512_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([48]byte, bool) {
+    hash: [48]byte
+    if c, ok := ctx.internal_ctx.(Sha512_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([48]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_48(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_48(ctx, buf[:]), ok
+        }
+    }
+    return [48]byte{}, false
+}
+
+hash_bytes_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [64]byte {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(Sha512_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([64]byte, bool) {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(Sha512_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_64(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_64(ctx, buf[:]), ok
+        }
+    }
+    return [64]byte{}, false
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    if ctx.hash_size == ._28 || ctx.hash_size == ._32 {
+        _create_sha256_ctx(ctx.hash_size == ._28)
+        if c, ok := ctx.internal_ctx.(Sha256_Context); ok {
+            init_odin(&c)
+        }
+        return
+    }
+    if ctx.hash_size == ._48 || ctx.hash_size == ._64 {
+        _create_sha512_ctx(ctx.hash_size == ._48)
+        if c, ok := ctx.internal_ctx.(Sha512_Context); ok {
+            init_odin(&c)
+        }
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    #partial switch ctx.hash_size {
+        case ._28, ._32:
+            if c, ok := ctx.internal_ctx.(Sha256_Context); ok {
+                update_odin(&c, data)
+            }
+        case ._48, ._64:
+            if c, ok := ctx.internal_ctx.(Sha512_Context); ok {
+                update_odin(&c, data)
+            }
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    #partial switch ctx.hash_size {
+        case ._28, ._32:
+            if c, ok := ctx.internal_ctx.(Sha256_Context); ok {
+                final_odin(&c, hash)
+            }
+        case ._48, ._64:
+            if c, ok := ctx.internal_ctx.(Sha512_Context); ok {
+                final_odin(&c, hash)
+            }
+    }
+}
+
+/*
+    SHA2 implementation
+*/
+
+SHA256_BLOCK_SIZE :: 64
+SHA512_BLOCK_SIZE :: 128
+
+Sha256_Context :: struct {
+    tot_len: uint,
+    length:  uint,
+    block:   [128]byte,
+    h:       [8]u32,
+    is224:   bool,
+}
+
+Sha512_Context :: struct {
+    tot_len: uint,
+    length:  uint,
+    block:   [256]byte,
+    h:       [8]u64,
+    is384:   bool,
+}
+
+sha256_k := [64]u32 {
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+    0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+    0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+    0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+    0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+}
+
+sha512_k := [80]u64 {
+    0x428a2f98d728ae22, 0x7137449123ef65cd,
+    0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc,
+    0x3956c25bf348b538, 0x59f111f1b605d019,
+    0x923f82a4af194f9b, 0xab1c5ed5da6d8118,
+    0xd807aa98a3030242, 0x12835b0145706fbe,
+    0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2,
+    0x72be5d74f27b896f, 0x80deb1fe3b1696b1,
+    0x9bdc06a725c71235, 0xc19bf174cf692694,
+    0xe49b69c19ef14ad2, 0xefbe4786384f25e3,
+    0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65,
+    0x2de92c6f592b0275, 0x4a7484aa6ea6e483,
+    0x5cb0a9dcbd41fbd4, 0x76f988da831153b5,
+    0x983e5152ee66dfab, 0xa831c66d2db43210,
+    0xb00327c898fb213f, 0xbf597fc7beef0ee4,
+    0xc6e00bf33da88fc2, 0xd5a79147930aa725,
+    0x06ca6351e003826f, 0x142929670a0e6e70,
+    0x27b70a8546d22ffc, 0x2e1b21385c26c926,
+    0x4d2c6dfc5ac42aed, 0x53380d139d95b3df,
+    0x650a73548baf63de, 0x766a0abb3c77b2a8,
+    0x81c2c92e47edaee6, 0x92722c851482353b,
+    0xa2bfe8a14cf10364, 0xa81a664bbc423001,
+    0xc24b8b70d0f89791, 0xc76c51a30654be30,
+    0xd192e819d6ef5218, 0xd69906245565a910,
+    0xf40e35855771202a, 0x106aa07032bbd1b8,
+    0x19a4c116b8d2d0c8, 0x1e376c085141ab53,
+    0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8,
+    0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb,
+    0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3,
+    0x748f82ee5defb2fc, 0x78a5636f43172f60,
+    0x84c87814a1f0ab72, 0x8cc702081a6439ec,
+    0x90befffa23631e28, 0xa4506cebde82bde9,
+    0xbef9a3f7b2c67915, 0xc67178f2e372532b,
+    0xca273eceea26619c, 0xd186b8c721c0c207,
+    0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178,
+    0x06f067aa72176fba, 0x0a637dc5a2c898a6,
+    0x113f9804bef90dae, 0x1b710b35131c471b,
+    0x28db77f523047d84, 0x32caab7b40c72493,
+    0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c,
+    0x4cc5d4becb3e42b6, 0x597f299cfc657e2a,
+    0x5fcb6fab3ad6faec, 0x6c44198c4a475817,
+}
+
+SHA256_CH :: #force_inline proc "contextless"(x, y, z: u32) -> u32 {
+    return (x & y) ~ (~x & z)
+}
+
+SHA256_MAJ :: #force_inline proc "contextless"(x, y, z: u32) -> u32 {
+    return (x & y) ~ (x & z) ~ (y & z)
+}
+
+SHA512_CH :: #force_inline proc "contextless"(x, y, z: u64) -> u64 {
+    return (x & y) ~ (~x & z)
+}
+
+SHA512_MAJ :: #force_inline proc "contextless"(x, y, z: u64) -> u64 {
+    return (x & y) ~ (x & z) ~ (y & z)
+}
+
+SHA256_F1 :: #force_inline proc "contextless"(x: u32) -> u32 {
+    return util.ROTR32(x, 2) ~ util.ROTR32(x, 13) ~ util.ROTR32(x, 22)
+}
+
+SHA256_F2 :: #force_inline proc "contextless"(x: u32) -> u32 {
+    return util.ROTR32(x, 6) ~ util.ROTR32(x, 11) ~ util.ROTR32(x, 25)
+}
+
+SHA256_F3 :: #force_inline proc "contextless"(x: u32) -> u32 {
+    return util.ROTR32(x, 7) ~ util.ROTR32(x, 18) ~ (x >> 3)
+}
+
+SHA256_F4 :: #force_inline proc "contextless"(x: u32) -> u32 {
+    return util.ROTR32(x, 17) ~ util.ROTR32(x, 19) ~ (x >> 10)
+}
+
+SHA512_F1 :: #force_inline proc "contextless"(x: u64) -> u64 {
+    return util.ROTR64(x, 28) ~ util.ROTR64(x, 34) ~ util.ROTR64(x, 39)
+}
+
+SHA512_F2 :: #force_inline proc "contextless"(x: u64) -> u64 {
+    return util.ROTR64(x, 14) ~ util.ROTR64(x, 18) ~ util.ROTR64(x, 41)
+}
+
+SHA512_F3 :: #force_inline proc "contextless"(x: u64) -> u64 {
+    return util.ROTR64(x, 1) ~ util.ROTR64(x, 8) ~ (x >> 7)
+}
+
+SHA512_F4 :: #force_inline proc "contextless"(x: u64) -> u64 {
+    return util.ROTR64(x, 19) ~ util.ROTR64(x, 61) ~ (x >> 6)
+}
+
+PACK32 :: #force_inline proc "contextless"(b: []byte, x: ^u32) {
+	x^ = u32(b[3]) | u32(b[2]) << 8 | u32(b[1]) << 16 | u32(b[0]) << 24
+}
+
+PACK64 :: #force_inline proc "contextless"(b: []byte, x: ^u64) {
+	x^ = u64(b[7]) | u64(b[6]) << 8 | u64(b[5]) << 16 | u64(b[4]) << 24 | u64(b[3]) << 32 | u64(b[2]) << 40 | u64(b[1]) << 48 | u64(b[0]) << 56
+}
+
+init_odin :: proc(ctx: ^$T) {
+	when T == Sha256_Context {
+		if ctx.is224 {
+			ctx.h[0] = 0xc1059ed8
+			ctx.h[1] = 0x367cd507
+			ctx.h[2] = 0x3070dd17
+			ctx.h[3] = 0xf70e5939
+			ctx.h[4] = 0xffc00b31
+			ctx.h[5] = 0x68581511
+			ctx.h[6] = 0x64f98fa7
+			ctx.h[7] = 0xbefa4fa4
+		} else {
+			ctx.h[0] = 0x6a09e667
+			ctx.h[1] = 0xbb67ae85
+			ctx.h[2] = 0x3c6ef372
+			ctx.h[3] = 0xa54ff53a
+			ctx.h[4] = 0x510e527f
+			ctx.h[5] = 0x9b05688c
+			ctx.h[6] = 0x1f83d9ab
+			ctx.h[7] = 0x5be0cd19
+		}
+	} else when T == Sha512_Context {
+		if ctx.is384 {
+			ctx.h[0] = 0xcbbb9d5dc1059ed8
+			ctx.h[1] = 0x629a292a367cd507
+			ctx.h[2] = 0x9159015a3070dd17
+			ctx.h[3] = 0x152fecd8f70e5939
+			ctx.h[4] = 0x67332667ffc00b31
+			ctx.h[5] = 0x8eb44a8768581511
+			ctx.h[6] = 0xdb0c2e0d64f98fa7
+			ctx.h[7] = 0x47b5481dbefa4fa4
+		} else {
+			ctx.h[0] = 0x6a09e667f3bcc908
+			ctx.h[1] = 0xbb67ae8584caa73b
+			ctx.h[2] = 0x3c6ef372fe94f82b
+			ctx.h[3] = 0xa54ff53a5f1d36f1
+			ctx.h[4] = 0x510e527fade682d1
+			ctx.h[5] = 0x9b05688c2b3e6c1f
+			ctx.h[6] = 0x1f83d9abfb41bd6b
+			ctx.h[7] = 0x5be0cd19137e2179
+		}
+	}
+}
+
+sha2_transf :: proc(ctx: ^$T, data: []byte, block_nb: uint) {
+	when T == Sha256_Context {
+		w: [64]u32
+		wv: [8]u32
+		t1, t2: u32
+	} else when T == Sha512_Context {
+		w: [80]u64
+		wv: [8]u64
+		t1, t2: u64
+	}
+
+	sub_block := make([]byte, len(data))
+	i, j: i32
+
+	for i = 0; i < i32(block_nb); i += 1 {
+		when T == Sha256_Context {
+			sub_block = data[i << 6:]
+		} else when T == Sha512_Context {
+			sub_block = data[i << 7:]
+		}
+
+		for j = 0; j < 16; j += 1 {
+			when T == Sha256_Context {
+				PACK32(sub_block[j << 2:], &w[j])
+			} else when T == Sha512_Context {
+				PACK64(sub_block[j << 3:], &w[j])
+			}
+		}
+
+		when T == Sha256_Context {
+			for j = 16; j < 64; j += 1 {
+				w[j] = SHA256_F4(w[j - 2]) + w[j - 7] + SHA256_F3(w[j - 15]) + w[j - 16]
+			}
+		} else when T == Sha512_Context {
+			for j = 16; j < 80; j += 1 {
+				w[j] = SHA512_F4(w[j - 2]) + w[j - 7] + SHA512_F3(w[j - 15]) + w[j - 16]
+			}
+		}
+
+		for j = 0; j < 8; j += 1 {
+			wv[j] = ctx.h[j]
+		}
+
+		when T == Sha256_Context {
+			for j = 0; j < 64; j += 1 {
+				t1 = wv[7] + SHA256_F2(wv[4]) + SHA256_CH(wv[4], wv[5], wv[6]) + sha256_k[j] + w[j]
+				t2 = SHA256_F1(wv[0]) + SHA256_MAJ(wv[0], wv[1], wv[2])
+				wv[7] = wv[6]
+				wv[6] = wv[5]
+				wv[5] = wv[4]
+				wv[4] = wv[3] + t1
+				wv[3] = wv[2]
+				wv[2] = wv[1]
+				wv[1] = wv[0]
+				wv[0] = t1 + t2
+			}
+		} else when T == Sha512_Context {
+			for j = 0; j < 80; j += 1 {
+				t1 = wv[7] + SHA512_F2(wv[4]) + SHA512_CH(wv[4], wv[5], wv[6]) + sha512_k[j] + w[j]
+				t2 = SHA512_F1(wv[0]) + SHA512_MAJ(wv[0], wv[1], wv[2])
+				wv[7] = wv[6]
+				wv[6] = wv[5]
+				wv[5] = wv[4]
+				wv[4] = wv[3] + t1
+				wv[3] = wv[2]
+				wv[2] = wv[1]
+				wv[1] = wv[0]
+				wv[0] = t1 + t2
+			}
+		}
+
+		for j = 0; j < 8; j += 1 {
+			ctx.h[j] += wv[j]
+		}
+	}
+}
+
+update_odin :: proc(ctx: ^$T, data: []byte) {
+	length := uint(len(data))
+	block_nb: uint
+	new_len, rem_len, tmp_len: uint
+	shifted_message := make([]byte, length)
+
+	when T == Sha256_Context {
+        CURR_BLOCK_SIZE :: SHA256_BLOCK_SIZE
+    } else when T == Sha512_Context {
+        CURR_BLOCK_SIZE :: SHA512_BLOCK_SIZE
+    }
+
+	tmp_len = CURR_BLOCK_SIZE - ctx.length
+	rem_len = length < tmp_len ? length : tmp_len
+	copy(ctx.block[ctx.length:], data[:rem_len])
+
+	if ctx.length + length < CURR_BLOCK_SIZE {
+		ctx.length += length
+		return
+	}
+
+	new_len = length - rem_len
+	block_nb = new_len / CURR_BLOCK_SIZE
+    shifted_message = data[rem_len:]
+
+	sha2_transf(ctx, ctx.block[:], 1)
+	sha2_transf(ctx, shifted_message, block_nb)
+
+	rem_len = new_len % CURR_BLOCK_SIZE
+	when T == Sha256_Context 	  {copy(ctx.block[:], shifted_message[block_nb << 6:rem_len])}
+	else when T == Sha512_Context {copy(ctx.block[:], shifted_message[block_nb << 7:rem_len])}
+
+	ctx.length = rem_len
+	when T == Sha256_Context 	  {ctx.tot_len += (block_nb + 1) << 6}
+	else when T == Sha512_Context {ctx.tot_len += (block_nb + 1) << 7}
+}
+
+final_odin :: proc(ctx: ^$T, hash: []byte) {
+	block_nb, pm_len, len_b: u32
+	i: i32
+
+	when T == Sha256_Context 	  {CURR_BLOCK_SIZE :: SHA256_BLOCK_SIZE}
+	else when T == Sha512_Context {CURR_BLOCK_SIZE :: SHA512_BLOCK_SIZE}
+
+	when T == Sha256_Context 	  {block_nb = 1 + ((CURR_BLOCK_SIZE - 9)  < (ctx.length % CURR_BLOCK_SIZE) ? 1 : 0)}
+	else when T == Sha512_Context {block_nb = 1 + ((CURR_BLOCK_SIZE - 17) < (ctx.length % CURR_BLOCK_SIZE) ? 1 : 0)}
+
+	len_b = u32(ctx.tot_len + ctx.length) << 3
+	when T == Sha256_Context 	  {pm_len = block_nb << 6}
+	else when T == Sha512_Context {pm_len = block_nb << 7}
+
+	mem.set(rawptr(&(ctx.block[ctx.length:])[0]), 0, int(uint(pm_len) - ctx.length))
+    ctx.block[ctx.length] = 0x80
+
+    util.PUT_U32_BE(ctx.block[pm_len - 4:], len_b)
+
+	sha2_transf(ctx, ctx.block[:], uint(block_nb))
+
+	when T == Sha256_Context {
+		if ctx.is224 {
+			for i = 0; i < 7; i += 1 {util.PUT_U32_BE(hash[i << 2:], ctx.h[i])}
+		} else {
+			for i = 0; i < 8; i += 1 {util.PUT_U32_BE(hash[i << 2:], ctx.h[i])}
+		} 
+	} else when T == Sha512_Context {
+		if ctx.is384 {
+			for i = 0; i < 6; i += 1 {util.PUT_U64_BE(hash[i << 3:], ctx.h[i])}
+		} else {
+			for i = 0; i < 8; i += 1 {util.PUT_U64_BE(hash[i << 3:], ctx.h[i])}
+		} 
+	} 
+}

core/crypto/sha3/sha3.odin

@@ -0,0 +1,428 @@
+package sha3
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Interface for the SHA3 hashing algorithm. The SHAKE functionality can be found in package shake.
+    If you wish to compute a Keccak hash, you can use the keccak package, it will use the original padding.
+*/
+
+import "core:os"
+import "core:io"
+
+import "../botan"
+import "../_ctx"
+import "../_sha3"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_28  = hash_bytes_odin_28
+    ctx.hash_file_28   = hash_file_odin_28
+    ctx.hash_stream_28 = hash_stream_odin_28
+    ctx.hash_bytes_32  = hash_bytes_odin_32
+    ctx.hash_file_32   = hash_file_odin_32
+    ctx.hash_stream_32 = hash_stream_odin_32
+    ctx.hash_bytes_48  = hash_bytes_odin_48
+    ctx.hash_file_48   = hash_file_odin_48
+    ctx.hash_stream_48 = hash_stream_odin_48
+    ctx.hash_bytes_64  = hash_bytes_odin_64
+    ctx.hash_file_64   = hash_file_odin_64
+    ctx.hash_stream_64 = hash_stream_odin_64
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan assigns the internal vtable of the hash context to use the Botan bindings
+use_botan :: #force_inline proc() {
+    botan.assign_hash_vtable(_hash_impl, botan.HASH_SHA3)
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+/*
+    High level API
+*/
+
+// hash_string_224 will hash the given input and return the
+// computed hash
+hash_string_224 :: proc(data: string) -> [28]byte {
+    return hash_bytes_224(transmute([]byte)(data))
+}
+
+// hash_bytes_224 will hash the given input and return the
+// computed hash
+hash_bytes_224 :: proc(data: []byte) -> [28]byte {
+    _create_sha3_ctx(28)
+    return _hash_impl->hash_bytes_28(data)
+}
+
+// hash_stream_224 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_224 :: proc(s: io.Stream) -> ([28]byte, bool) {
+    _create_sha3_ctx(28)
+    return _hash_impl->hash_stream_28(s)
+}
+
+// hash_file_224 will read the file provided by the given handle
+// and compute a hash
+hash_file_224 :: proc(hd: os.Handle, load_at_once := false) -> ([28]byte, bool) {
+    _create_sha3_ctx(28)
+    return _hash_impl->hash_file_28(hd, load_at_once)
+}
+
+hash_224 :: proc {
+    hash_stream_224,
+    hash_file_224,
+    hash_bytes_224,
+    hash_string_224,
+}
+
+// hash_string_256 will hash the given input and return the
+// computed hash
+hash_string_256 :: proc(data: string) -> [32]byte {
+    return hash_bytes_256(transmute([]byte)(data))
+}
+
+// hash_bytes_256 will hash the given input and return the
+// computed hash
+hash_bytes_256 :: proc(data: []byte) -> [32]byte {
+    _create_sha3_ctx(32)
+    return _hash_impl->hash_bytes_32(data)
+}
+
+// hash_stream_256 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_256 :: proc(s: io.Stream) -> ([32]byte, bool) {
+    _create_sha3_ctx(32)
+    return _hash_impl->hash_stream_32(s)
+}
+
+// hash_file_256 will read the file provided by the given handle
+// and compute a hash
+hash_file_256 :: proc(hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    _create_sha3_ctx(32)
+    return _hash_impl->hash_file_32(hd, load_at_once)
+}
+
+hash_256 :: proc {
+    hash_stream_256,
+    hash_file_256,
+    hash_bytes_256,
+    hash_string_256,
+}
+
+// hash_string_384 will hash the given input and return the
+// computed hash
+hash_string_384 :: proc(data: string) -> [48]byte {
+    return hash_bytes_384(transmute([]byte)(data))
+}
+
+// hash_bytes_384 will hash the given input and return the
+// computed hash
+hash_bytes_384 :: proc(data: []byte) -> [48]byte {
+    _create_sha3_ctx(48)
+    return _hash_impl->hash_bytes_48(data)
+}
+
+// hash_stream_384 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_384 :: proc(s: io.Stream) -> ([48]byte, bool) {
+    _create_sha3_ctx(48)
+    return _hash_impl->hash_stream_48(s)
+}
+
+// hash_file_384 will read the file provided by the given handle
+// and compute a hash
+hash_file_384 :: proc(hd: os.Handle, load_at_once := false) -> ([48]byte, bool) {
+    _create_sha3_ctx(48)
+    return _hash_impl->hash_file_48(hd, load_at_once)
+}
+
+hash_384 :: proc {
+    hash_stream_384,
+    hash_file_384,
+    hash_bytes_384,
+    hash_string_384,
+}
+
+// hash_string_512 will hash the given input and return the
+// computed hash
+hash_string_512 :: proc(data: string) -> [64]byte {
+    return hash_bytes_512(transmute([]byte)(data))
+}
+
+// hash_bytes_512 will hash the given input and return the
+// computed hash
+hash_bytes_512 :: proc(data: []byte) -> [64]byte {
+    _create_sha3_ctx(64)
+    return _hash_impl->hash_bytes_64(data)
+}
+
+// hash_stream_512 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_512 :: proc(s: io.Stream) -> ([64]byte, bool) {
+    _create_sha3_ctx(64)
+    return _hash_impl->hash_stream_64(s)
+}
+
+// hash_file_512 will read the file provided by the given handle
+// and compute a hash
+hash_file_512 :: proc(hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    _create_sha3_ctx(64)
+    return _hash_impl->hash_file_64(hd, load_at_once)
+}
+
+hash_512 :: proc {
+    hash_stream_512,
+    hash_file_512,
+    hash_bytes_512,
+    hash_string_512,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [28]byte {
+    hash: [28]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        _sha3.update_odin(&c, data)
+        _sha3.final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([28]byte, bool) {
+    hash: [28]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _sha3.update_odin(&c, buf[:read])
+            } 
+        }
+        _sha3.final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_28 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([28]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_28(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_28(ctx, buf[:]), ok
+        }
+    }
+    return [28]byte{}, false
+}
+
+hash_bytes_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [32]byte {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        _sha3.update_odin(&c, data)
+        _sha3.final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([32]byte, bool) {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _sha3.update_odin(&c, buf[:read])
+            } 
+        }
+        _sha3.final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_32(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_32(ctx, buf[:]), ok
+        }
+    }
+    return [32]byte{}, false
+}
+
+hash_bytes_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [48]byte {
+    hash: [48]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        _sha3.update_odin(&c, data)
+        _sha3.final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([48]byte, bool) {
+    hash: [48]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _sha3.update_odin(&c, buf[:read])
+            } 
+        }
+        _sha3.final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_48 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([48]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_48(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_48(ctx, buf[:]), ok
+        }
+    }
+    return [48]byte{}, false
+}
+
+hash_bytes_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [64]byte {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        _sha3.update_odin(&c, data)
+        _sha3.final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([64]byte, bool) {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _sha3.update_odin(&c, buf[:read])
+            } 
+        }
+        _sha3.final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_64(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_64(ctx, buf[:]), ok
+        }
+    }
+    return [64]byte{}, false
+}
+
+@(private)
+_create_sha3_ctx :: #force_inline proc(mdlen: int) {
+    ctx: _sha3.Sha3_Context
+    ctx.mdlen               = mdlen
+    _hash_impl.internal_ctx = ctx
+    switch mdlen {
+        case 28: _hash_impl.hash_size = ._28
+        case 32: _hash_impl.hash_size = ._32
+        case 48: _hash_impl.hash_size = ._48
+        case 64: _hash_impl.hash_size = ._64
+    }
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    #partial switch ctx.hash_size {
+        case ._28: _create_sha3_ctx(28)
+        case ._32: _create_sha3_ctx(32)
+        case ._48: _create_sha3_ctx(48)
+        case ._64: _create_sha3_ctx(64)
+    }
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.final_odin(&c, hash)
+    }
+}

core/crypto/shake/shake.odin

@@ -0,0 +1,273 @@
+package shake
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Interface for the SHAKE hashing algorithm.
+    The SHA3 functionality can be found in package sha3.
+*/
+
+import "core:os"
+import "core:io"
+
+import "../botan"
+import "../_ctx"
+import "../_sha3"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_16  = hash_bytes_odin_16
+    ctx.hash_file_16   = hash_file_odin_16
+    ctx.hash_stream_16 = hash_stream_odin_16
+    ctx.hash_bytes_32  = hash_bytes_odin_32
+    ctx.hash_file_32   = hash_file_odin_32
+    ctx.hash_stream_32 = hash_stream_odin_32
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan assigns the internal vtable of the hash context to use the Botan bindings
+use_botan :: #force_inline proc() {
+    botan.assign_hash_vtable(_hash_impl, botan.HASH_SHAKE)
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+/*
+    High level API
+*/
+
+// hash_string_128 will hash the given input and return the
+// computed hash
+hash_string_128 :: proc(data: string) -> [16]byte {
+    return hash_bytes_128(transmute([]byte)(data))
+}
+
+// hash_bytes_128 will hash the given input and return the
+// computed hash
+hash_bytes_128 :: proc(data: []byte) -> [16]byte {
+    _create_shake_ctx(16)
+    return _hash_impl->hash_bytes_16(data)
+}
+
+// hash_stream_128 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_128 :: proc(s: io.Stream) -> ([16]byte, bool) {
+    _create_shake_ctx(16)
+    return _hash_impl->hash_stream_16(s)
+}
+
+// hash_file_128 will read the file provided by the given handle
+// and compute a hash
+hash_file_128 :: proc(hd: os.Handle, load_at_once := false) -> ([16]byte, bool) {
+    _create_shake_ctx(16)
+    return _hash_impl->hash_file_16(hd, load_at_once)
+}
+
+hash_128 :: proc {
+    hash_stream_128,
+    hash_file_128,
+    hash_bytes_128,
+    hash_string_128,
+}
+
+// hash_string_256 will hash the given input and return the
+// computed hash
+hash_string_256 :: proc(data: string) -> [32]byte {
+    return hash_bytes_256(transmute([]byte)(data))
+}
+
+// hash_bytes_256 will hash the given input and return the
+// computed hash
+hash_bytes_256 :: proc(data: []byte) -> [32]byte {
+    _create_shake_ctx(32)
+    return _hash_impl->hash_bytes_32(data)
+}
+
+// hash_stream_256 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_256 :: proc(s: io.Stream) -> ([32]byte, bool) {
+    _create_shake_ctx(32)
+    return _hash_impl->hash_stream_32(s)
+}
+
+// hash_file_256 will read the file provided by the given handle
+// and compute a hash
+hash_file_256 :: proc(hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    _create_shake_ctx(32)
+    return _hash_impl->hash_file_32(hd, load_at_once)
+}
+
+hash_256 :: proc {
+    hash_stream_256,
+    hash_file_256,
+    hash_bytes_256,
+    hash_string_256,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin_16 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [16]byte {
+    hash: [16]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        _sha3.update_odin(&c, data)
+        _sha3.shake_xof_odin(&c)
+        _sha3.shake_out_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_16 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([16]byte, bool) {
+    hash: [16]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _sha3.update_odin(&c, buf[:read])
+            } 
+        }
+        _sha3.shake_xof_odin(&c)
+        _sha3.shake_out_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_16 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([16]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_16(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_16(ctx, buf[:]), ok
+        }
+    }
+    return [16]byte{}, false
+}
+
+hash_bytes_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [32]byte {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        _sha3.update_odin(&c, data)
+        _sha3.shake_xof_odin(&c)
+        _sha3.shake_out_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([32]byte, bool) {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _sha3.update_odin(&c, buf[:read])
+            } 
+        }
+        _sha3.shake_xof_odin(&c)
+        _sha3.shake_out_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_32(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_32(ctx, buf[:]), ok
+        }
+    }
+    return [32]byte{}, false
+}
+
+@(private)
+_create_shake_ctx :: #force_inline proc(mdlen: int) {
+    ctx: _sha3.Sha3_Context
+    ctx.mdlen               = mdlen
+    _hash_impl.internal_ctx = ctx
+    switch mdlen {
+        case 16: _hash_impl.hash_size = ._16
+        case 32: _hash_impl.hash_size = ._32
+    }
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    #partial switch ctx.hash_size {
+        case ._16: _create_shake_ctx(16)
+        case ._32: _create_shake_ctx(32)
+    }
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(_sha3.Sha3_Context); ok {
+        _sha3.shake_xof_odin(&c)
+        _sha3.shake_out_odin(&c, hash[:])
+    }
+}

core/crypto/skein/skein.odin

@@ -0,0 +1,487 @@
+package skein
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Implementation of the SKEIN hashing algorithm, as defined in <https://www.schneier.com/academic/skein/>
+    
+    This package offers the internal state sizes of 256, 512 and 1024 bits and arbitrary output size.
+*/
+
+import "core:os"
+import "core:io"
+
+import "../botan"
+import "../_ctx"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+        ctx.is_using_odin = false
+    } else {
+        _assign_hash_vtable(ctx)
+        ctx.is_using_odin = true
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    // @note(zh): Default to SKEIN-512
+    ctx.hash_bytes_slice  = hash_bytes_skein512_odin
+    ctx.hash_file_slice   = hash_file_skein512_odin
+    ctx.hash_stream_slice = hash_stream_skein512_odin
+    ctx.init              = _init_skein512_odin
+    ctx.update            = _update_skein512_odin
+    ctx.final             = _final_skein512_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan assigns the internal vtable of the hash context to use the Botan bindings
+use_botan :: #force_inline proc() {
+    _hash_impl.is_using_odin = false
+    // @note(zh): Botan only supports SKEIN-512.
+    botan.assign_hash_vtable(_hash_impl, botan.HASH_SKEIN_512)
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+@(warning="SKEIN is not yet implemented in Odin. Botan bindings will be used")
+use_odin :: #force_inline proc() {
+    // _hash_impl.is_using_odin = true
+    // _assign_hash_vtable(_hash_impl)
+    use_botan()
+}
+
+@(private)
+_create_skein256_ctx :: #force_inline proc(size: int) {
+    _hash_impl.hash_size_val = size
+    if _hash_impl.is_using_odin {
+        ctx: Skein256_Context
+        ctx.h.bit_length             = u64(size)
+        _hash_impl.internal_ctx      = ctx
+        _hash_impl.hash_bytes_slice  = hash_bytes_skein256_odin
+        _hash_impl.hash_file_slice   = hash_file_skein256_odin
+        _hash_impl.hash_stream_slice = hash_stream_skein256_odin
+        _hash_impl.init              = _init_skein256_odin
+        _hash_impl.update            = _update_skein256_odin
+        _hash_impl.final             = _final_skein256_odin
+    }
+}
+
+@(private)
+_create_skein512_ctx :: #force_inline proc(size: int) {
+    _hash_impl.hash_size_val = size
+    if _hash_impl.is_using_odin {
+        ctx: Skein512_Context
+        ctx.h.bit_length             = u64(size)
+        _hash_impl.internal_ctx      = ctx
+        _hash_impl.hash_bytes_slice  = hash_bytes_skein512_odin
+        _hash_impl.hash_file_slice   = hash_file_skein512_odin
+        _hash_impl.hash_stream_slice = hash_stream_skein512_odin
+        _hash_impl.init              = _init_skein512_odin
+        _hash_impl.update            = _update_skein512_odin
+        _hash_impl.final             = _final_skein512_odin
+    }
+}
+
+@(private)
+_create_skein1024_ctx :: #force_inline proc(size: int) {
+    _hash_impl.hash_size_val = size
+    if _hash_impl.is_using_odin {
+        ctx: Skein1024_Context
+        ctx.h.bit_length             = u64(size)
+        _hash_impl.internal_ctx      = ctx
+        _hash_impl.hash_bytes_slice  = hash_bytes_skein1024_odin
+        _hash_impl.hash_file_slice   = hash_file_skein1024_odin
+        _hash_impl.hash_stream_slice = hash_stream_skein1024_odin
+        _hash_impl.init              = _init_skein1024_odin
+        _hash_impl.update            = _update_skein1024_odin
+        _hash_impl.final             = _final_skein1024_odin
+    }
+}
+
+/*
+    High level API
+*/
+
+// hash_skein256_string will hash the given input and return the
+// computed hash
+hash_skein256_string :: proc(data: string, bit_size: int, allocator := context.allocator) -> []byte {
+    return hash_skein256_bytes(transmute([]byte)(data), bit_size, allocator)
+}
+
+// hash_skein256_bytes will hash the given input and return the
+// computed hash
+hash_skein256_bytes :: proc(data: []byte, bit_size: int, allocator := context.allocator) -> []byte {
+    _create_skein256_ctx(bit_size)
+    return _hash_impl->hash_bytes_slice(data, bit_size, allocator)
+}
+
+// hash_skein256_stream will read the stream in chunks and compute a
+// hash from its contents
+hash_skein256_stream :: proc(s: io.Stream, bit_size: int, allocator := context.allocator) -> ([]byte, bool) {
+    _create_skein256_ctx(bit_size)
+    return _hash_impl->hash_stream_slice(s, bit_size, allocator)
+}
+
+// hash_skein256_file will read the file provided by the given handle
+// and compute a hash
+hash_skein256_file :: proc(hd: os.Handle, bit_size: int, load_at_once := false, allocator := context.allocator) -> ([]byte, bool) {
+    _create_skein256_ctx(bit_size)
+    return _hash_impl->hash_file_slice(hd, bit_size, load_at_once, allocator)
+}
+
+hash_skein256 :: proc {
+    hash_skein256_stream,
+    hash_skein256_file,
+    hash_skein256_bytes,
+    hash_skein256_string,
+}
+
+// hash_skein512_string will hash the given input and return the
+// computed hash
+hash_skein512_string :: proc(data: string, bit_size: int, allocator := context.allocator) -> []byte {
+    return hash_skein512_bytes(transmute([]byte)(data), bit_size, allocator)
+}
+
+// hash_skein512_bytes will hash the given input and return the
+// computed hash
+hash_skein512_bytes :: proc(data: []byte, bit_size: int, allocator := context.allocator) -> []byte {
+    _create_skein512_ctx(bit_size)
+    return _hash_impl->hash_bytes_slice(data, bit_size, allocator)
+}
+
+// hash_skein512_stream will read the stream in chunks and compute a
+// hash from its contents
+hash_skein512_stream :: proc(s: io.Stream, bit_size: int, allocator := context.allocator) -> ([]byte, bool) {
+    _create_skein512_ctx(bit_size)
+    return _hash_impl->hash_stream_slice(s, bit_size, allocator)
+}
+
+// hash_skein512_file will read the file provided by the given handle
+// and compute a hash
+hash_skein512_file :: proc(hd: os.Handle, bit_size: int, load_at_once := false, allocator := context.allocator) -> ([]byte, bool) {
+    _create_skein512_ctx(bit_size)
+    return _hash_impl->hash_file_slice(hd, bit_size, load_at_once, allocator)
+}
+
+hash_skein512 :: proc {
+    hash_skein512_stream,
+    hash_skein512_file,
+    hash_skein512_bytes,
+    hash_skein512_string,
+}
+
+// hash_skein1024_string will hash the given input and return the
+// computed hash
+hash_skein1024_string :: proc(data: string, bit_size: int, allocator := context.allocator) -> []byte {
+    return hash_skein1024_bytes(transmute([]byte)(data), bit_size, allocator)
+}
+
+// hash_skein1024_bytes will hash the given input and return the
+// computed hash
+hash_skein1024_bytes :: proc(data: []byte, bit_size: int, allocator := context.allocator) -> []byte {
+    _create_skein1024_ctx(bit_size)
+    return _hash_impl->hash_bytes_slice(data, bit_size, allocator)
+}
+
+// hash_skein1024_stream will read the stream in chunks and compute a
+// hash from its contents
+hash_skein1024_stream :: proc(s: io.Stream, bit_size: int, allocator := context.allocator) -> ([]byte, bool) {
+    _create_skein1024_ctx(bit_size)
+    return _hash_impl->hash_stream_slice(s, bit_size, allocator)
+}
+
+// hash_skein1024_file will read the file provided by the given handle
+// and compute a hash
+hash_skein1024_file :: proc(hd: os.Handle, bit_size: int, load_at_once := false, allocator := context.allocator) -> ([]byte, bool) {
+    _create_skein1024_ctx(bit_size)
+    return _hash_impl->hash_file_slice(hd, bit_size, load_at_once, allocator)
+}
+
+hash_skein1024 :: proc {
+    hash_skein1024_stream,
+    hash_skein1024_file,
+    hash_skein1024_bytes,
+    hash_skein1024_string,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_skein256_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte, bit_size: int, allocator := context.allocator) -> []byte {
+    hash := make([]byte, bit_size, allocator)
+    if c, ok := ctx.internal_ctx.(Skein256_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+        return hash
+    } else {
+        delete(hash)
+        return nil
+    }
+}
+
+hash_stream_skein256_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream, bit_size: int, allocator := context.allocator) -> ([]byte, bool) {
+    hash := make([]byte, bit_size, allocator)
+    if c, ok := ctx.internal_ctx.(Skein256_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        delete(hash)
+        return nil, false
+    }
+}
+
+hash_file_skein256_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, bit_size: int, load_at_once := false, allocator := context.allocator) -> ([]byte, bool) {
+    if !load_at_once {
+        return hash_stream_skein256_odin(ctx, os.stream_from_handle(hd), bit_size, allocator)
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_skein256_odin(ctx, buf[:], bit_size, allocator), ok
+        }
+    }
+    return nil, false
+}
+
+hash_bytes_skein512_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte, bit_size: int, allocator := context.allocator) -> []byte {
+    hash := make([]byte, bit_size, allocator)
+    if c, ok := ctx.internal_ctx.(Skein512_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+        return hash
+    } else {
+        delete(hash)
+        return nil
+    }
+}
+
+hash_stream_skein512_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream, bit_size: int, allocator := context.allocator) -> ([]byte, bool) {
+    hash := make([]byte, bit_size, allocator)
+    if c, ok := ctx.internal_ctx.(Skein512_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        delete(hash)
+        return nil, false
+    }
+}
+
+hash_file_skein512_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, bit_size: int, load_at_once := false, allocator := context.allocator) -> ([]byte, bool) {
+    if !load_at_once {
+        return hash_stream_skein512_odin(ctx, os.stream_from_handle(hd), bit_size, allocator)
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_skein512_odin(ctx, buf[:], bit_size, allocator), ok
+        }
+    }
+    return nil, false
+}
+
+hash_bytes_skein1024_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte, bit_size: int, allocator := context.allocator) -> []byte {
+    hash := make([]byte, bit_size, allocator)
+    if c, ok := ctx.internal_ctx.(Skein1024_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+        return hash
+    } else {
+        delete(hash)
+        return nil
+    }
+}
+
+hash_stream_skein1024_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream, bit_size: int, allocator := context.allocator) -> ([]byte, bool) {
+    hash := make([]byte, bit_size, allocator)
+    if c, ok := ctx.internal_ctx.(Skein1024_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        delete(hash)
+        return nil, false
+    }
+}
+
+hash_file_skein1024_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, bit_size: int, load_at_once := false, allocator := context.allocator) -> ([]byte, bool) {
+    if !load_at_once {
+        return hash_stream_skein512_odin(ctx, os.stream_from_handle(hd), bit_size, allocator)
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_skein512_odin(ctx, buf[:], bit_size, allocator), ok
+        }
+    }
+    return nil, false
+}
+
+@(private)
+_init_skein256_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    _create_skein256_ctx(ctx.hash_size_val)
+    if c, ok := ctx.internal_ctx.(Skein256_Context); ok {
+        init_odin(&c)
+    }
+}
+
+@(private)
+_update_skein256_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(Skein256_Context); ok {
+        update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_skein256_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(Skein256_Context); ok {
+        final_odin(&c, hash)
+    }
+}
+
+@(private)
+_init_skein512_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    _create_skein512_ctx(ctx.hash_size_val)
+    if c, ok := ctx.internal_ctx.(Skein512_Context); ok {
+        init_odin(&c)
+    }
+}
+
+@(private)
+_update_skein512_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(Skein512_Context); ok {
+        update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_skein512_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(Skein512_Context); ok {
+        final_odin(&c, hash)
+    }
+}
+
+@(private)
+_init_skein1024_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    _create_skein1024_ctx(ctx.hash_size_val)
+    if c, ok := ctx.internal_ctx.(Skein1024_Context); ok {
+        init_odin(&c)
+    }
+}
+
+@(private)
+_update_skein1024_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(Skein1024_Context); ok {
+        update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_skein1024_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(Skein1024_Context); ok {
+        final_odin(&c, hash)
+    }
+}
+
+/*
+    SKEIN implementation
+*/
+
+STATE_WORDS_256  :: 4
+STATE_WORDS_512  :: 8
+STATE_WORDS_1024 :: 16
+
+STATE_BYTES_256  :: 32
+STATE_BYTES_512  :: 64
+STATE_BYTES_1024 :: 128
+
+Skein_Header :: struct {
+    bit_length: u64,
+    bcnt:       u64,
+    t:          [2]u64,
+}
+
+Skein256_Context :: struct {
+    h: Skein_Header,
+    x: [STATE_WORDS_256]u64,
+    b: [STATE_BYTES_256]byte,
+}
+
+Skein512_Context :: struct {
+    h: Skein_Header,
+    x: [STATE_WORDS_512]u64,
+    b: [STATE_BYTES_512]byte,
+}
+
+Skein1024_Context :: struct {
+    h: Skein_Header,
+    x: [STATE_WORDS_1024]u64,
+    b: [STATE_BYTES_1024]byte,
+}
+
+
+init_odin :: proc(ctx: ^$T) {
+
+}
+
+update_odin :: proc(ctx: ^$T, data: []byte) {
+
+}
+
+final_odin :: proc(ctx: ^$T, hash: []byte) {
+
+}

core/crypto/sm3/sm3.odin

@@ -0,0 +1,333 @@
+package sm3
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Implementation of the SM3 hashing algorithm, as defined in <https://datatracker.ietf.org/doc/html/draft-sca-cfrg-sm3-02>
+*/
+
+import "core:os"
+import "core:io"
+
+import "../util"
+import "../botan"
+import "../_ctx"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_32  = hash_bytes_odin
+    ctx.hash_file_32   = hash_file_odin
+    ctx.hash_stream_32 = hash_stream_odin
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan assigns the internal vtable of the hash context to use the Botan bindings
+use_botan :: #force_inline proc() {
+    botan.assign_hash_vtable(_hash_impl, botan.HASH_SM3)
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+/*
+    High level API
+*/
+
+// hash_string will hash the given input and return the
+// computed hash
+hash_string :: proc(data: string) -> [32]byte {
+    return hash_bytes(transmute([]byte)(data))
+}
+
+// hash_bytes will hash the given input and return the
+// computed hash
+hash_bytes :: proc(data: []byte) -> [32]byte {
+    _create_sm3_ctx()
+    return _hash_impl->hash_bytes_32(data)
+}
+
+// hash_stream will read the stream in chunks and compute a
+// hash from its contents
+hash_stream :: proc(s: io.Stream) -> ([32]byte, bool) {
+    _create_sm3_ctx()
+    return _hash_impl->hash_stream_32(s)
+}
+
+// hash_file will read the file provided by the given handle
+// and compute a hash
+hash_file :: proc(hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    _create_sm3_ctx()
+    return _hash_impl->hash_file_32(hd, load_at_once)
+}
+
+hash :: proc {
+    hash_stream,
+    hash_file,
+    hash_bytes,
+    hash_string,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [32]byte {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(Sm3_Context); ok {
+        init_odin(&c)
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([32]byte, bool) {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(Sm3_Context); ok {
+        init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin(ctx, buf[:]), ok
+        }
+    }
+    return [32]byte{}, false
+}
+
+@(private)
+_create_sm3_ctx :: #force_inline proc() {
+    ctx: Sm3_Context
+    _hash_impl.internal_ctx = ctx
+    _hash_impl.hash_size    = ._32
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    _create_sm3_ctx()
+    if c, ok := ctx.internal_ctx.(Sm3_Context); ok {
+        init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(Sm3_Context); ok {
+        update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(Sm3_Context); ok {
+        final_odin(&c, hash)
+    }
+}
+
+/*
+    SM3 implementation
+*/
+
+Sm3_Context :: struct {
+    state:     [8]u32,
+    x:         [64]byte,
+    bitlength: u64,
+    length:    u64,
+}
+
+BLOCK_SIZE_IN_BYTES :: 64
+BLOCK_SIZE_IN_32    :: 16
+
+IV := [8]u32 {
+    0x7380166f, 0x4914b2b9, 0x172442d7, 0xda8a0600,
+    0xa96f30bc, 0x163138aa, 0xe38dee4d, 0xb0fb0e4e,
+}
+
+init_odin :: proc(ctx: ^Sm3_Context) {
+    ctx.state[0] = IV[0]
+    ctx.state[1] = IV[1]
+    ctx.state[2] = IV[2]
+    ctx.state[3] = IV[3]
+    ctx.state[4] = IV[4]
+    ctx.state[5] = IV[5]
+    ctx.state[6] = IV[6]
+    ctx.state[7] = IV[7]
+}
+
+block :: proc "contextless" (ctx: ^Sm3_Context, buf: []byte) {
+    buf := buf
+
+    w:  [68]u32
+    wp: [64]u32
+
+    state0, state1, state2, state3 := ctx.state[0], ctx.state[1], ctx.state[2], ctx.state[3]
+    state4, state5, state6, state7 := ctx.state[4], ctx.state[5], ctx.state[6], ctx.state[7]
+
+    for len(buf) >= 64 {
+        for i := 0; i < 16; i += 1 {
+            j := i * 4
+            w[i] = u32(buf[j]) << 24 | u32(buf[j + 1]) << 16 | u32(buf[j + 2]) << 8 | u32(buf[j + 3])
+        }
+        for i := 16; i < 68; i += 1 {
+            p1v := w[i - 16] ~ w[i - 9] ~ util.ROTL32(w[i - 3], 15)
+            // @note(zh): inlined P1
+            w[i] = p1v ~ util.ROTL32(p1v, 15) ~ util.ROTL32(p1v, 23) ~ util.ROTL32(w[i - 13], 7) ~ w[i - 6]
+        }
+        for i := 0; i < 64; i += 1 {
+            wp[i] = w[i] ~ w[i + 4]
+        }
+
+        a, b, c, d := state0, state1, state2, state3
+        e, f, g, h := state4, state5, state6, state7
+
+        for i := 0; i < 16; i += 1 {
+            v1  := util.ROTL32(u32(a), 12)
+            ss1 := util.ROTL32(v1 + u32(e) + util.ROTL32(0x79cc4519, i), 7)
+            ss2 := ss1 ~ v1
+
+            // @note(zh): inlined FF1
+            tt1 := u32(a ~ b ~ c) + u32(d) + ss2 + wp[i]
+            // @note(zh): inlined GG1
+            tt2 := u32(e ~ f ~ g) + u32(h) + ss1 + w[i]
+
+            a, b, c, d = tt1, a, util.ROTL32(u32(b), 9), c
+            // @note(zh): inlined P0
+            e, f, g, h = (tt2 ~ util.ROTL32(tt2, 9) ~ util.ROTL32(tt2, 17)), e, util.ROTL32(u32(f), 19), g
+        }
+
+        for i := 16; i < 64; i += 1 {
+            v   := util.ROTL32(u32(a), 12)
+            ss1 := util.ROTL32(v + u32(e) + util.ROTL32(0x7a879d8a, i % 32), 7)
+            ss2 := ss1 ~ v
+
+            // @note(zh): inlined FF2
+            tt1 := u32(((a & b) | (a & c) | (b & c)) + d) + ss2 + wp[i]
+            // @note(zh): inlined GG2
+            tt2 := u32(((e & f) | ((~e) & g)) + h) + ss1 + w[i]
+
+            a, b, c, d = tt1, a, util.ROTL32(u32(b), 9), c
+            // @note(zh): inlined P0
+            e, f, g, h = (tt2 ~ util.ROTL32(tt2, 9) ~ util.ROTL32(tt2, 17)), e, util.ROTL32(u32(f), 19), g
+        }
+
+        state0 ~= a
+        state1 ~= b
+        state2 ~= c
+        state3 ~= d
+        state4 ~= e
+        state5 ~= f
+        state6 ~= g
+        state7 ~= h
+
+        buf = buf[64:]
+    }
+
+    ctx.state[0], ctx.state[1], ctx.state[2], ctx.state[3] = state0, state1, state2, state3
+    ctx.state[4], ctx.state[5], ctx.state[6], ctx.state[7] = state4, state5, state6, state7
+}
+
+update_odin :: proc(ctx: ^Sm3_Context, data: []byte) {
+    data := data
+    ctx.length += u64(len(data))
+
+    if ctx.bitlength > 0 {
+        n := copy(ctx.x[ctx.bitlength:], data[:])
+        ctx.bitlength += u64(n)
+        if ctx.bitlength == 64 {
+            block(ctx, ctx.x[:])
+            ctx.bitlength = 0
+        }
+        data = data[n:]
+    }
+    if len(data) >= 64 {
+        n := len(data) &~ (64 - 1)
+        block(ctx, data[:n])
+        data = data[n:]
+    }
+    if len(data) > 0 {
+        ctx.bitlength = u64(copy(ctx.x[:], data[:]))
+    }
+}
+
+final_odin :: proc(ctx: ^Sm3_Context, hash: []byte) {
+    length := ctx.length
+
+    pad: [64]byte
+    pad[0] = 0x80
+    if length % 64 < 56 {
+        update_odin(ctx, pad[0: 56 - length % 64])
+    } else {
+        update_odin(ctx, pad[0: 64 + 56 - length % 64])
+    }
+
+    length <<= 3
+    util.PUT_U64_BE(pad[:], length)
+    update_odin(ctx, pad[0: 8])
+    assert(ctx.bitlength == 0)
+
+    util.PUT_U32_BE(hash[0:],  ctx.state[0])
+    util.PUT_U32_BE(hash[4:],  ctx.state[1])
+    util.PUT_U32_BE(hash[8:],  ctx.state[2])
+    util.PUT_U32_BE(hash[12:], ctx.state[3])
+    util.PUT_U32_BE(hash[16:], ctx.state[4])
+    util.PUT_U32_BE(hash[20:], ctx.state[5])
+    util.PUT_U32_BE(hash[24:], ctx.state[6])
+    util.PUT_U32_BE(hash[28:], ctx.state[7])
+}

core/crypto/streebog/streebog.odin

@@ -0,0 +1,596 @@
+package streebog
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Implementation of the Streebog hashing algorithm, standardized as GOST R 34.11-2012 in RFC 6986 <https://datatracker.ietf.org/doc/html/rfc6986>
+*/
+
+import "core:os"
+import "core:io"
+
+import "../util"
+import "../botan"
+import "../_ctx"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_32  = hash_bytes_odin_32
+    ctx.hash_file_32   = hash_file_odin_32
+    ctx.hash_stream_32 = hash_stream_odin_32
+    ctx.hash_bytes_64  = hash_bytes_odin_64
+    ctx.hash_file_64   = hash_file_odin_64
+    ctx.hash_stream_64 = hash_stream_odin_64
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan assigns the internal vtable of the hash context to use the Botan bindings
+use_botan :: #force_inline proc() {
+    botan.assign_hash_vtable(_hash_impl, botan.HASH_STREEBOG)
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+@(private)
+_create_streebog_ctx :: #force_inline proc(is256: bool) {
+	ctx: Streebog_Context
+	ctx.is256               = is256
+	_hash_impl.internal_ctx = ctx
+	_hash_impl.hash_size    = is256 ? ._32 : ._64
+}
+
+/*
+    High level API
+*/
+
+// hash_string_256 will hash the given input and return the
+// computed hash
+hash_string_256 :: proc(data: string) -> [32]byte {
+    return hash_bytes_256(transmute([]byte)(data))
+}
+
+// hash_bytes_256 will hash the given input and return the
+// computed hash
+hash_bytes_256 :: proc(data: []byte) -> [32]byte {
+	_create_streebog_ctx(true)
+    return _hash_impl->hash_bytes_32(data)
+}
+
+// hash_stream_256 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_256 :: proc(s: io.Stream) -> ([32]byte, bool) {
+	_create_streebog_ctx(true)
+    return _hash_impl->hash_stream_32(s)
+}
+
+// hash_file_256 will read the file provided by the given handle
+// and compute a hash
+hash_file_256 :: proc(hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+	_create_streebog_ctx(true)
+    return _hash_impl->hash_file_32(hd, load_at_once)
+}
+
+hash_256 :: proc {
+    hash_stream_256,
+    hash_file_256,
+    hash_bytes_256,
+    hash_string_256,
+}
+
+// hash_string_512 will hash the given input and return the
+// computed hash
+hash_string_512 :: proc(data: string) -> [64]byte {
+    return hash_bytes_512(transmute([]byte)(data))
+}
+
+// hash_bytes_512 will hash the given input and return the
+// computed hash
+hash_bytes_512 :: proc(data: []byte) -> [64]byte {
+	_create_streebog_ctx(false)
+    return _hash_impl->hash_bytes_64(data)
+}
+
+// hash_stream_512 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_512 :: proc(s: io.Stream) -> ([64]byte, bool) {
+	_create_streebog_ctx(false)
+    return _hash_impl->hash_stream_64(s)
+}
+
+// hash_file_512 will read the file provided by the given handle
+// and compute a hash
+hash_file_512 :: proc(hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+	_create_streebog_ctx(false)
+    return _hash_impl->hash_file_64(hd, load_at_once)
+}
+
+hash_512 :: proc {
+    hash_stream_512,
+    hash_file_512,
+    hash_bytes_512,
+    hash_string_512,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [32]byte {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(Streebog_Context); ok {
+    	init_odin(&c)
+		update_odin(&c, data)
+		final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([32]byte, bool) {
+    hash: [32]byte
+    if c, ok := ctx.internal_ctx.(Streebog_Context); ok {
+    	init_odin(&c)
+	    buf := make([]byte, 512)
+	    defer delete(buf)
+	    read := 1
+	    for read > 0 {
+	        read, _ = fs->impl_read(buf)
+	        if read > 0 {
+	            update_odin(&c, buf[:read])
+	        } 
+	    }
+	    final_odin(&c, hash[:])
+	    return hash, true
+    } else {
+    	return hash, false
+    }
+}
+
+hash_file_odin_32 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([32]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_32(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_32(ctx, buf[:]), ok
+        }
+    }
+    return [32]byte{}, false
+}
+
+hash_bytes_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [64]byte {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(Streebog_Context); ok {
+    	init_odin(&c)
+		update_odin(&c, data)
+		final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([64]byte, bool) {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(Streebog_Context); ok {
+    	init_odin(&c)
+	    buf := make([]byte, 512)
+	    defer delete(buf)
+	    read := 1
+	    for read > 0 {
+	        read, _ = fs->impl_read(buf)
+	        if read > 0 {
+	            update_odin(&c, buf[:read])
+	        } 
+	    }
+	    final_odin(&c, hash[:])
+	    return hash, true
+    } else {
+    	return hash, false
+    }
+}
+
+hash_file_odin_64 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_64(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_64(ctx, buf[:]), ok
+        }
+    }
+    return [64]byte{}, false
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    _create_streebog_ctx(ctx.hash_size == ._32)
+    if c, ok := ctx.internal_ctx.(Streebog_Context); ok {
+    	init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(Streebog_Context); ok {
+        update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+	if c, ok := ctx.internal_ctx.(Streebog_Context); ok {
+        final_odin(&c, hash)
+    }
+}
+
+/*
+    Streebog implementation
+*/
+
+PI := [256]byte {
+	252, 238, 221, 17,  207, 110, 49,  22,  251, 196, 250, 218, 35,  197, 4,   77,
+	233, 119, 240, 219, 147, 46,  153, 186, 23,  54,  241, 187, 20,  205, 95,  193,
+	249, 24,  101, 90,  226, 92,  239, 33,  129, 28,  60,  66,  139, 1,   142, 79,
+	5,   132, 2,   174, 227, 106, 143, 160, 6,   11,  237, 152, 127, 212, 211, 31,
+	235, 52,  44,  81,  234, 200, 72,  171, 242, 42,  104, 162, 253, 58,  206, 204,
+	181, 112, 14,  86,  8,   12,  118, 18,  191, 114, 19,  71,  156, 183, 93,  135,
+	21,  161, 150, 41,  16,  123, 154, 199, 243, 145, 120, 111, 157, 158, 178, 177,
+	50,  117, 25,  61,  255, 53,  138, 126, 109, 84,  198, 128, 195, 189, 13,  87,
+	223, 245, 36,  169, 62,  168, 67,  201, 215, 121, 214, 246, 124, 34,  185, 3,
+	224, 15,  236, 222, 122, 148, 176, 188, 220, 232, 40,  80,  78,  51,  10,  74,
+	167, 151, 96,  115, 30,  0,   98,  68,  26,  184, 56,  130, 100, 159, 38,  65,
+	173, 69,  70,  146, 39,  94,  85,  47,  140, 163, 165, 125, 105, 213, 149, 59,
+	7,   88,  179, 64,  134, 172, 29,  247, 48,  55,  107, 228,	136, 217, 231, 137,
+	225, 27,  131, 73,  76,  63,  248, 254, 141, 83,  170, 144, 202, 216, 133, 97,
+	32,  113, 103, 164, 45,  43,  9,   91,  203, 155, 37,  208, 190, 229, 108, 82,
+	89,  166, 116, 210,	230, 244, 180, 192, 209, 102, 175, 194, 57,  75,  99,  182,
+}
+
+TAU := [64]byte {
+	0,  8, 16, 24, 32, 40, 48, 56,
+	1,  9, 17, 25, 33, 41, 49, 57,
+	2, 10, 18, 26, 34, 42, 50, 58,
+	3, 11, 19, 27, 35, 43, 51, 59,
+	4, 12, 20, 28, 36, 44, 52, 60,
+	5, 13, 21, 29, 37, 45, 53, 61,
+	6, 14, 22, 30, 38, 46, 54, 62,
+	7, 15, 23, 31, 39, 47, 55, 63,
+}
+
+STREEBOG_A := [64]u64 {
+	0x8e20faa72ba0b470, 0x47107ddd9b505a38, 0xad08b0e0c3282d1c, 0xd8045870ef14980e,
+	0x6c022c38f90a4c07, 0x3601161cf205268d, 0x1b8e0b0e798c13c8, 0x83478b07b2468764,
+	0xa011d380818e8f40, 0x5086e740ce47c920, 0x2843fd2067adea10, 0x14aff010bdd87508,
+	0x0ad97808d06cb404, 0x05e23c0468365a02, 0x8c711e02341b2d01, 0x46b60f011a83988e,
+	0x90dab52a387ae76f, 0x486dd4151c3dfdb9, 0x24b86a840e90f0d2, 0x125c354207487869,
+	0x092e94218d243cba, 0x8a174a9ec8121e5d, 0x4585254f64090fa0, 0xaccc9ca9328a8950,
+	0x9d4df05d5f661451, 0xc0a878a0a1330aa6, 0x60543c50de970553, 0x302a1e286fc58ca7,
+	0x18150f14b9ec46dd, 0x0c84890ad27623e0, 0x0642ca05693b9f70, 0x0321658cba93c138,
+	0x86275df09ce8aaa8, 0x439da0784e745554, 0xafc0503c273aa42a, 0xd960281e9d1d5215,
+	0xe230140fc0802984, 0x71180a8960409a42, 0xb60c05ca30204d21, 0x5b068c651810a89e,
+	0x456c34887a3805b9, 0xac361a443d1c8cd2, 0x561b0d22900e4669, 0x2b838811480723ba,
+	0x9bcf4486248d9f5d, 0xc3e9224312c8c1a0, 0xeffa11af0964ee50, 0xf97d86d98a327728,
+	0xe4fa2054a80b329c, 0x727d102a548b194e, 0x39b008152acb8227, 0x9258048415eb419d,
+	0x492c024284fbaec0, 0xaa16012142f35760, 0x550b8e9e21f7a530, 0xa48b474f9ef5dc18,
+	0x70a6a56e2440598e, 0x3853dc371220a247, 0x1ca76e95091051ad, 0x0edd37c48a08a6d8,
+	0x07e095624504536c, 0x8d70c431ac02a736, 0xc83862965601dd1b, 0x641c314b2b8ee083,
+}
+
+STREEBOG_C := [12][64]byte { 
+	{
+		0x07, 0x45, 0xa6, 0xf2, 0x59, 0x65, 0x80, 0xdd,
+		0x23, 0x4d, 0x74, 0xcc, 0x36, 0x74, 0x76, 0x05,
+		0x15, 0xd3, 0x60, 0xa4, 0x08, 0x2a, 0x42, 0xa2,
+		0x01, 0x69, 0x67, 0x92, 0x91, 0xe0, 0x7c, 0x4b,
+		0xfc, 0xc4, 0x85, 0x75, 0x8d, 0xb8, 0x4e, 0x71,
+		0x16, 0xd0, 0x45, 0x2e, 0x43, 0x76, 0x6a, 0x2f,
+		0x1f, 0x7c, 0x65, 0xc0, 0x81, 0x2f, 0xcb, 0xeb,
+		0xe9, 0xda, 0xca, 0x1e, 0xda, 0x5b, 0x08, 0xb1,
+	},
+	{
+		0xb7, 0x9b, 0xb1, 0x21, 0x70, 0x04, 0x79, 0xe6,
+		0x56, 0xcd, 0xcb, 0xd7, 0x1b, 0xa2, 0xdd, 0x55,
+		0xca, 0xa7, 0x0a, 0xdb, 0xc2, 0x61, 0xb5, 0x5c,
+		0x58, 0x99, 0xd6, 0x12, 0x6b, 0x17, 0xb5, 0x9a,
+		0x31, 0x01, 0xb5, 0x16, 0x0f, 0x5e, 0xd5, 0x61,
+		0x98, 0x2b, 0x23, 0x0a, 0x72, 0xea, 0xfe, 0xf3,
+		0xd7, 0xb5, 0x70, 0x0f, 0x46, 0x9d, 0xe3, 0x4f,
+		0x1a, 0x2f, 0x9d, 0xa9, 0x8a, 0xb5, 0xa3, 0x6f,
+	},
+	{
+		0xb2, 0x0a, 0xba, 0x0a, 0xf5, 0x96, 0x1e, 0x99,
+		0x31, 0xdb, 0x7a, 0x86, 0x43, 0xf4, 0xb6, 0xc2,
+		0x09, 0xdb, 0x62, 0x60, 0x37, 0x3a, 0xc9, 0xc1,
+		0xb1, 0x9e, 0x35, 0x90, 0xe4, 0x0f, 0xe2, 0xd3,
+		0x7b, 0x7b, 0x29, 0xb1, 0x14, 0x75, 0xea, 0xf2,
+		0x8b, 0x1f, 0x9c, 0x52, 0x5f, 0x5e, 0xf1, 0x06,
+		0x35, 0x84, 0x3d, 0x6a, 0x28, 0xfc, 0x39, 0x0a,
+		0xc7, 0x2f, 0xce, 0x2b, 0xac, 0xdc, 0x74, 0xf5,
+	},
+	{
+		0x2e, 0xd1, 0xe3, 0x84, 0xbc, 0xbe, 0x0c, 0x22,
+		0xf1, 0x37, 0xe8, 0x93, 0xa1, 0xea, 0x53, 0x34,
+		0xbe, 0x03, 0x52, 0x93, 0x33, 0x13, 0xb7, 0xd8,
+		0x75, 0xd6, 0x03, 0xed, 0x82, 0x2c, 0xd7, 0xa9,
+		0x3f, 0x35, 0x5e, 0x68, 0xad, 0x1c, 0x72, 0x9d,
+		0x7d, 0x3c, 0x5c, 0x33, 0x7e, 0x85, 0x8e, 0x48,
+		0xdd, 0xe4, 0x71, 0x5d, 0xa0, 0xe1, 0x48, 0xf9,
+		0xd2, 0x66, 0x15, 0xe8, 0xb3, 0xdf, 0x1f, 0xef,
+	},
+	{
+		0x57, 0xfe, 0x6c, 0x7c, 0xfd, 0x58, 0x17, 0x60,
+		0xf5, 0x63, 0xea, 0xa9, 0x7e, 0xa2, 0x56, 0x7a,
+		0x16, 0x1a, 0x27, 0x23, 0xb7, 0x00, 0xff, 0xdf,
+		0xa3, 0xf5, 0x3a, 0x25, 0x47, 0x17, 0xcd, 0xbf,
+		0xbd, 0xff, 0x0f, 0x80, 0xd7, 0x35, 0x9e, 0x35,
+		0x4a, 0x10, 0x86, 0x16, 0x1f, 0x1c, 0x15, 0x7f,
+		0x63, 0x23, 0xa9, 0x6c, 0x0c, 0x41, 0x3f, 0x9a,
+		0x99, 0x47, 0x47, 0xad, 0xac, 0x6b, 0xea, 0x4b,
+	},
+	{
+		0x6e, 0x7d, 0x64, 0x46, 0x7a, 0x40, 0x68, 0xfa,
+		0x35, 0x4f, 0x90, 0x36, 0x72, 0xc5, 0x71, 0xbf,
+		0xb6, 0xc6, 0xbe, 0xc2, 0x66, 0x1f, 0xf2, 0x0a,
+		0xb4, 0xb7, 0x9a, 0x1c, 0xb7, 0xa6, 0xfa, 0xcf,
+		0xc6, 0x8e, 0xf0, 0x9a, 0xb4, 0x9a, 0x7f, 0x18,
+		0x6c, 0xa4, 0x42, 0x51, 0xf9, 0xc4, 0x66, 0x2d,
+		0xc0, 0x39, 0x30, 0x7a, 0x3b, 0xc3, 0xa4, 0x6f,
+		0xd9, 0xd3, 0x3a, 0x1d, 0xae, 0xae, 0x4f, 0xae,
+	},
+	{
+		0x93, 0xd4, 0x14, 0x3a, 0x4d, 0x56, 0x86, 0x88,
+		0xf3, 0x4a, 0x3c, 0xa2, 0x4c, 0x45, 0x17, 0x35,
+		0x04, 0x05, 0x4a, 0x28, 0x83, 0x69, 0x47, 0x06,
+		0x37, 0x2c, 0x82, 0x2d, 0xc5, 0xab, 0x92, 0x09,
+		0xc9, 0x93, 0x7a, 0x19, 0x33, 0x3e, 0x47, 0xd3,
+		0xc9, 0x87, 0xbf, 0xe6, 0xc7, 0xc6, 0x9e, 0x39,
+		0x54, 0x09, 0x24, 0xbf, 0xfe, 0x86, 0xac, 0x51,
+		0xec, 0xc5, 0xaa, 0xee, 0x16, 0x0e, 0xc7, 0xf4,
+	},
+	{
+		0x1e, 0xe7, 0x02, 0xbf, 0xd4, 0x0d, 0x7f, 0xa4,
+		0xd9, 0xa8, 0x51, 0x59, 0x35, 0xc2, 0xac, 0x36,
+		0x2f, 0xc4, 0xa5, 0xd1, 0x2b, 0x8d, 0xd1, 0x69,
+		0x90, 0x06, 0x9b, 0x92, 0xcb, 0x2b, 0x89, 0xf4,
+		0x9a, 0xc4, 0xdb, 0x4d, 0x3b, 0x44, 0xb4, 0x89,
+		0x1e, 0xde, 0x36, 0x9c, 0x71, 0xf8, 0xb7, 0x4e,
+		0x41, 0x41, 0x6e, 0x0c, 0x02, 0xaa, 0xe7, 0x03,
+		0xa7, 0xc9, 0x93, 0x4d, 0x42, 0x5b, 0x1f, 0x9b,
+	},
+	{
+		0xdb, 0x5a, 0x23, 0x83, 0x51, 0x44, 0x61, 0x72,
+		0x60, 0x2a, 0x1f, 0xcb, 0x92, 0xdc, 0x38, 0x0e,
+		0x54, 0x9c, 0x07, 0xa6, 0x9a, 0x8a, 0x2b, 0x7b,
+		0xb1, 0xce, 0xb2, 0xdb, 0x0b, 0x44, 0x0a, 0x80,
+		0x84, 0x09, 0x0d, 0xe0, 0xb7, 0x55, 0xd9, 0x3c,
+		0x24, 0x42, 0x89, 0x25, 0x1b, 0x3a, 0x7d, 0x3a,
+		0xde, 0x5f, 0x16, 0xec, 0xd8, 0x9a, 0x4c, 0x94,
+		0x9b, 0x22, 0x31, 0x16, 0x54, 0x5a, 0x8f, 0x37,
+	},
+	{
+		0xed, 0x9c, 0x45, 0x98, 0xfb, 0xc7, 0xb4, 0x74,
+		0xc3, 0xb6, 0x3b, 0x15, 0xd1, 0xfa, 0x98, 0x36,
+		0xf4, 0x52, 0x76, 0x3b, 0x30, 0x6c, 0x1e, 0x7a,
+		0x4b, 0x33, 0x69, 0xaf, 0x02, 0x67, 0xe7, 0x9f,
+		0x03, 0x61, 0x33, 0x1b, 0x8a, 0xe1, 0xff, 0x1f,
+		0xdb, 0x78, 0x8a, 0xff, 0x1c, 0xe7, 0x41, 0x89,
+		0xf3, 0xf3, 0xe4, 0xb2, 0x48, 0xe5, 0x2a, 0x38,
+		0x52, 0x6f, 0x05, 0x80, 0xa6, 0xde, 0xbe, 0xab,
+	},
+	{
+		0x1b, 0x2d, 0xf3, 0x81, 0xcd, 0xa4, 0xca, 0x6b,
+		0x5d, 0xd8, 0x6f, 0xc0, 0x4a, 0x59, 0xa2, 0xde,
+		0x98, 0x6e, 0x47, 0x7d, 0x1d, 0xcd, 0xba, 0xef,
+		0xca, 0xb9, 0x48, 0xea, 0xef, 0x71, 0x1d, 0x8a,
+		0x79, 0x66, 0x84, 0x14, 0x21, 0x80, 0x01, 0x20,
+		0x61, 0x07, 0xab, 0xeb, 0xbb, 0x6b, 0xfa, 0xd8,
+		0x94, 0xfe, 0x5a, 0x63, 0xcd, 0xc6, 0x02, 0x30,
+		0xfb, 0x89, 0xc8, 0xef, 0xd0, 0x9e, 0xcd, 0x7b,
+	},
+	{
+		0x20, 0xd7, 0x1b, 0xf1, 0x4a, 0x92, 0xbc, 0x48,
+		0x99, 0x1b, 0xb2, 0xd9, 0xd5, 0x17, 0xf4, 0xfa,
+		0x52, 0x28, 0xe1, 0x88, 0xaa, 0xa4, 0x1d, 0xe7,
+		0x86, 0xcc, 0x91, 0x18, 0x9d, 0xef, 0x80, 0x5d,
+		0x9b, 0x9f, 0x21, 0x30, 0xd4, 0x12, 0x20, 0xf8,
+		0x77, 0x1d, 0xdf, 0xbc, 0x32, 0x3c, 0xa4, 0xcd,
+		0x7a, 0xb1, 0x49, 0x04, 0xb0, 0x80, 0x13, 0xd2,
+		0xba, 0x31, 0x16, 0xf1, 0x67, 0xe7, 0x8e, 0x37,
+	},
+}
+
+Streebog_Context :: struct {
+	buffer:    [64]byte,
+	h:         [64]byte,
+	n:         [64]byte,
+	sigma:     [64]byte,
+	v_0:       [64]byte,
+	v_512:     [64]byte,
+	buf_size:  u64,
+	hash_size: int,
+	is256:	   bool,
+}
+
+add_mod_512 :: proc(first_vector, second_vector, result_vector: []byte) {
+	t: i32 = 0
+	for i: i32 = 0; i < 64; i += 1 {
+		t = i32(first_vector[i]) + i32(second_vector[i]) + (t >> 8)
+		result_vector[i] = byte(t & 0xff)
+	}
+}
+
+X :: #force_inline proc(a, k, out: []byte) {
+	for i := 0; i < 64; i += 1 {
+		out[i] = a[i] ~ k[i]
+	}
+}
+
+S :: #force_inline proc(state: []byte) {
+	t: [64]byte
+	for i: i32 = 63; i >= 0; i -= 1 {
+		t[i] = PI[state[i]]
+	}
+	copy(state, t[:])
+}
+
+P :: #force_inline proc(state: []byte) {
+	t: [64]byte
+	for i: i32 = 63; i >= 0; i -= 1 {
+		t[i] = state[TAU[i]]
+	}
+	copy(state, t[:])
+}
+
+L :: #force_inline proc(state: []byte) {
+	ins := util.cast_slice([]u64, state)
+	out: [8]u64
+	for i: i32 = 7; i >= 0; i -= 1 {
+		for j: i32 = 63; j >= 0; j -= 1 {
+			if (ins[i] >> u32(j)) & 1 != 0 {
+				out[i] ~= STREEBOG_A[63 - j]
+			}	
+		}
+	}
+	copy(state, util.cast_slice([]byte, out[:]))
+}
+
+E :: #force_inline proc(K, m, state: []byte) {
+	X(m, K, state)
+	for i: i32 = 0; i < 12; i += 1 {
+		S(state)
+		P(state)
+		L(state)
+		get_key(K, i)
+		X(state, K, state)
+	}
+}
+
+get_key :: #force_inline proc(K: []byte, i: i32) {
+	X(K, STREEBOG_C[i][:], K)
+	S(K)
+	P(K)
+	L(K)
+}
+
+G :: #force_inline proc(h, N, m: []byte) {
+	t, K: [64]byte
+	X(N, h, K[:])
+	S(K[:])
+	P(K[:])
+	L(K[:])
+	E(K[:], m, t[:])
+	X(t[:], h, t[:])
+	X(t[:], m, h)
+}
+
+stage2 :: proc(ctx: ^Streebog_Context, m: []byte) {
+	G(ctx.h[:], ctx.n[:], m)
+	add_mod_512(ctx.n[:], ctx.v_512[:], ctx.n[:])
+	add_mod_512(ctx.sigma[:], m, ctx.sigma[:])
+}
+
+padding :: proc(ctx: ^Streebog_Context) {
+	if ctx.buf_size < 64 {
+		t: [64]byte
+		copy(t[:], ctx.buffer[:int(ctx.buf_size)])
+		t[ctx.buf_size] = 0x01
+		copy(ctx.buffer[:], t[:])
+	}
+}
+
+init_odin :: proc(ctx: ^Streebog_Context) {
+	if ctx.is256 {
+		ctx.hash_size = 256
+		for _, i in ctx.h {
+			ctx.h[i] = 0x01
+		}
+	} else {
+		ctx.hash_size = 512
+	}
+	ctx.v_512[1] = 0x02
+}
+
+update_odin :: proc(ctx: ^Streebog_Context, data: []byte) {
+	length := u64(len(data))
+	chk_size: u64
+	data := data
+	for (length > 63) && (ctx.buf_size == 0) {
+		stage2(ctx, data)
+		data = data[64:]
+		length -= 64
+	}
+
+	for length != 0 {
+		chk_size = 64 - ctx.buf_size
+		if chk_size > length {
+			chk_size = length
+		}
+		copy(ctx.buffer[ctx.buf_size:], data[:chk_size])
+		ctx.buf_size += chk_size
+		length -= chk_size
+		data = data[chk_size:]
+		if ctx.buf_size == 64 {
+			stage2(ctx, ctx.buffer[:])
+			ctx.buf_size = 0
+		}
+	}
+}
+
+final_odin :: proc(ctx: ^Streebog_Context, hash: []byte) {
+	t: [64]byte
+	t[1] = byte((ctx.buf_size * 8) >> 8) & 0xff
+	t[0] = byte((ctx.buf_size) * 8) & 0xff
+
+	padding(ctx)
+
+	G(ctx.h[:], ctx.n[:], ctx.buffer[:])
+
+	add_mod_512(ctx.n[:], t[:], ctx.n[:])
+	add_mod_512(ctx.sigma[:], ctx.buffer[:], ctx.sigma[:])
+
+	G(ctx.h[:], ctx.v_0[:], ctx.n[:])
+	G(ctx.h[:], ctx.v_0[:], ctx.sigma[:])
+
+	if ctx.is256 {
+		copy(hash[:], ctx.h[32:])
+	} else {
+		copy(hash[:], ctx.h[:])
+	}
+}

core/crypto/tiger/tiger.odin

@@ -0,0 +1,331 @@
+package tiger
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Interface for the Tiger1 variant of the Tiger hashing algorithm as defined in <https://www.cs.technion.ac.il/~biham/Reports/Tiger/>
+*/
+
+import "core:os"
+import "core:io"
+
+import "../botan"
+import "../_ctx"
+import "../_tiger"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_16  = hash_bytes_odin_16
+    ctx.hash_file_16   = hash_file_odin_16
+    ctx.hash_stream_16 = hash_stream_odin_16
+    ctx.hash_bytes_20  = hash_bytes_odin_20
+    ctx.hash_file_20   = hash_file_odin_20
+    ctx.hash_stream_20 = hash_stream_odin_20
+    ctx.hash_bytes_24  = hash_bytes_odin_24
+    ctx.hash_file_24   = hash_file_odin_24
+    ctx.hash_stream_24 = hash_stream_odin_24
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan assigns the internal vtable of the hash context to use the Botan bindings
+use_botan :: #force_inline proc() {
+    botan.assign_hash_vtable(_hash_impl, botan.HASH_TIGER)
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+/*
+    High level API
+*/
+
+// hash_string_128 will hash the given input and return the
+// computed hash
+hash_string_128 :: proc(data: string) -> [16]byte {
+    return hash_bytes_128(transmute([]byte)(data))
+}
+
+// hash_bytes_128 will hash the given input and return the
+// computed hash
+hash_bytes_128 :: proc(data: []byte) -> [16]byte {
+    _create_tiger_ctx(16)
+    return _hash_impl->hash_bytes_16(data)
+}
+
+// hash_stream_128 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_128 :: proc(s: io.Stream) -> ([16]byte, bool) {
+    _create_tiger_ctx(16)
+    return _hash_impl->hash_stream_16(s)
+}
+
+// hash_file_128 will read the file provided by the given handle
+// and compute a hash
+hash_file_128 :: proc(hd: os.Handle, load_at_once := false) -> ([16]byte, bool) {
+    _create_tiger_ctx(16)
+    return _hash_impl->hash_file_16(hd, load_at_once)
+}
+
+hash_128 :: proc {
+    hash_stream_128,
+    hash_file_128,
+    hash_bytes_128,
+    hash_string_128,
+}
+
+// hash_string_160 will hash the given input and return the
+// computed hash
+hash_string_160 :: proc(data: string) -> [20]byte {
+    return hash_bytes_160(transmute([]byte)(data))
+}
+
+// hash_bytes_160 will hash the given input and return the
+// computed hash
+hash_bytes_160 :: proc(data: []byte) -> [20]byte {
+    _create_tiger_ctx(20)
+    return _hash_impl->hash_bytes_20(data)
+}
+
+// hash_stream_160 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_160 :: proc(s: io.Stream) -> ([20]byte, bool) {
+    _create_tiger_ctx(20)
+    return _hash_impl->hash_stream_20(s)
+}
+
+// hash_file_160 will read the file provided by the given handle
+// and compute a hash
+hash_file_160 :: proc(hd: os.Handle, load_at_once := false) -> ([20]byte, bool) {
+    _create_tiger_ctx(20)
+    return _hash_impl->hash_file_20(hd, load_at_once)
+}
+
+hash_160 :: proc {
+    hash_stream_160,
+    hash_file_160,
+    hash_bytes_160,
+    hash_string_160,
+}
+
+// hash_string_192 will hash the given input and return the
+// computed hash
+hash_string_192 :: proc(data: string) -> [24]byte {
+    return hash_bytes_192(transmute([]byte)(data))
+}
+
+// hash_bytes_192 will hash the given input and return the
+// computed hash
+hash_bytes_192 :: proc(data: []byte) -> [24]byte {
+    _create_tiger_ctx(24)
+    return _hash_impl->hash_bytes_24(data)
+}
+
+// hash_stream_192 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_192 :: proc(s: io.Stream) -> ([24]byte, bool) {
+    _create_tiger_ctx(24)
+    return _hash_impl->hash_stream_24(s)
+}
+
+// hash_file_192 will read the file provided by the given handle
+// and compute a hash
+hash_file_192 :: proc(hd: os.Handle, load_at_once := false) -> ([24]byte, bool) {
+    _create_tiger_ctx(24)
+    return _hash_impl->hash_file_24(hd, load_at_once)
+}
+
+hash_192 :: proc {
+    hash_stream_192,
+    hash_file_192,
+    hash_bytes_192,
+    hash_string_192,
+}
+
+hash_bytes_odin_16 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [16]byte {
+    hash: [16]byte
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.init_odin(&c)
+        _tiger.update_odin(&c, data)
+        _tiger.final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_16 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([16]byte, bool) {
+    hash: [16]byte
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _tiger.update_odin(&c, buf[:read])
+            } 
+        }
+        _tiger.final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_16 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([16]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_16(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_16(ctx, buf[:]), ok
+        }
+    }
+    return [16]byte{}, false
+}
+
+hash_bytes_odin_20 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [20]byte {
+    hash: [20]byte
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.init_odin(&c)
+        _tiger.update_odin(&c, data)
+        _tiger.final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_20 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([20]byte, bool) {
+    hash: [20]byte
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _tiger.update_odin(&c, buf[:read])
+            } 
+        }
+        _tiger.final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_20 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([20]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_20(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_20(ctx, buf[:]), ok
+        }
+    }
+    return [20]byte{}, false
+}
+
+hash_bytes_odin_24 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [24]byte {
+    hash: [24]byte
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.init_odin(&c)
+        _tiger.update_odin(&c, data)
+        _tiger.final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_24 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([24]byte, bool) {
+    hash: [24]byte
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _tiger.update_odin(&c, buf[:read])
+            }
+        }
+        _tiger.final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_24 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([24]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_24(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_24(ctx, buf[:]), ok
+        }
+    }
+    return [24]byte{}, false
+}
+
+@(private)
+_create_tiger_ctx :: #force_inline proc(hash_size: int) {
+    ctx: _tiger.Tiger_Context
+    ctx.ver = 1
+    _hash_impl.internal_ctx = ctx
+    switch hash_size {
+        case 16: _hash_impl.hash_size = ._16
+        case 20: _hash_impl.hash_size = ._20
+        case 24: _hash_impl.hash_size = ._24
+    }
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    #partial switch ctx.hash_size {
+        case ._16: _create_tiger_ctx(16)
+        case ._20: _create_tiger_ctx(20)
+        case ._24: _create_tiger_ctx(24)
+    }
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.final_odin(&c, hash)
+    }
+}

core/crypto/tiger2/tiger2.odin

@@ -0,0 +1,331 @@
+package tiger2
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Interface for the Tiger2 variant of the Tiger hashing algorithm as defined in <https://www.cs.technion.ac.il/~biham/Reports/Tiger/>
+*/
+
+import "core:os"
+import "core:io"
+
+import "../_ctx"
+import "../_tiger"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_16  = hash_bytes_odin_16
+    ctx.hash_file_16   = hash_file_odin_16
+    ctx.hash_stream_16 = hash_stream_odin_16
+    ctx.hash_bytes_20  = hash_bytes_odin_20
+    ctx.hash_file_20   = hash_file_odin_20
+    ctx.hash_stream_20 = hash_stream_odin_20
+    ctx.hash_bytes_24  = hash_bytes_odin_24
+    ctx.hash_file_24   = hash_file_odin_24
+    ctx.hash_stream_24 = hash_stream_odin_24
+    ctx.init           = _init_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan does nothing, since Tiger2 is not available in Botan
+@(warning="Tiger2 is not provided by the Botan API. Odin implementation will be used")
+use_botan :: #force_inline proc() {
+    use_odin()
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+/*
+    High level API
+*/
+
+// hash_string_128 will hash the given input and return the
+// computed hash
+hash_string_128 :: proc(data: string) -> [16]byte {
+    return hash_bytes_128(transmute([]byte)(data))
+}
+
+// hash_bytes_128 will hash the given input and return the
+// computed hash
+hash_bytes_128 :: proc(data: []byte) -> [16]byte {
+    _create_tiger2_ctx(16)
+    return _hash_impl->hash_bytes_16(data)
+}
+
+// hash_stream_128 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_128 :: proc(s: io.Stream) -> ([16]byte, bool) {
+    _create_tiger2_ctx(16)
+    return _hash_impl->hash_stream_16(s)
+}
+
+// hash_file_128 will read the file provided by the given handle
+// and compute a hash
+hash_file_128 :: proc(hd: os.Handle, load_at_once := false) -> ([16]byte, bool) {
+    _create_tiger2_ctx(16)
+    return _hash_impl->hash_file_16(hd, load_at_once)
+}
+
+hash_128 :: proc {
+    hash_stream_128,
+    hash_file_128,
+    hash_bytes_128,
+    hash_string_128,
+}
+
+// hash_string_160 will hash the given input and return the
+// computed hash
+hash_string_160 :: proc(data: string) -> [20]byte {
+    return hash_bytes_160(transmute([]byte)(data))
+}
+
+// hash_bytes_160 will hash the given input and return the
+// computed hash
+hash_bytes_160 :: proc(data: []byte) -> [20]byte {
+    _create_tiger2_ctx(20)
+    return _hash_impl->hash_bytes_20(data)
+}
+
+// hash_stream_160 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_160 :: proc(s: io.Stream) -> ([20]byte, bool) {
+    _create_tiger2_ctx(20)
+    return _hash_impl->hash_stream_20(s)
+}
+
+// hash_file_160 will read the file provided by the given handle
+// and compute a hash
+hash_file_160 :: proc(hd: os.Handle, load_at_once := false) -> ([20]byte, bool) {
+    _create_tiger2_ctx(20)
+    return _hash_impl->hash_file_20(hd, load_at_once)
+}
+
+hash_160 :: proc {
+    hash_stream_160,
+    hash_file_160,
+    hash_bytes_160,
+    hash_string_160,
+}
+
+// hash_string_192 will hash the given input and return the
+// computed hash
+hash_string_192 :: proc(data: string) -> [24]byte {
+    return hash_bytes_192(transmute([]byte)(data))
+}
+
+// hash_bytes_192 will hash the given input and return the
+// computed hash
+hash_bytes_192 :: proc(data: []byte) -> [24]byte {
+    _create_tiger2_ctx(24)
+    return _hash_impl->hash_bytes_24(data)
+}
+
+// hash_stream_192 will read the stream in chunks and compute a
+// hash from its contents
+hash_stream_192 :: proc(s: io.Stream) -> ([24]byte, bool) {
+    _create_tiger2_ctx(24)
+    return _hash_impl->hash_stream_24(s)
+}
+
+// hash_file_192 will read the file provided by the given handle
+// and compute a hash
+hash_file_192 :: proc(hd: os.Handle, load_at_once := false) -> ([24]byte, bool) {
+    _create_tiger2_ctx(24)
+    return _hash_impl->hash_file_24(hd, load_at_once)
+}
+
+hash_192 :: proc {
+    hash_stream_192,
+    hash_file_192,
+    hash_bytes_192,
+    hash_string_192,
+}
+
+hash_bytes_odin_16 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [16]byte {
+    hash: [16]byte
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.init_odin(&c)
+        _tiger.update_odin(&c, data)
+        _tiger.final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_16 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([16]byte, bool) {
+    hash: [16]byte
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _tiger.update_odin(&c, buf[:read])
+            } 
+        }
+        _tiger.final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_16 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([16]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_16(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_16(ctx, buf[:]), ok
+        }
+    }
+    return [16]byte{}, false
+}
+
+hash_bytes_odin_20 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [20]byte {
+    hash: [20]byte
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.init_odin(&c)
+        _tiger.update_odin(&c, data)
+        _tiger.final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_20 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([20]byte, bool) {
+    hash: [20]byte
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _tiger.update_odin(&c, buf[:read])
+            } 
+        }
+        _tiger.final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_20 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([20]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_20(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_20(ctx, buf[:]), ok
+        }
+    }
+    return [20]byte{}, false
+}
+
+hash_bytes_odin_24 :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [24]byte {
+    hash: [24]byte
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.init_odin(&c)
+        _tiger.update_odin(&c, data)
+        _tiger.final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin_24 :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([24]byte, bool) {
+    hash: [24]byte
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.init_odin(&c)
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                _tiger.update_odin(&c, buf[:read])
+            } 
+        }
+        _tiger.final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin_24 :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([24]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin_24(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin_24(ctx, buf[:]), ok
+        }
+    }
+    return [24]byte{}, false
+}
+
+@(private)
+_create_tiger2_ctx :: #force_inline proc(hash_size: int) {
+    ctx: _tiger.Tiger_Context
+    ctx.ver = 2
+    _hash_impl.internal_ctx = ctx
+    switch hash_size {
+        case 16: _hash_impl.hash_size = ._16
+        case 20: _hash_impl.hash_size = ._20
+        case 24: _hash_impl.hash_size = ._24
+    }
+}
+
+@(private)
+_init_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    #partial switch ctx.hash_size {
+        case ._16: _create_tiger2_ctx(16)
+        case ._20: _create_tiger2_ctx(20)
+        case ._24: _create_tiger2_ctx(24)
+    }
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.init_odin(&c)
+    }
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(_tiger.Tiger_Context); ok {
+        _tiger.final_odin(&c, hash)
+    }
+}

core/crypto/util/util.odin

@@ -0,0 +1,144 @@
+package util
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+
+    Various utility procedures
+*/
+
+import "core:mem"
+
+// @note(bp): this can replace the other two
+cast_slice :: #force_inline proc "contextless" ($D: typeid/[]$DE, src: $S/[]$SE) -> D {
+    src := src
+    dst := (^mem.Raw_Slice)(&src)
+
+    when size_of(DE) < size_of(SE) {
+        when size_of(DE) % size_of(SE) == 0 {
+            dst.len /= size_of(SE) / size_of(DE)
+        } else {
+            dst.len *= size_of(SE)
+            dst.len /= size_of(DE)
+        }
+    } else when size_of(DE) > size_of(SE) {
+        when size_of(DE) % size_of(SE) == 0 {
+            dst.len *= size_of(DE) / size_of(SE)
+        } else {
+            dst.len *= size_of(SE)
+            dst.len /= size_of(DE)
+        }
+    } else when size_of(DE) != size_of(SE) {
+        #assert(size_of(DE) % size_of(SE) == 0, "Different size detected")
+        dst.len *= size_of(SE)
+        dst.len /= size_of(DE)
+    }
+
+    return (^D)(dst)^
+}
+
+bytes_to_slice :: #force_inline proc "contextless" ($T: typeid/[]$E, bytes: []byte) -> T {
+    s := transmute(mem.Raw_Slice)bytes
+    s.len /= size_of(E)
+    return transmute(T)s
+}
+
+slice_to_bytes :: #force_inline proc "contextless" (slice: $E/[]$T) -> []byte {
+    s := transmute(mem.Raw_Slice)slice
+    s.len *= size_of(T)
+    return transmute([]byte)s
+}
+
+ROTL16 :: #force_inline proc "contextless" (a, b: u16) -> u16 {
+    return ((a << b) | (a >> (16 - b)))
+}
+
+ROTR16 :: #force_inline proc "contextless" (a, b: u16) -> u16 {
+    return ((a >> b) | (a << (16 - b)))
+}
+
+ROTL32 :: #force_inline proc "contextless"(a: u32, b: int) -> u32 {
+    s := uint(b) & 31
+    return (a << s) | (a >> (32 - s))
+}
+
+ROTR32 :: #force_inline proc "contextless" (a: u32, b: int) -> u32 {
+    s := uint(b) & 31
+    return (a >> s) | (a << (32 - s))
+}
+
+ROTL64 :: #force_inline proc "contextless" (a, b: u64) -> u64 {
+    return ((a << b) | (a >> (64 - b)))
+}
+
+ROTR64 :: #force_inline proc "contextless" (a, b: u64) -> u64 {
+    return ((a >> b) | (a << (64 - b)))
+}
+
+ROTL128 :: #force_inline proc "contextless" (a, b, c, d: ^u32, n: uint) {
+    a, b, c, d := a, b, c, d
+    t := a^ >> (32 - n)
+    a^ = ((a^ << n) | (b^ >> (32 - n)))
+    b^ = ((b^ << n) | (c^ >> (32 - n)))
+    c^ = ((c^ << n) | (d^ >> (32 - n)))
+    d^ = ((d^ << n) | t)
+}
+
+U32_LE :: #force_inline proc "contextless" (b: []byte) -> u32 {
+    return u32(b[0]) | u32(b[1]) << 8 | u32(b[2]) << 16 | u32(b[3]) << 24
+}
+
+U64_LE :: #force_inline proc "contextless" (b: []byte) -> u64 {
+    return u64(b[0])       | u64(b[1]) << 8  | u64(b[2]) << 16 | u64(b[3]) << 24 |
+           u64(b[4]) << 32 | u64(b[5]) << 40 | u64(b[6]) << 48 | u64(b[7]) << 56
+}
+
+U64_BE :: #force_inline proc "contextless" (b: []byte) -> u64 {
+    return u64(b[7])       | u64(b[6]) << 8  | u64(b[5]) << 16 | u64(b[4]) << 24 |
+           u64(b[3]) << 32 | u64(b[2]) << 40 | u64(b[1]) << 48 | u64(b[0]) << 56
+}
+
+PUT_U64_LE :: #force_inline proc "contextless" (b: []byte, v: u64) {
+    b[0] = byte(v)
+    b[1] = byte(v >> 8)
+    b[2] = byte(v >> 16)
+    b[3] = byte(v >> 24)
+    b[4] = byte(v >> 32)
+    b[5] = byte(v >> 40)
+    b[6] = byte(v >> 48)
+    b[7] = byte(v >> 56)
+}
+
+PUT_U32_LE :: #force_inline proc "contextless" (b: []byte, v: u32) {
+    b[0] = byte(v)
+    b[1] = byte(v >> 8)
+    b[2] = byte(v >> 16)
+    b[3] = byte(v >> 24)
+}
+
+PUT_U32_BE :: #force_inline proc "contextless" (b: []byte, v: u32) {
+    b[0] = byte(v >> 24)
+    b[1] = byte(v >> 16)
+    b[2] = byte(v >> 8)
+    b[3] = byte(v)
+}
+
+PUT_U64_BE :: #force_inline proc "contextless" (b: []byte, v: u64) {
+    b[0] = byte(v >> 56)
+    b[1] = byte(v >> 48)
+    b[2] = byte(v >> 40)
+    b[3] = byte(v >> 32)
+    b[4] = byte(v >> 24)
+    b[5] = byte(v >> 16)
+    b[6] = byte(v >> 8)
+    b[7] = byte(v)
+}
+
+XOR_BUF :: #force_inline proc "contextless" (input, output: []byte) {
+    for i := 0; i < len(input); i += 1 {
+        output[i] ~= input[i]
+    }
+}

core/crypto/whirlpool/whirlpool.odin

@@ -0,0 +1,870 @@
+package whirlpool
+
+/*
+    Copyright 2021 zhibog
+    Made available under the BSD-3 license.
+
+    List of contributors:
+        zhibog, dotbmp:  Initial implementation.
+        Jeroen van Rijn: Context design to be able to change from Odin implementation to bindings.
+
+    Implementation of the Whirlpool hashing algorithm, as defined in <https://web.archive.org/web/20171129084214/http://www.larc.usp.br/~pbarreto/WhirlpoolPage.html>
+*/
+
+import "core:os"
+import "core:io"
+
+import "../botan"
+import "../_ctx"
+import "../util"
+
+/*
+    Context initialization and switching between the Odin implementation and the bindings
+*/
+
+USE_BOTAN_LIB :: bool(#config(USE_BOTAN_LIB, false))
+
+@(private)
+_init_vtable :: #force_inline proc() -> ^_ctx.Hash_Context {
+    ctx := _ctx._init_vtable()
+    when USE_BOTAN_LIB {
+        use_botan()
+    } else {
+        _assign_hash_vtable(ctx)
+    }
+    return ctx
+}
+
+@(private)
+_assign_hash_vtable :: #force_inline proc(ctx: ^_ctx.Hash_Context) {
+    ctx.hash_bytes_64  = hash_bytes_odin
+    ctx.hash_file_64   = hash_file_odin
+    ctx.hash_stream_64 = hash_stream_odin
+    ctx.update         = _update_odin
+    ctx.final          = _final_odin
+}
+
+_hash_impl := _init_vtable()
+
+// use_botan assigns the internal vtable of the hash context to use the Botan bindings
+use_botan :: #force_inline proc() {
+    botan.assign_hash_vtable(_hash_impl, botan.HASH_WHIRLPOOL)
+}
+
+// use_odin assigns the internal vtable of the hash context to use the Odin implementation
+use_odin :: #force_inline proc() {
+    _assign_hash_vtable(_hash_impl)
+}
+
+/*
+    High level API
+*/
+
+// hash_string will hash the given input and return the
+// computed hash
+hash_string :: proc(data: string) -> [64]byte {
+    return hash_bytes(transmute([]byte)(data))
+}
+
+// hash_bytes will hash the given input and return the
+// computed hash
+hash_bytes :: proc(data: []byte) -> [64]byte {
+    _create_whirlpool_ctx()
+    return _hash_impl->hash_bytes_64(data)
+}
+
+// hash_stream will read the stream in chunks and compute a
+// hash from its contents
+hash_stream :: proc(s: io.Stream) -> ([64]byte, bool) {
+    _create_whirlpool_ctx()
+    return _hash_impl->hash_stream_64(s)
+}
+
+// hash_file will read the file provided by the given handle
+// and compute a hash
+hash_file :: proc(hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    _create_whirlpool_ctx()
+    return _hash_impl->hash_file_64(hd, load_at_once)
+}
+
+hash :: proc {
+    hash_stream,
+    hash_file,
+    hash_bytes,
+    hash_string,
+}
+
+/*
+    Low level API
+*/
+
+init :: proc(ctx: ^_ctx.Hash_Context) {
+    _hash_impl->init()
+}
+
+update :: proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    _hash_impl->update(data)
+}
+
+final :: proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    _hash_impl->final(hash)
+}
+
+hash_bytes_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) -> [64]byte {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(Whirlpool_Context); ok {
+        update_odin(&c, data)
+        final_odin(&c, hash[:])
+    }
+    return hash
+}
+
+hash_stream_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, fs: io.Stream) -> ([64]byte, bool) {
+    hash: [64]byte
+    if c, ok := ctx.internal_ctx.(Whirlpool_Context); ok {
+        buf := make([]byte, 512)
+        defer delete(buf)
+        read := 1
+        for read > 0 {
+            read, _ = fs->impl_read(buf)
+            if read > 0 {
+                update_odin(&c, buf[:read])
+            } 
+        }
+        final_odin(&c, hash[:])
+        return hash, true
+    } else {
+        return hash, false
+    }
+}
+
+hash_file_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hd: os.Handle, load_at_once := false) -> ([64]byte, bool) {
+    if !load_at_once {
+        return hash_stream_odin(ctx, os.stream_from_handle(hd))
+    } else {
+        if buf, ok := os.read_entire_file(hd); ok {
+            return hash_bytes_odin(ctx, buf[:]), ok
+        }
+    }
+    return [64]byte{}, false
+}
+
+@(private)
+_create_whirlpool_ctx :: #force_inline proc() {
+    ctx: Whirlpool_Context
+    _hash_impl.internal_ctx = ctx
+    _hash_impl.hash_size    = ._64
+}
+
+@(private)
+_update_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, data: []byte) {
+    if c, ok := ctx.internal_ctx.(Whirlpool_Context); ok {
+        update_odin(&c, data)
+    }
+}
+
+@(private)
+_final_odin :: #force_inline proc(ctx: ^_ctx.Hash_Context, hash: []byte) {
+    if c, ok := ctx.internal_ctx.(Whirlpool_Context); ok {
+        final_odin(&c, hash)
+    }
+}
+
+/*
+	Whirlpool implementation
+*/
+
+ROUNDS :: 10
+
+Whirlpool_Context :: struct {
+    bitlength:   [32]byte,
+    buffer:      [64]byte,
+    buffer_bits: int,
+    buffer_pos:  int,
+    hash:        [8]u64,
+}
+
+C0 := [256]u64 {
+	0x18186018c07830d8, 0x23238c2305af4626, 0xc6c63fc67ef991b8, 0xe8e887e8136fcdfb,
+	0x878726874ca113cb, 0xb8b8dab8a9626d11, 0x0101040108050209, 0x4f4f214f426e9e0d,
+	0x3636d836adee6c9b, 0xa6a6a2a6590451ff, 0xd2d26fd2debdb90c, 0xf5f5f3f5fb06f70e,
+	0x7979f979ef80f296, 0x6f6fa16f5fcede30, 0x91917e91fcef3f6d, 0x52525552aa07a4f8,
+	0x60609d6027fdc047, 0xbcbccabc89766535, 0x9b9b569baccd2b37, 0x8e8e028e048c018a,
+	0xa3a3b6a371155bd2, 0x0c0c300c603c186c, 0x7b7bf17bff8af684, 0x3535d435b5e16a80,
+	0x1d1d741de8693af5, 0xe0e0a7e05347ddb3, 0xd7d77bd7f6acb321, 0xc2c22fc25eed999c,
+	0x2e2eb82e6d965c43, 0x4b4b314b627a9629, 0xfefedffea321e15d, 0x575741578216aed5,
+	0x15155415a8412abd, 0x7777c1779fb6eee8, 0x3737dc37a5eb6e92, 0xe5e5b3e57b56d79e,
+	0x9f9f469f8cd92313, 0xf0f0e7f0d317fd23, 0x4a4a354a6a7f9420, 0xdada4fda9e95a944,
+	0x58587d58fa25b0a2, 0xc9c903c906ca8fcf, 0x2929a429558d527c, 0x0a0a280a5022145a,
+	0xb1b1feb1e14f7f50, 0xa0a0baa0691a5dc9, 0x6b6bb16b7fdad614, 0x85852e855cab17d9,
+	0xbdbdcebd8173673c, 0x5d5d695dd234ba8f, 0x1010401080502090, 0xf4f4f7f4f303f507,
+	0xcbcb0bcb16c08bdd, 0x3e3ef83eedc67cd3, 0x0505140528110a2d, 0x676781671fe6ce78,
+	0xe4e4b7e47353d597, 0x27279c2725bb4e02, 0x4141194132588273, 0x8b8b168b2c9d0ba7,
+	0xa7a7a6a7510153f6, 0x7d7de97dcf94fab2, 0x95956e95dcfb3749, 0xd8d847d88e9fad56,
+	0xfbfbcbfb8b30eb70, 0xeeee9fee2371c1cd, 0x7c7ced7cc791f8bb, 0x6666856617e3cc71,
+	0xdddd53dda68ea77b, 0x17175c17b84b2eaf, 0x4747014702468e45, 0x9e9e429e84dc211a,
+	0xcaca0fca1ec589d4, 0x2d2db42d75995a58, 0xbfbfc6bf9179632e, 0x07071c07381b0e3f,
+	0xadad8ead012347ac, 0x5a5a755aea2fb4b0, 0x838336836cb51bef, 0x3333cc3385ff66b6,
+	0x636391633ff2c65c, 0x02020802100a0412, 0xaaaa92aa39384993, 0x7171d971afa8e2de,
+	0xc8c807c80ecf8dc6, 0x19196419c87d32d1, 0x494939497270923b, 0xd9d943d9869aaf5f,
+	0xf2f2eff2c31df931, 0xe3e3abe34b48dba8, 0x5b5b715be22ab6b9, 0x88881a8834920dbc,
+	0x9a9a529aa4c8293e, 0x262698262dbe4c0b, 0x3232c8328dfa64bf, 0xb0b0fab0e94a7d59,
+	0xe9e983e91b6acff2, 0x0f0f3c0f78331e77, 0xd5d573d5e6a6b733, 0x80803a8074ba1df4,
+	0xbebec2be997c6127, 0xcdcd13cd26de87eb, 0x3434d034bde46889, 0x48483d487a759032,
+	0xffffdbffab24e354, 0x7a7af57af78ff48d, 0x90907a90f4ea3d64, 0x5f5f615fc23ebe9d,
+	0x202080201da0403d, 0x6868bd6867d5d00f, 0x1a1a681ad07234ca, 0xaeae82ae192c41b7,
+	0xb4b4eab4c95e757d, 0x54544d549a19a8ce, 0x93937693ece53b7f, 0x222288220daa442f,
+	0x64648d6407e9c863, 0xf1f1e3f1db12ff2a, 0x7373d173bfa2e6cc, 0x12124812905a2482,
+	0x40401d403a5d807a, 0x0808200840281048, 0xc3c32bc356e89b95, 0xecec97ec337bc5df,
+	0xdbdb4bdb9690ab4d, 0xa1a1bea1611f5fc0, 0x8d8d0e8d1c830791, 0x3d3df43df5c97ac8,
+	0x97976697ccf1335b, 0x0000000000000000, 0xcfcf1bcf36d483f9, 0x2b2bac2b4587566e,
+	0x7676c57697b3ece1, 0x8282328264b019e6, 0xd6d67fd6fea9b128, 0x1b1b6c1bd87736c3,
+	0xb5b5eeb5c15b7774, 0xafaf86af112943be, 0x6a6ab56a77dfd41d, 0x50505d50ba0da0ea,
+	0x45450945124c8a57, 0xf3f3ebf3cb18fb38, 0x3030c0309df060ad, 0xefef9bef2b74c3c4,
+	0x3f3ffc3fe5c37eda, 0x55554955921caac7, 0xa2a2b2a2791059db, 0xeaea8fea0365c9e9,
+	0x656589650fecca6a, 0xbabad2bab9686903, 0x2f2fbc2f65935e4a, 0xc0c027c04ee79d8e,
+	0xdede5fdebe81a160, 0x1c1c701ce06c38fc, 0xfdfdd3fdbb2ee746, 0x4d4d294d52649a1f,
+	0x92927292e4e03976, 0x7575c9758fbceafa, 0x06061806301e0c36, 0x8a8a128a249809ae,
+	0xb2b2f2b2f940794b, 0xe6e6bfe66359d185, 0x0e0e380e70361c7e, 0x1f1f7c1ff8633ee7,
+	0x6262956237f7c455, 0xd4d477d4eea3b53a, 0xa8a89aa829324d81, 0x96966296c4f43152,
+	0xf9f9c3f99b3aef62, 0xc5c533c566f697a3, 0x2525942535b14a10, 0x59597959f220b2ab,
+	0x84842a8454ae15d0, 0x7272d572b7a7e4c5, 0x3939e439d5dd72ec, 0x4c4c2d4c5a619816,
+	0x5e5e655eca3bbc94, 0x7878fd78e785f09f, 0x3838e038ddd870e5, 0x8c8c0a8c14860598,
+	0xd1d163d1c6b2bf17, 0xa5a5aea5410b57e4, 0xe2e2afe2434dd9a1, 0x616199612ff8c24e,
+	0xb3b3f6b3f1457b42, 0x2121842115a54234, 0x9c9c4a9c94d62508, 0x1e1e781ef0663cee,
+	0x4343114322528661, 0xc7c73bc776fc93b1, 0xfcfcd7fcb32be54f, 0x0404100420140824,
+	0x51515951b208a2e3, 0x99995e99bcc72f25, 0x6d6da96d4fc4da22, 0x0d0d340d68391a65,
+	0xfafacffa8335e979, 0xdfdf5bdfb684a369, 0x7e7ee57ed79bfca9, 0x242490243db44819,
+	0x3b3bec3bc5d776fe, 0xabab96ab313d4b9a, 0xcece1fce3ed181f0, 0x1111441188552299,
+	0x8f8f068f0c890383, 0x4e4e254e4a6b9c04, 0xb7b7e6b7d1517366, 0xebeb8beb0b60cbe0,
+	0x3c3cf03cfdcc78c1, 0x81813e817cbf1ffd, 0x94946a94d4fe3540, 0xf7f7fbf7eb0cf31c,
+	0xb9b9deb9a1676f18, 0x13134c13985f268b, 0x2c2cb02c7d9c5851, 0xd3d36bd3d6b8bb05,
+	0xe7e7bbe76b5cd38c, 0x6e6ea56e57cbdc39, 0xc4c437c46ef395aa, 0x03030c03180f061b,
+	0x565645568a13acdc, 0x44440d441a49885e, 0x7f7fe17fdf9efea0, 0xa9a99ea921374f88,
+	0x2a2aa82a4d825467, 0xbbbbd6bbb16d6b0a, 0xc1c123c146e29f87, 0x53535153a202a6f1,
+	0xdcdc57dcae8ba572, 0x0b0b2c0b58271653, 0x9d9d4e9d9cd32701, 0x6c6cad6c47c1d82b,
+	0x3131c43195f562a4, 0x7474cd7487b9e8f3, 0xf6f6fff6e309f115, 0x464605460a438c4c,
+	0xacac8aac092645a5, 0x89891e893c970fb5, 0x14145014a04428b4, 0xe1e1a3e15b42dfba,
+	0x16165816b04e2ca6, 0x3a3ae83acdd274f7, 0x6969b9696fd0d206, 0x09092409482d1241,
+	0x7070dd70a7ade0d7, 0xb6b6e2b6d954716f, 0xd0d067d0ceb7bd1e, 0xeded93ed3b7ec7d6,
+	0xcccc17cc2edb85e2, 0x424215422a578468, 0x98985a98b4c22d2c, 0xa4a4aaa4490e55ed,
+	0x2828a0285d885075, 0x5c5c6d5cda31b886, 0xf8f8c7f8933fed6b, 0x8686228644a411c2,
+}
+
+C1 := [256]u64 {
+	0xd818186018c07830, 0x2623238c2305af46, 0xb8c6c63fc67ef991, 0xfbe8e887e8136fcd,
+	0xcb878726874ca113, 0x11b8b8dab8a9626d, 0x0901010401080502, 0x0d4f4f214f426e9e,
+	0x9b3636d836adee6c, 0xffa6a6a2a6590451, 0x0cd2d26fd2debdb9, 0x0ef5f5f3f5fb06f7,
+	0x967979f979ef80f2, 0x306f6fa16f5fcede, 0x6d91917e91fcef3f, 0xf852525552aa07a4,
+	0x4760609d6027fdc0, 0x35bcbccabc897665, 0x379b9b569baccd2b, 0x8a8e8e028e048c01,
+	0xd2a3a3b6a371155b, 0x6c0c0c300c603c18, 0x847b7bf17bff8af6, 0x803535d435b5e16a,
+	0xf51d1d741de8693a, 0xb3e0e0a7e05347dd, 0x21d7d77bd7f6acb3, 0x9cc2c22fc25eed99,
+	0x432e2eb82e6d965c, 0x294b4b314b627a96, 0x5dfefedffea321e1, 0xd5575741578216ae,
+	0xbd15155415a8412a, 0xe87777c1779fb6ee, 0x923737dc37a5eb6e, 0x9ee5e5b3e57b56d7,
+	0x139f9f469f8cd923, 0x23f0f0e7f0d317fd, 0x204a4a354a6a7f94, 0x44dada4fda9e95a9,
+	0xa258587d58fa25b0, 0xcfc9c903c906ca8f, 0x7c2929a429558d52, 0x5a0a0a280a502214,
+	0x50b1b1feb1e14f7f, 0xc9a0a0baa0691a5d, 0x146b6bb16b7fdad6, 0xd985852e855cab17,
+	0x3cbdbdcebd817367, 0x8f5d5d695dd234ba, 0x9010104010805020, 0x07f4f4f7f4f303f5,
+	0xddcbcb0bcb16c08b, 0xd33e3ef83eedc67c, 0x2d0505140528110a, 0x78676781671fe6ce,
+	0x97e4e4b7e47353d5, 0x0227279c2725bb4e, 0x7341411941325882, 0xa78b8b168b2c9d0b,
+	0xf6a7a7a6a7510153, 0xb27d7de97dcf94fa, 0x4995956e95dcfb37, 0x56d8d847d88e9fad,
+	0x70fbfbcbfb8b30eb, 0xcdeeee9fee2371c1, 0xbb7c7ced7cc791f8, 0x716666856617e3cc,
+	0x7bdddd53dda68ea7, 0xaf17175c17b84b2e, 0x454747014702468e, 0x1a9e9e429e84dc21,
+	0xd4caca0fca1ec589, 0x582d2db42d75995a, 0x2ebfbfc6bf917963, 0x3f07071c07381b0e,
+	0xacadad8ead012347, 0xb05a5a755aea2fb4, 0xef838336836cb51b, 0xb63333cc3385ff66,
+	0x5c636391633ff2c6, 0x1202020802100a04, 0x93aaaa92aa393849, 0xde7171d971afa8e2,
+	0xc6c8c807c80ecf8d, 0xd119196419c87d32, 0x3b49493949727092, 0x5fd9d943d9869aaf,
+	0x31f2f2eff2c31df9, 0xa8e3e3abe34b48db, 0xb95b5b715be22ab6, 0xbc88881a8834920d,
+	0x3e9a9a529aa4c829, 0x0b262698262dbe4c, 0xbf3232c8328dfa64, 0x59b0b0fab0e94a7d,
+	0xf2e9e983e91b6acf, 0x770f0f3c0f78331e, 0x33d5d573d5e6a6b7, 0xf480803a8074ba1d,
+	0x27bebec2be997c61, 0xebcdcd13cd26de87, 0x893434d034bde468, 0x3248483d487a7590,
+	0x54ffffdbffab24e3, 0x8d7a7af57af78ff4, 0x6490907a90f4ea3d, 0x9d5f5f615fc23ebe,
+	0x3d202080201da040, 0x0f6868bd6867d5d0, 0xca1a1a681ad07234, 0xb7aeae82ae192c41,
+	0x7db4b4eab4c95e75, 0xce54544d549a19a8, 0x7f93937693ece53b, 0x2f222288220daa44,
+	0x6364648d6407e9c8, 0x2af1f1e3f1db12ff, 0xcc7373d173bfa2e6, 0x8212124812905a24,
+	0x7a40401d403a5d80, 0x4808082008402810, 0x95c3c32bc356e89b, 0xdfecec97ec337bc5,
+	0x4ddbdb4bdb9690ab, 0xc0a1a1bea1611f5f, 0x918d8d0e8d1c8307, 0xc83d3df43df5c97a,
+	0x5b97976697ccf133, 0x0000000000000000, 0xf9cfcf1bcf36d483, 0x6e2b2bac2b458756,
+	0xe17676c57697b3ec, 0xe68282328264b019, 0x28d6d67fd6fea9b1, 0xc31b1b6c1bd87736,
+	0x74b5b5eeb5c15b77, 0xbeafaf86af112943, 0x1d6a6ab56a77dfd4, 0xea50505d50ba0da0,
+	0x5745450945124c8a, 0x38f3f3ebf3cb18fb, 0xad3030c0309df060, 0xc4efef9bef2b74c3,
+	0xda3f3ffc3fe5c37e, 0xc755554955921caa, 0xdba2a2b2a2791059, 0xe9eaea8fea0365c9,
+	0x6a656589650fecca, 0x03babad2bab96869, 0x4a2f2fbc2f65935e, 0x8ec0c027c04ee79d,
+	0x60dede5fdebe81a1, 0xfc1c1c701ce06c38, 0x46fdfdd3fdbb2ee7, 0x1f4d4d294d52649a,
+	0x7692927292e4e039, 0xfa7575c9758fbcea, 0x3606061806301e0c, 0xae8a8a128a249809,
+	0x4bb2b2f2b2f94079, 0x85e6e6bfe66359d1, 0x7e0e0e380e70361c, 0xe71f1f7c1ff8633e,
+	0x556262956237f7c4, 0x3ad4d477d4eea3b5, 0x81a8a89aa829324d, 0x5296966296c4f431,
+	0x62f9f9c3f99b3aef, 0xa3c5c533c566f697, 0x102525942535b14a, 0xab59597959f220b2,
+	0xd084842a8454ae15, 0xc57272d572b7a7e4, 0xec3939e439d5dd72, 0x164c4c2d4c5a6198,
+	0x945e5e655eca3bbc, 0x9f7878fd78e785f0, 0xe53838e038ddd870, 0x988c8c0a8c148605,
+	0x17d1d163d1c6b2bf, 0xe4a5a5aea5410b57, 0xa1e2e2afe2434dd9, 0x4e616199612ff8c2,
+	0x42b3b3f6b3f1457b, 0x342121842115a542, 0x089c9c4a9c94d625, 0xee1e1e781ef0663c,
+	0x6143431143225286, 0xb1c7c73bc776fc93, 0x4ffcfcd7fcb32be5, 0x2404041004201408,
+	0xe351515951b208a2, 0x2599995e99bcc72f, 0x226d6da96d4fc4da, 0x650d0d340d68391a,
+	0x79fafacffa8335e9, 0x69dfdf5bdfb684a3, 0xa97e7ee57ed79bfc, 0x19242490243db448,
+	0xfe3b3bec3bc5d776, 0x9aabab96ab313d4b, 0xf0cece1fce3ed181, 0x9911114411885522,
+	0x838f8f068f0c8903, 0x044e4e254e4a6b9c, 0x66b7b7e6b7d15173, 0xe0ebeb8beb0b60cb,
+	0xc13c3cf03cfdcc78, 0xfd81813e817cbf1f, 0x4094946a94d4fe35, 0x1cf7f7fbf7eb0cf3,
+	0x18b9b9deb9a1676f, 0x8b13134c13985f26, 0x512c2cb02c7d9c58, 0x05d3d36bd3d6b8bb,
+	0x8ce7e7bbe76b5cd3, 0x396e6ea56e57cbdc, 0xaac4c437c46ef395, 0x1b03030c03180f06,
+	0xdc565645568a13ac, 0x5e44440d441a4988, 0xa07f7fe17fdf9efe, 0x88a9a99ea921374f,
+	0x672a2aa82a4d8254, 0x0abbbbd6bbb16d6b, 0x87c1c123c146e29f, 0xf153535153a202a6,
+	0x72dcdc57dcae8ba5, 0x530b0b2c0b582716, 0x019d9d4e9d9cd327, 0x2b6c6cad6c47c1d8,
+	0xa43131c43195f562, 0xf37474cd7487b9e8, 0x15f6f6fff6e309f1, 0x4c464605460a438c,
+	0xa5acac8aac092645, 0xb589891e893c970f, 0xb414145014a04428, 0xbae1e1a3e15b42df,
+	0xa616165816b04e2c, 0xf73a3ae83acdd274, 0x066969b9696fd0d2, 0x4109092409482d12,
+	0xd77070dd70a7ade0, 0x6fb6b6e2b6d95471, 0x1ed0d067d0ceb7bd, 0xd6eded93ed3b7ec7,
+	0xe2cccc17cc2edb85, 0x68424215422a5784, 0x2c98985a98b4c22d, 0xeda4a4aaa4490e55,
+	0x752828a0285d8850, 0x865c5c6d5cda31b8, 0x6bf8f8c7f8933fed, 0xc28686228644a411,
+}
+
+C2 := [256]u64 {
+	0x30d818186018c078, 0x462623238c2305af, 0x91b8c6c63fc67ef9, 0xcdfbe8e887e8136f,
+	0x13cb878726874ca1, 0x6d11b8b8dab8a962, 0x0209010104010805, 0x9e0d4f4f214f426e,
+	0x6c9b3636d836adee, 0x51ffa6a6a2a65904, 0xb90cd2d26fd2debd, 0xf70ef5f5f3f5fb06,
+	0xf2967979f979ef80, 0xde306f6fa16f5fce, 0x3f6d91917e91fcef, 0xa4f852525552aa07,
+	0xc04760609d6027fd, 0x6535bcbccabc8976, 0x2b379b9b569baccd, 0x018a8e8e028e048c,
+	0x5bd2a3a3b6a37115, 0x186c0c0c300c603c, 0xf6847b7bf17bff8a, 0x6a803535d435b5e1,
+	0x3af51d1d741de869, 0xddb3e0e0a7e05347, 0xb321d7d77bd7f6ac, 0x999cc2c22fc25eed,
+	0x5c432e2eb82e6d96, 0x96294b4b314b627a, 0xe15dfefedffea321, 0xaed5575741578216,
+	0x2abd15155415a841, 0xeee87777c1779fb6, 0x6e923737dc37a5eb, 0xd79ee5e5b3e57b56,
+	0x23139f9f469f8cd9, 0xfd23f0f0e7f0d317, 0x94204a4a354a6a7f, 0xa944dada4fda9e95,
+	0xb0a258587d58fa25, 0x8fcfc9c903c906ca, 0x527c2929a429558d, 0x145a0a0a280a5022,
+	0x7f50b1b1feb1e14f, 0x5dc9a0a0baa0691a, 0xd6146b6bb16b7fda, 0x17d985852e855cab,
+	0x673cbdbdcebd8173, 0xba8f5d5d695dd234, 0x2090101040108050, 0xf507f4f4f7f4f303,
+	0x8bddcbcb0bcb16c0, 0x7cd33e3ef83eedc6, 0x0a2d050514052811, 0xce78676781671fe6,
+	0xd597e4e4b7e47353, 0x4e0227279c2725bb, 0x8273414119413258, 0x0ba78b8b168b2c9d,
+	0x53f6a7a7a6a75101, 0xfab27d7de97dcf94, 0x374995956e95dcfb, 0xad56d8d847d88e9f,
+	0xeb70fbfbcbfb8b30, 0xc1cdeeee9fee2371, 0xf8bb7c7ced7cc791, 0xcc716666856617e3,
+	0xa77bdddd53dda68e, 0x2eaf17175c17b84b, 0x8e45474701470246, 0x211a9e9e429e84dc,
+	0x89d4caca0fca1ec5, 0x5a582d2db42d7599, 0x632ebfbfc6bf9179, 0x0e3f07071c07381b,
+	0x47acadad8ead0123, 0xb4b05a5a755aea2f, 0x1bef838336836cb5, 0x66b63333cc3385ff,
+	0xc65c636391633ff2, 0x041202020802100a, 0x4993aaaa92aa3938, 0xe2de7171d971afa8,
+	0x8dc6c8c807c80ecf, 0x32d119196419c87d, 0x923b494939497270, 0xaf5fd9d943d9869a,
+	0xf931f2f2eff2c31d, 0xdba8e3e3abe34b48, 0xb6b95b5b715be22a, 0x0dbc88881a883492,
+	0x293e9a9a529aa4c8, 0x4c0b262698262dbe, 0x64bf3232c8328dfa, 0x7d59b0b0fab0e94a,
+	0xcff2e9e983e91b6a, 0x1e770f0f3c0f7833, 0xb733d5d573d5e6a6, 0x1df480803a8074ba,
+	0x6127bebec2be997c, 0x87ebcdcd13cd26de, 0x68893434d034bde4, 0x903248483d487a75,
+	0xe354ffffdbffab24, 0xf48d7a7af57af78f, 0x3d6490907a90f4ea, 0xbe9d5f5f615fc23e,
+	0x403d202080201da0, 0xd00f6868bd6867d5, 0x34ca1a1a681ad072, 0x41b7aeae82ae192c,
+	0x757db4b4eab4c95e, 0xa8ce54544d549a19, 0x3b7f93937693ece5, 0x442f222288220daa,
+	0xc86364648d6407e9, 0xff2af1f1e3f1db12, 0xe6cc7373d173bfa2, 0x248212124812905a,
+	0x807a40401d403a5d, 0x1048080820084028, 0x9b95c3c32bc356e8, 0xc5dfecec97ec337b,
+	0xab4ddbdb4bdb9690, 0x5fc0a1a1bea1611f, 0x07918d8d0e8d1c83, 0x7ac83d3df43df5c9,
+	0x335b97976697ccf1, 0x0000000000000000, 0x83f9cfcf1bcf36d4, 0x566e2b2bac2b4587,
+	0xece17676c57697b3, 0x19e68282328264b0, 0xb128d6d67fd6fea9, 0x36c31b1b6c1bd877,
+	0x7774b5b5eeb5c15b, 0x43beafaf86af1129, 0xd41d6a6ab56a77df, 0xa0ea50505d50ba0d,
+	0x8a5745450945124c, 0xfb38f3f3ebf3cb18, 0x60ad3030c0309df0, 0xc3c4efef9bef2b74,
+	0x7eda3f3ffc3fe5c3, 0xaac755554955921c, 0x59dba2a2b2a27910, 0xc9e9eaea8fea0365,
+	0xca6a656589650fec, 0x6903babad2bab968, 0x5e4a2f2fbc2f6593, 0x9d8ec0c027c04ee7,
+	0xa160dede5fdebe81, 0x38fc1c1c701ce06c, 0xe746fdfdd3fdbb2e, 0x9a1f4d4d294d5264,
+	0x397692927292e4e0, 0xeafa7575c9758fbc, 0x0c3606061806301e, 0x09ae8a8a128a2498,
+	0x794bb2b2f2b2f940, 0xd185e6e6bfe66359, 0x1c7e0e0e380e7036, 0x3ee71f1f7c1ff863,
+	0xc4556262956237f7, 0xb53ad4d477d4eea3, 0x4d81a8a89aa82932, 0x315296966296c4f4,
+	0xef62f9f9c3f99b3a, 0x97a3c5c533c566f6, 0x4a102525942535b1, 0xb2ab59597959f220,
+	0x15d084842a8454ae, 0xe4c57272d572b7a7, 0x72ec3939e439d5dd, 0x98164c4c2d4c5a61,
+	0xbc945e5e655eca3b, 0xf09f7878fd78e785, 0x70e53838e038ddd8, 0x05988c8c0a8c1486,
+	0xbf17d1d163d1c6b2, 0x57e4a5a5aea5410b, 0xd9a1e2e2afe2434d, 0xc24e616199612ff8,
+	0x7b42b3b3f6b3f145, 0x42342121842115a5, 0x25089c9c4a9c94d6, 0x3cee1e1e781ef066,
+	0x8661434311432252, 0x93b1c7c73bc776fc, 0xe54ffcfcd7fcb32b, 0x0824040410042014,
+	0xa2e351515951b208, 0x2f2599995e99bcc7, 0xda226d6da96d4fc4, 0x1a650d0d340d6839,
+	0xe979fafacffa8335, 0xa369dfdf5bdfb684, 0xfca97e7ee57ed79b, 0x4819242490243db4,
+	0x76fe3b3bec3bc5d7, 0x4b9aabab96ab313d, 0x81f0cece1fce3ed1, 0x2299111144118855,
+	0x03838f8f068f0c89, 0x9c044e4e254e4a6b, 0x7366b7b7e6b7d151, 0xcbe0ebeb8beb0b60,
+	0x78c13c3cf03cfdcc, 0x1ffd81813e817cbf, 0x354094946a94d4fe, 0xf31cf7f7fbf7eb0c,
+	0x6f18b9b9deb9a167, 0x268b13134c13985f, 0x58512c2cb02c7d9c, 0xbb05d3d36bd3d6b8,
+	0xd38ce7e7bbe76b5c, 0xdc396e6ea56e57cb, 0x95aac4c437c46ef3, 0x061b03030c03180f,
+	0xacdc565645568a13, 0x885e44440d441a49, 0xfea07f7fe17fdf9e, 0x4f88a9a99ea92137,
+	0x54672a2aa82a4d82, 0x6b0abbbbd6bbb16d, 0x9f87c1c123c146e2, 0xa6f153535153a202,
+	0xa572dcdc57dcae8b, 0x16530b0b2c0b5827, 0x27019d9d4e9d9cd3, 0xd82b6c6cad6c47c1,
+	0x62a43131c43195f5, 0xe8f37474cd7487b9, 0xf115f6f6fff6e309, 0x8c4c464605460a43,
+	0x45a5acac8aac0926, 0x0fb589891e893c97, 0x28b414145014a044, 0xdfbae1e1a3e15b42,
+	0x2ca616165816b04e, 0x74f73a3ae83acdd2, 0xd2066969b9696fd0, 0x124109092409482d,
+	0xe0d77070dd70a7ad, 0x716fb6b6e2b6d954, 0xbd1ed0d067d0ceb7, 0xc7d6eded93ed3b7e,
+	0x85e2cccc17cc2edb, 0x8468424215422a57, 0x2d2c98985a98b4c2, 0x55eda4a4aaa4490e,
+	0x50752828a0285d88, 0xb8865c5c6d5cda31, 0xed6bf8f8c7f8933f, 0x11c28686228644a4,
+}
+
+C3 := [256]u64 {
+	0x7830d818186018c0, 0xaf462623238c2305, 0xf991b8c6c63fc67e, 0x6fcdfbe8e887e813,
+	0xa113cb878726874c, 0x626d11b8b8dab8a9, 0x0502090101040108, 0x6e9e0d4f4f214f42,
+	0xee6c9b3636d836ad, 0x0451ffa6a6a2a659, 0xbdb90cd2d26fd2de, 0x06f70ef5f5f3f5fb,
+	0x80f2967979f979ef, 0xcede306f6fa16f5f, 0xef3f6d91917e91fc, 0x07a4f852525552aa,
+	0xfdc04760609d6027, 0x766535bcbccabc89, 0xcd2b379b9b569bac, 0x8c018a8e8e028e04,
+	0x155bd2a3a3b6a371, 0x3c186c0c0c300c60, 0x8af6847b7bf17bff, 0xe16a803535d435b5,
+	0x693af51d1d741de8, 0x47ddb3e0e0a7e053, 0xacb321d7d77bd7f6, 0xed999cc2c22fc25e,
+	0x965c432e2eb82e6d, 0x7a96294b4b314b62, 0x21e15dfefedffea3, 0x16aed55757415782,
+	0x412abd15155415a8, 0xb6eee87777c1779f, 0xeb6e923737dc37a5, 0x56d79ee5e5b3e57b,
+	0xd923139f9f469f8c, 0x17fd23f0f0e7f0d3, 0x7f94204a4a354a6a, 0x95a944dada4fda9e,
+	0x25b0a258587d58fa, 0xca8fcfc9c903c906, 0x8d527c2929a42955, 0x22145a0a0a280a50,
+	0x4f7f50b1b1feb1e1, 0x1a5dc9a0a0baa069, 0xdad6146b6bb16b7f, 0xab17d985852e855c,
+	0x73673cbdbdcebd81, 0x34ba8f5d5d695dd2, 0x5020901010401080, 0x03f507f4f4f7f4f3,
+	0xc08bddcbcb0bcb16, 0xc67cd33e3ef83eed, 0x110a2d0505140528, 0xe6ce78676781671f,
+	0x53d597e4e4b7e473, 0xbb4e0227279c2725, 0x5882734141194132, 0x9d0ba78b8b168b2c,
+	0x0153f6a7a7a6a751, 0x94fab27d7de97dcf, 0xfb374995956e95dc, 0x9fad56d8d847d88e,
+	0x30eb70fbfbcbfb8b, 0x71c1cdeeee9fee23, 0x91f8bb7c7ced7cc7, 0xe3cc716666856617,
+	0x8ea77bdddd53dda6, 0x4b2eaf17175c17b8, 0x468e454747014702, 0xdc211a9e9e429e84,
+	0xc589d4caca0fca1e, 0x995a582d2db42d75, 0x79632ebfbfc6bf91, 0x1b0e3f07071c0738,
+	0x2347acadad8ead01, 0x2fb4b05a5a755aea, 0xb51bef838336836c, 0xff66b63333cc3385,
+	0xf2c65c636391633f, 0x0a04120202080210, 0x384993aaaa92aa39, 0xa8e2de7171d971af,
+	0xcf8dc6c8c807c80e, 0x7d32d119196419c8, 0x70923b4949394972, 0x9aaf5fd9d943d986,
+	0x1df931f2f2eff2c3, 0x48dba8e3e3abe34b, 0x2ab6b95b5b715be2, 0x920dbc88881a8834,
+	0xc8293e9a9a529aa4, 0xbe4c0b262698262d, 0xfa64bf3232c8328d, 0x4a7d59b0b0fab0e9,
+	0x6acff2e9e983e91b, 0x331e770f0f3c0f78, 0xa6b733d5d573d5e6, 0xba1df480803a8074,
+	0x7c6127bebec2be99, 0xde87ebcdcd13cd26, 0xe468893434d034bd, 0x75903248483d487a,
+	0x24e354ffffdbffab, 0x8ff48d7a7af57af7, 0xea3d6490907a90f4, 0x3ebe9d5f5f615fc2,
+	0xa0403d202080201d, 0xd5d00f6868bd6867, 0x7234ca1a1a681ad0, 0x2c41b7aeae82ae19,
+	0x5e757db4b4eab4c9, 0x19a8ce54544d549a, 0xe53b7f93937693ec, 0xaa442f222288220d,
+	0xe9c86364648d6407, 0x12ff2af1f1e3f1db, 0xa2e6cc7373d173bf, 0x5a24821212481290,
+	0x5d807a40401d403a, 0x2810480808200840, 0xe89b95c3c32bc356, 0x7bc5dfecec97ec33,
+	0x90ab4ddbdb4bdb96, 0x1f5fc0a1a1bea161, 0x8307918d8d0e8d1c, 0xc97ac83d3df43df5,
+	0xf1335b97976697cc, 0x0000000000000000, 0xd483f9cfcf1bcf36, 0x87566e2b2bac2b45,
+	0xb3ece17676c57697, 0xb019e68282328264, 0xa9b128d6d67fd6fe, 0x7736c31b1b6c1bd8,
+	0x5b7774b5b5eeb5c1, 0x2943beafaf86af11, 0xdfd41d6a6ab56a77, 0x0da0ea50505d50ba,
+	0x4c8a574545094512, 0x18fb38f3f3ebf3cb, 0xf060ad3030c0309d, 0x74c3c4efef9bef2b,
+	0xc37eda3f3ffc3fe5, 0x1caac75555495592, 0x1059dba2a2b2a279, 0x65c9e9eaea8fea03,
+	0xecca6a656589650f, 0x686903babad2bab9, 0x935e4a2f2fbc2f65, 0xe79d8ec0c027c04e,
+	0x81a160dede5fdebe, 0x6c38fc1c1c701ce0, 0x2ee746fdfdd3fdbb, 0x649a1f4d4d294d52,
+	0xe0397692927292e4, 0xbceafa7575c9758f, 0x1e0c360606180630, 0x9809ae8a8a128a24,
+	0x40794bb2b2f2b2f9, 0x59d185e6e6bfe663, 0x361c7e0e0e380e70, 0x633ee71f1f7c1ff8,
+	0xf7c4556262956237, 0xa3b53ad4d477d4ee, 0x324d81a8a89aa829, 0xf4315296966296c4,
+	0x3aef62f9f9c3f99b, 0xf697a3c5c533c566, 0xb14a102525942535, 0x20b2ab59597959f2,
+	0xae15d084842a8454, 0xa7e4c57272d572b7, 0xdd72ec3939e439d5, 0x6198164c4c2d4c5a,
+	0x3bbc945e5e655eca, 0x85f09f7878fd78e7, 0xd870e53838e038dd, 0x8605988c8c0a8c14,
+	0xb2bf17d1d163d1c6, 0x0b57e4a5a5aea541, 0x4dd9a1e2e2afe243, 0xf8c24e616199612f,
+	0x457b42b3b3f6b3f1, 0xa542342121842115, 0xd625089c9c4a9c94, 0x663cee1e1e781ef0,
+	0x5286614343114322, 0xfc93b1c7c73bc776, 0x2be54ffcfcd7fcb3, 0x1408240404100420,
+	0x08a2e351515951b2, 0xc72f2599995e99bc, 0xc4da226d6da96d4f, 0x391a650d0d340d68,
+	0x35e979fafacffa83, 0x84a369dfdf5bdfb6, 0x9bfca97e7ee57ed7, 0xb44819242490243d,
+	0xd776fe3b3bec3bc5, 0x3d4b9aabab96ab31, 0xd181f0cece1fce3e, 0x5522991111441188,
+	0x8903838f8f068f0c, 0x6b9c044e4e254e4a, 0x517366b7b7e6b7d1, 0x60cbe0ebeb8beb0b,
+	0xcc78c13c3cf03cfd, 0xbf1ffd81813e817c, 0xfe354094946a94d4, 0x0cf31cf7f7fbf7eb,
+	0x676f18b9b9deb9a1, 0x5f268b13134c1398, 0x9c58512c2cb02c7d, 0xb8bb05d3d36bd3d6,
+	0x5cd38ce7e7bbe76b, 0xcbdc396e6ea56e57, 0xf395aac4c437c46e, 0x0f061b03030c0318,
+	0x13acdc565645568a, 0x49885e44440d441a, 0x9efea07f7fe17fdf, 0x374f88a9a99ea921,
+	0x8254672a2aa82a4d, 0x6d6b0abbbbd6bbb1, 0xe29f87c1c123c146, 0x02a6f153535153a2,
+	0x8ba572dcdc57dcae, 0x2716530b0b2c0b58, 0xd327019d9d4e9d9c, 0xc1d82b6c6cad6c47,
+	0xf562a43131c43195, 0xb9e8f37474cd7487, 0x09f115f6f6fff6e3, 0x438c4c464605460a,
+	0x2645a5acac8aac09, 0x970fb589891e893c, 0x4428b414145014a0, 0x42dfbae1e1a3e15b,
+	0x4e2ca616165816b0, 0xd274f73a3ae83acd, 0xd0d2066969b9696f, 0x2d12410909240948,
+	0xade0d77070dd70a7, 0x54716fb6b6e2b6d9, 0xb7bd1ed0d067d0ce, 0x7ec7d6eded93ed3b,
+	0xdb85e2cccc17cc2e, 0x578468424215422a, 0xc22d2c98985a98b4, 0x0e55eda4a4aaa449,
+	0x8850752828a0285d, 0x31b8865c5c6d5cda, 0x3fed6bf8f8c7f893, 0xa411c28686228644,
+}
+
+C4 := [256]u64 {
+	0xc07830d818186018, 0x05af462623238c23, 0x7ef991b8c6c63fc6, 0x136fcdfbe8e887e8,
+	0x4ca113cb87872687, 0xa9626d11b8b8dab8, 0x0805020901010401, 0x426e9e0d4f4f214f,
+	0xadee6c9b3636d836, 0x590451ffa6a6a2a6, 0xdebdb90cd2d26fd2, 0xfb06f70ef5f5f3f5,
+	0xef80f2967979f979, 0x5fcede306f6fa16f, 0xfcef3f6d91917e91, 0xaa07a4f852525552,
+	0x27fdc04760609d60, 0x89766535bcbccabc, 0xaccd2b379b9b569b, 0x048c018a8e8e028e,
+	0x71155bd2a3a3b6a3, 0x603c186c0c0c300c, 0xff8af6847b7bf17b, 0xb5e16a803535d435,
+	0xe8693af51d1d741d, 0x5347ddb3e0e0a7e0, 0xf6acb321d7d77bd7, 0x5eed999cc2c22fc2,
+	0x6d965c432e2eb82e, 0x627a96294b4b314b, 0xa321e15dfefedffe, 0x8216aed557574157,
+	0xa8412abd15155415, 0x9fb6eee87777c177, 0xa5eb6e923737dc37, 0x7b56d79ee5e5b3e5,
+	0x8cd923139f9f469f, 0xd317fd23f0f0e7f0, 0x6a7f94204a4a354a, 0x9e95a944dada4fda,
+	0xfa25b0a258587d58, 0x06ca8fcfc9c903c9, 0x558d527c2929a429, 0x5022145a0a0a280a,
+	0xe14f7f50b1b1feb1, 0x691a5dc9a0a0baa0, 0x7fdad6146b6bb16b, 0x5cab17d985852e85,
+	0x8173673cbdbdcebd, 0xd234ba8f5d5d695d, 0x8050209010104010, 0xf303f507f4f4f7f4,
+	0x16c08bddcbcb0bcb, 0xedc67cd33e3ef83e, 0x28110a2d05051405, 0x1fe6ce7867678167,
+	0x7353d597e4e4b7e4, 0x25bb4e0227279c27, 0x3258827341411941, 0x2c9d0ba78b8b168b,
+	0x510153f6a7a7a6a7, 0xcf94fab27d7de97d, 0xdcfb374995956e95, 0x8e9fad56d8d847d8,
+	0x8b30eb70fbfbcbfb, 0x2371c1cdeeee9fee, 0xc791f8bb7c7ced7c, 0x17e3cc7166668566,
+	0xa68ea77bdddd53dd, 0xb84b2eaf17175c17, 0x02468e4547470147, 0x84dc211a9e9e429e,
+	0x1ec589d4caca0fca, 0x75995a582d2db42d, 0x9179632ebfbfc6bf, 0x381b0e3f07071c07,
+	0x012347acadad8ead, 0xea2fb4b05a5a755a, 0x6cb51bef83833683, 0x85ff66b63333cc33,
+	0x3ff2c65c63639163, 0x100a041202020802, 0x39384993aaaa92aa, 0xafa8e2de7171d971,
+	0x0ecf8dc6c8c807c8, 0xc87d32d119196419, 0x7270923b49493949, 0x869aaf5fd9d943d9,
+	0xc31df931f2f2eff2, 0x4b48dba8e3e3abe3, 0xe22ab6b95b5b715b, 0x34920dbc88881a88,
+	0xa4c8293e9a9a529a, 0x2dbe4c0b26269826, 0x8dfa64bf3232c832, 0xe94a7d59b0b0fab0,
+	0x1b6acff2e9e983e9, 0x78331e770f0f3c0f, 0xe6a6b733d5d573d5, 0x74ba1df480803a80,
+	0x997c6127bebec2be, 0x26de87ebcdcd13cd, 0xbde468893434d034, 0x7a75903248483d48,
+	0xab24e354ffffdbff, 0xf78ff48d7a7af57a, 0xf4ea3d6490907a90, 0xc23ebe9d5f5f615f,
+	0x1da0403d20208020, 0x67d5d00f6868bd68, 0xd07234ca1a1a681a, 0x192c41b7aeae82ae,
+	0xc95e757db4b4eab4, 0x9a19a8ce54544d54, 0xece53b7f93937693, 0x0daa442f22228822,
+	0x07e9c86364648d64, 0xdb12ff2af1f1e3f1, 0xbfa2e6cc7373d173, 0x905a248212124812,
+	0x3a5d807a40401d40, 0x4028104808082008, 0x56e89b95c3c32bc3, 0x337bc5dfecec97ec,
+	0x9690ab4ddbdb4bdb, 0x611f5fc0a1a1bea1, 0x1c8307918d8d0e8d, 0xf5c97ac83d3df43d,
+	0xccf1335b97976697, 0x0000000000000000, 0x36d483f9cfcf1bcf, 0x4587566e2b2bac2b,
+	0x97b3ece17676c576, 0x64b019e682823282, 0xfea9b128d6d67fd6, 0xd87736c31b1b6c1b,
+	0xc15b7774b5b5eeb5, 0x112943beafaf86af, 0x77dfd41d6a6ab56a, 0xba0da0ea50505d50,
+	0x124c8a5745450945, 0xcb18fb38f3f3ebf3, 0x9df060ad3030c030, 0x2b74c3c4efef9bef,
+	0xe5c37eda3f3ffc3f, 0x921caac755554955, 0x791059dba2a2b2a2, 0x0365c9e9eaea8fea,
+	0x0fecca6a65658965, 0xb9686903babad2ba, 0x65935e4a2f2fbc2f, 0x4ee79d8ec0c027c0,
+	0xbe81a160dede5fde, 0xe06c38fc1c1c701c, 0xbb2ee746fdfdd3fd, 0x52649a1f4d4d294d,
+	0xe4e0397692927292, 0x8fbceafa7575c975, 0x301e0c3606061806, 0x249809ae8a8a128a,
+	0xf940794bb2b2f2b2, 0x6359d185e6e6bfe6, 0x70361c7e0e0e380e, 0xf8633ee71f1f7c1f,
+	0x37f7c45562629562, 0xeea3b53ad4d477d4, 0x29324d81a8a89aa8, 0xc4f4315296966296,
+	0x9b3aef62f9f9c3f9, 0x66f697a3c5c533c5, 0x35b14a1025259425, 0xf220b2ab59597959,
+	0x54ae15d084842a84, 0xb7a7e4c57272d572, 0xd5dd72ec3939e439, 0x5a6198164c4c2d4c,
+	0xca3bbc945e5e655e, 0xe785f09f7878fd78, 0xddd870e53838e038, 0x148605988c8c0a8c,
+	0xc6b2bf17d1d163d1, 0x410b57e4a5a5aea5, 0x434dd9a1e2e2afe2, 0x2ff8c24e61619961,
+	0xf1457b42b3b3f6b3, 0x15a5423421218421, 0x94d625089c9c4a9c, 0xf0663cee1e1e781e,
+	0x2252866143431143, 0x76fc93b1c7c73bc7, 0xb32be54ffcfcd7fc, 0x2014082404041004,
+	0xb208a2e351515951, 0xbcc72f2599995e99, 0x4fc4da226d6da96d, 0x68391a650d0d340d,
+	0x8335e979fafacffa, 0xb684a369dfdf5bdf, 0xd79bfca97e7ee57e, 0x3db4481924249024,
+	0xc5d776fe3b3bec3b, 0x313d4b9aabab96ab, 0x3ed181f0cece1fce, 0x8855229911114411,
+	0x0c8903838f8f068f, 0x4a6b9c044e4e254e, 0xd1517366b7b7e6b7, 0x0b60cbe0ebeb8beb,
+	0xfdcc78c13c3cf03c, 0x7cbf1ffd81813e81, 0xd4fe354094946a94, 0xeb0cf31cf7f7fbf7,
+	0xa1676f18b9b9deb9, 0x985f268b13134c13, 0x7d9c58512c2cb02c, 0xd6b8bb05d3d36bd3,
+	0x6b5cd38ce7e7bbe7, 0x57cbdc396e6ea56e, 0x6ef395aac4c437c4, 0x180f061b03030c03,
+	0x8a13acdc56564556, 0x1a49885e44440d44, 0xdf9efea07f7fe17f, 0x21374f88a9a99ea9,
+	0x4d8254672a2aa82a, 0xb16d6b0abbbbd6bb, 0x46e29f87c1c123c1, 0xa202a6f153535153,
+	0xae8ba572dcdc57dc, 0x582716530b0b2c0b, 0x9cd327019d9d4e9d, 0x47c1d82b6c6cad6c,
+	0x95f562a43131c431, 0x87b9e8f37474cd74, 0xe309f115f6f6fff6, 0x0a438c4c46460546,
+	0x092645a5acac8aac, 0x3c970fb589891e89, 0xa04428b414145014, 0x5b42dfbae1e1a3e1,
+	0xb04e2ca616165816, 0xcdd274f73a3ae83a, 0x6fd0d2066969b969, 0x482d124109092409,
+	0xa7ade0d77070dd70, 0xd954716fb6b6e2b6, 0xceb7bd1ed0d067d0, 0x3b7ec7d6eded93ed,
+	0x2edb85e2cccc17cc, 0x2a57846842421542, 0xb4c22d2c98985a98, 0x490e55eda4a4aaa4,
+	0x5d8850752828a028, 0xda31b8865c5c6d5c, 0x933fed6bf8f8c7f8, 0x44a411c286862286,
+}
+
+C5 := [256]u64 {
+	0x18c07830d8181860, 0x2305af462623238c, 0xc67ef991b8c6c63f, 0xe8136fcdfbe8e887,
+	0x874ca113cb878726, 0xb8a9626d11b8b8da, 0x0108050209010104, 0x4f426e9e0d4f4f21,
+	0x36adee6c9b3636d8, 0xa6590451ffa6a6a2, 0xd2debdb90cd2d26f, 0xf5fb06f70ef5f5f3,
+	0x79ef80f2967979f9, 0x6f5fcede306f6fa1, 0x91fcef3f6d91917e, 0x52aa07a4f8525255,
+	0x6027fdc04760609d, 0xbc89766535bcbcca, 0x9baccd2b379b9b56, 0x8e048c018a8e8e02,
+	0xa371155bd2a3a3b6, 0x0c603c186c0c0c30, 0x7bff8af6847b7bf1, 0x35b5e16a803535d4,
+	0x1de8693af51d1d74, 0xe05347ddb3e0e0a7, 0xd7f6acb321d7d77b, 0xc25eed999cc2c22f,
+	0x2e6d965c432e2eb8, 0x4b627a96294b4b31, 0xfea321e15dfefedf, 0x578216aed5575741,
+	0x15a8412abd151554, 0x779fb6eee87777c1, 0x37a5eb6e923737dc, 0xe57b56d79ee5e5b3,
+	0x9f8cd923139f9f46, 0xf0d317fd23f0f0e7, 0x4a6a7f94204a4a35, 0xda9e95a944dada4f,
+	0x58fa25b0a258587d, 0xc906ca8fcfc9c903, 0x29558d527c2929a4, 0x0a5022145a0a0a28,
+	0xb1e14f7f50b1b1fe, 0xa0691a5dc9a0a0ba, 0x6b7fdad6146b6bb1, 0x855cab17d985852e,
+	0xbd8173673cbdbdce, 0x5dd234ba8f5d5d69, 0x1080502090101040, 0xf4f303f507f4f4f7,
+	0xcb16c08bddcbcb0b, 0x3eedc67cd33e3ef8, 0x0528110a2d050514, 0x671fe6ce78676781,
+	0xe47353d597e4e4b7, 0x2725bb4e0227279c, 0x4132588273414119, 0x8b2c9d0ba78b8b16,
+	0xa7510153f6a7a7a6, 0x7dcf94fab27d7de9, 0x95dcfb374995956e, 0xd88e9fad56d8d847,
+	0xfb8b30eb70fbfbcb, 0xee2371c1cdeeee9f, 0x7cc791f8bb7c7ced, 0x6617e3cc71666685,
+	0xdda68ea77bdddd53, 0x17b84b2eaf17175c, 0x4702468e45474701, 0x9e84dc211a9e9e42,
+	0xca1ec589d4caca0f, 0x2d75995a582d2db4, 0xbf9179632ebfbfc6, 0x07381b0e3f07071c,
+	0xad012347acadad8e, 0x5aea2fb4b05a5a75, 0x836cb51bef838336, 0x3385ff66b63333cc,
+	0x633ff2c65c636391, 0x02100a0412020208, 0xaa39384993aaaa92, 0x71afa8e2de7171d9,
+	0xc80ecf8dc6c8c807, 0x19c87d32d1191964, 0x497270923b494939, 0xd9869aaf5fd9d943,
+	0xf2c31df931f2f2ef, 0xe34b48dba8e3e3ab, 0x5be22ab6b95b5b71, 0x8834920dbc88881a,
+	0x9aa4c8293e9a9a52, 0x262dbe4c0b262698, 0x328dfa64bf3232c8, 0xb0e94a7d59b0b0fa,
+	0xe91b6acff2e9e983, 0x0f78331e770f0f3c, 0xd5e6a6b733d5d573, 0x8074ba1df480803a,
+	0xbe997c6127bebec2, 0xcd26de87ebcdcd13, 0x34bde468893434d0, 0x487a75903248483d,
+	0xffab24e354ffffdb, 0x7af78ff48d7a7af5, 0x90f4ea3d6490907a, 0x5fc23ebe9d5f5f61,
+	0x201da0403d202080, 0x6867d5d00f6868bd, 0x1ad07234ca1a1a68, 0xae192c41b7aeae82,
+	0xb4c95e757db4b4ea, 0x549a19a8ce54544d, 0x93ece53b7f939376, 0x220daa442f222288,
+	0x6407e9c86364648d, 0xf1db12ff2af1f1e3, 0x73bfa2e6cc7373d1, 0x12905a2482121248,
+	0x403a5d807a40401d, 0x0840281048080820, 0xc356e89b95c3c32b, 0xec337bc5dfecec97,
+	0xdb9690ab4ddbdb4b, 0xa1611f5fc0a1a1be, 0x8d1c8307918d8d0e, 0x3df5c97ac83d3df4,
+	0x97ccf1335b979766, 0x0000000000000000, 0xcf36d483f9cfcf1b, 0x2b4587566e2b2bac,
+	0x7697b3ece17676c5, 0x8264b019e6828232, 0xd6fea9b128d6d67f, 0x1bd87736c31b1b6c,
+	0xb5c15b7774b5b5ee, 0xaf112943beafaf86, 0x6a77dfd41d6a6ab5, 0x50ba0da0ea50505d,
+	0x45124c8a57454509, 0xf3cb18fb38f3f3eb, 0x309df060ad3030c0, 0xef2b74c3c4efef9b,
+	0x3fe5c37eda3f3ffc, 0x55921caac7555549, 0xa2791059dba2a2b2, 0xea0365c9e9eaea8f,
+	0x650fecca6a656589, 0xbab9686903babad2, 0x2f65935e4a2f2fbc, 0xc04ee79d8ec0c027,
+	0xdebe81a160dede5f, 0x1ce06c38fc1c1c70, 0xfdbb2ee746fdfdd3, 0x4d52649a1f4d4d29,
+	0x92e4e03976929272, 0x758fbceafa7575c9, 0x06301e0c36060618, 0x8a249809ae8a8a12,
+	0xb2f940794bb2b2f2, 0xe66359d185e6e6bf, 0x0e70361c7e0e0e38, 0x1ff8633ee71f1f7c,
+	0x6237f7c455626295, 0xd4eea3b53ad4d477, 0xa829324d81a8a89a, 0x96c4f43152969662,
+	0xf99b3aef62f9f9c3, 0xc566f697a3c5c533, 0x2535b14a10252594, 0x59f220b2ab595979,
+	0x8454ae15d084842a, 0x72b7a7e4c57272d5, 0x39d5dd72ec3939e4, 0x4c5a6198164c4c2d,
+	0x5eca3bbc945e5e65, 0x78e785f09f7878fd, 0x38ddd870e53838e0, 0x8c148605988c8c0a,
+	0xd1c6b2bf17d1d163, 0xa5410b57e4a5a5ae, 0xe2434dd9a1e2e2af, 0x612ff8c24e616199,
+	0xb3f1457b42b3b3f6, 0x2115a54234212184, 0x9c94d625089c9c4a, 0x1ef0663cee1e1e78,
+	0x4322528661434311, 0xc776fc93b1c7c73b, 0xfcb32be54ffcfcd7, 0x0420140824040410,
+	0x51b208a2e3515159, 0x99bcc72f2599995e, 0x6d4fc4da226d6da9, 0x0d68391a650d0d34,
+	0xfa8335e979fafacf, 0xdfb684a369dfdf5b, 0x7ed79bfca97e7ee5, 0x243db44819242490,
+	0x3bc5d776fe3b3bec, 0xab313d4b9aabab96, 0xce3ed181f0cece1f, 0x1188552299111144,
+	0x8f0c8903838f8f06, 0x4e4a6b9c044e4e25, 0xb7d1517366b7b7e6, 0xeb0b60cbe0ebeb8b,
+	0x3cfdcc78c13c3cf0, 0x817cbf1ffd81813e, 0x94d4fe354094946a, 0xf7eb0cf31cf7f7fb,
+	0xb9a1676f18b9b9de, 0x13985f268b13134c, 0x2c7d9c58512c2cb0, 0xd3d6b8bb05d3d36b,
+	0xe76b5cd38ce7e7bb, 0x6e57cbdc396e6ea5, 0xc46ef395aac4c437, 0x03180f061b03030c,
+	0x568a13acdc565645, 0x441a49885e44440d, 0x7fdf9efea07f7fe1, 0xa921374f88a9a99e,
+	0x2a4d8254672a2aa8, 0xbbb16d6b0abbbbd6, 0xc146e29f87c1c123, 0x53a202a6f1535351,
+	0xdcae8ba572dcdc57, 0x0b582716530b0b2c, 0x9d9cd327019d9d4e, 0x6c47c1d82b6c6cad,
+	0x3195f562a43131c4, 0x7487b9e8f37474cd, 0xf6e309f115f6f6ff, 0x460a438c4c464605,
+	0xac092645a5acac8a, 0x893c970fb589891e, 0x14a04428b4141450, 0xe15b42dfbae1e1a3,
+	0x16b04e2ca6161658, 0x3acdd274f73a3ae8, 0x696fd0d2066969b9, 0x09482d1241090924,
+	0x70a7ade0d77070dd, 0xb6d954716fb6b6e2, 0xd0ceb7bd1ed0d067, 0xed3b7ec7d6eded93,
+	0xcc2edb85e2cccc17, 0x422a578468424215, 0x98b4c22d2c98985a, 0xa4490e55eda4a4aa,
+	0x285d8850752828a0, 0x5cda31b8865c5c6d, 0xf8933fed6bf8f8c7, 0x8644a411c2868622,
+}
+
+C6 := [256]u64 {
+	0x6018c07830d81818, 0x8c2305af46262323, 0x3fc67ef991b8c6c6, 0x87e8136fcdfbe8e8,
+	0x26874ca113cb8787, 0xdab8a9626d11b8b8, 0x0401080502090101, 0x214f426e9e0d4f4f,
+	0xd836adee6c9b3636, 0xa2a6590451ffa6a6, 0x6fd2debdb90cd2d2, 0xf3f5fb06f70ef5f5,
+	0xf979ef80f2967979, 0xa16f5fcede306f6f, 0x7e91fcef3f6d9191, 0x5552aa07a4f85252,
+	0x9d6027fdc0476060, 0xcabc89766535bcbc, 0x569baccd2b379b9b, 0x028e048c018a8e8e,
+	0xb6a371155bd2a3a3, 0x300c603c186c0c0c, 0xf17bff8af6847b7b, 0xd435b5e16a803535,
+	0x741de8693af51d1d, 0xa7e05347ddb3e0e0, 0x7bd7f6acb321d7d7, 0x2fc25eed999cc2c2,
+	0xb82e6d965c432e2e, 0x314b627a96294b4b, 0xdffea321e15dfefe, 0x41578216aed55757,
+	0x5415a8412abd1515, 0xc1779fb6eee87777, 0xdc37a5eb6e923737, 0xb3e57b56d79ee5e5,
+	0x469f8cd923139f9f, 0xe7f0d317fd23f0f0, 0x354a6a7f94204a4a, 0x4fda9e95a944dada,
+	0x7d58fa25b0a25858, 0x03c906ca8fcfc9c9, 0xa429558d527c2929, 0x280a5022145a0a0a,
+	0xfeb1e14f7f50b1b1, 0xbaa0691a5dc9a0a0, 0xb16b7fdad6146b6b, 0x2e855cab17d98585,
+	0xcebd8173673cbdbd, 0x695dd234ba8f5d5d, 0x4010805020901010, 0xf7f4f303f507f4f4,
+	0x0bcb16c08bddcbcb, 0xf83eedc67cd33e3e, 0x140528110a2d0505, 0x81671fe6ce786767,
+	0xb7e47353d597e4e4, 0x9c2725bb4e022727, 0x1941325882734141, 0x168b2c9d0ba78b8b,
+	0xa6a7510153f6a7a7, 0xe97dcf94fab27d7d, 0x6e95dcfb37499595, 0x47d88e9fad56d8d8,
+	0xcbfb8b30eb70fbfb, 0x9fee2371c1cdeeee, 0xed7cc791f8bb7c7c, 0x856617e3cc716666,
+	0x53dda68ea77bdddd, 0x5c17b84b2eaf1717, 0x014702468e454747, 0x429e84dc211a9e9e,
+	0x0fca1ec589d4caca, 0xb42d75995a582d2d, 0xc6bf9179632ebfbf, 0x1c07381b0e3f0707,
+	0x8ead012347acadad, 0x755aea2fb4b05a5a, 0x36836cb51bef8383, 0xcc3385ff66b63333,
+	0x91633ff2c65c6363, 0x0802100a04120202, 0x92aa39384993aaaa, 0xd971afa8e2de7171,
+	0x07c80ecf8dc6c8c8, 0x6419c87d32d11919, 0x39497270923b4949, 0x43d9869aaf5fd9d9,
+	0xeff2c31df931f2f2, 0xabe34b48dba8e3e3, 0x715be22ab6b95b5b, 0x1a8834920dbc8888,
+	0x529aa4c8293e9a9a, 0x98262dbe4c0b2626, 0xc8328dfa64bf3232, 0xfab0e94a7d59b0b0,
+	0x83e91b6acff2e9e9, 0x3c0f78331e770f0f, 0x73d5e6a6b733d5d5, 0x3a8074ba1df48080,
+	0xc2be997c6127bebe, 0x13cd26de87ebcdcd, 0xd034bde468893434, 0x3d487a7590324848,
+	0xdbffab24e354ffff, 0xf57af78ff48d7a7a, 0x7a90f4ea3d649090, 0x615fc23ebe9d5f5f,
+	0x80201da0403d2020, 0xbd6867d5d00f6868, 0x681ad07234ca1a1a, 0x82ae192c41b7aeae,
+	0xeab4c95e757db4b4, 0x4d549a19a8ce5454, 0x7693ece53b7f9393, 0x88220daa442f2222,
+	0x8d6407e9c8636464, 0xe3f1db12ff2af1f1, 0xd173bfa2e6cc7373, 0x4812905a24821212,
+	0x1d403a5d807a4040, 0x2008402810480808, 0x2bc356e89b95c3c3, 0x97ec337bc5dfecec,
+	0x4bdb9690ab4ddbdb, 0xbea1611f5fc0a1a1, 0x0e8d1c8307918d8d, 0xf43df5c97ac83d3d,
+	0x6697ccf1335b9797, 0x0000000000000000, 0x1bcf36d483f9cfcf, 0xac2b4587566e2b2b,
+	0xc57697b3ece17676, 0x328264b019e68282, 0x7fd6fea9b128d6d6, 0x6c1bd87736c31b1b,
+	0xeeb5c15b7774b5b5, 0x86af112943beafaf, 0xb56a77dfd41d6a6a, 0x5d50ba0da0ea5050,
+	0x0945124c8a574545, 0xebf3cb18fb38f3f3, 0xc0309df060ad3030, 0x9bef2b74c3c4efef,
+	0xfc3fe5c37eda3f3f, 0x4955921caac75555, 0xb2a2791059dba2a2, 0x8fea0365c9e9eaea,
+	0x89650fecca6a6565, 0xd2bab9686903baba, 0xbc2f65935e4a2f2f, 0x27c04ee79d8ec0c0,
+	0x5fdebe81a160dede, 0x701ce06c38fc1c1c, 0xd3fdbb2ee746fdfd, 0x294d52649a1f4d4d,
+	0x7292e4e039769292, 0xc9758fbceafa7575, 0x1806301e0c360606, 0x128a249809ae8a8a,
+	0xf2b2f940794bb2b2, 0xbfe66359d185e6e6, 0x380e70361c7e0e0e, 0x7c1ff8633ee71f1f,
+	0x956237f7c4556262, 0x77d4eea3b53ad4d4, 0x9aa829324d81a8a8, 0x6296c4f431529696,
+	0xc3f99b3aef62f9f9, 0x33c566f697a3c5c5, 0x942535b14a102525, 0x7959f220b2ab5959,
+	0x2a8454ae15d08484, 0xd572b7a7e4c57272, 0xe439d5dd72ec3939, 0x2d4c5a6198164c4c,
+	0x655eca3bbc945e5e, 0xfd78e785f09f7878, 0xe038ddd870e53838, 0x0a8c148605988c8c,
+	0x63d1c6b2bf17d1d1, 0xaea5410b57e4a5a5, 0xafe2434dd9a1e2e2, 0x99612ff8c24e6161,
+	0xf6b3f1457b42b3b3, 0x842115a542342121, 0x4a9c94d625089c9c, 0x781ef0663cee1e1e,
+	0x1143225286614343, 0x3bc776fc93b1c7c7, 0xd7fcb32be54ffcfc, 0x1004201408240404,
+	0x5951b208a2e35151, 0x5e99bcc72f259999, 0xa96d4fc4da226d6d, 0x340d68391a650d0d,
+	0xcffa8335e979fafa, 0x5bdfb684a369dfdf, 0xe57ed79bfca97e7e, 0x90243db448192424,
+	0xec3bc5d776fe3b3b, 0x96ab313d4b9aabab, 0x1fce3ed181f0cece, 0x4411885522991111,
+	0x068f0c8903838f8f, 0x254e4a6b9c044e4e, 0xe6b7d1517366b7b7, 0x8beb0b60cbe0ebeb,
+	0xf03cfdcc78c13c3c, 0x3e817cbf1ffd8181, 0x6a94d4fe35409494, 0xfbf7eb0cf31cf7f7,
+	0xdeb9a1676f18b9b9, 0x4c13985f268b1313, 0xb02c7d9c58512c2c, 0x6bd3d6b8bb05d3d3,
+	0xbbe76b5cd38ce7e7, 0xa56e57cbdc396e6e, 0x37c46ef395aac4c4, 0x0c03180f061b0303,
+	0x45568a13acdc5656, 0x0d441a49885e4444, 0xe17fdf9efea07f7f, 0x9ea921374f88a9a9,
+	0xa82a4d8254672a2a, 0xd6bbb16d6b0abbbb, 0x23c146e29f87c1c1, 0x5153a202a6f15353,
+	0x57dcae8ba572dcdc, 0x2c0b582716530b0b, 0x4e9d9cd327019d9d, 0xad6c47c1d82b6c6c,
+	0xc43195f562a43131, 0xcd7487b9e8f37474, 0xfff6e309f115f6f6, 0x05460a438c4c4646,
+	0x8aac092645a5acac, 0x1e893c970fb58989, 0x5014a04428b41414, 0xa3e15b42dfbae1e1,
+	0x5816b04e2ca61616, 0xe83acdd274f73a3a, 0xb9696fd0d2066969, 0x2409482d12410909,
+	0xdd70a7ade0d77070, 0xe2b6d954716fb6b6, 0x67d0ceb7bd1ed0d0, 0x93ed3b7ec7d6eded,
+	0x17cc2edb85e2cccc, 0x15422a5784684242, 0x5a98b4c22d2c9898, 0xaaa4490e55eda4a4,
+	0xa0285d8850752828, 0x6d5cda31b8865c5c, 0xc7f8933fed6bf8f8, 0x228644a411c28686,
+}
+
+C7 := [256]u64 {
+	0x186018c07830d818, 0x238c2305af462623, 0xc63fc67ef991b8c6, 0xe887e8136fcdfbe8,
+	0x8726874ca113cb87, 0xb8dab8a9626d11b8, 0x0104010805020901, 0x4f214f426e9e0d4f,
+	0x36d836adee6c9b36, 0xa6a2a6590451ffa6, 0xd26fd2debdb90cd2, 0xf5f3f5fb06f70ef5,
+	0x79f979ef80f29679, 0x6fa16f5fcede306f, 0x917e91fcef3f6d91, 0x525552aa07a4f852,
+	0x609d6027fdc04760, 0xbccabc89766535bc, 0x9b569baccd2b379b, 0x8e028e048c018a8e,
+	0xa3b6a371155bd2a3, 0x0c300c603c186c0c, 0x7bf17bff8af6847b, 0x35d435b5e16a8035,
+	0x1d741de8693af51d, 0xe0a7e05347ddb3e0, 0xd77bd7f6acb321d7, 0xc22fc25eed999cc2,
+	0x2eb82e6d965c432e, 0x4b314b627a96294b, 0xfedffea321e15dfe, 0x5741578216aed557,
+	0x155415a8412abd15, 0x77c1779fb6eee877, 0x37dc37a5eb6e9237, 0xe5b3e57b56d79ee5,
+	0x9f469f8cd923139f, 0xf0e7f0d317fd23f0, 0x4a354a6a7f94204a, 0xda4fda9e95a944da,
+	0x587d58fa25b0a258, 0xc903c906ca8fcfc9, 0x29a429558d527c29, 0x0a280a5022145a0a,
+	0xb1feb1e14f7f50b1, 0xa0baa0691a5dc9a0, 0x6bb16b7fdad6146b, 0x852e855cab17d985,
+	0xbdcebd8173673cbd, 0x5d695dd234ba8f5d, 0x1040108050209010, 0xf4f7f4f303f507f4,
+	0xcb0bcb16c08bddcb, 0x3ef83eedc67cd33e, 0x05140528110a2d05, 0x6781671fe6ce7867,
+	0xe4b7e47353d597e4, 0x279c2725bb4e0227, 0x4119413258827341, 0x8b168b2c9d0ba78b,
+	0xa7a6a7510153f6a7, 0x7de97dcf94fab27d, 0x956e95dcfb374995, 0xd847d88e9fad56d8,
+	0xfbcbfb8b30eb70fb, 0xee9fee2371c1cdee, 0x7ced7cc791f8bb7c, 0x66856617e3cc7166,
+	0xdd53dda68ea77bdd, 0x175c17b84b2eaf17, 0x47014702468e4547, 0x9e429e84dc211a9e,
+	0xca0fca1ec589d4ca, 0x2db42d75995a582d, 0xbfc6bf9179632ebf, 0x071c07381b0e3f07,
+	0xad8ead012347acad, 0x5a755aea2fb4b05a, 0x8336836cb51bef83, 0x33cc3385ff66b633,
+	0x6391633ff2c65c63, 0x020802100a041202, 0xaa92aa39384993aa, 0x71d971afa8e2de71,
+	0xc807c80ecf8dc6c8, 0x196419c87d32d119, 0x4939497270923b49, 0xd943d9869aaf5fd9,
+	0xf2eff2c31df931f2, 0xe3abe34b48dba8e3, 0x5b715be22ab6b95b, 0x881a8834920dbc88,
+	0x9a529aa4c8293e9a, 0x2698262dbe4c0b26, 0x32c8328dfa64bf32, 0xb0fab0e94a7d59b0,
+	0xe983e91b6acff2e9, 0x0f3c0f78331e770f, 0xd573d5e6a6b733d5, 0x803a8074ba1df480,
+	0xbec2be997c6127be, 0xcd13cd26de87ebcd, 0x34d034bde4688934, 0x483d487a75903248,
+	0xffdbffab24e354ff, 0x7af57af78ff48d7a, 0x907a90f4ea3d6490, 0x5f615fc23ebe9d5f,
+	0x2080201da0403d20, 0x68bd6867d5d00f68, 0x1a681ad07234ca1a, 0xae82ae192c41b7ae,
+	0xb4eab4c95e757db4, 0x544d549a19a8ce54, 0x937693ece53b7f93, 0x2288220daa442f22,
+	0x648d6407e9c86364, 0xf1e3f1db12ff2af1, 0x73d173bfa2e6cc73, 0x124812905a248212,
+	0x401d403a5d807a40, 0x0820084028104808, 0xc32bc356e89b95c3, 0xec97ec337bc5dfec,
+	0xdb4bdb9690ab4ddb, 0xa1bea1611f5fc0a1, 0x8d0e8d1c8307918d, 0x3df43df5c97ac83d,
+	0x976697ccf1335b97, 0x0000000000000000, 0xcf1bcf36d483f9cf, 0x2bac2b4587566e2b,
+	0x76c57697b3ece176, 0x82328264b019e682, 0xd67fd6fea9b128d6, 0x1b6c1bd87736c31b,
+	0xb5eeb5c15b7774b5, 0xaf86af112943beaf, 0x6ab56a77dfd41d6a, 0x505d50ba0da0ea50,
+	0x450945124c8a5745, 0xf3ebf3cb18fb38f3, 0x30c0309df060ad30, 0xef9bef2b74c3c4ef,
+	0x3ffc3fe5c37eda3f, 0x554955921caac755, 0xa2b2a2791059dba2, 0xea8fea0365c9e9ea,
+	0x6589650fecca6a65, 0xbad2bab9686903ba, 0x2fbc2f65935e4a2f, 0xc027c04ee79d8ec0,
+	0xde5fdebe81a160de, 0x1c701ce06c38fc1c, 0xfdd3fdbb2ee746fd, 0x4d294d52649a1f4d,
+	0x927292e4e0397692, 0x75c9758fbceafa75, 0x061806301e0c3606, 0x8a128a249809ae8a,
+	0xb2f2b2f940794bb2, 0xe6bfe66359d185e6, 0x0e380e70361c7e0e, 0x1f7c1ff8633ee71f,
+	0x62956237f7c45562, 0xd477d4eea3b53ad4, 0xa89aa829324d81a8, 0x966296c4f4315296,
+	0xf9c3f99b3aef62f9, 0xc533c566f697a3c5, 0x25942535b14a1025, 0x597959f220b2ab59,
+	0x842a8454ae15d084, 0x72d572b7a7e4c572, 0x39e439d5dd72ec39, 0x4c2d4c5a6198164c,
+	0x5e655eca3bbc945e, 0x78fd78e785f09f78, 0x38e038ddd870e538, 0x8c0a8c148605988c,
+	0xd163d1c6b2bf17d1, 0xa5aea5410b57e4a5, 0xe2afe2434dd9a1e2, 0x6199612ff8c24e61,
+	0xb3f6b3f1457b42b3, 0x21842115a5423421, 0x9c4a9c94d625089c, 0x1e781ef0663cee1e,
+	0x4311432252866143, 0xc73bc776fc93b1c7, 0xfcd7fcb32be54ffc, 0x0410042014082404,
+	0x515951b208a2e351, 0x995e99bcc72f2599, 0x6da96d4fc4da226d, 0x0d340d68391a650d,
+	0xfacffa8335e979fa, 0xdf5bdfb684a369df, 0x7ee57ed79bfca97e, 0x2490243db4481924,
+	0x3bec3bc5d776fe3b, 0xab96ab313d4b9aab, 0xce1fce3ed181f0ce, 0x1144118855229911,
+	0x8f068f0c8903838f, 0x4e254e4a6b9c044e, 0xb7e6b7d1517366b7, 0xeb8beb0b60cbe0eb,
+	0x3cf03cfdcc78c13c, 0x813e817cbf1ffd81, 0x946a94d4fe354094, 0xf7fbf7eb0cf31cf7,
+	0xb9deb9a1676f18b9, 0x134c13985f268b13, 0x2cb02c7d9c58512c, 0xd36bd3d6b8bb05d3,
+	0xe7bbe76b5cd38ce7, 0x6ea56e57cbdc396e, 0xc437c46ef395aac4, 0x030c03180f061b03,
+	0x5645568a13acdc56, 0x440d441a49885e44, 0x7fe17fdf9efea07f, 0xa99ea921374f88a9,
+	0x2aa82a4d8254672a, 0xbbd6bbb16d6b0abb, 0xc123c146e29f87c1, 0x535153a202a6f153,
+	0xdc57dcae8ba572dc, 0x0b2c0b582716530b, 0x9d4e9d9cd327019d, 0x6cad6c47c1d82b6c,
+	0x31c43195f562a431, 0x74cd7487b9e8f374, 0xf6fff6e309f115f6, 0x4605460a438c4c46,
+	0xac8aac092645a5ac, 0x891e893c970fb589, 0x145014a04428b414, 0xe1a3e15b42dfbae1,
+	0x165816b04e2ca616, 0x3ae83acdd274f73a, 0x69b9696fd0d20669, 0x092409482d124109,
+	0x70dd70a7ade0d770, 0xb6e2b6d954716fb6, 0xd067d0ceb7bd1ed0, 0xed93ed3b7ec7d6ed,
+	0xcc17cc2edb85e2cc, 0x4215422a57846842, 0x985a98b4c22d2c98, 0xa4aaa4490e55eda4,
+	0x28a0285d88507528, 0x5c6d5cda31b8865c, 0xf8c7f8933fed6bf8, 0x86228644a411c286,
+}
+
+RC := [ROUNDS + 1]u64 {
+	0x0000000000000000,
+	0x1823c6e887b8014f,
+	0x36a6d2f5796f9152,
+	0x60bc9b8ea30c7b35,
+	0x1de0d7c22e4bfe57,
+	0x157737e59ff04ada,
+	0x58c9290ab1a06b85,
+	0xbd5d10f4cb3e0567,
+	0xe427418ba77d95d8,
+	0xfbee7c66dd17479e,
+	0xca2dbf07ad5a8333,
+}
+
+transform :: proc (ctx: ^Whirlpool_Context) {
+	K, block, state, L: [8]u64
+
+	for i := 0; i < 8; i += 1 {block[i] = util.U64_BE(ctx.buffer[8 * i:])}
+
+	for i := 0; i < 8; i += 1 {
+		K[i] = ctx.hash[i]
+		state[i] = block[i] ~ K[i]
+	}
+
+	for r := 1; r <= ROUNDS; r += 1 {
+		for i := 0; i < 8; i += 1 {
+			L[i] = C0[byte(K[i % 8] >> 56)] ~
+				C1[byte(K[(i + 7) % 8] >> 48)] ~
+				C2[byte(K[(i + 6) % 8] >> 40)] ~
+				C3[byte(K[(i + 5) % 8] >> 32)] ~
+				C4[byte(K[(i + 4) % 8] >> 24)] ~
+				C5[byte(K[(i + 3) % 8] >> 16)] ~
+				C6[byte(K[(i + 2) % 8] >> 8)] ~
+				C7[byte(K[(i + 1) % 8])]
+		}
+		L[0] ~= RC[r]
+
+		for i := 0; i < 8; i += 1 {K[i] = L[i]}
+
+		for i := 0; i < 8; i += 1 {
+			L[i] = C0[byte(state[i % 8] >> 56)] ~
+				C1[byte(state[(i + 7) % 8] >> 48)] ~
+				C2[byte(state[(i + 6) % 8] >> 40)] ~
+				C3[byte(state[(i + 5) % 8] >> 32)] ~
+				C4[byte(state[(i + 4) % 8] >> 24)] ~
+				C5[byte(state[(i + 3) % 8] >> 16)] ~
+				C6[byte(state[(i + 2) % 8] >> 8)] ~
+				C7[byte(state[(i + 1) % 8])] ~
+				K[i % 8]
+		}
+		for i := 0; i < 8; i += 1 {state[i] = L[i]}
+	}
+	for i := 0; i < 8; i += 1 {ctx.hash[i] ~= state[i] ~ block[i]}
+}
+
+update_odin :: proc(ctx: ^Whirlpool_Context, source: []byte) {
+    source_pos: int
+    nn := len(source)
+    source_bits := u64(nn * 8)
+    source_gap := u32((8 - (int(source_bits & 7))) & 7)
+    buffer_rem := uint(ctx.buffer_bits & 7)
+    b: u32
+
+	for i, carry, value := 31, u32(0), u32(source_bits); i >= 0 && (carry != 0 || value != 0); i -= 1 {
+		carry += u32(ctx.bitlength[i]) + (u32(value & 0xff))
+		ctx.bitlength[i] = byte(carry)
+		carry >>= 8
+		value >>= 8
+	}
+
+	for source_bits > 8 {
+		b = u32(u32((source[source_pos] << source_gap) & 0xff) | u32((source[source_pos+1] & 0xff) >> (8 - source_gap)))
+
+		ctx.buffer[ctx.buffer_pos] |= u8(b >> buffer_rem)
+		ctx.buffer_pos += 1
+		ctx.buffer_bits += int(8 - buffer_rem)
+
+		if ctx.buffer_bits == 512 {
+			transform(ctx)
+			ctx.buffer_bits = 0
+			ctx.buffer_pos = 0
+		}
+		ctx.buffer[ctx.buffer_pos] = byte(b << (8 - buffer_rem))
+		ctx.buffer_bits += int(buffer_rem)
+		source_bits -= 8
+		source_pos += 1
+	}
+
+	if source_bits > 0 {
+		b = u32((source[source_pos] << source_gap) & 0xff)
+		ctx.buffer[ctx.buffer_pos] |= byte(b) >> buffer_rem
+	} else {b = 0}
+
+	if u64(buffer_rem) + source_bits < 8 {
+		ctx.buffer_bits += int(source_bits)
+	} else {
+		ctx.buffer_pos += 1
+		ctx.buffer_bits += 8 - int(buffer_rem)
+		source_bits -= u64(8 - buffer_rem)
+
+		if ctx.buffer_bits == 512 {
+			transform(ctx)
+			ctx.buffer_bits = 0
+			ctx.buffer_pos = 0
+		}
+		ctx.buffer[ctx.buffer_pos] = byte(b << (8 - buffer_rem))
+		ctx.buffer_bits += int(source_bits)
+	}
+}
+
+final_odin :: proc(ctx: ^Whirlpool_Context, hash: []byte) {
+	n := ctx
+	n.buffer[n.buffer_pos] |= 0x80 >> (uint(n.buffer_bits) & 7)
+	n.buffer_pos += 1
+
+	if n.buffer_pos > 64 - 32 {
+		if n.buffer_pos < 64 {
+			for i := 0; i < 64 - n.buffer_pos; i += 1 {
+				n.buffer[n.buffer_pos + i] = 0
+			}
+		}
+		transform(ctx)
+		n.buffer_pos = 0
+	}
+
+	if n.buffer_pos < 64 - 32 {
+		for i := 0; i < (64 - 32) - n.buffer_pos; i += 1 {
+			n.buffer[n.buffer_pos + i] = 0
+		}
+	}
+	n.buffer_pos = 64 - 32
+
+	for i := 0; i < 32; i += 1 {
+		n.buffer[n.buffer_pos + i] = n.bitlength[i]
+	}
+	transform(ctx)
+
+	for i := 0; i < 8; i += 1 {
+		hash[i * 8]     = byte(n.hash[i] >> 56)
+		hash[i * 8 + 1] = byte(n.hash[i] >> 48)
+		hash[i * 8 + 2] = byte(n.hash[i] >> 40)
+		hash[i * 8 + 3] = byte(n.hash[i] >> 32)
+		hash[i * 8 + 4] = byte(n.hash[i] >> 24)
+		hash[i * 8 + 5] = byte(n.hash[i] >> 16)
+		hash[i * 8 + 6] = byte(n.hash[i] >> 8)
+		hash[i * 8 + 7] = byte(n.hash[i])
+	}
+}

core/dynlib/lib.odin

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

core/dynlib/lib_unix.odin

@@ -4,20 +4,20 @@ package dynlib
 import "core:os"
 
 load_library :: proc(path: string, global_symbols := false) -> (Library, bool) {
-    flags := os.RTLD_NOW;
+    flags := os.RTLD_NOW
     if global_symbols {
-    	flags |= os.RTLD_GLOBAL;
+    	flags |= os.RTLD_GLOBAL
     }
-    lib := os.dlopen(path, flags);
-    return Library(lib), lib != nil;
+    lib := os.dlopen(path, flags)
+    return Library(lib), lib != nil
 }
 
 unload_library :: proc(library: Library) {
-    os.dlclose(rawptr(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;
+    ptr = os.dlsym(rawptr(library), symbol)
+    found = ptr != nil
+    return
 }

core/dynlib/lib_windows.odin

@@ -7,19 +7,19 @@ 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;
+	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);
+	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;
+	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

@@ -12,9 +12,9 @@ ENC_TABLE := [32]byte {
     '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 :: '=';
+PADDING :: '='
 
 DEC_TABLE := [?]u8 {
      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
@@ -31,118 +31,118 @@ 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,
-};
+}
 
 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);
+    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;
+    out := out
+    data := data
 
     for len(data) > 0 {
-        carry: byte;
+        carry: byte
         switch len(data) {
             case:
-                out[7] = ENC_TABLE[data[4] & 0x1f];
-                carry = data[4] >> 5;
-                fallthrough;
+                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;
+                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;
+                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;
+                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];
+                out[1] = ENC_TABLE[carry | (data[0] << 2) & 0x1f]
+                out[0] = ENC_TABLE[data[0] >> 3]
         }
 
         if len(data) < 5 {
-            out[7] = byte(PADDING);
+            out[7] = byte(PADDING)
             if len(data) < 4 {
-                out[6] = byte(PADDING);
-                out[5] = byte(PADDING);
+                out[6] = byte(PADDING)
+                out[5] = byte(PADDING)
                 if len(data) < 3 {
-                    out[4] = byte(PADDING);
+                    out[4] = byte(PADDING)
                     if len(data) < 2 {
-                        out[3] = byte(PADDING);
-                        out[2] = byte(PADDING);
+                        out[3] = byte(PADDING)
+                        out[2] = byte(PADDING)
                     }
                 }
             }
-            break;
+            break
         }
-        data = data[5:];
-        out = out[8:];
+        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;
+        return nil
     }
 
-    outi := 0;
-    data := data;
+    outi := 0
+    data := data
 
-    out := make([]byte, len(data) / 8 * 5, allocator);
-    end := false;
+    out := make([]byte, len(data) / 8 * 5, allocator)
+    end := false
     for len(data) > 0 && !end {
-        dbuf : [8]byte;
-        dlen := 8;
+        dbuf : [8]byte
+        dlen := 8
 
         for j := 0; j < 8; {
             if len(data) == 0 {
-                dlen, end = j, true;
-                break;
+                dlen, end = j, true
+                break
             }
-            input := data[0];
-            data = data[1:];
+            input := data[0]
+            data = data[1:]
             if input == byte(PADDING) && j >= 2 && len(data) < 8 {
-                assert(!(len(data) + j < 8 - 1), "Corrupted input");
+                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");
+                    assert(len(data) < k || data[k] == byte(PADDING), "Corrupted input")
                 }
-                dlen, end = j, true;
-                assert(dlen != 1 && dlen != 3 && dlen != 6, "Corrupted input");
-                break;
+                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;
+            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;
+                out[outi + 4] = dbuf[6] << 5 | dbuf[7]
+                fallthrough
             case 7:
-                out[outi + 3] = dbuf[4] << 7 | dbuf[5] << 2 | dbuf[6] >> 3;
-                fallthrough;
+                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;
+                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;
+                out[outi + 1] = dbuf[1] << 6 | dbuf[2] << 1 | dbuf[3] >> 4
+                fallthrough
             case 2:
-                out[outi + 0] = dbuf[0] << 3 | dbuf[1] >> 2;
+                out[outi + 0] = dbuf[0] << 3 | dbuf[1] >> 2
         }
-        outi += 5;
+        outi += 5
     }
-    return out;
+    return out
 }

core/encoding/base64/base64.odin

@@ -16,9 +16,9 @@ ENC_TABLE := [64]byte {
     'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
     'w', 'x', 'y', 'z', '0', '1', '2', '3',
     '4', '5', '6', '7', '8', '9', '+', '/',
-};
+}
 
-PADDING :: '=';
+PADDING :: '='
 
 DEC_TABLE := [128]int {
     -1, -1, -1, -1, -1, -1, -1, -1,
@@ -37,61 +37,61 @@ DEC_TABLE := [128]int {
     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);
+    length := len(data)
     if length == 0 {
-        return "";
+        return ""
     }
 
-    out_length := ((4 * length / 3) + 3) &~ 3;
-    out := make([]byte, out_length, allocator);
+    out_length := ((4 * length / 3) + 3) &~ 3
+    out := make([]byte, out_length, allocator)
 
-    c0, c1, c2, block: int;
+    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;
+        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]); }
+        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);
+        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];
+        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);
+    return string(out)
 }
 
 decode :: proc(data: string, DEC_TBL := DEC_TABLE, allocator := context.allocator) -> []byte #no_bounds_check {
-    length := len(data);
+    length := len(data)
     if length == 0 {
-        return nil;
+        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);
+    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;
+    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]];
+        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;
+        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);
+        out[j]     = byte(b0)
+        out[j + 1] = byte(b1)
+        out[j + 2] = byte(b2)
     }
-    return out;
+    return out
 }

core/encoding/cel/cel.odin

@@ -1,852 +0,0 @@
-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

@@ -1,51 +0,0 @@
-/*
-	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

@@ -1,523 +0,0 @@
-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

@@ -68,7 +68,7 @@ reader_error_kind_string := [Reader_Error_Kind]string{
 	.Quote          = "extra or missing \" in quoted field",
 	.Field_Count    = "wrong field count",
 	.Invalid_Delim  = "invalid delimiter",
-};
+}
 
 Reader_Error :: struct {
 	kind:          Reader_Error_Kind,
@@ -83,35 +83,35 @@ Error :: union {
 	io.Error,
 }
 
-DEFAULT_RECORD_BUFFER_CAPACITY :: 256;
+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 = ',';
+	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);
+	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);
+	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);
+	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
@@ -119,21 +119,21 @@ reader_destroy :: proc(r: ^Reader) {
 // 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);
+		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);
+		record, err = _read_record(r, nil, allocator)
 	}
-	return;
+	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 v == io_err
 	}
-	return false;
+	return false
 }
 
 
@@ -141,97 +141,97 @@ is_io_error :: proc(err: Error, io_err: io.Error) -> bool {
 // 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;
+	context.allocator = allocator
+	records: [dynamic][]string
 	for {
-		record, rerr := _read_record(r, nil, allocator);
+		record, rerr := _read_record(r, nil, allocator)
 		if is_io_error(rerr, .EOF) {
-			return records[:], nil;
+			return records[:], nil
 		}
 		if rerr != nil {
-			return nil, rerr;
+			return nil, rerr
 		}
-		append(&records, record);
+		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));
+	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;
+	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));
+	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);
+	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 false
 	}
-	return utf8.valid_rune(r);
+	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');
+		line, err := bufio.reader_read_slice(&r.r, '\n')
 		if err == .Buffer_Full {
-			clear(&r.raw_buffer);
-			append(&r.raw_buffer, ..line);
+			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, err = bufio.reader_read_slice(&r.r, '\n')
+				append(&r.raw_buffer, ..line)
 			}
-			line = r.raw_buffer[:];
+			line = r.raw_buffer[:]
 		}
 		if len(line) > 0 && err == .EOF {
-			err = nil;
+			err = nil
 			if line[len(line)-1] == '\r' {
-				line = line[:len(line)-1];
+				line = line[:len(line)-1]
 			}
 		}
-		r.line_count += 1;
+		r.line_count += 1
 
 		// normalize \r\n to \n
-		n := len(line);
+		n := len(line)
 		for n >= 2 && string(line[n-2:]) == "\r\n" {
-			line[n-2] = '\n';
-			line = line[:n-1];
+			line[n-2] = '\n'
+			line = line[:n-1]
 		}
 
-		return line, err;
+		return line, err
 	}
 
 	length_newline :: proc(b: []byte) -> int {
 		if len(b) > 0 && b[len(b)-1] == '\n' {
-			return 1;
+			return 1
 		}
-		return 0;
+		return 0
 	}
 
 	next_rune :: proc(b: []byte) -> rune {
-		r, _ := utf8.decode_rune(b);
-		return r;
+		r, _ := utf8.decode_rune(b)
+		return r
 	}
 
 	if r.comma == r.comment ||
@@ -240,152 +240,152 @@ _read_record :: proc(r: ^Reader, dst: ^[dynamic]string, allocator := context.all
 		err := Reader_Error{
 			kind = .Invalid_Delim,
 			line = r.line_count,
-		};
-		return nil, err;
+		}
+		return nil, err
 	}
 
-	line, full_line: []byte;
-	err_read: io.Error;
+	line, full_line: []byte
+	err_read: io.Error
 	for err_read == nil {
-		line, err_read = read_line(r);
+		line, err_read = read_line(r)
 		if r.comment != 0 && next_rune(line) == r.comment {
-			line = nil;
-			continue;
+			line = nil
+			continue
 		}
 		if err_read == nil && len(line) == length_newline(line) {
-			line = nil;
-			continue;
+			line = nil
+			continue
 		}
-		full_line = line;
-		break;
+		full_line = line
+		break
 	}
 
 	if is_io_error(err_read, .EOF) {
-		return nil, err_read;
+		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);
+	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);
+			line = bytes.trim_left_space(line)
 		}
 		if len(line) == 0 || line[0] != '"' {
-			i := bytes.index_rune(line, r.comma);
-			field := line;
+			i := bytes.index_rune(line, r.comma)
+			field := line
 			if i >= 0 {
-				field = field[:i];
+				field = field[:i]
 			} else {
-				field = field[:len(field) - length_newline(field)];
+				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:])]);
+					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;
+					}
+					break parse_field
 				}
 			}
-			append(&r.record_buffer, ..field);
-			append(&r.field_indices, len(r.record_buffer));
+			append(&r.record_buffer, ..field)
+			append(&r.field_indices, len(r.record_buffer))
 			if i >= 0 {
-				line = line[i+comma_len:];
-				continue parse_field;
+				line = line[i+comma_len:]
+				continue parse_field
 			}
-			break parse_field;
+			break parse_field
 
 		} else {
-			line = line[quote_len:];
+			line = line[quote_len:]
 			for {
-				i := bytes.index_byte(line, '"');
+				i := bytes.index_byte(line, '"')
 				switch {
 				case i >= 0:
-					append(&r.record_buffer, ..line[:i]);
-					line = line[i+quote_len:];
+					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:];
+						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;
+						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;
+						append(&r.field_indices, len(r.record_buffer))
+						break parse_field
 					case r.lazy_quotes: // bare quote
-						append(&r.record_buffer, '"');
+						append(&r.record_buffer, '"')
 					case: // invalid non-escaped quote
-						column := utf8.rune_count(full_line[:len(full_line) - len(line) - quote_len]);
+						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;
+						}
+						break parse_field
 					}
 
 				case len(line) > 0:
-					append(&r.record_buffer, ..line);
+					append(&r.record_buffer, ..line)
 					if err_read != nil {
-						break parse_field;
+						break parse_field
 					}
-					line, err_read = read_line(r);
+					line, err_read = read_line(r)
 					if is_io_error(err_read, .EOF) {
-						err_read = nil;
+						err_read = nil
 					}
-					full_line = line;
+					full_line = line
 
 				case:
 					if !r.lazy_quotes && err_read == nil {
-						column := utf8.rune_count(full_line);
+						column := utf8.rune_count(full_line)
 						err = Reader_Error{
 							kind = .Quote,
 							start_line = record_line,
 							line = r.line_count,
 							column = column,
-						};
-						break parse_field;
+						}
+						break parse_field
 					}
-					append(&r.field_indices, len(r.record_buffer));
-					break parse_field;
+					append(&r.field_indices, len(r.record_buffer))
+					break parse_field
 				}
 			}
 		}
 	}
 
 	if err == nil && err_read != nil {
-		err = err_read;
+		err = err_read
 	}
 
-	context.allocator = allocator;
-	dst := dst;
-	str := string(r.record_buffer[:]);
+	context.allocator = allocator
+	dst := dst
+	str := string(r.record_buffer[:])
 	if dst == nil {
 		// use local variable
-		dst = &([dynamic]string){};
+		dst = &([dynamic]string){}
 	}
-	clear(dst);
-	resize(dst, len(r.field_indices));
-	pre_idx: int;
+	clear(dst)
+	resize(dst, len(r.field_indices))
+	pre_idx: int
 	for idx, i in r.field_indices {
-		field := str[pre_idx:idx];
+		field := str[pre_idx:idx]
 		if !r.reuse_record_buffer {
-			field = strings.clone(field);
+			field = strings.clone(field)
 		}
-		dst[i] = field;
-		pre_idx = idx;
+		dst[i] = field
+		pre_idx = idx
 	}
 
 	if r.fields_per_record > 0 {
@@ -396,11 +396,11 @@ _read_record :: proc(r: ^Reader, dst: ^[dynamic]string, allocator := context.all
 				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);
+		r.fields_per_record = len(dst)
 	}
-	return dst[:], err;
+	return dst[:], err
 
 }

core/encoding/csv/writer.odin

@@ -17,8 +17,8 @@ Writer :: struct {
 
 // writer_init initializes a Writer that writes to w
 writer_init :: proc(writer: ^Writer, w: io.Writer) {
-	writer.comma = ',';
-	writer.w = w;
+	writer.comma = ','
+	writer.w = w
 }
 
 // write writes a single CSV records to w with any of the necessarily quoting.
@@ -26,122 +26,101 @@ writer_init :: proc(writer: ^Writer, w: io.Writer) {
 //
 // 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\"";
+	CHAR_SET :: "\n\r\""
 
 	field_needs_quoting :: proc(w: ^Writer, field: string) -> bool {
 		switch {
 		case field == "": // No need to quote empty strings
-			return false;
+			return false
 		case field == `\.`: // Postgres is weird
-			return true;
+			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;
+					return true
 				}
 			}
 		case:
 			if strings.contains_rune(field, w.comma) >= 0 {
-				return true;
+				return true
 			}
 			if strings.contains_any(field, CHAR_SET) {
-				return true;
+				return true
 			}
 		}
 
 		// Leading spaces need quoting
-		r, _ := utf8.decode_rune_in_string(field);
-		return strings.is_space(r);
+		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?
+		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];
+		field := record[field_idx]
 
 		if field_idx > 0 {
-			if _, err := io.write_rune(w.w, w.comma); err != nil {
-				return err;
-			}
+			io.write_rune(w.w, w.comma) or_return
 		}
 
 		if !field_needs_quoting(w, field) {
-			if _, err := io.write_string(w.w, field); err != nil {
-				return err;
-			}
-			continue;
+			io.write_string(w.w, field) or_return
+			continue
 		}
 
-		if err := io.write_byte(w.w, '"'); err != nil {
-			return err;
-		}
+		io.write_byte(w.w, '"') or_return
 
 		for len(field) > 0 {
-			i := strings.index_any(field, CHAR_SET);
+			i := strings.index_any(field, CHAR_SET)
 			if i < 0 {
-				i = len(field);
+				i = len(field)
 			}
 
-			if _, err := io.write_string(w.w, field[:i]); err != nil {
-				return err;
-			}
-			field = field[i:];
+			io.write_string(w.w, field[:i]) or_return
+			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;
-						}
+						io.write_byte(w.w, '\r') or_return
 					}
 				case '\n':
 					if w.use_crlf {
-						if _, err := io.write_string(w.w, "\r\n"); err != nil {
-							return err;
-						}
+						io.write_string(w.w, "\r\n") or_return
 					} else {
-						if err := io.write_byte(w.w, '\n'); err != nil {
-							return err;
-						}
+						io.write_byte(w.w, '\n') or_return
 					}
 				case '"':
-					if _, err := io.write_string(w.w, `""`); err != nil {
-						return err;
-					}
+					io.write_string(w.w, `""`) or_return
 				}
-				field = field[1:];
+				field = field[1:]
 			}
 		}
-		if err := io.write_byte(w.w, '"'); err != nil {
-			return err;
-		}
+		io.write_byte(w.w, '"') or_return
 	}
 
 	if w.use_crlf {
-		_, err := io.write_string(w.w, "\r\n");
-		return err;
+		_, err := io.write_string(w.w, "\r\n")
+		return err
 	}
-	return io.write_byte(w.w, '\n');
+	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;
-		}
+		write(w, record) or_return
 	}
-	return writer_flush(w);
+	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);
+	return io.flush(auto_cast w.w)
 }

core/encoding/hxa/doc.odin

@@ -0,0 +1,83 @@
+// Implementation of the HxA 3D asset format
+// HxA is a interchangeable graphics asset format.
+// Designed by Eskil Steenberg. @quelsolaar / eskil 'at' obsession 'dot' se / www.quelsolaar.com
+//
+// Author of this Odin package: Ginger Bill
+//
+// Following comment is copied from the original C-implementation
+// ---------
+// -Does the world need another Graphics file format?
+// 	Unfortunately, Yes. All existing formats are either too large and complicated to be implemented from
+// 	scratch, or don't have some basic features needed in modern computer graphics.
+// -Who is this format for?
+// 	For people who want a capable open Graphics format that can be implemented from scratch in
+// 	a few hours. It is ideal for graphics researchers, game developers or other people who
+// 	wants to build custom graphics pipelines. Given how easy it is to parse and write, it
+// 	should be easy to write utilities that process assets to preform tasks like: generating
+// 	normals, light-maps, tangent spaces, Error detection, GPU optimization, LOD generation,
+// 	and UV mapping.
+// -Why store images in the format when there are so many good image formats already?
+// 	Yes there are, but only for 2D RGB/RGBA images. A lot of computer graphics rendering rely
+// 	on 1D, 3D, cube, multilayer, multi channel, floating point bitmap buffers. There almost no
+// 	formats for this kind of data. Also 3D files that reference separate image files rely on
+// 	file paths, and this often creates issues when the assets are moved. By including the
+// 	texture data in the files directly the assets become self contained.
+// -Why doesn't the format support <insert whatever>?
+// 	Because the entire point is to make a format that can be implemented. Features like NURBSs,
+// 	Construction history, or BSP trees would make the format too large to serve its purpose.
+// 	The facilities of the formats to store meta data should make the format flexible enough
+// 	for most uses. Adding HxA support should be something anyone can do in a days work.
+
+// Structure:
+// ----------
+// HxA is designed to be extremely simple to parse, and is therefore based around conventions. It has
+// a few basic structures, and depending on how they are used they mean different things. This means
+// that you can implement a tool that loads the entire file, modifies the parts it cares about and
+// leaves the rest intact. It is also possible to write a tool that makes all data in the file
+// editable without the need to understand its use. It is also possible for anyone to use the format
+// to store data axillary data. Anyone who wants to store data not covered by a convention can submit
+// a convention to extend the format. There should never be a convention for storing the same data in
+// two differed ways.
+// The data is story in a number of nodes that are stored in an array. Each node stores an array of
+// meta data. Meta data can describe anything you want, and a lot of conventions will use meta data
+// to store additional information, for things like transforms, lights, shaders and animation.
+// Data for Vertices, Corners, Faces, and Pixels are stored in named layer stacks. Each stack consists
+// of a number of named layers. All layers in the stack have the same number of elements. Each layer
+// describes one property of the primitive. Each layer can have multiple channels and each layer can
+// store data of a different type.
+
+// HaX stores 3 kinds of nodes
+// 	- Pixel data.
+// 	- Polygon geometry data.
+// 	- Meta data only.
+
+// Pixel Nodes stores pixels in a layer stack. A layer may store things like Albedo, Roughness,
+// Reflectance, Light maps, Masks, Normal maps, and Displacement. Layers use the channels of the
+// layers to store things like color. The length of the layer stack is determined by the type and
+// dimensions stored in the
+
+// Geometry data is stored in 3 separate layer stacks for: vertex data, corner data and face data. The
+// vertex data stores things like verities, blend shapes, weight maps, and vertex colors. The first
+// layer in a vertex stack has to be a 3 channel layer named "position" describing the base position
+// of the vertices. The corner stack describes data per corner or edge of the polygons. It can be used
+// for things like UV, normals, and adjacency. The first layer in a corner stack has to be a 1 channel
+// integer layer named "index" describing the vertices used to form polygons. The last value in each
+// polygon has a negative - 1 index to indicate the end of the polygon.
+
+// Example:
+// 	A quad and a tri with the vertex index:
+// 		[0, 1, 2, 3] [1, 4, 2]
+// 	is stored:
+// 		[0, 1, 2, -4, 1, 4, -3]
+// The face stack stores values per face. the length of the face stack has to match the number of
+// negative values in the index layer in the corner stack. The face stack can be used to store things
+// like material index.
+
+// Storage
+// -------
+// All data is stored in little endian byte order with no padding. The layout mirrors the structs
+// defined below with a few exceptions. All names are stored as a 8-bit unsigned integer indicating
+// the length of the name followed by that many characters. Termination is not stored in the file.
+// Text strings stored in meta data are stored the same way as names, but instead of a 8-bit unsigned
+// integer a 32-bit unsigned integer is used.
+package encoding_hxa