From 42364f2fcee1f0f588b006bf2b7e9bc6f88acb93 Mon Sep 17 00:00:00 2001
From: phillvancejr <phillipvancejr@gmail.com>
Date: Fri, 4 Feb 2022 13:15:43 -0500
Subject: [PATCH] sync with main

---
 core/bindgen/c-parser-evaluate.odin      | 266 +++++++
 core/bindgen/c-parser-helpers.odin       | 267 +++++++
 core/bindgen/c-parser-nodes.odin         | 132 ++++
 core/bindgen/c-parser.odin               | 840 +++++++++++++++++++++++
 core/bindgen/errors.odin                 |  44 ++
 core/bindgen/generator-clean.odin        | 284 ++++++++
 core/bindgen/generator-export.odin       | 166 +++++
 core/bindgen/generator-helpers.odin      | 392 +++++++++++
 core/bindgen/generator.odin              | 205 ++++++
 vendor/stb/lib/darwin/libstb_image.a     | Bin 0 -> 55744 bytes
 vendor/stb/lib/darwin/stb_image.a        | Bin 0 -> 97544 bytes
 vendor/stb/lib/darwin/stb_image_resize.a | Bin 0 -> 36824 bytes
 vendor/stb/lib/darwin/stb_image_write.a  | Bin 0 -> 32896 bytes
 vendor/stb/lib/darwin/stb_rect_pack.a    | Bin 0 -> 5064 bytes
 vendor/stb/lib/darwin/stb_truetype.a     | Bin 0 -> 67008 bytes
 wasm-ld                                  |   1 +
 16 files changed, 2597 insertions(+)
 create mode 100644 core/bindgen/c-parser-evaluate.odin
 create mode 100644 core/bindgen/c-parser-helpers.odin
 create mode 100644 core/bindgen/c-parser-nodes.odin
 create mode 100644 core/bindgen/c-parser.odin
 create mode 100644 core/bindgen/errors.odin
 create mode 100644 core/bindgen/generator-clean.odin
 create mode 100644 core/bindgen/generator-export.odin
 create mode 100644 core/bindgen/generator-helpers.odin
 create mode 100644 core/bindgen/generator.odin
 create mode 100644 vendor/stb/lib/darwin/libstb_image.a
 create mode 100644 vendor/stb/lib/darwin/stb_image.a
 create mode 100644 vendor/stb/lib/darwin/stb_image_resize.a
 create mode 100644 vendor/stb/lib/darwin/stb_image_write.a
 create mode 100644 vendor/stb/lib/darwin/stb_rect_pack.a
 create mode 100644 vendor/stb/lib/darwin/stb_truetype.a
 create mode 120000 wasm-ld

diff --git a/core/bindgen/c-parser-evaluate.odin b/core/bindgen/c-parser-evaluate.odin
new file mode 100644
index 000000000..13cb5042c
--- /dev/null
+++ b/core/bindgen/c-parser-evaluate.odin
@@ -0,0 +1,266 @@
+package bindgen
+
+import "core:fmt"
+import "core:strconv"
+
+// Evaluates an expression to a i64, without checking.
+evaluate_i64 :: proc(data : ^ParserData) -> i64 {
+    ok : bool;
+    value : LiteralValue;
+
+    value, ok = evaluate(data);
+    return value.(i64);
+}
+
+// Evaluate an expression, returns whether it succeeded.
+evaluate :: proc(data : ^ParserData) -> (LiteralValue, bool) {
+    return evaluate_level_5(data);
+}
+
+// @note Evaluate levels numbers are based on
+// https://en.cppreference.com/w/c/language/operator_precedence.
+
+// Bitwise shift level.
+evaluate_level_5 :: proc(data : ^ParserData) -> (value : LiteralValue, ok : bool) {
+    value, ok = evaluate_level_4(data);
+    if !ok do return;
+
+    invalid_value : LiteralValue;
+    token := peek_token(data);
+
+    if token == "<<" {
+        v : LiteralValue;
+        eat_token(data);
+
+        v, ok = evaluate_level_5(data);
+        if is_i64(v) do value = value.(i64) << cast(u64) v.(i64);
+        else do invalid_value = v;
+    } else if token == ">>" {
+        v : LiteralValue;
+        eat_token(data);
+
+        v, ok = evaluate_level_5(data);
+        if is_i64(v) do value = value.(i64) >> cast(u64) v.(i64);
+        else do invalid_value = v;
+    }
+
+    if invalid_value != nil {
+        print_warning("Invalid operand for bitwise shift ", invalid_value);
+    }
+
+    return;
+}
+
+// Additive level.
+evaluate_level_4 :: proc(data : ^ParserData) -> (value : LiteralValue, ok : bool) {
+    value, ok = evaluate_level_3(data);
+    if !ok do return;
+
+    token := peek_token(data);
+    if token == "+" {
+        v : LiteralValue;
+        eat_token(data);
+        v, ok = evaluate_level_4(data);
+        if is_i64(v) do value = value.(i64) + v.(i64);
+        else if is_f64(v) do value = value.(f64) + v.(f64);
+    }
+    else if token == "-" {
+        v : LiteralValue;
+        eat_token(data);
+        v, ok = evaluate_level_4(data);
+        if is_i64(v) do value = value.(i64) - v.(i64);
+        else if is_f64(v) do value = value.(f64) - v.(f64);
+    }
+
+    return;
+}
+
+// Multiplicative level.
+evaluate_level_3 :: proc(data : ^ParserData) -> (value : LiteralValue, ok : bool) {
+    value, ok = evaluate_level_2(data);
+    if !ok do return;
+
+    token := peek_token(data);
+    if token == "*" {
+        v : LiteralValue;
+        eat_token(data);
+        v, ok = evaluate_level_3(data);
+        if is_i64(v) do value = value.(i64) * v.(i64);
+        else if is_f64(v) do value = value.(f64) * v.(f64);
+    }
+    else if token == "/" {
+        v : LiteralValue;
+        eat_token(data);
+        v, ok = evaluate_level_3(data);
+        if is_i64(v) do value = value.(i64) / v.(i64);
+        else if is_f64(v) do value = value.(f64) / v.(f64);
+    }
+
+    return;
+}
+
+// Prefix level.
+evaluate_level_2 :: proc(data : ^ParserData) -> (value : LiteralValue, ok : bool) {
+    token := peek_token(data);
+
+    // Bitwise not
+    if token == "~" {
+        check_and_eat_token(data, "~");
+        value, ok = evaluate_level_2(data);
+        value = ~value.(i64);
+    }
+    else {
+        // @note Should call evaluate_level_1, but we don't have that because we do not dereferenciation.
+        value, ok = evaluate_level_0(data);
+    }
+
+    return;
+}
+
+// Does not try to compose with arithmetics, it just evaluates one single expression.
+evaluate_level_0 :: proc(data : ^ParserData) -> (value : LiteralValue, ok : bool) {
+    ok = true;
+    value = 0;
+    token := peek_token(data);
+
+    // Parentheses
+    if token == "(" {
+        value, ok = evaluate_parentheses(data);
+    } // Number literal
+    else if (token[0] == '-') || (token[0] >= '0' && token[0] <= '9') {
+        value, ok = evaluate_number_literal(data);
+    } // String literal
+    else if token[0] == '"' {
+        value = evaluate_string_literal(data);
+    } // Function-like
+    else if token == "sizeof" {
+        value = evaluate_sizeof(data);
+    } // Knowned literal
+    else if token in data.knownedLiterals {
+        value = evaluate_knowned_literal(data);
+    } // Custom expression
+    else if token in data.options.customExpressionHandlers {
+        value = data.options.customExpressionHandlers[token](data);
+    }
+    else {
+        print_warning("Unknown token ", token, " for expression evaluation.");
+        ok = false;
+    }
+
+    return;
+}
+
+evaluate_sizeof :: proc(data : ^ParserData) -> LiteralValue {
+    print_warning("Using 'sizeof()'. Currently not able to precompute that. Please check generated code.");
+
+    check_and_eat_token(data, "sizeof");
+    check_and_eat_token(data, "(");
+    for data.bytes[data.offset] != ')' {
+        data.offset += 1;
+    }
+    check_and_eat_token(data, ")");
+    return 1;
+}
+
+evaluate_parentheses :: proc(data : ^ParserData) -> (value : LiteralValue, ok : bool) {
+    check_and_eat_token(data, "(");
+
+    // Cast to int (via "(int)" syntax)
+    token := peek_token(data);
+    if token == "int" {
+        check_and_eat_token(data, "int");
+        check_and_eat_token(data, ")");
+        value, ok = evaluate(data);
+        return;
+    } // Cast to enum value (via "(enum XXX)" syntax)
+    else if token == "enum" {
+        check_and_eat_token(data, "enum");
+        eat_token(data);
+        check_and_eat_token(data, ")");
+        value, ok = evaluate(data);
+        return;
+    }
+
+    value, ok = evaluate(data);
+    check_and_eat_token(data, ")");
+    return;
+}
+
+evaluate_number_literal :: proc(data : ^ParserData, loc := #caller_location) -> (value : LiteralValue, ok : bool) {
+    token := parse_any(data);
+
+    // Unary - before numbers
+    numberLitteral := token;
+    for token == "-" {
+        token = parse_any(data);
+        numberLitteral = tcat(numberLitteral, token);
+    }
+    token = numberLitteral;
+
+    // Check if any point or scientific notation in number
+    foundPointOrExp := false;
+    for c in token {
+        if c == '.' || c == 'e' || c == 'E' {
+            foundPointOrExp = true;
+            break;
+        }
+    }
+
+    isHexadecimal := len(token) >= 2 && token[:2] == "0x";
+
+    // Computing postfix
+    tokenLength := len(token);
+    l := tokenLength - 1;
+    for l > 0 {
+        c := token[l];
+        if c >= '0' && c <= '9' { break; }
+        if isHexadecimal && ((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) { break; }
+        l -= 1;
+    }
+
+    postfix : string;
+    if l != tokenLength - 1 {
+        postfix = token[l+1:];
+        token = token[:l+1];
+    }
+
+    if postfix != "" && (postfix[0] == 'u' || postfix[0] == 'U') {
+        print_warning("Found number litteral '", token, "' with unsigned postfix, we cast it to an int64 internally.");
+    }
+
+    // Floating point
+    if !isHexadecimal && (foundPointOrExp || postfix == "f") {
+        value, ok = strconv.parse_f64(token);
+    } // Integer
+    else {
+        value, ok = strconv.parse_i64(token);
+    }
+
+    if !ok {
+        print_error(data, loc, "Expected number litteral but got '", token, "'.");
+    }
+
+    return value, ok;
+}
+
+evaluate_string_literal :: proc(data : ^ParserData) -> string {
+    token := parse_any(data);
+    return token;
+}
+
+evaluate_knowned_literal :: proc(data : ^ParserData) -> LiteralValue {
+    token := parse_any(data);
+    return data.knownedLiterals[token];
+}
+
+is_i64 :: proc(value : LiteralValue) -> (ok : bool) {
+    v : i64;
+    v, ok = value.(i64);
+    return ok;
+}
+
+is_f64 :: proc(value : LiteralValue) -> (ok : bool) {
+    v : f64;
+    v, ok = value.(f64);
+    return ok;
+}
diff --git a/core/bindgen/c-parser-helpers.odin b/core/bindgen/c-parser-helpers.odin
new file mode 100644
index 000000000..a99d83dd2
--- /dev/null
+++ b/core/bindgen/c-parser-helpers.odin
@@ -0,0 +1,267 @@
+package bindgen
+
+import "core:os"
+import "core:fmt"
+import "core:strings"
+import "core:strconv"
+
+// Extract from start (included) to end (excluded) offsets
+extract_string :: proc(data : ^ParserData, startOffset : u32, endOffset : u32) -> string {
+    return strings.string_from_ptr(&data.bytes[startOffset], cast(int) (endOffset - startOffset));
+}
+
+// Peek the end offset of the next token
+peek_token_end :: proc(data : ^ParserData) -> u32 {
+    offset : u32;
+
+    for true {
+        eat_whitespaces_and_comments(data);
+        if data.offset >= data.bytesLength {
+            return data.bytesLength;
+        }
+        offset = data.offset;
+
+        // Identifier
+        if (data.bytes[offset] >= 'a' && data.bytes[offset] <= 'z') ||
+            (data.bytes[offset] >= 'A' && data.bytes[offset] <= 'Z') ||
+            (data.bytes[offset] == '_') {
+            offset += 1;
+            for (data.bytes[offset] >= 'a' && data.bytes[offset] <= 'z') ||
+                (data.bytes[offset] >= 'A' && data.bytes[offset] <= 'Z') ||
+                (data.bytes[offset] >= '0' && data.bytes[offset] <= '9') ||
+                (data.bytes[offset] == '_') {
+                offset += 1;
+            }
+        }
+        if offset != data.offset {
+            // Nothing to do: we found an identifier
+        } // Number literal
+        else if (data.bytes[offset] >= '0' && data.bytes[offset] <= '9') {
+            offset += 1;
+            // Hexademical literal
+            if data.bytes[offset - 1] == '0' && data.bytes[offset] == 'x' {
+                offset += 1;
+                for (data.bytes[offset] >= '0' && data.bytes[offset] <= '9') ||
+                    (data.bytes[offset] >= 'a' && data.bytes[offset] <= 'f') ||
+                    (data.bytes[offset] >= 'A' && data.bytes[offset] <= 'F') {
+                    offset += 1;
+                }
+            } // Basic number literal
+            else {
+                for (data.bytes[offset] >= '0' && data.bytes[offset] <= '9') ||
+                    data.bytes[offset] == '.' {
+                    offset += 1;
+                }
+
+                if (data.bytes[offset] == 'e' || data.bytes[offset] == 'E') {
+                    offset += 1;
+                    if data.bytes[offset] == '-' {
+                        offset += 1;
+                    }
+                }
+
+                for (data.bytes[offset] >= '0' && data.bytes[offset] <= '9') {
+                    offset += 1;
+                }
+            }
+
+            // Number suffix?
+            for (data.bytes[offset] == 'u' || data.bytes[offset] == 'U') ||
+                (data.bytes[offset] == 'l' || data.bytes[offset] == 'L') ||
+                (data.bytes[offset] == 'f') {
+                offset += 1;
+            }
+        } // String literal
+        else if data.bytes[offset] == '"' {
+            offset += 1;
+            for data.bytes[offset-1] == '\\' || data.bytes[offset] != '"' {
+                offset += 1;
+            }
+            offset += 1;
+        } // Possible shifts
+        else if data.bytes[offset] == '<' || data.bytes[offset] == '>' {
+            offset += 1;
+            if data.bytes[offset] == data.bytes[offset-1] {
+                offset += 1;
+            }
+        } // Single character
+        else {
+            offset += 1;
+        }
+
+        token := extract_string(data, data.offset, offset);
+
+        // Ignore __attribute__
+        if token == "__attribute__" {
+            print_warning("__attribute__ is ignored.");
+
+            for data.bytes[offset] != '(' {
+                offset += 1;
+            }
+
+            parenthesesCount := 1;
+            for true {
+                offset += 1;
+                if data.bytes[offset] == '(' do parenthesesCount += 1;
+                else if data.bytes[offset] == ')' do parenthesesCount -= 1;
+                if parenthesesCount == 0 do break;
+            }
+            offset += 1;
+
+            data.offset = offset;
+        } // Ignore certain keywords
+        else if (token == "inline" || token == "__inline" || token == "static"
+                || token == "restrict" || token == "__restrict"
+                || token == "volatile"
+                || token == "__extension__") {
+            data.offset = offset;
+        } // Ignore ignored tokens ;)
+        else {
+            for ignoredToken in data.options.ignoredTokens {
+                if token == ignoredToken {
+                    data.offset = offset;
+                    break;
+                }
+            }
+        }
+
+        if data.offset != offset {
+            break;
+        }
+    }
+
+    return offset;
+}
+
+// Peek the next token (just eating whitespaces and comment)
+peek_token :: proc(data : ^ParserData) -> string {
+    tokenEnd := peek_token_end(data);
+    if tokenEnd == data.bytesLength {
+        return "EOF";
+    }
+    return extract_string(data, data.offset, tokenEnd);
+}
+
+// Find the end of the define directive (understanding endline backslashes)
+// @note Tricky cases like comments hiding a backslash effect are not handled.
+peek_define_end :: proc(data : ^ParserData) -> u32 {
+    defineEndOffset := data.offset;
+    for data.bytes[defineEndOffset-1] == '\\' || data.bytes[defineEndOffset] != '\n'  {
+        defineEndOffset += 1;
+    }
+    return defineEndOffset;
+}
+
+eat_comment :: proc(data : ^ParserData) {
+    if data.offset >= data.bytesLength || data.bytes[data.offset] != '/' {
+        return;
+    }
+
+    // Line comment
+    if data.bytes[data.offset + 1] == '/' {
+        eat_line(data);
+    } // Range comment
+    else if data.bytes[data.offset + 1] == '*' {
+        data.offset += 2;
+        for data.bytes[data.offset] != '*' || data.bytes[data.offset + 1] != '/' {
+            data.offset += 1;
+        }
+        data.offset += 2;
+    }
+}
+
+// Eat whitespaces
+eat_whitespaces :: proc(data : ^ParserData) {
+    // Effective whitespace
+    for data.offset < data.bytesLength &&
+        (data.bytes[data.offset] == ' ' || data.bytes[data.offset] == '\t' ||
+        data.bytes[data.offset] == '\r' || data.bytes[data.offset] == '\n') {
+        if data.bytes[data.offset] == '\n' && data.bytes[data.offset] != '\\' {
+            data.foundFullReturn = true;
+        }
+        data.offset += 1;
+    }
+}
+
+// Removes whitespaces and comments
+eat_whitespaces_and_comments :: proc(data : ^ParserData) {
+    startOffset : u32 = 0xFFFFFFFF;
+    for startOffset != data.offset {
+        startOffset = data.offset;
+        eat_whitespaces(data);
+        eat_comment(data);
+    }
+}
+
+// Eat full line
+eat_line :: proc(data : ^ParserData) {
+    for ; data.bytes[data.offset] != '\n'; data.offset += 1 {
+    }
+}
+
+// Eat a line, and repeat if it ends with a backslash
+eat_define_lines :: proc(data : ^ParserData) {
+    for data.bytes[data.offset-1] == '\\' || data.bytes[data.offset] != '\n'  {
+        data.offset += 1;
+    }
+}
+
+// Eat next token
+eat_token :: proc(data : ^ParserData) {
+    data.offset = peek_token_end(data);
+}
+
+// Eat next token
+check_and_eat_token :: proc(data : ^ParserData, expectedToken : string, loc := #caller_location) {
+    token := peek_token(data);
+    if token != expectedToken {
+        print_error(data, loc, "Expected ", expectedToken, " but found ", token, ".");
+    }
+    data.offset += cast(u32) len(token);
+}
+
+// Check whether the next token is outside #define range
+is_define_end :: proc(data : ^ParserData) -> bool {
+    defineEnd := peek_define_end(data);
+    tokenEnd := peek_token_end(data);
+
+    return (defineEnd < tokenEnd);
+}
+
+// Check if the current #define is a macro definition
+is_define_macro :: proc(data : ^ParserData) -> bool {
+    startOffset := data.offset;
+    defer data.offset = startOffset;
+
+    token := parse_any(data);
+    if token != "(" do return false;
+
+    // Find the other parenthesis
+    parenthesesCount := 1;
+    for parenthesesCount != 0 {
+        token = parse_any(data);
+        if token == "(" do parenthesesCount += 1;
+        else if token == ")" do parenthesesCount -= 1;
+    }
+
+    // Its a macro if after the parentheses, it's not the end
+    return !is_define_end(data);
+}
+
+// @note Very slow function to get line number,
+// use only for errors.
+// @todo Well, this does not seem to work properly, UTF-8 problem?
+get_line_column :: proc(data : ^ParserData) -> (u32, u32) {
+    line : u32 = 1;
+    column : u32 = 0;
+    for i : u32 = 0; i < data.offset; i += 1 {
+        if data.bytes[i] == '\n' {
+            column = 0;
+            line += 1;
+        }
+        else {
+            column += 1;
+        }
+    }
+    return line, column;
+}
diff --git a/core/bindgen/c-parser-nodes.odin b/core/bindgen/c-parser-nodes.odin
new file mode 100644
index 000000000..0620e0187
--- /dev/null
+++ b/core/bindgen/c-parser-nodes.odin
@@ -0,0 +1,132 @@
+package bindgen
+
+DefineNode :: struct {
+    name : string,
+    value : LiteralValue,
+}
+
+StructDefinitionNode :: struct {
+    name : string,
+    members : [dynamic]StructOrUnionMember,
+    forwardDeclared : bool,
+}
+
+UnionDefinitionNode :: struct {
+    name : string,
+    members : [dynamic]StructOrUnionMember,
+}
+
+EnumDefinitionNode :: struct {
+    name : string,
+    members : [dynamic]EnumMember,
+}
+
+FunctionDeclarationNode :: struct {
+    name : string,
+    returnType : Type,
+    parameters : [dynamic]FunctionParameter,
+}
+
+TypedefNode :: struct {
+    name : string,
+    type : Type,
+}
+
+Nodes :: struct {
+    defines : [dynamic]DefineNode,
+    enumDefinitions : [dynamic]EnumDefinitionNode,
+    unionDefinitions : [dynamic]UnionDefinitionNode,
+    structDefinitions : [dynamic]StructDefinitionNode,
+    functionDeclarations : [dynamic]FunctionDeclarationNode,
+    typedefs : [dynamic]TypedefNode,
+}
+
+LiteralValue :: union {
+    i64,
+    f64,
+    string,
+}
+
+// Type, might be an array
+Type :: struct {
+    base : BaseType,
+    dimensions : [dynamic]u64,  // Array dimensions
+}
+
+BaseType :: union {
+    BuiltinType,
+    PointerType,
+    IdentifierType,
+    FunctionType,
+    FunctionPointerType,
+}
+
+BuiltinType :: enum {
+    Unknown,
+    Void,
+    Int,
+    UInt,
+    LongInt,
+    ULongInt,
+    LongLongInt,
+    ULongLongInt,
+    ShortInt,
+    UShortInt,
+    Char,
+    SChar,
+    UChar,
+    Float,
+    Double,
+    LongDouble,
+
+    // Not defined by C language but in <stdint.h>
+    Int8,
+    Int16,
+    Int32,
+    Int64,
+    UInt8,
+    UInt16,
+    UInt32,
+    UInt64,
+    Size,
+    SSize,
+    PtrDiff,
+    UIntPtr,
+    IntPtr,
+}
+
+PointerType :: struct {
+    type : ^Type, // Pointer is there to prevent definition cycle. Null means void.
+}
+
+IdentifierType :: struct {
+    name : string,
+    anonymous : bool, // An anonymous identifier can be hard-given a name in some contexts.
+}
+
+FunctionType :: struct {
+    returnType : ^Type, // Pointer is there to prevent definition cycle. Null means void.
+    parameters : [dynamic]FunctionParameter,
+}
+
+FunctionPointerType :: struct {
+    name : string,
+    returnType : ^Type, // Pointer is there to prevent definition cycle. Null means void.
+    parameters : [dynamic]FunctionParameter,
+}
+
+EnumMember :: struct {
+    name : string,
+    value : i64,
+    hasValue : bool,
+}
+
+StructOrUnionMember :: struct {
+    name : string,
+    type : Type,
+}
+
+FunctionParameter :: struct {
+    name : string,
+    type : Type,
+}
diff --git a/core/bindgen/c-parser.odin b/core/bindgen/c-parser.odin
new file mode 100644
index 000000000..c3ef4937f
--- /dev/null
+++ b/core/bindgen/c-parser.odin
@@ -0,0 +1,840 @@
+package bindgen
+
+import "core:os"
+import "core:fmt"
+import "core:strings"
+import "core:strconv"
+
+// Global counters
+anonymousStructCount := 0;
+anonymousUnionCount := 0;
+anonymousEnumCount := 0;
+
+knownTypeAliases : map[string]Type;
+
+CustomHandler :: proc(data : ^ParserData);
+CustomExpressionHandler :: proc(data : ^ParserData) -> LiteralValue;
+
+ParserOptions :: struct {
+    ignoredTokens : []string,
+
+    // Handlers
+    customHandlers : map[string]CustomHandler,
+    customExpressionHandlers : map[string]CustomExpressionHandler,
+}
+
+ParserData :: struct {
+    bytes : []u8,
+    bytesLength : u32,
+    offset : u32,
+
+    // References
+    nodes : Nodes,
+    options : ^ParserOptions,
+
+    // Knowned values
+    knownedLiterals : map[string]LiteralValue,
+
+    // Whether we have eaten a '\n' character that has no backslash just before
+    foundFullReturn : bool,
+}
+
+is_identifier :: proc(token : string) -> bool {
+    return (token[0] >= 'a' && token[0] <= 'z') ||
+        (token[0] >= 'A' && token[0] <= 'Z') ||
+        (token[0] == '_');
+}
+
+parse :: proc(bytes : []u8, options : ParserOptions, loc := #caller_location) -> Nodes {
+    options := options;
+
+    data : ParserData;
+    data.bytes = bytes;
+    data.bytesLength = cast(u32) len(bytes);
+    data.options = &options;
+
+    for data.offset = 0; data.offset < data.bytesLength; {
+        token := peek_token(&data);
+        if data.offset == data.bytesLength do break;
+
+        if token in options.customHandlers {
+            options.customHandlers[token](&data);
+        }
+        else if token == "{" || token == "}" || token == ";" {
+            eat_token(&data);
+        }
+        else if token == "extern" {
+            check_and_eat_token(&data, "extern");
+        }
+        else if token == "\"C\"" {
+            check_and_eat_token(&data, "\"C\"");
+        }
+        else if token == "#" {
+            parse_directive(&data);
+        }
+        else if token == "typedef" {
+            parse_typedef(&data);
+        }
+        else if is_identifier(token) {
+            parse_variable_or_function_declaration(&data);
+        }
+        else {
+            print_error(&data, loc, "Unexpected token: ", token, ".");
+            return data.nodes;
+        }
+    }
+
+    return data.nodes;
+}
+
+parse_any :: proc(data : ^ParserData) -> string {
+    offset := peek_token_end(data);
+    identifier := extract_string(data, data.offset, offset);
+    data.offset = offset;
+    return identifier;
+}
+
+parse_identifier :: proc(data : ^ParserData, loc := #caller_location) -> string {
+    identifier := parse_any(data);
+
+    if (identifier[0] < 'a' || identifier[0] > 'z') &&
+        (identifier[0] < 'A' || identifier[0] > 'Z') &&
+        (identifier[0] != '_') {
+            print_error(data, loc, "Expected identifier but found ", identifier, ".");
+        }
+
+    return identifier;
+}
+
+parse_type_dimensions :: proc(data : ^ParserData, type : ^Type) {
+    token := peek_token(data);
+    for token == "[" {
+        eat_token(data);
+        token = peek_token(data);
+        if token == "]" {
+            pointerType : PointerType;
+            pointerType.type = new(Type);
+            pointerType.type^ = type^; // Copy
+            type.base = pointerType;
+            delete(type.dimensions);
+        } else {
+            dimension := evaluate_i64(data);
+            append(&type.dimensions, cast(u64) dimension);
+        }
+        check_and_eat_token(data, "]");
+        token = peek_token(data);
+    }
+}
+
+// This will parse anything that look like a type:
+// Builtin: char/int/float/...
+// Struct-like: struct A/struct { ... }/enum E
+// Function pointer: void (*f)(...)
+//
+// Definition permitted: If a struct-like definition is found, it will generate
+// the according Node and return a corresponding type.
+parse_type :: proc(data : ^ParserData, definitionPermitted := false) -> Type {
+    type : Type;
+
+    // Eat qualifiers
+    token := peek_token(data);
+    if token == "const" {
+        eat_token(data);
+        token = peek_token(data);
+    }
+
+    // Parse main type
+    if token == "struct" {
+        type.base = parse_struct_type(data, definitionPermitted);
+    }
+    else if token == "union" {
+        type.base = parse_union_type(data);
+    }
+    else if token == "enum" {
+        type.base = parse_enum_type(data);
+    }
+    else {
+        // Test builtin type
+        type.base = parse_builtin_type(data);
+        if type.base.(BuiltinType) == BuiltinType.Unknown {
+            // Basic identifier type
+            identifierType : IdentifierType;
+            identifierType.name = parse_identifier(data);
+            type.base = identifierType;
+        }
+    }
+
+    // Eat qualifiers
+    token = peek_token(data);
+    if token == "const" {
+        eat_token(data);
+        token = peek_token(data);
+    }
+
+    // Check if pointer
+    for token == "*" {
+        check_and_eat_token(data, "*");
+        token = peek_token(data);
+
+        pointerType : PointerType;
+        pointerType.type = new(Type);
+        pointerType.type^ = type; // Copy
+
+        type.base = pointerType;
+
+        // Eat qualifiers
+        if token == "const" {
+            eat_token(data);
+            token = peek_token(data);
+        }
+    }
+
+    // Parse array dimensions if any.
+    parse_type_dimensions(data, &type);
+
+    // ----- Function pointer type
+
+    if token == "(" {
+        check_and_eat_token(data, "(");
+        check_and_eat_token(data, "*");
+
+        functionPointerType : FunctionPointerType;
+        functionPointerType.returnType = new(Type);
+        functionPointerType.returnType^ = type;
+        functionPointerType.name = parse_identifier(data);
+
+        check_and_eat_token(data, ")");
+        parse_function_parameters(data, &functionPointerType.parameters);
+
+        type.base = functionPointerType;
+    }
+
+    return type;
+}
+
+parse_builtin_type :: proc(data : ^ParserData) -> BuiltinType {
+    previousBuiltinType := BuiltinType.Unknown;
+    intFound := false;
+    shortFound := false;
+    signedFound := false;
+    unsignedFound := false;
+    longCount := 0;
+
+    for true {
+        token := peek_token(data);
+
+        // Attribute
+        attributeFound := true;
+        if token == "long" do longCount += 1;
+        else if token == "short" do shortFound = true;
+        else if token == "unsigned" do unsignedFound = true;
+        else if token == "signed" do signedFound = true;
+        else do attributeFound = false;
+        if attributeFound { eat_token(data); continue; }
+
+        // Known type alias
+        if token in knownTypeAliases {
+            builtinType, ok := knownTypeAliases[token].base.(BuiltinType);
+            if ok {
+                eat_token(data);
+                previousBuiltinType = builtinType;
+            }
+            break;
+        }
+
+        // Classic type and standard types
+        if token == "void" { eat_token(data); return BuiltinType.Void; }
+        else if token == "int" {
+            eat_token(data);
+            intFound = true;
+        }
+        else if token == "float" { eat_token(data); return BuiltinType.Float; }
+        else if token == "double" {
+            eat_token(data);
+            if longCount == 0 do return BuiltinType.Double;
+            else do return BuiltinType.LongDouble;
+        }
+        else if token == "char" {
+            eat_token(data);
+            if signedFound do return BuiltinType.SChar;
+            else if unsignedFound do return BuiltinType.UChar;
+            else do return BuiltinType.Char;
+        }
+        else if token == "__int8" {
+            // @note :MicrosoftDumminess __intX are Microsoft's fixed-size integers
+            // https://docs.microsoft.com/fr-fr/cpp/cpp/int8-int16-int32-int64
+            // and for unsigned version, they prefixed it with "unsigned"...
+            eat_token(data);
+            if unsignedFound do return BuiltinType.UInt8;
+            else do return BuiltinType.Int8;
+        }
+        else if token == "__int16" {
+            eat_token(data);
+            if unsignedFound do return BuiltinType.UInt16;
+            else do return BuiltinType.Int16;
+        }
+        else if token == "__int32" {
+            eat_token(data);
+            if unsignedFound do return BuiltinType.UInt32;
+            else do return BuiltinType.Int32;
+        }
+        else if token == "__int64" {
+            eat_token(data);
+            if unsignedFound do return BuiltinType.UInt64;
+            else do return BuiltinType.Int64;
+        }
+        else if token == "int8_t" { eat_token(data); return BuiltinType.Int8; }
+        else if token == "int16_t" { eat_token(data); return BuiltinType.Int16; }
+        else if token == "int32_t" { eat_token(data); return BuiltinType.Int32; }
+        else if token == "int64_t" { eat_token(data); return BuiltinType.Int64; }
+        else if token == "uint8_t" { eat_token(data); return BuiltinType.UInt8; }
+        else if token == "uint16_t" { eat_token(data); return BuiltinType.UInt16; }
+        else if token == "uint32_t" { eat_token(data); return BuiltinType.UInt32; }
+        else if token == "uint64_t" { eat_token(data); return BuiltinType.UInt64; }
+        else if token == "size_t" { eat_token(data); return BuiltinType.Size; }
+        else if token == "ssize_t" { eat_token(data); return BuiltinType.SSize; }
+        else if token == "ptrdiff_t" { eat_token(data); return BuiltinType.PtrDiff; }
+        else if token == "uintptr_t" { eat_token(data); return BuiltinType.UIntPtr; }
+        else if token == "intptr_t" { eat_token(data); return BuiltinType.IntPtr; }
+
+        break;
+    }
+
+    // Adapt previous builtin type
+    if previousBuiltinType == BuiltinType.ShortInt {
+        shortFound = true;
+    }
+    else if previousBuiltinType == BuiltinType.Int {
+        intFound = true;
+    }
+    else if previousBuiltinType == BuiltinType.LongInt {
+        longCount += 1;
+    }
+    else if previousBuiltinType == BuiltinType.LongLongInt {
+        longCount += 2;
+    }
+    else if previousBuiltinType == BuiltinType.UShortInt {
+        unsignedFound = true;
+        shortFound = true;
+    }
+    else if previousBuiltinType == BuiltinType.UInt {
+        unsignedFound = true;
+    }
+    else if previousBuiltinType == BuiltinType.ULongInt {
+        unsignedFound = true;
+        longCount += 1;
+    }
+    else if previousBuiltinType == BuiltinType.ULongLongInt {
+        unsignedFound = true;
+        longCount += 2;
+    }
+    else if (previousBuiltinType != BuiltinType.Unknown) {
+        return previousBuiltinType; // float, void, etc.
+    }
+
+    // Implicit and explicit int
+    if intFound || shortFound || unsignedFound || signedFound || longCount > 0 {
+        if unsignedFound {
+            if shortFound do return BuiltinType.UShortInt;
+            if longCount == 0 do return BuiltinType.UInt;
+            if longCount == 1 do return BuiltinType.ULongInt;
+            if longCount == 2 do return BuiltinType.ULongLongInt;
+        } else {
+            if shortFound do return BuiltinType.ShortInt;
+            if longCount == 0 do return BuiltinType.Int;
+            if longCount == 1 do return BuiltinType.LongInt;
+            if longCount == 2 do return BuiltinType.LongLongInt;
+        }
+    }
+
+    return BuiltinType.Unknown;
+}
+
+parse_struct_type :: proc(data : ^ParserData, definitionPermitted : bool) -> IdentifierType {
+    check_and_eat_token(data, "struct");
+
+    type : IdentifierType;
+    token := peek_token(data);
+
+    if !definitionPermitted || token != "{" {
+        type.name = parse_identifier(data);
+        token = peek_token(data);
+    } else {
+        type.name = tcat("AnonymousStruct", anonymousStructCount);
+        type.anonymous = true;
+        anonymousStructCount += 1;
+    }
+
+    if token == "{" {
+        node := parse_struct_definition(data);
+        node.name = type.name;
+    } else if definitionPermitted {
+        // @note Whatever happens, we create a definition of the struct,
+        // as it might be used to forward declare it and then use it only with a pointer.
+        // This for instance the pattern for xcb_connection_t which definition
+        // is never known from user API.
+        node : StructDefinitionNode;
+        node.forwardDeclared = false;
+        node.name = type.name;
+        append(&data.nodes.structDefinitions, node);
+    }
+
+    return type;
+}
+
+parse_union_type :: proc(data : ^ParserData) -> IdentifierType {
+    check_and_eat_token(data, "union");
+
+    type : IdentifierType;
+    token := peek_token(data);
+
+    if token != "{" {
+        type.name = parse_identifier(data);
+        token = peek_token(data);
+    } else {
+        type.name = tcat("AnonymousUnion", anonymousUnionCount);
+        type.anonymous = true;
+        anonymousUnionCount += 1;
+    }
+
+    if token == "{" {
+        node := parse_union_definition(data);
+        node.name = type.name;
+    }
+
+    return type;
+}
+
+parse_enum_type :: proc(data : ^ParserData) -> IdentifierType {
+    check_and_eat_token(data, "enum");
+
+    type : IdentifierType;
+    token := peek_token(data);
+
+    if token != "{" {
+        type.name = parse_identifier(data);
+        token = peek_token(data);
+    } else {
+        type.name = tcat("AnonymousEnum", anonymousEnumCount);
+        type.anonymous = true;
+        anonymousEnumCount += 1;
+    }
+
+    if token == "{" {
+        node := parse_enum_definition(data);
+        node.name = type.name;
+    }
+
+    return type;
+}
+
+/**
+ * We only care about defines of some value
+ */
+parse_directive :: proc(data : ^ParserData) {
+    check_and_eat_token(data, "#");
+
+    token := peek_token(data);
+    if token == "define" {
+        parse_define(data);
+    } // We ignore all other directives
+    else {
+        eat_line(data);
+    }
+}
+
+parse_define :: proc(data : ^ParserData) {
+    check_and_eat_token(data, "define");
+    data.foundFullReturn = false;
+
+    node : DefineNode;
+    node.name = parse_identifier(data);
+
+    // Does it look like end? It might be a #define with no expression
+    if is_define_end(data) {
+        node.value = 1;
+        append(&data.nodes.defines, node);
+        data.knownedLiterals[node.name] = node.value;
+    } // Macros are ignored
+    else if is_define_macro(data) {
+        print_warning("Ignoring define macro for ", node.name, ".");
+    }
+    else {
+        literalValue, ok := evaluate(data);
+        if ok {
+            node.value = literalValue;
+            append(&data.nodes.defines, node);
+            data.knownedLiterals[node.name] = node.value;
+        }
+        else {
+            print_warning("Ignoring define expression for ", node.name, ".");
+        }
+    }
+
+    // Evaluating the expression, we might have already eaten a full return,
+    // if so, do nothing.
+    if !data.foundFullReturn {
+        eat_define_lines(data);
+    }
+}
+
+// @fixme Move
+change_anonymous_node_name :: proc (data : ^ParserData, oldName : string, newName : string) -> bool {
+    for i := 0; i < len(data.nodes.structDefinitions); i += 1 {
+        if data.nodes.structDefinitions[i].name == oldName {
+            data.nodes.structDefinitions[i].name = newName;
+            return true;
+        }
+    }
+
+    for i := 0; i < len(data.nodes.enumDefinitions); i += 1 {
+        if data.nodes.enumDefinitions[i].name == oldName {
+            data.nodes.enumDefinitions[i].name = newName;
+            return true;
+        }
+    }
+
+    for i := 0; i < len(data.nodes.unionDefinitions); i += 1 {
+        if data.nodes.unionDefinitions[i].name == oldName {
+            data.nodes.unionDefinitions[i].name = newName;
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Type aliasing.
+ *  typedef <sourceType> <name>;
+ */
+parse_typedef :: proc(data : ^ParserData) {
+    check_and_eat_token(data, "typedef");
+
+    // @note Struct-like definitions (and such)
+    // are generated within type parsing.
+    //
+    // So that typedef struct { int foo; }* Ap; is valid.
+
+    // Parsing type
+    node : TypedefNode;
+    node.type = parse_type(data, true);
+
+    if sourceType, ok := node.type.base.(FunctionPointerType); ok {
+        node.name = sourceType.name;
+    } else {
+        node.name = parse_identifier(data);
+    }
+
+    // Checking if function type
+    token := peek_token(data);
+    if token == "(" {
+        functionType : FunctionType;
+        functionType.returnType = new(Type);
+        functionType.returnType^ = node.type;
+
+        parse_function_parameters(data, &functionType.parameters);
+
+        node.type.base = functionType;
+    }
+
+    // Checking if array
+    parse_type_dimensions(data, &node.type);
+
+    // If the underlying type is anonymous,
+    // we just affect it the name.
+    addTypedefNode := true;
+    if identifierType, ok := node.type.base.(IdentifierType); ok {
+        if identifierType.anonymous {
+            addTypedefNode = !change_anonymous_node_name(data, identifierType.name, node.name);
+        }
+    }
+
+    if addTypedefNode {
+        knownTypeAliases[node.name] = node.type;
+        append(&data.nodes.typedefs, node);
+    }
+
+    check_and_eat_token(data, ";");
+
+    // @note Commented tool for debug
+    // fmt.println("Typedef: ", node.type, node.name);
+}
+
+parse_struct_definition :: proc(data : ^ParserData) -> ^StructDefinitionNode {
+    node : StructDefinitionNode;
+    node.forwardDeclared = false;
+    parse_struct_or_union_members(data, &node.members);
+
+    append(&data.nodes.structDefinitions, node);
+    return &data.nodes.structDefinitions[len(data.nodes.structDefinitions) - 1];
+}
+
+parse_union_definition :: proc(data : ^ParserData) -> ^UnionDefinitionNode {
+    node : UnionDefinitionNode;
+    parse_struct_or_union_members(data, &node.members);
+
+    append(&data.nodes.unionDefinitions, node);
+    return &data.nodes.unionDefinitions[len(data.nodes.unionDefinitions) - 1];
+}
+
+parse_enum_definition :: proc(data : ^ParserData) -> ^EnumDefinitionNode {
+    node : EnumDefinitionNode;
+    parse_enum_members(data, &node.members);
+
+    append(&data.nodes.enumDefinitions, node);
+    return &data.nodes.enumDefinitions[len(data.nodes.enumDefinitions) - 1];
+}
+
+/**
+ *  {
+ *      <name> = <value>,
+ *      <name>,
+ *  }
+ */
+parse_enum_members :: proc(data : ^ParserData, members : ^[dynamic]EnumMember) {
+    check_and_eat_token(data, "{");
+
+    nextMemberValue : i64 = 0;
+    token := peek_token(data);
+    for token != "}" {
+        member : EnumMember;
+        member.name = parse_identifier(data);
+        member.hasValue = false;
+
+        token = peek_token(data);
+        if token == "=" {
+            check_and_eat_token(data, "=");
+
+            member.hasValue = true;
+            member.value = evaluate_i64(data);
+            nextMemberValue = member.value;
+            token = peek_token(data);
+        } else {
+            member.value = nextMemberValue;
+        }
+
+        data.knownedLiterals[member.name] = member.value;
+        nextMemberValue += 1;
+
+        // Eat until end, as this might be a complex expression that we couldn't understand
+        if token != "," && token != "}" {
+            print_warning("Parser cannot understand fully the expression of enum member ", member.name, ".");
+            for token != "," && token != "}" {
+                eat_token(data);
+                token = peek_token(data);
+            }
+        }
+        if token == "," {
+            check_and_eat_token(data, ",");
+            token = peek_token(data);
+        }
+
+        append(members, member);
+    }
+
+    check_and_eat_token(data, "}");
+}
+
+/**
+ *  {
+ *      <type> <name>;
+ *      <type> <name1>, <name2>;
+ *      <type> <name>[<dimension>];
+ *  }
+ */
+parse_struct_or_union_members :: proc(data : ^ParserData, structOrUnionMembers : ^[dynamic]StructOrUnionMember) {
+    check_and_eat_token(data, "{");
+
+    // To ensure unique id
+    unamedCount := 0;
+
+    token := peek_token(data);
+    for token != "}" {
+        member : StructOrUnionMember;
+        member.type = parse_type(data, true);
+
+        for true {
+            // In the case of function pointer types, the name has been parsed
+            // during type inspection.
+            if type, ok := member.type.base.(FunctionPointerType); ok {
+                member.name = type.name;
+            }
+            else {
+                // Unamed (struct or union)
+                token = peek_token(data);
+                if !is_identifier(token) {
+                    member.name = tcat("unamed", unamedCount);
+                    unamedCount += 1;
+                }
+                else {
+                    member.name = parse_identifier(data);
+                }
+            }
+
+            parse_type_dimensions(data, &member.type);
+
+            token = peek_token(data);
+            if token == ":" {
+                check_and_eat_token(data, ":");
+                print_warning("Found bitfield in struct, which is not handled correctly.");
+                evaluate_i64(data);
+                token = peek_token(data);
+            }
+
+            append(structOrUnionMembers, member);
+
+            // Multiple declarations on one line
+            if token == "," {
+                check_and_eat_token(data, ",");
+                continue;
+            }
+
+            break;
+        }
+
+        check_and_eat_token(data, ";");
+        token = peek_token(data);
+    }
+
+    check_and_eat_token(data, "}");
+}
+
+parse_variable_or_function_declaration :: proc(data : ^ParserData) {
+    type := parse_type(data, true);
+
+    // If it's just a type, it might be a struct definition
+    token := peek_token(data);
+    if token == ";" {
+        check_and_eat_token(data, ";");
+        return;
+    }
+
+    // Eat array declaration if any
+    // @fixme The return type of a function declaration will be wrong!
+    for data.bytes[data.offset] == '[' {
+        for data.bytes[data.offset] != ']' {
+            data.offset += 1;
+        }
+        data.offset += 1;
+    }
+
+    name := parse_identifier(data);
+
+    token = peek_token(data);
+    if token == "(" {
+        functionDeclarationNode := parse_function_declaration(data);
+        functionDeclarationNode.returnType = type;
+        functionDeclarationNode.name = name;
+        return;
+    } else if token == "[" {
+        // Eat whole array declaration
+        for data.bytes[data.offset] == '[' {
+            for data.bytes[data.offset] != ']' {
+                data.offset += 1;
+            }
+            data.offset += 1;
+        }
+    }
+
+    // Global variable declaration (with possible multiple declarations)
+    token = peek_token(data);
+
+    for true {
+        if token == "," {
+            print_warning("Found global variable declaration '", name, "', we won't generated any binding for it.");
+            check_and_eat_token(data, ",");
+
+            name = parse_identifier(data);
+            token = peek_token(data);
+            continue;
+        }
+        else if token == ";" {
+            if name != "" {
+                print_warning("Found global variable declaration '", name, "', we won't generated any binding for it.");
+            }
+            check_and_eat_token(data, ";");
+            break;
+        }
+
+        // Global variable assignment, considered as constant define.
+        node : DefineNode;
+
+        check_and_eat_token(data, "=");
+        literalValue, ok := evaluate(data);
+        if ok {
+            node.name = name;
+            node.value = literalValue;
+            append(&data.nodes.defines, node);
+        }
+        else {
+            print_warning("Ignoring global variable expression for '", name, "'.");
+        }
+
+        name = "";
+        token = peek_token(data);
+    }
+}
+
+parse_function_declaration :: proc(data : ^ParserData) -> ^FunctionDeclarationNode {
+    node : FunctionDeclarationNode;
+
+    parse_function_parameters(data, &node.parameters);
+
+    // Function definition? Ignore it.
+    token := peek_token(data);
+    if token == "{" {
+        bracesCount := 1;
+        for true {
+            data.offset += 1;
+            if data.bytes[data.offset] == '{' do bracesCount += 1;
+            else if data.bytes[data.offset] == '}' do bracesCount -= 1;
+            if bracesCount == 0 do break;
+        }
+        data.offset += 1;
+    } // Function declaration
+    else {
+        check_and_eat_token(data, ";");
+    }
+
+    append(&data.nodes.functionDeclarations, node);
+    return &data.nodes.functionDeclarations[len(data.nodes.functionDeclarations) - 1];
+}
+
+parse_function_parameters :: proc(data : ^ParserData, parameters : ^[dynamic]FunctionParameter) {
+    check_and_eat_token(data, "(");
+
+    token := peek_token(data);
+    for token != ")" {
+        parameter : FunctionParameter;
+
+        token = peek_token(data);
+        if token == "." {
+            print_warning("A function accepts variadic arguments, this is currently not handled within generated code.");
+
+            check_and_eat_token(data, ".");
+            check_and_eat_token(data, ".");
+            check_and_eat_token(data, ".");
+            break;
+        } else {
+            parameter.type = parse_type(data);
+        }
+
+        // Check if named parameter
+        token = peek_token(data);
+        if token != ")" && token != "," {
+            parameter.name = parse_identifier(data);
+            parse_type_dimensions(data, &parameter.type);
+            token = peek_token(data);
+        }
+
+        if token == "," {
+            eat_token(data);
+            token = peek_token(data);
+        }
+
+        append(parameters, parameter);
+    }
+
+    check_and_eat_token(data, ")");
+}
diff --git a/core/bindgen/errors.odin b/core/bindgen/errors.odin
new file mode 100644
index 000000000..9564c5244
--- /dev/null
+++ b/core/bindgen/errors.odin
@@ -0,0 +1,44 @@
+package bindgen
+
+import "core:fmt"
+import "core:os"
+
+seenWarnings : map[string]bool;
+
+print_warning :: proc(args : ..any) {
+    message := tcat(..args);
+
+    if !seenWarnings[message] {
+        fmt.eprint("[bindgen] Warning: ", message, "\n");
+        seenWarnings[message] = true;
+    }
+}
+
+print_error :: proc(data : ^ParserData, loc := #caller_location, args : ..any) {
+    message := tcat(..args);
+
+    min : u32 = 0;
+    for i := data.offset - 1; i > 0; i -= 1 {
+        if data.bytes[i] == '\n' {
+            min = i + 1;
+            break;
+        }
+    }
+
+    max := min + 200;
+    for i := min + 1; i < max; i += 1 {
+        if data.bytes[i] == '\n' {
+            max = i;
+            break;
+        }
+    }
+
+    line, _ := get_line_column(data);
+
+    fmt.eprint("[bindgen] Error: ", message, "\n");
+    fmt.eprint("[bindgen] ... from ", loc.procedure, "\n");
+    fmt.eprint("[bindgen] ... at line ", line, " within this context:\n");
+    fmt.eprint("> ", extract_string(data, min, max), "\n");
+
+    os.exit(1);
+}
diff --git a/core/bindgen/generator-clean.odin b/core/bindgen/generator-clean.odin
new file mode 100644
index 000000000..8dd837b10
--- /dev/null
+++ b/core/bindgen/generator-clean.odin
@@ -0,0 +1,284 @@
+package bindgen
+
+import "core:fmt"
+
+// Prevent keywords clashes and other tricky cases
+clean_identifier :: proc(name : string) -> string {
+    name := name;
+
+    if name == "" {
+        return name;
+    }
+
+    // Starting with _? Try removing that.
+    for true {
+        if name[0] == '_' {
+            name = name[1:];
+        }
+        else {
+            break;
+        }
+    }
+
+    // Number
+    if name[0] >= '0' && name[0] <= '9' {
+        return tcat("_", name);
+    } // Keywords clash
+    else if name == "map" || name == "proc" || name == "opaque" || name == "in" {
+        return tcat("_", name);
+    } // Jai keywords clash
+    else if name == "context" ||
+            name == "float32" || name == "float64" ||
+            name == "s8" || name == "s16" || name == "s32" || name == "s64" ||
+            name == "u8" || name == "u16" || name == "u32" || name == "u64" {
+        return tcat("_", name);
+    }
+
+    return name;
+}
+
+clean_variable_name :: proc(name : string, options : ^GeneratorOptions) -> string {
+    name := name;
+    name = change_case(name, options.variableCase);
+    return clean_identifier(name);
+}
+
+clean_pseudo_type_name :: proc(structName : string, options : ^GeneratorOptions) -> string {
+    structName := structName;
+    structName = remove_postfixes(structName, options.pseudoTypePostfixes, options.pseudoTypeTransparentPostfixes);
+    structName = remove_prefixes(structName, options.pseudoTypePrefixes, options.pseudoTypeTransparentPrefixes);
+    structName = change_case(structName, options.pseudoTypeCase);
+    return structName;
+}
+
+// Clean up the enum name so that it can be used to remove the prefix from enum values.
+clean_enum_name_for_prefix_removal :: proc(enumName : string, options : ^GeneratorOptions) -> (string, [dynamic]string) {
+    enumName := enumName;
+
+    if !options.enumValueNameRemove {
+        return enumName, nil;
+    }
+
+    // Remove postfix and use same case convention as the enum values
+    removedPostfixes : [dynamic]string;
+    enumName, removedPostfixes = remove_postfixes_with_removed(enumName, options.enumValueNameRemovePostfixes);
+    enumName = change_case(enumName, options.enumValueCase);
+    return enumName, removedPostfixes;
+}
+
+clean_enum_value_name :: proc(valueName : string, enumName : string, postfixes : []string, options : ^GeneratorOptions) -> string {
+    valueName := valueName;
+
+    valueName = remove_prefixes(valueName, options.enumValuePrefixes, options.enumValueTransparentPrefixes);
+    valueName = remove_postfixes(valueName, postfixes, options.enumValueTransparentPostfixes);
+
+    if options.enumValueNameRemove {
+        valueName = remove_prefixes(valueName, []string{enumName});
+    }
+
+    valueName = change_case(valueName, options.enumValueCase);
+
+    return clean_identifier(valueName);
+}
+
+clean_function_name :: proc(functionName : string, options : ^GeneratorOptions) -> string {
+    functionName := functionName;
+    functionName = remove_prefixes(functionName, options.functionPrefixes, options.functionTransparentPrefixes);
+    functionName = remove_postfixes(functionName, options.definePostfixes, options.defineTransparentPostfixes);
+    functionName = change_case(functionName, options.functionCase);
+    return functionName;
+}
+
+clean_define_name :: proc(defineName : string, options : ^GeneratorOptions) -> string {
+    defineName := defineName;
+    defineName = remove_prefixes(defineName, options.definePrefixes, options.defineTransparentPrefixes);
+    defineName = remove_postfixes(defineName, options.definePostfixes, options.defineTransparentPostfixes);
+    defineName = change_case(defineName, options.defineCase);
+    return defineName;
+}
+
+// Convert to Odin's types
+clean_type :: proc(data : ^GeneratorData, type : Type, baseTab : string = "", explicitSharpType := true) -> string {
+    output := "";
+
+    for dimension in type.dimensions {
+        output = tcat(output, "[", dimension, "]");
+    }
+    output = tcat(output, clean_base_type(data, type.base, baseTab, explicitSharpType));
+
+    return output;
+}
+
+clean_base_type :: proc(data : ^GeneratorData, baseType : BaseType, baseTab : string = "", explicitSharpType := true) -> string {
+    options := data.options;
+
+    if _type, ok := baseType.(BuiltinType); ok {
+        if _type == BuiltinType.Void do return options.mode == "jai" ? "void" : "";
+        else if _type == BuiltinType.Int do return options.mode == "jai" ? "s64" : "_c.int";
+        else if _type == BuiltinType.UInt do return options.mode == "jai" ? "u64" :"_c.uint";
+        else if _type == BuiltinType.LongInt do return options.mode == "jai" ? "s64" :"_c.long";
+        else if _type == BuiltinType.ULongInt do return options.mode == "jai" ? "u64" :"_c.ulong";
+        else if _type == BuiltinType.LongLongInt do return options.mode == "jai" ? "s64" :"_c.longlong";
+        else if _type == BuiltinType.ULongLongInt do return options.mode == "jai" ? "u64" :"_c.ulonglong";
+        else if _type == BuiltinType.ShortInt do return options.mode == "jai" ? "s16" :"_c.short";
+        else if _type == BuiltinType.UShortInt do return options.mode == "jai" ? "u16" :"_c.ushort";
+        else if _type == BuiltinType.Char do return options.mode == "jai" ? "u8" :"_c.char";
+        else if _type == BuiltinType.SChar do return options.mode == "jai" ? "s8" :"_c.schar";
+        else if _type == BuiltinType.UChar do return options.mode == "jai" ? "u8" :"_c.uchar";
+        else if _type == BuiltinType.Float do return options.mode == "jai" ? "float32" :"_c.float";
+        else if _type == BuiltinType.Double do return options.mode == "jai" ? "float64" :"_c.double";
+        else if _type == BuiltinType.LongDouble {
+            print_warning("Found long double which is currently not supported. Fallback to double in generated code.");
+            return options.mode == "jai" ? "double" :"_c.double";
+        }
+        else if _type == BuiltinType.Int8 do return options.mode == "jai" ? "s8" :"i8";
+        else if _type == BuiltinType.Int16 do return options.mode == "jai" ? "s16" :"i16";
+        else if _type == BuiltinType.Int32 do return options.mode == "jai" ? "s32" :"i32";
+        else if _type == BuiltinType.Int64 do return options.mode == "jai" ? "s64" :"i64";
+        else if _type == BuiltinType.UInt8 do return options.mode == "jai" ? "u8" :"u8";
+        else if _type == BuiltinType.UInt16 do return options.mode == "jai" ? "u16" :"u16";
+        else if _type == BuiltinType.UInt32 do return options.mode == "jai" ? "u32" :"u32";
+        else if _type == BuiltinType.UInt64 do return options.mode == "jai" ? "u64" :"u64";
+        else if _type == BuiltinType.Size do return options.mode == "jai" ? "u64" :"_c.size_t";
+        else if _type == BuiltinType.SSize do return options.mode == "jai" ? "u64" :"_c.ssize_t";
+        else if _type == BuiltinType.PtrDiff do return options.mode == "jai" ? "s64" :"_c.ptrdiff_t";
+        else if _type == BuiltinType.UIntPtr do return options.mode == "jai" ? "u64" :"_c.uintptr_t";
+        else if _type == BuiltinType.IntPtr do return options.mode == "jai" ? "s64" :"_c.intptr_t";
+    }
+    else if _type, ok := baseType.(PointerType); ok {
+        if options.mode == "jai" {
+            // Hide pointers to types that were not declared.
+            if !is_known_base_type(data, _type.type.base) {
+                print_warning("*", _type.type.base.(IdentifierType).name, " replaced by *void as the pointed type is unknown.");
+                return "*void";
+            }
+        } else {
+            if __type, ok := _type.type.base.(BuiltinType); ok {
+                if __type == BuiltinType.Void do return "rawptr";
+                else if __type == BuiltinType.Char do return "cstring";
+            }
+        }
+        name := clean_type(data, _type.type^, baseTab);
+        return tcat(options.mode == "jai" ? "*" :"^", name);
+    }
+    else if _type, ok := baseType.(IdentifierType); ok {
+        return clean_pseudo_type_name(_type.name, options);
+    }
+    else if _type, ok := baseType.(FunctionType); ok {
+        output : string;
+        if explicitSharpType {
+            output = "#type ";
+        }
+        output = tcat(output, options.mode == "jai" ? "(" :"proc(");
+        parameters := clean_function_parameters(data, _type.parameters, baseTab);
+        output = tcat(output, parameters, ")");
+
+        returnType := clean_type(data, _type.returnType^);
+        if len(returnType) > 0 && returnType != "void" {
+            output = tcat(output, " -> ", returnType);
+        }
+        return output;
+    }
+    else if _type, ok := baseType.(FunctionPointerType); ok {
+        output : string;
+        if explicitSharpType {
+            output = "#type ";
+        }
+        output = tcat(output, options.mode == "jai" ? "(" :"proc(");
+        parameters := clean_function_parameters(data, _type.parameters, baseTab);
+        output = tcat(output, parameters, ")");
+
+        returnType := clean_type(data, _type.returnType^);
+        if len(returnType) > 0 && returnType != "void" {
+            output = tcat(output, " -> ", returnType);
+        }
+
+        if options.mode == "jai" {
+            output = tcat(output, " #foreign");
+        }
+        return output;
+    }
+
+    return "<niy>";
+}
+
+clean_function_parameters :: proc(data : ^GeneratorData, parameters : [dynamic]FunctionParameter, baseTab : string) -> string {
+    output := "";
+    options := data.options;
+
+    // Special case: function(void) does not really have a parameter
+    if len(parameters) == 1 {
+        if _type, ok := parameters[0].type.base.(BuiltinType); ok {
+            if _type == BuiltinType.Void {
+                return "";
+            }
+        }
+    }
+
+    tab := "";
+    if options.mode == "jai" { // @note :OdinCodingStyle Odin forces a coding style, now. Ugh.
+        if (len(parameters) > 1) {
+            output = tcat(output, "\n");
+            tab = tcat(baseTab, "    ");
+        }
+    }
+
+    unamedParametersCount := 0;
+    for parameter, i in parameters {
+        type := clean_type(data, parameter.type);
+
+        name : string;
+        if len(parameter.name) != 0 {
+            name = clean_variable_name(parameter.name, options);
+        } else {
+            name = tcat("unamed", unamedParametersCount);
+            unamedParametersCount += 1;
+        }
+
+        output = tcat(output, tab, name, " : ", type);
+
+        if i != len(parameters) - 1 {
+            if options.mode == "jai" { // @note :OdinCodingStyle
+                output = tcat(output, ",\n");
+            } else {
+                output = tcat(output, ", ");
+            }
+        }
+    }
+
+    if (len(parameters) > 1) {
+        if options.mode == "jai" { // @note :OdinCodingStyle
+            output = tcat(output, "\n", baseTab);
+        }
+    }
+
+    return output;
+}
+
+is_known_base_type :: proc(data : ^GeneratorData, baseType : BaseType) -> bool {
+    if _type, ok := baseType.(IdentifierType); ok {
+        for it in data.nodes.typedefs {
+            if _type.name == it.name {
+                return true;
+            }
+        }
+        for it in data.nodes.structDefinitions {
+            if _type.name == it.name {
+                return true;
+            }
+        }
+        for it in data.nodes.enumDefinitions {
+            if _type.name == it.name {
+                return true;
+            }
+        }
+        for it in data.nodes.unionDefinitions {
+            if _type.name == it.name {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    return true;
+}
diff --git a/core/bindgen/generator-export.odin b/core/bindgen/generator-export.odin
new file mode 100644
index 000000000..a04113ed9
--- /dev/null
+++ b/core/bindgen/generator-export.odin
@@ -0,0 +1,166 @@
+package bindgen
+
+import "core:os"
+import "core:fmt"
+
+export_defines :: proc(data : ^GeneratorData) {
+    for node in data.nodes.defines {
+        defineName := clean_define_name(node.name, data.options);
+
+        // @fixme fprint of float numbers are pretty badly handled,
+        // just has a 10^-3 precision.
+        fcat(data.handle, defineName, " :: ", node.value, ";\n");
+    }
+    fcat(data.handle, "\n");
+}
+
+export_typedefs :: proc(data : ^GeneratorData) {
+    for node in data.nodes.typedefs {
+        name := clean_pseudo_type_name(node.name, data.options);
+        type := clean_type(data, node.type, "", true);
+        if name == type do continue;
+        fcat(data.handle, name, " :: ", type, ";\n");
+    }
+    fcat(data.handle, "\n");
+}
+
+export_enums :: proc(data : ^GeneratorData) {
+    for node in data.nodes.enumDefinitions {
+        enumName := clean_pseudo_type_name(node.name, data.options);
+
+        if data.options.mode == "jai" {
+            consideredFlags := false;
+            for postfix in data.options.enumConsideredFlagsPostfixes {
+                if ends_with(node.name, postfix) {
+                    consideredFlags = true;
+                    break;
+                }
+            }
+
+            if consideredFlags {
+                fcat(data.handle, enumName, " :: enum_flags u32 {");
+            } else {
+                fcat(data.handle, enumName, " :: enum s32 {");
+            }
+        } else {
+            fcat(data.handle, enumName, " :: enum i32 {");
+        }
+
+        postfixes : [dynamic]string;
+        enumName, postfixes = clean_enum_name_for_prefix_removal(enumName, data.options);
+
+        // Changing the case of postfixes to the enum value one,
+        // so that they can be removed.
+        enumValueCase := find_case(node.members[0].name);
+        for postfix, i in postfixes {
+            postfixes[i] = change_case(postfix, enumValueCase);
+        }
+
+        // And changing the case of enumName to the enum value one
+        enumName = change_case(enumName, enumValueCase);
+
+        // Merging enum value postfixes with postfixes that have been removed from the enum name.
+        for postfix in data.options.enumValuePostfixes {
+            append(&postfixes, postfix);
+        }
+
+        export_enum_members(data, node.members, enumName, postfixes[:]);
+        fcat(data.handle, data.options.mode == "jai" ? "}\n" : "};\n");
+        fcat(data.handle, "\n");
+    }
+}
+
+export_structs :: proc(data : ^GeneratorData) {
+    for node in data.nodes.structDefinitions {
+        structName := clean_pseudo_type_name(node.name, data.options);
+        fcat(data.handle, structName, " :: struct {");
+        export_struct_or_union_members(data, node.members);
+        fcat(data.handle, data.options.mode == "jai" ? "}\n" : "};\n");
+        fcat(data.handle, "\n");
+    }
+}
+
+export_unions :: proc(data : ^GeneratorData) {
+    for node in data.nodes.unionDefinitions {
+        unionName := clean_pseudo_type_name(node.name, data.options);
+        fcat(data.handle, unionName, data.options.mode == "jai" ? " :: union {" : " :: struct #raw_union {");
+        export_struct_or_union_members(data, node.members);
+        fcat(data.handle, data.options.mode == "jai" ? "}\n" : "};\n");
+        fcat(data.handle, "\n");
+    }
+}
+
+export_functions :: proc(data : ^GeneratorData) {
+    for node in data.nodes.functionDeclarations {
+        functionName := clean_function_name(node.name, data.options);
+        if data.options.mode == "jai" {
+            fcat(data.handle, functionName, " :: (");
+        } else {
+            fcat(data.handle, "    @(link_name=\"", node.name, "\")\n");
+            fcat(data.handle, "    ", functionName, " :: proc(");
+        }
+        parameters := clean_function_parameters(data, node.parameters, data.options.mode == "jai" ? "" : "    ");
+        fcat(data.handle, parameters, ")");
+        returnType := clean_type(data, node.returnType);
+        if len(returnType) > 0 {
+            fcat(data.handle, " -> ", returnType);
+        }
+        if data.options.mode == "jai" {
+            fcat(data.handle, " #foreign ", data.foreignLibrary, " \"", node.name ,"\";\n");
+        } else {
+            fcat(data.handle, " ---;\n");
+        }
+        fcat(data.handle, "\n");
+    }
+}
+
+export_enum_members :: proc(data : ^GeneratorData, members : [dynamic]EnumMember, enumName : string, postfixes : []string) {
+    if (len(members) > 0) {
+        fcat(data.handle, "\n");
+    }
+
+    cleanedMembers : [dynamic]EnumMember;
+    for member in members {
+        cleanedMember : EnumMember;
+        cleanedMember.hasValue = member.hasValue;
+        cleanedMember.value = member.value;
+        cleanedMember.name = clean_enum_value_name(member.name, enumName, postfixes, data.options);
+
+        if len(cleanedMember.name) == 0 {
+            // print_warning("Enum member ", member.name, " resolves to an empty name. Ignoring it.");
+            continue;
+        }
+
+        // Ensuring that we don't collide with an other enum member.
+        foundCopy := false;
+        for existingCleanedMember in cleanedMembers {
+            if cleanedMember.name == existingCleanedMember.name &&
+               cleanedMember.hasValue == existingCleanedMember.hasValue &&
+               cleanedMember.value == existingCleanedMember.value {
+                print_warning("Enum member ", member.name, " is duplicated once cleaned. Keeping only one copy.");
+                foundCopy = true;
+                break;
+            }
+        }
+        if foundCopy do continue;
+
+        fcat(data.handle, "    ", cleanedMember.name);
+        if member.hasValue {
+            fcat(data.handle, data.options.mode == "jai" ? " :: " : " = ", member.value);
+        }
+        fcat(data.handle, data.options.mode == "jai" ? ";\n" : ",\n");
+
+        append(&cleanedMembers, cleanedMember);
+    }
+}
+
+export_struct_or_union_members :: proc(data : ^GeneratorData, members : [dynamic]StructOrUnionMember) {
+    if (len(members) > 0) {
+        fcat(data.handle, "\n");
+    }
+    for member in members {
+        type := clean_type(data, member.type, "    ");
+        name := clean_variable_name(member.name, data.options);
+        fcat(data.handle, "    ", name, " : ", type, data.options.mode == "jai" ? ";\n" : ",\n");
+    }
+}
diff --git a/core/bindgen/generator-helpers.odin b/core/bindgen/generator-helpers.odin
new file mode 100644
index 000000000..a3b37f4f6
--- /dev/null
+++ b/core/bindgen/generator-helpers.odin
@@ -0,0 +1,392 @@
+package bindgen
+
+import "core:fmt"
+import "core:os"
+import "core:io"
+import "core:strings"
+import "core:unicode/utf8"
+
+Case :: enum {
+    Unknown,
+    Camel,
+    Constant,
+    Kebab,
+    Pascal,
+    Snake,
+}
+
+WordCase :: enum {
+    Unknown,
+    Up,
+    Low,
+    FirstUp,
+    // When first upping, numbers are followed always by a capital
+    FirstUpNumberReset,
+}
+
+// Change a character to a capital.
+to_uppercase :: proc(c : rune) -> rune {
+    c := c;
+    if c >= 'a' && c <= 'z' {
+        c = c - 'a' + 'A';
+    }
+    return c;
+}
+
+// Change a character to lowercase.
+to_lowercase :: proc(c : rune) -> rune {
+    c := c;
+    if c >= 'A' && c <= 'Z' {
+        c = c - 'A' + 'a';
+    }
+    return c;
+}
+
+// @note Stolen tprint and fprint from fmt package, because it was confusing due to args: ..any and sep default parameter.
+tcat :: proc(args: ..any) -> string {
+    return fmt.tprint(args=args, sep="");
+}
+
+fcat :: proc(fd: os.Handle, args: ..any) -> int {
+    return fmt.fprint(fd=fd, args=args, sep="");
+}
+
+// Change the case convention of a word.
+change_word_case :: proc(str : string, targetCase : WordCase) -> string {
+    newStr : string;
+    if targetCase == WordCase.Up {
+        for c in str {
+            newStr = tcat(newStr, to_uppercase(c));
+        }
+    }
+    else if targetCase == WordCase.Low {
+        for c in str {
+            newStr = tcat(newStr, to_lowercase(c));
+        }
+    }
+    else if targetCase == WordCase.FirstUp {
+        for c, i in str {
+            if i == 0 {
+                newStr = tcat(newStr, to_uppercase(c));
+            } else {
+                newStr = tcat(newStr, to_lowercase(c));
+            }
+        }
+    }
+    else if targetCase == WordCase.FirstUpNumberReset {
+        for c, i in str {
+            if i == 0 || (str[i - 1] >= '0' && str[i - 1] <= '9') {
+                newStr = tcat(newStr, to_uppercase(c));
+            } else {
+                newStr = tcat(newStr, to_lowercase(c));
+            }
+        }
+    }
+    return newStr;
+}
+
+// Change the case convention of a string by detecting original convention,
+// then splitting it into words.
+change_case :: proc(str : string, targetCase : Case) -> string {
+    if targetCase == Case.Unknown {
+        return str;
+    }
+
+    // Split
+    parts := autosplit_string(str);
+
+    // Join
+    newStr : string;
+    if targetCase == Case.Pascal {
+        for part, i in parts {
+            newStr = tcat(newStr, change_word_case(part, WordCase.FirstUpNumberReset));
+        }
+    }
+    else if targetCase == Case.Snake {
+        for part, i in parts {
+            newStr = tcat(newStr, change_word_case(part, WordCase.Low), (i != len(parts) - 1) ? "_" : "");
+        }
+    }
+    else if targetCase == Case.Kebab {
+        for part, i in parts {
+            newStr = tcat(newStr, change_word_case(part, WordCase.Low), (i != len(parts) - 1) ? "-" : "");
+        }
+    }
+    else if targetCase == Case.Camel {
+        for part, i in parts {
+            if i == 0 {
+                newStr = tcat(newStr, change_word_case(part, WordCase.Low));
+            } else {
+                newStr = tcat(newStr, change_word_case(part, WordCase.FirstUpNumberReset));
+            }
+        }
+    }
+    else if targetCase == Case.Constant {
+        for part, i in parts {
+            newStr = tcat(newStr, change_word_case(part, WordCase.Up), (i != len(parts) - 1) ? "_" : "");
+        }
+    }
+
+    return newStr;
+}
+
+// Identify the case of the provided string.
+// Full lowercase with no separator is identified as camelCase.
+find_case :: proc(str : string) -> Case {
+    refuted : bool;
+
+    // CONSTANT_CASE
+    refuted = false;
+    for c in str {
+        if (c != '_') && (c < 'A' || c > 'Z') && (c < '0' || c > '9') {
+            refuted = true;
+            break;
+        }
+    }
+    if !refuted do return Case.Constant;
+
+    for c in str {
+        // snake_case
+        if c == '_' {
+            return Case.Snake;
+        } // kebab-case
+        else if c == '-' {
+            return Case.Kebab;
+        }
+    }
+
+    // PascalCase
+    if str[0] >= 'A' && str[0] <= 'Z' {
+        return Case.Pascal;
+    }
+
+    // camelCase
+    return Case.Camel;
+}
+
+// Splits the string according to detected case.
+//  HeyBuddy -> {"Hey", "Buddy"}
+//  hey-buddy -> {"hey", "buddy"}
+//  _hey_buddy -> {"", "hey", "buddy"}
+// and such...
+autosplit_string :: proc(str : string) -> [dynamic]string {
+    lowCount := 0;
+    upCount := 0;
+    for c in str {
+        // If any '_', split according to that (CONSTANT_CASE or snake_case)
+        if c == '_' {
+            return split_from_separator(str, '_');
+        } // If any '-', split according to that (kebab-case)
+        else if c == '-' {
+            return split_from_separator(str, '-');
+        }
+        else if c >= 'a' && c <= 'z' {
+            lowCount += 1;
+        }
+        else if c >= 'A' && c <= 'Z' {
+            upCount += 1;
+        }
+    }
+
+    // If it seems to be only one word
+    if lowCount == 0 || upCount == 0 {
+        parts : [dynamic]string;
+        append(&parts, str);
+        return parts;
+    }
+
+    // Split at each uppercase letter (PascalCase or camelCase)
+    return split_from_capital(str);
+}
+
+split_from_separator :: proc(str : string, sep : rune) -> [dynamic]string {
+    parts : [dynamic]string;
+
+    lastI := 0;
+
+    // Empty strings for starting separators in string
+    for c in str {
+        if c == sep {
+            append(&parts, "");
+            lastI += 1;
+        } else {
+            break;
+        }
+    }
+
+    // Ignore non letter prefix
+    if lastI == 0 {
+        for c in str {
+            if (c < 'a' || c > 'z') && (c < 'A' || c > 'Z') {
+                lastI += 1;
+            }
+            else {
+                break;
+            }
+        }
+    }
+
+    for c, i in str {
+        if i > lastI + 1 && c == sep {
+            append(&parts, str[lastI:i]);
+            lastI = i + 1;
+        }
+    }
+
+    append(&parts, str[lastI:]);
+
+    return parts;
+}
+
+split_from_capital :: proc(str : string) -> [dynamic]string {
+    parts : [dynamic]string;
+
+    // Ignore non letter prefix
+    lastI := 0;
+    for c in str {
+        if (c < 'a' || c > 'z') && (c < 'A' || c > 'Z') {
+            lastI += 1;
+        }
+        else {
+            break;
+        }
+    }
+
+    // We want to handle:
+    //      myBrainIsCRAZY  -> my Brain Is Crazy
+    //      myCRAZYBrain    -> my CRAZY Brain
+    //      SOLO            -> SOLO
+
+    // Do split
+    for i := 1; i < len(str); i += 1 {
+        if str[i] >= 'A' && str[i] <= 'Z' {
+            // Do not split too much if it seems to be a capitalized word
+            if (lastI == i - 1) && (str[lastI] >= 'A' && str[lastI] <= 'Z') {
+                for ; i + 1 < len(str); i += 1 {
+                    if str[i + 1] < 'A' || str[i + 1] > 'Z' {
+                        break;
+                    }
+                }
+                if (i + 1 == len(str)) && (str[i] >= 'A' && str[i] <= 'Z') {
+                    i += 1;
+                }
+            }
+
+            append(&parts, str[lastI:i]);
+            lastI = i;
+        }
+    }
+
+    if lastI != len(str) {
+        append(&parts, str[lastI:]);
+    }
+
+    return parts;
+}
+
+// Check if str if prefixed with any of the provided strings,
+// even combinaisons of those, and remove them.
+remove_prefixes :: proc(str : string, prefixes : []string, transparentPrefixes : []string = nil) -> string {
+    str := str;
+    transparentStr := "";
+
+    found := true;
+    for found {
+        found = false;
+
+        // Remove effective prefixes
+        for prefix in prefixes {
+            if len(str) >= len(prefix) &&
+            str[:len(prefix)] == prefix {
+                str = str[len(prefix):];
+                if len(str) != 0 && (str[0] == '_' || str[0] == '-') {
+                    str = str[1:];
+                }
+                found = true;
+                break;
+            }
+        }
+
+        if found do continue;
+
+        // Remove transparent ones, only one by one,
+        // as we want effective ones to be fully removed.
+        for prefix in transparentPrefixes {
+            if len(str) >= len(prefix) &&
+            str[:len(prefix)] == prefix {
+                str = str[len(prefix):];
+                transparentStr = tcat(transparentStr, prefix);
+                if len(str) != 0 && (str[0] == '_' || str[0] == '-') {
+                    str = str[1:];
+                    transparentStr = tcat(transparentStr, '_');
+                }
+                found = true;
+                break;
+            }
+        }
+    }
+
+    return tcat(transparentStr, str);
+}
+
+// Check if str if postfixes with any of the provided strings,
+// even combinaisons of those, and remove them.
+remove_postfixes_with_removed :: proc(
+    str : string,
+    postfixes : []string,
+    transparentPostfixes : []string = nil) -> (string, [dynamic]string) {
+    str := str;
+    removedPostfixes : [dynamic]string;
+    transparentStr := "";
+
+    found := true;
+    for found {
+        found = false;
+
+        // Remove effective postfixes
+        for postfix in postfixes {
+            if ends_with(str, postfix) {
+                str = str[:len(str) - len(postfix)];
+                if len(str) != 0 && (str[len(str)-1] == '_' || str[len(str)-1] == '-') {
+                    str = str[:len(str)-1];
+                }
+                append(&removedPostfixes, postfix);
+                found = true;
+                break;
+            }
+        }
+
+        if found do continue;
+
+        // Remove transparent ones, only one by one,
+        // as we want effective ones to be fully removed.
+        for postfix in transparentPostfixes {
+            if ends_with(str, postfix) {
+                str = str[:len(str) - len(postfix)];
+                transparentStr = tcat(postfix, transparentStr);
+                if len(str) != 0 && (str[len(str)-1] == '_' || str[len(str)-1] == '-') {
+                    str = str[:len(str)-1];
+                    transparentStr = tcat('_', transparentStr);
+                }
+                found = true;
+                break;
+            }
+        }
+    }
+
+    return tcat(str, transparentStr), removedPostfixes;
+}
+
+remove_postfixes :: proc(
+    str : string,
+    postfixes : []string,
+    transparentPostfixes : []string = nil) -> string {
+    str := str;
+    removedPostfixes : [dynamic]string;
+    str, removedPostfixes = remove_postfixes_with_removed(str, postfixes, transparentPostfixes);
+    return str;
+}
+
+ends_with :: proc(str : string, postfix : string) -> bool {
+    return len(str) >= len(postfix) && str[len(str) - len(postfix):] == postfix;
+}
diff --git a/core/bindgen/generator.odin b/core/bindgen/generator.odin
new file mode 100644
index 000000000..3ef3d69c0
--- /dev/null
+++ b/core/bindgen/generator.odin
@@ -0,0 +1,205 @@
+/**
+ * Odin binding generator from C header data.
+ */
+
+package bindgen
+
+import "core:os"
+import "core:fmt"
+import "core:runtime"
+
+GeneratorOptions :: struct {
+    mode : string, // "odin" or "jai"
+
+    // Variable
+    variableCase : Case,
+
+    // Defines
+    definePrefixes : []string,
+    defineTransparentPrefixes : []string,
+    definePostfixes : []string,
+    defineTransparentPostfixes : []string,
+    defineCase : Case,
+
+    // Pseudo-types
+    pseudoTypePrefixes : []string,
+    pseudoTypeTransparentPrefixes : []string,
+    pseudoTypePostfixes : []string,
+    pseudoTypeTransparentPostfixes : []string,
+    pseudoTypeCase : Case,
+
+    // Enums
+    enumConsideredFlagsPostfixes : []string,
+
+    // Functions
+    functionPrefixes : []string,
+    functionTransparentPrefixes : []string,
+    functionPostfixes : []string,
+    functionTransparentPostfixes : []string,
+    functionCase : Case,
+
+    // Enum values
+    enumValuePrefixes : []string,
+    enumValueTransparentPrefixes : []string,
+    enumValuePostfixes : []string,
+    enumValueTransparentPostfixes : []string,
+    enumValueCase : Case,
+    enumValueNameRemove : bool,
+    enumValueNameRemovePostfixes : []string,
+
+    parserOptions : ParserOptions,
+}
+
+GeneratorData :: struct {
+    handle : os.Handle,
+    nodes : Nodes,
+
+    // References
+    foreignLibrary : string,
+    options : ^GeneratorOptions,
+}
+
+generate :: proc(
+    packageName : string,
+    foreignLibrary : string,
+    outputFile : string,
+    headerFiles : []string,
+    options : GeneratorOptions,
+) {
+    options := options;
+    data : GeneratorData;
+    data.options = &options;
+    data.foreignLibrary = foreignLibrary;
+
+    if options.mode == "" {
+        options.mode = "odin";
+    }
+
+    // Outputing odin file
+    errno : os.Errno;
+
+    // chmod 664 when creating file
+    mode: int = 0;
+    when os.OS == "linux" || os.OS == "darwin" {
+        mode = os.S_IRUSR | os.S_IWUSR | os.S_IRGRP | os.S_IWGRP | os.S_IROTH;
+    }
+
+    data.handle, errno = os.open(outputFile, os.O_WRONLY | os.O_CREATE | os.O_TRUNC, mode);
+    if errno != 0 {
+        fmt.eprint("[bindgen] Unable to write to output file ", outputFile, " (", errno ,")\n");
+        return;
+    }
+    defer os.close(data.handle);
+
+    if options.mode == "jai" {
+        fcat(data.handle, foreignLibrary, " :: #foreign_library \"", foreignLibrary, "\";\n");
+        fcat(data.handle, "\n");
+    } else {
+        fcat(data.handle, "package ", packageName, "\n");
+        fcat(data.handle, "\n");
+        fcat(data.handle, "foreign import \"", foreignLibrary, "\"\n");
+        fcat(data.handle, "\n");
+        fcat(data.handle, "import _c \"core:c\"\n");
+        fcat(data.handle, "\n");
+    }
+
+    // Parsing header files
+    anonymousStructCount = 0;
+    anonymousUnionCount = 0;
+    anonymousEnumCount = 0;
+
+    for headerFile in headerFiles {
+        bytes, ok := os.read_entire_file(headerFile);
+        if !ok {
+            fmt.eprint("[bindgen] Unable to read file ", headerFile, "\n");
+            return;
+        }
+
+        // We fuse the SOAs
+        headerNodes := parse(bytes, options.parserOptions);
+        merge_generic_nodes(&data.nodes.defines, &headerNodes.defines);
+        merge_generic_nodes(&data.nodes.enumDefinitions, &headerNodes.enumDefinitions);
+        merge_generic_nodes(&data.nodes.unionDefinitions, &headerNodes.unionDefinitions);
+        merge_forward_declared_nodes(&data.nodes.structDefinitions, &headerNodes.structDefinitions);
+        merge_generic_nodes(&data.nodes.functionDeclarations, &headerNodes.functionDeclarations);
+        merge_generic_nodes(&data.nodes.typedefs, &headerNodes.typedefs);
+    }
+
+    // Exporting
+    export_defines(&data);
+    export_typedefs(&data);
+    export_enums(&data);
+    export_structs(&data);
+    export_unions(&data);
+
+    // Foreign block for functions
+    if options.mode != "jai" {
+        foreignLibrarySimple := simplify_library_name(foreignLibrary);
+        fcat(data.handle, "@(default_calling_convention=\"c\")\n");
+        fcat(data.handle, "foreign ", foreignLibrarySimple, " {\n");
+        fcat(data.handle, "\n");
+    }
+
+    export_functions(&data);
+
+    if options.mode != "jai" {
+        fcat(data.handle, "}\n");
+    }
+}
+
+// system:foo.lib -> foo
+simplify_library_name :: proc(libraryName : string) -> string {
+    startOffset := 0;
+    endOffset := len(libraryName);
+
+    for c, i in libraryName {
+        if startOffset == 0 && c == ':' {
+            startOffset = i + 1;
+        }
+        else if c == '.' {
+            endOffset = i;
+            break;
+        }
+    }
+
+    return libraryName[startOffset:endOffset];
+}
+
+merge_generic_nodes :: proc(nodes : ^$T, headerNodes : ^T) {
+    for headerNode in headerNodes {
+        // Check that there are no duplicated nodes (due to forward declaration or such)
+        duplicatedIndex := -1;
+        for i := 0; i < len(nodes); i += 1 {
+            node := nodes[i];
+            if node.name == headerNode.name {
+                duplicatedIndex = i;
+                break;
+            }
+        }
+
+        if duplicatedIndex < 0 {
+            append(nodes, headerNode);
+        }
+    }
+}
+
+merge_forward_declared_nodes :: proc(nodes : ^$T, headerNodes : ^T) {
+    for headerNode in headerNodes {
+        // Check that there are no duplicated nodes (due to forward declaration or such)
+        duplicatedIndex := -1;
+        for i := 0; i < len(nodes); i += 1 {
+            node := nodes[i];
+            if node.name == headerNode.name {
+                duplicatedIndex = i;
+                break;
+            }
+        }
+
+        if duplicatedIndex < 0 {
+            append(nodes, headerNode);
+        }
+        else if !headerNode.forwardDeclared && len(headerNode.members) > 0 {
+            nodes[duplicatedIndex] = headerNode;
+        }
+    }
+}
diff --git a/vendor/stb/lib/darwin/libstb_image.a b/vendor/stb/lib/darwin/libstb_image.a
new file mode 100644
index 0000000000000000000000000000000000000000..06ce4432192e21268b40c487d33f54d0d4ec0007
GIT binary patch
literal 55744
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

literal 0
HcmV?d00001

diff --git a/vendor/stb/lib/darwin/stb_image.a b/vendor/stb/lib/darwin/stb_image.a
new file mode 100644
index 0000000000000000000000000000000000000000..1379d6f9e70c8dd9a853de55e1f5346d8d17f244
GIT binary patch
literal 97544
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%0DXs
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
M)se7pG-O}^0H7`N-T(jq

literal 0
HcmV?d00001

diff --git a/vendor/stb/lib/darwin/stb_image_resize.a b/vendor/stb/lib/darwin/stb_image_resize.a
new file mode 100644
index 0000000000000000000000000000000000000000..f39c507a6c92d777f16c781d44a9dd3b623c42f9
GIT binary patch
literal 36824
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
MXu!b0#l^)10C;Dn<NyEw

literal 0
HcmV?d00001

diff --git a/vendor/stb/lib/darwin/stb_image_write.a b/vendor/stb/lib/darwin/stb_image_write.a
new file mode 100644
index 0000000000000000000000000000000000000000..bce02b33dd9361bdd564c98a9e55e8b6978231c7
GIT binary patch
literal 32896
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

literal 0
HcmV?d00001

diff --git a/vendor/stb/lib/darwin/stb_rect_pack.a b/vendor/stb/lib/darwin/stb_rect_pack.a
new file mode 100644
index 0000000000000000000000000000000000000000..3b55ab8025d7dca76643a92399f45397e35f46e7
GIT binary patch
literal 5064
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
JtOgr00063`#B2Zn

literal 0
HcmV?d00001

diff --git a/vendor/stb/lib/darwin/stb_truetype.a b/vendor/stb/lib/darwin/stb_truetype.a
new file mode 100644
index 0000000000000000000000000000000000000000..c4a895b54b69c674e69c31dc2464951a929cc3a4
GIT binary patch
literal 67008
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

literal 0
HcmV?d00001

diff --git a/wasm-ld b/wasm-ld
new file mode 120000
index 000000000..01ef2a7e7
--- /dev/null
+++ b/wasm-ld
@@ -0,0 +1 @@
+/Volumes/Phill_Backup/pers/programming/sdk/emsdk/upstream/bin/lld
\ No newline at end of file