ed/gencpp
1
0
Fork 0
mirror of https://github.com/Ed94/gencpp.git synced 2024-12-22 07:44:45 -08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #62 from Ed94/de_oop

Browse Source 
De oop
This commit is contained in:
Edward R. Gonzalez 2024-12-11 11:54:14 -08:00 committed by GitHub
commit a390e7f895
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
179 changed files with 24701 additions and 23757 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -31,3 +31,4 @@ project/auxillary/vis_ast/dependencies/temp
test/gen/original
singleheader/gen/scratch.hpp
test/gen/scratch.cpp
gen_c_library/gen

14
.vscode/bookmarks.json vendored
View File

@ -1,14 +0,0 @@
{
"files": [
{
"path": "project/auxillary/vis_ast/dependencies/temp/raylib-master/src/rcamera.h",
"bookmarks": [
{
"line": 140,
"column": 14,
"label": ""
}
]
}
]
}

41
.vscode/c_cpp_properties.json vendored
View File

@ -1,9 +1,9 @@
{
"configurations": [
{
"name": "Win32 msvc",
"name": "Bootstrap",
"includePath": [
"${workspaceFolder}/**"
"${workspaceFolder}/base/**"
],
"defines": [
"_DEBUG",
@ -15,15 +15,44 @@
"GEN_INTELLISENSE_DIRECTIVES",
"INTELLISENSE_DIRECTIVES"
],
"cStandard": "c11",
"cppStandard": "c++17",
"windowsSdkVersion": "10.0.19041.0",
"compilerPath": "C:/Program Files/Microsoft Visual Studio/2022/Professional/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe",
"intelliSenseMode": "msvc-x64",
"compileCommands": "${workspaceFolder}/project/build/compile_commands.json"
"compileCommands": "${workspaceFolder}/.vscode/tasks.json",
"compilerArgs": [
"/EHsc-",
"/GR-",
"/Zc:preprocessor",
"/FC"
]
},
{
"name": "Win32 msvc c_library",
"includePath": [
"${workspaceFolder}/gen_c_library/**"
],
"defines": [
"_DEBUG",
"UNICODE",
"_UNICODE",
"GEN_TIME",
"GEN_IMPLEMENTATION",
// "GEN_DONT_USE_NAMESPACE"
"GEN_INTELLISENSE_DIRECTIVES",
"INTELLISENSE_DIRECTIVES"
],
"cppStandard": "c++17",
"windowsSdkVersion": "10.0.19041.0",
"compilerPath": "C:/Program Files/Microsoft Visual Studio/2022/Professional/VC/Tools/MSVC/14.29.30133/bin/HostX64/x64/cl.exe",
"intelliSenseMode": "msvc-x64",
"compileCommands": "${workspaceFolder}/.vscode/tasks.json"
},
{
"name": "Win32 clang",
"includePath": [
"${workspaceFolder}/**"
"${workspaceFolder}/base/**"
],
"defines": [
"_DEBUG",
@ -36,9 +65,9 @@
"INTELLISENSE_DIRECTIVES"
],
"windowsSdkVersion": "10.0.19041.0",
"compilerPath": "C:/Users/Ed/scoop/apps/llvm/current/bin/clang++.exe",
"compilerPath": "clang++.exe",
"intelliSenseMode": "windows-clang-x64",
"compileCommands": "${workspaceFolder}/project/build/compile_commands.json"
"compileCommands": "${workspaceFolder}/.vscode/tasks.json"
}
],
"version": 4

45
.vscode/launch.json vendored
View File

@ -4,39 +4,20 @@
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"type": "lldb",
"request": "launch",
"name": "Debug gentime lldb",
"program": "${workspaceFolder}/test/test.exe",
"args": [],
"cwd": "${workspaceFolder}/test/",
"postRunCommands": [
]
},
{
"type": "cppvsdbg",
"request": "launch",
"name": "Debug gentime vsdbg",
"program": "${workspaceFolder}/test/build/test.exe",
"name": "Debug base vsdbg",
"program": "${workspaceFolder}/base/build/base.exe",
"args": [],
"cwd": "${workspaceFolder}/test/",
"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
},
{
"type": "cppvsdbg",
"request": "launch",
"name": "Debug bootstrap vsdbg",
"program": "${workspaceFolder}/project/build/bootstrap.exe",
"args": [],
"cwd": "${workspaceFolder}/project/",
"cwd": "${workspaceFolder}/base/",
"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
},
{
"type": "cppvsdbg",
"request": "launch",
"name": "Debug singleheader vsdbg",
"program": "${workspaceFolder}/singleheader/build/gencpp_singleheader.exe",
"program": "${workspaceFolder}/singleheader/build/singleheader.exe",
"args": [],
"cwd": "${workspaceFolder}/singleheader/",
"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
@ -49,24 +30,6 @@
"args": [],
"cwd": "${workspaceFolder}/unreal_engine/",
"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
},
{
"type": "cppvsdbg",
"request": "launch",
"name": "Debug raylib refactor vsdbg",
"program": "${workspaceFolder}/project/auxillary/vis_ast/dependencies/raylib/build/raylib_refactor.exe",
"args": [],
"cwd": "${workspaceFolder}/project/auxillary/vis_ast/dependencies/temp/raylib-master/src/",
"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
},
{
"type": "cppvsdbg",
"request": "launch",
"name": "Debug VIS AST",
"program": "${workspaceFolder}/project/auxillary/vis_ast/binaries/vis_ast.exe",
"args": [],
"cwd": "${workspaceFolder}/project/auxillary/vis_ast/binaries/",
"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
}
]
}

27
.vscode/settings.json vendored
View File

@ -37,7 +37,26 @@
"propidl.h": "c",
"android_native_app_glue.h": "c",
"raylib.h": "c",
"*.m": "cpp"
"*.m": "cpp",
"atomic": "cpp",
"gen.h": "c",
"string_ops.hpp": "c",
"assert.h": "c",
"intrin.h": "c",
"bit": "cpp",
"cmath": "cpp",
"cstddef": "cpp",
"cstdint": "cpp",
"cstdio": "cpp",
"cstdlib": "cpp",
"cstring": "cpp",
"ctime": "cpp",
"cwchar": "cpp",
"iosfwd": "cpp",
"new": "cpp",
"typeinfo": "cpp",
"unordered_map": "cpp",
"xstddef": "cpp"
},
"C_Cpp.intelliSenseEngineFallback": "disabled",
"mesonbuild.configureOnOpen": true,
@ -48,8 +67,10 @@
"C_Cpp.files.exclude": {
"**/.vscode": true,
"**/.vs": true,
"**/sanity.gen.hpp": true
"**/sanity.gen.hpp": true,
"test/**":true,
},
"autoHide.autoHidePanel": false,
"autoHide.autoHideSideBar": false
"autoHide.autoHideSideBar": false,
"dimmer.enabled": false
}

144
.vscode/tasks.json vendored Normal file
View File

@ -0,0 +1,144 @@
{
"version": "2.0.0",
"tasks": [
{
"label": "Build Bootstrap",
"type": "shell",
"command": "C:\\Program Files\\PowerShell\\7\\pwsh.exe",
"args": [
"-ExecutionPolicy",
"Bypass",
"-File",
"${workspaceFolder}/scripts/build.ci.ps1",
"bootstrap",
"msvc"
],
"group": "build",
"problemMatcher": {
"owner": "cpp",
"fileLocation": [
"relative",
"${workspaceFolder}"
],
"pattern": {
"regexp": "^(.*)\\((\\d+)\\)\\s*:\\s*(warning|error)\\s*(\\w+)\\s*:\\s*(.*)$",
"file": 1,
"line": 2,
"severity": 3,
"code": 4,
"message": 5
}
},
"presentation": {
"reveal": "always",
"panel": "shared",
"clear": true
}
},
{
"label": "Build C Library",
"type": "shell",
"command": "C:\\Program Files\\PowerShell\\7\\pwsh.exe",
"args": [
"-ExecutionPolicy",
"Bypass",
"-File",
"${workspaceFolder}/scripts/build.ci.ps1",
"c_library",
"msvc"
],
"group": {
"kind": "build",
"isDefault": true
},
"problemMatcher": {
"owner": "cpp",
"fileLocation": [
"relative",
"${workspaceFolder}"
],
"pattern": {
"regexp": "^(.*)\\((\\d+)\\)\\s*:\\s*(warning|error)\\s*(\\w+)\\s*:\\s*(.*)$",
"file": 1,
"line": 2,
"severity": 3,
"code": 4,
"message": 5
}
},
"presentation": {
"reveal": "always",
"panel": "shared",
"clear": true
}
},
{
"label": "Build Singleheader (MSVC)",
"type": "shell",
"command": "C:\\Program Files\\PowerShell\\7\\pwsh.exe",
"args": [
"-ExecutionPolicy",
"Bypass",
"-File",
"${workspaceFolder}/scripts/build.ci.ps1",
"singleheader",
"msvc",
"debug"
],
"group": "build",
"problemMatcher": {
"owner": "cpp",
"fileLocation": ["relative", "${workspaceFolder}"],
"pattern": [
{
"regexp": "^(.*)\\((\\d+)\\)\\s*:\\s*(error|warning|info|note)\\s+(\\w{1,2}\\d+)\\s*:\\s*(.*)$",
"file": 1,
"line": 2,
"severity": 3,
"code": 4,
"message": 5
}
]
},
"presentation": {
"reveal": "always",
"panel": "shared",
"clear": true
}
},
{
"label": "Build Unreal (MSVC)",
"type": "shell",
"command": "C:\\Program Files\\PowerShell\\7\\pwsh.exe",
"args": [
"-ExecutionPolicy",
"Bypass",
"-File",
"${workspaceFolder}/scripts/build.ci.ps1",
"unreal",
"msvc",
"debug"
],
"group": "build",
"problemMatcher": {
"owner": "cpp",
"fileLocation": ["relative", "${workspaceFolder}"],
"pattern": [
{
"regexp": "^(.*)\\((\\d+)\\)\\s*:\\s*(error|warning|info|note)\\s+(\\w{1,2}\\d+)\\s*:\\s*(.*)$",
"file": 1,
"line": 2,
"severity": 3,
"code": 4,
"message": 5
}
]
},
"presentation": {
"reveal": "always",
"panel": "shared",
"clear": true
}
}
]
}

26
Readme.md
View File

@ -1,13 +1,26 @@
# gencpp
An attempt at simple staged metaprogramming for c/c++.
An attempt at simple staged metaprogramming for C/C++.
The library API is a composition of code element constructors.
These build up a code AST to then serialize with a file builder.
The library API is a composition of code element constructors, and a non-standards-compliant single-pass C/C++ parser.
These build up a code AST to then serialize with a file builder, or can be traversed for staged-reflection of C/C++ code.
This code base attempts follow the [handmade philosophy](https://handmade.network/manifesto).
Its not meant to be a black box metaprogramming utility, it should be easy to intergrate into a user's project domain.
## Documentation
* [docs - General](./docs/Readme.md): Overview and additional docs
* [AST_Design](./docs/AST_Design.md): Overvie of ASTs
* [AST Types](./docs/AST_Types.md): Listing of all AST types along with their Code type interface.
* [Parsing](./docs/Parsing.md): Overview of the parsing interface.
* [Parser Algo](./docs/Parser_Algo.md): In-depth breakdown of the parser's implementation.
* [base](./base/Readme.md): Essential (base) library.
* [gen_c_library](./gen_c_library/): C11 library variant generation (single header and segmeented).
* [gen_segmented](./gen_segmented/): Segemented C++ (`gen.<hpp/cpp>`, `gen.dep.<hpp/cpp>`) generation
* [gen_singleheader](./gen_singleheader/): Singlehader C++ generation `gen.hpp`
* [gen_unreal_engine](./gen_unreal_engine/): Unreal Engine thirdparty code generation.
## Notes
**On Partial Hiatus: Life has got me tackling other issues..**
@ -21,17 +34,13 @@ The library can already be used to generate code just fine, but the parser is wh
A `natvis` and `natstepfilter` are provided in the scripts directory (its outdated, I'll update this readme when its not).
***The editor and scanner have not been implemented yet. The scanner will come first, then the editor.***
A C variant is hosted [here](https://github.com/Ed94/genc); I will complete it when this library is feature complete, it should be easier to make than this...
## Usage
A metaprogram is built to generate files before the main program is built. We'll term runtime for this program as `GEN_TIME`. The metaprogram's core implementation are within `gen.hpp` and `gen.cpp` in the project directory.
`gen.cpp` \`s `main()` is defined as `gen_main()` which the user will have to define once for their program. There they will dictate everything that should be generated.
In order to keep the locality of this code within the same files the following pattern may be used (although this pattern isn't required at all):
In order to keep the locality of this code within the same files the following pattern may be used (although this pattern isn't the best to use):
Within `program.cpp` :
@ -54,7 +63,6 @@ u32 gen_main()
// Regular runtime dependent on the generated code here.
#endif
```
The design uses a constructive builder API for the code to generate.

156
base/Readme.md Normal file
View File

@ -0,0 +1,156 @@
## Navigation
# base
[Top](../Readme.md)
* [docs](../docs/Readme.md)
The library is fragmented into a series of headers and source files meant to be scanned in and then generated to a standard target format, or a user's desires.
Standard formats:
* **base**: Files are in granular pieces separated into four directories:
* **dependencies**: Originally from the c-zpl library and modified thereafter.
* **components**: The essential definitions of the library.
* **helpers**: Contains helper functionality used by base and other libraries to regenerate or generate the other library formats.
* `base_codegen.hpp`: Helps with self-hosted code generation of enums, and operator overload inlines of the code types.
* `<push/pop>.<name>.inline.<hpp>`: macros that are meant to be injected at specific locations of the library.
* `misc.hpp`: Misc functionality used by the library generation metaprograms.
* `undef.macros.h`: Undefines all macros from library that original were intended to leak into user code.
* **auxillary**: Non-essential tooling:
* `Builder`: Similar conceptually to Jai programming language's *builder*, just opens a file and prepares a string buffer to serialize code into (`builder_print`, `builder_print_fmt`). Then write & close the file when completed (`builder_write`).
* **`Scanner`**: Interface to load up `Code` from files two basic funcctions are currently provided.
* `scan_file`: Used mainly by the library format generators to directly scan files into untyped `Code` (raw string content, pre-formatted no AST parsed).
* `parse_file`: Used to read file and then parsed to populate a `CodeBody` AST.
* CSV parsing via one or two columns simplified.
* **gen_segemetned**: Dependencies go into gen.dep.{hpp/cpp} and components into gen.{hpp/cpp}
* **gen_singleheader**: Everything into a single file: gen.hpp
* **gen_unreal_engine**: Like gen_segemented but the library is modified slightly to compile as a thirdparty library within an Unreal Engine plugin or module.
* **gen_c_library**: The library is heavily modifed into C11 compliant code. A segemented and single-header set of variants are generatd.
Code not making up the core library is located in `auxiliary/<auxiliary_name>.<hpp/cpp>`. These are optional extensions or tools for the library.
## Dependencies
The project has no external dependencies beyond:
* `errno.h`
* `stat.h`
* `stdarg.h`
* `stddef.h`
* `stdio.h`
* `copyfile.h` (Mac)
* `types.h` (Linux)
* `sys/man.h` (Linux)
* `fcntl.h` (POSXIX Filesystem)
* `unistd.h` (Linux/Mac)
* `intrin.h` (Windows)
* `io.h` (Windows with gcc)
* `windows.h` (Windows)
Dependencies for the project are wrapped within `GENCPP_ROLL_OWN_DEPENDENCIES` (Defining it will disable them).
The majority of the dependency's implementation was derived from the [c-zpl library](https://github.com/zpl-c/zpl).
See the following files for any updates:
* [`platform.hpp`](./dependencies/platform.hpp)
* [`src_start.cpp`](./dependencies/src_start.cpp)
* [`filesystem.cpp`](./dependencies/filesystem.cpp)
* [`memory.cpp`](./dependencies/memory.cpp)
## Conventions
This library was written in a subset of C++ where the following are not used at all:
* RAII (Constructors/Destructors), lifetimes are managed using named static or regular functions.
* Language provide dynamic dispatch, RTTI
* Object-Oriented Inheritance
* Exceptions
Polymorphic & Member-functions are used as an ergonomic choice, along with a conserative use of operator overloads.
The base library itself does not use anything but C-like features to allow for generating a derviative compatiable with C.
Member function support or free-functions with reference object passing are wrapped in `! GEN_C_LIKE CPP` preprocess conditionals.
## C++ template usage
There are only 4 template definitions in the entire library (C++ versions). (`Array<Type>`, `Hashtable<Type>`, `swap<Type>`, and `tmpl_cast<CodeT>(CodeT code)`)
Two generic templated containers are used throughout the library:
* `template< class Type> struct Array`
* `template< class Type> struct HashTable`
`tmpl_cast<CodeT>(CodeT code)` is just an alternative way to explicitly cast to code. Its usage is wrapped in a macro called `cast` for the base library (needed for interoperability with C).
`template< class Type> swap( Type& a, Type& b)` is used over a macro.
Otherwise the library is free of any templates.
## Macro usage
Since this is a meta-programming library, it was desired to keep both templates and macros (especially macros) usage very limited.
Most macros are defined within [macros.hpp](./dependencies/macros.hpp).
The most advanced macro usage is `num_args` which is a helper for counting the number of arguments of another macro.
Any large macros used implementing the gen interface or parser are going to be phased out in favor of just forcinlined functions.
*(Unless there is a hot-path that requires them)*
The vast majority of macros should be single-line subsitutions that either add:
* Improvements to searching
* Inteniality of keyword usage
* A feature that only the preprocessor has (ex: function name reflection or stringifying)
* Compatibility of statements or expressions bewteen C & C++ that cannot be parsed by gencpp itself.
* Masking highly verbose syntax (the latter is getting phased out).
[gen_c_library](../gen_c_library/) has the most advanced set of macros for c11's generic selection.
* A significant amount of explicit code geneeration is utilized to keep abuse of the preprocessor to the absolute minimum.
* There is a heavy set of documentation inlined wth them; their naming is also highly verbose and explicit.
* See its documentation for more information.
## On base code generation
There are ***five*** header files which are automatically generated using [base_codegen.hpp](./helpers/base_codegen.hpp) by [base.cpp](./base.cpp). They are all located in [components/gen](./components/gen/).
* [`ecodetypes.hpp`](./components/gen/ecode.hpp): `CodeType` enum definition and related implementaiton. Generation is based off of [`ECodeType.csv](./enums/ECodeTypes.csv).
* [`especifier.hpp`](./components/gen/especifier.hpp): `Specifier` enum definition, etc. Generated using [`ESpecifier.csv`](./enums/ESpecifier.csv).
* [`eoperator.hpp`](./components/gen/eoperator.hpp): `Operator` enum definition, etc. Generated using [`EOperator.hpp`](./enums/EOperator.csv).
* [`etoktype.cpp`](./components/gen/etoktype.cpp): `TokType` enum defininition, etc. Used by the lexer and parser backend. Uses two csvs:
* [`ETokType.csv`](./enums/ETokType.csv): Provides the enum entries and their strinng ids.
* [`AttributeTokens.csv`](./enums/AttributeTokens.csv): Provides tokens entries that should be considered as attributes by the lexer and parser. Sspecfiically macro attributes such as those use for exporting symbols.
* [`ast_inlines.hpp`](./components/gen/ast_inlines.hpp): Member trivial `operator` definitions for C++ code types. Does not use a csv.
[`misc.hpp`](./helpers/misc.hpp): Has shared functions used by the library generation meta-programs throughout this codebase.
## On multi-threading
Currently unsupported. I want the library to be *stable* and *correct*, with the addition of exhausting all basic single-threaded optimizations before I consider multi-threading.
## Extending the library
This library is relatively very small (for parsing C++), and can be extended without much hassle.
The convention you'll see used throughout the upfront interface of the library is as follows:
1. Check name or parameters to make sure they are valid for the construction requested
2. Create a code object using `make_code`.
3. Populate immediate fields (Name, Type, ModuleFlags, etc)
4. Populate sub-entires using `add_entry`. If using the default serialization function `to_string`, follow the order at which entires are expected to appear (there is a strong ordering expected).
Names or Content fields are interned strings and thus showed be cached using `get_cached_string` if its desired to preserve that behavior.
`def_operator` is the most sophisticated upfront constructor as it has multiple permutations of definitions that could be created that are not trivial to determine if valid.
The parser is documented under [`docs/Parsing.md`](../docs/Parsing.md) and [`docs/Parser_Algo.md`](../docs/Parser_Algo.md). Extending it is more serious.
## A note on compilation and runtime generation speed
The library is designed to be fast to compile and generate code at runtime as fast as resonable possible on a debug build.
Its recommended that your metaprogam be compiled using a single translation unit (unity build).

59
base/auxillary/builder.cpp Normal file
View File

@ -0,0 +1,59 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# include "builder.hpp"
#endif
#pragma region Builder
Builder builder_open( char const* path )
{
Builder result;
FileError error = file_open_mode( & result.File, EFileMode_WRITE, path );
if ( error != EFileError_NONE )
{
log_failure( "gen::File::open - Could not open file: %s", path);
return result;
}
result.Buffer = string_make_reserve( GlobalAllocator, Builder_StrBufferReserve );
// log_fmt("$Builder - Opened file: %s\n", result.File.filename );
return result;
}
void builder_pad_lines( Builder* builder, s32 num )
{
string_append_strc( & builder->Buffer, txt("\n") );
}
void builder_print( Builder* builder, Code code )
{
String str = code_to_string(code);
// const ssize len = str.length();
// log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data );
string_append_string( & builder->Buffer, str );
}
void builder_print_fmt_va( Builder* builder, char const* fmt, va_list va )
{
ssize res;
char buf[ GEN_PRINTF_MAXLEN ] = { 0 };
res = str_fmt_va( buf, count_of( buf ) - 1, fmt, va ) - 1;
string_append_c_str_len( (String*) & (builder->Buffer), (char const*)buf, res);
}
void builder_write(Builder* builder)
{
b32 result = file_write( & builder->File, builder->Buffer, string_length(builder->Buffer) );
if ( result == false )
log_failure("gen::File::write - Failed to write to file: %s\n", file_name( & builder->File ) );
log_fmt( "Generated: %s\n", builder->File.filename );
file_close( & builder->File );
string_free(& builder->Buffer);
}
#pragma endregion Builder

70
base/auxillary/builder.hpp Normal file
View File

@ -0,0 +1,70 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "helpers/push_ignores.inline.hpp"
# include "components/header_start.hpp"
# include "components/types.hpp"
# include "components/gen/ecode.hpp"
# include "components/gen/eoperator.hpp"
# include "components/gen/especifier.hpp"
# include "components/ast.hpp"
# include "components/code_types.hpp"
# include "components/ast_types.hpp"
# include "components/interface.hpp"
# include "components/inlines.hpp"
# include "components/gen/ast_inlines.hpp"
# include "components/header_end.hpp"
using namespace gen;
#endif
#pragma region Builder
struct Builder;
typedef struct Builder Builder;
Builder builder_open ( char const* path );
void builder_pad_lines ( Builder* builder, s32 num );
void builder_print ( Builder* builder, Code code );
void builder_print_fmt_va( Builder* builder, char const* fmt, va_list va );
void builder_print_fmt ( Builder* builder, char const* fmt, ... ) {
va_list va;
va_start( va, fmt );
builder_print_fmt_va( builder, fmt, va );
va_end( va );
}
void builder_write( Builder* builder );
struct Builder
{
FileInfo File;
String Buffer;
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
forceinline static Builder open( char const* path ) { return builder_open(path); }
forceinline void pad_lines( s32 num ) { return builder_pad_lines(this, num); }
forceinline void print( Code code ) { return builder_print(this, code); }
forceinline void print_fmt( char const* fmt, ... ) {
va_list va;
va_start( va, fmt );
builder_print_fmt_va( this, fmt, va );
va_end( va );
}
forceinline void write() { return builder_write(this); }
#endif
};
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
void builder_pad_lines( Builder& builder, s32 num ) { return builder_pad_lines(& builder, num); }
void builder_print ( Builder& builder, Code code ) { return builder_print(& builder, code); }
void builder_write ( Builder& builder ) { return builder_write(& builder ); }
void builder_print_fmt( Builder& builder, char const* fmt, ...) {
va_list va;
va_start( va, fmt );
builder_print_fmt_va( & builder, fmt, va );
va_end( va );
}
#endif
#pragma endregion Builder

35
base/auxillary/gen_template.hpp Normal file
View File

@ -0,0 +1,35 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "helpers/push_ignores.inline.hpp"
# include "components/header_start.hpp"
# include "components/types.hpp"
# include "components/gen/ecode.hpp"
# include "components/gen/eoperator.hpp"
# include "components/gen/especifier.hpp"
# include "components/ast.hpp"
# include "components/code_types.hpp"
# include "components/ast_types.hpp"
# include "components/interface.hpp"
# include "components/inlines.hpp"
# include "components/gen/ast_inlines.hpp"
# include "components/header_end.hpp"
#endif
/*
Explicitly generates a resolved definition of a cpp template definition.
TODO(Ed): Needs implementing for the C-library variant.
TODO(Ed): We need a non <token> syntax subst implemtnation for Strings for this to work. It must subst keywords directly based on template parameter names.
This is only meant to be used on relatively trivial templates, where the type or numeric is mostly a 'duck' type.
It cannot parse complex template parameters.
The varadic args should correspond 1:1 with the type of objects the generator expects from the template's parameters.alignas.
*/
CodeOperator gen_operator_template( CodeTemplate template, ... );
CodeFn gen_func_template( CodeTemplate template, ... );
Code gen_class_struct_template( CodeTemplate template, ... );
Code gen_template( CodeTemplate template, ... );
Code gen_template( StrC template, StrC instantiation );

88
project/auxillary/scanner.hpp → base/auxillary/scanner.cpp
View File

@ -1,12 +1,9 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "gen.hpp"
# include "scanner.hpp"
#endif
// This is a simple file reader that reads the entire file into memory.
// It has an extra option to skip the first few lines for undesired includes.
// This is done so that includes can be kept in dependency and component files so that intellisense works.
inline
#pragma region Scanner
Code scan_file( char const* path )
{
FileInfo file;
@ -23,9 +20,9 @@ Code scan_file( char const* path )
GEN_FATAL("scan_file: %s is empty", path );
}
String str = String::make_reserve( GlobalAllocator, fsize );
String str = string_make_reserve( GlobalAllocator, fsize );
file_read( & file, str, fsize );
str.get_header().Length = fsize;
string_get_header(str)->Length = fsize;
// Skip GEN_INTELLISENSE_DIRECTIVES preprocessor blocks
// Its designed so that the directive should be the first thing in the file.
@ -39,7 +36,7 @@ Code scan_file( char const* path )
const StrC def_intellisense = txt("GEN_INTELLISENSE_DIRECTIVES" );
bool found_directive = false;
char const* scanner = str.Data;
char const* scanner = (char const*)str;
s32 left = fsize;
while ( left )
{
@ -52,7 +49,7 @@ Code scan_file( char const* path )
if ( ! found_directive )
{
if ( left && str_compare( scanner, directive_start.Ptr, directive_start.Len ) == matched )
if ( left && str_compare_len( scanner, directive_start.Ptr, directive_start.Len ) == matched )
{
scanner += directive_start.Len;
left -= directive_start.Len;
@ -60,7 +57,7 @@ Code scan_file( char const* path )
while ( left && char_is_space( current ) )
move_fwd();
if ( left && str_compare( scanner, def_intellisense.Ptr, def_intellisense.Len ) == matched )
if ( left && str_compare_len( scanner, def_intellisense.Ptr, def_intellisense.Len ) == matched )
{
scanner += def_intellisense.Len;
left -= def_intellisense.Len;
@ -80,7 +77,7 @@ Code scan_file( char const* path )
continue;
}
if ( left && str_compare( scanner, directive_end.Ptr, directive_end.Len ) == matched )
if ( left && str_compare_len( scanner, directive_end.Ptr, directive_end.Len ) == matched )
{
scanner += directive_end.Len;
left -= directive_end.Len;
@ -94,19 +91,18 @@ Code scan_file( char const* path )
move_fwd();
// sptr skip_size = fsize - left;
if ( (scanner + 2) >= ( str.Data + fsize ) )
if ( (scanner + 2) >= ( (char const*) str + fsize ) )
{
mem_move( str, scanner, left );
str.get_header().Length = left;
string_get_header(str)->Length = left;
break;
}
mem_move( str, scanner, left );
str.get_header().Length = left;
string_get_header(str)->Length = left;
break;
}
}
move_fwd();
@ -117,44 +113,36 @@ Code scan_file( char const* path )
}
file_close( & file );
return untyped_str( str );
return untyped_str( string_to_strc(str) );
}
#if 0
struct CodeFile
{
using namespace Parser;
String FilePath;
TokArray Tokens;
Array<ParseFailure> ParseFailures;
Code CodeRoot;
};
namespace Parser
{
struct ParseFailure
{
String Reason;
Code Node;
};
CodeBody parse_file( const char* path ) {
FileContents file = file_read_contents( GlobalAllocator, true, path );
StrC content = { file.size, (char const*)file.data };
CodeBody code = parse_global_body( content );
log_fmt("\nParsed: %s\n", path);
return code;
}
CodeFile scan_file( char const* path )
{
using namespace Parser;
CodeFile
result = {};
result.FilePath = String::make( GlobalAllocator, path );
Code code = scan_file( path );
result.CodeRoot = code;
ParseContext context = parser_get_last_context();
result.Tokens = context.Tokens;
result.ParseFailures = context.Failures;
CSV_Column parse_csv_one_column(AllocatorInfo allocator, char const* path) {
FileContents content = file_read_contents( allocator, file_zero_terminate, path );
Arena csv_arena = arena_init_from_memory(content.data, content.size);
CSV_Column result;
csv_parse( & result.ADT, rcast(char*, content.data), allocator, false );
result.Content = result.ADT.nodes[0].nodes;
return result;
}
#endif
CSV_Columns2 parse_csv_two_columns(AllocatorInfo allocator, char const* path) {
FileContents content = file_read_contents( allocator, file_zero_terminate, path );
Arena csv_arena = arena_init_from_memory(content.data, content.size);
CSV_Columns2 result;
csv_parse( & result.ADT, rcast(char*, content.data), allocator, false );
result.Col_1 = result.ADT.nodes[0].nodes;
result.Col_2 = result.ADT.nodes[1].nodes;
return result;
}
#pragma endregion Scanner

46
base/auxillary/scanner.hpp Normal file
View File

@ -0,0 +1,46 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "helpers/push_ignores.inline.hpp"
# include "components/header_start.hpp"
# include "components/types.hpp"
# include "components/gen/ecode.hpp"
# include "components/gen/eoperator.hpp"
# include "components/gen/especifier.hpp"
# include "components/ast.hpp"
# include "components/code_types.hpp"
# include "components/ast_types.hpp"
# include "components/interface.hpp"
# include "components/inlines.hpp"
# include "components/gen/ast_inlines.hpp"
# include "components/header_end.hpp"
#endif
#pragma region Scanner
// This is a simple file reader that reads the entire file into memory.
// It has an extra option to skip the first few lines for undesired includes.
// This is done so that includes can be kept in dependency and component files so that intellisense works.
Code scan_file( char const* path );
CodeBody parse_file( const char* path );
// The follow is basic support for light csv parsing (use it as an example)
// Make something robust if its more serious.
typedef struct CSV_Column CSV_Column;
struct CSV_Column {
CSV_Object ADT;
Array(ADT_Node) Content;
};
typedef struct CSV_Columns2 CSV_Columns2;
struct CSV_Columns2 {
CSV_Object ADT;
Array(ADT_Node) Col_1;
Array(ADT_Node) Col_2;
};
CSV_Column parse_csv_one_column(AllocatorInfo allocator, char const* path);
CSV_Columns2 parse_csv_two_columns(AllocatorInfo allocator, char const* path);
#pragma endregion Scanner

68
base/base.cpp Normal file
View File

@ -0,0 +1,68 @@
#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
#define GEN_ENFORCE_STRONG_CODE_TYPES
#define GEN_EXPOSE_BACKEND
#define GEN_C_LIKE_CPP 1
#include "gen.cpp"
#include "helpers/push_ignores.inline.hpp"
#include <stdlib.h>
GEN_NS_BEGIN
#include "helpers/base_codegen.hpp"
#include "helpers/misc.hpp"
GEN_NS_END
using namespace gen;
constexpr char const* path_format_style = "../scripts/.clang-format";
constexpr char const* scratch_file = "build/scratch.hpp";
Code format( Code code ) {
return code_refactor_and_format(code, scratch_file, nullptr, path_format_style );
}
constexpr char const* generation_notice =
"// This file was generated automatially by gencpp's bootstrap.cpp "
"(See: https://github.com/Ed94/gencpp)\n\n";
int gen_main()
{
gen::init();
CodeBody gen_component_header = def_global_body( args(
def_preprocess_cond( PreprocessCond_IfDef, txt("GEN_INTELLISENSE_DIRECTIVES") ),
pragma_once,
def_include(txt("components/types.hpp")),
preprocess_endif,
fmt_newline,
untyped_str( to_strc_from_c_str(generation_notice) )
));
CodeBody ecode = gen_ecode ( "enums/ECodeTypes.csv" );
CodeBody eoperator = gen_eoperator ( "enums/EOperator.csv" );
CodeBody especifier = gen_especifier( "enums/ESpecifier.csv" );
CodeBody ast_inlines = gen_ast_inlines();
Builder header_ecode = builder_open( "components/gen/ecodetypes.hpp" );
builder_print( & header_ecode, gen_component_header );
builder_print( & header_ecode, format(ecode) );
builder_write( & header_ecode);
Builder header_eoperator = builder_open( "components/gen/eoperator.hpp" );
builder_print( & header_eoperator, gen_component_header );
builder_print( & header_eoperator, format(eoperator) );
builder_write( & header_eoperator );
Builder header_especifier = builder_open( "components/gen/especifier.hpp" );
builder_print( & header_especifier, gen_component_header );
builder_print( & header_especifier, format(especifier) );
builder_write( & header_especifier);
Builder header_ast_inlines = builder_open( "components/gen/ast_inlines.hpp" );
builder_print( & header_ast_inlines, gen_component_header );
builder_print( & header_ast_inlines, format(ast_inlines) );
builder_write( & header_ast_inlines);
gen::deinit();
return 0;
}

1277
base/components/ast.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

478
base/components/ast.hpp Normal file
View File

@ -0,0 +1,478 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
#pragma once
#include "types.hpp"
#include "gen/ecode.hpp"
#include "gen/eoperator.hpp"
#include "gen/especifier.hpp"
#endif
/*
______ ______ ________ __ __ ______ __
/ \ / \| \ | \ | \ / \ | \
| ▓▓▓▓▓▓\ ▓▓▓▓▓▓\\▓▓▓▓▓▓▓▓ | ▓▓\ | ▓▓ | ▓▓▓▓▓▓\ ______ ____| ▓▓ ______
| ▓▓__| ▓▓ ▓▓___\▓▓ | ▓▓ | ▓▓▓\| ▓▓ | ▓▓ \▓▓/ \ / ▓▓/ \
| ▓▓ ▓▓\▓▓ \ | ▓▓ | ▓▓▓▓\ ▓▓ | ▓▓ | ▓▓▓▓▓▓\ ▓▓▓▓▓▓▓ ▓▓▓▓▓▓\
| ▓▓▓▓▓▓▓▓_\▓▓▓▓▓▓\ | ▓▓ | ▓▓\▓▓ ▓▓ | ▓▓ __| ▓▓ | ▓▓ ▓▓ | ▓▓ ▓▓ ▓▓
| ▓▓ | ▓▓ \__| ▓▓ | ▓▓ | ▓▓ \▓▓▓▓ | ▓▓__/ \ ▓▓__/ ▓▓ ▓▓__| ▓▓ ▓▓▓▓▓▓▓▓
| ▓▓ | ▓▓\▓▓ ▓▓ | ▓▓ | ▓▓ \▓▓▓ \▓▓ ▓▓\▓▓ ▓▓\▓▓ ▓▓\▓▓ \
\▓▓ \▓▓ \▓▓▓▓▓▓ \▓▓ \▓▓ \▓▓ \▓▓▓▓▓▓ \▓▓▓▓▓▓ \▓▓▓▓▓▓▓ \▓▓▓▓▓▓▓
*/
struct AST;
struct AST_Body;
struct AST_Attributes;
struct AST_Comment;
struct AST_Constructor;
// struct AST_BaseClass;
struct AST_Class;
struct AST_Define;
struct AST_Destructor;
struct AST_Enum;
struct AST_Exec;
struct AST_Extern;
struct AST_Include;
struct AST_Friend;
struct AST_Fn;
struct AST_Module;
struct AST_NS;
struct AST_Operator;
struct AST_OpCast;
struct AST_Params;
struct AST_Pragma;
struct AST_PreprocessCond;
struct AST_Specifiers;
#if GEN_EXECUTION_EXPRESSION_SUPPORT
struct AST_Expr;
struct AST_Expr_Assign;
struct AST_Expr_Alignof;
struct AST_Expr_Binary;
struct AST_Expr_CStyleCast;
struct AST_Expr_FunctionalCast;
struct AST_Expr_CppCast;
struct AST_Expr_ProcCall;
struct AST_Expr_Decltype;
struct AST_Expr_Comma; // TODO(Ed) : This is a binary op not sure if it needs its own AST...
struct AST_Expr_AMS; // Access Member Symbol
struct AST_Expr_Sizeof;
struct AST_Expr_Subscript;
struct AST_Expr_Ternary;
struct AST_Expr_UnaryPrefix;
struct AST_Expr_UnaryPostfix;
struct AST_Expr_Element;
struct AST_Stmt;
struct AST_Stmt_Break;
struct AST_Stmt_Case;
struct AST_Stmt_Continue;
struct AST_Stmt_Decl;
struct AST_Stmt_Do;
struct AST_Stmt_Expr; // TODO(Ed) : Is this distinction needed? (Should it be a flag instead?)
struct AST_Stmt_Else;
struct AST_Stmt_If;
struct AST_Stmt_For;
struct AST_Stmt_Goto;
struct AST_Stmt_Label;
struct AST_Stmt_Switch;
struct AST_Stmt_While;
#endif
struct AST_Struct;
struct AST_Template;
struct AST_Typename;
struct AST_Typedef;
struct AST_Union;
struct AST_Using;
struct AST_Var;
#if GEN_COMPILER_C
typedef AST* Code;
#else
struct Code;
#endif
#if GEN_COMPILER_C
typedef AST_Body* CodeBody;
typedef AST_Attributes* CodeAttributes;
typedef AST_Comment* CodeComment;
typedef AST_Class* CodeClass;
typedef AST_Constructor* CodeConstructor;
typedef AST_Define* CodeDefine;
typedef AST_Destructor* CodeDestructor;
typedef AST_Enum* CodeEnum;
typedef AST_Exec* CodeExec;
typedef AST_Extern* CodeExtern;
typedef AST_Include* CodeInclude;
typedef AST_Friend* CodeFriend;
typedef AST_Fn* CodeFn;
typedef AST_Module* CodeModule;
typedef AST_NS* CodeNS;
typedef AST_Operator* CodeOperator;
typedef AST_OpCast* CodeOpCast;
typedef AST_Params* CodeParams;
typedef AST_PreprocessCond* CodePreprocessCond;
typedef AST_Pragma* CodePragma;
typedef AST_Specifiers* CodeSpecifiers;
#else
struct CodeBody;
struct CodeAttributes;
struct CodeComment;
struct CodeClass;
struct CodeConstructor;
struct CodeDefine;
struct CodeDestructor;
struct CodeEnum;
struct CodeExec;
struct CodeExtern;
struct CodeInclude;
struct CodeFriend;
struct CodeFn;
struct CodeModule;
struct CodeNS;
struct CodeOperator;
struct CodeOpCast;
struct CodeParams;
struct CodePreprocessCond;
struct CodePragma;
struct CodeSpecifiers;
#endif
#if GEN_EXECUTION_EXPRESSION_SUPPORT
#if GEN_COMPILER_C
typedef AST_Expr* CodeExpr;
typedef AST_Expr_Assign* CodeExpr_Assign;
typedef AST_Expr_Alignof* CodeExpr_Alignof;
typedef AST_Expr_Binary* CodeExpr_Binary;
typedef AST_Expr_CStyleCast* CodeExpr_CStyleCast;
typedef AST_Expr_FunctionalCast* CodeExpr_FunctionalCast;
typedef AST_Expr_CppCast* CodeExpr_CppCast;
typedef AST_Expr_Element* CodeExpr_Element;
typedef AST_Expr_ProcCall* CodeExpr_ProcCall;
typedef AST_Expr_Decltype* CodeExpr_Decltype;
typedef AST_Expr_Comma* CodeExpr_Comma;
typedef AST_Expr_AMS* CodeExpr_AMS; // Access Member Symbol
typedef AST_Expr_Sizeof* CodeExpr_Sizeof;
typedef AST_Expr_Subscript* CodeExpr_Subscript;
typedef AST_Expr_Ternary* CodeExpr_Ternary;
typedef AST_Expr_UnaryPrefix* CodeExpr_UnaryPrefix;
typedef AST_Expr_UnaryPostfix* CodeExpr_UnaryPostfix;
#else
struct CodeExpr;
struct CodeExpr_Assign;
struct CodeExpr_Alignof;
struct CodeExpr_Binary;
struct CodeExpr_CStyleCast;
struct CodeExpr_FunctionalCast;
struct CodeExpr_CppCast;
struct CodeExpr_Element;
struct CodeExpr_ProcCall;
struct CodeExpr_Decltype;
struct CodeExpr_Comma;
struct CodeExpr_AMS; // Access Member Symbol
struct CodeExpr_Sizeof;
struct CodeExpr_Subscript;
struct CodeExpr_Ternary;
struct CodeExpr_UnaryPrefix;
struct CodeExpr_UnaryPostfix;
#endif
#if GEN_COMPILER_C
typedef AST_Stmt* CodeStmt;
typedef AST_Stmt_Break* CodeStmt_Break;
typedef AST_Stmt_Case* CodeStmt_Case;
typedef AST_Stmt_Continue* CodeStmt_Continue;
typedef AST_Stmt_Decl* CodeStmt_Decl;
typedef AST_Stmt_Do* CodeStmt_Do;
typedef AST_Stmt_Expr* CodeStmt_Expr;
typedef AST_Stmt_Else* CodeStmt_Else;
typedef AST_Stmt_If* CodeStmt_If;
typedef AST_Stmt_For* CodeStmt_For;
typedef AST_Stmt_Goto* CodeStmt_Goto;
typedef AST_Stmt_Label* CodeStmt_Label;
typedef AST_Stmt_Switch* CodeStmt_Switch;
typedef AST_Stmt_While* CodeStmt_While;
#else
struct CodeStmt;
struct CodeStmt_Break;
struct CodeStmt_Case;
struct CodeStmt_Continue;
struct CodeStmt_Decl;
struct CodeStmt_Do;
struct CodeStmt_Expr;
struct CodeStmt_Else;
struct CodeStmt_If;
struct CodeStmt_For;
struct CodeStmt_Goto;
struct CodeStmt_Label;
struct CodeStmt_Switch;
struct CodeStmt_While;
#endif
// GEN_EXECUTION_EXPRESSION_SUPPORT
#endif
#if GEN_COMPILER_C
typedef AST_Struct* CodeStruct;
typedef AST_Template* CodeTemplate;
typedef AST_Typename* CodeTypename;
typedef AST_Typedef* CodeTypedef;
typedef AST_Union* CodeUnion;
typedef AST_Using* CodeUsing;
typedef AST_Var* CodeVar;
#else
struct CodeStruct;
struct CodeTemplate;
struct CodeTypename;
struct CodeTypedef;
struct CodeUnion;
struct CodeUsing;
struct CodeVar;
#endif
GEN_NS_PARSER_BEGIN
struct Token;
GEN_NS_PARSER_END
#if GEN_COMPILER_CPP
// Note(Ed): This is to alleviate an edge case with parsing usings or typedefs where I don't really have it setup
// to parse a 'namespace' macro or a type with a macro.
// I have ideas for ways to pack that into the typedef/using ast, but for now just keeping it like this
#define ParserTokenType GEN_NS_PARSER Token
typedef ParserTokenType Token;
#undef ParserTokenType
#endif
#if GEN_COMPILER_CPP
template< class Type> forceinline Type tmpl_cast( Code self ) { return * rcast( Type*, & self ); }
#endif
#pragma region Code C-Interface
void code_append (Code code, Code other );
StrC code_debug_str (Code code);
Code code_duplicate (Code code);
Code* code_entry (Code code, u32 idx );
bool code_has_entries (Code code);
bool code_is_body (Code code);
bool code_is_equal (Code code, Code other);
bool code_is_valid (Code code);
void code_set_global (Code code);
String code_to_string (Code self );
void code_to_string_ptr(Code self, String* result );
StrC code_type_str (Code self );
bool code_validate_body(Code self );
#pragma endregion Code C-Interface
#if GEN_COMPILER_CPP
/*
AST* wrapper
- Not constantly have to append the '*' as this is written often..
- Allows for implicit conversion to any of the ASTs (raw or filtered).
*/
struct Code
{
AST* ast;
# define Using_Code( Typename ) \
forceinline StrC debug_str() { return code_debug_str(* this); } \
forceinline Code duplicate() { return code_duplicate(* this); } \
forceinline bool is_equal( Code other ) { return code_is_equal(* this, other); } \
forceinline bool is_body() { return code_is_body(* this); } \
forceinline bool is_valid() { return code_is_valid(* this); } \
forceinline void set_global() { return code_set_global(* this); }
# define Using_CodeOps( Typename ) \
forceinline Typename& operator = ( Code other ); \
forceinline bool operator ==( Code other ) { return (AST*)ast == other.ast; } \
forceinline bool operator !=( Code other ) { return (AST*)ast != other.ast; } \
forceinline bool operator ==(std::nullptr_t) const { return ast == nullptr; } \
forceinline bool operator !=(std::nullptr_t) const { return ast != nullptr; } \
operator bool();
#if ! GEN_C_LIKE_CPP
Using_Code( Code );
forceinline void append(Code other) { return code_append(* this, other); }
forceinline Code* entry(u32 idx) { return code_entry(* this, idx); }
forceinline bool has_entries() { return code_has_entries(* this); }
forceinline String to_string() { return code_to_string(* this); }
forceinline void to_string(String& result) { return code_to_string_ptr(* this, & result); }
forceinline StrC type_str() { return code_type_str(* this); }
forceinline bool validate_body() { return code_validate_body(*this); }
#endif
Using_CodeOps( Code );
forceinline AST* operator ->() { return ast; }
Code& operator ++();
// TODO(Ed) : Remove this overload.
auto& operator*()
{
local_persist thread_local
Code NullRef = { nullptr };
if ( ast == nullptr )
return NullRef;
return *this;
}
#ifdef GEN_ENFORCE_STRONG_CODE_TYPES
# define operator explicit operator
#endif
operator CodeBody() const;
operator CodeAttributes() const;
// operator CodeBaseClass() const;
operator CodeComment() const;
operator CodeClass() const;
operator CodeConstructor() const;
operator CodeDefine() const;
operator CodeDestructor() const;
operator CodeExec() const;
operator CodeEnum() const;
operator CodeExtern() const;
operator CodeInclude() const;
operator CodeFriend() const;
operator CodeFn() const;
operator CodeModule() const;
operator CodeNS() const;
operator CodeOperator() const;
operator CodeOpCast() const;
operator CodeParams() const;
operator CodePragma() const;
operator CodePreprocessCond() const;
operator CodeSpecifiers() const;
operator CodeStruct() const;
operator CodeTemplate() const;
operator CodeTypename() const;
operator CodeTypedef() const;
operator CodeUnion() const;
operator CodeUsing() const;
operator CodeVar() const;
#undef operator
};
#endif
#pragma region Statics
// Used to identify ASTs that should always be duplicated. (Global constant ASTs)
extern Code Code_Global;
// Used to identify invalid generated code.
extern Code Code_Invalid;
#pragma endregion Statics
struct Code_POD
{
AST* ast;
};
static_assert( sizeof(Code) == sizeof(Code_POD), "ERROR: Code is not POD" );
// Desired width of the AST data structure.
constexpr int const AST_POD_Size = 128;
constexpr static
int AST_ArrSpecs_Cap =
(
AST_POD_Size
- sizeof(Code)
- sizeof(StringCached)
- sizeof(Code) * 2
- sizeof(Token*)
- sizeof(Code)
- sizeof(CodeType)
- sizeof(ModuleFlag)
- sizeof(u32)
)
/ sizeof(Specifier) - 1;
/*
Simple AST POD with functionality to seralize into C++ syntax.
*/
struct AST
{
union {
struct
{
Code InlineCmt; // Class, Constructor, Destructor, Enum, Friend, Functon, Operator, OpCast, Struct, Typedef, Using, Variable
Code Attributes; // Class, Enum, Function, Struct, Typedef, Union, Using, Variable
Code Specs; // Destructor, Function, Operator, Typename, Variable
union {
Code InitializerList; // Constructor
Code ParentType; // Class, Struct, ParentType->Next has a possible list of interfaces.
Code ReturnType; // Function, Operator, Typename
Code UnderlyingType; // Enum, Typedef
Code ValueType; // Parameter, Variable
};
union {
Code Macro; // Parameter
Code BitfieldSize; // Variable (Class/Struct Data Member)
Code Params; // Constructor, Function, Operator, Template, Typename
Code UnderlyingTypeMacro; // Enum
};
union {
Code ArrExpr; // Typename
Code Body; // Class, Constructor, Destructor, Enum, Friend, Function, Namespace, Struct, Union
Code Declaration; // Friend, Template
Code Value; // Parameter, Variable
};
union {
Code NextVar; // Variable; Possible way to handle comma separated variables declarations. ( , NextVar->Specs NextVar->Name NextVar->ArrExpr = NextVar->Value )
Code SuffixSpecs; // Only used with typenames, to store the function suffix if typename is function signature. ( May not be needed )
Code PostNameMacro; // Only used with parameters for specifically UE_REQUIRES (Thanks Unreal)
};
};
StringCached Content; // Attributes, Comment, Execution, Include
struct {
Specifier ArrSpecs[AST_ArrSpecs_Cap]; // Specifiers
Code NextSpecs; // Specifiers; If ArrSpecs is full, then NextSpecs is used.
};
};
StringCached Name;
union {
Code Prev;
Code Front;
Code Last;
};
union {
Code Next;
Code Back;
};
Token* Token; // Reference to starting token, only avaialble if it was derived from parsing.
Code Parent;
CodeType Type;
// CodeFlag CodeFlags;
ModuleFlag ModuleFlags;
union {
b32 IsFunction; // Used by typedef to not serialize the name field.
struct {
b16 IsParamPack; // Used by typename to know if type should be considered a parameter pack.
ETypenameTag TypeTag; // Used by typename to keep track of explicitly declared tags for the identifier (enum, struct, union)
};
Operator Op;
AccessSpec ParentAccess;
s32 NumEntries;
s32 VarParenthesizedInit; // Used by variables to know that initialization is using a constructor expression instead of an assignment expression.
};
};
static_assert( sizeof(AST) == AST_POD_Size, "ERROR: AST is not size of AST_POD_Size" );
#if GEN_COMPILER_CPP
// Uses an implicitly overloaded cast from the AST to the desired code type.
// Necessary if the user wants GEN_ENFORCE_STRONG_CODE_TYPES
struct InvalidCode_ImplictCaster;
#define InvalidCode (InvalidCode_ImplictCaster{})
#else
#define InvalidCode (void*){ (void*)Code_Invalid }
#endif
#if GEN_COMPILER_CPP
struct NullCode_ImplicitCaster;
// Used when the its desired when omission is allowed in a definition.
#define NullCode (NullCode_ImplicitCaster{})
#else
#define NullCode nullptr
#endif

78
base/components/ast_case_macros.cpp Normal file
View File

@ -0,0 +1,78 @@
# define GEN_AST_BODY_CLASS_UNALLOWED_TYPES \
case CT_PlatformAttributes: \
case CT_Class_Body: \
case CT_Enum_Body: \
case CT_Extern_Linkage: \
case CT_Function_Body: \
case CT_Function_Fwd: \
case CT_Global_Body: \
case CT_Namespace: \
case CT_Namespace_Body: \
case CT_Operator: \
case CT_Operator_Fwd: \
case CT_Parameters: \
case CT_Specifiers: \
case CT_Struct_Body: \
case CT_Typename:
# define GEN_AST_BODY_STRUCT_UNALLOWED_TYPES GEN_AST_BODY_CLASS_UNALLOWED_TYPES
# define GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES \
case CT_Access_Public: \
case CT_Access_Protected: \
case CT_Access_Private: \
case CT_PlatformAttributes: \
case CT_Class_Body: \
case CT_Enum_Body: \
case CT_Extern_Linkage: \
case CT_Friend: \
case CT_Function_Body: \
case CT_Function_Fwd: \
case CT_Global_Body: \
case CT_Namespace: \
case CT_Namespace_Body: \
case CT_Operator: \
case CT_Operator_Fwd: \
case CT_Operator_Member: \
case CT_Operator_Member_Fwd: \
case CT_Parameters: \
case CT_Specifiers: \
case CT_Struct_Body: \
case CT_Typename:
# define GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES \
case CT_Access_Public: \
case CT_Access_Protected: \
case CT_Access_Private: \
case CT_PlatformAttributes: \
case CT_Class_Body: \
case CT_Enum_Body: \
case CT_Execution: \
case CT_Friend: \
case CT_Function_Body: \
case CT_Namespace_Body: \
case CT_Operator_Member: \
case CT_Operator_Member_Fwd: \
case CT_Parameters: \
case CT_Specifiers: \
case CT_Struct_Body: \
case CT_Typename:
# define GEN_AST_BODY_EXPORT_UNALLOWED_TYPES GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES
# define GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES
# define GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES \
case CT_Access_Public: \
case CT_Access_Protected: \
case CT_Access_Private: \
case CT_PlatformAttributes: \
case CT_Class_Body: \
case CT_Enum_Body: \
case CT_Execution: \
case CT_Friend: \
case CT_Function_Body: \
case CT_Namespace_Body: \
case CT_Operator_Member: \
case CT_Operator_Member_Fwd: \
case CT_Parameters: \
case CT_Specifiers: \
case CT_Struct_Body: \
case CT_Typename:

603
project/components/ast_types.hpp → base/components/ast_types.hpp
View File

File diff suppressed because it is too large Load Diff

1492
base/components/code_serialization.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1130
base/components/code_types.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

965
base/components/gen/ast_inlines.hpp Normal file
View File

@ -0,0 +1,965 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
#pragma once
#include "components/types.hpp"
#endif
// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
#pragma region generated code inline implementation
inline Code& Code::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline Code::operator bool()
{
return ast != nullptr;
}
inline CodeBody& CodeBody::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeBody::operator bool()
{
return ast != nullptr;
}
inline CodeAttributes& CodeAttributes::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeAttributes::operator bool()
{
return ast != nullptr;
}
inline CodeAttributes::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Attributes* CodeAttributes::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeComment& CodeComment::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeComment::operator bool()
{
return ast != nullptr;
}
inline CodeComment::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Comment* CodeComment::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeConstructor& CodeConstructor::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeConstructor::operator bool()
{
return ast != nullptr;
}
inline CodeConstructor::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Constructor* CodeConstructor::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeClass& CodeClass::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeClass::operator bool()
{
return ast != nullptr;
}
inline CodeDefine& CodeDefine::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeDefine::operator bool()
{
return ast != nullptr;
}
inline CodeDefine::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Define* CodeDefine::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeDestructor& CodeDestructor::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeDestructor::operator bool()
{
return ast != nullptr;
}
inline CodeDestructor::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Destructor* CodeDestructor::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeEnum& CodeEnum::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeEnum::operator bool()
{
return ast != nullptr;
}
inline CodeEnum::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Enum* CodeEnum::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeExec& CodeExec::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeExec::operator bool()
{
return ast != nullptr;
}
inline CodeExec::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Exec* CodeExec::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeExtern& CodeExtern::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeExtern::operator bool()
{
return ast != nullptr;
}
inline CodeExtern::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Extern* CodeExtern::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeFriend& CodeFriend::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeFriend::operator bool()
{
return ast != nullptr;
}
inline CodeFriend::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Friend* CodeFriend::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeFn& CodeFn::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeFn::operator bool()
{
return ast != nullptr;
}
inline CodeFn::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Fn* CodeFn::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeInclude& CodeInclude::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeInclude::operator bool()
{
return ast != nullptr;
}
inline CodeInclude::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Include* CodeInclude::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeModule& CodeModule::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeModule::operator bool()
{
return ast != nullptr;
}
inline CodeModule::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Module* CodeModule::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeNS& CodeNS::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeNS::operator bool()
{
return ast != nullptr;
}
inline CodeNS::operator Code()
{
return *rcast( Code*, this );
}
inline AST_NS* CodeNS::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeOperator& CodeOperator::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeOperator::operator bool()
{
return ast != nullptr;
}
inline CodeOperator::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Operator* CodeOperator::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeOpCast& CodeOpCast::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeOpCast::operator bool()
{
return ast != nullptr;
}
inline CodeOpCast::operator Code()
{
return *rcast( Code*, this );
}
inline AST_OpCast* CodeOpCast::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeParams& CodeParams::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeParams::operator bool()
{
return ast != nullptr;
}
inline CodePragma& CodePragma::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodePragma::operator bool()
{
return ast != nullptr;
}
inline CodePragma::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Pragma* CodePragma::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodePreprocessCond& CodePreprocessCond::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodePreprocessCond::operator bool()
{
return ast != nullptr;
}
inline CodePreprocessCond::operator Code()
{
return *rcast( Code*, this );
}
inline AST_PreprocessCond* CodePreprocessCond::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeSpecifiers& CodeSpecifiers::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeSpecifiers::operator bool()
{
return ast != nullptr;
}
inline CodeStruct& CodeStruct::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeStruct::operator bool()
{
return ast != nullptr;
}
inline CodeTemplate& CodeTemplate::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeTemplate::operator bool()
{
return ast != nullptr;
}
inline CodeTemplate::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Template* CodeTemplate::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeTypename& CodeTypename::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeTypename::operator bool()
{
return ast != nullptr;
}
inline CodeTypename::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Typename* CodeTypename::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeTypedef& CodeTypedef::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeTypedef::operator bool()
{
return ast != nullptr;
}
inline CodeTypedef::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Typedef* CodeTypedef::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeUnion& CodeUnion::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeUnion::operator bool()
{
return ast != nullptr;
}
inline CodeUnion::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Union* CodeUnion::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeUsing& CodeUsing::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeUsing::operator bool()
{
return ast != nullptr;
}
inline CodeUsing::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Using* CodeUsing::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
inline CodeVar& CodeVar::operator=( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return *this;
}
inline CodeVar::operator bool()
{
return ast != nullptr;
}
inline CodeVar::operator Code()
{
return *rcast( Code*, this );
}
inline AST_Var* CodeVar::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
#pragma endregion generated code inline implementation
#pragma region generated AST/Code cast implementation
GEN_OPTIMIZE_MAPPINGS_BEGIN
forceinline Code::operator CodeBody() const
{
return { (AST_Body*)ast };
}
forceinline Code::operator CodeAttributes() const
{
return { (AST_Attributes*)ast };
}
forceinline Code::operator CodeComment() const
{
return { (AST_Comment*)ast };
}
forceinline Code::operator CodeConstructor() const
{
return { (AST_Constructor*)ast };
}
forceinline Code::operator CodeClass() const
{
return { (AST_Class*)ast };
}
forceinline Code::operator CodeDefine() const
{
return { (AST_Define*)ast };
}
forceinline Code::operator CodeDestructor() const
{
return { (AST_Destructor*)ast };
}
forceinline Code::operator CodeEnum() const
{
return { (AST_Enum*)ast };
}
forceinline Code::operator CodeExec() const
{
return { (AST_Exec*)ast };
}
forceinline Code::operator CodeExtern() const
{
return { (AST_Extern*)ast };
}
forceinline Code::operator CodeFriend() const
{
return { (AST_Friend*)ast };
}
forceinline Code::operator CodeFn() const
{
return { (AST_Fn*)ast };
}
forceinline Code::operator CodeInclude() const
{
return { (AST_Include*)ast };
}
forceinline Code::operator CodeModule() const
{
return { (AST_Module*)ast };
}
forceinline Code::operator CodeNS() const
{
return { (AST_NS*)ast };
}
forceinline Code::operator CodeOperator() const
{
return { (AST_Operator*)ast };
}
forceinline Code::operator CodeOpCast() const
{
return { (AST_OpCast*)ast };
}
forceinline Code::operator CodeParams() const
{
return { (AST_Params*)ast };
}
forceinline Code::operator CodePragma() const
{
return { (AST_Pragma*)ast };
}
forceinline Code::operator CodePreprocessCond() const
{
return { (AST_PreprocessCond*)ast };
}
forceinline Code::operator CodeSpecifiers() const
{
return { (AST_Specifiers*)ast };
}
forceinline Code::operator CodeStruct() const
{
return { (AST_Struct*)ast };
}
forceinline Code::operator CodeTemplate() const
{
return { (AST_Template*)ast };
}
forceinline Code::operator CodeTypename() const
{
return { (AST_Typename*)ast };
}
forceinline Code::operator CodeTypedef() const
{
return { (AST_Typedef*)ast };
}
forceinline Code::operator CodeUnion() const
{
return { (AST_Union*)ast };
}
forceinline Code::operator CodeUsing() const
{
return { (AST_Using*)ast };
}
forceinline Code::operator CodeVar() const
{
return { (AST_Var*)ast };
}
GEN_OPITMIZE_MAPPINGS_END
#pragma endregion generated AST / Code cast implementation

219
base/components/gen/ecodetypes.hpp Normal file
View File

@ -0,0 +1,219 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
#pragma once
#include "components/types.hpp"
#endif
// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
enum CodeType : u32
{
CT_Invalid,
CT_Untyped,
CT_NewLine,
CT_Comment,
CT_Access_Private,
CT_Access_Protected,
CT_Access_Public,
CT_PlatformAttributes,
CT_Class,
CT_Class_Fwd,
CT_Class_Body,
CT_Constructor,
CT_Constructor_Fwd,
CT_Destructor,
CT_Destructor_Fwd,
CT_Enum,
CT_Enum_Fwd,
CT_Enum_Body,
CT_Enum_Class,
CT_Enum_Class_Fwd,
CT_Execution,
CT_Export_Body,
CT_Extern_Linkage,
CT_Extern_Linkage_Body,
CT_Friend,
CT_Function,
CT_Function_Fwd,
CT_Function_Body,
CT_Global_Body,
CT_Module,
CT_Namespace,
CT_Namespace_Body,
CT_Operator,
CT_Operator_Fwd,
CT_Operator_Member,
CT_Operator_Member_Fwd,
CT_Operator_Cast,
CT_Operator_Cast_Fwd,
CT_Parameters,
CT_Preprocess_Define,
CT_Preprocess_Include,
CT_Preprocess_If,
CT_Preprocess_IfDef,
CT_Preprocess_IfNotDef,
CT_Preprocess_ElIf,
CT_Preprocess_Else,
CT_Preprocess_EndIf,
CT_Preprocess_Pragma,
CT_Specifiers,
CT_Struct,
CT_Struct_Fwd,
CT_Struct_Body,
CT_Template,
CT_Typedef,
CT_Typename,
CT_Union,
CT_Union_Fwd,
CT_Union_Body,
CT_Using,
CT_Using_Namespace,
CT_Variable,
CT_NumTypes,
CT_UnderlyingType = GEN_U32_MAX
};
inline StrC codetype_to_str( CodeType type )
{
local_persist StrC lookup[61] = {
{ sizeof( "Invalid" ), "Invalid" },
{ sizeof( "Untyped" ), "Untyped" },
{ sizeof( "NewLine" ), "NewLine" },
{ sizeof( "Comment" ), "Comment" },
{ sizeof( "Access_Private" ), "Access_Private" },
{ sizeof( "Access_Protected" ), "Access_Protected" },
{ sizeof( "Access_Public" ), "Access_Public" },
{ sizeof( "PlatformAttributes" ), "PlatformAttributes" },
{ sizeof( "Class" ), "Class" },
{ sizeof( "Class_Fwd" ), "Class_Fwd" },
{ sizeof( "Class_Body" ), "Class_Body" },
{ sizeof( "Constructor" ), "Constructor" },
{ sizeof( "Constructor_Fwd" ), "Constructor_Fwd" },
{ sizeof( "Destructor" ), "Destructor" },
{ sizeof( "Destructor_Fwd" ), "Destructor_Fwd" },
{ sizeof( "Enum" ), "Enum" },
{ sizeof( "Enum_Fwd" ), "Enum_Fwd" },
{ sizeof( "Enum_Body" ), "Enum_Body" },
{ sizeof( "Enum_Class" ), "Enum_Class" },
{ sizeof( "Enum_Class_Fwd" ), "Enum_Class_Fwd" },
{ sizeof( "Execution" ), "Execution" },
{ sizeof( "Export_Body" ), "Export_Body" },
{ sizeof( "Extern_Linkage" ), "Extern_Linkage" },
{ sizeof( "Extern_Linkage_Body" ), "Extern_Linkage_Body" },
{ sizeof( "Friend" ), "Friend" },
{ sizeof( "Function" ), "Function" },
{ sizeof( "Function_Fwd" ), "Function_Fwd" },
{ sizeof( "Function_Body" ), "Function_Body" },
{ sizeof( "Global_Body" ), "Global_Body" },
{ sizeof( "Module" ), "Module" },
{ sizeof( "Namespace" ), "Namespace" },
{ sizeof( "Namespace_Body" ), "Namespace_Body" },
{ sizeof( "Operator" ), "Operator" },
{ sizeof( "Operator_Fwd" ), "Operator_Fwd" },
{ sizeof( "Operator_Member" ), "Operator_Member" },
{ sizeof( "Operator_Member_Fwd" ), "Operator_Member_Fwd" },
{ sizeof( "Operator_Cast" ), "Operator_Cast" },
{ sizeof( "Operator_Cast_Fwd" ), "Operator_Cast_Fwd" },
{ sizeof( "Parameters" ), "Parameters" },
{ sizeof( "Preprocess_Define" ), "Preprocess_Define" },
{ sizeof( "Preprocess_Include" ), "Preprocess_Include" },
{ sizeof( "Preprocess_If" ), "Preprocess_If" },
{ sizeof( "Preprocess_IfDef" ), "Preprocess_IfDef" },
{ sizeof( "Preprocess_IfNotDef" ), "Preprocess_IfNotDef" },
{ sizeof( "Preprocess_ElIf" ), "Preprocess_ElIf" },
{ sizeof( "Preprocess_Else" ), "Preprocess_Else" },
{ sizeof( "Preprocess_EndIf" ), "Preprocess_EndIf" },
{ sizeof( "Preprocess_Pragma" ), "Preprocess_Pragma" },
{ sizeof( "Specifiers" ), "Specifiers" },
{ sizeof( "Struct" ), "Struct" },
{ sizeof( "Struct_Fwd" ), "Struct_Fwd" },
{ sizeof( "Struct_Body" ), "Struct_Body" },
{ sizeof( "Template" ), "Template" },
{ sizeof( "Typedef" ), "Typedef" },
{ sizeof( "Typename" ), "Typename" },
{ sizeof( "Union" ), "Union" },
{ sizeof( "Union_Fwd" ), "Union_Fwd" },
{ sizeof( "Union_Body" ), "Union_Body" },
{ sizeof( "Using" ), "Using" },
{ sizeof( "Using_Namespace" ), "Using_Namespace" },
{ sizeof( "Variable" ), "Variable" },
};
return lookup[type];
}
inline StrC codetype_to_keyword_str( CodeType type )
{
local_persist StrC lookup[61] = {
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "//" ) - 1, "//" },
{ sizeof( "private" ) - 1, "private" },
{ sizeof( "protected" ) - 1, "protected" },
{ sizeof( "public" ) - 1, "public" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "class" ) - 1, "class" },
{ sizeof( "clsss" ) - 1, "clsss" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "enum" ) - 1, "enum" },
{ sizeof( "enum" ) - 1, "enum" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "enum class" ) - 1, "enum class" },
{ sizeof( "enum class" ) - 1, "enum class" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "extern" ) - 1, "extern" },
{ sizeof( "extern" ) - 1, "extern" },
{ sizeof( "friend" ) - 1, "friend" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "module" ) - 1, "module" },
{ sizeof( "namespace" ) - 1, "namespace" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "operator" ) - 1, "operator" },
{ sizeof( "operator" ) - 1, "operator" },
{ sizeof( "operator" ) - 1, "operator" },
{ sizeof( "operator" ) - 1, "operator" },
{ sizeof( "operator" ) - 1, "operator" },
{ sizeof( "operator" ) - 1, "operator" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "define" ) - 1, "define" },
{ sizeof( "include" ) - 1, "include" },
{ sizeof( "if" ) - 1, "if" },
{ sizeof( "ifdef" ) - 1, "ifdef" },
{ sizeof( "ifndef" ) - 1, "ifndef" },
{ sizeof( "elif" ) - 1, "elif" },
{ sizeof( "else" ) - 1, "else" },
{ sizeof( "endif" ) - 1, "endif" },
{ sizeof( "pragma" ) - 1, "pragma" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "struct" ) - 1, "struct" },
{ sizeof( "struct" ) - 1, "struct" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "template" ) - 1, "template" },
{ sizeof( "typedef" ) - 1, "typedef" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "union" ) - 1, "union" },
{ sizeof( "union" ) - 1, "union" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
{ sizeof( "using" ) - 1, "using" },
{ sizeof( "using namespace" ) - 1, "using namespace" },
{ sizeof( "__NA__" ) - 1, "__NA__" },
};
return lookup[type];
}
forceinline StrC to_str( CodeType type )
{
return codetype_to_str( type );
}
forceinline StrC to_keyword_str( CodeType type )
{
return codetype_to_keyword_str( type );
}

118
base/components/gen/eoperator.hpp Normal file
View File

@ -0,0 +1,118 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
#pragma once
#include "components/types.hpp"
#endif
// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
enum Operator : u32
{
Op_Invalid,
Op_Assign,
Op_Assign_Add,
Op_Assign_Subtract,
Op_Assign_Multiply,
Op_Assign_Divide,
Op_Assign_Modulo,
Op_Assign_BAnd,
Op_Assign_BOr,
Op_Assign_BXOr,
Op_Assign_LShift,
Op_Assign_RShift,
Op_Increment,
Op_Decrement,
Op_Unary_Plus,
Op_Unary_Minus,
Op_UnaryNot,
Op_Add,
Op_Subtract,
Op_Multiply,
Op_Divide,
Op_Modulo,
Op_BNot,
Op_BAnd,
Op_BOr,
Op_BXOr,
Op_LShift,
Op_RShift,
Op_LAnd,
Op_LOr,
Op_LEqual,
Op_LNot,
Op_Lesser,
Op_Greater,
Op_LesserEqual,
Op_GreaterEqual,
Op_Subscript,
Op_Indirection,
Op_AddressOf,
Op_MemberOfPointer,
Op_PtrToMemOfPtr,
Op_FunctionCall,
Op_Comma,
Op_New,
Op_NewArray,
Op_Delete,
Op_DeleteArray,
Op_NumOps,
Op_UnderlyingType = 0xffffffffu
};
inline StrC operator_to_str( Operator op )
{
local_persist StrC lookup[47] = {
{ sizeof( "INVALID" ), "INVALID" },
{ sizeof( "=" ), "=" },
{ sizeof( "+=" ), "+=" },
{ sizeof( "-=" ), "-=" },
{ sizeof( "*=" ), "*=" },
{ sizeof( "/=" ), "/=" },
{ sizeof( "%=" ), "%=" },
{ sizeof( "&=" ), "&=" },
{ sizeof( "|=" ), "|=" },
{ sizeof( "^=" ), "^=" },
{ sizeof( "<<=" ), "<<=" },
{ sizeof( ">>=" ), ">>=" },
{ sizeof( "++" ), "++" },
{ sizeof( "--" ), "--" },
{ sizeof( "+" ), "+" },
{ sizeof( "-" ), "-" },
{ sizeof( "!" ), "!" },
{ sizeof( "+" ), "+" },
{ sizeof( "-" ), "-" },
{ sizeof( "*" ), "*" },
{ sizeof( "/" ), "/" },
{ sizeof( "%" ), "%" },
{ sizeof( "~" ), "~" },
{ sizeof( "&" ), "&" },
{ sizeof( "|" ), "|" },
{ sizeof( "^" ), "^" },
{ sizeof( "<<" ), "<<" },
{ sizeof( ">>" ), ">>" },
{ sizeof( "&&" ), "&&" },
{ sizeof( "||" ), "||" },
{ sizeof( "==" ), "==" },
{ sizeof( "!=" ), "!=" },
{ sizeof( "<" ), "<" },
{ sizeof( ">" ), ">" },
{ sizeof( "<=" ), "<=" },
{ sizeof( ">=" ), ">=" },
{ sizeof( "[]" ), "[]" },
{ sizeof( "*" ), "*" },
{ sizeof( "&" ), "&" },
{ sizeof( "->" ), "->" },
{ sizeof( "->*" ), "->*" },
{ sizeof( "()" ), "()" },
{ sizeof( "," ), "," },
{ sizeof( "new" ), "new" },
{ sizeof( "new[]" ), "new[]" },
{ sizeof( "delete" ), "delete" },
{ sizeof( "delete[]" ), "delete[]" },
};
return lookup[op];
}
forceinline StrC to_str( Operator op )
{
return operator_to_str( op );
}

108
base/components/gen/especifier.hpp Normal file
View File

@ -0,0 +1,108 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
#pragma once
#include "components/types.hpp"
#endif
// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
enum Specifier : u32
{
Spec_Invalid,
Spec_Consteval,
Spec_Constexpr,
Spec_Constinit,
Spec_Explicit,
Spec_External_Linkage,
Spec_ForceInline,
Spec_Global,
Spec_Inline,
Spec_Internal_Linkage,
Spec_Local_Persist,
Spec_Mutable,
Spec_NeverInline,
Spec_Ptr,
Spec_Ref,
Spec_Register,
Spec_RValue,
Spec_Static,
Spec_Thread_Local,
Spec_Virtual,
Spec_Const,
Spec_Final,
Spec_NoExceptions,
Spec_Override,
Spec_Pure,
Spec_Volatile,
Spec_NumSpecifiers,
Spec_UnderlyingType = 0xffffffffu
};
inline StrC spec_to_str( Specifier type )
{
local_persist StrC lookup[26] = {
{ sizeof( "INVALID" ), "INVALID" },
{ sizeof( "consteval" ), "consteval" },
{ sizeof( "constexpr" ), "constexpr" },
{ sizeof( "constinit" ), "constinit" },
{ sizeof( "explicit" ), "explicit" },
{ sizeof( "extern" ), "extern" },
{ sizeof( "forceinline" ), "forceinline" },
{ sizeof( "global" ), "global" },
{ sizeof( "inline" ), "inline" },
{ sizeof( "internal" ), "internal" },
{ sizeof( "local_persist" ), "local_persist" },
{ sizeof( "mutable" ), "mutable" },
{ sizeof( "neverinline" ), "neverinline" },
{ sizeof( "*" ), "*" },
{ sizeof( "&" ), "&" },
{ sizeof( "register" ), "register" },
{ sizeof( "&&" ), "&&" },
{ sizeof( "static" ), "static" },
{ sizeof( "thread_local" ), "thread_local" },
{ sizeof( "virtual" ), "virtual" },
{ sizeof( "const" ), "const" },
{ sizeof( "final" ), "final" },
{ sizeof( "noexcept" ), "noexcept" },
{ sizeof( "override" ), "override" },
{ sizeof( "= 0" ), "= 0" },
{ sizeof( "volatile" ), "volatile" },
};
return lookup[type];
}
inline bool spec_is_trailing( Specifier specifier )
{
return specifier > Spec_Virtual;
}
inline Specifier strc_to_specifier( StrC str )
{
local_persist u32 keymap[Spec_NumSpecifiers];
do_once_start for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
{
StrC enum_str = spec_to_str( (Specifier)index );
keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 );
}
do_once_end u32 hash = crc32( str.Ptr, str.Len );
for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
{
if ( keymap[index] == hash )
return (Specifier)index;
}
return Spec_Invalid;
}
forceinline StrC to_str( Specifier spec )
{
return spec_to_str( spec );
}
forceinline Specifier to_type( StrC str )
{
return strc_to_specifier( str );
}
forceinline bool is_trailing( Specifier specifier )
{
return spec_is_trailing( specifier );
}

235
base/components/gen/etoktype.cpp Normal file
View File

@ -0,0 +1,235 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
#pragma once
#include "components/types.hpp"
#endif
// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
GEN_NS_PARSER_BEGIN
#define GEN_DEFINE_ATTRIBUTE_TOKENS Entry( Tok_Attribute_API_Export, "GEN_API_Export_Code" ) Entry( Tok_Attribute_API_Import, "GEN_API_Import_Code" )
enum TokType : u32
{
Tok_Invalid,
Tok_Access_Private,
Tok_Access_Protected,
Tok_Access_Public,
Tok_Access_MemberSymbol,
Tok_Access_StaticSymbol,
Tok_Ampersand,
Tok_Ampersand_DBL,
Tok_Assign_Classifer,
Tok_Attribute_Open,
Tok_Attribute_Close,
Tok_BraceCurly_Open,
Tok_BraceCurly_Close,
Tok_BraceSquare_Open,
Tok_BraceSquare_Close,
Tok_Capture_Start,
Tok_Capture_End,
Tok_Comment,
Tok_Comment_End,
Tok_Comment_Start,
Tok_Char,
Tok_Comma,
Tok_Decl_Class,
Tok_Decl_GNU_Attribute,
Tok_Decl_MSVC_Attribute,
Tok_Decl_Enum,
Tok_Decl_Extern_Linkage,
Tok_Decl_Friend,
Tok_Decl_Module,
Tok_Decl_Namespace,
Tok_Decl_Operator,
Tok_Decl_Struct,
Tok_Decl_Template,
Tok_Decl_Typedef,
Tok_Decl_Using,
Tok_Decl_Union,
Tok_Identifier,
Tok_Module_Import,
Tok_Module_Export,
Tok_NewLine,
Tok_Number,
Tok_Operator,
Tok_Preprocess_Hash,
Tok_Preprocess_Define,
Tok_Preprocess_If,
Tok_Preprocess_IfDef,
Tok_Preprocess_IfNotDef,
Tok_Preprocess_ElIf,
Tok_Preprocess_Else,
Tok_Preprocess_EndIf,
Tok_Preprocess_Include,
Tok_Preprocess_Pragma,
Tok_Preprocess_Content,
Tok_Preprocess_Macro,
Tok_Preprocess_Unsupported,
Tok_Spec_Alignas,
Tok_Spec_Const,
Tok_Spec_Consteval,
Tok_Spec_Constexpr,
Tok_Spec_Constinit,
Tok_Spec_Explicit,
Tok_Spec_Extern,
Tok_Spec_Final,
Tok_Spec_ForceInline,
Tok_Spec_Global,
Tok_Spec_Inline,
Tok_Spec_Internal_Linkage,
Tok_Spec_LocalPersist,
Tok_Spec_Mutable,
Tok_Spec_NeverInline,
Tok_Spec_Override,
Tok_Spec_Static,
Tok_Spec_ThreadLocal,
Tok_Spec_Volatile,
Tok_Spec_Virtual,
Tok_Star,
Tok_Statement_End,
Tok_StaticAssert,
Tok_String,
Tok_Type_Typename,
Tok_Type_Unsigned,
Tok_Type_Signed,
Tok_Type_Short,
Tok_Type_Long,
Tok_Type_bool,
Tok_Type_char,
Tok_Type_int,
Tok_Type_double,
Tok_Type_MS_int8,
Tok_Type_MS_int16,
Tok_Type_MS_int32,
Tok_Type_MS_int64,
Tok_Type_MS_W64,
Tok_Varadic_Argument,
Tok___Attributes_Start,
Tok_Attribute_API_Export,
Tok_Attribute_API_Import,
Tok_NumTokens
};
inline StrC toktype_to_str( TokType type )
{
local_persist StrC lookup[] = {
{ sizeof( "__invalid__" ), "__invalid__" },
{ sizeof( "private" ), "private" },
{ sizeof( "protected" ), "protected" },
{ sizeof( "public" ), "public" },
{ sizeof( "." ), "." },
{ sizeof( "::" ), "::" },
{ sizeof( "&" ), "&" },
{ sizeof( "&&" ), "&&" },
{ sizeof( ":" ), ":" },
{ sizeof( "[[" ), "[[" },
{ sizeof( "]]" ), "]]" },
{ sizeof( "{" ), "{" },
{ sizeof( "}" ), "}" },
{ sizeof( "[" ), "[" },
{ sizeof( "]" ), "]" },
{ sizeof( "(" ), "(" },
{ sizeof( ")" ), ")" },
{ sizeof( "__comment__" ), "__comment__" },
{ sizeof( "__comment_end__" ), "__comment_end__" },
{ sizeof( "__comment_start__" ), "__comment_start__" },
{ sizeof( "__character__" ), "__character__" },
{ sizeof( "," ), "," },
{ sizeof( "class" ), "class" },
{ sizeof( "__attribute__" ), "__attribute__" },
{ sizeof( "__declspec" ), "__declspec" },
{ sizeof( "enum" ), "enum" },
{ sizeof( "extern" ), "extern" },
{ sizeof( "friend" ), "friend" },
{ sizeof( "module" ), "module" },
{ sizeof( "namespace" ), "namespace" },
{ sizeof( "operator" ), "operator" },
{ sizeof( "struct" ), "struct" },
{ sizeof( "template" ), "template" },
{ sizeof( "typedef" ), "typedef" },
{ sizeof( "using" ), "using" },
{ sizeof( "union" ), "union" },
{ sizeof( "__identifier__" ), "__identifier__" },
{ sizeof( "import" ), "import" },
{ sizeof( "export" ), "export" },
{ sizeof( "__new_line__" ), "__new_line__" },
{ sizeof( "__number__" ), "__number__" },
{ sizeof( "__operator__" ), "__operator__" },
{ sizeof( "#" ), "#" },
{ sizeof( "define" ), "define" },
{ sizeof( "if" ), "if" },
{ sizeof( "ifdef" ), "ifdef" },
{ sizeof( "ifndef" ), "ifndef" },
{ sizeof( "elif" ), "elif" },
{ sizeof( "else" ), "else" },
{ sizeof( "endif" ), "endif" },
{ sizeof( "include" ), "include" },
{ sizeof( "pragma" ), "pragma" },
{ sizeof( "__macro_content__" ), "__macro_content__" },
{ sizeof( "__macro__" ), "__macro__" },
{ sizeof( "__unsupported__" ), "__unsupported__" },
{ sizeof( "alignas" ), "alignas" },
{ sizeof( "const" ), "const" },
{ sizeof( "consteval" ), "consteval" },
{ sizeof( "constexpr" ), "constexpr" },
{ sizeof( "constinit" ), "constinit" },
{ sizeof( "explicit" ), "explicit" },
{ sizeof( "extern" ), "extern" },
{ sizeof( "final" ), "final" },
{ sizeof( "forceinline" ), "forceinline" },
{ sizeof( "global" ), "global" },
{ sizeof( "inline" ), "inline" },
{ sizeof( "internal" ), "internal" },
{ sizeof( "local_persist" ), "local_persist" },
{ sizeof( "mutable" ), "mutable" },
{ sizeof( "neverinline" ), "neverinline" },
{ sizeof( "override" ), "override" },
{ sizeof( "static" ), "static" },
{ sizeof( "thread_local" ), "thread_local" },
{ sizeof( "volatile" ), "volatile" },
{ sizeof( "virtual" ), "virtual" },
{ sizeof( "*" ), "*" },
{ sizeof( ";" ), ";" },
{ sizeof( "static_assert" ), "static_assert" },
{ sizeof( "__string__" ), "__string__" },
{ sizeof( "typename" ), "typename" },
{ sizeof( "unsigned" ), "unsigned" },
{ sizeof( "signed" ), "signed" },
{ sizeof( "short" ), "short" },
{ sizeof( "long" ), "long" },
{ sizeof( "bool" ), "bool" },
{ sizeof( "char" ), "char" },
{ sizeof( "int" ), "int" },
{ sizeof( "double" ), "double" },
{ sizeof( "__int8" ), "__int8" },
{ sizeof( "__int16" ), "__int16" },
{ sizeof( "__int32" ), "__int32" },
{ sizeof( "__int64" ), "__int64" },
{ sizeof( "_W64" ), "_W64" },
{ sizeof( "..." ), "..." },
{ sizeof( "__attrib_start__" ), "__attrib_start__" },
{ sizeof( "GEN_API_Export_Code" ), "GEN_API_Export_Code" },
{ sizeof( "GEN_API_Import_Code" ), "GEN_API_Import_Code" },
};
return lookup[type];
}
inline TokType strc_to_toktype( StrC str )
{
local_persist u32 keymap[Tok_NumTokens];
do_once_start for ( u32 index = 0; index < Tok_NumTokens; index++ )
{
StrC enum_str = toktype_to_str( (TokType)index );
keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 );
}
do_once_end u32 hash = crc32( str.Ptr, str.Len );
for ( u32 index = 0; index < Tok_NumTokens; index++ )
{
if ( keymap[index] == hash )
return (TokType)index;
}
return Tok_Invalid;
}
GEN_NS_PARSER_END

89
project/components/header_end.hpp → base/components/header_end.hpp
View File

@ -24,8 +24,8 @@
#ifndef GEN_MAX_UNTYPED_STR_LENGTH
# define GEN_MAX_UNTYPED_STR_LENGTH megabytes(1)
#endif
#ifndef GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE
# define GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE kilobytes(4)
#ifndef TokenMap_FixedArena
# define TokenMap_FixedArena FixedArena_8KB
#endif
#ifndef GEN_LEX_ALLOCATOR_SIZE
# define GEN_LEX_ALLOCATOR_SIZE megabytes(4)
@ -42,17 +42,19 @@ constexpr s32 InitSize_DataArrays = 16;
// NOTE: This limits the maximum size of an allocation
// If you are generating a string larger than this, increase the size of the bucket here.
constexpr usize Global_BucketSize = GEN_GLOBAL_BUCKET_SIZE;
constexpr usize Global_BucketSize = GEN_GLOBAL_BUCKET_SIZE;
constexpr s32 CodePool_NumBlocks = GEN_CODEPOOL_NUM_BLOCKS;
constexpr s32 SizePer_StringArena = GEN_SIZE_PER_STRING_ARENA;
constexpr s32 MaxCommentLineLength = GEN_MAX_COMMENT_LINE_LENGTH;
constexpr s32 MaxNameLength = GEN_MAX_NAME_LENGTH;
constexpr s32 MaxUntypedStrLength = GEN_MAX_UNTYPED_STR_LENGTH;
constexpr s32 TokenFmt_TokenMap_MemSize = GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE;
// constexpr s32 TokenFmt_TokenMap_MemSize = GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE;
constexpr s32 LexAllocator_Size = GEN_LEX_ALLOCATOR_SIZE;
constexpr s32 Builder_StrBufferReserve = GEN_BUILDER_STR_BUFFER_RESERVE;
extern StrC enum_underlying_sig;
extern Code access_public;
extern Code access_protected;
extern Code access_private;
@ -67,7 +69,7 @@ extern Code fmt_newline;
extern CodePragma pragma_once;
extern CodeParam param_varadic;
extern CodeParams param_varadic;
extern CodePreprocessCond preprocess_else;
extern CodePreprocessCond preprocess_endif;
@ -97,76 +99,52 @@ extern CodeSpecifiers spec_thread_local;
extern CodeSpecifiers spec_virtual;
extern CodeSpecifiers spec_volatile;
extern CodeType t_empty; // Used with varaidc parameters. (Exposing just in case its useful for another circumstance)
extern CodeType t_auto;
extern CodeType t_void;
extern CodeType t_int;
extern CodeType t_bool;
extern CodeType t_char;
extern CodeType t_wchar_t;
extern CodeType t_class;
extern CodeType t_typename;
extern CodeTypename t_empty; // Used with varaidc parameters. (Exposing just in case its useful for another circumstance)
extern CodeTypename t_auto;
extern CodeTypename t_void;
extern CodeTypename t_int;
extern CodeTypename t_bool;
extern CodeTypename t_char;
extern CodeTypename t_wchar_t;
extern CodeTypename t_class;
extern CodeTypename t_typename;
#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
// Predefined typename codes. Are set to readonly and are setup during gen::init()
extern CodeType t_b32;
extern CodeTypename t_b32;
extern CodeType t_s8;
extern CodeType t_s16;
extern CodeType t_s32;
extern CodeType t_s64;
extern CodeTypename t_s8;
extern CodeTypename t_s16;
extern CodeTypename t_s32;
extern CodeTypename t_s64;
extern CodeType t_u8;
extern CodeType t_u16;
extern CodeType t_u32;
extern CodeType t_u64;
extern CodeTypename t_u8;
extern CodeTypename t_u16;
extern CodeTypename t_u32;
extern CodeTypename t_u64;
extern CodeType t_ssize;
extern CodeType t_usize;
extern CodeTypename t_ssize;
extern CodeTypename t_usize;
extern CodeType t_f32;
extern CodeType t_f64;
extern CodeTypename t_f32;
extern CodeTypename t_f64;
#endif
#pragma endregion Constants
#pragma region Macros
# define gen_main main
# define __ NoCode
// Convienence for defining any name used with the gen api.
// Lets you provide the length and string literal to the functions without the need for the DSL.
# define name( Id_ ) { sizeof(stringize( Id_ )) - 1, stringize(Id_) }
// Same as name just used to indicate intention of literal for code instead of names.
# define code( ... ) { sizeof(stringize(__VA_ARGS__)) - 1, stringize( __VA_ARGS__ ) }
# define args( ... ) num_args( __VA_ARGS__ ), __VA_ARGS__
# define code_str( ... ) GEN_NS untyped_str( code( __VA_ARGS__ ) )
# define code_fmt( ... ) GEN_NS untyped_str( token_fmt( __VA_ARGS__ ) )
// Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC of the formatted string.
# define token_fmt( ... ) GEN_NS token_fmt_impl( (num_args( __VA_ARGS__ ) + 1) / 2, __VA_ARGS__ )
#pragma endregion Macros
// Used by the lexer to persistently treat all these identifiers as preprocessor defines.
// Populate with strings via gen::get_cached_string.
// Functional defines must have format: id( ;at minimum to indicate that the define is only valid with arguments.
extern Array< StringCached > PreprocessorDefines;
extern Array(StringCached) PreprocessorDefines;
#ifdef GEN_EXPOSE_BACKEND
// Global allocator used for data with process lifetime.
extern AllocatorInfo GlobalAllocator;
extern Array< Arena > Global_AllocatorBuckets;
extern Array(Arena) Global_AllocatorBuckets;
extern Array< Pool > CodePools;
extern Array< Arena > StringArenas;
extern Array(Pool) CodePools;
extern Array(Arena) StringArenas;
extern StringTable StringCache;
@ -178,5 +156,4 @@ extern Array< StringCached > PreprocessorDefines;
extern AllocatorInfo Allocator_StringArena;
extern AllocatorInfo Allocator_StringTable;
extern AllocatorInfo Allocator_TypeTable;
#endif

32
base/components/header_start.hpp Normal file
View File

@ -0,0 +1,32 @@
#pragma once
/*
gencpp: An attempt at "simple" staged metaprogramming for c/c++.
See Readme.md for more information from the project repository.
Public Address:
https://github.com/Ed94/gencpp --------------------------------------------------------------.
| _____ _____ _ _ |
| / ____) / ____} | | | |
| | / ___ ___ _ __ ___ _ __ _ __ | {___ | |__ _ _, __ _, ___ __| | |
| | |{_ |/ _ \ '_ \ / __} '_ l| '_ l `\___ \| __/ _` |/ _` |/ _ \/ _` | |
| | l__j | ___/ | | | {__; |+l } |+l | ____) | l| (_| | {_| | ___/ (_| | |
| \_____|\___}_l |_|\___} ,__/| ,__/ (_____/ \__\__/_|\__, |\___}\__,_l |
| | | | | __} | |
| l_l l_l {___/ |
! ----------------------------------------------------------------------- VERSION: v0.20-Alpha |
! ============================================================================================ |
! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION |
! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL |
! ============================================================================================ /
*/
#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
# error Gen.hpp : GEN_TIME not defined
#endif
//! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
#ifndef GEN_ROLL_OWN_DEPENDENCIES
# include "gen.dep.hpp"
#endif

414
base/components/inlines.hpp Normal file
View File

@ -0,0 +1,414 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
#pragma once
#include "interface.hpp"
#endif
#pragma region Code
inline
void code_append( Code self, Code other )
{
GEN_ASSERT(self);
GEN_ASSERT(other);
GEN_ASSERT_MSG(self != other, "Attempted to recursively append Code AST to itself.");
if ( other->Parent != nullptr )
other = code_duplicate(other);
other->Parent = self;
if ( self->Front == nullptr )
{
self->Front = other;
self->Back = other;
self->NumEntries++;
return;
}
Code
Current = self->Back;
Current->Next = other;
other->Prev = Current;
self->Back = other;
self->NumEntries++;
}
inline
bool code_is_body(Code self)
{
GEN_ASSERT(self);
switch (self->Type)
{
case CT_Enum_Body:
case CT_Class_Body:
case CT_Union_Body:
case CT_Export_Body:
case CT_Global_Body:
case CT_Struct_Body:
case CT_Function_Body:
case CT_Namespace_Body:
case CT_Extern_Linkage_Body:
return true;
}
return false;
}
inline
Code* code_entry( Code self, u32 idx )
{
GEN_ASSERT(self != nullptr);
Code* current = & self->Front;
while ( idx >= 0 && current != nullptr )
{
if ( idx == 0 )
return rcast( Code*, current);
current = & ( * current )->Next;
idx--;
}
return rcast( Code*, current);
}
forceinline
bool code_is_valid(Code self)
{
GEN_ASSERT(self);
return self != nullptr && self->Type != CT_Invalid;
}
forceinline
bool code_has_entries(AST* self)
{
GEN_ASSERT(self);
return self->NumEntries > 0;
}
forceinline
void code_set_global(Code self)
{
if ( self == nullptr )
{
log_failure("Code::set_global: Cannot set code as global, AST is null!");
return;
}
self->Parent = Code_Global;
}
#if GEN_COMPILER_CPP
forceinline
Code& Code::operator ++()
{
if ( ast )
ast = ast->Next.ast;
return * this;
}
#endif
forceinline
StrC code_type_str(Code self)
{
GEN_ASSERT(self != nullptr);
return codetype_to_str( self->Type );
}
#pragma endregion Code
#pragma region CodeBody
inline
void body_append( CodeBody self, Code other )
{
GEN_ASSERT(self);
GEN_ASSERT(other);
if (code_is_body(other)) {
body_append_body( self, cast(CodeBody, other) );
return;
}
code_append( cast(Code, self), other );
}
inline
void body_append_body( CodeBody self, CodeBody body )
{
GEN_ASSERT(self);
GEN_ASSERT(body);
GEN_ASSERT_MSG(self != body, "Attempted to append body to itself.");
for ( Code entry = begin_CodeBody(body); entry != end_CodeBody(body); entry = next_CodeBody(body, entry) ) {
body_append( self, entry );
}
}
inline
Code begin_CodeBody( CodeBody body) {
GEN_ASSERT(body);
if ( body != nullptr )
return body->Front;
return NullCode;
}
forceinline
Code end_CodeBody(CodeBody body ){
GEN_ASSERT(body);
return body->Back->Next;
}
inline
Code next_CodeBody(CodeBody body, Code entry) {
GEN_ASSERT(body);
GEN_ASSERT(entry);
return entry->Next;
}
#pragma endregion CodeBody
#pragma region CodeClass
inline
void class_add_interface( CodeClass self, CodeTypename type )
{
GEN_ASSERT(self);
GEN_ASSERT(type);
CodeTypename possible_slot = self->ParentType;
if ( possible_slot != nullptr )
{
// Were adding an interface to parent type, so we need to make sure the parent type is public.
self->ParentAccess = AccessSpec_Public;
// If your planning on adding a proper parent,
// then you'll need to move this over to ParentType->next and update ParentAccess accordingly.
}
while ( possible_slot != nullptr )
{
possible_slot = cast(CodeTypename, possible_slot->Next);
}
possible_slot = type;
}
#pragma endregion CodeClass
#pragma region CodeParams
inline
void params_append( CodeParams appendee, CodeParams other )
{
GEN_ASSERT(appendee);
GEN_ASSERT(other);
GEN_ASSERT_MSG(appendee != other, "Attempted to append parameter to itself.");
Code self = cast(Code, appendee);
Code entry = cast(Code, other);
if ( entry->Parent != nullptr )
entry = code_duplicate( entry );
entry->Parent = self;
if ( self->Last == nullptr )
{
self->Last = entry;
self->Next = entry;
self->NumEntries++;
return;
}
self->Last->Next = entry;
self->Last = entry;
self->NumEntries++;
}
inline
CodeParams params_get(CodeParams self, s32 idx )
{
GEN_ASSERT(self);
CodeParams param = self;
do
{
if ( ++ param != nullptr )
return NullCode;
param = cast(CodeParams, cast(Code, param)->Next);
}
while ( --idx );
return param;
}
forceinline
bool params_has_entries(CodeParams self)
{
GEN_ASSERT(self);
return self->NumEntries > 0;
}
#if GEN_COMPILER_CPP
forceinline
CodeParams& CodeParams::operator ++()
{
* this = ast->Next;
return * this;
}
#endif
forceinline
CodeParams begin_CodeParams(CodeParams params)
{
if ( params != nullptr )
return params;
return NullCode;
}
forceinline
CodeParams end_CodeParams(CodeParams params)
{
// return { (AST_Params*) rcast( AST*, ast)->Last };
return NullCode;
}
forceinline
CodeParams next_CodeParams(CodeParams params, CodeParams param_iter)
{
GEN_ASSERT(param_iter);
return param_iter->Next;
}
#pragma endregion CodeParams
#pragma region CodeSpecifiers
inline
bool specifiers_append(CodeSpecifiers self, Specifier spec )
{
if ( self == nullptr )
{
log_failure("CodeSpecifiers: Attempted to append to a null specifiers AST!");
return false;
}
if ( self->NumEntries == AST_ArrSpecs_Cap )
{
log_failure("CodeSpecifiers: Attempted to append over %d specifiers to a specifiers AST!", AST_ArrSpecs_Cap );
return false;
}
self->ArrSpecs[ self->NumEntries ] = spec;
self->NumEntries++;
return true;
}
inline
s32 specifiers_has(CodeSpecifiers self, Specifier spec)
{
GEN_ASSERT(self != nullptr);
for ( s32 idx = 0; idx < self->NumEntries; idx++ ) {
if ( self->ArrSpecs[ idx ] == spec )
return idx;
}
return -1;
}
inline
s32 specifiers_remove( CodeSpecifiers self, Specifier to_remove )
{
if ( self == nullptr )
{
log_failure("CodeSpecifiers: Attempted to append to a null specifiers AST!");
return -1;
}
if ( self->NumEntries == AST_ArrSpecs_Cap )
{
log_failure("CodeSpecifiers: Attempted to append over %d specifiers to a specifiers AST!", AST_ArrSpecs_Cap );
return -1;
}
s32 result = -1;
s32 curr = 0;
s32 next = 0;
for(; next < self->NumEntries; ++ curr, ++ next)
{
Specifier spec = self->ArrSpecs[next];
if (spec == to_remove)
{
result = next;
next ++;
if (next >= self->NumEntries)
break;
spec = self->ArrSpecs[next];
}
self->ArrSpecs[ curr ] = spec;
}
if (result > -1) {
self->NumEntries --;
}
return result;
}
forceinline
Specifier* begin_CodeSpecifiers(CodeSpecifiers self)
{
if ( self != nullptr )
return & self->ArrSpecs[0];
return nullptr;
}
forceinline
Specifier* end_CodeSpecifiers(CodeSpecifiers self)
{
return self->ArrSpecs + self->NumEntries;
}
forceinline
Specifier* next_CodeSpecifiers(CodeSpecifiers self, Specifier* spec_iter)
{
return spec_iter + 1;
}
#pragma endregion CodeSpecifiers
#pragma region CodeStruct
inline
void struct_add_interface(CodeStruct self, CodeTypename type )
{
CodeTypename possible_slot = self->ParentType;
if ( possible_slot != nullptr )
{
// Were adding an interface to parent type, so we need to make sure the parent type is public.
self->ParentAccess = AccessSpec_Public;
// If your planning on adding a proper parent,
// then you'll need to move this over to ParentType->next and update ParentAccess accordingly.
}
while ( possible_slot != nullptr )
{
possible_slot = cast(CodeTypename, possible_slot->Next);
}
possible_slot = type;
}
#pragma endregion Code
#pragma region Interface
inline
CodeBody def_body( CodeType type )
{
switch ( type )
{
case CT_Class_Body:
case CT_Enum_Body:
case CT_Export_Body:
case CT_Extern_Linkage:
case CT_Function_Body:
case CT_Global_Body:
case CT_Namespace_Body:
case CT_Struct_Body:
case CT_Union_Body:
break;
default:
log_failure( "def_body: Invalid type %s", codetype_to_str(type).Ptr );
return (CodeBody)Code_Invalid;
}
Code
result = make_code();
result->Type = type;
return (CodeBody)result;
}
inline
StrC token_fmt_impl( ssize num, ... )
{
local_persist thread_local
char buf[GEN_PRINTF_MAXLEN] = { 0 };
mem_set( buf, 0, GEN_PRINTF_MAXLEN );
va_list va;
va_start(va, num );
ssize result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
va_end(va);
StrC str = { result, buf };
return str;
}
#pragma endregion Interface

462
base/components/interface.cpp Normal file
View File

@ -0,0 +1,462 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
#pragma once
#include "code_serialization.cpp"
#endif
GEN_NS_PARSER_BEGIN
internal void parser_init();
internal void parser_deinit();
GEN_NS_PARSER_END
internal
void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
{
Arena* last = array_back(Global_AllocatorBuckets);
switch ( type )
{
case EAllocation_ALLOC:
{
if ( ( last->TotalUsed + size ) > last->TotalSize )
{
Arena bucket = arena_init_from_allocator( heap(), Global_BucketSize );
if ( bucket.PhysicalStart == nullptr )
GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
if ( ! array_append( Global_AllocatorBuckets, bucket ) )
GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
last = array_back(Global_AllocatorBuckets);
}
return alloc_align( arena_allocator_info(last), size, alignment );
}
case EAllocation_FREE:
{
// Doesn't recycle.
}
break;
case EAllocation_FREE_ALL:
{
// Memory::cleanup instead.
}
break;
case EAllocation_RESIZE:
{
if ( last->TotalUsed + size > last->TotalSize )
{
Arena bucket = arena_init_from_allocator( heap(), Global_BucketSize );
if ( bucket.PhysicalStart == nullptr )
GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
if ( ! array_append( Global_AllocatorBuckets, bucket ) )
GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
last = array_back(Global_AllocatorBuckets);
}
void* result = alloc_align( last->Backing, size, alignment );
if ( result != nullptr && old_memory != nullptr )
{
mem_copy( result, old_memory, old_size );
}
return result;
}
}
return nullptr;
}
internal
void define_constants()
{
Code_Global = make_code();
Code_Global->Name = get_cached_string( txt("Global Code") );
Code_Global->Content = Code_Global->Name;
Code_Invalid = make_code();
code_set_global(Code_Invalid);
t_empty = (CodeTypename) make_code();
t_empty->Type = CT_Typename;
t_empty->Name = get_cached_string( txt("") );
code_set_global(cast(Code, t_empty));
access_private = make_code();
access_private->Type = CT_Access_Private;
access_private->Name = get_cached_string( txt("private:\n") );
code_set_global(cast(Code, access_private));
access_protected = make_code();
access_protected->Type = CT_Access_Protected;
access_protected->Name = get_cached_string( txt("protected:\n") );
code_set_global(access_protected);
access_public = make_code();
access_public->Type = CT_Access_Public;
access_public->Name = get_cached_string( txt("public:\n") );
code_set_global(access_public);
StrC api_export_str = code(GEN_API_Export_Code);
attrib_api_export = def_attributes( api_export_str );
code_set_global(cast(Code, attrib_api_export));
StrC api_import_str = code(GEN_API_Import_Code);
attrib_api_import = def_attributes( api_import_str );
code_set_global(cast(Code, attrib_api_import));
module_global_fragment = make_code();
module_global_fragment->Type = CT_Untyped;
module_global_fragment->Name = get_cached_string( txt("module;") );
module_global_fragment->Content = module_global_fragment->Name;
code_set_global(cast(Code, module_global_fragment));
module_private_fragment = make_code();
module_private_fragment->Type = CT_Untyped;
module_private_fragment->Name = get_cached_string( txt("module : private;") );
module_private_fragment->Content = module_private_fragment->Name;
code_set_global(cast(Code, module_private_fragment));
fmt_newline = make_code();
fmt_newline->Type = CT_NewLine;
code_set_global((Code)fmt_newline);
pragma_once = (CodePragma) make_code();
pragma_once->Type = CT_Preprocess_Pragma;
pragma_once->Name = get_cached_string( txt("once") );
pragma_once->Content = pragma_once->Name;
code_set_global((Code)pragma_once);
param_varadic = (CodeParams) make_code();
param_varadic->Type = CT_Parameters;
param_varadic->Name = get_cached_string( txt("...") );
param_varadic->ValueType = t_empty;
code_set_global((Code)param_varadic);
preprocess_else = (CodePreprocessCond) make_code();
preprocess_else->Type = CT_Preprocess_Else;
code_set_global((Code)preprocess_else);
preprocess_endif = (CodePreprocessCond) make_code();
preprocess_endif->Type = CT_Preprocess_EndIf;
code_set_global((Code)preprocess_endif);
# define def_constant_code_type( Type_ ) \
do \
{ \
StrC name_str = name(Type_); \
t_##Type_ = def_type( name_str ); \
code_set_global( cast(Code, t_##Type_)); \
} while(0)
def_constant_code_type( auto );
def_constant_code_type( void );
def_constant_code_type( int );
def_constant_code_type( bool );
def_constant_code_type( char );
def_constant_code_type( wchar_t );
def_constant_code_type( class );
def_constant_code_type( typename );
#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
t_b32 = def_type( name(b32) );
def_constant_code_type( s8 );
def_constant_code_type( s16 );
def_constant_code_type( s32 );
def_constant_code_type( s64 );
def_constant_code_type( u8 );
def_constant_code_type( u16 );
def_constant_code_type( u32 );
def_constant_code_type( u64 );
def_constant_code_type( ssize );
def_constant_code_type( usize );
def_constant_code_type( f32 );
def_constant_code_type( f64 );
#endif
# undef def_constant_code_type
spec_const = def_specifier( Spec_Const); code_set_global( cast(Code, spec_const ));
spec_consteval = def_specifier( Spec_Consteval); code_set_global( cast(Code, spec_consteval ));;
spec_constexpr = def_specifier( Spec_Constexpr); code_set_global( cast(Code, spec_constexpr ));;
spec_constinit = def_specifier( Spec_Constinit); code_set_global( cast(Code, spec_constinit ));;
spec_extern_linkage = def_specifier( Spec_External_Linkage); code_set_global( cast(Code, spec_extern_linkage ));;
spec_final = def_specifier( Spec_Final); code_set_global( cast(Code, spec_final ));;
spec_forceinline = def_specifier( Spec_ForceInline); code_set_global( cast(Code, spec_forceinline ));;
spec_global = def_specifier( Spec_Global); code_set_global( cast(Code, spec_global ));;
spec_inline = def_specifier( Spec_Inline); code_set_global( cast(Code, spec_inline ));;
spec_internal_linkage = def_specifier( Spec_Internal_Linkage); code_set_global( cast(Code, spec_internal_linkage ));;
spec_local_persist = def_specifier( Spec_Local_Persist); code_set_global( cast(Code, spec_local_persist ));;
spec_mutable = def_specifier( Spec_Mutable); code_set_global( cast(Code, spec_mutable ));;
spec_neverinline = def_specifier( Spec_NeverInline); code_set_global( cast(Code, spec_neverinline ));;
spec_noexcept = def_specifier( Spec_NoExceptions); code_set_global( cast(Code, spec_noexcept ));;
spec_override = def_specifier( Spec_Override); code_set_global( cast(Code, spec_override ));;
spec_ptr = def_specifier( Spec_Ptr); code_set_global( cast(Code, spec_ptr ));;
spec_pure = def_specifier( Spec_Pure); code_set_global( cast(Code, spec_pure ));
spec_ref = def_specifier( Spec_Ref); code_set_global( cast(Code, spec_ref ));;
spec_register = def_specifier( Spec_Register); code_set_global( cast(Code, spec_register ));;
spec_rvalue = def_specifier( Spec_RValue); code_set_global( cast(Code, spec_rvalue ));;
spec_static_member = def_specifier( Spec_Static); code_set_global( cast(Code, spec_static_member ));;
spec_thread_local = def_specifier( Spec_Thread_Local); code_set_global( cast(Code, spec_thread_local ));;
spec_virtual = def_specifier( Spec_Virtual); code_set_global( cast(Code, spec_virtual ));;
spec_volatile = def_specifier( Spec_Volatile); code_set_global( cast(Code, spec_volatile ));
spec_local_persist = def_specifiers( 1, Spec_Local_Persist );
code_set_global(cast(Code, spec_local_persist));
if (enum_underlying_sig.Len == 0) {
enum_underlying_sig = txt("enum_underlying(");
}
array_append(PreprocessorDefines, enum_underlying_sig);
# undef def_constant_spec
}
void init()
{
// Setup global allocator
{
AllocatorInfo becasue_C = { & Global_Allocator_Proc, nullptr };
GlobalAllocator = becasue_C;
Global_AllocatorBuckets = array_init_reserve(Arena, heap(), 128 );
if ( Global_AllocatorBuckets == nullptr )
GEN_FATAL( "Failed to reserve memory for Global_AllocatorBuckets");
Arena bucket = arena_init_from_allocator( heap(), Global_BucketSize );
if ( bucket.PhysicalStart == nullptr )
GEN_FATAL( "Failed to create first bucket for Global_AllocatorBuckets");
array_append( Global_AllocatorBuckets, bucket );
}
if (Allocator_DataArrays.Proc == nullptr) {
Allocator_DataArrays = GlobalAllocator;
}
if (Allocator_CodePool.Proc == nullptr ) {
Allocator_CodePool = GlobalAllocator;
}
if (Allocator_Lexer.Proc == nullptr) {
Allocator_Lexer = GlobalAllocator;
}
if (Allocator_StringArena.Proc == nullptr) {
Allocator_StringArena = GlobalAllocator;
}
if (Allocator_StringTable.Proc == nullptr) {
Allocator_StringTable = GlobalAllocator;
}
if (Allocator_TypeTable.Proc == nullptr) {
Allocator_TypeTable = GlobalAllocator;
}
// Setup the arrays
{
CodePools = array_init_reserve(Pool, Allocator_DataArrays, InitSize_DataArrays );
if ( CodePools == nullptr )
GEN_FATAL( "gen::init: Failed to initialize the CodePools array" );
StringArenas = array_init_reserve(Arena, Allocator_DataArrays, InitSize_DataArrays );
if ( StringArenas == nullptr )
GEN_FATAL( "gen::init: Failed to initialize the StringArenas array" );
}
// Setup the code pool and code entries arena.
{
Pool code_pool = pool_init( Allocator_CodePool, CodePool_NumBlocks, sizeof(AST) );
if ( code_pool.PhysicalStart == nullptr )
GEN_FATAL( "gen::init: Failed to initialize the code pool" );
array_append( CodePools, code_pool );
LexArena = arena_init_from_allocator( Allocator_Lexer, LexAllocator_Size );
Arena string_arena = arena_init_from_allocator( Allocator_StringArena, SizePer_StringArena );
if ( string_arena.PhysicalStart == nullptr )
GEN_FATAL( "gen::init: Failed to initialize the string arena" );
array_append( StringArenas, string_arena );
}
// Setup the hash tables
{
StringCache = hashtable_init(StringCached, Allocator_StringTable);
if ( StringCache.Entries == nullptr )
GEN_FATAL( "gen::init: Failed to initialize the StringCache");
}
// Preprocessor Defines
PreprocessorDefines = array_init_reserve(StringCached, GlobalAllocator, kilobytes(1) );
define_constants();
GEN_NS_PARSER parser_init();
}
void deinit()
{
usize index = 0;
usize left = array_num(CodePools);
do
{
Pool* code_pool = & CodePools[index];
pool_free(code_pool);
index++;
}
while ( left--, left );
index = 0;
left = array_num(StringArenas);
do
{
Arena* string_arena = & StringArenas[index];
arena_free(string_arena);
index++;
}
while ( left--, left );
hashtable_destroy(StringCache);
array_free( CodePools);
array_free( StringArenas);
arena_free(& LexArena);
array_free(PreprocessorDefines);
index = 0;
left = array_num(Global_AllocatorBuckets);
do
{
Arena* bucket = & Global_AllocatorBuckets[ index ];
arena_free(bucket);
index++;
}
while ( left--, left );
array_free(Global_AllocatorBuckets);
GEN_NS_PARSER parser_deinit();
}
void reset()
{
s32 index = 0;
s32 left = array_num(CodePools);
do
{
Pool* code_pool = & CodePools[index];
pool_clear(code_pool);
index++;
}
while ( left--, left );
index = 0;
left = array_num(StringArenas);
do
{
Arena* string_arena = & StringArenas[index];
string_arena->TotalUsed = 0;;
index++;
}
while ( left--, left );
hashtable_clear(StringCache);
define_constants();
}
AllocatorInfo get_string_allocator( s32 str_length )
{
Arena* last = array_back(StringArenas);
usize size_req = str_length + sizeof(StringHeader) + sizeof(char*);
if ( last->TotalUsed + scast(ssize, size_req) > last->TotalSize )
{
Arena new_arena = arena_init_from_allocator( Allocator_StringArena, SizePer_StringArena );
if ( ! array_append( StringArenas, new_arena ) )
GEN_FATAL( "gen::get_string_allocator: Failed to allocate a new string arena" );
last = array_back(StringArenas);
}
return arena_allocator_info(last);
}
// Will either make or retrive a code string.
StringCached get_cached_string( StrC str )
{
s32 hash_length = str.Len > kilobytes(1) ? kilobytes(1) : str.Len;
u64 key = crc32( str.Ptr, hash_length );
{
StringCached* result = hashtable_get(StringCache, key );
if ( result )
return * result;
}
StrC result = string_to_strc( string_make_strc( get_string_allocator( str.Len ), str ));
hashtable_set(StringCache, key, result );
return result;
}
// Used internally to retireve a Code object form the CodePool.
Code make_code()
{
Pool* allocator = array_back( CodePools);
if ( allocator->FreeList == nullptr )
{
Pool code_pool = pool_init( Allocator_CodePool, CodePool_NumBlocks, sizeof(AST) );
if ( code_pool.PhysicalStart == nullptr )
GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePool allcoator returned nullptr." );
if ( ! array_append( CodePools, code_pool ) )
GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePools failed to append new pool." );
allocator = array_back( CodePools);
}
Code result = { rcast( AST*, alloc( pool_allocator_info(allocator), sizeof(AST) )) };
mem_set( rcast(void*, cast(AST*, result)), 0, sizeof(AST) );
return result;
}
void set_allocator_data_arrays( AllocatorInfo allocator )
{
Allocator_DataArrays = allocator;
}
void set_allocator_code_pool( AllocatorInfo allocator )
{
Allocator_CodePool = allocator;
}
void set_allocator_lexer( AllocatorInfo allocator )
{
Allocator_Lexer = allocator;
}
void set_allocator_string_arena( AllocatorInfo allocator )
{
Allocator_StringArena = allocator;
}
void set_allocator_string_table( AllocatorInfo allocator )
{
Allocator_StringArena = allocator;
}

347
base/components/interface.hpp Normal file
View File

@ -0,0 +1,347 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
#pragma once
#include "ast_types.hpp"
#endif
#pragma region Gen Interface
/*
/ \ | \ | \ / \
| ▓▓▓▓▓▓\ ______ _______ \▓▓▓▓▓▓_______ _| ▓▓_ ______ ______ | ▓▓▓▓▓▓\ ______ _______ ______
| ▓▓ __\▓▓/ \| \ | ▓▓ | \| ▓▓ \ / \ / \| ▓▓_ \▓▓| \ / \/ \
| ▓▓| \ ▓▓▓▓▓▓\ ▓▓▓▓▓▓▓\ | ▓▓ | ▓▓▓▓▓▓▓\\▓▓▓▓▓▓ | ▓▓▓▓▓▓\ ▓▓▓▓▓▓\ ▓▓ \ \▓▓▓▓▓▓\ ▓▓▓▓▓▓▓ ▓▓▓▓▓▓\
| ▓▓ \▓▓▓▓ ▓▓ ▓▓ ▓▓ | ▓▓ | ▓▓ | ▓▓ | ▓▓ | ▓▓ __| ▓▓ ▓▓ ▓▓ \▓▓ ▓▓▓▓ / ▓▓ ▓▓ | ▓▓ ▓▓
| ▓▓__| ▓▓ ▓▓▓▓▓▓▓▓ ▓▓ | ▓▓ _| ▓▓_| ▓▓ | ▓▓ | ▓▓| \ ▓▓▓▓▓▓▓▓ ▓▓ | ▓▓ | ▓▓▓▓▓▓▓ ▓▓_____| ▓▓▓▓▓▓▓▓
\▓▓ ▓▓\▓▓ \ ▓▓ | ▓▓ | ▓▓ \ ▓▓ | ▓▓ \▓▓ ▓▓\▓▓ \ ▓▓ | ▓▓ \▓▓ ▓▓\▓▓ \\▓▓ \
\▓▓▓▓▓▓ \▓▓▓▓▓▓▓\▓▓ \▓▓ \▓▓▓▓▓▓\▓▓ \▓▓ \▓▓▓▓ \▓▓▓▓▓▓▓\▓▓ \▓▓ \▓▓▓▓▓▓▓ \▓▓▓▓▓▓▓ \▓▓▓▓▓▓▓
*/
// Initialize the library.
void init();
// Currently manually free's the arenas, code for checking for leaks.
// However on Windows at least, it doesn't need to occur as the OS will clean up after the process.
void deinit();
// Clears the allocations, but doesn't return to the heap, the calls init() again.
// Ease of use.
void reset();
// Used internally to retrive or make string allocations.
// Strings are stored in a series of string arenas of fixed size (SizePer_StringArena)
StringCached get_cached_string( StrC str );
/*
This provides a fresh Code AST.
The gen interface use this as their method from getting a new AST object from the CodePool.
Use this if you want to make your own API for formatting the supported Code Types.
*/
Code make_code();
// Set these before calling gen's init() procedure.
void set_allocator_data_arrays ( AllocatorInfo data_array_allocator );
void set_allocator_code_pool ( AllocatorInfo pool_allocator );
void set_allocator_lexer ( AllocatorInfo lex_allocator );
void set_allocator_string_arena( AllocatorInfo string_allocator );
void set_allocator_string_table( AllocatorInfo string_allocator );
void set_allocator_type_table ( AllocatorInfo type_reg_allocator );
#pragma region Upfront
CodeAttributes def_attributes( StrC content );
CodeComment def_comment ( StrC content );
struct Opts_def_struct {
CodeBody body;
CodeTypename parent;
AccessSpec parent_access;
CodeAttributes attributes;
CodeTypename* interfaces;
s32 num_interfaces;
ModuleFlag mflags;
};
CodeClass def_class( StrC name, Opts_def_struct opts GEN_PARAM_DEFAULT );
struct Opts_def_constructor {
CodeParams params;
Code initializer_list;
Code body;
};
CodeConstructor def_constructor( Opts_def_constructor opts GEN_PARAM_DEFAULT );
struct Opts_def_define {
b32 dont_append_preprocess_defines;
};
CodeDefine def_define( StrC name, StrC content, Opts_def_define opts GEN_PARAM_DEFAULT );
struct Opts_def_destructor {
Code body;
CodeSpecifiers specifiers;
};
CodeDestructor def_destructor( Opts_def_destructor opts GEN_PARAM_DEFAULT );
struct Opts_def_enum {
CodeBody body;
CodeTypename type;
EnumT specifier;
CodeAttributes attributes;
ModuleFlag mflags;
Code type_macro;
};
CodeEnum def_enum( StrC name, Opts_def_enum opts GEN_PARAM_DEFAULT );
CodeExec def_execution ( StrC content );
CodeExtern def_extern_link( StrC name, CodeBody body );
CodeFriend def_friend ( Code symbol );
struct Opts_def_function {
CodeParams params;
CodeTypename ret_type;
CodeBody body;
CodeSpecifiers specs;
CodeAttributes attrs;
ModuleFlag mflags;
};
CodeFn def_function( StrC name, Opts_def_function opts GEN_PARAM_DEFAULT );
struct Opts_def_include { b32 foreign; };
struct Opts_def_module { ModuleFlag mflags; };
struct Opts_def_namespace { ModuleFlag mflags; };
CodeInclude def_include ( StrC content, Opts_def_include opts GEN_PARAM_DEFAULT );
CodeModule def_module ( StrC name, Opts_def_module opts GEN_PARAM_DEFAULT );
CodeNS def_namespace( StrC name, CodeBody body, Opts_def_namespace opts GEN_PARAM_DEFAULT );
struct Opts_def_operator {
CodeParams params;
CodeTypename ret_type;
CodeBody body;
CodeSpecifiers specifiers;
CodeAttributes attributes;
ModuleFlag mflags;
};
CodeOperator def_operator( Operator op, StrC nspace, Opts_def_operator opts GEN_PARAM_DEFAULT );
struct Opts_def_operator_cast {
CodeBody body;
CodeSpecifiers specs;
};
CodeOpCast def_operator_cast( CodeTypename type, Opts_def_operator_cast opts GEN_PARAM_DEFAULT );
struct Opts_def_param { Code value; };
CodeParams def_param ( CodeTypename type, StrC name, Opts_def_param opts GEN_PARAM_DEFAULT );
CodePragma def_pragma( StrC directive );
CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC content );
CodeSpecifiers def_specifier( Specifier specifier );
CodeStruct def_struct( StrC name, Opts_def_struct opts GEN_PARAM_DEFAULT );
struct Opts_def_template { ModuleFlag mflags; };
CodeTemplate def_template( CodeParams params, Code definition, Opts_def_template opts GEN_PARAM_DEFAULT );
struct Opts_def_type {
ETypenameTag type_tag;
Code arrayexpr;
CodeSpecifiers specifiers;
CodeAttributes attributes;
};
CodeTypename def_type( StrC name, Opts_def_type opts GEN_PARAM_DEFAULT );
struct Opts_def_typedef {
CodeAttributes attributes;
ModuleFlag mflags;
};
CodeTypedef def_typedef( StrC name, Code type, Opts_def_typedef opts GEN_PARAM_DEFAULT );
struct Opts_def_union {
CodeAttributes attributes;
ModuleFlag mflags;
};
CodeUnion def_union( StrC name, CodeBody body, Opts_def_union opts GEN_PARAM_DEFAULT );
struct Opts_def_using {
CodeAttributes attributes;
ModuleFlag mflags;
};
CodeUsing def_using( StrC name, CodeTypename type, Opts_def_using opts GEN_PARAM_DEFAULT );
CodeUsing def_using_namespace( StrC name );
struct Opts_def_variable
{
Code value;
CodeSpecifiers specifiers;
CodeAttributes attributes;
ModuleFlag mflags;
};
CodeVar def_variable( CodeTypename type, StrC name, Opts_def_variable opts GEN_PARAM_DEFAULT );
// Constructs an empty body. Use AST::validate_body() to check if the body is was has valid entries.
CodeBody def_body( CodeType type );
// There are two options for defining a struct body, either varadically provided with the args macro to auto-deduce the arg num,
/// or provide as an array of Code objects.
CodeBody def_class_body ( s32 num, ... );
CodeBody def_class_body ( s32 num, Code* codes );
CodeBody def_enum_body ( s32 num, ... );
CodeBody def_enum_body ( s32 num, Code* codes );
CodeBody def_export_body ( s32 num, ... );
CodeBody def_export_body ( s32 num, Code* codes);
CodeBody def_extern_link_body( s32 num, ... );
CodeBody def_extern_link_body( s32 num, Code* codes );
CodeBody def_function_body ( s32 num, ... );
CodeBody def_function_body ( s32 num, Code* codes );
CodeBody def_global_body ( s32 num, ... );
CodeBody def_global_body ( s32 num, Code* codes );
CodeBody def_namespace_body ( s32 num, ... );
CodeBody def_namespace_body ( s32 num, Code* codes );
CodeParams def_params ( s32 num, ... );
CodeParams def_params ( s32 num, CodeParams* params );
CodeSpecifiers def_specifiers ( s32 num, ... );
CodeSpecifiers def_specifiers ( s32 num, Specifier* specs );
CodeBody def_struct_body ( s32 num, ... );
CodeBody def_struct_body ( s32 num, Code* codes );
CodeBody def_union_body ( s32 num, ... );
CodeBody def_union_body ( s32 num, Code* codes );
#pragma endregion Upfront
#pragma region Parsing
// TODO(Ed) : Implmeent the new parser API design.
#if 0
GEN_NS_PARSER_BEGIN
struct StackNode
{
StackNode* Prev;
Token Start;
Token Name; // The name of the AST node (if parsed)
StrC FailedProc; // The name of the procedure that failed
};
// Stack nodes are allocated the error's allocator
struct Error
{
String message;
StackNode* context_stack;
};
GEN_NS_PARSER_END
struct ParseInfo
{
Arena FileMem;
Arena TokMem;
Arena CodeMem;
FileContents FileContent;
Array<Token> Tokens;
Array<Error> Errors;
// Errors are allocated to a dedicated general arena.
};
CodeBody parse_file( StrC path );
#endif
CodeClass parse_class ( StrC class_def );
CodeConstructor parse_constructor ( StrC constructor_def );
CodeDestructor parse_destructor ( StrC destructor_def );
CodeEnum parse_enum ( StrC enum_def );
CodeBody parse_export_body ( StrC export_def );
CodeExtern parse_extern_link ( StrC exten_link_def );
CodeFriend parse_friend ( StrC friend_def );
CodeFn parse_function ( StrC fn_def );
CodeBody parse_global_body ( StrC body_def );
CodeNS parse_namespace ( StrC namespace_def );
CodeOperator parse_operator ( StrC operator_def );
CodeOpCast parse_operator_cast( StrC operator_def );
CodeStruct parse_struct ( StrC struct_def );
CodeTemplate parse_template ( StrC template_def );
CodeTypename parse_type ( StrC type_def );
CodeTypedef parse_typedef ( StrC typedef_def );
CodeUnion parse_union ( StrC union_def );
CodeUsing parse_using ( StrC using_def );
CodeVar parse_variable ( StrC var_def );
#pragma endregion Parsing
#pragma region Untyped text
ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va );
//! Do not use directly. Use the token_fmt macro instead.
StrC token_fmt_impl( ssize, ... );
Code untyped_str ( StrC content);
Code untyped_fmt ( char const* fmt, ... );
Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
#pragma endregion Untyped text
#pragma region Macros
#ifndef gen_main
#define gen_main main
#endif
#ifndef name
// Convienence for defining any name used with the gen api.
// Lets you provide the length and string literal to the functions without the need for the DSL.
#define name( Id_ ) { sizeof(stringize( Id_ )) - 1, stringize(Id_) }
#endif
#ifndef code
// Same as name just used to indicate intention of literal for code instead of names.
#define code( ... ) { sizeof(stringize(__VA_ARGS__)) - 1, stringize( __VA_ARGS__ ) }
#endif
#ifndef args
// Provides the number of arguments while passing args inplace.
#define args( ... ) num_args( __VA_ARGS__ ), __VA_ARGS__
#endif
#ifndef code_str
// Just wrappers over common untyped code definition constructions.
#define code_str( ... ) GEN_NS untyped_str( code( __VA_ARGS__ ) )
#endif
#ifndef code_fmt
#define code_fmt( ... ) GEN_NS untyped_str( token_fmt( __VA_ARGS__ ) )
#endif
#ifndef parse_fmt
#define parse_fmt( type, ... ) GEN_NS parse_##type( token_fmt( __VA_ARGS__ ) )
#endif
#ifndef token_fmt
/*
Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC of the formatted string.
Tokens are provided in '<'identifier'>' format where '<' '>' are just angle brackets (you can change it in token_fmt_va)
---------------------------------------------------------
Example - A string with:
typedef <type> <name> <name>;
Will have a token_fmt arguments populated with:
"type", strc_for_type,
"name", strc_for_name,
and:
stringize( typedef <type> <name> <name>; )
-----------------------------------------------------------
So the full call for this example would be:
token_fmt(
"type", strc_for_type
, "name", strc_for_name
, stringize(
typedef <type> <name> <name>
));
!----------------------------------------------------------
! Note: token_fmt_va is whitespace sensitive for the tokens.
! This can be alleviated by skipping whitespace between brackets but it was choosen to not have that implementation by default.
*/
#define token_fmt( ... ) GEN_NS token_fmt_impl( (num_args( __VA_ARGS__ ) + 1) / 2, __VA_ARGS__ )
#endif
#pragma endregion Macros
#pragma endregion Gen Interface

182
project/components/interface.parsing.cpp → base/components/interface.parsing.cpp
View File

@ -10,58 +10,58 @@
CodeClass parse_class( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
push_scope();
CodeClass result = (CodeClass) parse_class_struct( TokType::Decl_Class );
Context.pop();
CodeClass result = (CodeClass) parse_class_struct( Tok_Decl_Class, parser_not_inplace_def );
parser_pop(& Context);
return result;
}
CodeConstructor parse_constructor( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
// TODO(Ed): Constructors can have prefix attributes
CodeSpecifiers specifiers;
SpecifierT specs_found[ 16 ] { ESpecifier::NumSpecifiers };
CodeSpecifiers specifiers = NullCode;
Specifier specs_found[ 16 ] = { Spec_NumSpecifiers };
s32 NumSpecifiers = 0;
while ( left && currtok.is_specifier() )
while ( left && tok_is_specifier(currtok) )
{
SpecifierT spec = ESpecifier::to_type( currtok );
Specifier spec = strc_to_specifier( tok_to_str(currtok) );
b32 ignore_spec = false;
switch ( spec )
{
case ESpecifier::Constexpr :
case ESpecifier::Explicit:
case ESpecifier::Inline :
case ESpecifier::ForceInline :
case ESpecifier::NeverInline :
case Spec_Constexpr :
case Spec_Explicit:
case Spec_Inline :
case Spec_ForceInline :
case Spec_NeverInline :
break;
case ESpecifier::Const :
case Spec_Const :
ignore_spec = true;
break;
default :
log_failure( "Invalid specifier %s for variable\n%s", ESpecifier::to_str( spec ), Context.to_string() );
Context.pop();
return CodeInvalid;
log_failure( "Invalid specifier %s for variable\n%s", spec_to_str( spec ), parser_to_string(Context) );
parser_pop(& Context);
return InvalidCode;
}
// Every specifier after would be considered part of the type type signature
@ -80,250 +80,266 @@ CodeConstructor parse_constructor( StrC def )
}
Context.Tokens = toks;
CodeConstructor result = parse_constructor( specifiers );
CodeConstructor result = parser_parse_constructor( specifiers );
return result;
}
CodeDestructor parse_destructor( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
// TODO(Ed): Destructors can have prefix attributes
// TODO(Ed): Destructors can have virtual
Context.Tokens = toks;
CodeDestructor result = parse_destructor();
CodeDestructor result = parser_parse_destructor(NullCode);
return result;
}
CodeEnum parse_enum( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
{
Context.pop();
return CodeInvalid;
parser_pop(& Context);
return InvalidCode;
}
Context.Tokens = toks;
return parse_enum();
return parser_parse_enum( parser_not_inplace_def);
}
CodeBody parse_export_body( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
return parse_export_body();
return parser_parse_export_body();
}
CodeExtern parse_extern_link( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
return parse_extern_link();
return parser_parse_extern_link();
}
CodeFriend parse_friend( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
return parse_friend();
return parser_parse_friend();
}
CodeFn parse_function( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
return (CodeFn) parse_function();
return (CodeFn) parser_parse_function();
}
CodeBody parse_global_body( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
push_scope();
CodeBody result = parse_global_nspace( ECode::Global_Body );
Context.pop();
CodeBody result = parse_global_nspace( CT_Global_Body );
parser_pop(& Context);
return result;
}
CodeNS parse_namespace( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
return parse_namespace();
return parser_parse_namespace();
}
CodeOperator parse_operator( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
return (CodeOperator) parse_operator();
return (CodeOperator) parser_parse_operator();
}
CodeOpCast parse_operator_cast( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
return parse_operator_cast();
return parser_parse_operator_cast(NullCode);
}
CodeStruct parse_struct( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
push_scope();
CodeStruct result = (CodeStruct) parse_class_struct( TokType::Decl_Struct );
Context.pop();
CodeStruct result = (CodeStruct) parse_class_struct( Tok_Decl_Struct, parser_not_inplace_def );
parser_pop(& Context);
return result;
}
CodeTemplate parse_template( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
return parse_template();
return parser_parse_template();
}
CodeType parse_type( StrC def )
CodeTypename parse_type( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
return parse_type();
return parser_parse_type( parser_not_from_template, nullptr);
}
CodeTypedef parse_typedef( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
return parse_typedef();
return parser_parse_typedef();
}
CodeUnion parse_union( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
return parse_union();
return parser_parse_union( parser_not_inplace_def);
}
CodeUsing parse_using( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
return parse_using();
return parser_parse_using();
}
CodeVar parse_variable( StrC def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
using namespace parser;
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return CodeInvalid;
return InvalidCode;
Context.Tokens = toks;
return parse_variable();
return parser_parse_variable();
}
// Undef helper macros
# undef check_parse_args
# undef currtok
# undef prevtok
# undef nexttok
# undef eat
# undef left
# undef check
# undef push_scope
#undef check_parse_args
#undef currtok_noskip
#undef currtok
#undef peektok
#undef prevtok
#undef nexttok
#undef nexttok_noskip
#undef eat
#undef left
#undef check
#undef push_scope
#undef def_assign
// Here for C Variant
#undef lex_dont_skip_formatting
#undef lex_skip_formatting
#undef parser_inplace_def
#undef parser_not_inplace_def
#undef parser_dont_consume_braces
#undef parser_consume_braces
#undef parser_not_from_template
#undef parser_use_parenthesis
#undef parser_strip_formatting_dont_preserve_newlines

62
project/components/interface.untyped.cpp → base/components/interface.untyped.cpp
View File

@ -6,18 +6,16 @@
ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
{
char const* buf_begin = buf;
ssize remaining = buf_size;
ssize remaining = buf_size;
local_persist
Arena tok_map_arena;
TokenMap_FixedArena tok_map_arena;
fixed_arena_init( & tok_map_arena);
HashTable<StrC> tok_map;
local_persist
StringTable tok_map;
{
local_persist
char tok_map_mem[ TokenFmt_TokenMap_MemSize ];
tok_map_arena = Arena::init_from_memory( tok_map_mem, sizeof(tok_map_mem) );
tok_map = HashTable<StrC>::init( tok_map_arena );
tok_map = hashtable_init(StrC, fixed_arena_allocator_info(& tok_map_arena) );
s32 left = num_tokens - 1;
@ -27,8 +25,7 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
StrC value = va_arg( va, StrC );
u32 key = crc32( token, str_len(token) );
tok_map.set( key, value );
hashtable_set( tok_map, key, value );
}
}
@ -64,7 +61,7 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
char const* token = fmt + 1;
u32 key = crc32( token, tok_len );
StrC* value = tok_map.get( key );
StrC* value = hashtable_get(tok_map, key );
if ( value )
{
@ -94,8 +91,8 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
}
}
tok_map.clear();
tok_map_arena.free();
hashtable_clear(tok_map);
fixed_arena_free(& tok_map_arena);
ssize result = buf_size - remaining;
@ -107,19 +104,19 @@ Code untyped_str( StrC content )
if ( content.Len == 0 )
{
log_failure( "untyped_str: empty string" );
return CodeInvalid;
return InvalidCode;
}
Code
result = make_code();
result->Name = get_cached_string( content );
result->Type = ECode::Untyped;
result->Type = CT_Untyped;
result->Content = result->Name;
if ( result->Name == nullptr )
if ( result->Name.Len == 0 )
{
log_failure( "untyped_str: could not cache string" );
return CodeInvalid;
return InvalidCode;
}
return result;
@ -130,7 +127,7 @@ Code untyped_fmt( char const* fmt, ...)
if ( fmt == nullptr )
{
log_failure( "untyped_fmt: null format string" );
return CodeInvalid;
return InvalidCode;
}
local_persist thread_local
@ -141,47 +138,52 @@ Code untyped_fmt( char const* fmt, ...)
ssize length = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
va_end(va);
StrC buf_str = { str_len_capped(fmt, MaxNameLength), fmt };
StrC uncapped_str = { length, buf };
Code
result = make_code();
result->Name = get_cached_string( { str_len(fmt, MaxNameLength), fmt } );
result->Type = ECode::Untyped;
result->Content = get_cached_string( { length, buf } );
result->Name = get_cached_string( buf_str );
result->Type = CT_Untyped;
result->Content = get_cached_string( uncapped_str );
if ( result->Name == nullptr )
if ( result->Name.Len == 0 )
{
log_failure( "untyped_fmt: could not cache string" );
return CodeInvalid;
return InvalidCode;
}
return result;
}
Code untyped_token_fmt( s32 num_tokens, ... )
Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... )
{
if ( num_tokens == 0 )
{
log_failure( "untyped_token_fmt: zero tokens" );
return CodeInvalid;
return InvalidCode;
}
local_persist thread_local
char buf[GEN_PRINTF_MAXLEN] = { 0 };
va_list va;
va_start(va, num_tokens);
va_start(va, fmt);
ssize length = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num_tokens, va);
va_end(va);
StrC buf_str = { length, buf };
Code
result = make_code();
result->Name = get_cached_string( { length, buf } );
result->Type = ECode::Untyped;
result->Name = get_cached_string( buf_str );
result->Type = CT_Untyped;
result->Content = result->Name;
if ( result->Name == nullptr )
if ( result->Name.Len == 0 )
{
log_failure( "untyped_fmt: could not cache string" );
return CodeInvalid;
return InvalidCode;
}
return result;

1253
project/components/interface.upfront.cpp → base/components/interface.upfront.cpp
View File

File diff suppressed because it is too large Load Diff

1349
base/components/lexer.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

5594
base/components/parser.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

0
project/components/src_start.cpp → base/components/src_start.cpp
View File

70
project/components/static_data.cpp → base/components/static_data.cpp
View File

@ -1,33 +1,35 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
#pragma once
#include "gen.hpp"
#include "../gen.hpp"
#endif
#pragma region StaticData
// TODO : Convert global allocation strategy to use a slab allocation strategy.
global AllocatorInfo GlobalAllocator;
global Array<Arena> Global_AllocatorBuckets;
global Array( Arena ) Global_AllocatorBuckets;
// TODO(Ed) : Make the code pool a dynamic arena
global Array< Pool > CodePools = { nullptr };
global Array< Arena > StringArenas = { nullptr };
global Array( Pool ) CodePools = { nullptr };
global Array( Arena ) StringArenas = { nullptr };
global StringTable StringCache;
global Arena LexArena;
global AllocatorInfo Allocator_DataArrays = heap();
global AllocatorInfo Allocator_CodePool = heap();
global AllocatorInfo Allocator_Lexer = heap();
global AllocatorInfo Allocator_StringArena = heap();
global AllocatorInfo Allocator_StringTable = heap();
global AllocatorInfo Allocator_TypeTable = heap();
global AllocatorInfo Allocator_DataArrays = {0};
global AllocatorInfo Allocator_CodePool = {0};
global AllocatorInfo Allocator_Lexer = {0};
global AllocatorInfo Allocator_StringArena = {0};
global AllocatorInfo Allocator_StringTable = {0};
global AllocatorInfo Allocator_TypeTable = {0};
#pragma endregion StaticData
#pragma region Constants
global StrC enum_underlying_sig;
global Code access_public;
global Code access_protected;
global Code access_private;
@ -40,7 +42,7 @@ global Code module_private_fragment;
global Code fmt_newline;
global CodeParam param_varadic;
global CodeParams param_varadic;
global CodePragma pragma_once;
@ -72,36 +74,36 @@ global CodeSpecifiers spec_thread_local;
global CodeSpecifiers spec_virtual;
global CodeSpecifiers spec_volatile;
global CodeType t_empty;
global CodeType t_auto;
global CodeType t_void;
global CodeType t_int;
global CodeType t_bool;
global CodeType t_char;
global CodeType t_wchar_t;
global CodeType t_class;
global CodeType t_typename;
global CodeTypename t_empty;
global CodeTypename t_auto;
global CodeTypename t_void;
global CodeTypename t_int;
global CodeTypename t_bool;
global CodeTypename t_char;
global CodeTypename t_wchar_t;
global CodeTypename t_class;
global CodeTypename t_typename;
global Array< StringCached > PreprocessorDefines;
global Array(StringCached) PreprocessorDefines;
#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
global CodeType t_b32;
global CodeTypename t_b32;
global CodeType t_s8;
global CodeType t_s16;
global CodeType t_s32;
global CodeType t_s64;
global CodeTypename t_s8;
global CodeTypename t_s16;
global CodeTypename t_s32;
global CodeTypename t_s64;
global CodeType t_u8;
global CodeType t_u16;
global CodeType t_u32;
global CodeType t_u64;
global CodeTypename t_u8;
global CodeTypename t_u16;
global CodeTypename t_u32;
global CodeTypename t_u64;
global CodeType t_ssize;
global CodeType t_usize;
global CodeTypename t_ssize;
global CodeTypename t_usize;
global CodeType t_f32;
global CodeType t_f64;
global CodeTypename t_f32;
global CodeTypename t_f64;
#endif
#pragma endregion Constants

138
base/components/types.hpp Normal file
View File

@ -0,0 +1,138 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
#pragma once
#include "header_start.hpp"
#endif
/*
________ __ __ ________
| \ | \ | \ | \
| ▓▓▓▓▓▓▓▓_______ __ __ ______ ____ _______ | ▓▓\ | ▓▓ \▓▓▓▓▓▓▓▓__ __ ______ ______ _______
| ▓▓__ | \| \ | \ \ \ / \ | ▓▓▓\| ▓▓ | ▓▓ | \ | \/ \ / \ / \
| ▓▓ \ | ▓▓▓▓▓▓▓\ ▓▓ | ▓▓ ▓▓▓▓▓▓\▓▓▓▓\ ▓▓▓▓▓▓▓ | ▓▓▓▓\ ▓▓ | ▓▓ | ▓▓ | ▓▓ ▓▓▓▓▓▓\ ▓▓▓▓▓▓\ ▓▓▓▓▓▓▓
| ▓▓▓▓▓ | ▓▓ | ▓▓ ▓▓ | ▓▓ ▓▓ | ▓▓ | ▓▓\▓▓ \ | ▓▓\▓▓ ▓▓ | ▓▓ | ▓▓ | ▓▓ ▓▓ | ▓▓ ▓▓ ▓▓\▓▓ \
| ▓▓_____| ▓▓ | ▓▓ ▓▓__/ ▓▓ ▓▓ | ▓▓ | ▓▓_\▓▓▓▓▓▓\ | ▓▓ \▓▓▓▓ | ▓▓ | ▓▓__/ ▓▓ ▓▓__/ ▓▓ ▓▓▓▓▓▓▓▓_\▓▓▓▓▓▓\
| ▓▓ \ ▓▓ | ▓▓\▓▓ ▓▓ ▓▓ | ▓▓ | ▓▓ ▓▓ | ▓▓ \▓▓▓ | ▓▓ \▓▓ ▓▓ ▓▓ ▓▓\▓▓ \ ▓▓
\▓▓▓▓▓▓▓▓\▓▓ \▓▓ \▓▓▓▓▓▓ \▓▓ \▓▓ \▓▓\▓▓▓▓▓▓▓ \▓▓ \▓▓ \▓▓ _\▓▓▓▓▓▓▓ ▓▓▓▓▓▓▓ \▓▓▓▓▓▓▓\▓▓▓▓▓▓▓
| \__| ▓▓ ▓▓
\▓▓ ▓▓ ▓▓
\▓▓▓▓▓▓ \▓▓
*/
using LogFailType = ssize(*)(char const*, ...);
// By default this library will either crash or exit if an error is detected while generating codes.
// Even if set to not use GEN_FATAL, GEN_FATAL will still be used for memory failures as the library is unusable when they occur.
#ifdef GEN_DONT_USE_FATAL
#define log_failure log_fmt
#else
#define log_failure GEN_FATAL
#endif
enum AccessSpec : u32
{
AccessSpec_Default,
AccessSpec_Private,
AccessSpec_Protected,
AccessSpec_Public,
AccessSpec_Num_AccessSpec,
AccessSpec_Invalid,
AccessSpec_SizeDef = GEN_U32_MAX,
};
static_assert( size_of(AccessSpec) == size_of(u32), "AccessSpec not u32 size" );
inline
StrC access_spec_to_str( AccessSpec type )
{
local_persist
StrC lookup[ (u32)AccessSpec_Num_AccessSpec ] = {
{ sizeof("") - 1, "" },
{ sizeof("prviate") - 1, "private" },
{ sizeof("protected") - 1, "private" },
{ sizeof("public") - 1, "public" },
};
StrC invalid = { sizeof("Invalid") - 1, "Invalid" };
if ( type > AccessSpec_Public )
return invalid;
return lookup[ (u32)type ];
}
enum CodeFlag : u32
{
CodeFlag_None = 0,
CodeFlag_FunctionType = bit(0),
CodeFlag_ParamPack = bit(1),
CodeFlag_Module_Export = bit(2),
CodeFlag_Module_Import = bit(3),
CodeFlag_SizeDef = GEN_U32_MAX,
};
static_assert( size_of(CodeFlag) == size_of(u32), "CodeFlag not u32 size" );
// Used to indicate if enum definitoin is an enum class or regular enum.
enum EnumDecl : u8
{
EnumDecl_Regular,
EnumDecl_Class,
EnumT_SizeDef = GEN_U8_MAX,
};
typedef u8 EnumT;
enum ModuleFlag : u32
{
ModuleFlag_None = 0,
ModuleFlag_Export = bit(0),
ModuleFlag_Import = bit(1),
Num_ModuleFlags,
ModuleFlag_Invalid,
ModuleFlag_SizeDef = GEN_U32_MAX,
};
static_assert( size_of(ModuleFlag) == size_of(u32), "ModuleFlag not u32 size" );
inline
StrC module_flag_to_str( ModuleFlag flag )
{
local_persist
StrC lookup[ (u32)Num_ModuleFlags ] = {
{ sizeof("__none__"), "__none__" },
{ sizeof("export"), "export" },
{ sizeof("import"), "import" },
};
local_persist
StrC invalid_flag = { sizeof("invalid"), "invalid" };
if ( flag > ModuleFlag_Import )
return invalid_flag;
return lookup[ (u32)flag ];
}
enum EPreprocessCond : u32
{
PreprocessCond_If,
PreprocessCond_IfDef,
PreprocessCond_IfNotDef,
PreprocessCond_ElIf,
EPreprocessCond_SizeDef = GEN_U32_MAX,
};
static_assert( size_of(EPreprocessCond) == size_of(u32), "EPreprocessCond not u32 size" );
enum ETypenameTag : u16
{
Tag_None,
Tag_Class,
Tag_Enum,
Tag_Struct,
Tag_Union,
Tag_UnderlyingType = GEN_U16_MAX,
};
static_assert( size_of(ETypenameTag) == size_of(u16), "ETypenameTag is not u16 size");

12
project/dependencies/basic_types.hpp → base/dependencies/basic_types.hpp
View File

@ -122,13 +122,21 @@ typedef s8 b8;
typedef s16 b16;
typedef s32 b32;
using mem_ptr = void*;
using mem_ptr_const = void const*;
typedef void* mem_ptr;
typedef void const* mem_ptr_const ;
#if GEN_COMPILER_CPP
template<typename Type> uptr to_uptr( Type* ptr ) { return (uptr)ptr; }
template<typename Type> sptr to_sptr( Type* ptr ) { return (sptr)ptr; }
template<typename Type> mem_ptr to_mem_ptr ( Type ptr ) { return (mem_ptr) ptr; }
template<typename Type> mem_ptr_const to_mem_ptr_const( Type ptr ) { return (mem_ptr_const)ptr; }
#else
#define to_uptr( ptr ) ((uptr)(ptr))
#define to_sptr( ptr ) ((sptr)(ptr))
#define to_mem_ptr( ptr) ((mem_ptr)ptr)
#define to_mem_ptr_const( ptr) ((mem_ptr)ptr)
#endif
#pragma endregion Basic Types

797
base/dependencies/containers.hpp Normal file
View File

@ -0,0 +1,797 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "printing.hpp"
#endif
#pragma region Containers
template<class TType> struct RemoveConst { typedef TType Type; };
template<class TType> struct RemoveConst<const TType> { typedef TType Type; };
template<class TType> struct RemoveConst<const TType[]> { typedef TType Type[]; };
template<class TType, usize Size> struct RemoveConst<const TType[Size]> { typedef TType Type[Size]; };
template<class TType> using TRemoveConst = typename RemoveConst<TType>::Type;
template <class TType> struct RemovePtr { typedef TType Type; };
template <class TType> struct RemovePtr<TType*> { typedef TType Type; };
template <class TType> using TRemovePtr = typename RemovePtr<TType>::Type;
#pragma region Array
#define Array(Type) Array<Type>
// #define array_init(Type, ...) array_init <Type>(__VA_ARGS__)
// #define array_init_reserve(Type, ...) array_init_reserve<Type>(__VA_ARGS__)
struct ArrayHeader;
#if GEN_COMPILER_CPP
template<class Type> struct Array;
# define get_array_underlying_type(array) typename TRemovePtr<typeof(array)>:: DataType
#endif
usize array_grow_formula(ssize value);
template<class Type> Array<Type> array_init (AllocatorInfo allocator);
template<class Type> Array<Type> array_init_reserve (AllocatorInfo allocator, ssize capacity);
template<class Type> bool array_append_array (Array<Type>* array, Array<Type> other);
template<class Type> bool array_append (Array<Type>* array, Type value);
template<class Type> bool array_append_items (Array<Type>* array, Type* items, usize item_num);
template<class Type> bool array_append_at (Array<Type>* array, Type item, usize idx);
template<class Type> bool array_append_items_at(Array<Type>* array, Type* items, usize item_num, usize idx);
template<class Type> Type* array_back (Array<Type> array);
template<class Type> void array_clear (Array<Type> array);
template<class Type> bool array_fill (Array<Type> array, usize begin, usize end, Type value);
template<class Type> void array_free (Array<Type>* array);
template<class Type> bool arary_grow (Array<Type>* array, usize min_capacity);
template<class Type> usize array_num (Array<Type> array);
template<class Type> void arary_pop (Array<Type> array);
template<class Type> void arary_remove_at (Array<Type> array, usize idx);
template<class Type> bool arary_reserve (Array<Type>* array, usize new_capacity);
template<class Type> bool arary_resize (Array<Type>* array, usize num);
template<class Type> bool arary_set_capacity (Array<Type>* array, usize new_capacity);
template<class Type> ArrayHeader* arary_get_header (Array<Type> array);
struct ArrayHeader {
AllocatorInfo Allocator;
usize Capacity;
usize Num;
};
#if GEN_COMPILER_CPP
template<class Type>
struct Array
{
Type* Data;
#pragma region Member Mapping
forceinline static Array init(AllocatorInfo allocator) { return array_init<Type>(allocator); }
forceinline static Array init_reserve(AllocatorInfo allocator, ssize capacity) { return array_init_reserve<Type>(allocator, capacity); }
forceinline static usize grow_formula(ssize value) { return array_grow_formula<Type>(value); }
forceinline bool append(Array other) { return array_append_array<Type>(this, other); }
forceinline bool append(Type value) { return array_append<Type>(this, value); }
forceinline bool append(Type* items, usize item_num) { return array_append_items<Type>(this, items, item_num); }
forceinline bool append_at(Type item, usize idx) { return array_append_at<Type>(this, item, idx); }
forceinline bool append_at(Type* items, usize item_num, usize idx) { return array_append_items_at<Type>(this, items, item_num, idx); }
forceinline Type* back() { return array_back<Type>(* this); }
forceinline void clear() { array_clear<Type>(* this); }
forceinline bool fill(usize begin, usize end, Type value) { return array_fill<Type>(* this, begin, end, value); }
forceinline void free() { array_free<Type>(this); }
forceinline ArrayHeader* get_header() { return array_get_header<Type>(* this); }
forceinline bool grow(usize min_capacity) { return array_grow<Type>(this, min_capacity); }
forceinline usize num() { return array_num<Type>(*this); }
forceinline void pop() { array_pop<Type>(* this); }
forceinline void remove_at(usize idx) { array_remove_at<Type>(* this, idx); }
forceinline bool reserve(usize new_capacity) { return array_reserve<Type>(this, new_capacity); }
forceinline bool resize(usize num) { return array_resize<Type>(this, num); }
forceinline bool set_capacity(usize new_capacity) { return array_set_capacity<Type>(this, new_capacity); }
#pragma endregion Member Mapping
forceinline operator Type*() { return Data; }
forceinline operator Type const*() const { return Data; }
forceinline Type* begin() { return Data; }
forceinline Type* end() { return Data + get_header()->Num; }
forceinline Type& operator[](ssize index) { return Data[index]; }
forceinline Type const& operator[](ssize index) const { return Data[index]; }
using DataType = Type;
};
#endif
#if GEN_COMPILER_CPP && 0
template<class Type> bool append(Array<Type>& array, Array<Type> other) { return append( & array, other ); }
template<class Type> bool append(Array<Type>& array, Type value) { return append( & array, value ); }
template<class Type> bool append(Array<Type>& array, Type* items, usize item_num) { return append( & array, items, item_num ); }
template<class Type> bool append_at(Array<Type>& array, Type item, usize idx) { return append_at( & array, item, idx ); }
template<class Type> bool append_at(Array<Type>& array, Type* items, usize item_num, usize idx) { return append_at( & array, items, item_num, idx ); }
template<class Type> void free(Array<Type>& array) { return free( & array ); }
template<class Type> bool grow(Array<Type>& array, usize min_capacity) { return grow( & array, min_capacity); }
template<class Type> bool reserve(Array<Type>& array, usize new_capacity) { return reserve( & array, new_capacity); }
template<class Type> bool resize(Array<Type>& array, usize num) { return resize( & array, num); }
template<class Type> bool set_capacity(Array<Type>& array, usize new_capacity) { return set_capacity( & array, new_capacity); }
template<class Type> forceinline Type* begin(Array<Type>& array) { return array; }
template<class Type> forceinline Type* end(Array<Type>& array) { return array + array_get_header(array)->Num; }
template<class Type> forceinline Type* next(Array<Type>& array, Type* entry) { return entry + 1; }
#endif
template<class Type> forceinline Type* array_begin(Array<Type> array) { return array; }
template<class Type> forceinline Type* array_end(Array<Type> array) { return array + array_get_header(array)->Num; }
template<class Type> forceinline Type* array_next(Array<Type> array, Type* entry) { return ++ entry; }
template<class Type> inline
Array<Type> array_init(AllocatorInfo allocator) {
return array_init_reserve<Type>(allocator, array_grow_formula(0));
}
template<class Type> inline
Array<Type> array_init_reserve(AllocatorInfo allocator, ssize capacity)
{
GEN_ASSERT(capacity > 0);
ArrayHeader* header = rcast(ArrayHeader*, alloc(allocator, sizeof(ArrayHeader) + sizeof(Type) * capacity));
if (header == nullptr)
return {nullptr};
header->Allocator = allocator;
header->Capacity = capacity;
header->Num = 0;
return {rcast(Type*, header + 1)};
}
usize array_grow_formula(ssize value) {
return 2 * value + 8;
}
template<class Type> inline
bool array_append_array(Array<Type>* array, Array<Type> other) {
return array_append_items(array, (Type*)other, num(other));
}
template<class Type> inline
bool array_append(Array<Type>* array, Type value)
{
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
ArrayHeader* header = array_get_header(* array);
if (header->Num == header->Capacity)
{
if ( ! array_grow(array, header->Capacity))
return false;
header = array_get_header(* array);
}
(*array)[ header->Num] = value;
header->Num++;
return true;
}
template<class Type> inline
bool array_append_items(Array<Type>* array, Type* items, usize item_num)
{
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
GEN_ASSERT(items != nullptr);
GEN_ASSERT(item_num > 0);
ArrayHeader* header = array_get_header(array);
if (header->Num + item_num > header->Capacity)
{
if ( ! grow(array, header->Capacity + item_num))
return false;
header = array_get_header(array);
}
mem_copy((Type*)array + header->Num, items, item_num * sizeof(Type));
header->Num += item_num;
return true;
}
template<class Type> inline
bool array_append_at(Array<Type>* array, Type item, usize idx)
{
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
ArrayHeader* header = array_get_header(* array);
ssize slot = idx;
if (slot >= header->Num)
slot = header->Num - 1;
if (slot < 0)
slot = 0;
if (header->Capacity < header->Num + 1)
{
if ( ! array_grow(array, header->Capacity + 1))
return false;
header = array_get_header(* array);
}
Type* target = &(*array)[slot];
mem_move(target + 1, target, (header->Num - slot) * sizeof(Type));
header->Num++;
return true;
}
template<class Type> inline
bool array_append_items_at(Array<Type>* array, Type* items, usize item_num, usize idx)
{
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
ArrayHeader* header = get_header(array);
if (idx >= header->Num)
{
return array_append_items(array, items, item_num);
}
if (item_num > header->Capacity)
{
if (! grow(array, header->Capacity + item_num))
return false;
header = get_header(array);
}
Type* target = array.Data + idx + item_num;
Type* src = array.Data + idx;
mem_move(target, src, (header->Num - idx) * sizeof(Type));
mem_copy(src, items, item_num * sizeof(Type));
header->Num += item_num;
return true;
}
template<class Type> inline
Type* array_back(Array<Type> array)
{
GEN_ASSERT(array != nullptr);
ArrayHeader* header = array_get_header(array);
if (header->Num <= 0)
return nullptr;
return & (array)[header->Num - 1];
}
template<class Type> inline
void array_clear(Array<Type> array) {
GEN_ASSERT(array != nullptr);
ArrayHeader* header = array_get_header(array);
header->Num = 0;
}
template<class Type> inline
bool array_fill(Array<Type> array, usize begin, usize end, Type value)
{
GEN_ASSERT(array != nullptr);
GEN_ASSERT(begin <= end);
ArrayHeader* header = array_get_header(array);
if (begin < 0 || end > header->Num)
return false;
for (ssize idx = ssize(begin); idx < ssize(end); idx++)
{
array[idx] = value;
}
return true;
}
template<class Type> forceinline
void array_free(Array<Type>* array) {
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
ArrayHeader* header = array_get_header(* array);
allocator_free(header->Allocator, header);
Type** Data = (Type**)array;
*Data = nullptr;
}
template<class Type> forceinline
ArrayHeader* array_get_header(Array<Type> array) {
GEN_ASSERT(array != nullptr);
Type* Data = array;
using NonConstType = TRemoveConst<Type>;
return rcast(ArrayHeader*, const_cast<NonConstType*>(Data)) - 1;
}
template<class Type> forceinline
bool array_grow(Array<Type>* array, usize min_capacity)
{
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
GEN_ASSERT( min_capacity > 0 );
ArrayHeader* header = array_get_header(* array);
usize new_capacity = array_grow_formula(header->Capacity);
if (new_capacity < min_capacity)
new_capacity = min_capacity;
return array_set_capacity(array, new_capacity);
}
template<class Type> forceinline
usize array_num(Array<Type> array) {
GEN_ASSERT(array != nullptr);
return array_get_header(array)->Num;
}
template<class Type> forceinline
void array_pop(Array<Type> array) {
GEN_ASSERT(array != nullptr);
ArrayHeader* header = array_get_header(array);
GEN_ASSERT(header->Num > 0);
header->Num--;
}
template<class Type> inline
void array_remove_at(Array<Type> array, usize idx)
{
GEN_ASSERT(array != nullptr);
ArrayHeader* header = array_get_header(array);
GEN_ASSERT(idx < header->Num);
mem_move(array + idx, array + idx + 1, sizeof(Type) * (header->Num - idx - 1));
header->Num--;
}
template<class Type> inline
bool array_reserve(Array<Type>* array, usize new_capacity)
{
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
GEN_ASSERT(num > 0)
ArrayHeader* header = array_get_header(array);
if (header->Capacity < new_capacity)
return set_capacity(array, new_capacity);
return true;
}
template<class Type> inline
bool array_resize(Array<Type>* array, usize num)
{
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
ArrayHeader* header = array_get_header(* array);
if (header->Capacity < num) {
if (! array_grow( array, num))
return false;
header = array_get_header(* array);
}
header->Num = num;
return true;
}
template<class Type> inline
bool array_set_capacity(Array<Type>* array, usize new_capacity)
{
GEN_ASSERT( array != nullptr);
GEN_ASSERT(* array != nullptr);
ArrayHeader* header = array_get_header(* array);
if (new_capacity == header->Capacity)
return true;
if (new_capacity < header->Num)
{
header->Num = new_capacity;
return true;
}
ssize size = sizeof(ArrayHeader) + sizeof(Type) * new_capacity;
ArrayHeader* new_header = rcast(ArrayHeader*, alloc(header->Allocator, size));
if (new_header == nullptr)
return false;
mem_move(new_header, header, sizeof(ArrayHeader) + sizeof(Type) * header->Num);
new_header->Capacity = new_capacity;
allocator_free(header->Allocator, header);
Type** Data = (Type**)array;
* Data = rcast(Type*, new_header + 1);
return true;
}
// These are intended for use in the base library of gencpp and the C-variant of the library
// It provides a interoperability between the C++ and C implementation of arrays. (not letting these do any crazy substiution though)
// They are undefined in gen.hpp and gen.cpp at the end of the files.
// We cpp library expects the user to use the regular calls as they can resolve the type fine.
#define array_init(type, allocator) array_init <type> (allocator )
#define array_init_reserve(type, allocator, cap) array_init_reserve <type> (allocator, cap)
#define array_append_array(array, other) array_append_array < get_array_underlying_type(array) > (& array, other )
#define array_append(array, value) array_append < get_array_underlying_type(array) > (& array, value )
#define array_append_items(array, items, item_num) array_append_items < get_array_underlying_type(array) > (& array, items, item_num )
#define array_append_at(array, item, idx ) array_append_at < get_array_underlying_type(array) > (& array, item, idx )
#define array_append_at_items(array, items, item_num, idx) array_append_at_items< get_array_underlying_type(array) > (& items, item_num, idx )
#define array_back(array) array_back < get_array_underlying_type(array) > (array )
#define array_clear(array) array_clear < get_array_underlying_type(array) > (array )
#define array_fill(array, begin, end, value) array_fill < get_array_underlying_type(array) > (array, begin, end, value )
#define array_free(array) array_free < get_array_underlying_type(array) > (& array )
#define arary_grow(array, min_capacity) arary_grow < get_array_underlying_type(array) > (& array, min_capacity)
#define array_num(array) array_num < get_array_underlying_type(array) > (array )
#define arary_pop(array) arary_pop < get_array_underlying_type(array) > (array )
#define arary_remove_at(array, idx) arary_remove_at < get_array_underlying_type(array) > (idx)
#define arary_reserve(array, new_capacity) arary_reserve < get_array_underlying_type(array) > (& array, new_capacity )
#define arary_resize(array, num) arary_resize < get_array_underlying_type(array) > (& array, num)
#define arary_set_capacity(new_capacity) arary_set_capacity < get_array_underlying_type(array) > (& array, new_capacity )
#define arary_get_header(array) arary_get_header < get_array_underlying_type(array) > (array )
#pragma endregion Array
// TODO(Ed) : This thing needs ALOT of work.
#pragma region HashTable
#define HashTable(Type) HashTable<Type>
template<class Type> struct HashTable;
#ifndef get_hashtable_underlying_type
#define get_hashtable_underlying_type(table) typename TRemovePtr<typeof(table)>:: DataType
#endif
struct HashTableFindResult {
ssize HashIndex;
ssize PrevIndex;
ssize EntryIndex;
};
template<class Type>
struct HashTableEntry {
u64 Key;
ssize Next;
Type Value;
};
#define HashTableEntry(Type) HashTableEntry<Type>
template<class Type> HashTable<Type> hashtable_init (AllocatorInfo allocator);
template<class Type> HashTable<Type> hashtable_init_reserve(AllocatorInfo allocator, usize num);
template<class Type> void hashtable_clear (HashTable<Type> table);
template<class Type> void hashtable_destroy (HashTable<Type>* table);
template<class Type> Type* hashtable_get (HashTable<Type> table, u64 key);
template<class Type> void hashtable_grow (HashTable<Type>* table);
template<class Type> void hashtable_rehash (HashTable<Type>* table, ssize new_num);
template<class Type> void hashtable_rehash_fast (HashTable<Type> table);
template<class Type> void hashtable_remove (HashTable<Type> table, u64 key);
template<class Type> void hashtable_remove_entry(HashTable<Type> table, ssize idx);
template<class Type> void hashtable_set (HashTable<Type>* table, u64 key, Type value);
template<class Type> ssize hashtable_slot (HashTable<Type> table, u64 key);
template<class Type> void hashtable_map (HashTable<Type> table, void (*map_proc)(u64 key, Type value));
template<class Type> void hashtable_map_mut (HashTable<Type> table, void (*map_proc)(u64 key, Type* value));
template<class Type> ssize hashtable__add_entry (HashTable<Type>* table, u64 key);
template<class Type> HashTableFindResult hashtable__find (HashTable<Type> table, u64 key);
template<class Type> bool hashtable__full (HashTable<Type> table);
static constexpr f32 HashTable_CriticalLoadScale = 0.7f;
template<typename Type>
struct HashTable
{
Array<ssize> Hashes;
Array<HashTableEntry<Type>> Entries;
#if ! GEN_C_LIKE_CPP
#pragma region Member Mapping
forceinline static HashTable init(AllocatorInfo allocator) { return hashtable_init<Type>(allocator); }
forceinline static HashTable init_reserve(AllocatorInfo allocator, usize num) { return hashtable_init_reserve<Type>(allocator, num); }
forceinline void clear() { clear<Type>(*this); }
forceinline void destroy() { destroy<Type>(*this); }
forceinline Type* get(u64 key) { return get<Type>(*this, key); }
forceinline void grow() { grow<Type>(*this); }
forceinline void rehash(ssize new_num) { rehash<Type>(*this, new_num); }
forceinline void rehash_fast() { rehash_fast<Type>(*this); }
forceinline void remove(u64 key) { remove<Type>(*this, key); }
forceinline void remove_entry(ssize idx) { remove_entry<Type>(*this, idx); }
forceinline void set(u64 key, Type value) { set<Type>(*this, key, value); }
forceinline ssize slot(u64 key) { return slot<Type>(*this, key); }
forceinline void map(void (*proc)(u64, Type)) { map<Type>(*this, proc); }
forceinline void map_mut(void (*proc)(u64, Type*)) { map_mut<Type>(*this, proc); }
#pragma endregion Member Mapping
#endif
using DataType = Type;
};
#if GEN_SUPPORT_CPP_REFERENCES
template<class Type> void destroy (HashTable<Type>& table) { destroy(& table); }
template<class Type> void grow (HashTable<Type>& table) { grow(& table); }
template<class Type> void rehash (HashTable<Type>& table, ssize new_num) { rehash(& table, new_num); }
template<class Type> void set (HashTable<Type>& table, u64 key, Type value) { set(& table, key, value); }
template<class Type> ssize add_entry(HashTable<Type>& table, u64 key) { add_entry(& table, key); }
#endif
template<typename Type> inline
HashTable<Type> hashtable_init(AllocatorInfo allocator) {
HashTable<Type> result = hashtable_init_reserve<Type>(allocator, 8);
return result;
}
template<typename Type> inline
HashTable<Type> hashtable_init_reserve(AllocatorInfo allocator, usize num)
{
HashTable<Type> result = { { nullptr }, { nullptr } };
result.Hashes = array_init_reserve<ssize>(allocator, num);
array_get_header(result.Hashes)->Num = num;
array_resize(& result.Hashes, num);
array_fill(result.Hashes, 0, num, (ssize)-1);
result.Entries = array_init_reserve<HashTableEntry<Type>>(allocator, num);
return result;
}
template<typename Type> forceinline
void hashtable_clear(HashTable<Type> table) {
GEN_ASSERT_NOT_NULL(table.Hashes);
GEN_ASSERT_NOT_NULL(table.Entries);
array_clear(table.Entries);
array_fill(table.Hashes, 0, array_num(table.Hashes), (ssize)-1);
}
template<typename Type> forceinline
void hashtable_destroy(HashTable<Type>* table) {
GEN_ASSERT_NOT_NULL(table->Hashes);
GEN_ASSERT_NOT_NULL(table->Entries);
if (table->Hashes && array_get_header(table->Hashes)->Capacity) {
array_free(table->Hashes);
array_free(table->Entries);
}
}
template<typename Type> forceinline
Type* hashtable_get(HashTable<Type> table, u64 key) {
GEN_ASSERT_NOT_NULL(table.Hashes);
GEN_ASSERT_NOT_NULL(table.Entries);
ssize idx = hashtable__find(table, key).EntryIndex;
if (idx >= 0)
return & table.Entries[idx].Value;
return nullptr;
}
template<typename Type> forceinline
void hashtable_map(HashTable<Type> table, void (*map_proc)(u64 key, Type value)) {
GEN_ASSERT_NOT_NULL(table.Hashes);
GEN_ASSERT_NOT_NULL(table.Entries);
GEN_ASSERT_NOT_NULL(map_proc);
for (ssize idx = 0; idx < ssize(num(table.Entries)); ++idx) {
map_proc(table.Entries[idx].Key, table.Entries[idx].Value);
}
}
template<typename Type> forceinline
void hashtable_map_mut(HashTable<Type> table, void (*map_proc)(u64 key, Type* value)) {
GEN_ASSERT_NOT_NULL(table.Hashes);
GEN_ASSERT_NOT_NULL(table.Entries);
GEN_ASSERT_NOT_NULL(map_proc);
for (ssize idx = 0; idx < ssize(num(table.Entries)); ++idx) {
map_proc(table.Entries[idx].Key, & table.Entries[idx].Value);
}
}
template<typename Type> forceinline
void hashtable_grow(HashTable<Type>* table) {
GEN_ASSERT_NOT_NULL(table);
GEN_ASSERT_NOT_NULL(table->Hashes);
GEN_ASSERT_NOT_NULL(table->Entries);
ssize new_num = array_grow_formula( array_num(table->Entries));
hashtable_rehash(table, new_num);
}
template<typename Type> inline
void hashtable_rehash(HashTable<Type>* table, ssize new_num)
{
GEN_ASSERT_NOT_NULL(table);
GEN_ASSERT_NOT_NULL(table->Hashes);
GEN_ASSERT_NOT_NULL(table->Entries);
ssize last_added_index;
HashTable<Type> new_ht = hashtable_init_reserve<Type>( array_get_header(table->Hashes)->Allocator, new_num);
for (ssize idx = 0; idx < ssize( array_num(table->Entries)); ++idx)
{
HashTableFindResult find_result;
HashTableEntry<Type>& entry = table->Entries[idx];
find_result = hashtable__find(new_ht, entry.Key);
last_added_index = hashtable__add_entry(& new_ht, entry.Key);
if (find_result.PrevIndex < 0)
new_ht.Hashes[find_result.HashIndex] = last_added_index;
else
new_ht.Entries[find_result.PrevIndex].Next = last_added_index;
new_ht.Entries[last_added_index].Next = find_result.EntryIndex;
new_ht.Entries[last_added_index].Value = entry.Value;
}
hashtable_destroy(table);
* table = new_ht;
}
template<typename Type> inline
void hashtable_rehash_fast(HashTable<Type> table)
{
GEN_ASSERT_NOT_NULL(table.Hashes);
GEN_ASSERT_NOT_NULL(table.Entries);
ssize idx;
for (idx = 0; idx < ssize(num(table.Entries)); idx++)
table.Entries[idx].Next = -1;
for (idx = 0; idx < ssize(num(table.Hashes)); idx++)
table.Hashes[idx] = -1;
for (idx = 0; idx < ssize(num(table.Entries)); idx++)
{
HashTableEntry<Type>* entry;
HashTableFindResult find_result;
entry = &table.Entries[idx];
find_result = find(table, entry->Key);
if (find_result.PrevIndex < 0)
table.Hashes[find_result.HashIndex] = idx;
else
table.Entries[find_result.PrevIndex].Next = idx;
}
}
template<typename Type> forceinline
void hashtable_remove(HashTable<Type> table, u64 key) {
GEN_ASSERT_NOT_NULL(table.Hashes);
GEN_ASSERT_NOT_NULL(table.Entries);
HashTableFindResult find_result = find(table, key);
if (find_result.EntryIndex >= 0) {
remove_at(table.Entries, find_result.EntryIndex);
rehash_fast(table);
}
}
template<typename Type> forceinline
void hashtable_remove_entry(HashTable<Type> table, ssize idx) {
GEN_ASSERT_NOT_NULL(table.Hashes);
GEN_ASSERT_NOT_NULL(table.Entries);
remove_at(table.Entries, idx);
}
template<typename Type> inline
void hashtable_set(HashTable<Type>* table, u64 key, Type value)
{
GEN_ASSERT_NOT_NULL(table);
GEN_ASSERT_NOT_NULL(table->Hashes);
GEN_ASSERT_NOT_NULL(table->Entries);
ssize idx;
HashTableFindResult find_result;
if (hashtable_full(* table))
hashtable_grow(table);
find_result = hashtable__find(* table, key);
if (find_result.EntryIndex >= 0) {
idx = find_result.EntryIndex;
}
else
{
idx = hashtable__add_entry(table, key);
if (find_result.PrevIndex >= 0) {
table->Entries[find_result.PrevIndex].Next = idx;
}
else {
table->Hashes[find_result.HashIndex] = idx;
}
}
table->Entries[idx].Value = value;
if (hashtable_full(* table))
hashtable_grow(table);
}
template<typename Type> forceinline
ssize hashtable_slot(HashTable<Type> table, u64 key) {
GEN_ASSERT_NOT_NULL(table.Hashes);
GEN_ASSERT_NOT_NULL(table.Entries);
for (ssize idx = 0; idx < ssize(num(table.Hashes)); ++idx)
if (table.Hashes[idx] == key)
return idx;
return -1;
}
template<typename Type> forceinline
ssize hashtable__add_entry(HashTable<Type>* table, u64 key) {
GEN_ASSERT_NOT_NULL(table);
GEN_ASSERT_NOT_NULL(table->Hashes);
GEN_ASSERT_NOT_NULL(table->Entries);
ssize idx;
HashTableEntry<Type> entry = { key, -1 };
idx = array_num(table->Entries);
array_append( table->Entries, entry);
return idx;
}
template<typename Type> inline
HashTableFindResult hashtable__find(HashTable<Type> table, u64 key)
{
GEN_ASSERT_NOT_NULL(table.Hashes);
GEN_ASSERT_NOT_NULL(table.Entries);
HashTableFindResult result = { -1, -1, -1 };
if (array_num(table.Hashes) > 0)
{
result.HashIndex = key % array_num(table.Hashes);
result.EntryIndex = table.Hashes[result.HashIndex];
while (result.EntryIndex >= 0)
{
if (table.Entries[result.EntryIndex].Key == key)
break;
result.PrevIndex = result.EntryIndex;
result.EntryIndex = table.Entries[result.EntryIndex].Next;
}
}
return result;
}
template<typename Type> forceinline
bool hashtable_full(HashTable<Type> table) {
GEN_ASSERT_NOT_NULL(table.Hashes);
GEN_ASSERT_NOT_NULL(table.Entries);
usize critical_load = usize(HashTable_CriticalLoadScale * f32(array_num(table.Hashes)));
b32 result = array_num(table.Entries) > critical_load;
return result;
}
#define hashtable_init(type, allocator) hashtable_init <type >(allocator)
#define hashtable_init_reserve(type, allocator, num) hashtable_init_reserve<type >(allocator, num)
#define hashtable_clear(table) hashtable_clear < get_hashtable_underlying_type(table) >(table)
#define hashtable_destroy(table) hashtable_destroy < get_hashtable_underlying_type(table) >(& table)
#define hashtable_get(table, key) hashtable_get < get_hashtable_underlying_type(table) >(table, key)
#define hashtable_grow(table) hashtable_grow < get_hashtable_underlying_type(table) >(& table)
#define hashtable_rehash(table, new_num) hashtable_rehash < get_hashtable_underlying_type(table) >(& table, new_num)
#define hashtable_rehash_fast(table) hashtable_rehash_fast < get_hashtable_underlying_type(table) >(table)
#define hashtable_remove(table, key) hashtable_remove < get_hashtable_underlying_type(table) >(table, key)
#define hashtable_remove_entry(table, idx) hashtable_remove_entry< get_hashtable_underlying_type(table) >(table, idx)
#define hashtable_set(table, key, value) hashtable_set < get_hashtable_underlying_type(table) >(& table, key, value)
#define hashtable_slot(table, key) hashtable_slot < get_hashtable_underlying_type(table) >(table, key)
#define hashtable_map(table, map_proc) hashtable_map < get_hashtable_underlying_type(table) >(table, map_proc)
#define hashtable_map_mut(table, map_proc) hashtable_map_mut < get_hashtable_underlying_type(table) >(table, map_proc)
//#define hashtable_add_entry(table, key) hashtable_add_entry < get_hashtable_underlying_type(table) >(& table, key)
//#define hashtable_find(table, key) hashtable_find < get_hashtable_underlying_type(table) >(table, key)
//#define hashtable_full(table) hashtable_full < get_hashtable_underlying_type(table) >(table)
#pragma endregion HashTable
#pragma endregion Containers

6
project/dependencies/debug.cpp → base/dependencies/debug.cpp
View File

@ -1,15 +1,13 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "debug.hpp"
# include "basic_types.hpp"
# include "src_start.cpp"
#endif
#pragma region Debug
void assert_handler( char const* condition, char const* file, s32 line, char const* msg, ... )
void assert_handler( char const* condition, char const* file, char const* function, s32 line, char const* msg, ... )
{
_printf_err( "%s:(%d): Assert Failure: ", file, line );
_printf_err( "%s - %s:(%d): Assert Failure: ", file, function, line );
if ( condition )
_printf_err( "`%s` \n", condition );

21
project/dependencies/debug.hpp → base/dependencies/debug.hpp
View File

@ -1,6 +1,9 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "dependencies/platform.hpp"
# include "dependencies/macros.hpp"
# include "basic_types.hpp"
# include "macros.hpp"
#endif
#pragma region Debug
@ -19,14 +22,14 @@
#define GEN_ASSERT( cond ) GEN_ASSERT_MSG( cond, NULL )
#define GEN_ASSERT_MSG( cond, msg, ... ) \
do \
{ \
if ( ! ( cond ) ) \
{ \
assert_handler( #cond, __FILE__, scast( s64, __LINE__ ), msg, ##__VA_ARGS__ ); \
GEN_DEBUG_TRAP(); \
} \
#define GEN_ASSERT_MSG( cond, msg, ... ) \
do \
{ \
if ( ! ( cond ) ) \
{ \
assert_handler( #cond, __FILE__, __func__, scast( s64, __LINE__ ), msg, ##__VA_ARGS__ ); \
GEN_DEBUG_TRAP(); \
} \
} while ( 0 )
#define GEN_ASSERT_NOT_NULL( ptr ) GEN_ASSERT_MSG( ( ptr ) != NULL, #ptr " must not be NULL" )
@ -56,7 +59,7 @@
while (0)
#endif
void assert_handler( char const* condition, char const* file, s32 line, char const* msg, ... );
void assert_handler( char const* condition, char const* file, char const* function, s32 line, char const* msg, ... );
s32 assert_crash( char const* condition );
void process_exit( u32 code );

29
project/dependencies/filesystem.cpp → base/dependencies/filesystem.cpp
View File

@ -36,7 +36,7 @@ wchar_t* _alloc_utf8_to_ucs2( AllocatorInfo a, char const* text, ssize* w_len_ )
w_len1 = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, text, scast( int, len), w_text, scast( int, w_len) );
if ( w_len1 == 0 )
{
free( a, w_text );
allocator_free( a, w_text );
if ( w_len_ )
*w_len_ = 0;
return NULL;
@ -145,7 +145,7 @@ GEN_FILE_OPEN_PROC( _win32_file_open )
w_text = _alloc_utf8_to_ucs2( heap(), filename, NULL );
handle = CreateFileW( w_text, desired_access, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, creation_disposition, FILE_ATTRIBUTE_NORMAL, NULL );
free( heap(), w_text );
allocator_free( heap(), w_text );
if ( handle == INVALID_HANDLE_VALUE )
{
@ -340,7 +340,7 @@ FileError file_close( FileInfo* f )
return EFileError_INVALID;
if ( f->filename )
free( heap(), ccast( char*, f->filename ));
allocator_free( heap(), ccast( char*, f->filename ));
#if defined( GEN_SYSTEM_WINDOWS )
if ( f->fd.p == INVALID_HANDLE_VALUE )
@ -459,6 +459,7 @@ FileContents file_read_contents( AllocatorInfo a, b32 zero_terminate, char const
return result;
}
typedef struct _memory_fd _memory_fd;
struct _memory_fd
{
u8 magic;
@ -505,7 +506,7 @@ b8 file_stream_new( FileInfo* file, AllocatorInfo allocator )
d->allocator = allocator;
d->flags = EFileStream_CLONE_WRITABLE;
d->cap = 0;
d->buf = Array<u8>::init( allocator );
d->buf = array_init( u8, allocator );
if ( ! d->buf )
return false;
@ -531,7 +532,7 @@ b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, ssize
d->flags = flags;
if ( d->flags & EFileStream_CLONE_WRITABLE )
{
Array<u8> arr = Array<u8>::init_reserve( allocator, size );
Array(u8) arr = array_init_reserve(u8, allocator, size );
d->buf = arr;
if ( ! d->buf )
@ -540,7 +541,7 @@ b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, ssize
mem_copy( d->buf, buffer, size );
d->cap = size;
arr.get_header()->Num = size;
array_get_header(arr)->Num = size;
}
else
{
@ -608,11 +609,11 @@ GEN_FILE_WRITE_AT_PROC( _memory_file_write )
if ( d->flags & EFileStream_CLONE_WRITABLE )
{
Array<u8> arr = { d->buf };
Array(u8) arr = { d->buf };
if ( arr.get_header()->Capacity < usize(new_cap) )
if ( array_get_header(arr)->Capacity < scast(usize, new_cap) )
{
if ( ! arr.grow( ( s64 )( new_cap ) ) )
if ( ! array_grow( & arr, ( s64 )( new_cap ) ) )
return false;
d->buf = arr;
}
@ -622,11 +623,11 @@ GEN_FILE_WRITE_AT_PROC( _memory_file_write )
if ( ( d->flags & EFileStream_CLONE_WRITABLE ) && extralen > 0 )
{
Array<u8> arr = { d->buf };
Array(u8) arr = { d->buf };
mem_copy( d->buf + offset + rwlen, pointer_add_const( buffer, rwlen ), extralen );
d->cap = new_cap;
arr.get_header()->Capacity = new_cap;
array_get_header(arr)->Capacity = new_cap;
}
else
{
@ -646,11 +647,11 @@ GEN_FILE_CLOSE_PROC( _memory_file_close )
if ( d->flags & EFileStream_CLONE_WRITABLE )
{
Array<u8> arr = { d->buf };
arr.free();
Array(u8) arr = { d->buf };
array_free(arr);
}
free( allocator, d );
allocator_free( allocator, d );
}
FileOperations const memory_file_operations = { _memory_file_read, _memory_file_write, _memory_file_seek, _memory_file_close };

18
project/dependencies/filesystem.hpp → base/dependencies/filesystem.hpp
View File

@ -5,8 +5,6 @@
#pragma region File Handling
typedef u32 FileMode;
enum FileModeFlag
{
EFileMode_READ = bit( 0 ),
@ -45,11 +43,12 @@ union FileDescriptor
uptr u;
};
typedef u32 FileMode;
typedef struct FileOperations FileOperations;
#define GEN_FILE_OPEN_PROC( name ) FileError name( FileDescriptor* fd, FileOperations* ops, FileMode mode, char const* filename )
#define GEN_FILE_READ_AT_PROC( name ) b32 name( FileDescriptor fd, void* buffer, ssize size, s64 offset, ssize* bytes_read, b32 stop_at_newline )
#define GEN_FILE_WRITE_AT_PROC( name ) b32 name( FileDescriptor fd, void const* buffer, ssize size, s64 offset, ssize* bytes_written )
#define GEN_FILE_WRITE_AT_PROC( name ) b32 name( FileDescriptor fd, mem_ptr_const buffer, ssize size, s64 offset, ssize* bytes_written )
#define GEN_FILE_SEEK_PROC( name ) b32 name( FileDescriptor fd, s64 offset, SeekWhenceType whence, s64* new_offset )
#define GEN_FILE_CLOSE_PROC( name ) void name( FileDescriptor fd )
@ -82,9 +81,9 @@ struct DirInfo;
struct DirEntry
{
char const* filename;
struct DirInfo* dir_info;
u8 type;
char const* filename;
DirInfo* dir_info;
u8 type;
};
struct DirInfo
@ -183,6 +182,7 @@ b32 file_read_at( FileInfo* file, void* buffer, ssize size, s64 offset );
*/
b32 file_read_at_check( FileInfo* file, void* buffer, ssize size, s64 offset, ssize* bytes_read );
typedef struct FileContents FileContents;
struct FileContents
{
AllocatorInfo allocator;
@ -190,8 +190,8 @@ struct FileContents
ssize size;
};
constexpr b32 zero_terminate = true;
constexpr b32 no_zero_terminate = false;
constexpr b32 file_zero_terminate = true;
constexpr b32 file_no_zero_terminate = false;
/**
* Reads the whole file contents
@ -265,6 +265,8 @@ enum FileStreamFlags : u32
/* Clones the input buffer so you can write (zpl_file_write*) data into it. */
/* Since we work with a clone, the buffer size can dynamically grow as well. */
EFileStream_CLONE_WRITABLE = bit( 1 ),
EFileStream_UNDERLYING = GEN_U32_MAX,
};
/**

0
project/dependencies/hashing.cpp → base/dependencies/hashing.cpp
View File

0
project/dependencies/hashing.hpp → base/dependencies/hashing.hpp
View File

160
project/dependencies/macros.hpp → base/dependencies/macros.hpp
View File

@ -1,5 +1,6 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "platform.hpp"
#endif
#pragma region Macros
@ -14,26 +15,52 @@
#define local_persist static // Local Persisting variables
#endif
#ifndef api_c
#define api_c extern "C"
#endif
#ifndef bit
#define bit( Value ) ( 1 << Value )
#define bitfield_is_equal( Type, Field, Mask ) ( (Type(Mask) & Type(Field)) == Type(Mask) )
#define bitfield_is_equal( Type, Field, Mask ) ( (scast(Type, Mask) & scast(Type, Field)) == scast(Type, Mask) )
#endif
#ifndef ccast
#define ccast( type, value ) ( const_cast< type >( (value) ) )
// Mainly intended for forcing the base library to utilize only C-valid constructs or type coercion
#ifndef GEN_C_LIKE_CPP
#define GEN_C_LIKE_CPP 0
#endif
#ifndef pcast
#define pcast( type, value ) ( * reinterpret_cast< type* >( & ( value ) ) )
#if GEN_COMPILER_CPP
# ifndef cast
# define cast( type, value ) (tmpl_cast<type>( value ))
# endif
#else
# ifndef cast
# define cast( type, value ) ( (type)(value) )
# endif
#endif
#ifndef rcast
#define rcast( type, value ) reinterpret_cast< type >( value )
#endif
#ifndef scast
#define scast( type, value ) static_cast< type >( value )
#if GEN_COMPILER_CPP
# ifndef ccast
# define ccast( type, value ) ( const_cast< type >( (value) ) )
# endif
# ifndef pcast
# define pcast( type, value ) ( * reinterpret_cast< type* >( & ( value ) ) )
# endif
# ifndef rcast
# define rcast( type, value ) reinterpret_cast< type >( value )
# endif
# ifndef scast
# define scast( type, value ) static_cast< type >( value )
# endif
#else
# ifndef ccast
# define ccast( type, value ) ( (type)(value) )
# endif
# ifndef pcast
# define pcast( type, value ) ( * (type*)(& value) )
# endif
# ifndef rcast
# define rcast( type, value ) ( (type)(value) )
# endif
# ifndef scast
# define scast( type, value ) ( (type)(value) )
# endif
#endif
#ifndef stringize
@ -72,6 +99,10 @@
#endif
#ifndef num_args_impl
// This is essentially an arg couneter version of GEN_SELECT_ARG macros
// See section : _Generic function overloading for that usage (explains this heavier case)
#define num_args_impl( _0, \
_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
_11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \
@ -123,20 +154,20 @@
#define min( a, b ) ( (a < b) ? (a) : (b) )
#endif
#if defined( _MSC_VER ) || defined( GEN_COMPILER_TINYC )
#if GEN_COMPILER_MSVC || GEN_COMPILER_TINYC
# define offset_of( Type, element ) ( ( GEN_NS( ssize ) ) & ( ( ( Type* )0 )->element ) )
#else
# define offset_of( Type, element ) __builtin_offsetof( Type, element )
#endif
#ifndef forceinline
# ifdef GEN_COMPILER_MSVC
# if GEN_COMPILER_MSVC
# define forceinline __forceinline
# define neverinline __declspec( noinline )
# elif defined(GEN_COMPILER_GCC)
# elif GEN_COMPILER_GCC
# define forceinline inline __attribute__((__always_inline__))
# define neverinline __attribute__( ( __noinline__ ) )
# elif defined(GEN_COMPILER_CLANG)
# elif GEN_COMPILER_CLANG
# if __has_attribute(__always_inline__)
# define forceinline inline __attribute__((__always_inline__))
# define neverinline __attribute__( ( __noinline__ ) )
@ -151,11 +182,11 @@
#endif
#ifndef neverinline
# ifdef GEN_COMPILER_MSVC
# if GEN_COMPILER_MSVC
# define neverinline __declspec( noinline )
# elif defined(GEN_COMPILER_GCC)
# elif GEN_COMPILER_GCC
# define neverinline __attribute__( ( __noinline__ ) )
# elif defined(GEN_COMPILER_CLANG)
# elif GEN_COMPILER_CLANG
# if __has_attribute(__always_inline__)
# define neverinline __attribute__( ( __noinline__ ) )
# else
@ -166,4 +197,91 @@
# endif
#endif
#if GEN_COMPILER_C
#ifndef static_assert
#undef static_assert
#if GEN_COMPILER_C && __STDC_VERSION__ >= 201112L
#define static_assert(condition, message) _Static_assert(condition, message)
#else
#define static_assert(condition, message) typedef char static_assertion_##__LINE__[(condition)?1:-1]
#endif
#endif
#endif
#if GEN_COMPILER_CPP
// Already Defined
#elif GEN_COMPILER_C && __STDC_VERSION__ >= 201112L
# define thread_local _Thread_local
#elif GEN_COMPILER_MSVC
# define thread_local __declspec(thread)
#elif GEN_COMPILER_CLANG
# define thread_local __thread
#else
# error "No thread local support"
#endif
#if ! defined(typeof) && (!GEN_COMPILER_C || __STDC_VERSION__ < 202311L)
# if ! GEN_COMPILER_C
# define typeof decltype
# elif defined(_MSC_VER)
# define typeof(x) __typeof__(x)
# elif defined(__GNUC__) || defined(__clang__)
# define typeof(x) __typeof__(x)
# else
# error "Compiler not supported"
# endif
#endif
#ifndef GEN_API_C_BEGIN
# if GEN_COMPILER_C
# define GEN_API_C_BEGIN
# define GEN_API_C_END
# else
# define GEN_API_C_BEGIN extern "C" {
# define GEN_API_C_END }
# endif
#endif
#if GEN_COMPILER_C
# if __STDC_VERSION__ >= 202311L
# define enum_underlying(type) : type
# else
# define enum_underlying(type)
# endif
#else
# define enum_underlying(type) : type
#endif
#if GEN_COMPILER_C
# ifndef nullptr
# define nullptr NULL
# endif
# ifndef GEN_REMOVE_PTR
# define GEN_REMOVE_PTR(type) typeof(* ( (type) NULL) )
# endif
#endif
#if ! defined(GEN_PARAM_DEFAULT) && GEN_COMPILER_CPP
# define GEN_PARAM_DEFAULT = {}
#else
# define GEN_PARAM_DEFAULT
#endif
#if GEN_COMPILER_CPP
#define struct_init(type, value) {value}
#else
#define struct_init(type, value) {value}
#endif
#if 0
#ifndef GEN_OPTIMIZE_MAPPINGS_BEGIN
# define GEN_OPTIMIZE_MAPPINGS_BEGIN _pragma(optimize("gt", on))
# define GEN_OPITMIZE_MAPPINGS_END _pragma(optimize("", on))
#endif
#else
# define GEN_OPTIMIZE_MAPPINGS_BEGIN
# define GEN_OPITMIZE_MAPPINGS_END
#endif
#pragma endregion Macros

26
project/dependencies/memory.cpp → base/dependencies/memory.cpp
View File

@ -7,9 +7,9 @@
void* mem_copy( void* dest, void const* source, ssize n )
{
if ( dest == NULL )
if ( dest == nullptr )
{
return NULL;
return nullptr;
}
return memcpy( dest, source, n );
@ -46,6 +46,7 @@ void const* mem_find( void const* data, u8 c, ssize n )
#define GEN_HEAP_STATS_MAGIC 0xDEADC0DE
typedef struct _heap_stats _heap_stats;
struct _heap_stats
{
u32 magic;
@ -80,6 +81,7 @@ void heap_stats_check( void )
GEN_ASSERT( _heap_stats_info.alloc_count == 0 );
}
typedef struct _heap_alloc_info _heap_alloc_info;
struct _heap_alloc_info
{
ssize size;
@ -334,7 +336,7 @@ ssize virtual_memory_page_size( ssize* alignment_out )
#pragma endregion VirtualMemory
void* Arena::allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
void* arena_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
{
Arena* arena = rcast(Arena*, allocator_data);
void* ptr = NULL;
@ -346,7 +348,7 @@ void* Arena::allocator_proc( void* allocator_data, AllocType type, ssize size, s
case EAllocation_ALLOC :
{
void* end = pointer_add( arena->PhysicalStart, arena->TotalUsed );
ssize total_size = align_forward_i64( size, alignment );
ssize total_size = align_forward_s64( size, alignment );
// NOTE: Out of memory
if ( arena->TotalUsed + total_size > (ssize) arena->TotalSize )
@ -384,7 +386,7 @@ void* Arena::allocator_proc( void* allocator_data, AllocType type, ssize size, s
return ptr;
}
void* Pool::allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
void* pool_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
{
Pool* pool = rcast( Pool*, allocator_data);
void* ptr = NULL;
@ -457,7 +459,7 @@ void* Pool::allocator_proc( void* allocator_data, AllocType type, ssize size, ss
return ptr;
}
Pool Pool::init_align( AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align )
Pool pool_init_align( AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align )
{
Pool pool = {};
@ -495,16 +497,16 @@ Pool Pool::init_align( AllocatorInfo backing, ssize num_blocks, ssize block_size
return pool;
}
void Pool::clear()
void pool_clear(Pool* pool)
{
ssize actual_block_size, block_index;
ssize actual_block_size, block_index;
void* curr;
uptr* end;
actual_block_size = BlockSize + BlockAlign;
actual_block_size = pool->BlockSize + pool->BlockAlign;
curr = PhysicalStart;
for ( block_index = 0; block_index < NumBlocks - 1; block_index++ )
curr = pool->PhysicalStart;
for ( block_index = 0; block_index < pool->NumBlocks - 1; block_index++ )
{
uptr* next = ( uptr* ) curr;
*next = ( uptr ) curr + actual_block_size;
@ -514,7 +516,7 @@ void Pool::clear()
end = ( uptr* ) curr;
*end = ( uptr ) NULL;
FreeList = PhysicalStart;
pool->FreeList = pool->PhysicalStart;
}
#pragma endregion Memory

396
project/dependencies/memory.hpp → base/dependencies/memory.hpp
View File

@ -29,7 +29,7 @@ b32 is_power_of_two( ssize x );
void* align_forward( void* ptr, ssize alignment );
//! Aligns value to a specified alignment.
s64 align_forward_i64( s64 value, ssize alignment );
s64 align_forward_by_value( s64 value, ssize alignment );
//! Moves pointer forward by bytes.
void* pointer_add( void* ptr, ssize bytes );
@ -70,10 +70,7 @@ enum AllocType : u8
EAllocation_RESIZE,
};
using AllocatorProc = void* ( void* allocator_data, AllocType type
, ssize size, ssize alignment
, void* old_memory, ssize old_size
, u64 flags );
typedef void*(AllocatorProc)( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
struct AllocatorInfo
{
@ -101,7 +98,7 @@ void* alloc( AllocatorInfo a, ssize size );
void* alloc_align( AllocatorInfo a, ssize size, ssize alignment );
//! Free allocated memory.
void free( AllocatorInfo a, void* ptr );
void allocator_free( AllocatorInfo a, void* ptr );
//! Free all memory allocated by an allocator.
void free_all( AllocatorInfo a );
@ -135,7 +132,7 @@ void* default_resize_align( AllocatorInfo a, void* ptr, ssize old_size, ssize ne
void* heap_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
//! The heap allocator backed by operating system's memory manager.
constexpr AllocatorInfo heap( void ) { return { heap_allocator_proc, nullptr }; }
constexpr AllocatorInfo heap( void ) { AllocatorInfo allocator = { heap_allocator_proc, nullptr }; return allocator; }
//! Helper to allocate memory using heap allocator.
#define malloc( sz ) alloc( heap(), sz )
@ -165,163 +162,243 @@ b32 vm_free( VirtualMemory vm );
VirtualMemory vm_trim( VirtualMemory vm, ssize lead_size, ssize size );
//! Purge virtual memory.
b32 gen_vm_purge( VirtualMemory vm );
b32 vm_purge( VirtualMemory vm );
//! Retrieve VM's page size and alignment.
ssize gen_virtual_memory_page_size( ssize* alignment_out );
ssize virtual_memory_page_size( ssize* alignment_out );
#pragma region Arena
struct Arena;
AllocatorInfo arena_allocator_info( Arena* arena );
// Remove static keyword and rename allocator_proc
void* arena_allocator_proc(void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags);
// Add these declarations after the Arena struct
Arena arena_init_from_allocator(AllocatorInfo backing, ssize size);
Arena arena_init_from_memory ( void* start, ssize size );
Arena arena_init_sub (Arena* parent, ssize size);
ssize arena_alignment_of (Arena* arena, ssize alignment);
void arena_check (Arena* arena);
void arena_free (Arena* arena);
ssize arena_size_remaining(Arena* arena, ssize alignment);
struct Arena
{
static
void* allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
AllocatorInfo Backing;
void* PhysicalStart;
ssize TotalSize;
ssize TotalUsed;
ssize TempCount;
static
Arena init_from_memory( void* start, ssize size )
{
return
{
{ nullptr, nullptr },
start,
size,
0,
0
};
}
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
#pragma region Member Mapping
forceinline operator AllocatorInfo() { return arena_allocator_info(this); }
static
Arena init_from_allocator( AllocatorInfo backing, ssize size )
{
Arena result =
{
backing,
alloc( backing, size),
size,
0,
0
};
return result;
}
static
Arena init_sub( Arena& parent, ssize size )
{
return init_from_allocator( parent.Backing, size );
}
ssize alignment_of( ssize alignment )
{
ssize alignment_offset, result_pointer, mask;
GEN_ASSERT( is_power_of_two( alignment ) );
alignment_offset = 0;
result_pointer = (ssize) PhysicalStart + TotalUsed;
mask = alignment - 1;
if ( result_pointer & mask )
alignment_offset = alignment - ( result_pointer & mask );
return alignment_offset;
}
forceinline static void* allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags ) { return arena_allocator_proc( allocator_data, type, size, alignment, old_memory, old_size, flags ); }
forceinline static Arena init_from_memory( void* start, ssize size ) { return arena_init_from_memory( start, size ); }
forceinline static Arena init_from_allocator( AllocatorInfo backing, ssize size ) { return arena_init_from_allocator( backing, size ); }
forceinline static Arena init_sub( Arena& parent, ssize size ) { return arena_init_from_allocator( parent.Backing, size ); }
forceinline ssize alignment_of( ssize alignment ) { return arena_alignment_of(this, alignment); }
forceinline void free() { return arena_free(this); }
forceinline ssize size_remaining( ssize alignment ) { return arena_size_remaining(this, alignment); }
// This id is defined by Unreal for asserts
#pragma push_macro("check")
#undef check
void check()
{
GEN_ASSERT( TempCount == 0 );
}
forceinline void check() { arena_check(this); }
#pragma pop_macro("check")
void free()
{
if ( Backing.Proc )
{
gen::free( Backing, PhysicalStart );
PhysicalStart = nullptr;
}
}
ssize size_remaining( ssize alignment )
{
ssize result = TotalSize - ( TotalUsed + alignment_of( alignment ) );
return result;
}
AllocatorInfo Backing;
void* PhysicalStart;
ssize TotalSize;
ssize TotalUsed;
ssize TempCount;
operator AllocatorInfo()
{
return { allocator_proc, this };
}
#pragma endregion Member Mapping
#endif
};
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
forceinline AllocatorInfo allocator_info(Arena& arena ) { return arena_allocator_info(& arena); }
forceinline Arena init_sub (Arena& parent, ssize size) { return arena_init_sub( & parent, size); }
forceinline ssize alignment_of (Arena& arena, ssize alignment) { return arena_alignment_of( & arena, alignment); }
forceinline void free (Arena& arena) { return arena_free(& arena); }
forceinline ssize size_remaining(Arena& arena, ssize alignment) { return arena_size_remaining(& arena, alignment); }
// This id is defined by Unreal for asserts
#pragma push_macro("check")
#undef check
forceinline void check(Arena& arena) { return arena_check(& arena); };
#pragma pop_macro("check")
#endif
inline
AllocatorInfo arena_allocator_info( Arena* arena ) {
GEN_ASSERT(arena != nullptr);
AllocatorInfo info = { arena_allocator_proc, arena };
return info;
}
inline
Arena arena_init_from_memory( void* start, ssize size )
{
Arena arena = {
{ nullptr, nullptr },
start,
size,
0,
0
};
return arena;
}
inline
Arena arena_init_from_allocator(AllocatorInfo backing, ssize size) {
Arena result = {
backing,
alloc(backing, size),
size,
0,
0
};
return result;
}
inline
Arena arena_init_sub(Arena* parent, ssize size) {
GEN_ASSERT(parent != nullptr);
return arena_init_from_allocator(parent->Backing, size);
}
inline
ssize arena_alignment_of(Arena* arena, ssize alignment)
{
GEN_ASSERT(arena != nullptr);
ssize alignment_offset, result_pointer, mask;
GEN_ASSERT(is_power_of_two(alignment));
alignment_offset = 0;
result_pointer = (ssize)arena->PhysicalStart + arena->TotalUsed;
mask = alignment - 1;
if (result_pointer & mask)
alignment_offset = alignment - (result_pointer & mask);
return alignment_offset;
}
inline
void arena_check(Arena* arena)
{
GEN_ASSERT(arena != nullptr );
GEN_ASSERT(arena->TempCount == 0);
}
inline
void arena_free(Arena* arena)
{
GEN_ASSERT(arena != nullptr);
if (arena->Backing.Proc)
{
allocator_free(arena->Backing, arena->PhysicalStart);
arena->PhysicalStart = nullptr;
}
}
inline
ssize arena_size_remaining(Arena* arena, ssize alignment)
{
GEN_ASSERT(arena != nullptr);
ssize result = arena->TotalSize - (arena->TotalUsed + arena_alignment_of(arena, alignment));
return result;
}
#pragma endregion Arena
#pragma region FixedArena
template<s32 Size>
struct FixedArena;
template<s32 Size> FixedArena<Size> fixed_arena_init();
template<s32 Size> AllocatorInfo fixed_arena_allocator_info(FixedArena<Size>* fixed_arena );
template<s32 Size> ssize fixed_arena_size_remaining(FixedArena<Size>* fixed_arena, ssize alignment);
template<s32 Size> void fixed_arena_free(FixedArena<Size>* fixed_arena);
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
template<s32 Size> AllocatorInfo allocator_info( FixedArena<Size>& fixed_arena ) { return allocator_info(& fixed_arena); }
template<s32 Size> ssize size_remaining(FixedArena<Size>& fixed_arena, ssize alignment) { return size_remaining( & fixed_arena, alignment); }
#endif
// Just a wrapper around using an arena with memory associated with its scope instead of from an allocator.
// Used for static segment or stack allocations.
template< s32 Size >
struct FixedArena
{
static
FixedArena init()
{
FixedArena result = { Arena::init_from_memory( result.memory, Size ), {0} };
return result;
}
ssize size_remaining( ssize alignment )
{
return arena.size_remaining( alignment );
}
operator AllocatorInfo()
{
return { Arena::allocator_proc, &arena };
}
char memory[Size];
Arena arena;
char memory[ Size ];
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
#pragma region Member Mapping
forceinline operator AllocatorInfo() { return fixed_arena_allocator_info(this); }
forceinline static FixedArena init() { FixedArena result; fixed_arena_init<Size>(result); return result; }
forceinline ssize size_remaining(ssize alignment) { fixed_arena_size_remaining(this, alignment); }
#pragma endregion Member Mapping
#endif
};
using Arena_1KB = FixedArena< kilobytes( 1 ) >;
using Arena_4KB = FixedArena< kilobytes( 4 ) >;
using Arena_8KB = FixedArena< kilobytes( 8 ) >;
using Arena_16KB = FixedArena< kilobytes( 16 ) >;
using Arena_32KB = FixedArena< kilobytes( 32 ) >;
using Arena_64KB = FixedArena< kilobytes( 64 ) >;
using Arena_128KB = FixedArena< kilobytes( 128 ) >;
using Arena_256KB = FixedArena< kilobytes( 256 ) >;
using Arena_512KB = FixedArena< kilobytes( 512 ) >;
using Arena_1MB = FixedArena< megabytes( 1 ) >;
using Arena_2MB = FixedArena< megabytes( 2 ) >;
using Arena_4MB = FixedArena< megabytes( 4 ) >;
template<s32 Size> inline
AllocatorInfo fixed_arena_allocator_info( FixedArena<Size>* fixed_arena ) {
GEN_ASSERT(fixed_arena);
return { arena_allocator_proc, & fixed_arena->arena };
}
template<s32 Size> inline
void fixed_arena_init(FixedArena<Size>* result) {
zero_size(& result->memory[0], Size);
result->arena = arena_init_from_memory(& result->memory[0], Size);
}
template<s32 Size> inline
void fixed_arena_free(FixedArena<Size>* fixed_arena) {
arena_free( & fixed_arena->arena);
}
template<s32 Size> inline
ssize fixed_arena_size_remaining(FixedArena<Size>* fixed_arena, ssize alignment) {
return size_remaining(fixed_arena->arena, alignment);
}
using FixedArena_1KB = FixedArena< kilobytes( 1 ) >;
using FixedArena_4KB = FixedArena< kilobytes( 4 ) >;
using FixedArena_8KB = FixedArena< kilobytes( 8 ) >;
using FixedArena_16KB = FixedArena< kilobytes( 16 ) >;
using FixedArena_32KB = FixedArena< kilobytes( 32 ) >;
using FixedArena_64KB = FixedArena< kilobytes( 64 ) >;
using FixedArena_128KB = FixedArena< kilobytes( 128 ) >;
using FixedArena_256KB = FixedArena< kilobytes( 256 ) >;
using FixedArena_512KB = FixedArena< kilobytes( 512 ) >;
using FixedArena_1MB = FixedArena< megabytes( 1 ) >;
using FixedArena_2MB = FixedArena< megabytes( 2 ) >;
using FixedArena_4MB = FixedArena< megabytes( 4 ) >;
#pragma endregion FixedArena
#pragma region Pool
struct Pool;
void* pool_allocator_proc(void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags);
Pool pool_init(AllocatorInfo backing, ssize num_blocks, ssize block_size);
Pool pool_init_align(AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align);
AllocatorInfo pool_allocator_info(Pool* pool);
void pool_clear(Pool* pool);
void pool_free(Pool* pool);
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
AllocatorInfo allocator_info(Pool& pool) { return pool_allocator_info(& pool); }
void clear(Pool& pool) { return pool_clear(& pool); }
void free(Pool& pool) { return pool_free(& pool); }
#endif
struct Pool
{
static
void* allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags );
static
Pool init( AllocatorInfo backing, ssize num_blocks, ssize block_size )
{
return init_align( backing, num_blocks, block_size, GEN_DEFAULT_MEMORY_ALIGNMENT );
}
static
Pool init_align( AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align );
void clear();
void free()
{
if ( Backing.Proc )
{
gen::free( Backing, PhysicalStart );
}
}
AllocatorInfo Backing;
void* PhysicalStart;
void* FreeList;
@ -330,12 +407,37 @@ struct Pool
ssize TotalSize;
ssize NumBlocks;
operator AllocatorInfo()
{
return { allocator_proc, this };
}
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
#pragma region Member Mapping
forceinline operator AllocatorInfo() { return pool_allocator_info(this); }
forceinline static void* allocator_proc(void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags) { return pool_allocator_proc(allocator_data, type, size, alignment, old_memory, old_size, flags); }
forceinline static Pool init(AllocatorInfo backing, ssize num_blocks, ssize block_size) { return pool_init(backing, num_blocks, block_size); }
forceinline static Pool init_align(AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align) { return pool_init_align(backing, num_blocks, block_size, block_align); }
forceinline void clear() { pool_clear( this); }
forceinline void free() { pool_free( this); }
#pragma endregion
#endif
};
inline
AllocatorInfo pool_allocator_info(Pool* pool) {
AllocatorInfo info = { pool_allocator_proc, pool };
return info;
}
inline
Pool pool_init(AllocatorInfo backing, ssize num_blocks, ssize block_size) {
return pool_init_align(backing, num_blocks, block_size, GEN_DEFAULT_MEMORY_ALIGNMENT);
}
inline
void pool_free(Pool* pool) {
if(pool->Backing.Proc) {
allocator_free(pool->Backing, pool->PhysicalStart);
}
}
#pragma endregion Pool
inline
b32 is_power_of_two( ssize x ) {
@ -354,9 +456,9 @@ mem_ptr align_forward( void* ptr, ssize alignment )
return to_mem_ptr(forward);
}
inline s64 align_forward_i64( s64 value, ssize alignment ) { return value + ( alignment - value % alignment ) % alignment; }
inline s64 align_forward_s64( s64 value, ssize alignment ) { return value + ( alignment - value % alignment ) % alignment; }
inline void* pointer_add ( void* ptr, ssize bytes ) { return rcast(void*, rcast( u8*, ptr) + bytes ); }
inline void* pointer_add ( void* ptr, ssize bytes ) { return rcast(void*, rcast( u8*, ptr) + bytes ); }
inline void const* pointer_add_const( void const* ptr, ssize bytes ) { return rcast(void const*, rcast( u8 const*, ptr) + bytes ); }
inline sptr pointer_diff( mem_ptr_const begin, mem_ptr_const end ) {
@ -512,7 +614,7 @@ void* alloc( AllocatorInfo a, ssize size ) {
}
inline
void free( AllocatorInfo a, void* ptr ) {
void allocator_free( AllocatorInfo a, void* ptr ) {
if ( ptr != nullptr )
a.Proc( a.Data, EAllocation_FREE, 0, 0, ptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS );
}
@ -540,7 +642,7 @@ void* default_resize_align( AllocatorInfo a, void* old_memory, ssize old_size, s
if ( new_size == 0 )
{
free( a, old_memory );
allocator_free( a, old_memory );
return nullptr;
}
@ -558,7 +660,7 @@ void* default_resize_align( AllocatorInfo a, void* old_memory, ssize old_size, s
return nullptr;
mem_move( new_memory, old_memory, min( new_size, old_size ) );
free( a, old_memory );
allocator_free( a, old_memory );
return new_memory;
}
}

67
project/dependencies/parsing.cpp → base/dependencies/parsing.cpp
View File

@ -1,5 +1,6 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "parsing.hpp"
#endif
#pragma region ADT
@ -23,7 +24,7 @@ u8 adt_make_branch( ADT_Node* node, AllocatorInfo backing, char const* name, b32
node->type = type;
node->name = name;
node->parent = parent;
node->nodes = Array<ADT_Node>::init( backing );
node->nodes = array_init(ADT_Node, backing );
if ( ! node->nodes )
return EADT_ERROR_OUT_OF_MEMORY;
@ -36,12 +37,12 @@ u8 adt_destroy_branch( ADT_Node* node )
GEN_ASSERT_NOT_NULL( node );
if ( ( node->type == EADT_TYPE_OBJECT || node->type == EADT_TYPE_ARRAY ) && node->nodes )
{
for ( ssize i = 0; i < scast(ssize, node->nodes.num()); ++i )
for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); ++i )
{
adt_destroy_branch( node->nodes + i );
}
node->nodes.free();
array_free(node->nodes);
}
return 0;
}
@ -66,7 +67,7 @@ ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search )
return NULL;
}
for ( ssize i = 0; i < scast(ssize, node->nodes.num()); i++ )
for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ )
{
if ( ! str_compare( node->nodes[ i ].name, name ) )
{
@ -76,7 +77,7 @@ ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search )
if ( deep_search )
{
for ( ssize i = 0; i < scast(ssize, node->nodes.num()); i++ )
for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ )
{
ADT_Node* res = adt_find( node->nodes + i, name, deep_search );
@ -132,7 +133,7 @@ internal ADT_Node* _adt_get_value( ADT_Node* node, char const* value )
internal ADT_Node* _adt_get_field( ADT_Node* node, char* name, char* value )
{
for ( ssize i = 0; i < scast(ssize, node->nodes.num()); i++ )
for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ )
{
if ( ! str_compare( node->nodes[ i ].name, name ) )
{
@ -207,7 +208,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
/* run a value comparison against any child that is an object node */
else if ( node->type == EADT_TYPE_ARRAY )
{
for ( ssize i = 0; i < scast(ssize, node->nodes.num()); i++ )
for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ )
{
ADT_Node* child = &node->nodes[ i ];
if ( child->type != EADT_TYPE_OBJECT )
@ -225,7 +226,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
/* [value] */
else
{
for ( ssize i = 0; i < scast(ssize, node->nodes.num()); i++ )
for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ )
{
ADT_Node* child = &node->nodes[ i ];
if ( _adt_get_value( child, l_b2 ) )
@ -257,7 +258,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
else
{
ssize idx = ( ssize )str_to_i64( buf, NULL, 10 );
if ( idx >= 0 && idx < scast(ssize, node->nodes.num()) )
if ( idx >= 0 && idx < scast(ssize, array_num(node->nodes)) )
{
found_node = &node->nodes[ idx ];
@ -282,15 +283,16 @@ ADT_Node* adt_alloc_at( ADT_Node* parent, ssize index )
if ( ! parent->nodes )
return NULL;
if ( index < 0 || index > scast(ssize, parent->nodes.num()) )
if ( index < 0 || index > scast(ssize, array_num(parent->nodes)) )
return NULL;
ADT_Node o = { 0 };
o.parent = parent;
if ( ! parent->nodes.append_at( o, index ) )
if ( ! array_append_at( parent->nodes, o, index ) )
return NULL;
return parent->nodes + index;
ADT_Node* node = & parent->nodes[index];
return node;
}
ADT_Node* adt_alloc( ADT_Node* parent )
@ -303,7 +305,7 @@ ADT_Node* adt_alloc( ADT_Node* parent )
if ( ! parent->nodes )
return NULL;
return adt_alloc_at( parent, parent->nodes.num() );
return adt_alloc_at( parent, array_num(parent->nodes) );
}
b8 adt_set_obj( ADT_Node* obj, char const* name, AllocatorInfo backing )
@ -357,7 +359,7 @@ ADT_Node* adt_move_node( ADT_Node* node, ADT_Node* new_parent )
GEN_ASSERT_NOT_NULL( node );
GEN_ASSERT_NOT_NULL( new_parent );
GEN_ASSERT( new_parent->type == EADT_TYPE_ARRAY || new_parent->type == EADT_TYPE_OBJECT );
return adt_move_node_at( node, new_parent, new_parent->nodes.num() );
return adt_move_node_at( node, new_parent, array_num(new_parent->nodes) );
}
void adt_swap_nodes( ADT_Node* node, ADT_Node* other_node )
@ -381,7 +383,7 @@ void adt_remove_node( ADT_Node* node )
GEN_ASSERT_NOT_NULL( node->parent );
ADT_Node* parent = node->parent;
ssize index = ( pointer_diff( parent->nodes, node ) / size_of( ADT_Node ) );
parent->nodes.remove_at( index );
array_remove_at( parent->nodes, index );
}
ADT_Node* adt_append_obj( ADT_Node* parent, char const* name )
@ -389,7 +391,7 @@ ADT_Node* adt_append_obj( ADT_Node* parent, char const* name )
ADT_Node* o = adt_alloc( parent );
if ( ! o )
return NULL;
if ( adt_set_obj( o, name, parent->nodes.get_header()->Allocator ) )
if ( adt_set_obj( o, name, array_get_header(parent->nodes)->Allocator ) )
{
adt_remove_node( o );
return NULL;
@ -402,7 +404,9 @@ ADT_Node* adt_append_arr( ADT_Node* parent, char const* name )
ADT_Node* o = adt_alloc( parent );
if ( ! o )
return NULL;
if ( adt_set_arr( o, name, parent->nodes.get_header()->Allocator ) )
ArrayHeader* node_header = array_get_header(parent->nodes);
if ( adt_set_arr( o, name, node_header->Allocator ) )
{
adt_remove_node( o );
return NULL;
@ -447,7 +451,7 @@ char* adt_parse_number_strict( ADT_Node* node, char* base_str )
while ( *e )
++e;
while ( *p && ( str_find( "eE.+-", *p ) || char_is_hex_digit( *p ) ) )
while ( *p && ( char_first_occurence( "eE.+-", *p ) || char_is_hex_digit( *p ) ) )
{
++p;
}
@ -476,7 +480,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
u8 node_props = 0;
/* skip false positives and special cases */
if ( ! ! str_find( "eE", *p ) || ( ! ! str_find( ".+-", *p ) && ! char_is_hex_digit( *( p + 1 ) ) && *( p + 1 ) != '.' ) )
if ( ! ! char_first_occurence( "eE", *p ) || ( ! ! char_first_occurence( ".+-", *p ) && ! char_is_hex_digit( *( p + 1 ) ) && *( p + 1 ) != '.' ) )
{
return ++base_str;
}
@ -507,7 +511,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
}
else
{
if ( ! str_compare( e, "0x", 2 ) || ! str_compare( e, "0X", 2 ) )
if ( ! str_compare_len( e, "0x", 2 ) || ! str_compare_len( e, "0X", 2 ) )
{
node_props = EADT_PROPS_IS_HEX;
}
@ -552,7 +556,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
char expbuf[ 6 ] = { 0 };
ssize expi = 0;
if ( *e && ! ! str_find( "eE", *e ) )
if ( *e && ! ! char_first_occurence( "eE", *e ) )
{
++e;
if ( *e == '+' || *e == '-' || char_is_digit( *e ) )
@ -748,7 +752,7 @@ ADT_Error adt_print_string( FileInfo* file, ADT_Node* node, char const* escaped_
{
p = str_skip_any( p, escaped_chars );
_adt_fprintf( file, "%.*s", pointer_diff( b, p ), b );
if ( *p && ! ! str_find( escaped_chars, *p ) )
if ( *p && ! ! char_first_occurence( escaped_chars, *p ) )
{
_adt_fprintf( file, "%s%c", escape_symbol, *p );
p++;
@ -946,12 +950,12 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
}
}
if ( columnIndex >= scast(ssize, root->nodes.num()) )
if ( columnIndex >= scast(ssize, array_num(root->nodes)) )
{
adt_append_arr( root, NULL );
}
root->nodes[ columnIndex ].nodes.append( rowItem );
array_append( root->nodes[ columnIndex ].nodes, rowItem );
if ( delimiter == delim )
{
@ -979,7 +983,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
}
while ( *currentChar );
if ( root->nodes.num() == 0 )
if (array_num( root->nodes) == 0 )
{
GEN_CSV_ASSERT( "unexpected end of input. stream is empty." );
error = ECSV_Error__UNEXPECTED_END_OF_INPUT;
@ -989,12 +993,12 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
/* consider first row as a header. */
if ( has_header )
{
for ( ssize i = 0; i < scast(ssize, root->nodes.num()); i++ )
for ( ssize i = 0; i < scast(ssize, array_num(root->nodes)); i++ )
{
CSV_Object* col = root->nodes + i;
CSV_Object* hdr = col->nodes;
col->name = hdr->string;
col->nodes.remove_at( 0 );
array_remove_at(col->nodes, 0 );
}
}
@ -1057,11 +1061,11 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
GEN_ASSERT_NOT_NULL( file );
GEN_ASSERT_NOT_NULL( obj );
GEN_ASSERT( obj->nodes );
ssize cols = obj->nodes.num();
ssize cols = array_num(obj->nodes);
if ( cols == 0 )
return;
ssize rows = obj->nodes[ 0 ].nodes.num();
ssize rows = array_num(obj->nodes[ 0 ].nodes);
if ( rows == 0 )
return;
@ -1102,10 +1106,11 @@ String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delimi
ssize fsize;
u8* buf = file_stream_buf( &tmp, &fsize );
String output = String::make_length( a, ( char* )buf, fsize );
String output = string_make_length( a, ( char* )buf, fsize );
file_close( &tmp );
return output;
}
#pragma endregion CSV
#undef _adt_fprintf
#pragma endregion CSV

3
project/dependencies/parsing.hpp → base/dependencies/parsing.hpp
View File

@ -1,5 +1,6 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "timing.hpp"
#endif
#pragma region ADT
@ -83,7 +84,7 @@ struct ADT_Node
union
{
char const* string;
Array<ADT_Node> nodes; ///< zpl_array
Array(ADT_Node) nodes; ///< zpl_array
struct
{

79
project/dependencies/platform.hpp → base/dependencies/platform.hpp
View File

@ -29,12 +29,6 @@
# ifndef GEN_SYSTEM_MACOS
# define GEN_SYSTEM_MACOS 1
# endif
# include <TargetConditionals.h>
# if TARGET_IPHONE_SIMULATOR == 1 || TARGET_OS_IPHONE == 1
# ifndef GEN_SYSTEM_IOS
# define GEN_SYSTEM_IOS 1
# endif
# endif
#elif defined( __unix__ )
# ifndef GEN_SYSTEM_UNIX
# define GEN_SYSTEM_UNIX 1
@ -76,13 +70,21 @@
/* Platform compiler */
#if defined( _MSC_VER )
# define GEN_COMPILER_MSVC 1
# pragma message("Detected MSVC")
// # define GEN_COMPILER_CLANG 0
# define GEN_COMPILER_MSVC 1
// # define GEN_COMPILER_GCC 0
#elif defined( __GNUC__ )
# define GEN_COMPILER_GCC 1
# pragma message("Detected GCC")
// # define GEN_COMPILER_CLANG 0
// # define GEN_COMPILER_MSVC 0
# define GEN_COMPILER_GCC 1
#elif defined( __clang__ )
# pragma message("Detected CLANG")
# define GEN_COMPILER_CLANG 1
#elif defined( __MINGW32__ )
# define GEN_COMPILER_MINGW 1
// # define GEN_COMPILER_MSVC 0
// # define GEN_COMPILER_GCC 0
#else
# error Unknown compiler
#endif
@ -101,6 +103,26 @@
# define GEN_GCC_VERSION_CHECK(major,minor,patch) (0)
#endif
#if !defined(GEN_COMPILER_C)
# ifdef __cplusplus
# define GEN_COMPILER_C 0
# define GEN_COMPILER_CPP 1
# else
# if defined(__STDC__)
# define GEN_COMPILER_C 1
# define GEN_COMPILER_CPP 0
# else
// Fallback for very old C compilers
# define GEN_COMPILER_C 1
# define GEN_COMPILER_CPP 0
# endif
# endif
#endif
#if GEN_COMPILER_C
#pragma message("GENCPP: Detected C")
#endif
#pragma endregion Platform Detection
#pragma region Mandatory Includes
@ -112,14 +134,37 @@
# include <intrin.h>
# endif
#if GEN_COMPILER_C
#include <assert.h>
#include <stdbool.h>
#endif
#pragma endregion Mandatory Includes
#ifdef GEN_DONT_USE_NAMESPACE
# define GEN_NS
# define GEN_NS_BEGIN
# define GEN_NS_END
#if GEN_DONT_USE_NAMESPACE || GEN_COMPILER_C
# if GEN_COMPILER_C
# define GEN_NS_PARSER_BEGIN
# define GEN_NS_PARSER_END
# define GEN_USING_NS_PARSER
# define GEN_NS_PARSER
# define GEN_NS
# define GEN_NS_BEGIN
# define GEN_NS_END
# else
# define GEN_NS_PARSER_BEGIN namespace parser {
# define GEN_NS_PARSER_END }
# define GEN_USING_NS_PARSER using namespace parser
# define GEN_NS_PARSER parser::
# define GEN_NS ::
# define GEN_NS_BEGIN
# define GEN_NS_END
# endif
#else
# define GEN_NS gen::
# define GEN_NS_BEGIN namespace gen {
# define GEN_NS_END }
# define GEN_NS_PARSER_BEGIN namespace parser {
# define GEN_NS_PARSER_END }
# define GEN_NS_PARSER parser::
# define GEN_USING_NS_PARSER using namespace parser
# define GEN_NS gen::
# define GEN_NS_BEGIN namespace gen {
# define GEN_NS_END }
#endif

26
project/dependencies/printing.cpp → base/dependencies/printing.cpp
View File

@ -1,7 +1,5 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "filesystem.hpp"
# include "strings.hpp"
# include "string_ops.cpp"
#endif
@ -33,6 +31,7 @@ enum
GEN_FMT_INTS = GEN_FMT_CHAR | GEN_FMT_SHORT | GEN_FMT_INT | GEN_FMT_LONG | GEN_FMT_LLONG | GEN_FMT_SIZE | GEN_FMT_INTPTR
};
typedef struct _format_info _format_info;
struct _format_info
{
s32 base;
@ -43,8 +42,8 @@ struct _format_info
internal ssize _print_string( char* text, ssize max_len, _format_info* info, char const* str )
{
ssize res = 0, len = 0;
ssize remaining = max_len;
ssize res = 0, len = 0;
ssize remaining = max_len;
char* begin = text;
if ( str == NULL && max_len >= 6 )
@ -247,7 +246,7 @@ neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_lis
while ( *fmt )
{
_format_info info = { 0 };
ssize len = 0;
ssize len = 0;
info.precision = -1;
while ( *fmt && *fmt != '%' && remaining )
@ -420,9 +419,18 @@ neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_lis
case 'S':
{
String gen_str = String { va_arg( va, char*) };
if ( *(fmt + 1) == 'C' )
{
++ fmt;
StrC gen_str = va_arg( va, StrC);
info.precision = gen_str.Len;
len = _print_string( text, remaining, &info, gen_str.Ptr );
break;
}
info.precision = gen_str.length();
String gen_str = { va_arg( va, char*) };
info.precision = string_length(gen_str);
len = _print_string( text, remaining, &info, gen_str );
}
break;
@ -540,7 +548,7 @@ char* str_fmt_buf( char const* fmt, ... )
return str;
}
ssize str_fmt_file_va( struct FileInfo* f, char const* fmt, va_list va )
ssize str_fmt_file_va( FileInfo* f, char const* fmt, va_list va )
{
local_persist thread_local char buf[ GEN_PRINTF_MAXLEN ];
ssize len = str_fmt_va( buf, size_of( buf ), fmt, va );
@ -548,7 +556,7 @@ ssize str_fmt_file_va( struct FileInfo* f, char const* fmt, va_list va )
return res ? len : -1;
}
ssize str_fmt_file( struct FileInfo* f, char const* fmt, ... )
ssize str_fmt_file( FileInfo* f, char const* fmt, ... )
{
ssize res;
va_list va;

3
project/dependencies/printing.hpp → base/dependencies/printing.hpp
View File

@ -5,11 +5,12 @@
#pragma region Printing
struct FileInfo;
typedef struct FileInfo FileInfo;
#ifndef GEN_PRINTF_MAXLEN
# define GEN_PRINTF_MAXLEN kilobytes(128)
#endif
typedef char PrintF_Buffer[GEN_PRINTF_MAXLEN];
// NOTE: A locally persisting buffer is used internally
char* str_fmt_buf ( char const* fmt, ... );

1
project/dependencies/src_start.cpp → base/dependencies/src_start.cpp
View File

@ -1,4 +1,5 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "header_start.hpp"
#endif

5
project/dependencies/string_ops.cpp → base/dependencies/string_ops.cpp
View File

@ -1,6 +1,5 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "string_ops.hpp"
# include "debug.cpp"
#endif
@ -19,7 +18,7 @@ ssize _scan_zpl_i64( const char* text, s32 base, s64* value )
text++;
}
if ( base == 16 && str_compare( text, "0x", 2 ) == 0 )
if ( base == 16 && str_compare_len( text, "0x", 2 ) == 0 )
text += 2;
for ( ;; )
@ -61,7 +60,7 @@ s64 str_to_i64( const char* str, char** end_ptr, s32 base )
if ( ! base )
{
if ( ( str_len( str ) > 2 ) && ( str_compare( str, "0x", 2 ) == 0 ) )
if ( ( str_len( str ) > 2 ) && ( str_compare_len( str, "0x", 2 ) == 0 ) )
base = 16;
else
base = 10;

11
project/dependencies/string_ops.hpp → base/dependencies/string_ops.hpp
View File

@ -6,7 +6,6 @@
#pragma region String Ops
const char* char_first_occurence( const char* str, char c );
constexpr auto str_find = &char_first_occurence;
b32 char_is_alpha( char c );
b32 char_is_alphanumeric( char c );
@ -20,11 +19,11 @@ s32 digit_to_int( char c );
s32 hex_digit_to_int( char c );
s32 str_compare( const char* s1, const char* s2 );
s32 str_compare( const char* s1, const char* s2, ssize len );
s32 str_compare_len( const char* s1, const char* s2, ssize len );
char* str_copy( char* dest, const char* source, ssize len );
ssize str_copy_nulpad( char* dest, const char* source, ssize len );
ssize str_len( const char* str );
ssize str_len( const char* str, ssize max_len );
ssize str_len_capped( const char* str, ssize max_len );
char* str_reverse( char* str ); // NOTE: ASCII only
char const* str_skip( char const* str, char c );
char const* str_skip_any( char const* str, char const* char_list );
@ -133,7 +132,7 @@ s32 str_compare( const char* s1, const char* s2 )
}
inline
s32 str_compare( const char* s1, const char* s2, ssize len )
s32 str_compare_len( const char* s1, const char* s2, ssize len )
{
for ( ; len > 0; s1++, s2++, len-- )
{
@ -205,7 +204,7 @@ ssize str_len( const char* str )
}
inline
ssize str_len( const char* str, ssize max_len )
ssize str_len_capped( const char* str, ssize max_len )
{
const char* end = rcast(const char*, mem_find( str, 0, max_len ));
if ( end )
@ -241,7 +240,7 @@ char const* str_skip( char const* str, char c )
inline
char const* str_skip_any( char const* str, char const* char_list )
{
char const* closest_ptr = rcast( char const*, pointer_add_const( rcast(void const*, str), str_len( str ) ));
char const* closest_ptr = rcast( char const*, pointer_add_const( rcast(mem_ptr_const, str), str_len( str ) ));
ssize char_list_count = str_len( char_list );
for ( ssize i = 0; i < char_list_count; i++ )
{

61
base/dependencies/strings.cpp Normal file
View File

@ -0,0 +1,61 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "hashing.cpp"
#endif
#pragma region String
String string_make_length( AllocatorInfo allocator, char const* str, ssize length )
{
ssize const header_size = sizeof( StringHeader );
s32 alloc_size = header_size + length + 1;
void* allocation = alloc( allocator, alloc_size );
if ( allocation == nullptr ) {
String null_string = {nullptr};
return null_string;
}
StringHeader*
header = rcast(StringHeader*, allocation);
header->Allocator = allocator;
header->Capacity = length;
header->Length = length;
String result = { rcast( char*, allocation) + header_size };
if ( length && str )
mem_copy( result, str, length );
else
mem_set( result, 0, alloc_size - header_size );
result[ length ] = '\0';
return result;
}
String string_make_reserve( AllocatorInfo allocator, ssize capacity )
{
ssize const header_size = sizeof( StringHeader );
s32 alloc_size = header_size + capacity + 1;
void* allocation = alloc( allocator, alloc_size );
if ( allocation == nullptr ) {
String null_string = {nullptr};
return null_string;
}
mem_set( allocation, 0, alloc_size );
StringHeader*
header = rcast(StringHeader*, allocation);
header->Allocator = allocator;
header->Capacity = capacity;
header->Length = 0;
String result = { rcast(char*, allocation) + header_size };
return result;
}
#pragma endregion String

744
base/dependencies/strings.hpp Normal file
View File

@ -0,0 +1,744 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "hashing.hpp"
#endif
#pragma region Strings
struct StrC;
StrC to_strc_from_c_str (char const* bad_string);
bool strc_are_equal (StrC lhs, StrC rhs);
char const* strc_back (StrC str);
bool strc_contains (StrC str, StrC substring);
StrC strc_duplicate (StrC str, AllocatorInfo allocator);
b32 strc_starts_with (StrC str, StrC substring);
StrC strc_visualize_whitespace(StrC str, AllocatorInfo allocator);
// Constant string with length.
struct StrC
{
ssize Len;
char const* Ptr;
#if GEN_COMPILER_CPP
forceinline operator char const* () const { return Ptr; }
forceinline char const& operator[]( ssize index ) const { return Ptr[index]; }
#if ! GEN_C_LIKE_CPP
forceinline bool is_equal (StrC rhs) const { return strc_are_equal(* this, rhs); }
forceinline char const* back () const { return strc_back(* this); }
forceinline bool contains (StrC substring) const { return strc_contains(* this, substring); }
forceinline StrC duplicate (AllocatorInfo allocator) const { return strc_duplicate(* this, allocator); }
forceinline b32 starts_with (StrC substring) const { return strc_starts_with(* this, substring); }
forceinline StrC visualize_whitespace(AllocatorInfo allocator) const { return strc_visualize_whitespace(* this, allocator); }
#endif
#endif
};
#define cast_to_strc( str ) * rcast( StrC*, (str) - sizeof(ssize) )
#ifndef txt
# if GEN_COMPILER_CPP
# define txt( text ) StrC { sizeof( text ) - 1, ( text ) }
# else
# define txt( text ) (StrC){ sizeof( text ) - 1, ( text ) }
# endif
#endif
GEN_API_C_BEGIN
forceinline char const* strc_begin(StrC str) { return str.Ptr; }
forceinline char const* strc_end (StrC str) { return str.Ptr + str.Len; }
forceinline char const* strc_next (StrC str, char const* iter) { return iter + 1; }
GEN_API_C_END
#if GEN_COMPILER_CPP
forceinline char const* begin(StrC str) { return str.Ptr; }
forceinline char const* end (StrC str) { return str.Ptr + str.Len; }
forceinline char const* next (StrC str, char const* iter) { return iter + 1; }
#endif
inline
bool strc_are_equal(StrC lhs, StrC rhs)
{
if (lhs.Len != rhs.Len)
return false;
for (ssize idx = 0; idx < lhs.Len; ++idx)
if (lhs.Ptr[idx] != rhs.Ptr[idx])
return false;
return true;
}
inline
char const* strc_back(StrC str) {
return & str.Ptr[str.Len - 1];
}
inline
bool strc_contains(StrC str, StrC substring)
{
if (substring.Len > str.Len)
return false;
ssize main_len = str.Len;
ssize sub_len = substring.Len;
for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
{
if (str_compare_len(str.Ptr + idx, substring.Ptr, sub_len) == 0)
return true;
}
return false;
}
inline
b32 strc_starts_with(StrC str, StrC substring) {
if (substring.Len > str.Len)
return false;
b32 result = str_compare_len(str.Ptr, substring.Ptr, substring.Len) == 0;
return result;
}
inline
StrC to_strc_from_c_str( char const* bad_str ) {
StrC result = { str_len( bad_str ), bad_str };
return result;
}
// Dynamic String
// This is directly based off the ZPL string api.
// They used a header pattern
// I kept it for simplicty of porting but its not necessary to keep it that way.
#pragma region String
struct StringHeader;
#if GEN_COMPILER_C
typedef char* String;
#else
struct String;
#endif
forceinline usize string_grow_formula(usize value);
String string_make_c_str (AllocatorInfo allocator, char const* str);
String string_make_strc (AllocatorInfo allocator, StrC str);
String string_make_reserve (AllocatorInfo allocator, ssize capacity);
String string_make_length (AllocatorInfo allocator, char const* str, ssize length);
String string_fmt (AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...);
String string_fmt_buf (AllocatorInfo allocator, char const* fmt, ...);
String string_join (AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue);
bool string_are_equal (String const lhs, String const rhs);
bool string_are_equal_strc (String const lhs, StrC rhs);
bool string_make_space_for (String* str, char const* to_append, ssize add_len);
bool string_append_char (String* str, char c);
bool string_append_c_str (String* str, char const* str_to_append);
bool string_append_c_str_len (String* str, char const* str_to_append, ssize length);
bool string_append_strc (String* str, StrC str_to_append);
bool string_append_string (String* str, String const other);
bool string_append_fmt (String* str, char const* fmt, ...);
ssize string_avail_space (String const str);
char* string_back (String str);
bool string_contains_strc (String const str, StrC substring);
bool string_contains_string (String const str, String const substring);
ssize string_capacity (String const str);
void string_clear (String str);
String string_duplicate (String const str, AllocatorInfo allocator);
void string_free (String* str);
StringHeader* string_get_header (String str);
ssize string_length (String const str);
b32 string_starts_with_strc (String const str, StrC substring);
b32 string_starts_with_string (String const str, String substring);
void string_skip_line (String str);
void string_strip_space (String str);
StrC string_to_strc (String str);
void string_trim (String str, char const* cut_set);
void string_trim_space (String str);
String string_visualize_whitespace(String const str);
struct StringHeader {
AllocatorInfo Allocator;
ssize Capacity;
ssize Length;
};
#if GEN_COMPILER_CPP
struct String
{
char* Data;
forceinline operator char*() { return Data; }
forceinline operator char const*() const { return Data; }
forceinline operator StrC() const { return { string_length(* this), Data }; }
String const& operator=(String const& other) const {
if (this == &other)
return *this;
String* this_ = ccast(String*, this);
this_->Data = other.Data;
return *this;
}
forceinline char& operator[](ssize index) { return Data[index]; }
forceinline char const& operator[](ssize index) const { return Data[index]; }
forceinline bool operator==(std::nullptr_t) const { return Data == nullptr; }
forceinline bool operator!=(std::nullptr_t) const { return Data != nullptr; }
friend forceinline bool operator==(std::nullptr_t, const String str) { return str.Data == nullptr; }
friend forceinline bool operator!=(std::nullptr_t, const String str) { return str.Data != nullptr; }
#if ! GEN_C_LIKE_CPP
forceinline char* begin() const { return Data; }
forceinline char* end() const { return Data + string_length(* this); }
#pragma region Member Mapping
forceinline static String make(AllocatorInfo allocator, char const* str) { return string_make_c_str(allocator, str); }
forceinline static String make(AllocatorInfo allocator, StrC str) { return string_make_strc(allocator, str); }
forceinline static String make_reserve(AllocatorInfo allocator, ssize cap) { return string_make_reserve(allocator, cap); }
forceinline static String make_length(AllocatorInfo a, char const* s, ssize l) { return string_make_length(a, s, l); }
forceinline static String join(AllocatorInfo a, char const** p, ssize n, char const* g) { return string_join(a, p, n, g); }
forceinline static usize grow_formula(usize value) { return string_grow_formula(value); }
static
String fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
va_list va;
va_start(va, fmt);
ssize res = str_fmt_va(buf, buf_size, fmt, va) - 1;
va_end(va);
return string_make_length(allocator, buf, res);
}
static
String fmt_buf(AllocatorInfo allocator, char const* fmt, ...) {
local_persist thread_local
char buf[GEN_PRINTF_MAXLEN] = { 0 };
va_list va;
va_start(va, fmt);
ssize res = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va) - 1;
va_end(va);
return string_make_length(allocator, buf, res);
}
forceinline bool make_space_for(char const* str, ssize add_len) { return string_make_space_for(this, str, add_len); }
forceinline bool append(char c) { return string_append_char(this, c); }
forceinline bool append(char const* str) { return string_append_c_str(this, str); }
forceinline bool append(char const* str, ssize length) { return string_append_c_str_len(this, str, length); }
forceinline bool append(StrC str) { return string_append_strc(this, str); }
forceinline bool append(const String other) { return string_append_string(this, other); }
forceinline ssize avail_space() const { return string_avail_space(* this); }
forceinline char* back() { return string_back(* this); }
forceinline bool contains(StrC substring) const { return string_contains_strc(* this, substring); }
forceinline bool contains(String const& substring) const { return string_contains_string(* this, substring); }
forceinline ssize capacity() const { return string_capacity(* this); }
forceinline void clear() { string_clear(* this); }
forceinline String duplicate(AllocatorInfo allocator) const { return string_duplicate(* this, allocator); }
forceinline void free() { string_free(this); }
forceinline bool is_equal(String const& other) const { return string_are_equal(* this, other); }
forceinline bool is_equal(StrC other) const { return string_are_equal_strc(* this, other); }
forceinline ssize length() const { return string_length(* this); }
forceinline b32 starts_with(StrC substring) const { return string_starts_with_strc(* this, substring); }
forceinline b32 starts_with(String substring) const { return string_starts_with_string(* this, substring); }
forceinline void skip_line() { string_skip_line(* this); }
forceinline void strip_space() { string_strip_space(* this); }
forceinline StrC to_strc() { return { string_length(*this), Data}; }
forceinline void trim(char const* cut_set) { string_trim(* this, cut_set); }
forceinline void trim_space() { string_trim_space(* this); }
forceinline String visualize_whitespace() const { return string_visualize_whitespace(* this); }
forceinline StringHeader& get_header() { return * string_get_header(* this); }
bool append_fmt(char const* fmt, ...) {
ssize res;
char buf[GEN_PRINTF_MAXLEN] = { 0 };
va_list va;
va_start(va, fmt);
res = str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1;
va_end(va);
return string_append_c_str_len(this, buf, res);
}
#pragma endregion Member Mapping
#endif
};
#endif
forceinline char* string_begin(String str) { return ((char*) str); }
forceinline char* string_end (String str) { return ((char*) str + string_length(str)); }
forceinline char* string_next (String str, char const* iter) { return ((char*) iter + 1); }
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
forceinline char* begin(String str) { return ((char*) str); }
forceinline char* end (String str) { return ((char*) str + string_length(str)); }
forceinline char* next (String str, char* iter) { return ((char*) iter + 1); }
#endif
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
forceinline bool make_space_for(String& str, char const* to_append, ssize add_len);
forceinline bool append(String& str, char c);
forceinline bool append(String& str, char const* str_to_append);
forceinline bool append(String& str, char const* str_to_append, ssize length);
forceinline bool append(String& str, StrC str_to_append);
forceinline bool append(String& str, const String other);
forceinline bool append_fmt(String& str, char const* fmt, ...);
forceinline char& back(String& str);
forceinline void clear(String& str);
forceinline void free(String& str);
#endif
forceinline
usize string_grow_formula(usize value) {
// Using a very aggressive growth formula to reduce time mem_copying with recursive calls to append in this library.
return 4 * value + 8;
}
forceinline
String string_make_c_str(AllocatorInfo allocator, char const* str) {
ssize length = str ? str_len(str) : 0;
return string_make_length(allocator, str, length);
}
forceinline
String string_make_strc(AllocatorInfo allocator, StrC str) {
return string_make_length(allocator, str.Ptr, str.Len);
}
inline
String string_fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
va_list va;
va_start(va, fmt);
ssize res = str_fmt_va(buf, buf_size, fmt, va) - 1;
va_end(va);
return string_make_length(allocator, buf, res);
}
inline
String string_fmt_buf(AllocatorInfo allocator, char const* fmt, ...)
{
local_persist thread_local
PrintF_Buffer buf = struct_init(PrintF_Buffer, {0});
va_list va;
va_start(va, fmt);
ssize res = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va) -1;
va_end(va);
return string_make_length(allocator, buf, res);
}
inline
String string_join(AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue)
{
String result = string_make_c_str(allocator, "");
for (ssize idx = 0; idx < num_parts; ++idx)
{
string_append_c_str(& result, parts[idx]);
if (idx < num_parts - 1)
string_append_c_str(& result, glue);
}
return result;
}
forceinline
bool string_append_char(String* str, char c) {
GEN_ASSERT(str != nullptr);
return string_append_c_str_len( str, (char const*)& c, (ssize)1);
}
forceinline
bool string_append_c_str(String* str, char const* str_to_append) {
GEN_ASSERT(str != nullptr);
return string_append_c_str_len(str, str_to_append, str_len(str_to_append));
}
inline
bool string_append_c_str_len(String* str, char const* str_to_append, ssize append_length)
{
GEN_ASSERT(str != nullptr);
if ( rcast(sptr, str_to_append) > 0)
{
ssize curr_len = string_length(* str);
if ( ! string_make_space_for(str, str_to_append, append_length))
return false;
StringHeader* header = string_get_header(* str);
char* Data = * str;
mem_copy( Data + curr_len, str_to_append, append_length);
Data[curr_len + append_length] = '\0';
header->Length = curr_len + append_length;
}
return str_to_append != nullptr;
}
forceinline
bool string_append_strc(String* str, StrC str_to_append) {
GEN_ASSERT(str != nullptr);
return string_append_c_str_len(str, str_to_append.Ptr, str_to_append.Len);
}
forceinline
bool string_append_string(String* str, String const other) {
GEN_ASSERT(str != nullptr);
return string_append_c_str_len(str, (char const*)other, string_length(other));
}
bool string_append_fmt(String* str, char const* fmt, ...) {
GEN_ASSERT(str != nullptr);
ssize res;
char buf[GEN_PRINTF_MAXLEN] = { 0 };
va_list va;
va_start(va, fmt);
res = str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1;
va_end(va);
return string_append_c_str_len(str, (char const*)buf, res);
}
inline
bool string_are_equal_string(String const lhs, String const rhs)
{
if (string_length(lhs) != string_length(rhs))
return false;
for (ssize idx = 0; idx < string_length(lhs); ++idx)
if (lhs[idx] != rhs[idx])
return false;
return true;
}
inline
bool string_are_equal_strc(String const lhs, StrC rhs)
{
if (string_length(lhs) != (rhs.Len))
return false;
for (ssize idx = 0; idx < string_length(lhs); ++idx)
if (lhs[idx] != rhs.Ptr[idx])
return false;
return true;
}
forceinline
ssize string_avail_space(String const str) {
StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
return header->Capacity - header->Length;
}
forceinline
char* string_back(String str) {
return & (str)[string_length(str) - 1];
}
inline
bool string_contains_StrC(String const str, StrC substring)
{
StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
if (substring.Len > header->Length)
return false;
ssize main_len = header->Length;
ssize sub_len = substring.Len;
for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
{
if (str_compare_len(str + idx, substring.Ptr, sub_len) == 0)
return true;
}
return false;
}
inline
bool string_contains_string(String const str, String const substring)
{
StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
if (string_length(substring) > header->Length)
return false;
ssize main_len = header->Length;
ssize sub_len = string_length(substring);
for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
{
if (str_compare_len(str + idx, substring, sub_len) == 0)
return true;
}
return false;
}
forceinline
ssize string_capacity(String const str) {
StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
return header->Capacity;
}
forceinline
void string_clear(String str) {
string_get_header(str)->Length = 0;
}
forceinline
String string_duplicate(String const str, AllocatorInfo allocator) {
return string_make_length(allocator, str, string_length(str));
}
forceinline
void string_free(String* str) {
GEN_ASSERT(str != nullptr);
if (! (* str))
return;
StringHeader* header = string_get_header(* str);
allocator_free(header->Allocator, header);
}
forceinline
StringHeader* string_get_header(String str) {
return (StringHeader*)(scast(char*, str) - sizeof(StringHeader));
}
forceinline
ssize string_length(String const str)
{
StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader));
return header->Length;
}
inline
bool string_make_space_for(String* str, char const* to_append, ssize add_len)
{
ssize available = string_avail_space(* str);
if (available >= add_len) {
return true;
}
else
{
ssize new_len, old_size, new_size;
void* ptr;
void* new_ptr;
AllocatorInfo allocator = string_get_header(* str)->Allocator;
StringHeader* header = nullptr;
new_len = string_grow_formula(string_length(* str) + add_len);
ptr = string_get_header(* str);
old_size = size_of(StringHeader) + string_length(* str) + 1;
new_size = size_of(StringHeader) + new_len + 1;
new_ptr = resize(allocator, ptr, old_size, new_size);
if (new_ptr == nullptr)
return false;
header = rcast(StringHeader*, new_ptr);
header->Allocator = allocator;
header->Capacity = new_len;
char** Data = rcast(char**, str);
* Data = rcast(char*, header + 1);
return true;
}
}
forceinline
b32 string_starts_with_strc(String const str, StrC substring) {
if (substring.Len > string_length(str))
return false;
b32 result = str_compare_len(str, substring.Ptr, substring.Len) == 0;
return result;
}
forceinline
b32 string_starts_with_string(String const str, String substring) {
if (string_length(substring) > string_length(str))
return false;
b32 result = str_compare_len(str, substring, string_length(substring) - 1) == 0;
return result;
}
inline
void string_skip_line(String str)
{
#define current (*scanner)
char* scanner = str;
while (current != '\r' && current != '\n') {
++scanner;
}
s32 new_length = scanner - str;
if (current == '\r') {
new_length += 1;
}
mem_move((char*)str, scanner, new_length);
StringHeader* header = string_get_header(str);
header->Length = new_length;
#undef current
}
inline
void strip_space(String str)
{
char* write_pos = str;
char* read_pos = str;
while (* read_pos)
{
if (! char_is_space(* read_pos))
{
* write_pos = * read_pos;
write_pos++;
}
read_pos++;
}
write_pos[0] = '\0'; // Null-terminate the modified string
// Update the length if needed
string_get_header(str)->Length = write_pos - str;
}
forceinline
StrC string_to_strc(String str) {
StrC result = { string_length(str), (char const*)str };
return result;
}
inline
void string_trim(String str, char const* cut_set)
{
ssize len = 0;
char* start_pos = str;
char* end_pos = scast(char*, str) + string_length(str) - 1;
while (start_pos <= end_pos && char_first_occurence(cut_set, *start_pos))
start_pos++;
while (end_pos > start_pos && char_first_occurence(cut_set, *end_pos))
end_pos--;
len = scast(ssize, (start_pos > end_pos) ? 0 : ((end_pos - start_pos) + 1));
if (str != start_pos)
mem_move(str, start_pos, len);
str[len] = '\0';
string_get_header(str)->Length = len;
}
forceinline
void string_trim_space(String str) {
string_trim(str, " \t\r\n\v\f");
}
inline
String string_visualize_whitespace(String const str)
{
StringHeader* header = (StringHeader*)(scast(char const*, str) - sizeof(StringHeader));
String result = string_make_reserve(header->Allocator, string_length(str) * 2); // Assume worst case for space requirements.
for (char const* c = string_begin(str); c != string_end(str); c = string_next(str, c))
switch ( * c )
{
case ' ':
string_append_strc(& result, txt("·"));
break;
case '\t':
string_append_strc(& result, txt("→"));
break;
case '\n':
string_append_strc(& result, txt("↵"));
break;
case '\r':
string_append_strc(& result, txt("⏎"));
break;
case '\v':
string_append_strc(& result, txt("⇕"));
break;
case '\f':
string_append_strc(& result, txt("⌂"));
break;
default:
string_append_char(& result, * c);
break;
}
return result;
}
#pragma endregion String
#if GEN_COMPILER_CPP
struct String_POD {
char* Data;
};
static_assert( sizeof( String_POD ) == sizeof( String ), "String is not a POD" );
#endif
forceinline
StrC strc_duplicate(StrC str, AllocatorInfo allocator) {
StrC result = string_to_strc( string_make_length(allocator, str.Ptr, str.Len));
return result;
}
inline
StrC strc_visualize_whitespace(StrC str, AllocatorInfo allocator)
{
String result = string_make_reserve(allocator, str.Len * 2); // Assume worst case for space requirements.
for (char const* c = strc_begin(str); c != strc_end(str); c = strc_next(str, c))
switch ( * c )
{
case ' ':
string_append_strc(& result, txt("·"));
break;
case '\t':
string_append_strc(& result, txt("→"));
break;
case '\n':
string_append_strc(& result, txt("↵"));
break;
case '\r':
string_append_strc(& result, txt("⏎"));
break;
case '\v':
string_append_strc(& result, txt("⇕"));
break;
case '\f':
string_append_strc(& result, txt("⌂"));
break;
default:
string_append_char(& result, * c);
break;
}
return string_to_strc(result);
}
// Represents strings cached with the string table.
// Should never be modified, if changed string is desired, cache_string( str ) another.
typedef StrC StringCached;
// Implements basic string interning. Data structure is based off the ZPL Hashtable.
typedef HashTable(StringCached) StringTable;
#pragma endregion Strings

0
project/dependencies/timing.cpp → base/dependencies/timing.cpp
View File

0
project/dependencies/timing.hpp → base/dependencies/timing.hpp
View File

0
project/enums/AttributeTokens.csv → base/enums/AttributeTokens.csv
View File

0
project/enums/ECode_ExecutionSupport.csv → base/enums/ECodeType_ExecutionSupport.csv
View File

61
base/enums/ECodeTypes.csv Normal file
View File

@ -0,0 +1,61 @@
Invalid, "__NA__"
Untyped, "__NA__"
NewLine, "__NA__"
Comment, "//"
Access_Private, "private"
Access_Protected, "protected"
Access_Public, "public"
PlatformAttributes, "__NA__"
Class, "class"
Class_Fwd, "clsss"
Class_Body, "__NA__"
Constructor, "__NA__"
Constructor_Fwd, "__NA__"
Destructor, "__NA__"
Destructor_Fwd, "__NA__"
Enum, "enum"
Enum_Fwd, "enum"
Enum_Body, "__NA__"
Enum_Class, "enum class"
Enum_Class_Fwd, "enum class"
Execution, "__NA__"
Export_Body, "__NA__"
Extern_Linkage, "extern"
Extern_Linkage_Body, "extern"
Friend, "friend"
Function, "__NA__"
Function_Fwd, "__NA__"
Function_Body, "__NA__"
Global_Body, "__NA__"
Module, "module"
Namespace, "namespace"
Namespace_Body, "__NA__"
Operator, "operator"
Operator_Fwd, "operator"
Operator_Member, "operator"
Operator_Member_Fwd, "operator"
Operator_Cast, "operator"
Operator_Cast_Fwd, "operator"
Parameters, "__NA__"
Preprocess_Define, "define"
Preprocess_Include, "include"
Preprocess_If, "if"
Preprocess_IfDef, "ifdef"
Preprocess_IfNotDef, "ifndef"
Preprocess_ElIf, "elif"
Preprocess_Else, "else"
Preprocess_EndIf, "endif"
Preprocess_Pragma, "pragma"
Specifiers, "__NA__"
Struct, "struct"
Struct_Fwd, "struct"
Struct_Body, "__NA__"
Template, "template"
Typedef, "typedef"
Typename, "__NA__"
Union, "union"
Union_Fwd, "union"
Union_Body, "__NA__"
Using, "using"
Using_Namespace, "using namespace"
Variable, "__NA__"
1 Invalid __NA__
2 Untyped __NA__
3 NewLine __NA__
4 Comment //
5 Access_Private private
6 Access_Protected protected
7 Access_Public public
8 PlatformAttributes __NA__
9 Class class
10 Class_Fwd clsss
11 Class_Body __NA__
12 Constructor __NA__
13 Constructor_Fwd __NA__
14 Destructor __NA__
15 Destructor_Fwd __NA__
16 Enum enum
17 Enum_Fwd enum
18 Enum_Body __NA__
19 Enum_Class enum class
20 Enum_Class_Fwd enum class
21 Execution __NA__
22 Export_Body __NA__
23 Extern_Linkage extern
24 Extern_Linkage_Body extern
25 Friend friend
26 Function __NA__
27 Function_Fwd __NA__
28 Function_Body __NA__
29 Global_Body __NA__
30 Module module
31 Namespace namespace
32 Namespace_Body __NA__
33 Operator operator
34 Operator_Fwd operator
35 Operator_Member operator
36 Operator_Member_Fwd operator
37 Operator_Cast operator
38 Operator_Cast_Fwd operator
39 Parameters __NA__
40 Preprocess_Define define
41 Preprocess_Include include
42 Preprocess_If if
43 Preprocess_IfDef ifdef
44 Preprocess_IfNotDef ifndef
45 Preprocess_ElIf elif
46 Preprocess_Else else
47 Preprocess_EndIf endif
48 Preprocess_Pragma pragma
49 Specifiers __NA__
50 Struct struct
51 Struct_Fwd struct
52 Struct_Body __NA__
53 Template template
54 Typedef typedef
55 Typename __NA__
56 Union union
57 Union_Fwd union
58 Union_Body __NA__
59 Using using
60 Using_Namespace using namespace
61 Variable __NA__

0
project/enums/EOperator.csv → base/enums/EOperator.csv
View File

0
project/enums/ESpecifier.csv → base/enums/ESpecifier.csv
View File

0
project/enums/ETokType.csv → base/enums/ETokType.csv
View File

0
project/enums/ETokType_New.csv → base/enums/ETokType_ExecutionSupport.csv
View File

11
project/gen.cpp → base/gen.cpp
View File

@ -8,6 +8,13 @@
#include "gen.hpp"
// These are intended for use in the base library of gencpp and the C-variant of the library
// It provides a interoperability between the C++ and C interfacing for containers. (not letting these do any crazy substiution though)
// They are undefined in gen.hpp and gen.cpp at the end of the files.
// We cpp library expects the user to use the regular calls as they can resolve the type fine.
#include "helpers/push_container_defines.inline.hpp"
//! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
//! Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
#ifndef GEN_ROLL_OWN_DEPENDENCIES
@ -30,6 +37,10 @@ GEN_NS_BEGIN
#include "components/interface.parsing.cpp"
#include "components/interface.untyped.cpp"
#include "auxillary/builder.cpp"
#include "auxillary/scanner.cpp"
GEN_NS_END
#include "helpers/pop_container_defines.inline.hpp"
#include "helpers/pop_ignores.inline.hpp"

1
project/gen.dep.cpp → base/gen.dep.cpp
View File

@ -13,5 +13,6 @@ GEN_NS_BEGIN
#include "dependencies/strings.cpp"
#include "dependencies/filesystem.cpp"
#include "dependencies/timing.cpp"
#include "dependencies/parsing.cpp"
GEN_NS_END

1
project/gen.dep.hpp → base/gen.dep.hpp
View File

@ -16,5 +16,6 @@ GEN_NS_BEGIN
#include "dependencies/strings.hpp"
#include "dependencies/filesystem.hpp"
#include "dependencies/timing.hpp"
#include "dependencies/parsing.hpp"
GEN_NS_END

9
project/gen.hpp → base/gen.hpp
View File

@ -11,10 +11,13 @@
#include "helpers/push_ignores.inline.hpp"
#include "components/header_start.hpp"
// Has container defines pushed
#include "gen.dep.hpp"
GEN_NS_BEGIN
#include "components/types.hpp"
#include "components/gen/ecode.hpp"
#include "components/gen/ecodetypes.hpp"
#include "components/gen/eoperator.hpp"
#include "components/gen/especifier.hpp"
@ -28,6 +31,10 @@ GEN_NS_BEGIN
#include "components/gen/ast_inlines.hpp"
#include "components/header_end.hpp"
#include "auxillary/builder.hpp"
#include "auxillary/scanner.hpp"
GEN_NS_END
#include "helpers/pop_container_defines.inline.hpp"
#include "helpers/pop_ignores.inline.hpp"

4
scripts/gencpp.refactor → base/gencpp.refactor
View File

@ -18,6 +18,8 @@
// Precedence (highest to lowest):
// word, namespace, regex
// TODO(ED): THIS IS VERY OUTDATED
// Gen Macro namespace
// namespace GEN_, new_namespace_
@ -253,7 +255,7 @@
// word log_failure, new_name
// word NoCode, new_name
// word NullCode, new_name
// word CodeInvalid, new_name
// ------------ gencpp common

689
base/helpers/base_codegen.hpp Normal file
View File

@ -0,0 +1,689 @@
#pragma once
#if GEN_INTELLISENSE_DIRECTIVES
# include "../gen.hpp"
# include "misc.hpp"
using namespace gen;
#endif
CodeBody gen_ecode( char const* path, bool use_c_definition = false )
{
FixedArena_32KB scratch; fixed_arena_init(& scratch);
AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch);
CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
String enum_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
String to_keyword_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
for ( ssize idx = 0; idx < array_num(csv_enum.Col_1); ++ idx ) {
char const* code = csv_enum.Col_1[idx].string;
char const* keyword = csv_enum.Col_2[idx].string;
// TODO(Ed): to_str_entries and the others in here didn't have proper sizing of the StrC slice.
string_append_fmt( & enum_entries, "CT_%s,\n", code );
string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", code, code );
string_append_fmt( & to_keyword_str_entries, "{ sizeof(\"%s\") - 1, \"%s\" },\n", keyword, keyword );
}
CodeEnum enum_code;
if (use_c_definition) {
enum_code = parse_enum(token_fmt_impl((3 + 1) / 2, "entries", string_to_strc(enum_entries),
"enum CodeType enum_underlying(u32) { <entries> CT_NumTypes, CT_UnderlyingType = GEN_U32_MAX };"
));
}
else {
enum_code = parse_enum(token_fmt_impl((3 + 1) / 2, "entries", string_to_strc(enum_entries),
"enum CodeType : u32 { <entries> CT_NumTypes, CT_UnderlyingType = GEN_U32_MAX };"
));
}
#pragma push_macro("local_persist")
#undef local_persist
StrC lookup_size = string_to_strc(string_fmt_buf(GlobalAllocator, "%d", array_num(csv_enum.Col_1) ));
CodeBody to_str_fns = parse_global_body( token_fmt(
"entries", string_to_strc(to_str_entries)
, "keywords", string_to_strc(to_keyword_str_entries)
, "num", lookup_size
, stringize(
inline
StrC codetype_to_str( CodeType type )
{
local_persist
StrC lookup[<num>] = {
<entries>
};
return lookup[ type ];
}
inline
StrC codetype_to_keyword_str( CodeType type )
{
local_persist
StrC lookup[ <num> ] = {
<keywords>
};
return lookup[ type ];
}
)));
#pragma pop_macro("local_persist")
CodeBody result = def_body(CT_Global_Body);
body_append(result, enum_code);
if (use_c_definition) {
CodeTypedef code_t = parse_typedef(code(typedef enum CodeType CodeType; ));
body_append(result, code_t);
}
body_append(result, to_str_fns);
if (! use_c_definition) {
#pragma push_macro("forceinline")
#undef forceinline
CodeBody alias_mappings = parse_global_body(code(
forceinline StrC to_str (CodeType type) { return codetype_to_str(type); }
forceinline StrC to_keyword_str(CodeType type) { return codetype_to_keyword_str(type); }
));
#pragma pop_macro("forceinline")
body_append(result, alias_mappings);
}
return result;
}
CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
{
FixedArena_16KB scratch; fixed_arena_init(& scratch);
AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch);
CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
String enum_entries = string_make_reserve( GlobalAllocator, 32 );
String to_str_entries = string_make_reserve( GlobalAllocator, 32 );
for (usize idx = 0; idx < array_num(csv_enum.Col_1); idx++) {
char const* enum_str = csv_enum.Col_1[idx].string;
char const* entry_to_str = csv_enum.Col_2[idx].string;
string_append_fmt( & enum_entries, "Op_%s,\n", enum_str );
string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
}
CodeEnum enum_code;
if (use_c_definition)
{
#pragma push_macro("enum_underlying")
#undef enum_underlying
enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize(
enum Operator enum_underlying(u32)
{
<entries>
Op_NumOps,
Op_UnderlyingType = GEN_U32_MAX
};
)));
#pragma pop_macro("enum_underlying")
}
else
{
enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize(
enum Operator : u32
{
<entries>
Op_NumOps,
Op_UnderlyingType = GEN_U32_MAX
};
)));
}
#pragma push_macro("local_persist")
#undef local_persist
StrC lookup_size = string_to_strc(string_fmt_buf(GlobalAllocator, "%d", array_num(csv_enum.Col_1) ));
CodeFn to_str = parse_function(token_fmt(
"entries", string_to_strc(to_str_entries)
, "num", lookup_size
, stringize(
inline
StrC operator_to_str( Operator op )
{
local_persist
StrC lookup[<num>] = {
<entries>
};
return lookup[ op ];
}
)));
#pragma pop_macro("local_persist")
CodeBody result = def_body(CT_Global_Body);
body_append(result, enum_code);
if ( use_c_definition ) {
CodeTypedef operator_t = parse_typedef(code( typedef enum Operator Operator; ));
body_append(result, operator_t);
}
body_append(result, to_str);
if (! use_c_definition)
{
#pragma push_macro("forceinline")
#undef forceinline
CodeBody alias_mappings = parse_global_body(code(
forceinline StrC to_str(Operator op) { return operator_to_str(op); }
));
#pragma pop_macro("forceinline")
body_append(result, alias_mappings);
}
return result;
}
CodeBody gen_especifier( char const* path, bool use_c_definition = false )
{
FixedArena_16KB scratch; fixed_arena_init(& scratch);
AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch);
CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
String enum_entries = string_make_reserve( scratch_info, kilobytes(1) );
String to_str_entries = string_make_reserve( scratch_info, kilobytes(1) );
for (usize idx = 0; idx < array_num(csv_enum.Col_1); idx++)
{
char const* enum_str = csv_enum.Col_1[idx].string;
char const* entry_to_str = csv_enum.Col_2[idx].string;
string_append_fmt( & enum_entries, "Spec_%s,\n", enum_str );
string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
}
CodeEnum enum_code;
if (use_c_definition)
{
#pragma push_macro("enum_underlying")
#undef enum_underlying
enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize(
enum Specifier enum_underlying(u32)
{
<entries>
Spec_NumSpecifiers,
Spec_UnderlyingType = GEN_U32_MAX
};
)));
#pragma pop_macro("enum_underlying")
}
else
{
enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize(
enum Specifier : u32
{
<entries>
Spec_NumSpecifiers,
Spec_UnderlyingType = GEN_U32_MAX
};
)));
}
CodeFn is_trailing = parse_function(token_fmt("specifier", string_to_strc(to_str_entries), stringize(
inline
bool spec_is_trailing( Specifier specifier )
{
return specifier > Spec_Virtual;
}
)));
#pragma push_macro("local_persist")
#pragma push_macro("do_once_start")
#pragma push_macro("do_once_end")
#pragma push_macro("forceinline")
#pragma push_macro("neverinline")
#undef local_persist
#undef do_once_start
#undef do_once_end
#undef forceinline
#undef neverinline
StrC lookup_size = string_to_strc(string_fmt_buf(GlobalAllocator, "%d", array_num(csv_enum.Col_1) ));
CodeFn to_str = parse_function(token_fmt(
"entries", string_to_strc(to_str_entries)
, "num", lookup_size
, stringize(
inline
StrC spec_to_str( Specifier type )
{
local_persist
StrC lookup[<num>] = {
<entries>
};
return lookup[ type ];
}
)));
CodeFn to_type = parse_function( token_fmt( "entries", string_to_strc(to_str_entries), stringize(
inline
Specifier strc_to_specifier( StrC str )
{
local_persist
u32 keymap[ Spec_NumSpecifiers ];
do_once_start
for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
{
StrC enum_str = spec_to_str( (Specifier)index );
// We subtract 1 to remove the null terminator
// This is because the tokens lexed are not null terminated.
keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1);
}
do_once_end
u32 hash = crc32( str.Ptr, str.Len );
for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
{
if ( keymap[index] == hash )
return (Specifier)index;
}
return Spec_Invalid;
}
)));
#pragma pop_macro("local_persist")
#pragma pop_macro("do_once_start")
#pragma pop_macro("do_once_end")
#pragma pop_macro("forceinline")
#pragma pop_macro("neverinline")
CodeBody result = def_body(CT_Global_Body);
body_append(result, enum_code);
if (use_c_definition)
{
CodeTypedef specifier_t = parse_typedef( code(typedef u32 Specifier; ));
body_append(result, specifier_t);
}
body_append(result, to_str);
body_append(result, is_trailing);
body_append(result, to_type);
if (! use_c_definition)
{
#pragma push_macro("forceinline")
#undef forceinline
CodeBody alias_mappings = parse_global_body(code(
forceinline StrC to_str (Specifier spec) { return spec_to_str(spec); }
forceinline Specifier to_type( StrC str ) { return strc_to_specifier(str); }
forceinline bool is_trailing( Specifier specifier ) { return spec_is_trailing(specifier); }
));
#pragma pop_macro("forceinline")
body_append(result, alias_mappings);
}
return result;
}
CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_definition = false )
{
FixedArena_64KB scratch; fixed_arena_init(& scratch);
AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch);
FileContents enum_content = file_read_contents( scratch_info, file_zero_terminate, etok_path );
CSV_Object csv_enum_nodes;
csv_parse( &csv_enum_nodes, rcast(char*, enum_content.data), scratch_info, false );
FileContents attrib_content = file_read_contents( scratch_info, file_zero_terminate, attr_path );
CSV_Object csv_attr_nodes;
csv_parse( &csv_attr_nodes, rcast(char*, attrib_content.data), scratch_info, false );
Array<ADT_Node> enum_strs = csv_enum_nodes.nodes[0].nodes;
Array<ADT_Node> enum_str_strs = csv_enum_nodes.nodes[1].nodes;
Array<ADT_Node> attribute_strs = csv_attr_nodes.nodes[0].nodes;
Array<ADT_Node> attribute_str_strs = csv_attr_nodes.nodes[1].nodes;
String enum_entries = string_make_reserve( scratch_info, kilobytes(2) );
String to_str_entries = string_make_reserve( scratch_info, kilobytes(4) );
String attribute_entries = string_make_reserve( scratch_info, kilobytes(2) );
String to_str_attributes = string_make_reserve( scratch_info, kilobytes(4) );
String attribute_define_entries = string_make_reserve( scratch_info, kilobytes(4) );
for (usize idx = 0; idx < array_num(enum_strs); idx++)
{
char const* enum_str = enum_strs[idx].string;
char const* entry_to_str = enum_str_strs [idx].string;
string_append_fmt( & enum_entries, "Tok_%s,\n", enum_str );
string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
}
for ( usize idx = 0; idx < array_num(attribute_strs); idx++ )
{
char const* attribute_str = attribute_strs[idx].string;
char const* entry_to_str = attribute_str_strs [idx].string;
string_append_fmt( & attribute_entries, "Tok_Attribute_%s,\n", attribute_str );
string_append_fmt( & to_str_attributes, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
string_append_fmt( & attribute_define_entries, "Entry( Tok_Attribute_%s, \"%s\" )", attribute_str, entry_to_str );
if ( idx < array_num(attribute_strs) - 1 )
string_append_strc( & attribute_define_entries, txt(" \\\n"));
else
string_append_strc( & attribute_define_entries, txt("\n"));
}
#pragma push_macro("GEN_DEFINE_ATTRIBUTE_TOKENS")
#undef GEN_DEFINE_ATTRIBUTE_TOKENS
CodeDefine attribute_entires_def = def_define( name(GEN_DEFINE_ATTRIBUTE_TOKENS), string_to_strc(attribute_define_entries) );
#pragma pop_macro("GEN_DEFINE_ATTRIBUTE_TOKENS")
// We cannot parse this enum, it has Attribute names as enums
CodeEnum enum_code;
if (use_c_definition)
{
enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), "attribute_toks", string_to_strc(attribute_entries), stringize(
enum TokType
{
<entries>
<attribute_toks>
Tok_NumTokens,
Tok_UnderlyingType = GEN_U32_MAX
};
)));
}
else
{
enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), "attribute_toks", string_to_strc(attribute_entries), stringize(
enum TokType : u32
{
<entries>
<attribute_toks>
Tok_NumTokens
};
)));
}
#pragma push_macro("local_persist")
#pragma push_macro("do_once_start")
#pragma push_macro("do_once_end")
#undef local_persist
#undef do_once_start
#undef do_once_end
CodeFn to_str = parse_function(token_fmt("entries", string_to_strc(to_str_entries), "attribute_toks", string_to_strc(to_str_attributes), stringize(
inline
StrC toktype_to_str( TokType type )
{
local_persist
StrC lookup[] = {
<entries>
<attribute_toks>
};
return lookup[ type ];
}
)));
CodeFn to_type = parse_function( token_fmt( "entries", string_to_strc(to_str_entries), stringize(
inline
TokType strc_to_toktype( StrC str )
{
local_persist
u32 keymap[ Tok_NumTokens ];
do_once_start
for ( u32 index = 0; index < Tok_NumTokens; index++ )
{
StrC enum_str = toktype_to_str( (TokType)index );
// We subtract 1 to remove the null terminator
// This is because the tokens lexed are not null terminated.
keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1);
}
do_once_end
u32 hash = crc32( str.Ptr, str.Len );
for ( u32 index = 0; index < Tok_NumTokens; index++ )
{
if ( keymap[index] == hash )
return (TokType)index;
}
return Tok_Invalid;
}
)));
#pragma pop_macro("local_persist")
#pragma pop_macro("do_once_start")
#pragma pop_macro("do_once_end")
CodeBody result = def_body(CT_Global_Body);
body_append(result, untyped_str(txt("GEN_NS_PARSER_BEGIN\n\n")));
body_append(result, attribute_entires_def);
body_append(result, enum_code);
if (use_c_definition)
{
CodeTypedef td_toktype = parse_typedef( code( typedef enum TokType TokType; ));
body_append(result, td_toktype);
}
body_append(result, to_str);
body_append(result, to_type);
body_append(result, untyped_str(txt("\nGEN_NS_PARSER_END\n\n")));
return result;
}
CodeBody gen_ast_inlines()
{
#pragma push_macro("GEN_NS")
#pragma push_macro("rcast")
#pragma push_macro("log_failure")
#pragma push_macro("CodeInvalid")
#undef GEN_NS
#undef rcast
#undef log_failure
#undef CodeInvalid
char const* code_impl_tmpl = stringize(
\n
inline
<typename>& <typename>::operator =( Code other )
{
if ( other.ast != nullptr && other->Parent != nullptr )
{
ast = rcast( decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
return * this;
}
inline
<typename>::operator bool()
{
return ast != nullptr;
}
);
char const* codetype_impl_tmpl = stringize(
inline
Code<typename>::operator Code()
{
return *rcast( Code*, this );
}
inline
AST_<typename>* Code<typename>::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
return nullptr;
}
return ast;
}
\n
);
#pragma pop_macro("GEN_NS")
#pragma pop_macro("CodeInvalid")
CodeBody impl_code = parse_global_body( token_fmt( "typename", StrC name(Code), code_impl_tmpl ));
CodeBody impl_code_body = parse_global_body( token_fmt( "typename", StrC name(CodeBody), code_impl_tmpl ));
CodeBody impl_code_attr = parse_global_body( token_fmt( "typename", StrC name(CodeAttributes), code_impl_tmpl ));
CodeBody impl_code_cmt = parse_global_body( token_fmt( "typename", StrC name(CodeComment), code_impl_tmpl ));
CodeBody impl_code_constr = parse_global_body( token_fmt( "typename", StrC name(CodeConstructor), code_impl_tmpl ));
CodeBody impl_code_class = parse_global_body( token_fmt( "typename", StrC name(CodeClass), code_impl_tmpl ));
CodeBody impl_code_define = parse_global_body( token_fmt( "typename", StrC name(CodeDefine), code_impl_tmpl ));
CodeBody impl_code_destruct = parse_global_body( token_fmt( "typename", StrC name(CodeDestructor), code_impl_tmpl ));
CodeBody impl_code_enum = parse_global_body( token_fmt( "typename", StrC name(CodeEnum), code_impl_tmpl ));
CodeBody impl_code_exec = parse_global_body( token_fmt( "typename", StrC name(CodeExec), code_impl_tmpl ));
CodeBody impl_code_extern = parse_global_body( token_fmt( "typename", StrC name(CodeExtern), code_impl_tmpl ));
CodeBody impl_code_include = parse_global_body( token_fmt( "typename", StrC name(CodeInclude), code_impl_tmpl ));
CodeBody impl_code_friend = parse_global_body( token_fmt( "typename", StrC name(CodeFriend), code_impl_tmpl ));
CodeBody impl_code_fn = parse_global_body( token_fmt( "typename", StrC name(CodeFn), code_impl_tmpl ));
CodeBody impl_code_module = parse_global_body( token_fmt( "typename", StrC name(CodeModule), code_impl_tmpl ));
CodeBody impl_code_ns = parse_global_body( token_fmt( "typename", StrC name(CodeNS), code_impl_tmpl ));
CodeBody impl_code_op = parse_global_body( token_fmt( "typename", StrC name(CodeOperator), code_impl_tmpl ));
CodeBody impl_code_opcast = parse_global_body( token_fmt( "typename", StrC name(CodeOpCast), code_impl_tmpl ));
CodeBody impl_code_params = parse_global_body( token_fmt( "typename", StrC name(CodeParams), code_impl_tmpl ));
CodeBody impl_code_pragma = parse_global_body( token_fmt( "typename", StrC name(CodePragma), code_impl_tmpl ));
CodeBody impl_code_precond = parse_global_body( token_fmt( "typename", StrC name(CodePreprocessCond), code_impl_tmpl ));
CodeBody impl_code_specs = parse_global_body( token_fmt( "typename", StrC name(CodeSpecifiers), code_impl_tmpl ));
CodeBody impl_code_struct = parse_global_body( token_fmt( "typename", StrC name(CodeStruct), code_impl_tmpl ));
CodeBody impl_code_tmpl = parse_global_body( token_fmt( "typename", StrC name(CodeTemplate), code_impl_tmpl ));
CodeBody impl_code_type = parse_global_body( token_fmt( "typename", StrC name(CodeTypename), code_impl_tmpl ));
CodeBody impl_code_typedef = parse_global_body( token_fmt( "typename", StrC name(CodeTypedef), code_impl_tmpl ));
CodeBody impl_code_union = parse_global_body( token_fmt( "typename", StrC name(CodeUnion), code_impl_tmpl ));
CodeBody impl_code_using = parse_global_body( token_fmt( "typename", StrC name(CodeUsing), code_impl_tmpl ));
CodeBody impl_code_var = parse_global_body( token_fmt( "typename", StrC name(CodeVar), code_impl_tmpl ));
body_append(impl_code_attr, parse_global_body( token_fmt( "typename", StrC name(Attributes), codetype_impl_tmpl )));
body_append(impl_code_cmt, parse_global_body( token_fmt( "typename", StrC name(Comment), codetype_impl_tmpl )));
body_append(impl_code_constr, parse_global_body( token_fmt( "typename", StrC name(Constructor), codetype_impl_tmpl )));
body_append(impl_code_define, parse_global_body( token_fmt( "typename", StrC name(Define), codetype_impl_tmpl )));
body_append(impl_code_destruct, parse_global_body( token_fmt( "typename", StrC name(Destructor), codetype_impl_tmpl )));
body_append(impl_code_enum, parse_global_body( token_fmt( "typename", StrC name(Enum), codetype_impl_tmpl )));
body_append(impl_code_exec, parse_global_body( token_fmt( "typename", StrC name(Exec), codetype_impl_tmpl )));
body_append(impl_code_extern, parse_global_body( token_fmt( "typename", StrC name(Extern), codetype_impl_tmpl )));
body_append(impl_code_include, parse_global_body( token_fmt( "typename", StrC name(Include), codetype_impl_tmpl )));
body_append(impl_code_friend, parse_global_body( token_fmt( "typename", StrC name(Friend), codetype_impl_tmpl )));
body_append(impl_code_fn, parse_global_body( token_fmt( "typename", StrC name(Fn), codetype_impl_tmpl )));
body_append(impl_code_module, parse_global_body( token_fmt( "typename", StrC name(Module), codetype_impl_tmpl )));
body_append(impl_code_ns, parse_global_body( token_fmt( "typename", StrC name(NS), codetype_impl_tmpl )));
body_append(impl_code_op, parse_global_body( token_fmt( "typename", StrC name(Operator), codetype_impl_tmpl )));
body_append(impl_code_opcast, parse_global_body( token_fmt( "typename", StrC name(OpCast), codetype_impl_tmpl )));
body_append(impl_code_pragma, parse_global_body( token_fmt( "typename", StrC name(Pragma), codetype_impl_tmpl )));
body_append(impl_code_precond, parse_global_body( token_fmt( "typename", StrC name(PreprocessCond), codetype_impl_tmpl )));
body_append(impl_code_tmpl, parse_global_body( token_fmt( "typename", StrC name(Template), codetype_impl_tmpl )));
body_append(impl_code_type, parse_global_body( token_fmt( "typename", StrC name(Typename), codetype_impl_tmpl )));
body_append(impl_code_typedef, parse_global_body( token_fmt( "typename", StrC name(Typedef), codetype_impl_tmpl )));
body_append(impl_code_union, parse_global_body( token_fmt( "typename", StrC name(Union), codetype_impl_tmpl )));
body_append(impl_code_using, parse_global_body( token_fmt( "typename", StrC name(Using), codetype_impl_tmpl )));
body_append(impl_code_var, parse_global_body( token_fmt( "typename", StrC name(Var), codetype_impl_tmpl )));
#pragma push_macro("forceinline")
#undef forceinline
char const* cast_tmpl = stringize(
forceinline Code::operator Code<typename>() const
{
return { (AST_<typename>*) ast };
}
);
#pragma pop_macro("forceinline")
CodeBody impl_cast_body = parse_global_body( token_fmt( "typename", StrC name(Body), cast_tmpl ));
CodeBody impl_cast_attribute = parse_global_body( token_fmt( "typename", StrC name(Attributes), cast_tmpl ));
CodeBody impl_cast_cmt = parse_global_body( token_fmt( "typename", StrC name(Comment), cast_tmpl ));
CodeBody impl_cast_constr = parse_global_body( token_fmt( "typename", StrC name(Constructor), cast_tmpl ));
CodeBody impl_cast_class = parse_global_body( token_fmt( "typename", StrC name(Class), cast_tmpl ));
CodeBody impl_cast_define = parse_global_body( token_fmt( "typename", StrC name(Define), cast_tmpl ));
CodeBody impl_cast_destruct = parse_global_body( token_fmt( "typename", StrC name(Destructor), cast_tmpl ));
CodeBody impl_cast_enum = parse_global_body( token_fmt( "typename", StrC name(Enum), cast_tmpl ));
CodeBody impl_cast_exec = parse_global_body( token_fmt( "typename", StrC name(Exec), cast_tmpl ));
CodeBody impl_cast_extern = parse_global_body( token_fmt( "typename", StrC name(Extern), cast_tmpl ));
CodeBody impl_cast_friend = parse_global_body( token_fmt( "typename", StrC name(Friend), cast_tmpl ));
CodeBody impl_cast_fn = parse_global_body( token_fmt( "typename", StrC name(Fn), cast_tmpl ));
CodeBody impl_cast_include = parse_global_body( token_fmt( "typename", StrC name(Include), cast_tmpl ));
CodeBody impl_cast_module = parse_global_body( token_fmt( "typename", StrC name(Module), cast_tmpl ));
CodeBody impl_cast_ns = parse_global_body( token_fmt( "typename", StrC name(NS), cast_tmpl ));
CodeBody impl_cast_op = parse_global_body( token_fmt( "typename", StrC name(Operator), cast_tmpl ));
CodeBody impl_cast_opcast = parse_global_body( token_fmt( "typename", StrC name(OpCast), cast_tmpl ));
CodeBody impl_cast_params = parse_global_body( token_fmt( "typename", StrC name(Params), cast_tmpl ));
CodeBody impl_cast_pragma = parse_global_body( token_fmt( "typename", StrC name(Pragma), cast_tmpl ));
CodeBody impl_cast_precond = parse_global_body( token_fmt( "typename", StrC name(PreprocessCond), cast_tmpl ));
CodeBody impl_cast_specs = parse_global_body( token_fmt( "typename", StrC name(Specifiers), cast_tmpl ));
CodeBody impl_cast_struct = parse_global_body( token_fmt( "typename", StrC name(Struct), cast_tmpl ));
CodeBody impl_cast_tmpl = parse_global_body( token_fmt( "typename", StrC name(Template), cast_tmpl ));
CodeBody impl_cast_type = parse_global_body( token_fmt( "typename", StrC name(Typename), cast_tmpl ));
CodeBody impl_cast_typedef = parse_global_body( token_fmt( "typename", StrC name(Typedef), cast_tmpl ));
CodeBody impl_cast_union = parse_global_body( token_fmt( "typename", StrC name(Union), cast_tmpl ));
CodeBody impl_cast_using = parse_global_body( token_fmt( "typename", StrC name(Using), cast_tmpl ));
CodeBody impl_cast_var = parse_global_body( token_fmt( "typename", StrC name(Var), cast_tmpl ));
CodeBody result = def_global_body( args(
def_pragma( txt("region generated code inline implementation")),
fmt_newline,
impl_code,
impl_code_body,
impl_code_attr,
impl_code_cmt,
impl_code_constr,
impl_code_class,
impl_code_define,
impl_code_destruct,
impl_code_enum,
impl_code_exec,
impl_code_extern,
impl_code_friend,
impl_code_fn,
impl_code_include,
impl_code_module,
impl_code_ns,
impl_code_op,
impl_code_opcast,
impl_code_params,
impl_code_pragma,
impl_code_precond,
impl_code_specs,
impl_code_struct,
impl_code_tmpl,
impl_code_type,
impl_code_typedef,
impl_code_union,
impl_code_using,
impl_code_var,
fmt_newline,
def_pragma( txt("endregion generated code inline implementation")),
fmt_newline,
def_pragma( txt("region generated AST/Code cast implementation")),
untyped_str(txt("GEN_OPTIMIZE_MAPPINGS_BEGIN\n")),
fmt_newline,
impl_cast_body,
impl_cast_attribute,
impl_cast_cmt,
impl_cast_constr,
impl_cast_class,
impl_cast_define,
impl_cast_destruct,
impl_cast_enum,
impl_cast_exec,
impl_cast_extern,
impl_cast_friend,
impl_cast_fn,
impl_cast_include,
impl_cast_module,
impl_cast_ns,
impl_cast_op,
impl_cast_opcast,
impl_cast_params,
impl_cast_pragma,
impl_cast_precond,
impl_cast_specs,
impl_cast_struct,
impl_cast_tmpl,
impl_cast_type,
impl_cast_typedef,
impl_cast_union,
impl_cast_using,
impl_cast_var,
fmt_newline,
untyped_str(txt("GEN_OPITMIZE_MAPPINGS_END\n")),
def_pragma( txt("endregion generated AST/Code cast implementation")),
fmt_newline
));
return result;
#pragma pop_macro("rcast")
#pragma pop_macro("log_failure")
}

80
base/helpers/misc.hpp Normal file
View File

@ -0,0 +1,80 @@
#pragma once
#ifdef GEN_INTELLISENSE_DIRECTIVES
# define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
# define GEN_ENFORCE_STRONG_CODE_TYPES
# define GEN_EXPOSE_BACKEND
# include "gen.hpp"
# include "helpers/push_ignores.inline.hpp"
# include "helpers/helper.hpp"
# include "auxillary/builder.hpp"
# include "auxillary/builder.cpp"
# include "auxillary/scanner.hpp"
#include <stdlib.h>
using namespace gen;
#endif
// Will format a file with the given style at the provided path.
// Assumes clang-format is defined in an user-exposed or system enviornment PATH.
void clang_format_file( char const* path, char const* style_path )
{
GEN_ASSERT_NOT_NULL(path);
String resolved_path = string_make_strc(GlobalAllocator, to_strc_from_c_str(path));
String style_arg;
if (style_path) {
style_arg = string_make_strc(GlobalAllocator, txt("-style=file:"));
string_append_fmt( & style_arg, "%s ", style_path );
}
StrC clang_format = txt("clang-format ");
StrC cf_format_inplace = txt("-i ");
StrC cf_verbose = txt("-verbose ");
String command = string_make_strc( GlobalAllocator, clang_format );
string_append_strc( & command, cf_format_inplace );
string_append_strc( & command, cf_verbose );
string_append_string( & command, style_arg );
string_append_string( & command, resolved_path );
system( command );
}
// Will refactor a file with the given script at the provided path.
// Assumes refactor is defined in an user-exposed or system enviornment PATH.
// (See: ./gencpp/scripts/build.ci.ps1 for how)
void refactor_file( char const* path, char const* refactor_script )
{
GEN_ASSERT_NOT_NULL(path);
GEN_ASSERT_NOT_NULL(refactor_script);
String command = string_make_strc(GlobalAllocator, txt("refactor "));
// string_append_strc( & command, txt("-debug ") );
string_append_strc( & command, txt("-num=1 ") );
string_append_fmt( & command, "-src=%s ", path );
string_append_fmt( & command,"-spec=%s ", refactor_script );
system(command);
log_fmt("\n");
}
// Does either of the above or both to the provided code.
// Code returned will be untyped content (its be serialized)
Code code_refactor_and_format( Code code, char const* scratch_path, char const* refactor_script, char const* clang_format_sytle_path )
{
GEN_ASSERT(code);
GEN_ASSERT_NOT_NULL(scratch_path);
Builder scratch_file = builder_open( scratch_path );
builder_print( & scratch_file, code);
builder_write(& scratch_file);
if (refactor_script) {
refactor_file(scratch_path, refactor_script);
}
if ( clang_format_sytle_path ) {
clang_format_file(scratch_path, clang_format_sytle_path);
}
Code result = scan_file( scratch_path );
::remove(scratch_path);
return result;
}

39
base/helpers/pop_container_defines.inline.hpp Normal file
View File

@ -0,0 +1,39 @@
#undef array_init
#undef array_init_reserve
#undef array_append_array
#undef array_append
#undef array_append_items
#undef array_append_at
#undef array_append_items_at
#undef array_back
#undef array_clear
#undef array_fill
#undef array_free
#undef arary_grow
#undef array_num
#undef arary_pop
#undef arary_remove_at
#undef arary_reserve
#undef arary_resize
#undef arary_set_capacity
#undef arary_get_header
#undef hashtable_init
#undef hashtable_init_reserve
#undef hashtable_clear
#undef hashtable_destroy
#undef hashtable_get
#undef hashtable_grow
#undef hashtable_rehash
#undef hashtable_rehash_fast
#undef hashtable_remove
#undef hashtable_remove_entry
#undef hashtable_set
#undef hashtable_slot
#undef hashtable_map
#undef hashtable_map_mut
//#undef hashtable_add_entry
//#undef hashtable_find
//#undef hashtable_full

0
project/helpers/pop_ignores.inline.hpp → base/helpers/pop_ignores.inline.hpp
View File

39
base/helpers/push_container_defines.inline.hpp Normal file
View File

@ -0,0 +1,39 @@
#define array_init(type, allocator) array_init <type> (allocator )
#define array_init_reserve(type, allocator, cap) array_init_reserve <type> (allocator, cap)
#define array_append_array(array, other) array_append_array < get_array_underlying_type(array) > (& array, other )
#define array_append(array, value) array_append < get_array_underlying_type(array) > (& array, value )
#define array_append_items(array, items, item_num) array_append_items < get_array_underlying_type(array) > (& array, items, item_num )
#define array_append_at(array, item, idx ) array_append_at < get_array_underlying_type(array) > (& array, item, idx )
#define array_append_at_items(array, items, item_num, idx) array_append_at_items< get_array_underlying_type(array) > (& items, item_num, idx )
#define array_back(array) array_back < get_array_underlying_type(array) > (array )
#define array_clear(array) array_clear < get_array_underlying_type(array) > (array )
#define array_fill(array, begin, end, value) array_fill < get_array_underlying_type(array) > (array, begin, end, value )
#define array_free(array) array_free < get_array_underlying_type(array) > (& array )
#define arary_grow(array, min_capacity) arary_grow < get_array_underlying_type(array) > (& array, min_capacity)
#define array_num(array) array_num < get_array_underlying_type(array) > (array )
#define arary_pop(array) arary_pop < get_array_underlying_type(array) > (array )
#define arary_remove_at(array, idx) arary_remove_at < get_array_underlying_type(array) > (idx)
#define arary_reserve(array, new_capacity) arary_reserve < get_array_underlying_type(array) > (& array, new_capacity )
#define arary_resize(array, num) arary_resize < get_array_underlying_type(array) > (& array, num)
#define arary_set_capacity(new_capacity) arary_set_capacity < get_array_underlying_type(array) > (& array, new_capacity )
#define arary_get_header(array) arary_get_header < get_array_underlying_type(array) > (array )
#define hashtable_init(type, allocator) hashtable_init <type >(allocator)
#define hashtable_init_reserve(type, allocator, num) hashtable_init_reserve<type >(allocator, num)
#define hashtable_clear(table) hashtable_clear < get_hashtable_underlying_type(table) >(table)
#define hashtable_destroy(table) hashtable_destroy < get_hashtable_underlying_type(table) >(& table)
#define hashtable_get(table, key) hashtable_get < get_hashtable_underlying_type(table) >(table, key)
#define hashtable_grow(table) hashtable_grow < get_hashtable_underlying_type(table) >(& table)
#define hashtable_rehash(table, new_num) hashtable_rehash < get_hashtable_underlying_type(table) >(& table, new_num)
#define hashtable_rehash_fast(table) hashtable_rehash_fast < get_hashtable_underlying_type(table) >(table)
#define hashtable_remove(table, key) hashtable_remove < get_hashtable_underlying_type(table) >(table, key)
#define hashtable_remove_entry(table, idx) hashtable_remove_entry< get_hashtable_underlying_type(table) >(table, idx)
#define hashtable_set(table, key, value) hashtable_set < get_hashtable_underlying_type(table) >(& table, key, value)
#define hashtable_slot(table, key) hashtable_slot < get_hashtable_underlying_type(table) >(table, key)
#define hashtable_map(table, map_proc) hashtable_map < get_hashtable_underlying_type(table) >(table, map_proc)
#define hashtable_map_mut(table, map_proc) hashtable_map_mut < get_hashtable_underlying_type(table) >(table, map_proc)
//#define hashtable_add_entry(table, key) hashtable_add_entry < get_hashtable_underlying_type(table) >(& table, key)
//#define hashtable_find(table, key) hashtable_find < get_hashtable_underlying_type(table) >(table, key)
//#define hashtable_full(table) hashtable_full < get_hashtable_underlying_type(table) >(table)

3
project/helpers/push_ignores.inline.hpp → base/helpers/push_ignores.inline.hpp
View File

@ -7,6 +7,9 @@
# pragma clang diagnostic ignored "-Wunknown-pragmas"
# pragma clang diagnostic ignored "-Wvarargs"
# pragma clang diagnostic ignored "-Wunused-function"
# pragma clang diagnostic ignored "-Wbraced-scalar-init"
# pragma clang diagnostic ignored "-W#pragma-messages"
# pragma clang diagnostic ignored "-Wstatic-in-inline"
#endif
#ifdef __GNUC__

203
base/helpers/undef.macros.h Normal file
View File

@ -0,0 +1,203 @@
// This undefines the macros used by the gen library
#undef GEN_TIME
#undef GEN_ARCH_64_BIT
#undef GEN_ARCH_32_BIT
#undef GEN_SYSTEM_ANDROID
#undef GEN_SYSTEM_CYGWIN
#undef GEN_SYSTEM_EMSCRIPTEN
#undef GEN_SYSTEM_FREEBSD
#undef GEN_SYSTEM_IOS
#undef GEN_SYSTEM_LINUX
#undef GEN_SYSTEM_MACOS
#undef GEN_SYSTEM_OPENBSD
#undef GEN_SYSTEM_OSX
#undef GEN_SYSTEM_UNIX
#undef GEN_SYSTEM_WINDOWS
#undef GEN_COMPILER_CLANG
#undef GEN_COMPILER_GCC
#undef GEN_COMPILER_MSVC
#undef GEN_HAS_ATTRIBUTE
#undef GEN_COMPILER_C
#undef GEN_COMPILER_CPP
#undef GEN_DONT_USE_NAMESPACE
#undef GEN_NS_PARSER_BEGIN
#undef GEN_NS_PARSER_END
#undef GEN_USING_NS_PARSER
#undef GEN_NS_PARSER
#undef GEN_NS
#undef GEN_NS_BEGIN
#undef GEN_NS_END
#undef GEN_C_LIKE_CPP
#undef global
#undef internal
#undef local_persist
#undef bit
#undef bitfield_is_equal
#undef cast
#undef ccast
#undef scast
#undef rcast
#undef pcast
#undef stringize
#undef do_once
#undef do_once_start
#undef do_once_end
#undef labeled_scope_start
#undef labeled_scope_end
#undef compiler_decorated_func_name
#undef num_args_impl
#undef num_args
#undef clamp
#undef count_of
#undef is_between
#undef size_of
#undef max
#undef min
#undef offset_of
#undef forceinline
#undef neverinline
#undef static_assert
#undef thread_local
#undef typeof
#undef GEN_API_C_BEGIN
#undef GEN_API_C_END
#undef enum_underlying
#undef nullptr
#undef GEN_PARAM_DEFAULT
#undef struct_init
#undef GEN_OPTIMIZE_MAPPINGS_BEGIN
#undef GEN_OPITMIZE_MAPPINGS_END
#undef GEN_U8_MIN
#undef GEN_U8_MAX
#undef GEN_I8_MIN
#undef GEN_I8_MAX
#undef GEN_U16_MIN
#undef GEN_U16_MAX
#undef GEN_I16_MIN
#undef GEN_I16_MAX
#undef GEN_U32_MIN
#undef GEN_U32_MAX
#undef GEN_I32_MIN
#undef GEN_I32_MAX
#undef GEN_U64_MIN
#undef GEN_U64_MAX
#undef GEN_I64_MIN
#undef GEN_I64_MAX
#undef GEN_USIZE_MIN
#undef GEN_USIZE_MAX
#undef GEN_ISIZE_MIN
#undef GEN_ISIZE_MAX
#undef GEN_USIZE_MIN
#undef GEN_USIZE_MAX
#undef GEN_ISIZE_MIN
#undef GEN_ISIZE_MAX
#undef GEN_F32_MIN
#undef GEN_F32_MAX
#undef GEN_F64_MIN
#undef GEN_F64_MAX
#undef to_uptr
#undef to_sptr
#undef to_mem_ptr
#undef to_mem_ptr_const
#undef kilobytes
#undef megabytes
#undef gigabytes
#undef terabytes
#undef GEN__ONES
#undef GEN__HIGHS
#undef GEN__HAS_ZERO
#undef GEN_DEFAULT_MEMORY_ALIGNMENT
#undef GEN_DEFAULT_ALLOCATOR_FLAGS
#undef zero_item
#undef zero_array
#undef alloc_item
#undef alloc_array
#undef malloc
#undef mfree
#undef GEN_DEBUG_TRAP
#undef GEN_ASSERT
#undef GEN_ASSERT_MSG
#undef GEN_ASSERT_NOT_NULL
#undef GEN_PANIC
#undef GEN_FATAL
#undef GEN_FILE_OPEN_PROC
#undef GEN_FILE_READ_AT_PROC
#undef GEN_FILE_WRITE_AT_PROC
#undef GEN_FILE_SEEK_PROC
#undef GEN_FILE_CLOSE_PROC
#undef GEN_PRINTF_MAXLEN
#undef _strlen
#undef _printf_err
#undef _printf_err_va
#undef _strlen
#undef _printf_err
#undef _printf_err_va
#undef Array
#undef get_array_underlying_type
#undef HashTable
#undef get_hashtable_underlying_type
#undef txt
#undef NOMINMAX
#undef VC_EXTRALEAN
#undef WIN32_LEAN_AND_MEAN
#undef WIN32_MEAN_AND_LEAN
#undef GEN_DEFINE_ATTRIBUTE_TOKENS
#undef GEN_AST_BODY_CLASS_UNALLOWED_TYPES
#undef GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES
#undef GEN_AST_BODY_GLOBAL_UNALLOWED_TYPES
#undef GEN_AST_BODY_EXPORT_UNALLOWED_TYPES
#undef GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES
#undef GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES
#undef GEN_GLOBAL_BUCKET_SIZE
#undef GEN_CODEPOOL_NUM_BLOCKS
#undef GEN_SIZE_PER_STRING_ARENA
#undef GEN_MAX_COMMENT_LINE_LENGTH
#undef GEN_MAX_NAME_LENGTH
#undef GEN_MAX_UNTYPED_STR_LENGTH
#undef TokenMap_FixedArena
#undef GEN_LEX_ALLOCATOR_SIZE
#undef GEN_BUILDER_STR_BUFFER_RESERVE
#undef log_failure
#undef gen_main
#undef name
#undef code
#undef args
#undef code_str
#undef code_fmt
#undef token_fmt
#undef parse_fmt
#undef token_fmt

70
docs/AST_Design.md
View File

@ -1,44 +1,58 @@
## Navigation
[Top](../Readme.md)
<- [docs - General](Readme.md)
## Current Design
`AST` is the actual managed node object for the library.
Its raw and really not meant to be used directly.
All user interaction must be with its pointer so the type they deal with is `AST*`.
For user-facing code, they should never be giveen a nullptr. Instead, they should be given a designated `Invalid` AST node.
In order to abstract away constant use of `AST*` its wrapped in a Code type which can be either:
In order to abstract away constant use of `AST*`, I wanted to provide a wrapper for it.
The simpliest being just a type alias.
```cpp
using Code = AST*;
When its the [C generated variant of the library](../gen_c_library/)
```c
typedef AST* Code;
tyepdef AST_<name>* Code<name>;
...
```
This is what the genc library would have to use due to its constraints of a langauge.
The actual content per type of AST is covered within [AST_Types.md](AST_Types.md).
These are pure PODS that just have the lay members relevant to the type of AST node they represent.
Each of them has a Code type alias specific to it.
Again, the simpliest case for these would be a type alias.
**or**
For C++:
```cpp
using struct AST_Typedef CodeTypedef;
struct Code {
AST* ast;
};
struct Code<name> {
...
AST_<name>* ast;
};
```
As of November 21st, 2023, the AST has had a strict layout for how its content is laid out.
This will be abandoned during its redesign that will occur starting with support for statments & expressions for either execution and type declarations.
Having a strict layout is too resctrictive vs allowing each AST type to have maximum control over the layout.
The full definitions of all asts are within:
The redesign will occur after the following todos are addressed:
* [`ast.hpp`](../base/components/ast.hpp)
* [`ast_types.hpp`](../base/components/ast_types.hpp)
* [`code_types.hpp`](../base/components/ast_types.hpp)
* [Improvements Lexer & Token struct#27](https://github.com/Ed94/gencpp/issues/27)
* [Generalize AST Flags to a single 4-byte flag#42](https://github.com/Ed94/gencpp/issues/42)
* [AST-Code Object Redesign.#38](https://github.com/Ed94/gencpp/issues/38)
* [Code-AST Documentation#40](https://github.com/Ed94/gencpp/issues/40)
* [AST::debug_str() improvements#33](https://github.com/Ed94/gencpp/issues/33)
* [AST::is_equal implemented and works with singleheader-test#31](https://github.com/Ed94/gencpp/issues/31)
* [Parser : Add ability to have a parse failure and continue with errors recorded.#35](https://github.com/Ed94/gencpp/issues/35)
* [Scanner : Add CodeFile#29](https://github.com/Ed94/gencpp/issues/29)
* [Auxiliary : AST visual debugger#36](https://github.com/Ed94/gencpp/issues/36)
The C/C++ interface procedures are located with `ast.hpp` (for the Code type), and `code_types.hpp` for all others.
## Serialization
All code types can either serialize using a function of the pattern:
```c
String <prefix>_to_string(Code code);
// or
<prefix>_to_string(Code code, String& result);
```
Where the first generates strings allocated using Allocator_StringArena and the other appends an existing strings with their backed allocator.
Serialization of for the AST is defined for `Code` in [`ast.chpp`](../base/components/ast.cpp) with `code_to_string_ptr` & `code_to_string`.
Serializtion for the rest of the code types is within [`code_serialization.cpp`](../base/components/code_serialization.cpp).
Gencpp's serialization does not provide coherent formatting of the code. The user should use a formatter after serializing.

180
docs/AST_Types.md
View File

@ -1,10 +1,16 @@
## Navigation
[Top](../Readme.md)
<- [docs - General](Readme.md)
# AST Types Documentation
While the Readme for docs covers the data layout per AST, this will focus on the AST types avaialble, and their nuances.
## Body
These are containers representing a scope body of a definition that can be of the following `ECode` type:
These are containers representing a scope body of a definition that can be of the following `CodeType` type:
* Class_Body
* Enum_Body
@ -19,11 +25,11 @@ These are containers representing a scope body of a definition that can be of th
Fields:
```cpp
StringCached Name;
Code Front;
Code Back;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
s32 NumEntries;
```
@ -31,14 +37,15 @@ s32 NumEntries;
The `Front` member represents the start of the link list and `Back` the end.
NumEntries is the number of entries in the body.
Parent should have a compatible ECode type for the type of defintion used.
Parent should have a compatible CodeType type for the type of defintion used.
Serialization:
Will output only the entries, the braces are handled by the parent.
```cpp
<Front>...
<Front>
...
<Back>
```
@ -50,11 +57,11 @@ Fields:
```cpp
StringCached Content;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
```
@ -74,11 +81,11 @@ Fields:
```cpp
StringCached Content;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
```
@ -102,11 +109,11 @@ CodeComment InlineCmt; // Only supported by forward declarations
CodeAttributes Attributes;
CodeType ParentType;
CodeBody Body;
CodeType Prev; // Used to store references to interfaces
CodeType Next; // Used to store references to interfaces
parser::Token* Tok;
Code Parent;
StringCached Name;
CodeType Prev;
CodeType Next;
Token* Tok;
Code Parent;
CodeT Type;
ModuleFlag ModuleFlags;
AccessSpec ParentAccess;
@ -125,7 +132,7 @@ Serialization:
};
```
You'll notice that only one parent type is supported only with parent access. This library only supports single inheritance, the rest must be done through interfaces.
You'll notice that only one parent type is supported only with parent access. This library only supports single inheritance, the rest are assumed to be interfaces and are given public acess specifiers.
## Constructor
@ -134,13 +141,13 @@ Fields:
```cpp
CodeComment InlineCmt; // Only supported by forward declarations
Code InitializerList;
CodeParam Params;
CodeParams Params;
Code Body;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
```
@ -172,11 +179,11 @@ Fields:
```cpp
StringCached Content;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
```
@ -194,11 +201,11 @@ Fields:
CodeComment InlineCmt;
CodeSpecifiers Specs;
Code Body;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
```
@ -229,24 +236,28 @@ Fields:
CodeComment InlineCmt;
CodeAttributes Attributes;
CodeType UnderlyingType;
Code UnderlyingTypeMacro;
CodeBody Body;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
ModuleFlag ModuleFlags;
```
UnderlyingTypeMacro is a macro the library natively supports: `enum_underlying(type)` that is meant to behave as a wrapper for underlying type assignment.
The `enum_underlying_sig` is a `StrC` global var that can be set which will be defined within `PreprocessorDefines` and used in `parser_parse_enum` to identify a valid macro.
Serialization:
```cpp
// Enum_Fwd
<ModuleFlags> enum class <Name> : <UnderlyingType>; <InlineCmt>
<ModuleFlags> enum class <Name> : <UnderlyingType> or <UnderlyingTypeMacro> ; <InlineCmt>
// Enum
<ModuleFlags> <enum or enum class> <Name> : <UnderlyingType>
<ModuleFlags> <enum or enum class> <Name> : <UnderlyingType> or <UnderlyingTypeMacro>
{
<Body>
};
@ -261,11 +272,11 @@ Fields:
```cpp
StringCached Content;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
```
@ -281,11 +292,11 @@ Fields:
```cpp
CodeBody Body;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
```
@ -304,11 +315,11 @@ Fields:
```cpp
StringCached Content;
StringCached Name;
Code Prev;
Code Next;
Code Parent;
parser::Token* Tok;
StringCached Name;
Token* Tok;
CodeT Type;
```
@ -327,11 +338,11 @@ Fields:
```cpp
CodeComment InlineCmt;
Code Declaration;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
```
@ -350,13 +361,13 @@ CodeComment InlineCmt;
CodeAttributes Attributes;
CodeSpecifiers Specs;
CodeType ReturnType;
CodeParam Params;
CodeParams Params;
CodeBody Body;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
ModuleFlag ModuleFlags;
```
@ -379,11 +390,11 @@ Serialization:
Fields:
```cpp
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
ModuleFlag ModuleFlags;
```
@ -400,11 +411,11 @@ Fields:
```cpp
CodeBody Body;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
ModuleFlag ModuleFlags;
```
@ -418,7 +429,7 @@ Serialization:
}
```
## Operator Overload
## Operator Overload (Operator)
Fields:
@ -427,13 +438,13 @@ CodeComment InlineCmt;
CodeAttributes Attributes;
CodeSpecifiers Specs;
CodeType ReturnType;
CodeParam Params;
CodeParams Params;
CodeBody Body;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
ModuleFlag ModuleFlags;
OperatorT Op;
@ -452,7 +463,7 @@ Serialization:
}
```
## Operator Cast Overload ( User-Defined Type Conversion )
## Operator Cast Overload ( User-Defined Type Conversion, OpCast )
Fields:
@ -461,11 +472,11 @@ CodeComment InlineCmt;
CodeSpecifiers Specs;
CodeType ValueType;
CodeBody Body;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
```
@ -482,7 +493,7 @@ Serialization:
}
```
## Parameters (AST_Param)
## Parameters (AST_Params)
Fields:
@ -490,11 +501,12 @@ Fields:
CodeType ValueType;
Code Macro;
Code Value;
CodeParam Last;
CodeParam Next;
parser::Token* Tok;
Code Parent;
Code PostNameMacro;
StringCached Name;
CodeParams Last;
CodeParams Next;
Token* Tok;
Code Parent;
CodeT Type;
s32 NumEntries;
```
@ -504,7 +516,7 @@ Serialization:
```cpp
<Macro>, <Next> ... <Last>
<Macro> <ValueType> <Name>, <Next>... <Last>
<Macro> <ValueType> <Name> <PostNameMacro> = <Value>, <Next>... <Last>
```
## Pragma
@ -513,11 +525,11 @@ Fields:
```cpp
StringCached Content;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
```
@ -533,11 +545,11 @@ Fields:
```cpp
StringCached Content;
StringCached Name;
Code Prev;
Code Next;
paser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
```
@ -552,13 +564,13 @@ Serialization:
Fields:
```cpp
SpecifierT ArrSpecs[ AST::ArrSpecs_Cap ];
SpecifierT ArrSpecs[ AST_ArrSpecs_Cap ];
CodeSpecifiers NextSpecs;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
s32 NumEntries;
```
@ -574,13 +586,13 @@ Serialization:
Fields:
```cpp
CodeParam Params;
CodeParams Params;
Code Declaration;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
ModuleFlag ModuleFlags;
```
@ -603,23 +615,30 @@ Fields:
CodeAttributes Attributes;
CodeSpecifiers Specs;
CodeReturnType ReturnType;
CodeParam Params;
CodeParams Params;
Code ArrExpr;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
b32 IsParamPack;
ETypenameTag TypeTag;
```
Serialization:
```cpp
<Attributes> <Name> <Specs> <IsParamPack ?: ...>
<Attributes> <TypeTag> <Name> <Specs> <IsParamPack ?: ...>
// Function
<Attributes> <ReturnType> <Name> <Params> <Specs>
```
`<Name>` currently has the full serialization of anything with
*Note: ArrExpr is not used in serialization by `typename_to_string_ref` its instead handled by a parent AST's serailization (variable, typedef, using).*
## Typedef
Behave as usual except function or macro typedefs.
@ -630,11 +649,11 @@ Fields:
```cpp
CodeComment InlineCmt;
Code UnderlyingType;
StringCached Name;
Code Prev;
Code Next;
parse::Token* Tok
Token* Tok
Code Parent;
StringCached Name;
CodeT Type;
ModuleFlag ModuleFlags;
b32 IsFunction;
@ -644,11 +663,16 @@ Serialization:
```cpp
// Regular
<ModuleFlags> typedef <UnderlyingType> <Name>; <InlineCmt>
<ModuleFlags> typedef <UnderlyingType> <Name> <UnderlyingType-ArrExpr>; <InlineCmt>
// Functions
<ModuleFlags> typedef <ReturnType> <Name>( <Parameters> ); <InlineCmt>
<ModuleFlags> typedef <ReturnType> ( <Expression that yeilds an Identifier signature> )( <Parameters> ); <InlineCmt>
// Currently:
<ModuleFlags> typedef <UnderlyingType (Serialized expression)>; <InlineCmt>
// Desired: Not handled yet
<ModuleFlags> typedef <UnderlyingType->ReturnType> UnderlyingType->Name> <UnderlyingType-ArrExpr> ( <UnderlyingType->Parameters> ); <InlineCmt>
<ModuleFlags> typedef <UnderlyingType->ReturnType> ( <Name->Namespace> for<Specs->has(Spec_Ptr) ?: *> <UnderlyingType->Name> <UnderlyingType-ArrExpr> ) ( <UnderlyingType->Parameters> ); <InlineCmt>
```
## Union
@ -658,11 +682,11 @@ Fields:
```cpp
CodeAttributes Attributes;
CodeBody Body;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
ModuleFlag ModuleFlags;
```
@ -684,11 +708,11 @@ Fields:
CodeComment InlineCmt;
CodeAttributes Attributes;
CodeType UnderlyingType;
StringCached Name;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
ModuleFlag ModuleFlags;
```
@ -716,14 +740,15 @@ CodeSpecifiers Specs;
CodeType ValueType;
Code BitfieldSize;
Code Value;
StringCached Name;
CodeVar NextVar;
Code Prev;
Code Next;
parser::Token* Tok;
Token* Tok;
Code Parent;
StringCached Name;
CodeT Type;
ModuleFlag ModuleFlags;
s32 VarParenthesizedInit;
```
Serialization:
@ -734,4 +759,7 @@ Serialization:
// Bitfield
<ModuleFlags> <Attributes> <Specs> <ValueType> <Name> : <BitfieldSize> = <Value>, NextVar ...; <InlineCmt>
// VarParenthesizedInit
<Attributes> <Specs> <ValueType> <Name>( <Value>, NextVar ... ); <InlineCmt>
```

10
docs/Parser_Algo.md
View File

@ -1,3 +1,9 @@
## Navigation
[Top](../Readme.md)
<- [docs - General](Readme.md)
# Parser's Algorithim
gencpp uses a hand-written recursive descent parser. Both the lexer and parser currently handle a full C/C++ file in a single pass.
@ -7,7 +13,7 @@ gencpp uses a hand-written recursive descent parser. Both the lexer and parser c
### Lexer
The lex procedure does the lexical pass of content provided as a `StrC` type.
The tokens are stored (for now) in `gen::parser::Tokens`.
The tokens are stored (for now) in `gen::parser::Lexer_Tokens`.
Fields:
@ -16,7 +22,7 @@ Array<Token> Arr;
s32 Idx;
```
What token types are supported can be found in [ETokType.csv](../project/enums/ETokType.csv) you can also find the token types in [ETokType.h](../project/components/gen/etoktype.cpp) , which is the generated enum from the csv file.
What token types are supported can be found in [ETokType.csv](../base/enums/ETokType.csv) you can also find the token types in [ETokType.h](../base/components/gen/etoktype.cpp) , which is the generated enum from the csv file.
Tokens are defined with the struct `gen::parser::Token`:

27
docs/Parsing.md
View File

@ -1,10 +1,16 @@
## Navigation
[Top](../Readme.md)
<- [docs - General](Readme.md)
# Parsing
The library features a naive parser tailored for only what the library needs to construct the supported syntax of C++ into its AST.
The library features a naive single-pass parser tailored for only what the library needs to construct the supported syntax of C++ into its AST for *"front-end"* meta-programming purposes.
This parser does not, and should not do the compiler's job. By only supporting this minimal set of features, the parser is kept (so far) around ~5600 loc. I hope to keep it under 10k loc worst case.
This parser does not, and should not do the compiler's job. By only supporting this minimal set of features, the parser is kept (so far) around ~7000 loc. I hope to keep it under 10k loc worst case.
You can think of this parser of a frontend parser vs a semantic parser. Its intuitively similar to WYSIWYG. What you precerive as the syntax from the user-side before the compiler gets a hold of it, is what you get.
You can think of this parser as *frontend parser* vs a *semantic parser*. Its intuitively similar to WYSIWYG. What you ***precerive*** as the syntax from the user-side before the compiler gets a hold of it, is what you get.
User exposed interface:
@ -47,10 +53,11 @@ The keywords supported for the preprocessor are:
* endif
* pragma
Each directive `#` line is considered one preproecessor unit, and will be treated as one Preprocessor AST. *These ASTs will be considered members or entries of braced scope they reside within*.
Each directive `#` line is considered one preproecessor unit, and will be treated as one Preprocessor AST.
If a directive is used with an unsupported keyword its will be processed as an untyped AST.
The preprocessor lines are stored as members of their associated scope they are parsed within. ( Global, Namespace, Class/Struct )
***Again (Its not standard): These ASTs will be considered members or entries of braced scope they reside within***
Any preprocessor definition abuse that changes the syntax of the core language is unsupported and will fail to parse if not kept within an execution scope (function body, or expression assignment).
Exceptions:
@ -59,6 +66,8 @@ Exceptions:
* Disable with: `#define GEN_PARSER_DISABLE_MACRO_FUNCTION_SIGNATURES`
* typedefs allow for a preprocessed macro: `typedef MACRO();`
* Disable with: `#define GEN_PARSER_DISABLE_MACRO_TYPEDEF`
* Macros can behave as typenames
* There is some macro support in paramters for functions or templates *(Specifically added to support parsing Unreal Engine source)*.
*(Exceptions are added on an on-demand basis)*
*(See functions `parse_operator_function_or_variable` and `parse_typedef` )*
@ -67,15 +76,23 @@ Adding your own exceptions is possible by simply modifying the parser to allow f
*Note: You could interpret this strictness as a feature. This would allow the user to see if their codebase or a third-party's codebase some some egregious preprocessor abuse.*
If a macro is not defined withint e scope of parsing a set of files, it can be defined beforehand by:
* Appending the [`PreprocessorDefines`](https://github.com/Ed94/gencpp/blob/a18b5b97aa5cfd20242065cbf53462a623cd18fa/base/components/header_end.hpp#L137) array.
* For functional macros a "(" just needs to be added after the name like: `<name>(` so that it will tokenize its arguments as part of the token during lexing.
* Defining a CodeDefine using `def_define`. The definition will be processed by the interface for user into `PreprocessorDefines`.
* This can be prevented by setting the optional prameter `dont_append_preprocess_defines`.
The lexing and parsing takes shortcuts from whats expected in the standard.
* Numeric literals are not checked for validity.
* The parse API treats any execution scope definitions with no validation and are turned into untyped Code ASTs.
* The parse API treats any execution scope definitions with no validation and are turned into untyped Code ASTs. (There is a [todo](https://github.com/Ed94/gencpp/issues/49) to add support)
* *This includes the assignment of variables.*
* Attributes ( `[[]]` (standard), `__declspec` (Microsoft), or `__attribute__` (GNU) )
* Assumed to *come before specifiers* (`const`, `constexpr`, `extern`, `static`, etc) for a function or right afterthe return type.
* Or in the usual spot for class, structs, (*right after the declaration keyword*)
* typedefs have attributes with the type (`parse_type`)
* Parsing attributes can be extended to support user defined macros by defining `GEN_DEFINE_ATTRIBUTE_TOKENS` (see `gen.hpp` for the formatting)
* This is useful for example: parsing Unreal `Module_API` macros.
Empty lines used throughout the file are preserved for formatting purposes during ast serialization.

178
docs/Readme.md
View File

@ -1,48 +1,18 @@
## Documentation
# General Docs
The project has no external dependencies beyond:
[Top](../Readme.md)
* `errno.h`
* `stat.h`
* `stdarg.h`
* `stddef.h`
* `stdio.h`
* `copyfile.h` (Mac)
* `types.h` (Linux)
* `unistd.h` (Linux/Mac)
* `intrin.h` (Windows)
* `io.h` (Windows with gcc)
* `windows.h` (Windows)
Contains:
Dependencies for the project are wrapped within `GENCPP_ROLL_OWN_DEPENDENCIES` (Defining it will disable them).
The majority of the dependency's implementation was derived from the [c-zpl library](https://github.com/zpl-c/zpl).
* [AST_Design](./AST_Design.md): Overvie of ASTs
* [AST Types](./AST_Types.md): Listing of all AST types along with their Code type interface.
* [Parsing](./Parsing.md): Overview of the parsing interface.
* [Parser Algo](./Parser_Algo.md): In-depth breakdown of the parser's implementation.
This library was written in a subset of C++ where the following are not used at all:
* RAII (Constructors/Destructors), lifetimes are managed using named static or regular functions.
* Language provide dynamic dispatch, RTTI
* Object-Oriented Inheritance
* Exceptions
Polymorphic & Member-functions are used as an ergonomic choice, along with a conserative use of operator overloads.
There are only 4 template definitions in the entire library. (`Array<Type>`, `Hashtable<Type>`, `swap<Type>`, and `AST/Code::cast<Type>`)
Two generic templated containers are used throughout the library:
* `template< class Type> struct Array`
* `template< class Type> struct HashTable`
Both Code and AST definitions have a `template< class Type> Code/AST :: cast()`. Its just an alternative way to explicitly cast to each other.
`template< class Type> swap( Type& a, Type& b)` is used over a macro.
Otherwise the library is free of any templates.
### *WHAT IS NOT PROVIDED*
### *CURRENTLY UNSUPPORTED*
**There is no support for validating expressions.**
Its difficult to parse without enough benefits (At the metaprogramming level).
I plan to add this only at the tail of the project parsing milestone.
Its a [todo](https://github.com/Ed94/gencpp/issues/49)
**Only trivial template support is provided.**
The intention is for only simple, non-recursive substitution.
@ -53,10 +23,20 @@ This means that the typename entry for the parameter AST would be either:
* `typename`
* A fundamental type, function, or pointer type.
Anything beyond this usage is not supported by parse_template for arguments (at least not intentionally).
Use at your own mental peril.
***Concepts and Constraints are not supported***
Its a [todo](https://github.com/Ed94/gencpp/issues/21)
*Concepts and Constraints are not supported, its usage is non-trivial substitution.*
### Feature Macros:
* `GEN_DEFINE_ATTRIBUTE_TOKENS` : Allows user to define their own attribute macros for use in parsing.
* This can be generated using base.cpp.
* `GEN_DEFINE_LIBRARY_CORE_CONSTANTS` : Optional typename codes as they are non-standard to C/C++ and not necessary to library usage
* `GEN_DONT_ENFORCE_GEN_TIME_GUARD` : By default, the library ( gen.hpp/ gen.cpp ) expects the macro `GEN_TIME` to be defined, this disables that.
* `GEN_ENFORCE_STRONG_CODE_TYPES` : Enforces casts to filtered code types.
* `GEN_EXPOSE_BACKEND` : Will expose symbols meant for internal use only.
* `GEN_ROLL_OWN_DEPENDENCIES` : Optional override so that user may define the dependencies themselves.
* `GEN_DONT_ALLOW_INVALID_CODE` (Not implemented yet) : Will fail when an invalid code is constructed, parsed, or serialized.
* `GEN_C_LIKE_PP` : Setting to `<true or 1>` Will prevent usage of function defnitions using references and structs with member functions. Structs will still have user-defined operator conversions, for-range support, and other operator overloads
### The Data & Interface
@ -65,68 +45,11 @@ As mentioned in root readme, the user is provided Code objects by calling the co
The AST is managed by the library and provided to the user via its interface.
However, the user may specifiy memory configuration.
Data layout of AST struct (Subject to heavily change with upcoming redesign):
[Data layout of AST struct (Subject to heavily change with upcoming todos)](../base/components/ast.hpp#L396-461)
```cpp
union {
struct
{
AST* InlineCmt; // Class, Constructor, Destructor, Enum, Friend, Functon, Operator, OpCast, Struct, Typedef, Using, Variable
AST* Attributes; // Class, Enum, Function, Struct, Typedef, Union, Using, Variable
AST* Specs; // Destructor, Function, Operator, Typename, Variable
union {
AST* InitializerList; // Constructor
AST* ParentType; // Class, Struct, ParentType->Next has a possible list of interfaces.
AST* ReturnType; // Function, Operator, Typename
AST* UnderlyingType; // Enum, Typedef
AST* ValueType; // Parameter, Variable
};
union {
AST* Macro; // Parameters
AST* BitfieldSize; // Variable (Class/Struct Data Member)
AST* Params; // Constructor, Function, Operator, Template, Typename
};
union {
AST* ArrExpr; // Typename
AST* Body; // Class, Constructr, Destructor, Enum, Function, Namespace, Struct, Union
AST* Declaration; // Friend, Template
AST* Value; // Parameter, Variable
};
union {
AST* NextVar; // Variable; Possible way to handle comma separated variables declarations. ( , NextVar->Specs NextVar->Name NextVar->ArrExpr = NextVar->Value )
AST* SpecsFuncSuffix; // Only used with typenames, to store the function suffix if typename is function signature.
};
};
StringCached Content; // Attributes, Comment, Execution, Include
struct {
SpecifierT ArrSpecs[AST::ArrSpecs_Cap]; // Specifiers
AST* NextSpecs; // Specifiers
};
};
union {
AST* Prev;
AST* Front;
AST* Last;
};
union {
AST* Next;
AST* Back;
};
AST* Parent;
StringCached Name;
CodeT Type;
ModuleFlag ModuleFlags;
union {
b32 IsFunction; // Used by typedef to not serialize the name field.
b32 IsParamPack; // Used by typename to know if type should be considered a parameter pack.
OperatorT Op;
AccessSpec ParentAccess;
s32 NumEntries;
};
s32 Token; // Handle to the token, stored in the CodeFile (Otherwise unretrivable)
```
https://github.com/Ed94/gencpp/blob/eea4ebf5c40d5d87baa465abfb1be30845b2377e/base/components/ast.hpp#L396-L461
*`CodeT` is a typedef for `ECode::Type` which has an underlying type of `u32`*
*`CodeType` is enum taggin the type of code. Has an underlying type of `u32`*
*`OperatorT` is a typedef for `EOperator::Type` which has an underlying type of `u32`*
*`StringCahced` is a typedef for `String const`, to denote it is an interned string*
*`String` is the dynamically allocated string type for the library*
@ -136,16 +59,19 @@ The width dictates how much the static array can hold before it must give way to
```cpp
constexpr static
usize ArrSpecs_Cap =
int AST_ArrSpecs_Cap =
(
AST_POD_Size
- sizeof(AST*) * 3
- sizeof(Code)
- sizeof(StringCached)
- sizeof(CodeT)
- sizeof(Code) * 2
- sizeof(Token*)
- sizeof(Code)
- sizeof(CodeType)
- sizeof(ModuleFlag)
- sizeof(u32)
)
/ sizeof(SpecifierT) -1; // -1 for 4 extra bytes (Odd num of AST*)
/ sizeof(Specifier) - 1;
```
*Ex: If the AST_POD_Size is 128 the capacity of the static array is 20.*
@ -154,7 +80,7 @@ Data Notes:
* The allocator definitions used are exposed to the user incase they want to dictate memory usage
* You'll find the memory handling in `init`, `deinit`, `reset`, `gen_string_allocator`, `get_cached_string`, `make_code`.
* Allocators are defined with the `AllocatorInfo` structure found in `dependencies\memory.hpp`
* Allocators are defined with the `AllocatorInfo` structure found in [`memory.hpp`](../base/dependencies/memory.hpp)
* Most of the work is just defining the allocation procedure:
```cpp
@ -162,30 +88,30 @@ Data Notes:
```
* ASTs are wrapped for the user in a Code struct which is a wrapper for a AST* type.
* Both AST and Code have member symbols but their data layout is enforced to be POD types.
* Code types have member symbols but their data layout is enforced to be POD types.
* This library treats memory failures as fatal.
* Cached Strings are stored in their own set of arenas. AST constructors use cached strings for names, and content.
* `StringArenas`, `StringCache`, `Allocator_StringArena`, and `Allocator_StringTable` are the associated containers or allocators.
* Strings used for serialization and file buffers are not contained by those used for cached strings.
* They are currently using `GlobalAllocator`, which are tracked array of arenas that grows as needed (adds buckets when one runs out).
* Memory within the buckets is not reused, so its inherently wasteful.
* I will be augmenting the single arena with a simple slag allocator.
* Linked lists used children nodes on bodies, and parameters.
* I will be augmenting the default allocator with virtual memory & a slab allocator in the [future](https://github.com/Ed94/gencpp/issues/12)
* Intrusive linked lists used children nodes on bodies, and parameters.
* Its intended to generate the AST in one go and serialize after. The constructors and serializer are designed to be a "one pass, front to back" setup.
* Allocations can be tuned by defining the folloiwng macros:
* Allocations can be tuned by defining the folloiwng macros (will be moved to runtime configuration in the future):
* `GEN_GLOBAL_BUCKET_SIZE` : Size of each bucket area for the global allocator
* `GEN_CODEPOOL_NUM_BLOCKS` : Number of blocks per code pool in the code allocator
* `GEN_SIZE_PER_STRING_ARENA` : Size per arena used with string caching.
* `GEN_MAX_COMMENT_LINE_LENGTH` : Longest length a comment can have per line.
* `GEN_MAX_NAME_LENGTH` : Max length of any identifier.
* `GEN_MAX_UNTYPED_STR_LENGTH` : Max content length for any untyped code.
* `GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE` : token_fmt_va uses local_persit memory of this size for the hashtable.
* `TokenMap_FixedArena` : token_fmt_va uses local_persit memory of this arena type for the hashtable.
* `GEN_LEX_ALLOCATOR_SIZE`
* `GEN_BUILDER_STR_BUFFER_RESERVE`
The following CodeTypes are used which the user may optionally use strong typing with if they enable: `GEN_ENFORCE_STRONG_CODE_TYPES`
* CodeBody : Has support for `for-range` iterating across Code objects.
* CodeBody : Has support for `for : range` iterating across Code objects.
* CodeAttributes
* CodeComment
* CodeClass
@ -202,13 +128,13 @@ The following CodeTypes are used which the user may optionally use strong typing
* CodeNS
* CodeOperator
* CodeOpCast
* CodeParam : Has support for `for-range` iterating across parameters.
* CodeParams : Has support for `for : range` iterating across parameters.
* CodePreprocessCond
* CodePragma
* CodeSpecifiers : Has support for `for-range` iterating across specifiers.
* CodeSpecifiers : Has support for `for : range` iterating across specifiers.
* CodeStruct
* CodeTemplate
* CodeType
* CodeTypename
* CodeTypedef
* CodeUnion
* CodeUsing
@ -293,6 +219,7 @@ Code <name>
```
When using the body functions, its recommended to use the args macro to auto determine the number of arguments for the varadic:
```cpp
def_global_body( args( ht_entry, array_ht_entry, hashtable ));
@ -373,6 +300,7 @@ Code <name> = untyped_str( code(
```
Optionally, `code_str`, and `code_fmt` macros can be used so that the code macro doesn't have to be used:
```cpp
Code <name> = code_str( <some code without "" quotes > )
```
@ -402,8 +330,8 @@ The following are provided predefined by the library as they are commonly used:
* `module_global_fragment`
* `module_private_fragment`
* `fmt_newline`
* `param_varaidc` (Used for varadic definitions)
* `pragma_once`
* `param_varaidc` (Used for varadic definitions)
* `preprocess_else`
* `preprocess_endif`
* `spec_const`
@ -419,6 +347,7 @@ The following are provided predefined by the library as they are commonly used:
* `spec_local_persist` (local_persist macro)
* `spec_mutable`
* `spec_neverinline`
* `spec_noexcept`
* `spec_override`
* `spec_ptr`
* `spec_pure`
@ -450,8 +379,8 @@ Optionally the following may be defined if `GEN_DEFINE_LIBRARY_CODE_CONSTANTS` i
* `t_u16`
* `t_u32`
* `t_u64`
* `t_sw` (ssize_t)
* `t_uw` (size_t)
* `t_ssize` (ssize_t)
* `t_usize` (size_t)
* `t_f32`
* `t_f64`
@ -469,14 +398,11 @@ and have the desired specifiers assigned to them beforehand.
## Code generation and modification
There are three provided auxillary interfaces:
There are two provided auxillary interfaces:
* Builder
* Editor
* Scanner
Editor and Scanner are disabled by default, use `GEN_FEATURE_EDITOR` and `GEN_FEATURE_SCANNER` to enable them.
### Builder is a similar object to the jai language's string_builder
* The purpose of it is to generate a file.
@ -486,4 +412,8 @@ Editor and Scanner are disabled by default, use `GEN_FEATURE_EDITOR` and `GEN_FE
### Scanner Auxillary Interface
Provides *(eventually)* `scan_file` to automatically populate a CodeFile which contains a parsed AST (`Code`) of the file, with any contextual failures that are reported from the parser.
* The purpose is to scan or parse files
* Some with two basic functions to convert a fil to code: `scan_file` and `parse_file`
* `scan_file`: Merely grabs the file and stores it in an untyped Code.
* `parse_file`: Will parse the file using `parse_global_body` and return a `CodeBody`.
* Two basic functions for grabbing columns from a CSV: `parse_csv_one_column` and `parse_csv_two_columns`

8
gen_c_library/.editorconfig Normal file
View File

@ -0,0 +1,8 @@
[*.c]
indent_style = tab
indent_size = 4
[*.cpp]
indent_style = tab
indent_size = 2

23
gen_c_library/Readme.md Normal file
View File

@ -0,0 +1,23 @@
## Navigation
# base
[Top](../Readme.md)
* [docs](../docs/Readme.md)
# C Library Generation
`c_library.cpp` generates both *segemnted* and *singleheader* variants of the library compliant with C11.
The output will be in the `gen_segmented/gen` directory (if the directory does not exist, it will create it).
If using the library's provided build scripts:
```ps1
.\build.ps1 <compiler> <debug or omit> c_library
```
All free from tag identifiers will be prefixed with `gen_` or `GEN_` as the namespace. This can either be changed after generation with a `.refactor` script (or your preferred subst method), OR by modifying c_library.refactor.
**If c_library.refactor is modified you may need to modify c_library.cpp and its [components](./components/). As some of the container generation relies on that prefix.**

1755
gen_c_library/c_library.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

543
gen_c_library/c_library.refactor Normal file
View File

@ -0,0 +1,543 @@
__VERSION 1
// not : Ignore
// include : #includes
// word : Alphanumeric or underscore
// namespace : Prefix search and replace (c-namspaces).
// regex : Unavailable in __VERSION 1.
// Precedence (highest to lowest):
// word, namespace, regex
// Gen Macro namespace
// namespace GEN_, new_namespace_
// c_library.refactor
// Used to prefix all exposed identifiers with the gen_namespace by c_library.cpp using ./gencpp/scripts/helpers/refactor.exe
// Macros
word global, gen_global
word internal, gen_internal
word local_persist, gen_local_persist
word bit, gen_bit
word bitfield_is_equal, gen_bitfield_is_equal
word cast, gen_cast
word ccast, gen_ccast
word pcast, gen_pcast
word rcast, gen_rcast
word scast, gen_scast
word stringize_va, gen_stringize_va
word stringize, gen_stringize
word do_once, gen_do_once
word do_once_start, gen_do_once_start
word do_once_end, gen_do_once_end
word labeled_scope_start, gen_labeled_scope_start
word labeled_scope_end, gen_labeled_scope_end
word compiler_decorated_func_name, gen_compiler_decorated_func_name
word num_args_impl, gen_num_args_impl
word num_args, gen_num_args
word clamp, gen_clamp
word count_of, gen_count_of
word is_between, gen_is_between
word size_of, gen_size_of
word max, gen_max
word min, gen_min
word offset_of, gen_offset_of
word forceinline, gen_forceinline
word neverinline, gen_neverinline
word static_assert, gen_static_assert
word thread_local, gen_thread_local
word typeof, gen_typeof
word enum_underlying, gen_enum_underlying
word nullptr, gen_nullptr
word struct_init, gen_struct_init
word hash, gen_hash
// Basic Types
word u8, gen_u8
word s8, gen_s8
word u16, gen_u16
word s16, gen_s16
word u32, gen_u32
word s32, gen_s32
word u64, gen_u64
word s64, gen_s64
word usize, gen_usize
word ssize, gen_ssize
word sptr, gen_sptr
word uptr, gen_uptr
word f32, gen_f32
word f64, gen_f64
word b8, gen_b8
word b16, gen_b16
word b32, gen_b32
word mem_ptr, gen_mem_ptr
word mem_ptr_const, gen_mem_ptr_const
word to_uptr, gen_to_uptr
word to_sptr, gen_to_sptr
word to_mem_ptr, gen_to_mem_ptr
word to_mem_ptr_const, gen_to_mem_ptr_const
// Debug
word assert_handler, gen_assert_handler
word assert_crash, gen_assert_crash
word process_exit, gen_process_exit
// Memory
word kilobytes, gen_kilobytes
word megabytes, gen_megabytes
word gigabytes, gen_gigabytes
word terabytes, gen_terabytes
word swap, gen_swap
word is_power_of_two, gen_is_power_of_two
word align_forward, gen_align_forward
word align_forward_by_value, gen_align_forward_by_value
word pointer_add, gen_pointer_add
word pointer_add_const, gen_pointer_add_const
word pointer_diff, gen_pointer_diff
word mem_copy, gen_mem_copy
word mem_find, gen_mem_find
word mem_move, gen_mem_move
word mem_set, gen_mem_set
word zero_size, gen_zero_size
word zero_item, gen_zero_item
word zero_array, gen_zero_array
word AllocType, gen_AllocType
word AllocatorProc, gen_AllocatorProc
word AllocatorInfo, gen_AllocatorInfo
word AllocFlag, gen_AllocFlag
word alloc, gen_alloc
word alloc_align, gen_alloc_align
word allocator_free, gen_allocator_free
word free_all, gen_free_all
word resize, gen_resize
word resize_align, gen_resize_align
word alloc_item, gen_alloc_item
word alloc_array, gen_alloc_array
word heap_stats_init, gen_heap_stats_init
word heap_stats_used_memory, gen_heap_stats_used_memory
word heap_stats_alloc_count, gen_heap_stats_alloc_count
word heap_stats_check, gen_heap_stats_check
word default_resize_align, gen_default_resize_align
word heap_allocator_proc, gen_heap_allocator_proc
word heap, gen_heap
word malloc, gen_malloc
word mfree, gen_mfree
word VirtualMemory, gen_VirtualMemory
word vm_from_memory, gen_vm_from_memory
word vm_alloc, gen_vm_alloc
word vm_free, gen_vm_free
word vm_trim, gen_vm_trim
word vm_purge, gen_vm_purge
word virtual_memory_page_size, gen_virtual_memory_page_size
// Memory: Arena
word Arena, gen_Arena
namespace arena_, gen_arena_
// word arena_allocator_info
// word arena_init_from_memory
// word arena_init_from_allocator
// word arena_init_sub
// word arena_alignment_of
// word arena_check
// word arena_size_remaining
// Memory: FixedArena
namespace FixedArena_, gen_FixedArena_
namespace fixed_arena_, gen_fixed_arena_
// Memory: Pool
word Pool, gen_Pool
namespace pool_, gen_pool_
// Printing
namespace str_, gen_str_
word PrintF_Buffer, gen_PrintF_Buffer
word Msg_Invalid_Value, gen_Msg_Invalid_Value
word log_fmt, gen_log_fmt
// String Ops
namespace char_, gen_char_
word digit_to_int, gen_digit_to_int
word hex_digit_to_init, gen_hex_digit_to_init
word i64_to_str, gen_i64_to_str
word u64_to_str, gen_u64_to_str
// Containers
namespace GENERIC_SLOT_, GEN_GENERIC_SLOT_
word Array, gen_Array
word Array_ssize, gen_Array_gen_ssize
word ArrayHeader, gen_ArrayHeader
namespace Array_, gen_Array_
namespace array_, gen_array_
word HashTable, gen_HashTable
namespace HashTable_, gen_HashTable_
namespace hashtable_, gen_hashtable_
namespace HT_, gen_HT_
namespace HTE_, gen_HTE_
namespace arr_hte_, gen_arr_hte_
namespace Arr_HTE_, gen_Arr_HTE_
// Hashing
word crc32, gen_crc32
word crc64, gen_crc64
// Strings
word StrC, gen_StrC
word to_strc_from_c_str, gen_to_strc_from_c_str
namespace strc_, gen_strc_
word cast_to_strc, gen_cast_to_strc
word StringHeader, gen_StringHeader
word String, gen_String
namespace string_, gen_string_
word StringCached, gen_StringCached
word StringTable, gen_StringTable
namespace StringTable_, gen_StringTable_
// File Handling
word FileModeFlag, gen_FileModeFlag
word SeekWhenceType, gen_SeekWhenceType
word FileError, gen_FileError
word FileDescriptor, gen_FileDescriptor
word FileMode, gen_FileMode
word FileOperations, gen_FileOperations
word FileOperations, gen_FileOperations
default_file_operations
word FileTime, word FileTime
word DirType, gen_DirType
word DirInfo, gen_DirInfo
word DirEntry, gen_DirEntry
word DirInfo, gen_DirInfo
word FileInfo, gen_FileInfo
word FileStandardType, gen_FileStandardType
namespace file_, gen_file_
word gen_FileContents, gen_FileContents
// Timing
word read_cpu_time_stamp_counter, gen_read_cpu_time_stamp_counter
word time_rel, gen_time_rel
word time_rel_ms, gen_time_rel_ms
// Parsing
// Parsing: ADT
word ADT_Node, gen_ADT_Node
word ADT_Type, gen_ADT_Type
word ADT_Props, gen_ADT_Props
word ADT_NamingStyle, gen_ADT_NamingStyle
word ADT_AssignStyle, gen_ADT_AssignStyle
word ADT_DelimStyle, gen_ADT_DelimStyle
word ADT_Error, gen_ADT_Error
word ADT_Node, gen_ADT_Node
namespace adt_, gen_adt_
word CSV_Error, gen_CSV_Error
word CSV_Object, gen_CSV_Object
namespace csv_, gen_csv_
// Types.hpp
word log_failure, gen_log_failure
word AccessSpec, gen_AccessSpec
word access_spec_to_str, gen_access_spec_to_str
word CodeFlag, gen_CodeFlag
word EnumDecl, gen_EnumDecl
word ModuleFlag, gen_ModuleFlag
word module_flag_to_str, gen_module_flag_to_str
word EPreprocessCond, gen_EPreprocessCOnd
word ETypenameTag, gen_ETypenameTag
word CodeType, gen_CodeType
word codetype_to_str, gen_codetype_to_str
word codetype_to_keyword_str, gen_codetype_to_keyword_str
word Operator, gen_Operator
word operator_to_str, gen_operator_to_str
word Specifier, gen_Specifier
word spec_to_str, gen_spec_to_str
word spec_is_trailing, gen_spec_is_trailing
// word strc_to_specifier, gen_strc_to_specifier
// AST
word AST, gen_AST
namespace AST_, gen_AST_
word Code, gen_Code
word Token, gen_Token
word CodeBody, gen_CodeBody
word CodeAttributes, gen_CodeAttributes
word CodeComment, gen_CodeComment
word CodeClass, gen_CodeClass
word CodeConstructor, gen_CodeConstructor
word CodeDefine, gen_CodeDefine
word CodeDestructor, gen_CodeDestructor
word CodeEnum, gen_CodeEnum
word CodeExec, gen_CodeExec
word CodeExtern, gen_CodeExtern
word CodeInclude, gen_CodeInclude
word CodeFriend, gen_CodeFriend
word CodeFn, gen_CodeFn
word CodeModule, gen_CodeModule
word CodeNS, gen_CodeNS
word CodeOperator, gen_CodeOperator
word CodeOpCast, gen_CodeOpCast
word CodePragma, gen_CodePragma
word CodeParams, gen_CodeParams
word CodePreprocessCo, gen_CodePreprocessCo
word CodeSpecifiers, gen_CodeSpecifiers
word CodeTemplate, gen_CodeTemplate
word CodeTypename, gen_CodeTypename
word CodeTypedef, gen_CodeTypedef
word CodeUnion, gen_CodeUnion
word CodeUsing, gen_CodeUsing
word CodeVar, gen_CodeVar
// Code Interface
namespace code_, gen_code_
word Code_Global, gen_Code_Global
word Code_Invalid, gen_Code_Invalid
word Code_POD, gen_Code_POD
word AST_POD_Size, gen_AST_POD_Size
word AST_ArrSpecs_Cap, gen_AST_ArrSpecs_Cap
word InvalidCode, gen_InvalidCode
word NullCode, gen_NullCode
namespace begin_, gen_begin_
namespace end_, gen_end_
namespace next_, gen_next_
namespace body_, gen_body_
namespace class_, gen_class_
namespace params_, gen_params_
namespace specifiers_, gen_specifiers_
namespace struct_, gen_struct_
namespace attributes_, gen_attributes_
namespace comment_, gen_comment_
namespace constructor, gen_constructor_
namespace define_, gen_define_
namespace destructor, gen_destructor_
namespace enum_, gen_enum_
namespace exec_, gen_exec_
namespace extern_, gen_extern_
namespace include_, gen_include_
namespace friend_, gen_friend_
namespace fn_, gen_fn_
namespace module_, gen_module_
namespace code_op, gen_code_op_
namespace opcast_, gen_opcast_
namespace pragma_, gen_pragma_
namespace preprocess_, gen_preprocess_
namespace template_, gen_template_
namespace typename_, gen_typename_
namespace typedef_, gen_typedef_
namesapce union_, gen_union_
namespace using_, gen_using_
namespace var_, gen_var_
// Gen Interface
word init, gen_init
word deinit, gen_deinit
word reset, gen_reset
word get_cached_string, gen_get_cached_string
word make_code, gen_make_code
namespace set_allocator_, gen_set_allocator_
namespace def_, gen_def_
namespace parse_, gen_parse_
namespace token_, gen_token_
namespace untyped_, gen_untyped_
// Constants
word TokenMap_FixedArena, gen_TokenMap_FixedArena
word InitSize_DataArrays, gen_InitSize_DataArrays
word Global_BucketSize, gen_Global_BucketSize
word CodePool_NumBlocks, gen_CodePool_NumBlocks
word SizePer_StringArena, gen_SizePer_StringArena
word MaxCommentLineLength, gen_MaxCommentLineLength
word MaxNameLength, gen_MaxNameLength
word MaxUntypedStrLength, gen_MaxUntypedStrLength
word LexAllocator_Size, gen_LexAllocator_Size
word Builder_StrBufferReserve, gen_Builder_StrBufferReserve
word access_public, gen_access_public
word access_protected, gen_access_protected
word access_private, gen_access_private
word attrib_api_export, gen_attrib_api_export
word attrib_api_import, gen_attrib_api_import
word module_global_fragment, gen_module_global_fragment
word module_private_fragment, gen_module_private_fragment
word fmt_newline, gen_fmt_newline
word pragma_once, gen_pragma_once
word param_varadic, gen_param_varadic
word preprocess_else, gen_preprocess_else
namespace spec_, gen_spec_
namespace t_, gen_t_
word PreprocessorDefines, gen_PreprocessorDefines
// Backend
word GlobalAllocator, gen_GlobalAllocator
word Global_AllocatorBuckets, gen_Global_AllocatorBuckets
word CodePools, gen_CodePools
word StringArenas, gen_StringArenas
word StringCache, gen_StringCache
word LexArena, gen_LexArena
word Allocator_DataArrays, gen_Allocator_DataArrays
word Allocator_CodePool, gen_Allocator_CodePool
word Allocator_Lexer, gen_Allocator_Lexer
word Allocator_StringArena, gen_Allocator_StringArena
word Allocator_StringTable, gen_Allocator_StringTable
word Allocator_TypeTable, gen_Allocator_TypeTable
// Builder
word Builder, gen_Builder
namespace builder_, gen_builder_
// Implementation (prviate)
word _format_info, gen__format_info
namespace _print_, gen__print_
word _heap_stats, gen__heap_stats
word _heap_alloc_info, gen__heap_alloc_info
word _crc32_table, gen__crc32_table
word _crc64_table, gen__crc64_table
word _alloc_utf8_to_ucs2, gen__alloc_utf8_to_ucs2
word _win32_file_seek, gen__win32_file_seek
word _win32_file_read, gen__win32_file_read
word _win32_file_write, gen__win32_file_write
word _win32_file_close, gen__win32_file_close
word _win32_file_open, gen__win32_file_open
word _posix_file_seek, gen__posix_file_seek
word _posix_file_read, gen__posix_file_read
word _posix_file_write, gen__posix_file_write
word _posix_file_close, gen__posix_file_close
word _posix_file_open, gen__posix_file_open
word _dirinfo_free_entry, gen__dirinfo_free_entry
word _std_file_set, gen__std_file_set
word _memory_fd, gen__memory_fd
word _file_stream_fd_make, gen__file_stream_fd_make
word _file_stream_from_fd, gen__file_stream_from_fd
word _memory_file_seek, gen__memory_file_seek
word _memory_file_read, gen__memory_file_read
word _memory_file_write, gen__memory_file_write
word _memory_file_close, gen__memory_file_close
word _unix_gettime, gen__unix_gettime
word _adt_fprintf, gen__adt_fprintf
word _adt_get_value, gen__adt_get_value
word _adt_get_field, gen__adt_get_field
word _csv_write_record, gen__csv_write_record
word _csv_write_header, gen__csv_write_header
word Global_Allocator_Proc, gen_Global_Allocator_Proc
word define_constants, gen_define_constants
word operator__validate, gen_operator__validate
word parser_init, gen_parser_init
word parser_deinit, gen_parser_deinit
word TokType, gen_TokType
word toktype_to_str, gen_toktype_to_str
// word strc_to_toktype, gen_strc_to_toktype
word NullToken, gen_NullToken
namespace tok_, gen_tok_
word TokArray, gen_TokArray
namespace lex_, gen_lex_
namespace Lexer_, gen_Lexer_
word LexContext, gen_LexContext
word lex, gen_lex
word StackNode, gen_StackNode
word ParseContext, gen_ParseContext
// namespace parse_, gen_parse_
namespace parser_, gen_parser_

434
gen_c_library/components/containers.array.hpp Normal file
View File

@ -0,0 +1,434 @@
#pragma once
#include "gen.hpp"
using namespace gen;
// Used to know what slot the array will be for generic selection
global s32 Array_DefinitionCounter = 0;
CodeBody gen_array_base()
{
CodeTypedef td_header = parse_typedef( code( typedef struct ArrayHeader ArrayHeader; ));
CodeStruct header = parse_struct( code(
struct ArrayHeader
{
AllocatorInfo Allocator;
usize Capacity;
usize Num;
};
));
Code grow_formula = untyped_str( txt( "#define array_grow_formula( value ) ( 2 * value + 8 )\n" ));
Code get_header = untyped_str( txt( "#define array_get_header( self ) ( (ArrayHeader*)( self ) - 1)\n" ));
Code type_define = untyped_str( txt( "#define Array(Type) gen_Array_##Type\n"));
Code array_begin = def_define(txt("array_begin(array)"), code( (array) ));
Code array_end = def_define(txt("array_end(array)"), code( (array + array_get_header(array)->Num ) ));
Code array_next = def_define(txt("array_next(array, entry)"), code( (entry + 1) ));
return def_global_body( args(
fmt_newline,
td_header,
header,
type_define,
grow_formula,
get_header,
array_begin,
array_end,
array_next,
fmt_newline
));
};
CodeBody gen_array( StrC type, StrC array_name )
{
String array_type = String::fmt_buf( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr );
String fn = String::fmt_buf( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr );
// str_to_lower(fn.Data);
#pragma push_macro( "GEN_ASSERT" )
#pragma push_macro( "rcast" )
#pragma push_macro( "cast" )
#pragma push_macro( "typeof" )
#pragma push_macro( "forceinline" )
#undef GEN_ASSERT
#undef rcast
#undef cast
#undef typeof
#undef forceinline
CodeBody result = parse_global_body( token_fmt( "array_type", (StrC)array_type, "fn", (StrC)fn, "type", (StrC)type
, stringize(
typedef <type>* <array_type>;
<array_type> <fn>_init ( AllocatorInfo allocator );
<array_type> <fn>_init_reserve ( AllocatorInfo allocator, usize capacity );
bool <fn>_append_array ( <array_type>* self, <array_type> other );
bool <fn>_append ( <array_type>* self, <type> value );
bool <fn>_append_items ( <array_type>* self, <type>* items, usize item_num );
bool <fn>_append_at ( <array_type>* self, <type> item, usize idx );
bool <fn>_append_items_at( <array_type>* self, <type>* items, usize item_num, usize idx );
<type>* <fn>_back ( <array_type> self );
void <fn>_clear ( <array_type> self );
bool <fn>_fill ( <array_type> self, usize begin, usize end, <type> value );
void <fn>_free ( <array_type>* self );
bool <fn>_grow ( <array_type>* self, usize min_capacity );
usize <fn>_num ( <array_type> self );
<type> <fn>_pop ( <array_type> self );
void <fn>_remove_at ( <array_type> self, usize idx );
bool <fn>_reserve ( <array_type>* self, usize new_capacity );
bool <fn>_resize ( <array_type>* self, usize num );
bool <fn>_set_capacity ( <array_type>* self, usize new_capacity );
forceinline
<array_type> <fn>_init( AllocatorInfo allocator )
{
size_t initial_size = array_grow_formula(0);
return array_init_reserve( <type>, allocator, initial_size );
}
inline
<array_type> <fn>_init_reserve( AllocatorInfo allocator, usize capacity )
{
GEN_ASSERT(capacity > 0);
ArrayHeader* header = rcast(ArrayHeader*, alloc(allocator, sizeof(ArrayHeader) + sizeof(<type>) * capacity));
if (header == nullptr)
return nullptr;
header->Allocator = allocator;
header->Capacity = capacity;
header->Num = 0;
return rcast(<type>*, header + 1);
}
forceinline
bool <fn>_append_array( <array_type>* self, <array_type> other )
{
return array_append_items( * self, (<array_type>)other, <fn>_num(other));
}
inline
bool <fn>_append( <array_type>* self, <type> value )
{
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
ArrayHeader* header = array_get_header( * self );
if ( header->Num == header->Capacity )
{
if ( ! array_grow( self, header->Capacity))
return false;
header = array_get_header( * self );
}
(* self)[ header->Num ] = value;
header->Num++;
return true;
}
inline
bool <fn>_append_items( <array_type>* self, <type>* items, usize item_num )
{
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
GEN_ASSERT(items != nullptr);
GEN_ASSERT(item_num > 0);
ArrayHeader* header = array_get_header( * self );
if ( header->Num + item_num > header->Capacity )
{
if ( ! array_grow( self, header->Capacity + item_num ))
return false;
header = array_get_header( * self );
}
mem_copy( (* self) + header->Num, items, sizeof(<type>) * item_num );
header->Num += item_num;
return true;
}
inline
bool <fn>_append_at( <array_type>* self, <type> item, usize idx )
{
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
ArrayHeader* header = array_get_header( * self );
if ( idx >= header->Num )
idx = header->Num - 1;
if ( idx < 0 )
idx = 0;
if ( header->Capacity < header->Num + 1 )
{
if ( ! array_grow( self, header->Capacity + 1 ) )
return false;
header = array_get_header( * self );
}
<array_type> target = (* self) + idx;
mem_move( target + 1, target, (header->Num - idx) * sizeof(<type>) );
header->Num++;
return true;
}
inline
bool <fn>_append_items_at( <array_type>* self, <type>* items, usize item_num, usize idx )
{
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
ArrayHeader* header = array_get_header( * self );
if ( idx >= header->Num )
{
return array_append_items( * self, items, item_num );
}
if ( item_num > header->Capacity )
{
if ( ! array_grow( self, item_num + header->Capacity ) )
return false;
header = array_get_header( * self );
}
<type>* target = (* self) + idx + item_num;
<type>* src = (* self) + idx;
mem_move( target, src, (header->Num - idx) * sizeof(<type>) );
mem_copy( src, items, item_num * sizeof(<type>) );
header->Num += item_num;
return true;
}
inline
<type>* <fn>_back( <array_type> self )
{
GEN_ASSERT(self != nullptr);
ArrayHeader* header = array_get_header( self );
if ( header->Num == 0 )
return NULL;
return self + header->Num - 1;
}
inline
void <fn>_clear( <array_type> self )
{
GEN_ASSERT(self != nullptr);
ArrayHeader* header = array_get_header( self );
header->Num = 0;
}
inline
bool <fn>_fill( <array_type> self, usize begin, usize end, <type> value )
{
GEN_ASSERT(self != nullptr);
GEN_ASSERT(begin <= end);
ArrayHeader* header = array_get_header( self );
if ( begin < 0 || end >= header->Num )
return false;
for ( ssize idx = begin; idx < end; idx ++ )
self[ idx ] = value;
return true;
}
inline
void <fn>_free( <array_type>* self )
{
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
ArrayHeader* header = array_get_header( * self );
allocator_free( header->Allocator, header );
self = NULL;
}
inline
bool <fn>_grow( <array_type>* self, usize min_capacity )
{
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
GEN_ASSERT( min_capacity > 0 );
ArrayHeader* header = array_get_header( *self );
usize new_capacity = array_grow_formula( header->Capacity );
if ( new_capacity < min_capacity )
new_capacity = min_capacity;
return array_set_capacity( self, new_capacity );
}
forceinline
usize <fn>_num( <array_type> self )
{
GEN_ASSERT( self != nullptr);
return array_get_header(self)->Num;
}
inline
<type> <fn>_pop( <array_type> self )
{
GEN_ASSERT( self != nullptr);
ArrayHeader* header = array_get_header( self );
GEN_ASSERT( header->Num > 0 );
<type> result = self[ header->Num - 1 ];
header->Num--;
return result;
}
forceinline
void <fn>_remove_at( <array_type> self, usize idx )
{
GEN_ASSERT( self != nullptr);
ArrayHeader* header = array_get_header( self );
GEN_ASSERT( idx < header->Num );
mem_move( self + idx, self + idx + 1, sizeof( <type> ) * ( header->Num - idx - 1 ) );
header->Num--;
}
inline
bool <fn>_reserve( <array_type>* self, usize new_capacity )
{
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
GEN_ASSERT(new_capacity > 0);
ArrayHeader* header = array_get_header( * self );
if ( header->Capacity < new_capacity )
return array_set_capacity( self, new_capacity );
return true;
}
inline
bool <fn>_resize( <array_type>* self, usize num )
{
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
GEN_ASSERT(num > 0);
ArrayHeader* header = array_get_header( * self );
if ( header->Capacity < num )
{
if ( ! array_grow( self, num ) )
return false;
header = array_get_header( * self );
}
header->Num = num;
return true;
}
inline
bool <fn>_set_capacity( <array_type>* self, usize new_capacity )
{
GEN_ASSERT( self != nullptr);
GEN_ASSERT(* self != nullptr);
GEN_ASSERT( new_capacity > 0 );
ArrayHeader* header = array_get_header( * self );
if ( new_capacity == header->Capacity )
return true;
if ( new_capacity < header->Num )
{
header->Num = new_capacity;
return true;
}
usize size = sizeof( ArrayHeader ) + sizeof( <type> ) * new_capacity;
ArrayHeader* new_header = cast( ArrayHeader*, alloc( header->Allocator, size ));
if ( new_header == NULL )
return false;
mem_move( new_header, header, sizeof( ArrayHeader ) + sizeof( <type> ) * header->Num );
new_header->Capacity = new_capacity;
allocator_free( header->Allocator, & header );
* self = cast( <type>*, new_header + 1 );
return true;
}
)));
#pragma pop_macro( "GEN_ASSERT" )
#pragma pop_macro( "rcast" )
#pragma pop_macro( "cast" )
#pragma pop_macro( "typeof" )
#pragma pop_macro( "forceinline" )
++ Array_DefinitionCounter;
StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", Array_DefinitionCounter).to_strc();
Code generic_interface_slot = untyped_str(token_fmt( "type", type, "array_type", (StrC)array_type, "slot", (StrC)slot_str,
R"(#define GENERIC_SLOT_<slot>__array_init <type>, <array_type>_init
#define GENERIC_SLOT_<slot>__array_init_reserve <type>, <array_type>_init_reserve
#define GENERIC_SLOT_<slot>__array_append <array_type>, <array_type>_append
#define GENERIC_SLOT_<slot>__array_append_items <array_type>, <array_type>_append_items
#define GENERIC_SLOT_<slot>__array_append_at <array_type>, <array_type>_append_at
#define GENERIC_SLOT_<slot>__array_append_items_at <array_type>, <array_type>_append_items_at
#define GENERIC_SLOT_<slot>__array_back <array_type>, <array_type>_back
#define GENERIC_SLOT_<slot>__array_clear <array_type>, <array_type>_clear
#define GENERIC_SLOT_<slot>__array_fill <array_type>, <array_type>_fill
#define GENERIC_SLOT_<slot>__array_free <array_type>, <array_type>_free
#define GENERIC_SLOT_<slot>__array_grow <array_type>*, <array_type>_grow
#define GENERIC_SLOT_<slot>__array_num <array_type>, <array_type>_num
#define GENERIC_SLOT_<slot>__array_pop <array_type>, <array_type>_pop
#define GENERIC_SLOT_<slot>__array_remove_at <array_type>, <array_type>_remove_at
#define GENERIC_SLOT_<slot>__array_reserve <array_type>, <array_type>_reserve
#define GENERIC_SLOT_<slot>__array_resize <array_type>, <array_type>_resize
#define GENERIC_SLOT_<slot>__array_set_capacity <array_type>*, <array_type>_set_capacity
)"
));
return def_global_body( args(
def_pragma( string_to_strc( string_fmt_buf( GlobalAllocator, "region %S", array_type ))),
fmt_newline,
generic_interface_slot,
fmt_newline,
result,
fmt_newline,
def_pragma( string_to_strc(string_fmt_buf( GlobalAllocator, "endregion %S", array_type ))),
fmt_newline
));
};
CodeBody gen_array_generic_selection_interface()
{
CodeBody interface_defines = def_body(CT_Global_Body);
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_init"), GenericSel_Direct_Type ));
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_init_reserve"), GenericSel_Direct_Type ));
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_append"), GenericSel_By_Ref ));
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_append_at"), GenericSel_By_Ref ));
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_append_items"), GenericSel_By_Ref ));
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_append_items_at"), GenericSel_By_Ref ));
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_back"), GenericSel_Default, GenericSel_One_Arg ));
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_clear"), GenericSel_Default, GenericSel_One_Arg ));
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_fill")) );
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_free"), GenericSel_By_Ref, GenericSel_One_Arg ) );
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_grow")) );
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_num"), GenericSel_Default, GenericSel_One_Arg ));
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_pop"), GenericSel_Default, GenericSel_One_Arg ));
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_remove_at")) );
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_reserve"), GenericSel_By_Ref) );
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_resize"), GenericSel_By_Ref) );
interface_defines.append( gen_generic_selection_function_macro( Array_DefinitionCounter, txt("array_set_capacity")) );
return interface_defines;
}

433
gen_c_library/components/containers.hashtable.hpp Normal file
View File

@ -0,0 +1,433 @@
#pragma once
#include "gen.hpp"
#include "containers.array.hpp"
using namespace gen;
global s32 HashTable_DefinitionCounter = 0;
CodeBody gen_hashtable_base()
{
CodeBody struct_def = parse_global_body( code(
typedef struct HT_FindResult_Def HT_FindResult;
struct HT_FindResult_Def
{
ssize HashIndex;
ssize PrevIndex;
ssize EntryIndex;
};
));
Code define_type = untyped_str(txt(
R"(#define HashTable(_type) struct _type
)"
));
Code define_critical_load_scale = untyped_str(txt("#define HashTable_CriticalLoadScale 0.7f\n"));
return def_global_body(args(struct_def, define_type, define_critical_load_scale));
}
CodeBody gen_hashtable( StrC type, StrC hashtable_name )
{
String tbl_type = {(char*) hashtable_name.duplicate(GlobalAllocator).Ptr};
String fn = tbl_type.duplicate(GlobalAllocator);
// str_to_lower(fn.Data);
String name_lower = String::make( GlobalAllocator, hashtable_name );
// str_to_lower( name_lower.Data );
String hashtable_entry = String::fmt_buf( GlobalAllocator, "HTE_%.*s", hashtable_name.Len, hashtable_name.Ptr );
String entry_array_name = String::fmt_buf( GlobalAllocator, "Arr_HTE_%.*s", hashtable_name.Len, hashtable_name.Ptr );
String entry_array_fn_ns = String::fmt_buf( GlobalAllocator, "arr_hte_%.*s", name_lower.length(), name_lower.Data );
CodeBody hashtable_types = parse_global_body( token_fmt(
"type", (StrC) type,
"tbl_name", (StrC) hashtable_name,
"tbl_type", (StrC) tbl_type,
stringize(
typedef struct HashTable_<type> <tbl_type>;
typedef struct HTE_<tbl_name> HTE_<tbl_name>;
struct HTE_<tbl_name> {
u64 Key;
ssize Next;
<type> Value;
};
typedef void (* <tbl_type>_MapProc) ( <tbl_type> self, u64 key, <type> value );
typedef void (* <tbl_type>_MapMutProc) ( <tbl_type> self, u64 key, <type>* value );
)));
CodeBody entry_array = gen_array( hashtable_entry, entry_array_name );
#pragma push_macro( "GEN_ASSERT" )
#pragma push_macro( "GEN_ASSERT_NOT_NULL" )
#pragma push_macro( "rcast" )
#pragma push_macro( "cast" )
#pragma push_macro( "typeof" )
#pragma push_macro( "forceinline" )
#undef GEN_ASSERT
#undef GEN_ASSERT_NOT_NULL
#undef GEN_ASSERT
#undef rcast
#undef cast
#undef typeof
#undef forceinline
CodeBody hashtable_def = parse_global_body( token_fmt(
"type", (StrC) type,
"tbl_name", (StrC) hashtable_name,
"tbl_type", (StrC) tbl_type,
"fn", (StrC) fn,
"entry_type", (StrC) hashtable_entry,
"array_entry", (StrC) entry_array_name,
"fn_array", (StrC) entry_array_fn_ns,
stringize(
struct HashTable_<type> {
Array_ssize Hashes;
<array_entry> Entries;
};
<tbl_type> <fn>_init ( AllocatorInfo allocator );
<tbl_type> <fn>_init_reserve( AllocatorInfo allocator, ssize num );
void <fn>_clear ( <tbl_type> self );
void <fn>_destroy ( <tbl_type>* self );
<type>* <fn>_get ( <tbl_type> self, u64 key );
void <fn>_map ( <tbl_type> self, <tbl_type>_MapProc map_proc );
void <fn>_map_mut ( <tbl_type> self, <tbl_type>_MapMutProc map_proc );
void <fn>_grow ( <tbl_type>* self );
void <fn>_rehash ( <tbl_type>* self, ssize new_num );
void <fn>_rehash_fast ( <tbl_type> self );
void <fn>_remove ( <tbl_type> self, u64 key );
void <fn>_remove_entry( <tbl_type> self, ssize idx );
void <fn>_set ( <tbl_type>* self, u64 key, <type> value );
ssize <fn>_slot ( <tbl_type> self, u64 key );
ssize <fn>__add_entry( <tbl_type>* self, u64 key );
HT_FindResult <fn>__find ( <tbl_type> self, u64 key );
b32 <fn>__full ( <tbl_type> self );
<tbl_type> <fn>_init( AllocatorInfo allocator )
{
<tbl_type> result = hashtable_init_reserve(<type>, allocator, 8);
return result;
}
<tbl_type> <fn>_init_reserve( AllocatorInfo allocator, ssize num )
{
<tbl_type> result = { NULL, NULL };
result.Hashes = array_init_reserve(ssize, allocator, num );
array_get_header(result.Hashes)->Num = num;
array_resize(result.Hashes, num);
array_fill(result.Hashes, 0, num, -1);
result.Entries = array_init_reserve(<entry_type>, allocator, num );
return result;
}
void <fn>_clear( <tbl_type> self )
{
GEN_ASSERT_NOT_NULL(self.Hashes);
GEN_ASSERT_NOT_NULL(self.Entries);
array_clear( self.Entries );
s32 what = array_num(self.Hashes);
array_fill( self.Hashes, 0, what, (ssize)-1 );
}
void <fn>_destroy( <tbl_type>* self )
{
GEN_ASSERT_NOT_NULL(self);
GEN_ASSERT_NOT_NULL(self->Hashes);
GEN_ASSERT_NOT_NULL(self->Entries);
if ( self->Hashes && array_get_header(self->Hashes)->Capacity) {
array_free( self->Hashes );
array_free( self->Entries );
}
}
<type>* <fn>_get( <tbl_type> self, u64 key )
{
GEN_ASSERT_NOT_NULL(self.Hashes);
GEN_ASSERT_NOT_NULL(self.Entries);
ssize idx = <fn>__find( self, key ).EntryIndex;
if ( idx > 0 )
return & self.Entries[idx].Value;
return nullptr;
}
void <fn>_map( <tbl_type> self, <tbl_type>_MapProc map_proc )
{
GEN_ASSERT_NOT_NULL(self.Hashes);
GEN_ASSERT_NOT_NULL(self.Entries);
GEN_ASSERT_NOT_NULL( map_proc );
for ( ssize idx = 0; idx < array_get_header( self.Entries )->Num; idx++ ) {
map_proc( self, self.Entries[idx].Key, self.Entries[idx].Value );
}
}
void <fn>_map_mut( <tbl_type> self, <tbl_type>_MapMutProc map_proc )
{
GEN_ASSERT_NOT_NULL(self.Hashes);
GEN_ASSERT_NOT_NULL(self.Entries);
GEN_ASSERT_NOT_NULL( map_proc );
for ( ssize idx = 0; idx < array_get_header( self.Entries )->Num; idx++ ) {
map_proc( self, self.Entries[idx].Key, & self.Entries[idx].Value );
}
}
void <fn>_grow( <tbl_type>* self )
{
GEN_ASSERT_NOT_NULL(self);
GEN_ASSERT_NOT_NULL(self->Hashes);
GEN_ASSERT_NOT_NULL(self->Entries);
ssize new_num = array_grow_formula( array_get_header( self->Entries )->Num );
hashtable_rehash( self, new_num );
}
void <fn>_rehash( <tbl_type>* self, ssize new_num )
{
GEN_ASSERT_NOT_NULL(self);
GEN_ASSERT_NOT_NULL(self->Hashes);
GEN_ASSERT_NOT_NULL(self->Entries);
GEN_ASSERT( new_num > 0 );
ssize idx;
ssize last_added_index;
ArrayHeader* old_hash_header = array_get_header( self->Hashes );
ArrayHeader* old_entries_header = array_get_header( self->Entries );
<tbl_type> new_tbl = hashtable_init_reserve( <type>, old_hash_header->Allocator, old_hash_header->Num );
ArrayHeader* new_hash_header = array_get_header( new_tbl.Hashes );
for (ssize idx = 0; idx < cast(ssize, old_hash_header->Num); ++idx)
{
<entry_type>* entry = & self->Entries[idx];
HT_FindResult find_result;
find_result = <fn>__find( new_tbl, entry->Key);
last_added_index = <fn>__add_entry( & new_tbl, entry->Key);
if (find_result.PrevIndex < 0)
new_tbl.Hashes[find_result.HashIndex] = last_added_index;
else
new_tbl.Entries[find_result.PrevIndex].Next = last_added_index;
new_tbl.Entries[last_added_index].Next = find_result.EntryIndex;
new_tbl.Entries[last_added_index].Value = entry->Value;
}
<fn>_destroy( self );
* self = new_tbl;
}
void <fn>_rehash_fast( <tbl_type> self )
{
GEN_ASSERT_NOT_NULL(self.Hashes);
GEN_ASSERT_NOT_NULL(self.Entries);
ssize idx;
for ( idx = 0; idx < array_get_header( self.Entries )->Num; idx++ )
self.Entries[ idx ].Next = -1;
for ( idx = 0; idx < array_get_header( self.Hashes )->Num; idx++ )
self.Hashes[ idx ] = -1;
for ( idx = 0; idx < array_get_header( self.Entries )->Num; idx++ )
{
<entry_type>* entry;
HT_FindResult find_result;
entry = & self.Entries[ idx ];
find_result = <fn>__find( self, entry->Key );
if ( find_result.PrevIndex < 0 )
self.Hashes[ find_result.HashIndex ] = idx;
else
self.Entries[ find_result.PrevIndex ].Next = idx;
}
}
void <fn>_remove( <tbl_type> self, u64 key )
{
GEN_ASSERT_NOT_NULL(self.Hashes);
GEN_ASSERT_NOT_NULL(self.Entries);
HT_FindResult find_result = <fn>__find( self, key );
if ( find_result.EntryIndex >= 0 ) {
array_remove_at( self.Entries, find_result.EntryIndex );
hashtable_rehash_fast( self );
}
}
void <fn>_remove_entry( <tbl_type> self, ssize idx )
{
GEN_ASSERT_NOT_NULL(self.Hashes);
GEN_ASSERT_NOT_NULL(self.Entries);
array_remove_at( self.Entries, idx );
}
void <fn>_set( <tbl_type>* self, u64 key, <type> value )
{
GEN_ASSERT_NOT_NULL(self);
GEN_ASSERT_NOT_NULL(self->Hashes);
GEN_ASSERT_NOT_NULL(self->Entries);
ssize idx;
HT_FindResult find_result;
if ( array_get_header( self->Hashes )->Num == 0 )
hashtable_grow( self );
find_result = <fn>__find( * self, key );
if ( find_result.EntryIndex >= 0 ) {
idx = find_result.EntryIndex;
}
else
{
idx = <fn>__add_entry( self, key );
if ( find_result.PrevIndex >= 0 ) {
self->Entries[ find_result.PrevIndex ].Next = idx;
}
else {
self->Hashes[ find_result.HashIndex ] = idx;
}
}
self->Entries[ idx ].Value = value;
if ( <fn>__full( * self ) )
hashtable_grow( self );
}
ssize <fn>_slot( <tbl_type> self, u64 key )
{
GEN_ASSERT_NOT_NULL(self.Hashes);
GEN_ASSERT_NOT_NULL(self.Entries);
for ( ssize idx = 0; idx < array_get_header( self.Hashes )->Num; ++idx )
if ( self.Hashes[ idx ] == key )
return idx;
return -1;
}
ssize <fn>__add_entry( <tbl_type>* self, u64 key )
{
GEN_ASSERT_NOT_NULL(self);
GEN_ASSERT_NOT_NULL(self->Hashes);
GEN_ASSERT_NOT_NULL(self->Entries);
ssize idx;
<entry_type> entry = { key, -1 };
idx = array_get_header( self->Entries )->Num;
array_append( self->Entries, entry );
return idx;
}
HT_FindResult <fn>__find( <tbl_type> self, u64 key )
{
GEN_ASSERT_NOT_NULL(self.Hashes);
GEN_ASSERT_NOT_NULL(self.Entries);
HT_FindResult result = { -1, -1, -1 };
ArrayHeader* hash_header = array_get_header( self.Hashes );
if ( hash_header->Num > 0 )
{
result.HashIndex = key % hash_header->Num;
result.EntryIndex = self.Hashes[ result.HashIndex ];
while ( result.EntryIndex >= 0 )
{
if ( self.Entries[ result.EntryIndex ].Key == key )
break;
result.PrevIndex = result.EntryIndex;
result.EntryIndex = self.Entries[ result.EntryIndex ].Next;
}
}
return result;
}
b32 <fn>__full( <tbl_type> self )
{
GEN_ASSERT_NOT_NULL(self.Hashes);
GEN_ASSERT_NOT_NULL(self.Entries);
ArrayHeader* hash_header = array_get_header( self.Hashes );
ArrayHeader* entries_header = array_get_header( self.Entries );
usize critical_load = cast(usize, HashTable_CriticalLoadScale * cast(f32, hash_header->Num));
b32 result = entries_header->Num > critical_load;
return result;
}
)));
#pragma pop_macro( "GEN_ASSERT" )
#pragma pop_macro( "GEN_ASSERT_NOT_NULL" )
#pragma pop_macro( "rcast" )
#pragma pop_macro( "cast" )
#pragma pop_macro( "typeof" )
#pragma pop_macro( "forceinline" )
++ HashTable_DefinitionCounter;
StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", HashTable_DefinitionCounter).to_strc();
Code generic_interface_slot = untyped_str(token_fmt( "type", type, "tbl_type", (StrC)tbl_type, "slot", (StrC)slot_str,
R"(#define GENERIC_SLOT_<slot>__hashtable_init <type>, <tbl_type>_init
#define GENERIC_SLOT_<slot>__hashtable_init_reserve <type>, <tbl_type>_init_reserve
#define GENERIC_SLOT_<slot>__hashtable_clear <tbl_type>, <tbl_type>_clear
#define GENERIC_SLOT_<slot>__hashtable_destroy <tbl_type>, <tbl_type>_destroy
#define GENERIC_SLOT_<slot>__hashtable_get <tbl_type>, <tbl_type>_get
#define GENERIC_SLOT_<slot>__hashtable_map <tbl_type>, <tbl_type>_map
#define GENERIC_SLOT_<slot>__hashtable_map_mut <tbl_type>, <tbl_type>_map_mut
#define GENERIC_SLOT_<slot>__hashtable_grow <tbl_type>*, <tbl_type>_grow
#define GENERIC_SLOT_<slot>__hashtable_rehash <tbl_type>*, <tbl_type>_rehash
#define GENERIC_SLOT_<slot>__hashtable_rehash_fast <tbl_type>, <tbl_type>_rehash_fast
#define GENERIC_SLOT_<slot>__hashtable_remove_entry <tbl_type>, <tbl_type>_remove_entry
#define GENERIC_SLOT_<slot>__hashtable_set <tbl_type>, <tbl_type>_set
#define GENERIC_SLOT_<slot>__hashtable_slot <tbl_type>, <tbl_type>_slot
#define GENERIC_SLOT_<slot>__hashtable__add_entry <tbl_type>*, <tbl_type>__add_entry
#define GENERIC_SLOT_<slot>__hashtable__find <tbl_type>, <tbl_type>__find
#define GENERIC_SLOT_<slot>__hashtable__full <tbl_type>, <tbl_type>__full
)"
));
char const* cmt_str = str_fmt_buf( "Name: %.*s Type: %.*s"
, tbl_type.length(), tbl_type.Data
, type.Len, type.Ptr );
return def_global_body(args(
def_pragma( string_to_strc( string_fmt_buf( GlobalAllocator, "region %S", tbl_type ))),
fmt_newline,
generic_interface_slot,
fmt_newline,
hashtable_types,
fmt_newline,
entry_array,
hashtable_def,
fmt_newline,
def_pragma( string_to_strc( string_fmt_buf( GlobalAllocator, "endregion %S", tbl_type ))),
fmt_newline
));
}
CodeBody gen_hashtable_generic_selection_interface()
{
CodeBody interface_defines = def_body(CT_Global_Body);
interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_init"), GenericSel_Direct_Type ));
interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_init_reserve"), GenericSel_Direct_Type ));
interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_clear"), GenericSel_Default, GenericSel_One_Arg ));
interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_destroy"), GenericSel_By_Ref, GenericSel_One_Arg ) );
interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_get") ));
interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_grow"), GenericSel_Default, GenericSel_One_Arg ));
interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_rehash") ));
interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_rehash_fast"), GenericSel_Default, GenericSel_One_Arg ));
interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_remove") ));
interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_remove_entry") ));
interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_set"), GenericSel_By_Ref ));
interface_defines.append( gen_generic_selection_function_macro( HashTable_DefinitionCounter, txt("hashtable_slot") ));
return interface_defines;
}

115
gen_c_library/components/generic_macros.hpp Normal file
View File

@ -0,0 +1,115 @@
#pragma region _Generic Macros
// ____ _ ______ _ _ ____ _ __ _
// / ___} (_) | ____} | | (_) / __ \ | | | |(_)
// | | ___ ___ _ __ ___ _ __ _ ___ | |__ _ _ _ __ ___| |_ _ ___ _ __ | | | |_ _____ _ __ | | ___ __ _ __| | _ _ __ __ _
// | |{__ |/ _ \ '_ \ / _ \ '__} |/ __| | __} | | | '_ \ / __} __} |/ _ \| '_ \ | | | \ \ / / _ \ '_ \| |/ _ \ / _` |/ _` || | '_ \ / _` |
// | |__j | __/ | | | __/ | | | (__ | | | |_| | | | | (__| l_| | (_) | | | | | l__| |\ V / __/ | | | | (_) | (_| | (_| || | | | | (_| |
// \____/ \___}_l l_l\___}_l l_l\___| l_l \__,_l_l l_l\___}\__}_l\___/l_l l_l \____/ \_/ \___}_l l_l_l\___/ \__,_l\__,_l|_|_| |_|\__, |
// This implemnents macros for utilizing "The Naive Extendible _Generic Macro" explained in: __| |
// https://github.com/JacksonAllan/CC/blob/main/articles/Better_C_Generics_Part_1_The_Extendible_Generic.md {___/
// Since gencpp is used to generate the c-library, it was choosen over the more novel implementations to keep the macros as easy to understand and unobfuscated as possible.
#define GEN_COMMA_OPERATOR , // The comma operator is used by preprocessor macros to delimit arguments, so we have to represent it via a macro to prevent parsing incorrectly.
// Helper macros for argument selection
#define GEN_SELECT_ARG_1( _1, ... ) _1 // <-- Of all th args passed pick _1.
#define GEN_SELECT_ARG_2( _1, _2, ... ) _2 // <-- Of all the args passed pick _2.
#define GEN_SELECT_ARG_3( _1, _2, _3, ... ) _3 // etc..
#define GEN_GENERIC_SEL_ENTRY_TYPE GEN_SELECT_ARG_1 // Use the arg expansion macro to select arg 1 which should have the type.
#define GEN_GENERIC_SEL_ENTRY_FUNCTION GEN_SELECT_ARG_2 // Use the arg expansion macro to select arg 2 which should have the function.
#define GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER GEN_SELECT_ARG_3 // Use the arg expansion macro to select arg 3 which should have the comma delimiter ','.
#define GEN_RESOLVED_FUNCTION_CALL // Just used to indicate where the call "occurs"
// ----------------------------------------------------------------------------------------------------------------------------------
// GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( macro ) includes a _Generic slot only if the specified macro is defined (as type, function_name).
// It takes advantage of the fact that if the macro is defined, then the expanded text will contain a comma.
// Expands to ',' if it can find (type): (function) <comma_operator: ',' >
// Where GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER is specifically looking for that <comma> ,
#define GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( slot_exp ) GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER( slot_exp, GEN_GENERIC_SEL_ENTRY_TYPE( slot_exp, ): GEN_GENERIC_SEL_ENTRY_FUNCTION( slot_exp, ) GEN_COMMA_OPERATOR, , )
// ^ Selects the comma ^ is the type ^ is the function ^ Insert a comma
// The slot won't exist if that comma is not found. |
// For the occastion where an expression didn't resolve to a selection option the "default: <value>" will be set to:
typedef struct GENCPP_NO_RESOLVED_GENERIC_SELECTION GENCPP_NO_RESOLVED_GENERIC_SELECTION;
struct GENCPP_NO_RESOLVED_GENERIC_SELECTION {
void* _THE_VOID_SLOT_;
};
GENCPP_NO_RESOLVED_GENERIC_SELECTION const gen_generic_selection_fail = {0};
// Which will provide the message: error: called object type 'struct NO_RESOLVED_GENERIC_SELECTION' is not a function or function pointer
// ----------------------------------------------------------------------------------------------------------------------------------
// Below are generated on demand for an overlaod depdendent on a type:
// ----------------------------------------------------------------------------------------------------------------------------------
#define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg ) _Generic( \
(selector_arg), /* Select Via Expression*/ \
/* Extendibility slots: */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
default: gen_generic_selection_fail \
) GEN_RESOLVED_FUNCTION_CALL( selector_arg )
// ----------------------------------------------------------------------------------------------------------------------------------
// Then each definiton of a function has an associated define:
#// #define GENERIC_SLOT_<#>_<generic identifier> <typename>, <function_to_resolve>
// Then somehwere later on
// <etc> <return_type> <function_id> ( <arguments> ) { <implementation> }
// Concrete example:
// To add support for long:
#define GENERIC_SLOT_1_gen_example_hash long, gen_example_hash__P_long
size_t gen_example_hash__P_long( long val ) { return val * 2654435761ull; }
// To add support for long long:
#define GENERIC_SLOT_2_gen_example_hash long long, gen_example_hash__P_long_long
size_t gen_example_hash__P_long_long( long long val ) { return val * 2654435761ull; }
// If using an Editor with support for syntax hightlighting macros: HASH__ARGS_SIG_1 and HASH_ARGS_SIG_2 should show color highlighting indicating the slot is enabled,
// or, "defined" for usage during the compilation pass that handles the _Generic instrinsic.
#define gen_hash_example( function_arguments ) _Generic( \
(function_arguments), /* Select Via Expression*/ \
/* Extendibility slots: */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_2 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_3 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_4 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_5 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_6 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_7 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_8 ) \
default: gen_generic_selection_fail \
) GEN_RESOLVED_FUNCTION_CALL( function_arguments )
// Additional Variations:
// If the function takes more than one argument the following is used:
#define GEN_FUNCTION_GENERIC_EXAMPLE_VARADIC( selector_arg, ... ) _Generic( \
(selector_arg), \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_2 ) \
/* ... */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT(FunctionID__ARGS_SIG_N ) \
default: gen_generic_selection_fail \
) GEN_RESOLVED_FUNCTION_CALL( selector_arg, __VA_ARG__ )
// If the function does not take the arugment as a parameter:
#define GEN_FUNCTION_GENERIC_EXAMPLE_DIRECT_TYPE( selector_arg ) _Generic( \
( GEN_TYPE_TO_EXP(selector_arg) ), \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_2 ) \
/* ... */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT(FunctionID__ARGS_SIG_N ) \
default: gen_generic_selection_fail \
) GEN_RESOLVED_FUNCTION_CALL()
// Used to keep the _Generic keyword happy as bare types are not considered "expressions"
#define GEN_TYPE_TO_EXP(type) (* (type*)NULL)
// Instead of using this macro, you'll see it directly expanded by the code generation.
// typedef void* GEN_GenericExampleType;
// GEN_FUNCTION_GENERIC_EXAMPLE_DIRECT_TYPE( GEN_GenericExampleType );
#pragma endregion _Generic Macros

9
gen_c_library/components/header_seg_includes.h Normal file
View File

@ -0,0 +1,9 @@
#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
# error Gen.h : GEN_TIME not defined
#endif
//! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
#ifndef GEN_ROLL_OWN_DEPENDENCIES
# include "gen.dep.h"
#endif

24
gen_c_library/components/header_start.hpp Normal file
View File

@ -0,0 +1,24 @@
/*
gencpp: An attempt at "simple" staged metaprogramming for c/c++.
See Readme.md for more information from the project repository.
Public Address:
https://github.com/Ed94/gencpp ---------------------------------------------------------------.
| _____ _____ _ _ ___ __ __ |
| / ____) / ____} | | | / ,__} / | / | |
| | / ___ ___ _ __ ___ _ __ _ __ | {___ | l_ __ _ __ _, ___ __| | | | '-l | '-l | |
| | |{_ \/ __\ '_ \ / __} '_ l| '_ l \___ \| __/ _` |/ _` |/ __\/ _` | | | | | | | |
| | l__j | ___/ | | | {__; ;_l } ;_l } ____} | l| (_} | {_| | ___j {_; | | l___ _J l_ _J l_ |
| \_____|\___}_l |_|\___} .__/| .__/ {_____/ \__\__/_l\__. |\___/\__,_l \____}{_____}{_____} |
| | | | | __} | |
| l_l l_l {___/ |
! ----------------------------------------------------------------------- VERSION: v0.20-Alpha |
! ============================================================================================= |
! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION |
! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL |
! ============================================================================================= /
*/
#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
# error Gen.hpp : GEN_TIME not defined
#endif

151
gen_c_library/components/memory.fixed_arena.hpp Normal file
View File

@ -0,0 +1,151 @@
#pragma once
#include "gen.hpp"
using namespace gen;
CodeBody gen_fixed_arenas()
{
CodeBody result = def_body(CT_Global_Body);
result.append(def_pragma(txt("region FixedArena")));
char const* template_struct = stringize(
struct FixedArena_<Name>
{
char memory[<Size>];
Arena arena;
};
typedef struct FixedArena_<Name> FixedArena_<Name>;
);
char const* template_interface = stringize(
inline
void fixed_arena_init_<Name>(FixedArena_<Name>* result)
{
result->arena = arena_init_from_memory(& result->memory[0], <Size>);
}
inline
ssize fixed_arena_size_remaining_<Name>(FixedArena_<Name>* fixed_arena, ssize alignment)
{
return arena_size_remaining( & fixed_arena->arena, alignment);
}
inline
void fixed_arena_free_<Name>(FixedArena_<Name>* fixed_arena) {
arena_free( & fixed_arena->arena);
}
);
CodeBody arena_struct_1kb = parse_global_body( token_fmt_impl( 3, "Name", txt("1KB"), "Size", txt("kilobytes(1)"), template_struct ));
CodeBody arena_struct_4kb = parse_global_body( token_fmt_impl( 3, "Name", txt("4KB"), "Size", txt("kilobytes(4)"), template_struct ));
CodeBody arena_struct_8kb = parse_global_body( token_fmt_impl( 3, "Name", txt("8KB"), "Size", txt("kilobytes(8)"), template_struct ));
CodeBody arena_struct_16kb = parse_global_body( token_fmt_impl( 3, "Name", txt("16KB"), "Size", txt("kilobytes(16)"), template_struct ));
CodeBody arena_struct_32kb = parse_global_body( token_fmt_impl( 3, "Name", txt("32KB"), "Size", txt("kilobytes(32)"), template_struct ));
CodeBody arena_struct_64kb = parse_global_body( token_fmt_impl( 3, "Name", txt("64KB"), "Size", txt("kilobytes(64)"), template_struct ));
CodeBody arena_struct_128kb = parse_global_body( token_fmt_impl( 3, "Name", txt("128KB"), "Size", txt("kilobytes(128)"), template_struct ));
CodeBody arena_struct_256kb = parse_global_body( token_fmt_impl( 3, "Name", txt("256KB"), "Size", txt("kilobytes(256)"), template_struct ));
CodeBody arena_struct_512kb = parse_global_body( token_fmt_impl( 3, "Name", txt("512KB"), "Size", txt("kilobytes(512)"), template_struct ));
CodeBody arena_struct_1mb = parse_global_body( token_fmt_impl( 3, "Name", txt("1MB"), "Size", txt("megabytes(1)"), template_struct ));
CodeBody arena_struct_2mb = parse_global_body( token_fmt_impl( 3, "Name", txt("2MB"), "Size", txt("megabytes(2)"), template_struct ));
CodeBody arena_struct_4mb = parse_global_body( token_fmt_impl( 3, "Name", txt("4MB"), "Size", txt("megabytes(4)"), template_struct ));
CodeBody arena_interface_1kb = parse_global_body( token_fmt_impl( 3, "Name", txt("1KB"), "Size", txt("kilobytes(1)"), template_interface ));
CodeBody arena_interface_4kb = parse_global_body( token_fmt_impl( 3, "Name", txt("4KB"), "Size", txt("kilobytes(4)"), template_interface ));
CodeBody arena_interface_8kb = parse_global_body( token_fmt_impl( 3, "Name", txt("8KB"), "Size", txt("kilobytes(8)"), template_interface ));
CodeBody arena_interface_16kb = parse_global_body( token_fmt_impl( 3, "Name", txt("16KB"), "Size", txt("kilobytes(16)"), template_interface ));
CodeBody arena_interface_32kb = parse_global_body( token_fmt_impl( 3, "Name", txt("32KB"), "Size", txt("kilobytes(32)"), template_interface ));
CodeBody arena_interface_64kb = parse_global_body( token_fmt_impl( 3, "Name", txt("64KB"), "Size", txt("kilobytes(64)"), template_interface ));
CodeBody arena_interface_128kb = parse_global_body( token_fmt_impl( 3, "Name", txt("128KB"), "Size", txt("kilobytes(128)"), template_interface ));
CodeBody arena_interface_256kb = parse_global_body( token_fmt_impl( 3, "Name", txt("256KB"), "Size", txt("kilobytes(256)"), template_interface ));
CodeBody arena_interface_512kb = parse_global_body( token_fmt_impl( 3, "Name", txt("512KB"), "Size", txt("kilobytes(512)"), template_interface ));
CodeBody arena_interface_1mb = parse_global_body( token_fmt_impl( 3, "Name", txt("1MB"), "Size", txt("megabytes(1)"), template_interface ));
CodeBody arena_interface_2mb = parse_global_body( token_fmt_impl( 3, "Name", txt("2MB"), "Size", txt("megabytes(2)"), template_interface ));
CodeBody arena_interface_4mb = parse_global_body( token_fmt_impl( 3, "Name", txt("4MB"), "Size", txt("megabytes(4)"), template_interface ));
result.append(arena_struct_1kb);
result.append(arena_struct_4kb);
result.append(arena_struct_8kb);
result.append(arena_struct_16kb);
result.append(arena_struct_32kb);
result.append(arena_struct_64kb);
result.append(arena_struct_128kb);
result.append(arena_struct_256kb);
result.append(arena_struct_512kb);
result.append(arena_struct_1mb);
result.append(arena_struct_2mb);
result.append(arena_struct_4mb);
result.append(arena_interface_1kb);
result.append(arena_interface_4kb);
result.append(arena_interface_8kb);
result.append(arena_interface_16kb);
result.append(arena_interface_32kb);
result.append(arena_interface_64kb);
result.append(arena_interface_128kb);
result.append(arena_interface_256kb);
result.append(arena_interface_512kb);
result.append(arena_interface_1mb);
result.append(arena_interface_2mb);
result.append(arena_interface_4mb);
CodeDefine def = def_define(txt("fixed_arena_allocator_info(fixed_arena)"), txt("( (AllocatorInfo) { arena_allocator_proc, & (fixed_arena)->arena } )"));
result.append(def);
result.append(fmt_newline);
result.append(parse_global_body(txt(R"(
#define fixed_arena_init(expr) _Generic((expr), \
FixedArena_1KB* : fixed_arena_init_1KB, \
FixedArena_4KB* : fixed_arena_init_4KB, \
FixedArena_8KB* : fixed_arena_init_8KB, \
FixedArena_16KB* : fixed_arena_init_16KB, \
FixedArena_32KB* : fixed_arena_init_32KB, \
FixedArena_64KB* : fixed_arena_init_64KB, \
FixedArena_128KB* : fixed_arena_init_128KB, \
FixedArena_256KB* : fixed_arena_init_256KB, \
FixedArena_512KB* : fixed_arena_init_512KB, \
FixedArena_1MB* : fixed_arena_init_1MB, \
FixedArena_2MB* : fixed_arena_init_2MB, \
FixedArena_4MB* : fixed_arena_init_4MB, \
default : gen_generic_selection_fail \
) GEN_RESOLVED_FUNCTION_CALL(expr)
#define fixed_arena_free(expr) _Generic((expr), \
FixedArena_1KB* : fixed_arena_free_1KB, \
FixedArena_4KB* : fixed_arena_free_4KB, \
FixedArena_8KB* : fixed_arena_free_8KB, \
FixedArena_16KB* : fixed_arena_free_16KB, \
FixedArena_32KB* : fixed_arena_free_32KB, \
FixedArena_64KB* : fixed_arena_free_64KB, \
FixedArena_128KB* : fixed_arena_free_128KB, \
FixedArena_256KB* : fixed_arena_free_256KB, \
FixedArena_512KB* : fixed_arena_free_512KB, \
FixedArena_1MB* : fixed_arena_free_1MB, \
FixedArena_2MB* : fixed_arena_free_2MB, \
FixedArena_4MB* : fixed_arena_free_4MB, \
default : gen_generic_selection_fail \
) GEN_RESOLVED_FUNCTION_CALL(expr)
#define fixed_arena_size_remaining(expr, alignment) _Generic((expr), \
FixedArena_1KB* : fixed_arena_size_remaining_1KB, \
FixedArena_4KB* : fixed_arena_size_remaining_4KB, \
FixedArena_8KB* : fixed_arena_size_remaining_8KB, \
FixedArena_16KB* : fixed_arena_size_remaining_16KB, \
FixedArena_32KB* : fixed_arena_size_remaining_32KB, \
FixedArena_64KB* : fixed_arena_size_remaining_64KB, \
FixedArena_128KB* : fixed_arena_size_remaining_128KB, \
FixedArena_256KB* : fixed_arena_size_remaining_256KB, \
FixedArena_512KB* : fixed_arena_size_remaining_512KB, \
FixedArena_1MB* : fixed_arena_size_remaining_1MB, \
FixedArena_2MB* : fixed_arena_size_remaining_2MB, \
FixedArena_4MB* : fixed_arena_size_remaining_4MB, \
default : gen_generic_selection_fail \
) GEN_RESOLVED_FUNCTION_CALL(expr, alignment)
)"
)));
result.append(fmt_newline);
result.append(def_pragma(txt("endregion FixedArena")));
return result;
}

255
gen_c_library/components/misc.hpp Normal file
View File

@ -0,0 +1,255 @@
#pragma once
#include "gen.hpp"
using namespace gen;
void convert_cpp_enum_to_c( CodeEnum to_convert, CodeBody to_append )
{
#pragma push_macro("enum_underlying")
#undef enum_underlying
if (to_convert->UnderlyingType)
{
to_convert->UnderlyingTypeMacro = untyped_str(token_fmt("type", to_convert->UnderlyingType->Name, stringize(enum_underlying(<type>))));
to_convert->UnderlyingType = CodeTypename{nullptr};
}
CodeTypedef tdef = parse_typedef(token_fmt("name", to_convert->Name, stringize( typedef enum <name> <name>; )));
to_append.append(to_convert);
to_append.append(tdef);
#pragma pop_macro("enum_underlying")
}
b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& parsed_body, CodeBody& body )
{
b32 found = false;
CodePreprocessCond cond = cast(CodePreprocessCond, entry_iter);
if ( cond->Content.is_equal(cond_sig) )
{
//log_fmt("Preprocess cond found: %SC\n", cond->Content);
found = true;
s32 depth = 1;
++ entry_iter;
for(b32 continue_for = true; continue_for && entry_iter != parsed_body.end(); ) switch
(entry_iter->Type) {
case CT_Preprocess_If:
case CT_Preprocess_IfDef:
case CT_Preprocess_IfNotDef:
++ depth;
++ entry_iter;
break;
case CT_Preprocess_Else:
++ entry_iter;
for(; continue_for && entry_iter != parsed_body.end(); ++ entry_iter)
{
if (entry_iter->Type == CT_Preprocess_EndIf)
{
continue_for = false;
break;
}
body.append(entry_iter);
}
break;
case CT_Preprocess_EndIf:
{
depth --;
if (depth == 0) {
continue_for = false;
break;
}
++ entry_iter;
}
break;
default:
++ entry_iter;
break;
}
}
return found;
}
constexpr bool GenericSel_One_Arg = true;
enum GenericSelectionOpts : u32 { GenericSel_Default, GenericSel_By_Ref, GenericSel_Direct_Type };
Code gen_generic_selection_function_macro( s32 num_slots, StrC macro_name, GenericSelectionOpts opts = GenericSel_Default, bool one_arg = false )
{
/* Implements:
#define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg, ... ) _Generic( \
(selector_arg), \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_2 ) \
... \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT_LAST(FunctionID__ARGS_SIG_N ) \
) GEN_RESOLVED_FUNCTION_CALL( selector_arg )
*/
local_persist
String define_builder = String::make_reserve(GlobalAllocator, kilobytes(64));
define_builder.clear();
StrC macro_begin;
if (opts == GenericSel_Direct_Type) {
macro_begin = token_fmt( "macro_name", (StrC)macro_name,
R"(#define <macro_name>(selector_arg, ...) _Generic( (*(selector_arg*)NULL ), \
)"
);
}
else {
macro_begin = token_fmt( "macro_name", (StrC)macro_name,
R"(#define <macro_name>(selector_arg, ...) _Generic( (selector_arg), \
)"
);
}
define_builder.append(macro_begin);
for ( s32 slot = 1; slot <= num_slots; ++ slot )
{
StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", slot).to_strc();
if (slot == num_slots && false)
{
define_builder.append( token_fmt( "macro_name", macro_name, "slot", slot_str,
R"( GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT_LAST( GENERIC_SLOT_<slot>__<macro_name> ) \
)"
));
// if ( one_arg )
// define_builder.append(token_fmt( "macro_name", macro_name, stringize(
// default: static_assert(false, "<macro_name>: Failed to select correct function signature (Did you pass the type?)")
// )));
// else
// define_builder.append(token_fmt( "macro_name", macro_name, stringize(
// default: static_assert(false, "<macro_name>: Failed to select correct function signature")
// )));
continue;
}
define_builder.append( token_fmt( "macro_name", macro_name, "slot", slot_str,
R"( GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_<slot>__<macro_name> ) \
)"
));
}
define_builder.append( txt("default: gen_generic_selection_fail") );
if ( ! one_arg )
{
if (opts == GenericSel_By_Ref)
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( & selector_arg, __VA_ARGS__ )"));
else if (opts == GenericSel_Direct_Type)
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( __VA_ARGS__ )"));
else
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( selector_arg, __VA_ARGS__ )"));
}
else
{
if (opts == GenericSel_By_Ref)
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( & selector_arg )"));
else if (opts == GenericSel_Direct_Type)
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL()"));
else
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( selector_arg )"));
}
// Add gap for next definition
define_builder.append(txt("\n\n"));
Code macro = untyped_str(define_builder.to_strc());
return macro;
}
CodeFn rename_function_to_unique_symbol(CodeFn fn, StrC optional_prefix = txt(""))
{
// Get basic components for the name
StrC old_name = fn->Name;
String new_name;
// Add prefix if provided
if (optional_prefix.Len)
new_name = string_fmt_buf(GlobalAllocator, "%SC_%SC_", optional_prefix, old_name);
else
new_name = string_fmt_buf(GlobalAllocator, "%SC_", old_name);
// Add return type to the signature
if (fn->ReturnType)
new_name.append_fmt("_%SC", fn->ReturnType->Name);
// Add parameter types to create a unique signature
bool first_param = true;
for (CodeParams param = fn->Params; param.ast; param = param->Next)
{
if (param->ValueType)
{
// Add separator for readability
if (first_param)
{
new_name.append("_P_");
first_param = false;
}
else
new_name.append("_");
// Add parameter type, handle any specifiers
if (param->ValueType->Specs && param->ValueType->Specs->NumEntries > 0)
{
// Add specifiers (const, volatile, etc)
for (Specifier spec : param->ValueType->Specs)
{
if (spec == Spec_Ptr) {
new_name.append("ptr_");
continue;
}
new_name.append_fmt("%SC_", spec_to_str(spec));
}
}
new_name.append_fmt("%SC", param->ValueType->Name);
}
}
// Handle function specifiers if present
if (fn->Specs && fn->Specs->NumEntries > 0)
{
new_name.append("_S_");
for (Specifier* spec = begin(fn->Specs);
spec != end(fn->Specs);
++spec)
{
new_name.append_fmt("%SC_", spec_to_str(*spec));
}
}
fn->Name = new_name;
return fn;
}
using SwapContentProc = CodeBody(void);
bool swap_pragma_region_implementation( StrC region_name, SwapContentProc* swap_content, Code& entry_iter, CodeBody& body )
{
bool found = false;
CodePragma possible_region = cast(CodePragma, entry_iter);
String region_sig = string_fmt_buf(GlobalAllocator, "region %s", region_name.Ptr);
String endregion_sig = string_fmt_buf(GlobalAllocator, "endregion %s", region_name.Ptr);
if ( possible_region->Content.contains(region_sig))
{
found = true;
// body.append(possible_region);
body.append(swap_content());
++ entry_iter;
for(b32 continue_for = true; continue_for; ++entry_iter) switch
(entry_iter->Type) {
case CT_Preprocess_Pragma:
{
CodePragma possible_end_region = cast(CodePragma, entry_iter);
if ( possible_end_region->Content.contains(endregion_sig) ) {
// body.append(possible_end_region);
continue_for = false;
}
}
break;
}
body.append(entry_iter);
}
return found;
}

11
gen_c_library/components/src_start.c Normal file
View File

@ -0,0 +1,11 @@
#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
# error Gen.hpp : GEN_TIME not defined
#endif
#include "gen.h"
//! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
//! Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
#ifndef GEN_ROLL_OWN_DEPENDENCIES
# include "gen.dep.c"
#endif

8
gen_c_library/gen.c Normal file
View File

@ -0,0 +1,8 @@
#define GEN_IMPLEMENTATION
#include "gen/gen.c"
int main()
{
// init();
__debugbreak();
}

21
gen_segmented/Readme.md Normal file
View File

@ -0,0 +1,21 @@
## Navigation
# base
[Top](../Readme.md)
* [docs](../docs/Readme.md)
# Segemented Library Generation
The principal (user) files are `gen.hpp` and `gen.cpp`.
They contain includes for its various components: `components/<component_name>.<hpp/cpp>`
Dependencies are bundled into `gen.dep.<hpp/cpp>`. They are included in `gen.<hpp/cpp>` before component includes.
Just like the `gen.<hpp/cpp>` they include their components: `dependencies/<dependency_name>.<hpp/cpp>`
If using the library's provided build scripts:
```ps1
.\build.ps1 <compiler> <debug or omit> segmented
```

287
gen_segmented/segmented.cpp Normal file
View File

@ -0,0 +1,287 @@
// Includes are exposed to base directory
#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
#define GEN_ENFORCE_STRONG_CODE_TYPES
#define GEN_EXPOSE_BACKEND
#define GEN_C_LIKE_CPP 1
#include "gen.cpp"
#include "helpers/push_ignores.inline.hpp"
#include <stdlib.h>
GEN_NS_BEGIN
#include "helpers/base_codegen.hpp"
#include "helpers/misc.hpp"
GEN_NS_END
using namespace gen;
constexpr char const* generation_notice =
"// This file was generated automatially by gencpp's bootstrap.cpp "
"(See: https://github.com/Ed94/gencpp)\n\n";
#include <cstdlib> // for system()
#define path_format_style "../scripts/.clang-format "
#define scratch_file "gen/scratch.hpp"
#define path_base "../base/"
Code format( Code code ) {
return code_refactor_and_format(code, scratch_file, nullptr, path_format_style );
}
int gen_main()
{
gen::init();
Code push_ignores = scan_file( (path_base "helpers/push_ignores.inline.hpp") );
Code pop_ignores = scan_file( (path_base "helpers/pop_ignores.inline.hpp") );
// gen_dep.hpp
{
Code platform = scan_file( path_base "dependencies/platform.hpp" );
Code macros = scan_file( path_base "dependencies/macros.hpp" );
Code basic_types = scan_file( path_base "dependencies/basic_types.hpp" );
Code debug = scan_file( path_base "dependencies/debug.hpp" );
Code memory = scan_file( path_base "dependencies/memory.hpp" );
Code string_ops = scan_file( path_base "dependencies/string_ops.hpp" );
Code printing = scan_file( path_base "dependencies/printing.hpp" );
Code containers = scan_file( path_base "dependencies/containers.hpp" );
Code hashing = scan_file( path_base "dependencies/hashing.hpp" );
Code strings = scan_file( path_base "dependencies/strings.hpp" );
Code filesystem = scan_file( path_base "dependencies/filesystem.hpp" );
Code timing = scan_file( path_base "dependencies/timing.hpp" );
Code parsing = scan_file( path_base "dependencies/parsing.hpp" );
Builder _header = builder_open( "gen/gen.dep.hpp");
Builder* header = & _header;
builder_print_fmt( header, generation_notice );
builder_print_fmt( header, "// This file is intended to be included within gen.hpp (There is no pragma diagnostic ignores)\n" );
builder_print( header, platform );
builder_print_fmt( header, "\nGEN_NS_BEGIN\n" );
builder_print( header, macros );
builder_print( header, basic_types );
builder_print( header, debug );
builder_print( header, memory );
builder_print( header, string_ops );
builder_print( header, printing );
builder_print( header, containers );
builder_print( header, hashing );
builder_print( header, strings );
builder_print( header, filesystem );
builder_print( header, timing );
builder_print( header, parsing );
builder_print_fmt( header, "\nGEN_NS_END\n" );
builder_write(header);
}
// gen_dep.cpp
{
Code src_start = scan_file( path_base "dependencies/src_start.cpp" );
Code debug = scan_file( path_base "dependencies/debug.cpp" );
Code string_ops = scan_file( path_base "dependencies/string_ops.cpp" );
Code printing = scan_file( path_base "dependencies/printing.cpp" );
Code memory = scan_file( path_base "dependencies/memory.cpp" );
Code hashing = scan_file( path_base "dependencies/hashing.cpp" );
Code strings = scan_file( path_base "dependencies/strings.cpp" );
Code filesystem = scan_file( path_base "dependencies/filesystem.cpp" );
Code timing = scan_file( path_base "dependencies/timing.cpp" );
Code parsing = scan_file( path_base "dependencies/parsing.cpp" );
Builder _src = builder_open( "gen/gen.dep.cpp" );
Builder* src = & _src;
builder_print_fmt(src, generation_notice );
builder_print_fmt( src, "// This file is intended to be included within gen.cpp (There is no pragma diagnostic ignores)\n" );
builder_print( src, src_start );
builder_print_fmt( src, "\nGEN_NS_BEGIN\n" );
builder_print( src, debug );
builder_print( src, string_ops );
builder_print( src, printing );
builder_print( src, hashing );
builder_print( src, memory );
builder_print( src, strings );
builder_print( src, filesystem );
builder_print( src, timing );
builder_print( src, parsing );
builder_print_fmt( src, "\nGEN_NS_END\n" );
builder_write(src);
}
CodeBody gen_component_header = def_global_body( args(
def_preprocess_cond( PreprocessCond_IfDef, txt("GEN_INTELLISENSE_DIRECTIVES") ),
pragma_once,
def_include(txt("components/types.hpp")),
preprocess_endif,
fmt_newline,
untyped_str( to_strc_from_c_str(generation_notice) )
));
// gen.hpp
{
Code header_start = scan_file( path_base "components/header_start.hpp" );
Code types = scan_file( path_base "components/types.hpp" );
Code ast = scan_file( path_base "components/ast.hpp" );
Code ast_types = scan_file( path_base "components/ast_types.hpp" );
Code code_types = scan_file( path_base "components/code_types.hpp" );
Code interface = scan_file( path_base "components/interface.hpp" );
Code inlines = scan_file( path_base "components/inlines.hpp" );
Code header_end = scan_file( path_base "components/header_end.hpp" );
CodeBody ecode = gen_ecode ( path_base "enums/ECodeTypes.csv" );
CodeBody eoperator = gen_eoperator ( path_base "enums/EOperator.csv" );
CodeBody especifier = gen_especifier( path_base "enums/ESpecifier.csv" );
CodeBody ast_inlines = gen_ast_inlines();
Builder _header = builder_open( "gen/gen.hpp" );
Builder* header = & _header;
builder_print_fmt( header, generation_notice );
builder_print_fmt( header, "#pragma once\n\n" );
builder_print( header, push_ignores );
builder_print( header, header_start );
builder_print_fmt( header, "\nGEN_NS_BEGIN\n\n" );
builder_print_fmt(header, "#pragma region Types\n" );
builder_print( header, types );
builder_print( header, fmt_newline);
builder_print( header, format(ecode) );
builder_print( header, fmt_newline);
builder_print( header, format(eoperator) );
builder_print( header, fmt_newline);
builder_print( header, format(especifier) );
builder_print( header, fmt_newline);
builder_print_fmt( header, "#pragma endregion Types\n\n" );
builder_print_fmt( header, "#pragma region AST\n" );
builder_print( header, ast );
builder_print( header, code_types );
builder_print( header, ast_types );
builder_print_fmt( header, "\n#pragma endregion AST\n" );
builder_print( header, interface );
builder_print_fmt( header, "\n#pragma region Inlines\n" );
builder_print( header, inlines );
builder_print( header, fmt_newline );
builder_print( header, format(ast_inlines) );
builder_print( header, fmt_newline );
builder_print_fmt( header, "#pragma endregion Inlines\n" );
builder_print( header, header_end );
builder_print_fmt( header, "GEN_NS_END\n\n" );
builder_print( header, pop_ignores );
builder_write(header);
}
// gen.cpp
{
Code src_start = scan_file( path_base "components/src_start.cpp" );
Code static_data = scan_file( path_base "components/static_data.cpp" );
Code ast_case_macros = scan_file( path_base "components/ast_case_macros.cpp" );
Code ast = scan_file( path_base "components/ast.cpp" );
Code code_serialization = scan_file( path_base "components/code_serialization.cpp" );
Code interface = scan_file( path_base "components/interface.cpp" );
Code upfront = scan_file( path_base "components/interface.upfront.cpp" );
Code lexer = scan_file( path_base "components/lexer.cpp" );
Code parser = scan_file( path_base "components/parser.cpp" );
Code parsing_interface = scan_file( path_base "components/interface.parsing.cpp" );
Code untyped = scan_file( path_base "components/interface.untyped.cpp" );
CodeBody etoktype = gen_etoktype( path_base "enums/ETokType.csv", path_base "enums/AttributeTokens.csv" );
CodeBody nspaced_etoktype = def_global_body( args(
etoktype
));
Code formatted_toktype = format(nspaced_etoktype);
Builder _src = builder_open( "gen/gen.cpp" );
Builder* src = & _src;
builder_print_fmt( src, generation_notice );
builder_print( src, push_ignores );
builder_print( src, src_start );
builder_print_fmt( src, "\nGEN_NS_BEGIN\n");
builder_print( src, static_data );
builder_print_fmt( src, "\n#pragma region AST\n\n" );
builder_print( src, ast_case_macros );
builder_print( src, ast );
builder_print( src, code_serialization );
builder_print_fmt( src, "\n#pragma endregion AST\n" );
builder_print_fmt( src, "\n#pragma region Interface\n" );
builder_print( src, interface );
builder_print( src, upfront );
builder_print_fmt( src, "\n#pragma region Parsing\n\n" );
builder_print( src, formatted_toktype );
builder_print( src, lexer );
builder_print( src, parser );
builder_print( src, parsing_interface );
builder_print_fmt( src, "\n#pragma endregion Parsing\n\n" );
builder_print( src, untyped );
builder_print_fmt( src, "#pragma endregion Interface\n\n" );
builder_print_fmt( src, "GEN_NS_END\n\n");
builder_print( src, pop_ignores );
builder_write(src);
}
// gen_builder.hpp
{
Code builder = scan_file( path_base "auxillary/builder.hpp" );
Builder header = builder_open( "gen/gen.builder.hpp" );
builder_print_fmt( & header, generation_notice );
builder_print_fmt( & header, "#pragma once\n\n" );
builder_print( & header, def_include( txt("gen.hpp") ));
builder_print_fmt( & header, "\nGEN_NS_BEGIN\n" );
builder_print( & header, builder );
builder_print_fmt( & header, "GEN_NS_END\n" );
builder_write( & header);
}
// gen_builder.cpp
{
Code builder = scan_file( path_base "auxillary/builder.cpp" );
Builder src = builder_open( "gen/gen.builder.cpp" );
builder_print_fmt( & src, generation_notice );
builder_print( & src, def_include( txt("gen.builder.hpp") ) );
builder_print_fmt( & src, "\nGEN_NS_BEGIN\n" );
builder_print( & src, builder );
builder_print_fmt( & src, "\nGEN_NS_END\n" );
builder_write( & src);
}
// gen_scanner.hpp
{
Code scanner = scan_file( path_base "auxillary/scanner.hpp" );
Builder header = builder_open( "gen/gen.scanner.hpp" );
builder_print_fmt( & header, generation_notice );
builder_print_fmt( & header, "#pragma once\n\n" );
builder_print( & header, def_include( txt("gen.hpp") ) );
builder_print_fmt( & header, "\nGEN_NS_BEGIN\n" );
builder_print( & header, scanner );
builder_print_fmt( & header, "\nGEN_NS_END\n" );
builder_write(& header);
}
// gen_scanner.cpp
{
Code scanner = scan_file( path_base "auxillary/scanner.cpp" );
Builder src = builder_open( "gen/gen.scanner.cpp" );
builder_print_fmt( & src, generation_notice );
builder_print( & src, def_include( txt("gen.scanner.hpp") ) );
builder_print_fmt( & src, "\nGEN_NS_BEGIN\n" );
builder_print( & src, scanner );
builder_print_fmt( & src, "GEN_NS_END\n" );
builder_write( & src);
}
gen::deinit();
return 0;
}

Some files were not shown because too many files have changed in this diff Show More