chore: add docs and example

NOTE: doesn't handles union and arrays, considere attributes part of the type

.gitignore

@@ -1 +1,2 @@
-build
+**/cmeta
+**/main

DOCS.md

@@ -0,0 +1,40 @@
+# Docs
+
+This file is meant to explain how it's working. I'll try to keep it up to date.
+
+## General idea
+
+Meta programming is really useful, in a lots of ways, that's why I'm trying to implement this in C, in the most pleasant way.  
+Header-only libraries are also a must imo, so let's try to implement meta programming within a single header! The same header for both compilation and runtime btw.
+
+## Compilation time
+
+`cmeta.h` contains the code to parse structs, lexing is handled by `stb_c_lexer` (for now).  
+The `bool process_file(const char *file_path)` function calls `gcc -E <file_path>` (so we handle macros etc), then parses the result. It then generates all `Struct_Info`s in a special place in the header, delimited by two `// AUTO GENERATED CODE  //`.  
+If anything has failed, nothing will be generated between the two comments, so cmeta remains intact.  
+
+This struct:
+```c
+typedef struct {
+    int int_field;
+} Foo_Struct;
+```
+
+Will be converted to this:
+```c
+// cmeta.h
+
+// AUTO GENERATED CODE  //
+static Struct_Info foo_struct_info = {
+    .name = "Foo_Struct",
+    .fields_count = 1,
+    .fields = (Field_Info[1]) {
+        { .type = "int", .name = "int_field" },
+    },
+};
+// AUTO GENERATED CODE  //
+```
+
+## Runtime
+
+`cmeta.h` now contains both type infos and useful functions to interact with them.

Makefile

@@ -1,6 +0,0 @@
-build/cmeta: src/main.c
-	mkdir -p build
-	gcc -Wall -Wextra -pedantic -o build/cmeta src/main.c
-
-run: build/cmeta
-	build/cmeta

README.md

@@ -1,3 +1,74 @@
 # cmeta
 
-Meta Programming for C
+> [!WARNING]
+> Work in progress. This is not finished at all, I'm just experimenting.
+
+Meta Programming Header Only Library for C
+
+## Current limitations
+
+- Only parses `typedef struct { ... } type_name;`
+- Will generate colliding definitions in case of types with the same name
+- Requires `stb_c_lexer`
+
+## Quick start
+
+Current implementation depends on `stb_c_lexer`, in future I'll use my own lexer. Because of the current setup, cmeta is not easy to use, remember, it's not finished!
+
+1. Create `main.c`
+
+```c
+typedef struct { 
+    int int_field;
+    const char *char_ptr_field;
+} My_Struct;
+
+int main(void) {
+    return 0;
+}
+```
+
+2. Create `cmeta.c`
+
+You only have to call `process_file` with a file to generate type infos etc in `cmeta.h`.
+
+```c
+#define CMETA_COMPTIME
+#include "cmeta.h"
+
+int main(void) {
+    if (!process_file("./main.c")) return 1;
+
+    return 0;
+}
+```
+
+3. Build and cmeta
+
+As mentionned before, `stb_c_lexer` is currently required, it will be removed in the future.
+
+```console
+$ gcc cmeta.c -I./third_party/ -o cmeta
+$ ./cmeta
+```
+
+4. Enjoy!
+
+You can now inspect your types!
+
+```c
+#include "cmeta.h"
+
+typedef struct { 
+    int int_field;
+    const char* char_field;
+} My_Struct;
+
+int main(void) {
+    printf("My_Struct.name = %s\n", my_struct_info.name);
+    printf("My_Struct.fields_count = %zu\n", my_struct_info.fields_count);
+    return 0;
+}
+```
+
+It runs `gcc -E`, so it process everything your code uses, including structs from cmeta itself.

cmeta.h

@@ -0,0 +1,413 @@
+#ifndef CMETA_H
+#define CMETA_H
+
+#include <stddef.h>
+
+typedef struct {
+    const char* type;
+    const char* name;
+} Field_Info;
+
+typedef struct {
+    const char* name;
+    size_t fields_count;
+    Field_Info *fields;
+} Struct_Info;
+
+// AUTO GENERATED CODE  //
+// AUTO GENERATED CODE  //
+
+#ifdef CMETA_COMPTIME
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+#define STB_C_LEXER_IMPLEMENTATION
+#include "stb_c_lexer.h"
+
+stb_lexer lexer = {0};
+
+typedef struct {
+    char* type;
+    char* name;
+} Parsed_Field_Info;
+
+typedef struct {
+    Parsed_Field_Info* items;
+    size_t count;
+    size_t capacity;
+} Parsed_Field_Infos;
+
+typedef struct {
+    char* name;
+    size_t fields_count;
+    Parsed_Field_Info *fields;
+} Parsed_Struct_Info;
+
+typedef struct {
+    Parsed_Struct_Info* items;
+    size_t count;
+    size_t capacity;
+} Parsed_Struct_Infos;
+
+typedef struct {
+    char* data;
+    size_t capacity;
+    size_t length;
+} String_Builder;
+
+void sb_append(String_Builder* sb, const char* data) {
+    size_t data_len = strlen(data);
+    size_t total_len = sb->length + data_len;
+
+    if (total_len + 1 > sb->capacity) {
+        size_t new_capacity = sb->capacity == 0 ? 64 : sb->capacity * 2;
+        while (new_capacity < total_len + 1) {
+            new_capacity *= 2;
+        }
+        sb->data = (char*) realloc(sb->data, new_capacity);
+        sb->capacity = new_capacity;
+    }
+
+    memcpy(sb->data + sb->length, data, data_len);
+    sb->length = total_len;
+    sb->data[sb->length] = '\0';
+}
+
+void sb_append_ch(String_Builder* sb, char ch) {
+    char buf[2] = {ch, '\0'};
+    sb_append(sb, buf);
+}
+
+#define da_append(da, item)                                                          \
+    do {                                                                             \
+        if ((da)->count + 1 > (da)->capacity) {                                      \
+            size_t new_capacity = (da)->capacity == 0 ? 64 : (da)->capacity * 2;     \
+            while ((da)->count + 1 > new_capacity) {                                 \
+                new_capacity *= 2;                                                   \
+            }                                                                        \
+            (da)->items = realloc((da)->items, new_capacity * sizeof(*(da)->items)); \
+        }                                                                            \
+        (da)->items[(da)->count++] = (item);                                         \
+    } while (0)                                                                      \
+
+bool lexer_expect_keyword(const char* expected) {
+    stb_c_lexer_get_token(&lexer);
+
+    if (lexer.token != CLEX_id) {
+        // TODO: map lexer.token to readable name
+        fprintf(stderr, "ERROR: expected `%s` but got `%ld`\n", expected, lexer.token);
+        return false;
+    }
+
+    if (strcmp(lexer.string, expected) != 0) {
+        fprintf(stderr, "ERROR: expected `%s` but got `%s`\n", expected, lexer.string);
+        return false;
+    }
+
+    return true;
+}
+
+bool lexer_expect(long expected, const char* expected_str) {
+    stb_c_lexer_get_token(&lexer);
+
+    if (lexer.token != expected) {
+        // TODO: map lexer.token to readable name
+        if(expected_str != NULL) {
+            fprintf(stderr, "ERROR: expected %s but got `%ld`\n", expected_str, lexer.token);
+        } else {
+            fprintf(stderr, "ERROR: expected `%ld` but got `%ld`\n", expected, lexer.token);
+        }
+        return false;
+    }
+
+    return true;
+}
+
+long lexer_peek() {
+    char* mark = lexer.parse_point;
+    if (!stb_c_lexer_get_token(&lexer)) {
+        lexer.parse_point = mark;
+        return CLEX_eof;
+    }
+
+    long token = lexer.token;
+    lexer.parse_point = mark;
+
+    return token;
+}
+
+// parses typedef struct { FIELDS } TYPE_NAME
+bool parse_struct(Parsed_Struct_Info* info) {
+    bool result = false;
+    char* name = NULL;
+
+    Parsed_Field_Infos fields = {0};
+    String_Builder field = {0};
+
+    if (!lexer_expect_keyword("typedef")) goto fail;
+    if (!lexer_expect_keyword("struct")) goto fail;
+    if (!lexer_expect('{', NULL)) goto fail;
+
+    while (true) {
+        char* mark = lexer.parse_point;
+        if (!stb_c_lexer_get_token(&lexer)) {
+            fprintf(stderr, "ERROR: expected struct fields but got EOF\n");
+            goto fail;
+        }
+
+        if (lexer.token == '}') break;
+        lexer.parse_point = mark;
+
+        field.length = 0;
+        while (stb_c_lexer_get_token(&lexer) && lexer.token != ';') {
+            if (lexer.token <= 255) {
+                // TODO: parse arrays
+                if(lexer.token == '[') goto fail;
+
+                sb_append_ch(&field, (char)lexer.token);
+                sb_append_ch(&field, ' ');
+            } else {
+                // TODO: parse unions
+                if(strcmp(lexer.string, "union") == 0) goto fail;
+
+                // TODO: parse attributes
+                sb_append(&field, lexer.string);
+                sb_append_ch(&field, ' ');
+            }
+        }
+        field.data[field.length -  1] = '\0';
+
+        char* last_space = strrchr(field.data, ' ');
+        char* field_name = strdup(last_space + 1);
+
+        field.data[last_space - field.data] = '\0';
+
+        char* field_type = strdup(field.data);
+
+        da_append(&fields, ((Parsed_Field_Info) {
+            .type = field_type,
+            .name = field_name,
+        }));
+    }
+
+    if (!lexer_expect(CLEX_id, "type name")) goto fail;
+    name = strdup(lexer.string);
+
+    info->name = name;
+    info->fields_count = fields.count;
+    info->fields = (Parsed_Field_Info*)calloc(info->fields_count, sizeof(Parsed_Field_Info));
+    for(size_t i = 0; i < info->fields_count; i += 1) {
+        info->fields[i].type = fields.items[i].type;
+        info->fields[i].name = fields.items[i].name;
+    }
+
+    result = true;
+fail:
+    free(field.data);
+
+    if(!result) {
+        free(name);
+        for(size_t i = 0; i < fields.count; i += 1) {
+            free(fields.items[i].name);
+            free(fields.items[i].type);
+        }
+        free(fields.items);
+    }
+
+    return result;
+}
+
+void print_struct(Parsed_Struct_Info info) {
+    printf("struct_name = %s\n", info.name);
+    printf("fields[%zu] = [\n", info.fields_count);
+    for (size_t i = 0; i < info.fields_count; i += 1) {
+        printf("    { type = %s, name = %s },\n", info.fields[i].type, info.fields[i].name);
+    }
+    printf("]\n");
+}
+
+#define gen(...) do {                                       \
+        fprintf(stream, __VA_ARGS__);                       \
+        fprintf(stream, " // %s:%d\n", __FILE__, __LINE__); \
+    } while(0)
+
+char* to_lowercase(char* str) {
+    size_t len = strlen(str);
+    for(size_t i = 0; i < len; i += 1) {
+        str[i] = tolower(str[i]);
+    }
+    return str;
+}
+
+void generate_struct_info(FILE* stream, Parsed_Struct_Info info) {
+    char* lowercase_name = to_lowercase(strdup(info.name));
+
+    gen("static Struct_Info %s_info = {", lowercase_name);
+    gen("    .name = \"%s\",", info.name);
+    gen("    .fields_count = %zu,", info.fields_count);
+    gen("    .fields = (Field_Info[%zu]) {", info.fields_count);
+    for (size_t i = 0; i < info.fields_count; i += 1) {
+        gen("        { .type = \"%s\", .name = \"%s\" },", info.fields[i].type, info.fields[i].name);
+    }
+    gen("    },");
+    gen("};");
+
+    free(lowercase_name);
+}
+
+bool read_entire_file(const char* file_path, char** content) {
+    bool result = false;
+    FILE* file = fopen(file_path, "rb");
+    if(file == NULL) goto fail;
+
+    if(fseek(file, 0, SEEK_END) < 0) goto fail;
+
+    long length = ftell(file);
+    if(length < 0) goto fail;
+
+    if(fseek(file, 0, SEEK_SET) < 0) goto fail;
+
+    *content = (char*) malloc((length + 1) * sizeof(char));
+    fread(*content, 1, length, file);
+
+    // TODO: will not set errno
+    if (ferror(file)) goto fail;
+
+    (*content)[length] = '\0';
+
+    result = true;
+fail:
+    if (!result) {
+        free(*content);
+        fprintf(stderr, "ERROR: Could not read `%s`: %s\n", file_path, strerror(errno));
+    }
+    if (file) fclose(file);
+    return result;
+}
+
+bool generate_output_file(const char* output_path, Parsed_Struct_Infos struct_infos) {
+    const char* GENERATION_MARK = "// AUTO GENERATED CODE  //\n";
+    const size_t GENERATION_MARK_LEN = strlen(GENERATION_MARK);
+
+    bool result = false;
+
+    char* header_content;
+    if (!read_entire_file(__FILE__, &header_content)) goto fail;
+
+    // 1. find BEGIN an END
+    char* generate_begin = strstr(header_content, GENERATION_MARK);
+    if (generate_begin == NULL) {
+        fprintf(stderr, "ERROR: could not found generation mark in cmeta.h\n");
+        goto fail;
+    }
+
+    char* generate_end = strstr(generate_begin + GENERATION_MARK_LEN, GENERATION_MARK);
+    if (generate_end == NULL) {
+        fprintf(stderr, "ERROR: could not found generation mark in cmeta.h\n");
+        goto fail;
+    }
+
+    FILE* output_file = fopen(output_path, "wb");
+    if (!output_file) {
+        fprintf(stderr, "ERROR: could not write to %s: %s\n", output_path, strerror(errno));
+        goto fail;
+    }
+
+    FILE* stream = output_file;
+
+    // write up to the generation mark, including it
+    fwrite(header_content, generate_begin + GENERATION_MARK_LEN - header_content, 1, stream);
+
+    for (size_t i = 0; i < struct_infos.count; i += 1) {
+        generate_struct_info(stream, struct_infos.items[i]);
+    }
+
+    fwrite(generate_end, strlen(generate_end), 1, stream);
+
+    result = true;
+fail:
+    free(header_content);
+    if (output_file) fclose(output_file);
+
+    return result;
+}
+
+bool preprocess_file(const char* file_path, String_Builder* result) {
+    char command[256] = {0};
+    sprintf(command, "gcc -E %s", file_path);
+
+    FILE* fp = popen(command, "r");
+    if (fp == NULL) {
+        fprintf(stderr, "ERROR: Failed to run command: %s\n", strerror(errno));
+        return false;
+    }
+
+    char line[512];
+    size_t line_num = 0;
+    char file_name[512];
+
+    size_t cursor = 0;
+    result->length = 0;
+
+    bool collecting_content = false;
+
+    while (fgets(line, sizeof(line), fp) != NULL) {
+        if (sscanf(line, "# %zu \"%s\"", &line_num, file_name) == 2) {
+            // remove trailing "
+            file_name[strlen(file_name) - 1] = '\0';
+
+            if (strcmp(file_name, file_path) == 0) {
+                collecting_content = true;
+                continue;
+            }
+
+            // TODO: read original file at line_num, to check for comments (e.g annotations)
+        } else if(collecting_content) {
+            sb_append(result, line);
+            cursor += strlen(line);
+        }
+    }
+
+    pclose(fp);
+
+    return true;
+}
+
+bool process_file(const char* input_file) {
+    // read input file
+    String_Builder input_content = {0};
+    if (!preprocess_file(input_file, &input_content)) return false;
+
+    // init lexer
+    char string_store[1024] = {0};
+    stb_c_lexer_init(&lexer, input_content.data, input_content.data + input_content.length, string_store, sizeof(string_store) / sizeof(char));
+
+    // find and parse all structs
+    Parsed_Struct_Infos struct_infos = {0};
+
+    while (true) {
+        char* mark = lexer.parse_point;
+
+        if (!stb_c_lexer_get_token(&lexer)) break;
+        if (lexer.token == CLEX_id && strcmp(lexer.string, "typedef") == 0) {
+            lexer.parse_point = mark;
+
+            Parsed_Struct_Info struct_info = {0};
+            if (parse_struct(&struct_info)) {
+                da_append(&struct_infos, struct_info);
+            }
+        }
+    }
+
+    if (!generate_output_file(__FILE__, struct_infos)) return false;
+
+    return true;
+}
+
+#endif // CMETA_COMPTIME
+
+#endif // CMETA_H

example/01_simple_struct/Makefile

@@ -0,0 +1,8 @@
+all: cmeta main
+
+cmeta: main.c cmeta.h cmeta.c
+	gcc cmeta.c -I../../third_party/ -o cmeta
+
+main: cmeta.h main.c
+	./cmeta
+	gcc main.c -o main

example/01_simple_struct/cmeta.c

@@ -0,0 +1,8 @@
+#define CMETA_COMPTIME
+#include "cmeta.h"
+
+int main(void) {
+    if (!process_file("./main.c")) return 1;
+
+    return 0;
+}

example/01_simple_struct/cmeta.h

@@ -0,0 +1,413 @@
+#ifndef CMETA_H
+#define CMETA_H
+
+#include <stddef.h>
+
+typedef struct {
+    const char* type;
+    const char* name;
+} Field_Info;
+
+typedef struct {
+    const char* name;
+    size_t fields_count;
+    Field_Info *fields;
+} Struct_Info;
+
+// AUTO GENERATED CODE  //
+// AUTO GENERATED CODE  //
+
+#ifdef CMETA_COMPTIME
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+#define STB_C_LEXER_IMPLEMENTATION
+#include "stb_c_lexer.h"
+
+stb_lexer lexer = {0};
+
+typedef struct {
+    char* type;
+    char* name;
+} Parsed_Field_Info;
+
+typedef struct {
+    Parsed_Field_Info* items;
+    size_t count;
+    size_t capacity;
+} Parsed_Field_Infos;
+
+typedef struct {
+    char* name;
+    size_t fields_count;
+    Parsed_Field_Info *fields;
+} Parsed_Struct_Info;
+
+typedef struct {
+    Parsed_Struct_Info* items;
+    size_t count;
+    size_t capacity;
+} Parsed_Struct_Infos;
+
+typedef struct {
+    char* data;
+    size_t capacity;
+    size_t length;
+} String_Builder;
+
+void sb_append(String_Builder* sb, const char* data) {
+    size_t data_len = strlen(data);
+    size_t total_len = sb->length + data_len;
+
+    if (total_len + 1 > sb->capacity) {
+        size_t new_capacity = sb->capacity == 0 ? 64 : sb->capacity * 2;
+        while (new_capacity < total_len + 1) {
+            new_capacity *= 2;
+        }
+        sb->data = (char*) realloc(sb->data, new_capacity);
+        sb->capacity = new_capacity;
+    }
+
+    memcpy(sb->data + sb->length, data, data_len);
+    sb->length = total_len;
+    sb->data[sb->length] = '\0';
+}
+
+void sb_append_ch(String_Builder* sb, char ch) {
+    char buf[2] = {ch, '\0'};
+    sb_append(sb, buf);
+}
+
+#define da_append(da, item)                                                          \
+    do {                                                                             \
+        if ((da)->count + 1 > (da)->capacity) {                                      \
+            size_t new_capacity = (da)->capacity == 0 ? 64 : (da)->capacity * 2;     \
+            while ((da)->count + 1 > new_capacity) {                                 \
+                new_capacity *= 2;                                                   \
+            }                                                                        \
+            (da)->items = realloc((da)->items, new_capacity * sizeof(*(da)->items)); \
+        }                                                                            \
+        (da)->items[(da)->count++] = (item);                                         \
+    } while (0)                                                                      \
+
+bool lexer_expect_keyword(const char* expected) {
+    stb_c_lexer_get_token(&lexer);
+
+    if (lexer.token != CLEX_id) {
+        // TODO: map lexer.token to readable name
+        fprintf(stderr, "ERROR: expected `%s` but got `%ld`\n", expected, lexer.token);
+        return false;
+    }
+
+    if (strcmp(lexer.string, expected) != 0) {
+        fprintf(stderr, "ERROR: expected `%s` but got `%s`\n", expected, lexer.string);
+        return false;
+    }
+
+    return true;
+}
+
+bool lexer_expect(long expected, const char* expected_str) {
+    stb_c_lexer_get_token(&lexer);
+
+    if (lexer.token != expected) {
+        // TODO: map lexer.token to readable name
+        if(expected_str != NULL) {
+            fprintf(stderr, "ERROR: expected %s but got `%ld`\n", expected_str, lexer.token);
+        } else {
+            fprintf(stderr, "ERROR: expected `%ld` but got `%ld`\n", expected, lexer.token);
+        }
+        return false;
+    }
+
+    return true;
+}
+
+long lexer_peek() {
+    char* mark = lexer.parse_point;
+    if (!stb_c_lexer_get_token(&lexer)) {
+        lexer.parse_point = mark;
+        return CLEX_eof;
+    }
+
+    long token = lexer.token;
+    lexer.parse_point = mark;
+
+    return token;
+}
+
+// parses typedef struct { FIELDS } TYPE_NAME
+bool parse_struct(Parsed_Struct_Info* info) {
+    bool result = false;
+    char* name = NULL;
+
+    Parsed_Field_Infos fields = {0};
+    String_Builder field = {0};
+
+    if (!lexer_expect_keyword("typedef")) goto fail;
+    if (!lexer_expect_keyword("struct")) goto fail;
+    if (!lexer_expect('{', NULL)) goto fail;
+
+    while (true) {
+        char* mark = lexer.parse_point;
+        if (!stb_c_lexer_get_token(&lexer)) {
+            fprintf(stderr, "ERROR: expected struct fields but got EOF\n");
+            goto fail;
+        }
+
+        if (lexer.token == '}') break;
+        lexer.parse_point = mark;
+
+        field.length = 0;
+        while (stb_c_lexer_get_token(&lexer) && lexer.token != ';') {
+            if (lexer.token <= 255) {
+                // TODO: parse arrays
+                if(lexer.token == '[') goto fail;
+
+                sb_append_ch(&field, (char)lexer.token);
+                sb_append_ch(&field, ' ');
+            } else {
+                // TODO: parse unions
+                if(strcmp(lexer.string, "union") == 0) goto fail;
+
+                // TODO: parse attributes
+                sb_append(&field, lexer.string);
+                sb_append_ch(&field, ' ');
+            }
+        }
+        field.data[field.length -  1] = '\0';
+
+        char* last_space = strrchr(field.data, ' ');
+        char* field_name = strdup(last_space + 1);
+
+        field.data[last_space - field.data] = '\0';
+
+        char* field_type = strdup(field.data);
+
+        da_append(&fields, ((Parsed_Field_Info) {
+            .type = field_type,
+            .name = field_name,
+        }));
+    }
+
+    if (!lexer_expect(CLEX_id, "type name")) goto fail;
+    name = strdup(lexer.string);
+
+    info->name = name;
+    info->fields_count = fields.count;
+    info->fields = (Parsed_Field_Info*)calloc(info->fields_count, sizeof(Parsed_Field_Info));
+    for(size_t i = 0; i < info->fields_count; i += 1) {
+        info->fields[i].type = fields.items[i].type;
+        info->fields[i].name = fields.items[i].name;
+    }
+
+    result = true;
+fail:
+    free(field.data);
+
+    if(!result) {
+        free(name);
+        for(size_t i = 0; i < fields.count; i += 1) {
+            free(fields.items[i].name);
+            free(fields.items[i].type);
+        }
+        free(fields.items);
+    }
+
+    return result;
+}
+
+void print_struct(Parsed_Struct_Info info) {
+    printf("struct_name = %s\n", info.name);
+    printf("fields[%zu] = [\n", info.fields_count);
+    for (size_t i = 0; i < info.fields_count; i += 1) {
+        printf("    { type = %s, name = %s },\n", info.fields[i].type, info.fields[i].name);
+    }
+    printf("]\n");
+}
+
+#define gen(...) do {                                       \
+        fprintf(stream, __VA_ARGS__);                       \
+        fprintf(stream, " // %s:%d\n", __FILE__, __LINE__); \
+    } while(0)
+
+char* to_lowercase(char* str) {
+    size_t len = strlen(str);
+    for(size_t i = 0; i < len; i += 1) {
+        str[i] = tolower(str[i]);
+    }
+    return str;
+}
+
+void generate_struct_info(FILE* stream, Parsed_Struct_Info info) {
+    char* lowercase_name = to_lowercase(strdup(info.name));
+
+    gen("static Struct_Info %s_info = {", lowercase_name);
+    gen("    .name = \"%s\",", info.name);
+    gen("    .fields_count = %zu,", info.fields_count);
+    gen("    .fields = (Field_Info[%zu]) {", info.fields_count);
+    for (size_t i = 0; i < info.fields_count; i += 1) {
+        gen("        { .type = \"%s\", .name = \"%s\" },", info.fields[i].type, info.fields[i].name);
+    }
+    gen("    },");
+    gen("};");
+
+    free(lowercase_name);
+}
+
+bool read_entire_file(const char* file_path, char** content) {
+    bool result = false;
+    FILE* file = fopen(file_path, "rb");
+    if(file == NULL) goto fail;
+
+    if(fseek(file, 0, SEEK_END) < 0) goto fail;
+
+    long length = ftell(file);
+    if(length < 0) goto fail;
+
+    if(fseek(file, 0, SEEK_SET) < 0) goto fail;
+
+    *content = (char*) malloc((length + 1) * sizeof(char));
+    fread(*content, 1, length, file);
+
+    // TODO: will not set errno
+    if (ferror(file)) goto fail;
+
+    (*content)[length] = '\0';
+
+    result = true;
+fail:
+    if (!result) {
+        free(*content);
+        fprintf(stderr, "ERROR: Could not read `%s`: %s\n", file_path, strerror(errno));
+    }
+    if (file) fclose(file);
+    return result;
+}
+
+bool generate_output_file(const char* output_path, Parsed_Struct_Infos struct_infos) {
+    const char* GENERATION_MARK = "// AUTO GENERATED CODE  //\n";
+    const size_t GENERATION_MARK_LEN = strlen(GENERATION_MARK);
+
+    bool result = false;
+
+    char* header_content;
+    if (!read_entire_file(__FILE__, &header_content)) goto fail;
+
+    // 1. find BEGIN an END
+    char* generate_begin = strstr(header_content, GENERATION_MARK);
+    if (generate_begin == NULL) {
+        fprintf(stderr, "ERROR: could not found generation mark in cmeta.h\n");
+        goto fail;
+    }
+
+    char* generate_end = strstr(generate_begin + GENERATION_MARK_LEN, GENERATION_MARK);
+    if (generate_end == NULL) {
+        fprintf(stderr, "ERROR: could not found generation mark in cmeta.h\n");
+        goto fail;
+    }
+
+    FILE* output_file = fopen(output_path, "wb");
+    if (!output_file) {
+        fprintf(stderr, "ERROR: could not write to %s: %s\n", output_path, strerror(errno));
+        goto fail;
+    }
+
+    FILE* stream = output_file;
+
+    // write up to the generation mark, including it
+    fwrite(header_content, generate_begin + GENERATION_MARK_LEN - header_content, 1, stream);
+
+    for (size_t i = 0; i < struct_infos.count; i += 1) {
+        generate_struct_info(stream, struct_infos.items[i]);
+    }
+
+    fwrite(generate_end, strlen(generate_end), 1, stream);
+
+    result = true;
+fail:
+    free(header_content);
+    if (output_file) fclose(output_file);
+
+    return result;
+}
+
+bool preprocess_file(const char* file_path, String_Builder* result) {
+    char command[256] = {0};
+    sprintf(command, "gcc -E %s", file_path);
+
+    FILE* fp = popen(command, "r");
+    if (fp == NULL) {
+        fprintf(stderr, "ERROR: Failed to run command: %s\n", strerror(errno));
+        return false;
+    }
+
+    char line[512];
+    size_t line_num = 0;
+    char file_name[512];
+
+    size_t cursor = 0;
+    result->length = 0;
+
+    bool collecting_content = false;
+
+    while (fgets(line, sizeof(line), fp) != NULL) {
+        if (sscanf(line, "# %zu \"%s\"", &line_num, file_name) == 2) {
+            // remove trailing "
+            file_name[strlen(file_name) - 1] = '\0';
+
+            if (strcmp(file_name, file_path) == 0) {
+                collecting_content = true;
+                continue;
+            }
+
+            // TODO: read original file at line_num, to check for comments (e.g annotations)
+        } else if(collecting_content) {
+            sb_append(result, line);
+            cursor += strlen(line);
+        }
+    }
+
+    pclose(fp);
+
+    return true;
+}
+
+bool process_file(const char* input_file) {
+    // read input file
+    String_Builder input_content = {0};
+    if (!preprocess_file(input_file, &input_content)) return false;
+
+    // init lexer
+    char string_store[1024] = {0};
+    stb_c_lexer_init(&lexer, input_content.data, input_content.data + input_content.length, string_store, sizeof(string_store) / sizeof(char));
+
+    // find and parse all structs
+    Parsed_Struct_Infos struct_infos = {0};
+
+    while (true) {
+        char* mark = lexer.parse_point;
+
+        if (!stb_c_lexer_get_token(&lexer)) break;
+        if (lexer.token == CLEX_id && strcmp(lexer.string, "typedef") == 0) {
+            lexer.parse_point = mark;
+
+            Parsed_Struct_Info struct_info = {0};
+            if (parse_struct(&struct_info)) {
+                da_append(&struct_infos, struct_info);
+            }
+        }
+    }
+
+    if (!generate_output_file(__FILE__, struct_infos)) return false;
+
+    return true;
+}
+
+#endif // CMETA_COMPTIME
+
+#endif // CMETA_H

example/01_simple_struct/main.c

@@ -0,0 +1,19 @@
+#include <stdio.h>
+#include "cmeta.h"
+
+typedef struct {
+    int int_field;
+} Foo_Struct;
+
+int main(void) {
+    printf("Foo_Struct infos:\n");
+    printf("  name = %s\n", foo_struct_info.name);
+    printf("  fields_count = %zu\n", foo_struct_info.fields_count);
+
+    for (size_t i = 0; i < foo_struct_info.fields_count; i += 1) {
+        Field_Info field = foo_struct_info.fields[i];
+        printf("    .%s: %s\n", field.name, field.type);
+    }
+
+    return 0;
+}

src/main.c

@@ -1,6 +0,0 @@
-#include <stdio.h>
-
-int main(void) {
-    printf("Ok\n");
-    return 0;
-}

third_party/stb_c_lexer.h

@@ -0,0 +1,941 @@
+// stb_c_lexer.h - v0.12 - public domain Sean Barrett 2013
+// lexer for making little C-like languages with recursive-descent parsers
+//
+// This file provides both the interface and the implementation.
+// To instantiate the implementation,
+//      #define STB_C_LEXER_IMPLEMENTATION
+// in *ONE* source file, before #including this file.
+//
+// The default configuration is fairly close to a C lexer, although
+// suffixes on integer constants are not handled (you can override this).
+//
+// History:
+//     0.12 fix compilation bug for NUL support; better support separate inclusion
+//     0.11 fix clang static analysis warning
+//     0.10 fix warnings
+//     0.09 hex floats, no-stdlib fixes
+//     0.08 fix bad pointer comparison
+//     0.07 fix mishandling of hexadecimal constants parsed by strtol
+//     0.06 fix missing next character after ending quote mark (Andreas Fredriksson)
+//     0.05 refixed get_location because github version had lost the fix
+//     0.04 fix octal parsing bug
+//     0.03 added STB_C_LEX_DISCARD_PREPROCESSOR option
+//          refactor API to simplify (only one struct instead of two)
+//          change literal enum names to have 'lit' at the end
+//     0.02 first public release
+//
+// Status:
+//     - haven't tested compiling as C++
+//     - haven't tested the float parsing path
+//     - haven't tested the non-default-config paths (e.g. non-stdlib)
+//     - only tested default-config paths by eyeballing output of self-parse
+//
+//     - haven't implemented multiline strings
+//     - haven't implemented octal/hex character constants
+//     - haven't implemented support for unicode CLEX_char
+//     - need to expand error reporting so you don't just get "CLEX_parse_error"
+//
+// Contributors:
+//   Arpad Goretity (bugfix)
+//   Alan Hickman (hex floats)
+//   github:mundusnine (bugfix)
+//
+// LICENSE
+//
+//   See end of file for license information.
+
+#ifdef STB_C_LEXER_IMPLEMENTATION
+#ifndef STB_C_LEXER_DEFINITIONS
+// to change the default parsing rules, copy the following lines
+// into your C/C++ file *before* including this, and then replace
+// the Y's with N's for the ones you don't want. This needs to be
+// set to the same values for every place in your program where
+// stb_c_lexer.h is included.
+// --BEGIN--
+
+#if defined(Y) || defined(N)
+#error "Can only use stb_c_lexer in contexts where the preprocessor symbols 'Y' and 'N' are not defined"
+#endif
+
+#define STB_C_LEX_C_DECIMAL_INTS    Y   //  "0|[1-9][0-9]*"                        CLEX_intlit
+#define STB_C_LEX_C_HEX_INTS        Y   //  "0x[0-9a-fA-F]+"                       CLEX_intlit
+#define STB_C_LEX_C_OCTAL_INTS      Y   //  "[0-7]+"                               CLEX_intlit
+#define STB_C_LEX_C_DECIMAL_FLOATS  Y   //  "[0-9]*(.[0-9]*([eE][-+]?[0-9]+)?)     CLEX_floatlit
+#define STB_C_LEX_C99_HEX_FLOATS    N   //  "0x{hex}+(.{hex}*)?[pP][-+]?{hex}+     CLEX_floatlit
+#define STB_C_LEX_C_IDENTIFIERS     Y   //  "[_a-zA-Z][_a-zA-Z0-9]*"               CLEX_id
+#define STB_C_LEX_C_DQ_STRINGS      Y   //  double-quote-delimited strings with escapes  CLEX_dqstring
+#define STB_C_LEX_C_SQ_STRINGS      N   //  single-quote-delimited strings with escapes  CLEX_ssstring
+#define STB_C_LEX_C_CHARS           Y   //  single-quote-delimited character with escape CLEX_charlits
+#define STB_C_LEX_C_COMMENTS        Y   //  "/* comment */"
+#define STB_C_LEX_CPP_COMMENTS      Y   //  "// comment to end of line\n"
+#define STB_C_LEX_C_COMPARISONS     Y   //  "==" CLEX_eq  "!=" CLEX_noteq   "<=" CLEX_lesseq  ">=" CLEX_greatereq
+#define STB_C_LEX_C_LOGICAL         Y   //  "&&"  CLEX_andand   "||"  CLEX_oror
+#define STB_C_LEX_C_SHIFTS          Y   //  "<<"  CLEX_shl      ">>"  CLEX_shr
+#define STB_C_LEX_C_INCREMENTS      Y   //  "++"  CLEX_plusplus "--"  CLEX_minusminus
+#define STB_C_LEX_C_ARROW           Y   //  "->"  CLEX_arrow
+#define STB_C_LEX_EQUAL_ARROW       N   //  "=>"  CLEX_eqarrow
+#define STB_C_LEX_C_BITWISEEQ       Y   //  "&="  CLEX_andeq    "|="  CLEX_oreq     "^="  CLEX_xoreq
+#define STB_C_LEX_C_ARITHEQ         Y   //  "+="  CLEX_pluseq   "-="  CLEX_minuseq
+                                        //  "*="  CLEX_muleq    "/="  CLEX_diveq    "%=" CLEX_modeq
+                                        //  if both STB_C_LEX_SHIFTS & STB_C_LEX_ARITHEQ:
+                                        //                      "<<=" CLEX_shleq    ">>=" CLEX_shreq
+
+#define STB_C_LEX_PARSE_SUFFIXES    N   // letters after numbers are parsed as part of those numbers, and must be in suffix list below
+#define STB_C_LEX_DECIMAL_SUFFIXES  ""  // decimal integer suffixes e.g. "uUlL" -- these are returned as-is in string storage
+#define STB_C_LEX_HEX_SUFFIXES      ""  // e.g. "uUlL"
+#define STB_C_LEX_OCTAL_SUFFIXES    ""  // e.g. "uUlL"
+#define STB_C_LEX_FLOAT_SUFFIXES    ""  //
+
+#define STB_C_LEX_0_IS_EOF             N  // if Y, ends parsing at '\0'; if N, returns '\0' as token
+#define STB_C_LEX_INTEGERS_AS_DOUBLES  N  // parses integers as doubles so they can be larger than 'int', but only if STB_C_LEX_STDLIB==N
+#define STB_C_LEX_MULTILINE_DSTRINGS   N  // allow newlines in double-quoted strings
+#define STB_C_LEX_MULTILINE_SSTRINGS   N  // allow newlines in single-quoted strings
+#define STB_C_LEX_USE_STDLIB           Y  // use strtod,strtol for parsing #s; otherwise inaccurate hack
+#define STB_C_LEX_DOLLAR_IDENTIFIER    Y  // allow $ as an identifier character
+#define STB_C_LEX_FLOAT_NO_DECIMAL     Y  // allow floats that have no decimal point if they have an exponent
+
+#define STB_C_LEX_DEFINE_ALL_TOKEN_NAMES  N   // if Y, all CLEX_ token names are defined, even if never returned
+                                              // leaving it as N should help you catch config bugs
+
+#define STB_C_LEX_DISCARD_PREPROCESSOR    Y   // discard C-preprocessor directives (e.g. after prepocess
+                                              // still have #line, #pragma, etc)
+
+//#define STB_C_LEX_ISWHITE(str)    ... // return length in bytes of whitespace characters if first char is whitespace
+
+#define STB_C_LEXER_DEFINITIONS         // This line prevents the header file from replacing your definitions
+// --END--
+#endif
+#endif
+
+#ifndef INCLUDE_STB_C_LEXER_H
+#define INCLUDE_STB_C_LEXER_H
+
+typedef struct
+{
+   // lexer variables
+   char *input_stream;
+   char *eof;
+   char *parse_point;
+   char *string_storage;
+   int   string_storage_len;
+
+   // lexer parse location for error messages
+   char *where_firstchar;
+   char *where_lastchar;
+
+   // lexer token variables
+   long token;
+   double real_number;
+   long   int_number;
+   char *string;
+   int string_len;
+} stb_lexer;
+
+typedef struct
+{
+   int line_number;
+   int line_offset;
+} stb_lex_location;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void stb_c_lexer_init(stb_lexer *lexer, const char *input_stream, const char *input_stream_end, char *string_store, int store_length);
+// this function initialize the 'lexer' structure
+//   Input:
+//   - input_stream points to the file to parse, loaded into memory
+//   - input_stream_end points to the end of the file, or NULL if you use 0-for-EOF
+//   - string_store is storage the lexer can use for storing parsed strings and identifiers
+//   - store_length is the length of that storage
+
+extern int stb_c_lexer_get_token(stb_lexer *lexer);
+// this function returns non-zero if a token is parsed, or 0 if at EOF
+//   Output:
+//   - lexer->token is the token ID, which is unicode code point for a single-char token, < 0 for a multichar or eof or error
+//   - lexer->real_number is a double constant value for CLEX_floatlit, or CLEX_intlit if STB_C_LEX_INTEGERS_AS_DOUBLES
+//   - lexer->int_number is an integer constant for CLEX_intlit if !STB_C_LEX_INTEGERS_AS_DOUBLES, or character for CLEX_charlit
+//   - lexer->string is a 0-terminated string for CLEX_dqstring or CLEX_sqstring or CLEX_identifier
+//   - lexer->string_len is the byte length of lexer->string
+
+extern void stb_c_lexer_get_location(const stb_lexer *lexer, const char *where, stb_lex_location *loc);
+// this inefficient function returns the line number and character offset of a
+// given location in the file as returned by stb_lex_token. Because it's inefficient,
+// you should only call it for errors, not for every token.
+// For error messages of invalid tokens, you typically want the location of the start
+// of the token (which caused the token to be invalid). For bugs involving legit
+// tokens, you can report the first or the range.
+//    Output:
+//    - loc->line_number is the line number in the file, counting from 1, of the location
+//    - loc->line_offset is the char-offset in the line, counting from 0, of the location
+
+
+#ifdef __cplusplus
+}
+#endif
+
+enum
+{
+   CLEX_eof = 256,
+   CLEX_parse_error,
+   CLEX_intlit        ,
+   CLEX_floatlit      ,
+   CLEX_id            ,
+   CLEX_dqstring      ,
+   CLEX_sqstring      ,
+   CLEX_charlit       ,
+   CLEX_eq            ,
+   CLEX_noteq         ,
+   CLEX_lesseq        ,
+   CLEX_greatereq     ,
+   CLEX_andand        ,
+   CLEX_oror          ,
+   CLEX_shl           ,
+   CLEX_shr           ,
+   CLEX_plusplus      ,
+   CLEX_minusminus    ,
+   CLEX_pluseq        ,
+   CLEX_minuseq       ,
+   CLEX_muleq         ,
+   CLEX_diveq         ,
+   CLEX_modeq         ,
+   CLEX_andeq         ,
+   CLEX_oreq          ,
+   CLEX_xoreq         ,
+   CLEX_arrow         ,
+   CLEX_eqarrow       ,
+   CLEX_shleq, CLEX_shreq,
+
+   CLEX_first_unused_token
+
+};
+#endif // INCLUDE_STB_C_LEXER_H
+
+#ifdef STB_C_LEXER_IMPLEMENTATION
+
+// Hacky definitions so we can easily #if on them
+#define Y(x) 1
+#define N(x) 0
+
+#if STB_C_LEX_INTEGERS_AS_DOUBLES(x)
+typedef double     stb__clex_int;
+#define intfield   real_number
+#define STB__clex_int_as_double
+#else
+typedef long       stb__clex_int;
+#define intfield   int_number
+#endif
+
+// Convert these config options to simple conditional #defines so we can more
+// easily test them once we've change the meaning of Y/N
+
+#if STB_C_LEX_PARSE_SUFFIXES(x)
+#define STB__clex_parse_suffixes
+#endif
+
+#if STB_C_LEX_C99_HEX_FLOATS(x)
+#define STB__clex_hex_floats
+#endif
+
+#if STB_C_LEX_C_HEX_INTS(x)
+#define STB__clex_hex_ints
+#endif
+
+#if STB_C_LEX_C_DECIMAL_INTS(x)
+#define STB__clex_decimal_ints
+#endif
+
+#if STB_C_LEX_C_OCTAL_INTS(x)
+#define STB__clex_octal_ints
+#endif
+
+#if STB_C_LEX_C_DECIMAL_FLOATS(x)
+#define STB__clex_decimal_floats
+#endif
+
+#if STB_C_LEX_DISCARD_PREPROCESSOR(x)
+#define STB__clex_discard_preprocessor
+#endif
+
+#if STB_C_LEX_USE_STDLIB(x) && (!defined(STB__clex_hex_floats) || __STDC_VERSION__ >= 199901L)
+#define STB__CLEX_use_stdlib
+#include <stdlib.h>
+#endif
+
+// Now for the rest of the file we'll use the basic definition where
+// where Y expands to its contents and N expands to nothing
+#undef  Y
+#define Y(a) a
+#undef N
+#define N(a)
+
+// API function
+void stb_c_lexer_init(stb_lexer *lexer, const char *input_stream, const char *input_stream_end, char *string_store, int store_length)
+{
+   lexer->input_stream = (char *) input_stream;
+   lexer->eof = (char *) input_stream_end;
+   lexer->parse_point = (char *) input_stream;
+   lexer->string_storage = string_store;
+   lexer->string_storage_len = store_length;
+}
+
+// API function
+void stb_c_lexer_get_location(const stb_lexer *lexer, const char *where, stb_lex_location *loc)
+{
+   char *p = lexer->input_stream;
+   int line_number = 1;
+   int char_offset = 0;
+   while (*p && p < where) {
+      if (*p == '\n' || *p == '\r') {
+         p += (p[0]+p[1] == '\r'+'\n' ? 2 : 1); // skip newline
+         line_number += 1;
+         char_offset = 0;
+      } else {
+         ++p;
+         ++char_offset;
+      }
+   }
+   loc->line_number = line_number;
+   loc->line_offset = char_offset;
+}
+
+// main helper function for returning a parsed token
+static int stb__clex_token(stb_lexer *lexer, int token, char *start, char *end)
+{
+   lexer->token = token;
+   lexer->where_firstchar = start;
+   lexer->where_lastchar = end;
+   lexer->parse_point = end+1;
+   return 1;
+}
+
+// helper function for returning eof
+static int stb__clex_eof(stb_lexer *lexer)
+{
+   lexer->token = CLEX_eof;
+   return 0;
+}
+
+static int stb__clex_iswhite(int x)
+{
+   return x == ' ' || x == '\t' || x == '\r' || x == '\n' || x == '\f';
+}
+
+static const char *stb__strchr(const char *str, int ch)
+{
+   for (; *str; ++str)
+      if (*str == ch)
+         return str;
+   return 0;
+}
+
+// parse suffixes at the end of a number
+static int stb__clex_parse_suffixes(stb_lexer *lexer, long tokenid, char *start, char *cur, const char *suffixes)
+{
+   #ifdef STB__clex_parse_suffixes
+   lexer->string = lexer->string_storage;
+   lexer->string_len = 0;
+
+   while ((*cur >= 'a' && *cur <= 'z') || (*cur >= 'A' && *cur <= 'Z')) {
+      if (stb__strchr(suffixes, *cur) == 0)
+         return stb__clex_token(lexer, CLEX_parse_error, start, cur);
+      if (lexer->string_len+1 >= lexer->string_storage_len)
+         return stb__clex_token(lexer, CLEX_parse_error, start, cur);
+      lexer->string[lexer->string_len++] = *cur++;
+   }
+   #else
+   suffixes = suffixes; // attempt to suppress warnings
+   #endif
+   return stb__clex_token(lexer, tokenid, start, cur-1);
+}
+
+#ifndef STB__CLEX_use_stdlib
+static double stb__clex_pow(double base, unsigned int exponent)
+{
+   double value=1;
+   for ( ; exponent; exponent >>= 1) {
+      if (exponent & 1)
+         value *= base;
+      base *= base;
+   }
+   return value;
+}
+
+static double stb__clex_parse_float(char *p, char **q)
+{
+   char *s = p;
+   double value=0;
+   int base=10;
+   int exponent=0;
+
+#ifdef STB__clex_hex_floats
+   if (*p == '0') {
+      if (p[1] == 'x' || p[1] == 'X') {
+         base=16;
+         p += 2;
+      }
+   }
+#endif
+
+   for (;;) {
+      if (*p >= '0' && *p <= '9')
+         value = value*base + (*p++ - '0');
+#ifdef STB__clex_hex_floats
+      else if (base == 16 && *p >= 'a' && *p <= 'f')
+         value = value*base + 10 + (*p++ - 'a');
+      else if (base == 16 && *p >= 'A' && *p <= 'F')
+         value = value*base + 10 + (*p++ - 'A');
+#endif
+      else
+         break;
+   }
+
+   if (*p == '.') {
+      double pow, addend = 0;
+      ++p;
+      for (pow=1; ; pow*=base) {
+         if (*p >= '0' && *p <= '9')
+            addend = addend*base + (*p++ - '0');
+#ifdef STB__clex_hex_floats
+         else if (base == 16 && *p >= 'a' && *p <= 'f')
+            addend = addend*base + 10 + (*p++ - 'a');
+         else if (base == 16 && *p >= 'A' && *p <= 'F')
+            addend = addend*base + 10 + (*p++ - 'A');
+#endif
+         else
+            break;
+      }
+      value += addend / pow;
+   }
+#ifdef STB__clex_hex_floats
+   if (base == 16) {
+      // exponent required for hex float literal
+      if (*p != 'p' && *p != 'P') {
+         *q = s;
+         return 0;
+      }
+      exponent = 1;
+   } else
+#endif
+      exponent = (*p == 'e' || *p == 'E');
+
+   if (exponent) {
+      int sign = p[1] == '-';
+      unsigned int exponent=0;
+      double power=1;
+      ++p;
+      if (*p == '-' || *p == '+')
+         ++p;
+      while (*p >= '0' && *p <= '9')
+         exponent = exponent*10 + (*p++ - '0');
+
+#ifdef STB__clex_hex_floats
+      if (base == 16)
+         power = stb__clex_pow(2, exponent);
+      else
+#endif
+         power = stb__clex_pow(10, exponent);
+      if (sign)
+         value /= power;
+      else
+         value *= power;
+   }
+   *q = p;
+   return value;
+}
+#endif
+
+static int stb__clex_parse_char(char *p, char **q)
+{
+   if (*p == '\\') {
+      *q = p+2; // tentatively guess we'll parse two characters
+      switch(p[1]) {
+         case '\\': return '\\';
+         case '\'': return '\'';
+         case '"': return '"';
+         case 't': return '\t';
+         case 'f': return '\f';
+         case 'n': return '\n';
+         case 'r': return '\r';
+         case '0': return '\0'; // @TODO ocatal constants
+         case 'x': case 'X': return -1; // @TODO hex constants
+         case 'u': return -1; // @TODO unicode constants
+      }
+   }
+   *q = p+1;
+   return (unsigned char) *p;
+}
+
+static int stb__clex_parse_string(stb_lexer *lexer, char *p, int type)
+{
+   char *start = p;
+   char delim = *p++; // grab the " or ' for later matching
+   char *out = lexer->string_storage;
+   char *outend = lexer->string_storage + lexer->string_storage_len;
+   while (*p != delim) {
+      int n;
+      if (*p == '\\') {
+         char *q;
+         n = stb__clex_parse_char(p, &q);
+         if (n < 0)
+            return stb__clex_token(lexer, CLEX_parse_error, start, q);
+         p = q;
+      } else {
+         // @OPTIMIZE: could speed this up by looping-while-not-backslash
+         n = (unsigned char) *p++;
+      }
+      if (out+1 > outend)
+         return stb__clex_token(lexer, CLEX_parse_error, start, p);
+      // @TODO expand unicode escapes to UTF8
+      *out++ = (char) n;
+   }
+   *out = 0;
+   lexer->string = lexer->string_storage;
+   lexer->string_len = (int) (out - lexer->string_storage);
+   return stb__clex_token(lexer, type, start, p);
+}
+
+int stb_c_lexer_get_token(stb_lexer *lexer)
+{
+   char *p = lexer->parse_point;
+
+   // skip whitespace and comments
+   for (;;) {
+      #ifdef STB_C_LEX_ISWHITE
+      while (p != lexer->stream_end) {
+         int n;
+         n = STB_C_LEX_ISWHITE(p);
+         if (n == 0) break;
+         if (lexer->eof && lexer->eof - lexer->parse_point < n)
+            return stb__clex_token(tok, CLEX_parse_error, p,lexer->eof-1);
+         p += n;
+      }
+      #else
+      while (p != lexer->eof && stb__clex_iswhite(*p))
+         ++p;
+      #endif
+
+      STB_C_LEX_CPP_COMMENTS(
+         if (p != lexer->eof && p[0] == '/' && p[1] == '/') {
+            while (p != lexer->eof && *p != '\r' && *p != '\n')
+               ++p;
+            continue;
+         }
+      )
+
+      STB_C_LEX_C_COMMENTS(
+         if (p != lexer->eof && p[0] == '/' && p[1] == '*') {
+            char *start = p;
+            p += 2;
+            while (p != lexer->eof && (p[0] != '*' || p[1] != '/'))
+               ++p;
+            if (p == lexer->eof)
+               return stb__clex_token(lexer, CLEX_parse_error, start, p-1);
+            p += 2;
+            continue;
+         }
+      )
+
+      #ifdef STB__clex_discard_preprocessor
+         // @TODO this discards everything after a '#', regardless
+         // of where in the line the # is, rather than requiring it
+         // be at the start. (because this parser doesn't otherwise
+         // check for line breaks!)
+         if (p != lexer->eof && p[0] == '#') {
+            while (p != lexer->eof && *p != '\r' && *p != '\n')
+               ++p;
+            continue;
+         }
+      #endif
+
+      break;
+   }
+
+   if (p == lexer->eof)
+      return stb__clex_eof(lexer);
+
+   switch (*p) {
+      default:
+         if (   (*p >= 'a' && *p <= 'z')
+             || (*p >= 'A' && *p <= 'Z')
+             || *p == '_' || (unsigned char) *p >= 128    // >= 128 is UTF8 char
+             STB_C_LEX_DOLLAR_IDENTIFIER( || *p == '$' ) )
+         {
+            int n = 0;
+            lexer->string = lexer->string_storage;
+            do {
+               if (n+1 >= lexer->string_storage_len)
+                  return stb__clex_token(lexer, CLEX_parse_error, p, p+n);
+               lexer->string[n] = p[n];
+               ++n;
+            } while (
+                  (p[n] >= 'a' && p[n] <= 'z')
+               || (p[n] >= 'A' && p[n] <= 'Z')
+               || (p[n] >= '0' && p[n] <= '9') // allow digits in middle of identifier
+               || p[n] == '_' || (unsigned char) p[n] >= 128
+                STB_C_LEX_DOLLAR_IDENTIFIER( || p[n] == '$' )
+            );
+            lexer->string[n] = 0;
+            lexer->string_len = n;
+            return stb__clex_token(lexer, CLEX_id, p, p+n-1);
+         }
+
+         // check for EOF
+         STB_C_LEX_0_IS_EOF(
+            if (*p == 0)
+               return stb__clex_eof(lexer);
+         )
+
+      single_char:
+         // not an identifier, return the character as itself
+         return stb__clex_token(lexer, *p, p, p);
+
+      case '+':
+         if (p+1 != lexer->eof) {
+            STB_C_LEX_C_INCREMENTS(if (p[1] == '+') return stb__clex_token(lexer, CLEX_plusplus, p,p+1);)
+            STB_C_LEX_C_ARITHEQ(   if (p[1] == '=') return stb__clex_token(lexer, CLEX_pluseq  , p,p+1);)
+         }
+         goto single_char;
+      case '-':
+         if (p+1 != lexer->eof) {
+            STB_C_LEX_C_INCREMENTS(if (p[1] == '-') return stb__clex_token(lexer, CLEX_minusminus, p,p+1);)
+            STB_C_LEX_C_ARITHEQ(   if (p[1] == '=') return stb__clex_token(lexer, CLEX_minuseq   , p,p+1);)
+            STB_C_LEX_C_ARROW(     if (p[1] == '>') return stb__clex_token(lexer, CLEX_arrow     , p,p+1);)
+         }
+         goto single_char;
+      case '&':
+         if (p+1 != lexer->eof) {
+            STB_C_LEX_C_LOGICAL(  if (p[1] == '&') return stb__clex_token(lexer, CLEX_andand, p,p+1);)
+            STB_C_LEX_C_BITWISEEQ(if (p[1] == '=') return stb__clex_token(lexer, CLEX_andeq , p,p+1);)
+         }
+         goto single_char;
+      case '|':
+         if (p+1 != lexer->eof) {
+            STB_C_LEX_C_LOGICAL(  if (p[1] == '|') return stb__clex_token(lexer, CLEX_oror, p,p+1);)
+            STB_C_LEX_C_BITWISEEQ(if (p[1] == '=') return stb__clex_token(lexer, CLEX_oreq, p,p+1);)
+         }
+         goto single_char;
+      case '=':
+         if (p+1 != lexer->eof) {
+            STB_C_LEX_C_COMPARISONS(if (p[1] == '=') return stb__clex_token(lexer, CLEX_eq, p,p+1);)
+            STB_C_LEX_EQUAL_ARROW(  if (p[1] == '>') return stb__clex_token(lexer, CLEX_eqarrow, p,p+1);)
+         }
+         goto single_char;
+      case '!':
+         STB_C_LEX_C_COMPARISONS(if (p+1 != lexer->eof && p[1] == '=') return stb__clex_token(lexer, CLEX_noteq, p,p+1);)
+         goto single_char;
+      case '^':
+         STB_C_LEX_C_BITWISEEQ(if (p+1 != lexer->eof && p[1] == '=') return stb__clex_token(lexer, CLEX_xoreq, p,p+1));
+         goto single_char;
+      case '%':
+         STB_C_LEX_C_ARITHEQ(if (p+1 != lexer->eof && p[1] == '=') return stb__clex_token(lexer, CLEX_modeq, p,p+1));
+         goto single_char;
+      case '*':
+         STB_C_LEX_C_ARITHEQ(if (p+1 != lexer->eof && p[1] == '=') return stb__clex_token(lexer, CLEX_muleq, p,p+1));
+         goto single_char;
+      case '/':
+         STB_C_LEX_C_ARITHEQ(if (p+1 != lexer->eof && p[1] == '=') return stb__clex_token(lexer, CLEX_diveq, p,p+1));
+         goto single_char;
+      case '<':
+         if (p+1 != lexer->eof) {
+            STB_C_LEX_C_COMPARISONS(if (p[1] == '=') return stb__clex_token(lexer, CLEX_lesseq, p,p+1);)
+            STB_C_LEX_C_SHIFTS(     if (p[1] == '<') {
+                                       STB_C_LEX_C_ARITHEQ(if (p+2 != lexer->eof && p[2] == '=')
+                                                              return stb__clex_token(lexer, CLEX_shleq, p,p+2);)
+                                       return stb__clex_token(lexer, CLEX_shl, p,p+1);
+                                    }
+                              )
+         }
+         goto single_char;
+      case '>':
+         if (p+1 != lexer->eof) {
+            STB_C_LEX_C_COMPARISONS(if (p[1] == '=') return stb__clex_token(lexer, CLEX_greatereq, p,p+1);)
+            STB_C_LEX_C_SHIFTS(     if (p[1] == '>') {
+                                       STB_C_LEX_C_ARITHEQ(if (p+2 != lexer->eof && p[2] == '=')
+                                                              return stb__clex_token(lexer, CLEX_shreq, p,p+2);)
+                                       return stb__clex_token(lexer, CLEX_shr, p,p+1);
+                                    }
+                              )
+         }
+         goto single_char;
+
+      case '"':
+         STB_C_LEX_C_DQ_STRINGS(return stb__clex_parse_string(lexer, p, CLEX_dqstring);)
+         goto single_char;
+      case '\'':
+         STB_C_LEX_C_SQ_STRINGS(return stb__clex_parse_string(lexer, p, CLEX_sqstring);)
+         STB_C_LEX_C_CHARS(
+         {
+            char *start = p;
+            lexer->int_number = stb__clex_parse_char(p+1, &p);
+            if (lexer->int_number < 0)
+               return stb__clex_token(lexer, CLEX_parse_error, start,start);
+            if (p == lexer->eof || *p != '\'')
+               return stb__clex_token(lexer, CLEX_parse_error, start,p);
+            return stb__clex_token(lexer, CLEX_charlit, start, p+1);
+         })
+         goto single_char;
+
+      case '0':
+         #if defined(STB__clex_hex_ints) || defined(STB__clex_hex_floats)
+            if (p+1 != lexer->eof) {
+               if (p[1] == 'x' || p[1] == 'X') {
+                  char *q;
+
+                  #ifdef STB__clex_hex_floats
+                  for (q=p+2;
+                       q != lexer->eof && ((*q >= '0' && *q <= '9') || (*q >= 'a' && *q <= 'f') || (*q >= 'A' && *q <= 'F'));
+                       ++q);
+                  if (q != lexer->eof) {
+                     if (*q == '.' STB_C_LEX_FLOAT_NO_DECIMAL(|| *q == 'p' || *q == 'P')) {
+                        #ifdef STB__CLEX_use_stdlib
+                        lexer->real_number = strtod((char *) p, (char**) &q);
+                        #else
+                        lexer->real_number = stb__clex_parse_float(p, &q);
+                        #endif
+
+                        if (p == q)
+                           return stb__clex_token(lexer, CLEX_parse_error, p,q);
+                        return stb__clex_parse_suffixes(lexer, CLEX_floatlit, p,q, STB_C_LEX_FLOAT_SUFFIXES);
+
+                     }
+                  }
+                  #endif   // STB__CLEX_hex_floats
+
+                  #ifdef STB__clex_hex_ints
+                  #ifdef STB__CLEX_use_stdlib
+                  lexer->int_number = strtol((char *) p, (char **) &q, 16);
+                  #else
+                  {
+                     stb__clex_int n=0;
+                     for (q=p+2; q != lexer->eof; ++q) {
+                        if (*q >= '0' && *q <= '9')
+                           n = n*16 + (*q - '0');
+                        else if (*q >= 'a' && *q <= 'f')
+                           n = n*16 + (*q - 'a') + 10;
+                        else if (*q >= 'A' && *q <= 'F')
+                           n = n*16 + (*q - 'A') + 10;
+                        else
+                           break;
+                     }
+                     lexer->int_number = n;
+                  }
+                  #endif
+                  if (q == p+2)
+                     return stb__clex_token(lexer, CLEX_parse_error, p-2,p-1);
+                  return stb__clex_parse_suffixes(lexer, CLEX_intlit, p,q, STB_C_LEX_HEX_SUFFIXES);
+                  #endif
+               }
+            }
+         #endif // defined(STB__clex_hex_ints) || defined(STB__clex_hex_floats)
+         // can't test for octal because we might parse '0.0' as float or as '0' '.' '0',
+         // so have to do float first
+
+         /* FALL THROUGH */
+      case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
+
+         #ifdef STB__clex_decimal_floats
+         {
+            char *q = p;
+            while (q != lexer->eof && (*q >= '0' && *q <= '9'))
+               ++q;
+            if (q != lexer->eof) {
+               if (*q == '.' STB_C_LEX_FLOAT_NO_DECIMAL(|| *q == 'e' || *q == 'E')) {
+                  #ifdef STB__CLEX_use_stdlib
+                  lexer->real_number = strtod((char *) p, (char**) &q);
+                  #else
+                  lexer->real_number = stb__clex_parse_float(p, &q);
+                  #endif
+
+                  return stb__clex_parse_suffixes(lexer, CLEX_floatlit, p,q, STB_C_LEX_FLOAT_SUFFIXES);
+
+               }
+            }
+         }
+         #endif // STB__clex_decimal_floats
+
+         #ifdef STB__clex_octal_ints
+         if (p[0] == '0') {
+            char *q = p;
+            #ifdef STB__CLEX_use_stdlib
+            lexer->int_number = strtol((char *) p, (char **) &q, 8);
+            #else
+            stb__clex_int n=0;
+            while (q != lexer->eof) {
+               if (*q >= '0' && *q <= '7')
+                  n = n*8 + (*q - '0');
+               else
+                  break;
+               ++q;
+            }
+            if (q != lexer->eof && (*q == '8' || *q=='9'))
+               return stb__clex_token(lexer, CLEX_parse_error, p, q);
+            lexer->int_number = n;
+            #endif
+            return stb__clex_parse_suffixes(lexer, CLEX_intlit, p,q, STB_C_LEX_OCTAL_SUFFIXES);
+         }
+         #endif // STB__clex_octal_ints
+
+         #ifdef STB__clex_decimal_ints
+         {
+            char *q = p;
+            #ifdef STB__CLEX_use_stdlib
+            lexer->int_number = strtol((char *) p, (char **) &q, 10);
+            #else
+            stb__clex_int n=0;
+            while (q != lexer->eof) {
+               if (*q >= '0' && *q <= '9')
+                  n = n*10 + (*q - '0');
+               else
+                  break;
+               ++q;
+            }
+            lexer->int_number = n;
+            #endif
+            return stb__clex_parse_suffixes(lexer, CLEX_intlit, p,q, STB_C_LEX_OCTAL_SUFFIXES);
+         }
+         #endif // STB__clex_decimal_ints
+         goto single_char;
+   }
+}
+#endif // STB_C_LEXER_IMPLEMENTATION
+
+#ifdef STB_C_LEXER_SELF_TEST
+#define _CRT_SECURE_NO_WARNINGS
+#include <stdio.h>
+#include <stdlib.h>
+
+static void print_token(stb_lexer *lexer)
+{
+   switch (lexer->token) {
+      case CLEX_id        : printf("_%s", lexer->string); break;
+      case CLEX_eq        : printf("=="); break;
+      case CLEX_noteq     : printf("!="); break;
+      case CLEX_lesseq    : printf("<="); break;
+      case CLEX_greatereq : printf(">="); break;
+      case CLEX_andand    : printf("&&"); break;
+      case CLEX_oror      : printf("||"); break;
+      case CLEX_shl       : printf("<<"); break;
+      case CLEX_shr       : printf(">>"); break;
+      case CLEX_plusplus  : printf("++"); break;
+      case CLEX_minusminus: printf("--"); break;
+      case CLEX_arrow     : printf("->"); break;
+      case CLEX_andeq     : printf("&="); break;
+      case CLEX_oreq      : printf("|="); break;
+      case CLEX_xoreq     : printf("^="); break;
+      case CLEX_pluseq    : printf("+="); break;
+      case CLEX_minuseq   : printf("-="); break;
+      case CLEX_muleq     : printf("*="); break;
+      case CLEX_diveq     : printf("/="); break;
+      case CLEX_modeq     : printf("%%="); break;
+      case CLEX_shleq     : printf("<<="); break;
+      case CLEX_shreq     : printf(">>="); break;
+      case CLEX_eqarrow   : printf("=>"); break;
+      case CLEX_dqstring  : printf("\"%s\"", lexer->string); break;
+      case CLEX_sqstring  : printf("'\"%s\"'", lexer->string); break;
+      case CLEX_charlit   : printf("'%s'", lexer->string); break;
+      #if defined(STB__clex_int_as_double) && !defined(STB__CLEX_use_stdlib)
+      case CLEX_intlit    : printf("#%g", lexer->real_number); break;
+      #else
+      case CLEX_intlit    : printf("#%ld", lexer->int_number); break;
+      #endif
+      case CLEX_floatlit  : printf("%g", lexer->real_number); break;
+      default:
+         if (lexer->token >= 0 && lexer->token < 256)
+            printf("%c", (int) lexer->token);
+         else {
+            printf("<<<UNKNOWN TOKEN %ld >>>\n", lexer->token);
+         }
+         break;
+   }
+}
+
+/* Force a test
+of parsing
+multiline comments */
+
+/*/ comment /*/
+/**/ extern /**/
+
+void dummy(void)
+{
+   double some_floats[] = {
+      1.0501, -10.4e12, 5E+10,
+#if 0   // not supported in C++ or C-pre-99, so don't try to compile it, but let our parser test it
+      0x1.0p+24, 0xff.FP-8, 0x1p-23,
+#endif
+      4.
+   };
+   (void) sizeof(some_floats);
+   (void) some_floats[1];
+
+   printf("test %d",1); // https://github.com/nothings/stb/issues/13
+}
+
+int main(int argc, char **argv)
+{
+   FILE *f = fopen("stb_c_lexer.h","rb");
+   char *text = (char *) malloc(1 << 20);
+   int len = f ? (int) fread(text, 1, 1<<20, f) : -1;
+   stb_lexer lex;
+   if (len < 0) {
+      fprintf(stderr, "Error opening file\n");
+      free(text);
+      fclose(f);
+      return 1;
+   }
+   fclose(f);
+
+   stb_c_lexer_init(&lex, text, text+len, (char *) malloc(0x10000), 0x10000);
+   while (stb_c_lexer_get_token(&lex)) {
+      if (lex.token == CLEX_parse_error) {
+         printf("\n<<<PARSE ERROR>>>\n");
+         break;
+      }
+      print_token(&lex);
+      printf("  ");
+   }
+   return 0;
+}
+#endif
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2017 Sean Barrett
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/