ed/gencpp
1
0
Fork 0
mirror of https://github.com/Ed94/gencpp.git synced 2025-07-06 05:35:43 -07:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: ed:v0.23-Alpha
Branches Tags
ed:main ed:dev ed:Ed94-patch-1 ed:defines_n_macros_upgrades ed:string_distinctings_refactor ed:de_oop ed:broken_changes ed:preprocessor_support ed:parser_context_stack ed:designchanges_to_bettercodetypes
ed:v0.25-Alpha ed:v0.24-Alpha ed:v0.23-Alpha ed:v0.22-Alpha ed:v0.21-Alpha ed:v0.20-Alpha ed:v0.19-Alpha ed:v0.18-Alpha ed:v0.17-Alpha ed:v0.16-Alpha ed:v0.15-Alpha ed:v0.14-Alpha ed:v0.13-Alpha ed:v0.12-Alpha ed:v0.11-Alpha ed:v0.10-Alpha ed:v0.9-Alpha ed:v0.8-Alpha ed:v0.7-Alpha ed:v0.6-Alpha ed:v0.5-alpha ed:v0.4-Alpha ed:V0.3-Alpha ed:V0.1-Alpha ed:V0.2-Alpha
...
compare: ed:62b36ec8bbfe641997dbf91bc3365cb5feeefd98
Branches Tags
ed:dev ed:main ed:Ed94-patch-1 ed:defines_n_macros_upgrades ed:string_distinctings_refactor ed:de_oop ed:broken_changes ed:preprocessor_support ed:parser_context_stack ed:designchanges_to_bettercodetypes
ed:v0.25-Alpha ed:v0.24-Alpha ed:v0.23-Alpha ed:v0.22-Alpha ed:v0.21-Alpha ed:v0.20-Alpha ed:v0.19-Alpha ed:v0.18-Alpha ed:v0.17-Alpha ed:v0.16-Alpha ed:v0.15-Alpha ed:v0.14-Alpha ed:v0.13-Alpha ed:v0.12-Alpha ed:v0.11-Alpha ed:v0.10-Alpha ed:v0.9-Alpha ed:v0.8-Alpha ed:v0.7-Alpha ed:v0.6-Alpha ed:v0.5-alpha ed:v0.4-Alpha ed:V0.3-Alpha ed:V0.1-Alpha ed:V0.2-Alpha

10 Commits
v0.23-Alph ... 62b36ec8bb

Author SHA1 Message Date
Ed_
62b36ec8bb misc changes to clang format spacing 2025-01-28 14:49:19 -05:00
Ed_
b6b246fb38 Added refactor.exe binary 2024-12-19 09:40:41 -05:00
Ed_
d91d3c6b6f typo in _Generic psuedo 2024-12-17 13:30:41 -05:00
Ed_
3ab2673fd3 gen_c_library doc update 2024-12-17 13:29:38 -05:00
Ed_
ca7ff99a79 Code type coercion for builder_print in C11 library using generic selector. 2024-12-17 10:03:50 -05:00
Ed_
177820cd6e remove .vscode 2024-12-16 22:24:18 -05:00
Ed_
d254d3aec4 removed custom attribute form gen_unreal_engine (mistake) 2024-12-16 22:00:56 -05:00
Ed_
299f1b1ef7 more proofing 2024-12-16 21:50:59 -05:00
Ed_
9c968967e2 Proofing 2024-12-16 21:48:01 -05:00
Ed_
04ae75c698 Update main readme (old example code) 2024-12-16 21:19:19 -05:00
47 changed files with 841 additions and 1048 deletions
Expand all files Collapse all files

5
.gitignore vendored
View File

@ -1,3 +1,4 @@
.vscode
.idea
**/build/*
@ -27,7 +28,7 @@ release/**
**/Unreal/*.h
**/Unreal/*.cpp
! **/Unreal/validate.unreal.cpp
project/auxillary/vis_ast/dependencies/temp
project/auxiliary/vis_ast/dependencies/temp
test/gen/original
singleheader/gen/scratch.hpp
test/gen/scratch.cpp
@ -41,3 +42,5 @@ gen_c_library/gen
**/*.vcxproj.user
test/c_library/gen
test/cpp_library/gen
!scripts/helpers/refactor.exe

99
.vscode/c_cpp_properties.json vendored
View File

@ -1,99 +0,0 @@
{
"configurations": [
{
"name": "Bootstrap",
"includePath": [
"${workspaceFolder}/base/**"
],
"defines": [
"_DEBUG",
"UNICODE",
"_UNICODE",
"GEN_TIME",
"GEN_IMPLEMENTATION",
// "GEN_DONT_USE_NAMESPACE"
"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}/.vscode/tasks.json",
"compilerArgs": [
"/EHsc-",
"/GR-",
"/Zc:preprocessor",
"/FC"
]
},
{
"name": "Win32 clang",
"includePath": [
"${workspaceFolder}/base/**"
],
"defines": [
"_DEBUG",
"UNICODE",
"_UNICODE",
"GEN_TIME",
"GEN_IMPLEMENTATION",
// "GEN_DONT_USE_NAMESPACE"
"GEN_INTELLISENSE_DIRECTIVES",
"INTELLISENSE_DIRECTIVES"
],
"cStandard": "c11",
"cppStandard": "c++17",
"windowsSdkVersion": "10.0.19041.0",
"compilerPath": "clang++.exe",
"intelliSenseMode": "windows-clang-x64",
"compileCommands": "${workspaceFolder}/.vscode/tasks.json"
},
{
"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"
],
"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}/.vscode/tasks.json"
},
{
"name": "Win32 msvc c_library test",
"includePath": [
"${workspaceFolder}/test/c_library/**",
"${workspaceFolder}/gen_c_library/gen/**"
],
"defines": [
"_DEBUG",
"UNICODE",
"_UNICODE",
"GEN_TIME",
"GEN_IMPLEMENTATION",
// "GEN_DONT_USE_NAMESPACE"
"GEN_INTELLISENSE_DIRECTIVES",
"INTELLISENSE_DIRECTIVES"
],
"cStandard": "c11",
"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"
}
],
"version": 4
}

35
.vscode/launch.json vendored
View File

@ -1,35 +0,0 @@
{
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"type": "cppvsdbg",
"request": "launch",
"name": "Debug base vsdbg",
"program": "${workspaceFolder}/base/build/base.exe",
"args": [],
"cwd": "${workspaceFolder}/base/",
"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
},
{
"type": "cppvsdbg",
"request": "launch",
"name": "Debug singleheader vsdbg",
"program": "${workspaceFolder}/singleheader/build/singleheader.exe",
"args": [],
"cwd": "${workspaceFolder}/singleheader/",
"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
},
{
"type": "cppvsdbg",
"request": "launch",
"name": "Debug unreal vsdbg",
"program": "${workspaceFolder}/unreal_engine/build/unreal.exe",
"args": [],
"cwd": "${workspaceFolder}/unreal_engine/",
"visualizerFile": "${workspaceFolder}/scripts/gencpp.natvis"
}
]
}

97
.vscode/settings.json vendored
View File

@ -1,97 +0,0 @@
{
"files.associations": {
"*.rmd": "markdown",
"array": "cpp",
"compare": "cpp",
"type_traits": "cpp",
"utility": "cpp",
"xtr1common": "cpp",
"xutility": "cpp",
"initializer_list": "cpp",
"table.h": "c",
"iterator": "cpp",
"memory": "cpp",
"exception": "cpp",
"optional": "cpp",
"tuple": "cpp",
"xmemory": "cpp",
"algorithm": "cpp",
"limits": "cpp",
"concepts": "cpp",
"*.rh": "cpp",
"chrono": "cpp",
"string": "cpp",
"filesystem": "cpp",
"format": "cpp",
"ratio": "cpp",
"xstring": "cpp",
"functional": "cpp",
"vector": "cpp",
"list": "cpp",
"xhash": "cpp",
"glfw3.h": "c",
"stdbool.h": "c",
"objbase.h": "c",
"mmreg.h": "c",
"mmsystem.h": "c",
"propidl.h": "c",
"android_native_app_glue.h": "c",
"raylib.h": "c",
"*.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",
"gen_singleheader.h": "c"
},
"C_Cpp.intelliSenseEngineFallback": "disabled",
"mesonbuild.configureOnOpen": true,
"C_Cpp.errorSquiggles": "disabled", // This doesn't work well with how the headers are included.
"godot_tools.scene_file_config": "",
"C_Cpp.default.compilerPath": "cl.exe",
"C_Cpp.exclusionPolicy": "checkFilesAndFolders",
"C_Cpp.files.exclude": {
"**/.vscode": true,
"**/.vs": true,
"**/sanity.gen.hpp": true,
"test/**":true,
},
"autoHide.autoHidePanel": false,
"autoHide.autoHideSideBar": false,
"dimmer.enabled": false,
"workbench.colorCustomizations": {
"activityBar.activeBackground": "#fa1b49",
"activityBar.background": "#fa1b49",
"activityBar.foreground": "#e7e7e7",
"activityBar.inactiveForeground": "#e7e7e799",
"activityBarBadge.background": "#155e02",
"activityBarBadge.foreground": "#e7e7e7",
"commandCenter.border": "#e7e7e799",
"sash.hoverBorder": "#fa1b49",
"statusBar.background": "#dd0531",
"statusBar.foreground": "#e7e7e7",
"statusBarItem.hoverBackground": "#fa1b49",
"statusBarItem.remoteBackground": "#dd0531",
"statusBarItem.remoteForeground": "#e7e7e7",
"titleBar.activeBackground": "#dd0531",
"titleBar.activeForeground": "#e7e7e7",
"titleBar.inactiveBackground": "#dd053199",
"titleBar.inactiveForeground": "#e7e7e799"
},
"peacock.color": "#dd0531"
}

144
.vscode/tasks.json vendored
View File

@ -1,144 +0,0 @@
{
"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
}
}
]
}

20
Readme.md
View File

@ -79,18 +79,18 @@ Example using each construction interface:
Validation and construction through a functional interface.
```cpp
Code t_uw = def_type( name(usize) );
Code t_allocator = def_type( name(allocator) );
Code t_string_const = def_type( name(char), def_specifiers( args( ESpecifier::Const, ESpecifier::Ptr ) ));
CodeTypename t_uw = def_type( name(usize) );
CodeTypename t_allocator = def_type( name(allocator) );
CodeTypename t_string_const = def_type( name(char), def_specifiers( args( ESpecifier::Const, ESpecifier::Ptr ) ));
Code header;
CodeStruct header;
{
Code num = def_variable( t_uw, name(Num) );
Code cap = def_variable( t_uw, name(Capacity) );
Code mem_alloc = def_variable( t_allocator, name(Allocator) );
Code body = def_struct_body( args( num, cap, mem_alloc ) );
CodeVar num = def_variable( t_uw, name(Num) );
CodeVar cap = def_variable( t_uw, name(Capacity) );
CodeVar mem_alloc = def_variable( t_allocator, name(Allocator) );
CodeBody body = def_struct_body( args( num, cap, mem_alloc ) );
header = def_struct( name(ArrayHeader), __, __, body );
header = def_struct( name(ArrayHeader), { body });
}
```
@ -99,7 +99,7 @@ Code header;
Validation through ast construction.
```cpp
Code header = parse_struct( code(
CodeStruct header = parse_struct( code(
struct ArrayHeader
{
usize Num;

12
base/Readme.md
View File

@ -24,16 +24,16 @@ If using the library's provided build scripts:
* `<push/pop>.<name>.inline.<hpp>`: macros that are meant to be injected at specific locations of the library file/s.
* `misc.hpp`: Misc functionality used by the library generation metaprograms.
* `undef.macros.h`: Undefines all macros from library.
* **auxillary**: Non-essential tooling:
* **auxiliary**: 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.
* **`Scanner`**: Interface to load up `Code` from files two basic functions 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 generated.
* **gen_unreal_engine**: Like gen_segmented 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 segmented and single-header set of variants are generated.
Code not making up the core library is located in `auxiliary/<auxiliary_name>.<hpp/cpp>`. These are optional extensions or tools for the library.
@ -108,7 +108,7 @@ Any large macros used implementing the gen interface or parser are going to be p
The vast majority of macros should be single-line subsitutions that either add:
* Improvements to searching
* Inteniality of keyword usage
* Intentionality 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).
@ -123,7 +123,7 @@ The vast majority of macros should be single-line subsitutions that either add:
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).
* [ecodetypes.hpp](./components/gen/ecode.hpp): `CodeType` enum definition and related implementation. 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:

0
base/auxillary/builder.cpp → base/auxiliary/builder.cpp
View File

0
base/auxillary/builder.hpp → base/auxiliary/builder.hpp
View File

0
base/auxillary/gen_template.hpp → base/auxiliary/gen_template.hpp
View File

0
base/auxillary/scanner.cpp → base/auxiliary/scanner.cpp
View File

0
base/auxillary/scanner.hpp → base/auxiliary/scanner.hpp
View File

2
base/components/ast.hpp
View File

@ -420,7 +420,7 @@ struct AST
Code Next;
Code Back;
};
Token* Token; // Reference to starting token, only avaialble if it was derived from parsing.
Token* Token; // Reference to starting token, only available if it was derived from parsing.
Code Parent;
CodeType Type;
// CodeFlag CodeFlags;

378
base/components/gen/ast_inlines.hpp
View File

@ -7,14 +7,14 @@
#pragma region generated code inline implementation
inline Code& Code::operator=( Code other )
inline Code& Code::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -23,14 +23,14 @@ inline Code::operator bool()
return ast != nullptr;
}
inline CodeBody& CodeBody::operator=( Code other )
inline CodeBody& CodeBody::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -39,14 +39,14 @@ inline CodeBody::operator bool()
return ast != nullptr;
}
inline CodeAttributes& CodeAttributes::operator=( Code other )
inline CodeAttributes& CodeAttributes::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -57,27 +57,27 @@ inline CodeAttributes::operator bool()
inline CodeAttributes::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Attributes* CodeAttributes::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeComment& CodeComment::operator=( Code other )
inline CodeComment& CodeComment::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -88,27 +88,27 @@ inline CodeComment::operator bool()
inline CodeComment::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Comment* CodeComment::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeConstructor& CodeConstructor::operator=( Code other )
inline CodeConstructor& CodeConstructor::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -119,27 +119,27 @@ inline CodeConstructor::operator bool()
inline CodeConstructor::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Constructor* CodeConstructor::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeClass& CodeClass::operator=( Code other )
inline CodeClass& CodeClass::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -148,14 +148,14 @@ inline CodeClass::operator bool()
return ast != nullptr;
}
inline CodeDefine& CodeDefine::operator=( Code other )
inline CodeDefine& CodeDefine::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -166,27 +166,27 @@ inline CodeDefine::operator bool()
inline CodeDefine::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Define* CodeDefine::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeDefineParams& CodeDefineParams::operator=( Code other )
inline CodeDefineParams& CodeDefineParams::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -195,14 +195,14 @@ inline CodeDefineParams::operator bool()
return ast != nullptr;
}
inline CodeDestructor& CodeDestructor::operator=( Code other )
inline CodeDestructor& CodeDestructor::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -213,27 +213,27 @@ inline CodeDestructor::operator bool()
inline CodeDestructor::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Destructor* CodeDestructor::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeEnum& CodeEnum::operator=( Code other )
inline CodeEnum& CodeEnum::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -244,27 +244,27 @@ inline CodeEnum::operator bool()
inline CodeEnum::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Enum* CodeEnum::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeExec& CodeExec::operator=( Code other )
inline CodeExec& CodeExec::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -275,27 +275,27 @@ inline CodeExec::operator bool()
inline CodeExec::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Exec* CodeExec::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeExtern& CodeExtern::operator=( Code other )
inline CodeExtern& CodeExtern::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -306,27 +306,27 @@ inline CodeExtern::operator bool()
inline CodeExtern::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Extern* CodeExtern::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeFriend& CodeFriend::operator=( Code other )
inline CodeFriend& CodeFriend::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -337,27 +337,27 @@ inline CodeFriend::operator bool()
inline CodeFriend::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Friend* CodeFriend::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeFn& CodeFn::operator=( Code other )
inline CodeFn& CodeFn::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -368,27 +368,27 @@ inline CodeFn::operator bool()
inline CodeFn::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Fn* CodeFn::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeInclude& CodeInclude::operator=( Code other )
inline CodeInclude& CodeInclude::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -399,27 +399,27 @@ inline CodeInclude::operator bool()
inline CodeInclude::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Include* CodeInclude::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeModule& CodeModule::operator=( Code other )
inline CodeModule& CodeModule::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -430,27 +430,27 @@ inline CodeModule::operator bool()
inline CodeModule::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Module* CodeModule::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeNS& CodeNS::operator=( Code other )
inline CodeNS& CodeNS::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -461,27 +461,27 @@ inline CodeNS::operator bool()
inline CodeNS::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_NS* CodeNS::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeOperator& CodeOperator::operator=( Code other )
inline CodeOperator& CodeOperator::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -492,27 +492,27 @@ inline CodeOperator::operator bool()
inline CodeOperator::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Operator* CodeOperator::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeOpCast& CodeOpCast::operator=( Code other )
inline CodeOpCast& CodeOpCast::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -523,27 +523,27 @@ inline CodeOpCast::operator bool()
inline CodeOpCast::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_OpCast* CodeOpCast::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeParams& CodeParams::operator=( Code other )
inline CodeParams& CodeParams::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -552,14 +552,14 @@ inline CodeParams::operator bool()
return ast != nullptr;
}
inline CodePragma& CodePragma::operator=( Code other )
inline CodePragma& CodePragma::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -570,27 +570,27 @@ inline CodePragma::operator bool()
inline CodePragma::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Pragma* CodePragma::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodePreprocessCond& CodePreprocessCond::operator=( Code other )
inline CodePreprocessCond& CodePreprocessCond::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -601,27 +601,27 @@ inline CodePreprocessCond::operator bool()
inline CodePreprocessCond::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_PreprocessCond* CodePreprocessCond::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeSpecifiers& CodeSpecifiers::operator=( Code other )
inline CodeSpecifiers& CodeSpecifiers::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -630,14 +630,14 @@ inline CodeSpecifiers::operator bool()
return ast != nullptr;
}
inline CodeStruct& CodeStruct::operator=( Code other )
inline CodeStruct& CodeStruct::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -646,14 +646,14 @@ inline CodeStruct::operator bool()
return ast != nullptr;
}
inline CodeTemplate& CodeTemplate::operator=( Code other )
inline CodeTemplate& CodeTemplate::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -664,27 +664,27 @@ inline CodeTemplate::operator bool()
inline CodeTemplate::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Template* CodeTemplate::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeTypename& CodeTypename::operator=( Code other )
inline CodeTypename& CodeTypename::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -695,27 +695,27 @@ inline CodeTypename::operator bool()
inline CodeTypename::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Typename* CodeTypename::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeTypedef& CodeTypedef::operator=( Code other )
inline CodeTypedef& CodeTypedef::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -726,27 +726,27 @@ inline CodeTypedef::operator bool()
inline CodeTypedef::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Typedef* CodeTypedef::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeUnion& CodeUnion::operator=( Code other )
inline CodeUnion& CodeUnion::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -757,27 +757,27 @@ inline CodeUnion::operator bool()
inline CodeUnion::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Union* CodeUnion::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeUsing& CodeUsing::operator=( Code other )
inline CodeUsing& CodeUsing::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -788,27 +788,27 @@ inline CodeUsing::operator bool()
inline CodeUsing::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Using* CodeUsing::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;
}
inline CodeVar& CodeVar::operator=( Code other )
inline CodeVar& CodeVar::operator=(Code other)
{
if ( other.ast != nullptr && other->Parent != nullptr )
if (other.ast != nullptr && other->Parent != nullptr)
{
ast = rcast( decltype( ast ), code_duplicate( other ).ast );
ast = rcast(decltype(ast), code_duplicate(other).ast);
ast->Parent = { nullptr };
}
ast = rcast( decltype( ast ), other.ast );
ast = rcast(decltype(ast), other.ast);
return *this;
}
@ -819,14 +819,14 @@ inline CodeVar::operator bool()
inline CodeVar::operator Code()
{
return *rcast( Code*, this );
return *rcast(Code*, this);
}
inline AST_Var* CodeVar::operator->()
{
if ( ast == nullptr )
if (ast == nullptr)
{
log_failure( "Attempt to dereference a nullptr!\n" );
log_failure("Attempt to dereference a nullptr!\n");
return nullptr;
}
return ast;

260
base/components/gen/ecodetypes.hpp
View File

@ -73,150 +73,150 @@ enum CodeType : u32
CT_UnderlyingType = GEN_U32_MAX
};
inline Str codetype_to_str( CodeType type )
inline Str codetype_to_str(CodeType type)
{
local_persist Str lookup[] = {
{ "Invalid", sizeof( "Invalid" ) - 1 },
{ "Untyped", sizeof( "Untyped" ) - 1 },
{ "NewLine", sizeof( "NewLine" ) - 1 },
{ "Comment", sizeof( "Comment" ) - 1 },
{ "Access_Private", sizeof( "Access_Private" ) - 1 },
{ "Access_Protected", sizeof( "Access_Protected" ) - 1 },
{ "Access_Public", sizeof( "Access_Public" ) - 1 },
{ "PlatformAttributes", sizeof( "PlatformAttributes" ) - 1 },
{ "Class", sizeof( "Class" ) - 1 },
{ "Class_Fwd", sizeof( "Class_Fwd" ) - 1 },
{ "Class_Body", sizeof( "Class_Body" ) - 1 },
{ "Constructor", sizeof( "Constructor" ) - 1 },
{ "Constructor_Fwd", sizeof( "Constructor_Fwd" ) - 1 },
{ "Destructor", sizeof( "Destructor" ) - 1 },
{ "Destructor_Fwd", sizeof( "Destructor_Fwd" ) - 1 },
{ "Enum", sizeof( "Enum" ) - 1 },
{ "Enum_Fwd", sizeof( "Enum_Fwd" ) - 1 },
{ "Enum_Body", sizeof( "Enum_Body" ) - 1 },
{ "Enum_Class", sizeof( "Enum_Class" ) - 1 },
{ "Enum_Class_Fwd", sizeof( "Enum_Class_Fwd" ) - 1 },
{ "Execution", sizeof( "Execution" ) - 1 },
{ "Export_Body", sizeof( "Export_Body" ) - 1 },
{ "Extern_Linkage", sizeof( "Extern_Linkage" ) - 1 },
{ "Extern_Linkage_Body", sizeof( "Extern_Linkage_Body" ) - 1 },
{ "Friend", sizeof( "Friend" ) - 1 },
{ "Function", sizeof( "Function" ) - 1 },
{ "Function_Fwd", sizeof( "Function_Fwd" ) - 1 },
{ "Function_Body", sizeof( "Function_Body" ) - 1 },
{ "Global_Body", sizeof( "Global_Body" ) - 1 },
{ "Module", sizeof( "Module" ) - 1 },
{ "Namespace", sizeof( "Namespace" ) - 1 },
{ "Namespace_Body", sizeof( "Namespace_Body" ) - 1 },
{ "Operator", sizeof( "Operator" ) - 1 },
{ "Operator_Fwd", sizeof( "Operator_Fwd" ) - 1 },
{ "Operator_Member", sizeof( "Operator_Member" ) - 1 },
{ "Operator_Member_Fwd", sizeof( "Operator_Member_Fwd" ) - 1 },
{ "Operator_Cast", sizeof( "Operator_Cast" ) - 1 },
{ "Operator_Cast_Fwd", sizeof( "Operator_Cast_Fwd" ) - 1 },
{ "Parameters", sizeof( "Parameters" ) - 1 },
{ "Parameters_Define", sizeof( "Parameters_Define" ) - 1 },
{ "Preprocess_Define", sizeof( "Preprocess_Define" ) - 1 },
{ "Preprocess_Include", sizeof( "Preprocess_Include" ) - 1 },
{ "Preprocess_If", sizeof( "Preprocess_If" ) - 1 },
{ "Preprocess_IfDef", sizeof( "Preprocess_IfDef" ) - 1 },
{ "Preprocess_IfNotDef", sizeof( "Preprocess_IfNotDef" ) - 1 },
{ "Preprocess_ElIf", sizeof( "Preprocess_ElIf" ) - 1 },
{ "Preprocess_Else", sizeof( "Preprocess_Else" ) - 1 },
{ "Preprocess_EndIf", sizeof( "Preprocess_EndIf" ) - 1 },
{ "Preprocess_Pragma", sizeof( "Preprocess_Pragma" ) - 1 },
{ "Specifiers", sizeof( "Specifiers" ) - 1 },
{ "Struct", sizeof( "Struct" ) - 1 },
{ "Struct_Fwd", sizeof( "Struct_Fwd" ) - 1 },
{ "Struct_Body", sizeof( "Struct_Body" ) - 1 },
{ "Template", sizeof( "Template" ) - 1 },
{ "Typedef", sizeof( "Typedef" ) - 1 },
{ "Typename", sizeof( "Typename" ) - 1 },
{ "Union", sizeof( "Union" ) - 1 },
{ "Union_Fwd", sizeof( "Union_Fwd" ) - 1 },
{ "Union_Body", sizeof( "Union_Body" ) - 1 },
{ "Using", sizeof( "Using" ) - 1 },
{ "Using_Namespace", sizeof( "Using_Namespace" ) - 1 },
{ "Variable", sizeof( "Variable" ) - 1 },
{ "Invalid", sizeof("Invalid") - 1 },
{ "Untyped", sizeof("Untyped") - 1 },
{ "NewLine", sizeof("NewLine") - 1 },
{ "Comment", sizeof("Comment") - 1 },
{ "Access_Private", sizeof("Access_Private") - 1 },
{ "Access_Protected", sizeof("Access_Protected") - 1 },
{ "Access_Public", sizeof("Access_Public") - 1 },
{ "PlatformAttributes", sizeof("PlatformAttributes") - 1 },
{ "Class", sizeof("Class") - 1 },
{ "Class_Fwd", sizeof("Class_Fwd") - 1 },
{ "Class_Body", sizeof("Class_Body") - 1 },
{ "Constructor", sizeof("Constructor") - 1 },
{ "Constructor_Fwd", sizeof("Constructor_Fwd") - 1 },
{ "Destructor", sizeof("Destructor") - 1 },
{ "Destructor_Fwd", sizeof("Destructor_Fwd") - 1 },
{ "Enum", sizeof("Enum") - 1 },
{ "Enum_Fwd", sizeof("Enum_Fwd") - 1 },
{ "Enum_Body", sizeof("Enum_Body") - 1 },
{ "Enum_Class", sizeof("Enum_Class") - 1 },
{ "Enum_Class_Fwd", sizeof("Enum_Class_Fwd") - 1 },
{ "Execution", sizeof("Execution") - 1 },
{ "Export_Body", sizeof("Export_Body") - 1 },
{ "Extern_Linkage", sizeof("Extern_Linkage") - 1 },
{ "Extern_Linkage_Body", sizeof("Extern_Linkage_Body") - 1 },
{ "Friend", sizeof("Friend") - 1 },
{ "Function", sizeof("Function") - 1 },
{ "Function_Fwd", sizeof("Function_Fwd") - 1 },
{ "Function_Body", sizeof("Function_Body") - 1 },
{ "Global_Body", sizeof("Global_Body") - 1 },
{ "Module", sizeof("Module") - 1 },
{ "Namespace", sizeof("Namespace") - 1 },
{ "Namespace_Body", sizeof("Namespace_Body") - 1 },
{ "Operator", sizeof("Operator") - 1 },
{ "Operator_Fwd", sizeof("Operator_Fwd") - 1 },
{ "Operator_Member", sizeof("Operator_Member") - 1 },
{ "Operator_Member_Fwd", sizeof("Operator_Member_Fwd") - 1 },
{ "Operator_Cast", sizeof("Operator_Cast") - 1 },
{ "Operator_Cast_Fwd", sizeof("Operator_Cast_Fwd") - 1 },
{ "Parameters", sizeof("Parameters") - 1 },
{ "Parameters_Define", sizeof("Parameters_Define") - 1 },
{ "Preprocess_Define", sizeof("Preprocess_Define") - 1 },
{ "Preprocess_Include", sizeof("Preprocess_Include") - 1 },
{ "Preprocess_If", sizeof("Preprocess_If") - 1 },
{ "Preprocess_IfDef", sizeof("Preprocess_IfDef") - 1 },
{ "Preprocess_IfNotDef", sizeof("Preprocess_IfNotDef") - 1 },
{ "Preprocess_ElIf", sizeof("Preprocess_ElIf") - 1 },
{ "Preprocess_Else", sizeof("Preprocess_Else") - 1 },
{ "Preprocess_EndIf", sizeof("Preprocess_EndIf") - 1 },
{ "Preprocess_Pragma", sizeof("Preprocess_Pragma") - 1 },
{ "Specifiers", sizeof("Specifiers") - 1 },
{ "Struct", sizeof("Struct") - 1 },
{ "Struct_Fwd", sizeof("Struct_Fwd") - 1 },
{ "Struct_Body", sizeof("Struct_Body") - 1 },
{ "Template", sizeof("Template") - 1 },
{ "Typedef", sizeof("Typedef") - 1 },
{ "Typename", sizeof("Typename") - 1 },
{ "Union", sizeof("Union") - 1 },
{ "Union_Fwd", sizeof("Union_Fwd") - 1 },
{ "Union_Body", sizeof("Union_Body") - 1 },
{ "Using", sizeof("Using") - 1 },
{ "Using_Namespace", sizeof("Using_Namespace") - 1 },
{ "Variable", sizeof("Variable") - 1 },
};
return lookup[type];
}
inline Str codetype_to_keyword_str( CodeType type )
inline Str codetype_to_keyword_str(CodeType type)
{
local_persist Str lookup[] = {
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "//", sizeof( "//" ) - 1 },
{ "private", sizeof( "private" ) - 1 },
{ "protected", sizeof( "protected" ) - 1 },
{ "public", sizeof( "public" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "class", sizeof( "class" ) - 1 },
{ "clsss", sizeof( "clsss" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "enum", sizeof( "enum" ) - 1 },
{ "enum", sizeof( "enum" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "enum class", sizeof( "enum class" ) - 1 },
{ "enum class", sizeof( "enum class" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "extern", sizeof( "extern" ) - 1 },
{ "extern", sizeof( "extern" ) - 1 },
{ "friend", sizeof( "friend" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "module", sizeof( "module" ) - 1 },
{ "namespace", sizeof( "namespace" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "operator", sizeof( "operator" ) - 1 },
{ "operator", sizeof( "operator" ) - 1 },
{ "operator", sizeof( "operator" ) - 1 },
{ "operator", sizeof( "operator" ) - 1 },
{ "operator", sizeof( "operator" ) - 1 },
{ "operator", sizeof( "operator" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "define", sizeof( "define" ) - 1 },
{ "include", sizeof( "include" ) - 1 },
{ "if", sizeof( "if" ) - 1 },
{ "ifdef", sizeof( "ifdef" ) - 1 },
{ "ifndef", sizeof( "ifndef" ) - 1 },
{ "elif", sizeof( "elif" ) - 1 },
{ "else", sizeof( "else" ) - 1 },
{ "endif", sizeof( "endif" ) - 1 },
{ "pragma", sizeof( "pragma" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "struct", sizeof( "struct" ) - 1 },
{ "struct", sizeof( "struct" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "template", sizeof( "template" ) - 1 },
{ "typedef", sizeof( "typedef" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "union", sizeof( "union" ) - 1 },
{ "union", sizeof( "union" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "using", sizeof( "using" ) - 1 },
{ "using namespace", sizeof( "using namespace" ) - 1 },
{ "__NA__", sizeof( "__NA__" ) - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "//", sizeof("//") - 1 },
{ "private", sizeof("private") - 1 },
{ "protected", sizeof("protected") - 1 },
{ "public", sizeof("public") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "class", sizeof("class") - 1 },
{ "clsss", sizeof("clsss") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "enum", sizeof("enum") - 1 },
{ "enum", sizeof("enum") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "enum class", sizeof("enum class") - 1 },
{ "enum class", sizeof("enum class") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "extern", sizeof("extern") - 1 },
{ "extern", sizeof("extern") - 1 },
{ "friend", sizeof("friend") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "module", sizeof("module") - 1 },
{ "namespace", sizeof("namespace") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "operator", sizeof("operator") - 1 },
{ "operator", sizeof("operator") - 1 },
{ "operator", sizeof("operator") - 1 },
{ "operator", sizeof("operator") - 1 },
{ "operator", sizeof("operator") - 1 },
{ "operator", sizeof("operator") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "define", sizeof("define") - 1 },
{ "include", sizeof("include") - 1 },
{ "if", sizeof("if") - 1 },
{ "ifdef", sizeof("ifdef") - 1 },
{ "ifndef", sizeof("ifndef") - 1 },
{ "elif", sizeof("elif") - 1 },
{ "else", sizeof("else") - 1 },
{ "endif", sizeof("endif") - 1 },
{ "pragma", sizeof("pragma") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "struct", sizeof("struct") - 1 },
{ "struct", sizeof("struct") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "template", sizeof("template") - 1 },
{ "typedef", sizeof("typedef") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "union", sizeof("union") - 1 },
{ "union", sizeof("union") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
{ "using", sizeof("using") - 1 },
{ "using namespace", sizeof("using namespace") - 1 },
{ "__NA__", sizeof("__NA__") - 1 },
};
return lookup[type];
}
forceinline Str to_str( CodeType type )
forceinline Str to_str(CodeType type)
{
return codetype_to_str( type );
return codetype_to_str(type);
}
forceinline Str to_keyword_str( CodeType type )
forceinline Str to_keyword_str(CodeType type)
{
return codetype_to_keyword_str( type );
return codetype_to_keyword_str(type);
}

100
base/components/gen/eoperator.hpp
View File

@ -58,61 +58,61 @@ enum Operator : u32
Op_UnderlyingType = 0xffffffffu
};
inline Str operator_to_str( Operator op )
inline Str operator_to_str(Operator op)
{
local_persist Str lookup[] = {
{ "INVALID", sizeof( "INVALID" ) - 1 },
{ "=", sizeof( "=" ) - 1 },
{ "+=", sizeof( "+=" ) - 1 },
{ "-=", sizeof( "-=" ) - 1 },
{ "*=", sizeof( "*=" ) - 1 },
{ "/=", sizeof( "/=" ) - 1 },
{ "%=", sizeof( "%=" ) - 1 },
{ "&=", sizeof( "&=" ) - 1 },
{ "|=", sizeof( "|=" ) - 1 },
{ "^=", sizeof( "^=" ) - 1 },
{ "<<=", sizeof( "<<=" ) - 1 },
{ ">>=", sizeof( ">>=" ) - 1 },
{ "++", sizeof( "++" ) - 1 },
{ "--", sizeof( "--" ) - 1 },
{ "+", sizeof( "+" ) - 1 },
{ "-", sizeof( "-" ) - 1 },
{ "!", sizeof( "!" ) - 1 },
{ "+", sizeof( "+" ) - 1 },
{ "-", sizeof( "-" ) - 1 },
{ "*", sizeof( "*" ) - 1 },
{ "/", sizeof( "/" ) - 1 },
{ "%", sizeof( "%" ) - 1 },
{ "~", sizeof( "~" ) - 1 },
{ "&", sizeof( "&" ) - 1 },
{ "|", sizeof( "|" ) - 1 },
{ "^", sizeof( "^" ) - 1 },
{ "<<", sizeof( "<<" ) - 1 },
{ ">>", sizeof( ">>" ) - 1 },
{ "&&", sizeof( "&&" ) - 1 },
{ "||", sizeof( "||" ) - 1 },
{ "==", sizeof( "==" ) - 1 },
{ "!=", sizeof( "!=" ) - 1 },
{ "<", sizeof( "<" ) - 1 },
{ ">", sizeof( ">" ) - 1 },
{ "<=", sizeof( "<=" ) - 1 },
{ ">=", sizeof( ">=" ) - 1 },
{ "[]", sizeof( "[]" ) - 1 },
{ "*", sizeof( "*" ) - 1 },
{ "&", sizeof( "&" ) - 1 },
{ "->", sizeof( "->" ) - 1 },
{ "->*", sizeof( "->*" ) - 1 },
{ "()", sizeof( "()" ) - 1 },
{ ",", sizeof( "," ) - 1 },
{ "new", sizeof( "new" ) - 1 },
{ "new[]", sizeof( "new[]" ) - 1 },
{ "delete", sizeof( "delete" ) - 1 },
{ "delete[]", sizeof( "delete[]" ) - 1 },
{ "INVALID", sizeof("INVALID") - 1 },
{ "=", sizeof("=") - 1 },
{ "+=", sizeof("+=") - 1 },
{ "-=", sizeof("-=") - 1 },
{ "*=", sizeof("*=") - 1 },
{ "/=", sizeof("/=") - 1 },
{ "%=", sizeof("%=") - 1 },
{ "&=", sizeof("&=") - 1 },
{ "|=", sizeof("|=") - 1 },
{ "^=", sizeof("^=") - 1 },
{ "<<=", sizeof("<<=") - 1 },
{ ">>=", sizeof(">>=") - 1 },
{ "++", sizeof("++") - 1 },
{ "--", sizeof("--") - 1 },
{ "+", sizeof("+") - 1 },
{ "-", sizeof("-") - 1 },
{ "!", sizeof("!") - 1 },
{ "+", sizeof("+") - 1 },
{ "-", sizeof("-") - 1 },
{ "*", sizeof("*") - 1 },
{ "/", sizeof("/") - 1 },
{ "%", sizeof("%") - 1 },
{ "~", sizeof("~") - 1 },
{ "&", sizeof("&") - 1 },
{ "|", sizeof("|") - 1 },
{ "^", sizeof("^") - 1 },
{ "<<", sizeof("<<") - 1 },
{ ">>", sizeof(">>") - 1 },
{ "&&", sizeof("&&") - 1 },
{ "||", sizeof("||") - 1 },
{ "==", sizeof("==") - 1 },
{ "!=", sizeof("!=") - 1 },
{ "<", sizeof("<") - 1 },
{ ">", sizeof(">") - 1 },
{ "<=", sizeof("<=") - 1 },
{ ">=", sizeof(">=") - 1 },
{ "[]", sizeof("[]") - 1 },
{ "*", sizeof("*") - 1 },
{ "&", sizeof("&") - 1 },
{ "->", sizeof("->") - 1 },
{ "->*", sizeof("->*") - 1 },
{ "()", sizeof("()") - 1 },
{ ",", sizeof(",") - 1 },
{ "new", sizeof("new") - 1 },
{ "new[]", sizeof("new[]") - 1 },
{ "delete", sizeof("delete") - 1 },
{ "delete[]", sizeof("delete[]") - 1 },
};
return lookup[op];
}
forceinline Str to_str( Operator op )
forceinline Str to_str(Operator op)
{
return operator_to_str( op );
return operator_to_str(op);
}

100
base/components/gen/especifier.hpp
View File

@ -38,84 +38,84 @@ enum Specifier : u32
Spec_UnderlyingType = 0xffffffffu
};
inline Str spec_to_str( Specifier type )
inline Str spec_to_str(Specifier type)
{
local_persist Str lookup[] = {
{ "INVALID", sizeof( "INVALID" ) - 1 },
{ "consteval", sizeof( "consteval" ) - 1 },
{ "constexpr", sizeof( "constexpr" ) - 1 },
{ "constinit", sizeof( "constinit" ) - 1 },
{ "explicit", sizeof( "explicit" ) - 1 },
{ "extern", sizeof( "extern" ) - 1 },
{ "forceinline", sizeof( "forceinline" ) - 1 },
{ "global", sizeof( "global" ) - 1 },
{ "inline", sizeof( "inline" ) - 1 },
{ "internal", sizeof( "internal" ) - 1 },
{ "local_persist", sizeof( "local_persist" ) - 1 },
{ "mutable", sizeof( "mutable" ) - 1 },
{ "neverinline", sizeof( "neverinline" ) - 1 },
{ "*", sizeof( "*" ) - 1 },
{ "&", sizeof( "&" ) - 1 },
{ "register", sizeof( "register" ) - 1 },
{ "restrict", sizeof( "restrict" ) - 1 },
{ "&&", sizeof( "&&" ) - 1 },
{ "static", sizeof( "static" ) - 1 },
{ "thread_local", sizeof( "thread_local" ) - 1 },
{ "virtual", sizeof( "virtual" ) - 1 },
{ "const", sizeof( "const" ) - 1 },
{ "final", sizeof( "final" ) - 1 },
{ "noexcept", sizeof( "noexcept" ) - 1 },
{ "override", sizeof( "override" ) - 1 },
{ "= 0", sizeof( "= 0" ) - 1 },
{ "volatile", sizeof( "volatile" ) - 1 },
{ "INVALID", sizeof("INVALID") - 1 },
{ "consteval", sizeof("consteval") - 1 },
{ "constexpr", sizeof("constexpr") - 1 },
{ "constinit", sizeof("constinit") - 1 },
{ "explicit", sizeof("explicit") - 1 },
{ "extern", sizeof("extern") - 1 },
{ "forceinline", sizeof("forceinline") - 1 },
{ "global", sizeof("global") - 1 },
{ "inline", sizeof("inline") - 1 },
{ "internal", sizeof("internal") - 1 },
{ "local_persist", sizeof("local_persist") - 1 },
{ "mutable", sizeof("mutable") - 1 },
{ "neverinline", sizeof("neverinline") - 1 },
{ "*", sizeof("*") - 1 },
{ "&", sizeof("&") - 1 },
{ "register", sizeof("register") - 1 },
{ "restrict", sizeof("restrict") - 1 },
{ "&&", sizeof("&&") - 1 },
{ "static", sizeof("static") - 1 },
{ "thread_local", sizeof("thread_local") - 1 },
{ "virtual", sizeof("virtual") - 1 },
{ "const", sizeof("const") - 1 },
{ "final", sizeof("final") - 1 },
{ "noexcept", sizeof("noexcept") - 1 },
{ "override", sizeof("override") - 1 },
{ "= 0", sizeof("= 0") - 1 },
{ "volatile", sizeof("volatile") - 1 },
};
return lookup[type];
}
inline bool spec_is_trailing( Specifier specifier )
inline bool spec_is_trailing(Specifier specifier)
{
switch ( specifier )
switch (specifier)
{
case Spec_Const :
case Spec_Final :
case Spec_NoExceptions :
case Spec_Override :
case Spec_Pure :
case Spec_Volatile :
case Spec_Const:
case Spec_Final:
case Spec_NoExceptions:
case Spec_Override:
case Spec_Pure:
case Spec_Volatile:
return true;
default :
default:
return false;
}
}
inline Specifier str_to_specifier( Str str )
inline Specifier str_to_specifier(Str str)
{
local_persist u32 keymap[Spec_NumSpecifiers];
do_once_start for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
do_once_start for (u32 index = 0; index < Spec_NumSpecifiers; index++)
{
Str enum_str = spec_to_str( (Specifier)index );
keymap[index] = crc32( enum_str.Ptr, enum_str.Len );
Str enum_str = spec_to_str((Specifier)index);
keymap[index] = crc32(enum_str.Ptr, enum_str.Len);
}
do_once_end u32 hash = crc32( str.Ptr, str.Len );
for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
do_once_end u32 hash = crc32(str.Ptr, str.Len);
for (u32 index = 0; index < Spec_NumSpecifiers; index++)
{
if ( keymap[index] == hash )
if (keymap[index] == hash)
return (Specifier)index;
}
return Spec_Invalid;
}
forceinline Str to_str( Specifier spec )
forceinline Str to_str(Specifier spec)
{
return spec_to_str( spec );
return spec_to_str(spec);
}
forceinline Specifier to_type( Str str )
forceinline Specifier to_type(Str str)
{
return str_to_specifier( str );
return str_to_specifier(str);
}
forceinline bool is_trailing( Specifier specifier )
forceinline bool is_trailing(Specifier specifier)
{
return spec_is_trailing( specifier );
return spec_is_trailing(specifier);
}

218
base/components/gen/etoktype.hpp
View File

@ -5,7 +5,7 @@
// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
#define GEN_DEFINE_ATTRIBUTE_TOKENS Entry( Tok_Attribute_GEN_API, "GEN_API" )
#define GEN_DEFINE_ATTRIBUTE_TOKENS Entry(Tok_Attribute_GEN_API, "GEN_API")
enum TokType : u32
{
@ -112,125 +112,125 @@ enum TokType : u32
Tok_NumTokens
};
inline Str toktype_to_str( TokType type )
inline Str toktype_to_str(TokType type)
{
local_persist Str lookup[] = {
{ "__invalid__", sizeof( "__invalid__" ) - 1 },
{ "private", sizeof( "private" ) - 1 },
{ "protected", sizeof( "protected" ) - 1 },
{ "public", sizeof( "public" ) - 1 },
{ ".", sizeof( "." ) - 1 },
{ "::", sizeof( "::" ) - 1 },
{ "&", sizeof( "&" ) - 1 },
{ "&&", sizeof( "&&" ) - 1 },
{ ":", sizeof( ":" ) - 1 },
{ "[[", sizeof( "[[" ) - 1 },
{ "]]", sizeof( "]]" ) - 1 },
{ "{", sizeof( "{" ) - 1 },
{ "}", sizeof( "}" ) - 1 },
{ "[", sizeof( "[" ) - 1 },
{ "]", sizeof( "]" ) - 1 },
{ "(", sizeof( "(" ) - 1 },
{ ")", sizeof( ")" ) - 1 },
{ "__comment__", sizeof( "__comment__" ) - 1 },
{ "__comment_end__", sizeof( "__comment_end__" ) - 1 },
{ "__comment_start__", sizeof( "__comment_start__" ) - 1 },
{ "__character__", sizeof( "__character__" ) - 1 },
{ ",", sizeof( "," ) - 1 },
{ "class", sizeof( "class" ) - 1 },
{ "__attribute__", sizeof( "__attribute__" ) - 1 },
{ "__declspec", sizeof( "__declspec" ) - 1 },
{ "enum", sizeof( "enum" ) - 1 },
{ "extern", sizeof( "extern" ) - 1 },
{ "friend", sizeof( "friend" ) - 1 },
{ "module", sizeof( "module" ) - 1 },
{ "namespace", sizeof( "namespace" ) - 1 },
{ "operator", sizeof( "operator" ) - 1 },
{ "struct", sizeof( "struct" ) - 1 },
{ "template", sizeof( "template" ) - 1 },
{ "typedef", sizeof( "typedef" ) - 1 },
{ "using", sizeof( "using" ) - 1 },
{ "union", sizeof( "union" ) - 1 },
{ "__identifier__", sizeof( "__identifier__" ) - 1 },
{ "import", sizeof( "import" ) - 1 },
{ "export", sizeof( "export" ) - 1 },
{ "__new_line__", sizeof( "__new_line__" ) - 1 },
{ "__number__", sizeof( "__number__" ) - 1 },
{ "__operator__", sizeof( "__operator__" ) - 1 },
{ "#", sizeof( "#" ) - 1 },
{ "define", sizeof( "define" ) - 1 },
{ "__define_param__", sizeof( "__define_param__" ) - 1 },
{ "if", sizeof( "if" ) - 1 },
{ "ifdef", sizeof( "ifdef" ) - 1 },
{ "ifndef", sizeof( "ifndef" ) - 1 },
{ "elif", sizeof( "elif" ) - 1 },
{ "else", sizeof( "else" ) - 1 },
{ "endif", sizeof( "endif" ) - 1 },
{ "include", sizeof( "include" ) - 1 },
{ "pragma", sizeof( "pragma" ) - 1 },
{ "__macro_content__", sizeof( "__macro_content__" ) - 1 },
{ "__macro_expression__", sizeof( "__macro_expression__" ) - 1 },
{ "__macro_statment__", sizeof( "__macro_statment__" ) - 1 },
{ "__macro_typename__", sizeof( "__macro_typename__" ) - 1 },
{ "__unsupported__", sizeof( "__unsupported__" ) - 1 },
{ "alignas", sizeof( "alignas" ) - 1 },
{ "const", sizeof( "const" ) - 1 },
{ "consteval", sizeof( "consteval" ) - 1 },
{ "constexpr", sizeof( "constexpr" ) - 1 },
{ "constinit", sizeof( "constinit" ) - 1 },
{ "explicit", sizeof( "explicit" ) - 1 },
{ "extern", sizeof( "extern" ) - 1 },
{ "final", sizeof( "final" ) - 1 },
{ "forceinline", sizeof( "forceinline" ) - 1 },
{ "global", sizeof( "global" ) - 1 },
{ "inline", sizeof( "inline" ) - 1 },
{ "internal", sizeof( "internal" ) - 1 },
{ "local_persist", sizeof( "local_persist" ) - 1 },
{ "mutable", sizeof( "mutable" ) - 1 },
{ "neverinline", sizeof( "neverinline" ) - 1 },
{ "override", sizeof( "override" ) - 1 },
{ "restrict", sizeof( "restrict" ) - 1 },
{ "static", sizeof( "static" ) - 1 },
{ "thread_local", sizeof( "thread_local" ) - 1 },
{ "volatile", sizeof( "volatile" ) - 1 },
{ "virtual", sizeof( "virtual" ) - 1 },
{ "*", sizeof( "*" ) - 1 },
{ ";", sizeof( ";" ) - 1 },
{ "static_assert", sizeof( "static_assert" ) - 1 },
{ "__string__", sizeof( "__string__" ) - 1 },
{ "typename", sizeof( "typename" ) - 1 },
{ "unsigned", sizeof( "unsigned" ) - 1 },
{ "signed", sizeof( "signed" ) - 1 },
{ "short", sizeof( "short" ) - 1 },
{ "long", sizeof( "long" ) - 1 },
{ "bool", sizeof( "bool" ) - 1 },
{ "char", sizeof( "char" ) - 1 },
{ "int", sizeof( "int" ) - 1 },
{ "double", sizeof( "double" ) - 1 },
{ "__int8", sizeof( "__int8" ) - 1 },
{ "__int16", sizeof( "__int16" ) - 1 },
{ "__int32", sizeof( "__int32" ) - 1 },
{ "__int64", sizeof( "__int64" ) - 1 },
{ "_W64", sizeof( "_W64" ) - 1 },
{ "...", sizeof( "..." ) - 1 },
{ "__attrib_start__", sizeof( "__attrib_start__" ) - 1 },
{ "GEN_API", sizeof( "GEN_API" ) - 1 },
{ "__invalid__", sizeof("__invalid__") - 1 },
{ "private", sizeof("private") - 1 },
{ "protected", sizeof("protected") - 1 },
{ "public", sizeof("public") - 1 },
{ ".", sizeof(".") - 1 },
{ "::", sizeof("::") - 1 },
{ "&", sizeof("&") - 1 },
{ "&&", sizeof("&&") - 1 },
{ ":", sizeof(":") - 1 },
{ "[[", sizeof("[[") - 1 },
{ "]]", sizeof("]]") - 1 },
{ "{", sizeof("{") - 1 },
{ "}", sizeof("}") - 1 },
{ "[", sizeof("[") - 1 },
{ "]", sizeof("]") - 1 },
{ "(", sizeof("(") - 1 },
{ ")", sizeof(")") - 1 },
{ "__comment__", sizeof("__comment__") - 1 },
{ "__comment_end__", sizeof("__comment_end__") - 1 },
{ "__comment_start__", sizeof("__comment_start__") - 1 },
{ "__character__", sizeof("__character__") - 1 },
{ ",", sizeof(",") - 1 },
{ "class", sizeof("class") - 1 },
{ "__attribute__", sizeof("__attribute__") - 1 },
{ "__declspec", sizeof("__declspec") - 1 },
{ "enum", sizeof("enum") - 1 },
{ "extern", sizeof("extern") - 1 },
{ "friend", sizeof("friend") - 1 },
{ "module", sizeof("module") - 1 },
{ "namespace", sizeof("namespace") - 1 },
{ "operator", sizeof("operator") - 1 },
{ "struct", sizeof("struct") - 1 },
{ "template", sizeof("template") - 1 },
{ "typedef", sizeof("typedef") - 1 },
{ "using", sizeof("using") - 1 },
{ "union", sizeof("union") - 1 },
{ "__identifier__", sizeof("__identifier__") - 1 },
{ "import", sizeof("import") - 1 },
{ "export", sizeof("export") - 1 },
{ "__new_line__", sizeof("__new_line__") - 1 },
{ "__number__", sizeof("__number__") - 1 },
{ "__operator__", sizeof("__operator__") - 1 },
{ "#", sizeof("#") - 1 },
{ "define", sizeof("define") - 1 },
{ "__define_param__", sizeof("__define_param__") - 1 },
{ "if", sizeof("if") - 1 },
{ "ifdef", sizeof("ifdef") - 1 },
{ "ifndef", sizeof("ifndef") - 1 },
{ "elif", sizeof("elif") - 1 },
{ "else", sizeof("else") - 1 },
{ "endif", sizeof("endif") - 1 },
{ "include", sizeof("include") - 1 },
{ "pragma", sizeof("pragma") - 1 },
{ "__macro_content__", sizeof("__macro_content__") - 1 },
{ "__macro_expression__", sizeof("__macro_expression__") - 1 },
{ "__macro_statment__", sizeof("__macro_statment__") - 1 },
{ "__macro_typename__", sizeof("__macro_typename__") - 1 },
{ "__unsupported__", sizeof("__unsupported__") - 1 },
{ "alignas", sizeof("alignas") - 1 },
{ "const", sizeof("const") - 1 },
{ "consteval", sizeof("consteval") - 1 },
{ "constexpr", sizeof("constexpr") - 1 },
{ "constinit", sizeof("constinit") - 1 },
{ "explicit", sizeof("explicit") - 1 },
{ "extern", sizeof("extern") - 1 },
{ "final", sizeof("final") - 1 },
{ "forceinline", sizeof("forceinline") - 1 },
{ "global", sizeof("global") - 1 },
{ "inline", sizeof("inline") - 1 },
{ "internal", sizeof("internal") - 1 },
{ "local_persist", sizeof("local_persist") - 1 },
{ "mutable", sizeof("mutable") - 1 },
{ "neverinline", sizeof("neverinline") - 1 },
{ "override", sizeof("override") - 1 },
{ "restrict", sizeof("restrict") - 1 },
{ "static", sizeof("static") - 1 },
{ "thread_local", sizeof("thread_local") - 1 },
{ "volatile", sizeof("volatile") - 1 },
{ "virtual", sizeof("virtual") - 1 },
{ "*", sizeof("*") - 1 },
{ ";", sizeof(";") - 1 },
{ "static_assert", sizeof("static_assert") - 1 },
{ "__string__", sizeof("__string__") - 1 },
{ "typename", sizeof("typename") - 1 },
{ "unsigned", sizeof("unsigned") - 1 },
{ "signed", sizeof("signed") - 1 },
{ "short", sizeof("short") - 1 },
{ "long", sizeof("long") - 1 },
{ "bool", sizeof("bool") - 1 },
{ "char", sizeof("char") - 1 },
{ "int", sizeof("int") - 1 },
{ "double", sizeof("double") - 1 },
{ "__int8", sizeof("__int8") - 1 },
{ "__int16", sizeof("__int16") - 1 },
{ "__int32", sizeof("__int32") - 1 },
{ "__int64", sizeof("__int64") - 1 },
{ "_W64", sizeof("_W64") - 1 },
{ "...", sizeof("...") - 1 },
{ "__attrib_start__", sizeof("__attrib_start__") - 1 },
{ "GEN_API", sizeof("GEN_API") - 1 },
};
return lookup[type];
}
inline TokType str_to_toktype( Str str )
inline TokType str_to_toktype(Str str)
{
local_persist u32 keymap[Tok_NumTokens];
do_once_start for ( u32 index = 0; index < Tok_NumTokens; index++ )
do_once_start for (u32 index = 0; index < Tok_NumTokens; index++)
{
Str enum_str = toktype_to_str( (TokType)index );
keymap[index] = crc32( enum_str.Ptr, enum_str.Len );
Str enum_str = toktype_to_str((TokType)index);
keymap[index] = crc32(enum_str.Ptr, enum_str.Len);
}
do_once_end u32 hash = crc32( str.Ptr, str.Len );
for ( u32 index = 0; index < Tok_NumTokens; index++ )
do_once_end u32 hash = crc32(str.Ptr, str.Len);
for (u32 index = 0; index < Tok_NumTokens; index++)
{
if ( keymap[index] == hash )
if (keymap[index] == hash)
return (TokType)index;
}
return Tok_Invalid;

1
base/components/interface.hpp
View File

@ -50,6 +50,7 @@ struct Context
// LoggerCallaback* log_callback; // TODO(Ed): Impl user logger callback as an option.
// Initalization config
u32 Max_CommentLineLength; // Used by def_comment
u32 Max_StrCacheLength; // Any cached string longer than this is always allocated again.

2
base/components/interface.upfront.cpp
View File

@ -402,7 +402,7 @@ bool null__check( char const* context, char const* code_id, Code code ) {
#define null_check( context, code ) null__check( #context, #code, cast(Code, code) )
/*
The implementaiton of the upfront constructors involves doing three things:
The implementation of the upfront constructors involves doing three things:
* Validate the arguments given to construct the intended type of AST is valid.
* Construct said AST type.
* Lock the AST (set to readonly) and return the valid object.

2
base/components/parser.cpp
View File

@ -4629,7 +4629,7 @@ CodeTypename parser_parse_type( bool from_template, bool* typedef_is_function )
// <Attributes> <Specifiers> <class, enum, struct, union> <Name>
}
// Decltype draft implementaiton
// Decltype draft implementation
#if 0
else if ( currtok.Type == Tok_DeclType )
{

2
base/components/parser_types.hpp
View File

@ -178,7 +178,7 @@ enum EMacroFlags : u16
// ^^^ This a kludge because unreal has a macro that behaves as both a 'statement' and an attribute (UE_DEPRECATED, PRAGMA_ENABLE_DEPRECATION_WARNINGS, etc)
// TODO(Ed): We can keep the MF_Allow_As_Attribute flag for macros, however, we need to add the ability of AST_Attributes to chain themselves.
// Its thats already a thing in the standard language anyway
// & it would allow UE_DEPRECATED, (UE_PROPERTY / UE_FUNCTION) to chain themselves as attributes of a resolved member function/varaible definition
// & it would allow UE_DEPRECATED, (UE_PROPERTY / UE_FUNCTION) to chain themselves as attributes of a resolved member function/variable definition
MF_Allow_As_Attribute = bit(3),
// When a macro is encountered after attributs and specifiers while parsing a function, or variable:

1
base/dependencies/containers.hpp
View File

@ -309,6 +309,7 @@ ArrayHeader* array_get_header(Array<Type> 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)
{

2
base/dependencies/memory.cpp
View File

@ -90,7 +90,7 @@ struct _heap_alloc_info
void* heap_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
{
void* ptr = NULL;
void* ptr = nullptr;
// unused( allocator_data );
// unused( old_size );
if ( ! alignment )

4
base/gen.cpp
View File

@ -37,8 +37,8 @@ GEN_NS_BEGIN
#include "components/interface.parsing.cpp"
#include "components/interface.untyped.cpp"
#include "auxillary/builder.cpp"
#include "auxillary/scanner.cpp"
#include "auxiliary/builder.cpp"
#include "auxiliary/scanner.cpp"
GEN_NS_END

4
base/gen.hpp
View File

@ -33,8 +33,8 @@ GEN_NS_BEGIN
#include "components/gen/ast_inlines.hpp"
#include "components/header_end.hpp"
#include "auxillary/builder.hpp"
#include "auxillary/scanner.hpp"
#include "auxiliary/builder.hpp"
#include "auxiliary/scanner.hpp"
GEN_NS_END

6
base/helpers/misc.hpp
View File

@ -7,9 +7,9 @@
# 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 "auxiliary/builder.hpp"
# include "auxiliary/builder.cpp"
# include "auxiliary/scanner.hpp"
#include <stdlib.h>

2
docs/AST_Design.md
View File

@ -15,7 +15,7 @@ In order to abstract away constant use of `AST*` its wrapped in a Code type whic
When its the [C generated variant of the library](../gen_c_library/)
```c
typedef AST* Code;
tyepdef AST_<name>* Code<name>;
typedef AST_<name>* Code<name>;
...
```

8
docs/AST_Types.md
View File

@ -6,7 +6,7 @@
# 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.
While the Readme for docs covers the data layout per AST, this will focus on the AST types available, and their nuances.
## Body
@ -37,7 +37,7 @@ 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 CodeType type for the type of defintion used.
Parent should have a compatible CodeType type for the type of definition used.
Serialization:
@ -95,7 +95,7 @@ Serialization:
<Content>
```
The parser will perserve comments found if residing with a body or in accepted inline-to-definition locations.
The parser will preserve comments found if residing with a body or in accepted inline-to-definition locations.
Otherwise they will be skipped by the TokArray::__eat and TokArray::current( skip foramtting enabled ) functions.
The upfront constructor: `def_comment` expects to recieve a comment without the `//` or `/* */` parts. It will add them during construction.
@ -289,7 +289,7 @@ Serialization:
## Execution
Just represents an execution body. Equivalent to an untyped body.
Will be obsolute when function body parsing is implemented.
Will be obsolete when function body parsing is implemented.
Fields:

18
docs/Parser_Algo.md
View File

@ -4,7 +4,7 @@
<- [docs - General](Readme.md)
# Parser's Algorithim
# Parser's Algorithm
gencpp uses a hand-written recursive descent parser. Both the lexer and parser currently handle a full C/C++ file in a single pass.
@ -399,7 +399,7 @@ Below is an outline of the general alogirithim used for these internal procedure
## `parse_function_after_name`
This is needed as a function defintion is not easily resolvable early on, as such this function handles resolving a function
This is needed as a function definition is not easily resolvable early on, as such this function handles resolving a function
after its been made ceratin that the type of declaration or definition is indeed for a function signature.
By the point this function is called the following are known : export module flag, attributes, specifiers, return type, & name
@ -548,7 +548,7 @@ In the future statements and expressions will be parsed.
### Implementation Constraints
* Cannot definitively distinguish nested namespaces with identical names
* Cannot distinguish nested namespaces with identical names
* Return type detection requires parser enhancement
* Template parameter validation is syntax-based only
* Future enhancement: Implement type parsing with rollback capability
@ -595,7 +595,7 @@ Notes:
## `parse_operator_after_ret_type`
This is needed as a operator defintion is not easily resolvable early on, as such this function handles resolving a operator after its been made ceratin that the type of declaration or definition is indeed for a operator signature.
This is needed as a operator definition is not easily resolvable early on, as such this function handles resolving a operator after its been made ceratin that the type of declaration or definition is indeed for a operator signature.
By the point this function is called the following are known : export module flag, attributes, specifiers, and return type
@ -639,7 +639,7 @@ By the point this function is called the following are known : export module fla
## `parse_operator_function_or_variable`
When this function is called, attribute and specifiers may have been resolved, however what comes next can still be either an operator, function, or varaible.
When this function is called, attribute and specifiers may have been resolved, however what comes next can still be either an operator, function, or variable.
1. Initial Type Resolution
1. Push parsing scope
@ -792,7 +792,7 @@ This will get changed heavily once we have better support for typename expressio
## `parse_variable_after_name`
This is needed as a variable defintion is not easily resolvable early on, it takes a long evaluation period before its known that the declaration or definition is a variable. As such this function handles resolving a variable.
This is needed as a variable definition is not easily resolvable early on, it takes a long evaluation period before its known that the declaration or definition is a variable. As such this function handles resolving a variable.
By the point this function is called the following are known : export module flag, attributes, specifiers, value type, name
1. Initialization Processing
@ -1090,7 +1090,7 @@ Limitations:
This implementatin will be updated in the future to properly handle functional typename signatures.
### Current Algorithim
### Current Algorithm
Anything that is in the qualifier capture of the function typename is treated as an expression abstracted as an untyped string
@ -1119,7 +1119,7 @@ Anything that is in the qualifier capture of the function typename is treated as
8. Check for varaidic argument (param pack) token:
1. Consume varadic argument token
### WIP - Alternative Algorithim
### WIP - Alternative Algorithm
Currently wrapped up via macro: `GEN_USE_NEW_TYPENAME_PARSING`
Anything that is in the qualifier capture of the function typename is treated as an expression abstracted as an untyped string
@ -1152,7 +1152,7 @@ Anything that is in the qualifier capture of the function typename is treated as
7. Check for varaidic argument (param pack) token:
1. Consume varadic argument token
### **Later: Algorithim based on typename expressions**
### **Later: Algorithm based on typename expressions**
## `parse_typedef`

4
docs/Parsing.md
View File

@ -10,7 +10,7 @@ The library features a naive single-pass parser, tailored for only what the libr
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 10-15k loc worst case.
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.
You can think of this parser as *frontend parser* vs a *semantic parser*. Its intuitively similar to WYSIWYG. What you ***perceive*** as the syntax from the user-side before the compiler gets a hold of it, is what you get.
User exposed interface:
@ -63,7 +63,7 @@ The preprocessor lines are stored as members of their associated scope they are
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:
* varaible definitions are allowed for a preprocessed macro `extern MACRO();`
* variable definitions are allowed for a preprocessed macro `extern MACRO();`
* function definitions are allowed for a preprocessed macro: `neverinline MACRO() { ... }`
* Disable with: `#define GEN_PARSER_DISABLE_MACRO_FUNCTION_SIGNATURES`
* typedefs allow for a preprocessed macro: `typedef MACRO();`

6
docs/Readme.md
View File

@ -260,7 +260,7 @@ def_global_body( args( ht_entry, array_ht_entry, hashtable ));
def_global_body( 3, ht_entry, array_ht_entry, hashtable );
```
If a more incremental approach is desired for the body ASTs, `Code def_body( CodeT type )` can be used to create an empty body.
If a more incremental approach is desired for the body ASTs, `Code def_body( CodeT type )` can be used to create an empty bodyss
When the members have been populated use: `code_validate_body` to verify that the members are valid entires for that type.
### Parse construction
@ -432,7 +432,7 @@ and have the desired specifiers assigned to them beforehand.
## Code generation and modification
There are two provided auxillary interfaces:
There are two provided auxiliary interfaces:
* Builder
* Scanner
@ -444,7 +444,7 @@ There are two provided auxillary interfaces:
* The code is provided via print( code ) function will be serialized to its buffer.
* When all serialization is finished, use the write() command to write the buffer to the file.
### Scanner Auxillary Interface
### Scanner
* The purpose is to scan or parse files
* Some with two basic functions to convert a fil to code: `scan_file` and `parse_file`

16
gen_c_library/Readme.md
View File

@ -21,7 +21,7 @@ To generate a static or dynamic library:
```ps1
.\build.ps1 <compiler> <debug or omit> c_lib_static c_lib_dyn
```
.
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](./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.**
@ -29,10 +29,10 @@ All free from tag identifiers will be prefixed with `gen_` or `GEN_` as the name
## Generation structure
1. Files are scanned in or parsed.
* If they are parsed, its dude to requiring some changes to either naming, or adding additonal definitions (container generation, typedefs, etc).
* If they are parsed, its due to requiring some changes to either naming, or adding additonal definitions (container generation, typedefs, etc).
2. All scanned or parsed code is refactored (identifiers substs) and/or formatted.
3. Singleheader generated.
4. Segemented headers and source generated.
4. Segmented headers and source generated.
## Templated container generation
@ -43,7 +43,7 @@ The array and hashtable containers used across this library are generated using
These are functionally (and interface wise) equivalent to the library's `Array<Type>` `HashTable<Type>` within [containers.hpp](../base/dependencies/containers.hpp)
Both files follow the same patter of providing three procedures:
Both files follow the same pattern of providing three procedures:
* `gen_<container>_base` : Intended to be called once, defines universal "base" definitions.
* `gen_<container>` : Called per instatiation of the container for a given set of dependent args.
@ -54,11 +54,13 @@ A simple `<container>_DefinitionCounter` is used to know how many instantiations
## Macro Usage
For the most part macros are kept minimal with exception to `_Generic`...
*(I will be explaining this thing for the rest of this seciton along with gencpp c library's usage of it)*
The `_Generic` macro plays a key role in reducing direct need of the user to wrangle with mangled definition identifiers of 'templated' containers or for type coercion to map distinct data types to a common code path.
Because of its lack of use in many C11 libraries.. and, of those that do; they usually end up obfuscating it with excessive preprocessor abuse; Effort was put into minimizing how much of these macros are handled by the preprocessor vs gencpp itself.
Many C11 libraries don't use it.. and, of those that do. they usually end up obfuscate it with excessive preprocessor abuse; Effort was put into minimizing how much of these macros are handled by the preprocessor vs gencpp itself.
*(I will be explaining this thing for the rest of this seciton along with gencpp c library's usage of it)*
The usual presentation (done bare) is the following:
@ -95,7 +97,7 @@ For this library's purposes we'll be using the functional macro equivalent *(if
```c
#define macro_that_uses_selector_arg_for_resolving_a_fucntion( selecting_exp) \
_Generic( (arg), \
_Generic( (selecting_exp), \
int : func_use_int, \
double : func_use_double, \
struct Whatnot : func_use_Whatnot, \

192
gen_c_library/c_library.cpp
View File

@ -995,7 +995,7 @@ R"(#define AST_ArrSpecs_Cap \
/*
This thing makes a:
#define code_<interface_name>( code, ... ) _Generic( (code), \
<slots> of defintions that look like: <typeof(code)>: code__<interface_name>, \
<slots> of definitions that look like: <typeof(code)>: code__<interface_name>, \
default: gen_generic_selection (Fail case) \
) GEN_RESOLVED_FUNCTION_CALL( code, ... ) \
*/
@ -1256,63 +1256,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
break;
}
CodeBody parsed_header_builder = parse_file( path_base "auxillary/builder.hpp" );
CodeBody header_builder = def_body(CT_Global_Body);
for ( Code entry = parsed_header_builder.begin(); entry != parsed_header_builder.end(); ++ entry ) switch( entry->Type )
{
case CT_Preprocess_IfDef:
{
b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_header_builder, header_builder );
if (found) break;
header_builder.append(entry);
}
break;
case CT_Preprocess_If:
{
b32 found = ignore_preprocess_cond_block(txt("GEN_COMPILER_CPP"), entry, parsed_header_builder, header_builder );
if (found) break;
found = ignore_preprocess_cond_block(txt("GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP"), entry, parsed_header_builder, header_builder );
if (found) break;
header_builder.append(entry);
}
break;
case CT_Struct:
{
CodeBody body = cast(CodeBody, entry->Body);
CodeBody new_body = def_body(CT_Struct_Body);
for ( Code body_entry = body.begin(); body_entry != body.end(); ++ body_entry ) switch(body_entry->Type)
{
case CT_Preprocess_If:
{
b32 found = ignore_preprocess_cond_block(txt("GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP"), body_entry, body, new_body );
if (found) break;
new_body.append(body_entry);
}
break;
default:
new_body.append(body_entry);
break;
}
if ( new_body->NumEntries > 0 ) {
entry->Body = new_body;
}
header_builder.append(entry);
}
break;
default:
header_builder.append(entry);
break;
}
s32 idx = 0;
CodeBody parsed_header_end = parse_file( path_base "components/header_end.hpp" );
CodeBody header_end = def_body(CT_Global_Body);
@ -1351,6 +1294,111 @@ R"(#define <interface_name>( code ) _Generic( (code), \
}
#pragma endregion Resolve Components
#pragma region Resolve Aux
CodeDefine gsel_builder_print = NullCode;
CodeBody parsed_header_builder = parse_file( path_base "auxiliary/builder.hpp" );
CodeBody header_builder = def_body(CT_Global_Body);
for ( Code entry = parsed_header_builder.begin(); entry != parsed_header_builder.end(); ++ entry ) switch( entry->Type )
{
case CT_Preprocess_IfDef:
{
b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_header_builder, header_builder );
if (found) break;
header_builder.append(entry);
}
break;
case CT_Preprocess_If:
{
b32 found = ignore_preprocess_cond_block(txt("GEN_COMPILER_CPP"), entry, parsed_header_builder, header_builder );
if (found) break;
found = ignore_preprocess_cond_block(txt("GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP"), entry, parsed_header_builder, header_builder );
if (found) break;
header_builder.append(entry);
}
break;
case CT_Function_Fwd:
{
CodeFn fn = cast(CodeFn, entry);
if (! fn->Name.is_equal(txt("builder_print")) ) {
header_builder.append(fn);
continue;
}
fn->Name = cache_str(txt("builder__print"));
StrBuilder generic_selector = StrBuilder::make(_ctx->Allocator_Temp,
"#define builder_print(builder, code) _Generic( (code), \\\n"
);
// Append slots
for(Str type : code_typenames ) {
generic_selector.append_fmt("%S : %S,\\\n", type, fn->Name );
}
generic_selector.append(txt("default: gen_generic_selection_fail \\\n"));
generic_selector.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( builder, (Code)code )"));
// We need to register this as an identifier macro now sot that parsing the source wont break.
register_macro({ txt("builder_print"), MT_Statement, MF_Functional | MF_Allow_As_Identifier });
// We'll be adding this selector after builder_print_fmt
gsel_builder_print = parse_define(generic_selector);
header_builder.append(fn);
}
break;
case CT_Function:
{
CodeFn fn = cast(CodeFn, entry);
if ( fn->Name.is_equal(txt("builder_print_fmt")) ) {
header_builder.append(fn);
// Add the selector right after
header_builder.append(fmt_newline);
header_builder.append(gsel_builder_print);
}
}
break;
case CT_Struct:
{
CodeBody body = cast(CodeBody, entry->Body);
CodeBody new_body = def_body(CT_Struct_Body);
for ( Code body_entry = body.begin(); body_entry != body.end(); ++ body_entry ) switch(body_entry->Type)
{
case CT_Preprocess_If:
{
b32 found = ignore_preprocess_cond_block(txt("GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP"), body_entry, body, new_body );
if (found) break;
new_body.append(body_entry);
}
break;
default:
new_body.append(body_entry);
break;
}
if ( new_body->NumEntries > 0 ) {
entry->Body = new_body;
}
header_builder.append(entry);
}
break;
default:
header_builder.append(entry);
break;
}
#pragma endregion Aux
// Source Content : Reflection and Generation
#pragma region Resolve Dependencies
@ -1559,7 +1607,27 @@ R"(#define <interface_name>( code ) _Generic( (code), \
}
#pragma endregion Resolve Components
// THERE SHOULD BE NO NEW GENERIC CONTAINER DEFINTIONS PAST THIS POINT (It will not have slots for the generic selection generated macros)
#pragma region Resolve Aux
CodeBody parsed_src_builder = parse_file( path_base "auxiliary/builder.cpp" );
CodeBody src_builder = def_body(CT_Global_Body);
for ( Code entry = parsed_src_builder.begin(); entry != parsed_src_builder.end(); ++ entry ) switch( entry->Type )
{
case CT_Function:
{
if (entry->Name.is_equal(txt("builder_print"))) {
entry->Name = cache_str(txt("builder__print"));
}
src_builder.append(entry);
}
break;
default:
src_builder.append(entry);
break;
}
#pragma endregion ResolveAux
// THERE SHOULD BE NO NEW GENERIC CONTAINER DEFINITIONS PAST THIS POINT (It will not have slots for the generic selection generated macros)
CodeBody containers = def_body(CT_Global_Body);
{
containers.append( def_pragma(code(region Containers)));
@ -1611,7 +1679,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
Code rf_array_string_cached = refactor_and_format(array_string_cached);
Code rf_header_end = refactor_and_format(header_end);
Code rf_header_builder = refactor_and_format(header_builder);
Code rf_header_scanner = refactor_and_format( scan_file( path_base "auxillary/scanner.hpp" ));
Code rf_header_scanner = refactor_and_format( scan_file( path_base "auxiliary/scanner.hpp" ));
Code r_src_dep_start = refactor(src_dep_start);
Code r_src_debug = refactor(src_debug);
@ -1644,8 +1712,8 @@ R"(#define <interface_name>( code ) _Generic( (code), \
CodeBody etoktype = gen_etoktype( path_base "enums/ETokType.csv", path_base "enums/AttributeTokens.csv", helper_use_c_definition );
Code rf_etoktype = refactor_and_format(etoktype);
Code rf_src_builder = refactor_and_format( scan_file( path_base "auxillary/builder.cpp" ));
Code rf_src_scanner = refactor_and_format( scan_file( path_base "auxillary/scanner.cpp" ));
Code rf_src_builder = refactor_and_format( src_builder );
Code rf_src_scanner = refactor_and_format( scan_file( path_base "auxiliary/scanner.cpp" ));
#pragma endregion Refactored / Formatted
#pragma region Singleheader

6
gen_segmented/Readme.md
View File

@ -6,15 +6,15 @@
* [docs](../docs/Readme.md)
# Segemented Library Generation
# segmented Library Generation
Create a segemented library using `segemented.cpp`
Create a segmented library using `segmented.cpp`
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>`. The auxillary content (builder & scanner) is given their own files.
Just like the `gen.<hpp/cpp>` they include their components: `dependencies/<dependency_name>.<hpp/cpp>`. The auxiliary content (builder & scanner) is given their own files.
If using the library's provided build scripts:

8
gen_segmented/segmented.cpp
View File

@ -231,7 +231,7 @@ int gen_main()
// gen_builder.hpp
{
Code builder = scan_file( path_base "auxillary/builder.hpp" );
Code builder = scan_file( path_base "auxiliary/builder.hpp" );
Builder header = builder_open( "gen/gen.builder.hpp" );
builder_print_fmt( & header, generation_notice );
@ -245,7 +245,7 @@ int gen_main()
// gen_builder.cpp
{
Code builder = scan_file( path_base "auxillary/builder.cpp" );
Code builder = scan_file( path_base "auxiliary/builder.cpp" );
Builder src = builder_open( "gen/gen.builder.cpp" );
builder_print_fmt( & src, generation_notice );
@ -258,7 +258,7 @@ int gen_main()
// gen_scanner.hpp
{
Code scanner = scan_file( path_base "auxillary/scanner.hpp" );
Code scanner = scan_file( path_base "auxiliary/scanner.hpp" );
Builder header = builder_open( "gen/gen.scanner.hpp" );
builder_print_fmt( & header, generation_notice );
@ -272,7 +272,7 @@ int gen_main()
// gen_scanner.cpp
{
Code scanner = scan_file( path_base "auxillary/scanner.cpp" );
Code scanner = scan_file( path_base "auxiliary/scanner.cpp" );
Builder src = builder_open( "gen/gen.scanner.cpp" );
builder_print_fmt( & src, generation_notice );

8
gen_singleheader/singleheader.cpp
View File

@ -159,10 +159,10 @@ int gen_main()
header.print( header_end );
if ( generate_builder ) {
header.print( scan_file( path_base "auxillary/builder.hpp" ) );
header.print( scan_file( path_base "auxiliary/builder.hpp" ) );
}
if ( generate_scanner ) {
header.print( scan_file( path_base "auxillary/scanner.hpp" ) );
header.print( scan_file( path_base "auxiliary/scanner.hpp" ) );
}
header.print(fmt_newline);
@ -246,11 +246,11 @@ int gen_main()
header.print_fmt( "\n#pragma endregion Interface\n");
if ( generate_builder ) {
header.print( scan_file( path_base "auxillary/builder.cpp" ) );
header.print( scan_file( path_base "auxiliary/builder.cpp" ) );
}
if ( generate_scanner ) {
header.print( scan_file( path_base "auxillary/scanner.cpp" ) );
header.print( scan_file( path_base "auxiliary/scanner.cpp" ) );
}
header.print( fmt_newline);

1
gen_unreal_engine/enums/AttributeTokens.csv
View File

@ -4,4 +4,3 @@ COREUOBJECT_API, COREUOBJECT_API
ENGINE_API, ENGINE_API
GAMEPLAYABILITIES_API, GAMEPLAYABILITIES_API
UMG_API, UMG_API
GASA_API, GASA_API
1 API_Export GEN_API_Export_Code
4 ENGINE_API ENGINE_API
5 GAMEPLAYABILITIES_API GAMEPLAYABILITIES_API
6 UMG_API UMG_API
GASA_API GASA_API

8
gen_unreal_engine/unreal.cpp
View File

@ -337,7 +337,7 @@ int gen_main()
// gen_builder.hpp
{
Code builder = scan_file( path_base "auxillary/builder.hpp" );
Code builder = scan_file( path_base "auxiliary/builder.hpp" );
Builder
header = Builder::open( "gen/gen.builder.hpp" );
@ -356,7 +356,7 @@ int gen_main()
// gen_builder.cpp
{
Code builder = scan_file( path_base "auxillary/builder.cpp" );
Code builder = scan_file( path_base "auxiliary/builder.cpp" );
Builder
src = Builder::open( "gen/gen.builder.cpp" );
@ -374,7 +374,7 @@ int gen_main()
// gen_scanner.hpp
{
Code scanner = scan_file( path_base "auxillary/scanner.hpp" );
Code scanner = scan_file( path_base "auxiliary/scanner.hpp" );
Builder
header = Builder::open( "gen/gen.scanner.hpp" );
@ -393,7 +393,7 @@ int gen_main()
// gen.scanner.cpp
{
Code scanner = scan_file( path_base "auxillary/scanner.cpp" );
Code scanner = scan_file( path_base "auxiliary/scanner.cpp" );
Builder
src = Builder::open( "gen/gen.scanner.cpp" );

6
scripts/.clang-format
View File

@ -146,7 +146,7 @@ QualifierAlignment: Leave
ReferenceAlignment: Left
ReflowComments: true
ReflowComments: false
# RequiresExpressionIndentation: OuterScope
@ -164,7 +164,7 @@ SpaceAfterTemplateKeyword: false
SpaceAroundPointerQualifiers: Default
SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: true
SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: true
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
@ -182,7 +182,7 @@ SpacesInContainerLiterals: false
SpacesInLineCommentPrefix:
Minimum: 1
Maximum: 20
SpacesInParentheses: true
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: c++17

2
scripts/Readme.md
View File

@ -22,7 +22,7 @@ args:
c_lib : Build c11 library (singleheader & segmented)
c_lib_static : Build static c11 library
c_lib_dyn : Buidl dyanmic c11
segemented
segmented
singleheader
unreal
clang

4
scripts/build.ci.ps1
View File

@ -326,7 +326,7 @@ if ( $unreal )
}
# C Library testing
if ( $test -and $false )
if ( $test -and $true )
{
$path_test_c = join-path $path_test c_library
$path_build = join-path $path_test_c build
@ -368,7 +368,7 @@ if ( $test -and $false )
Pop-Location
}
if ( $test -and $true )
if ( $test -and $false )
{
$path_test_c = join-path $path_test c_library
$path_build = join-path $path_test_c build

BIN
scripts/helpers/refactor.exe Normal file
View File

Binary file not shown.

8
scripts/package_release.ps1
View File

@ -106,10 +106,10 @@ Copy-Item -Verbose -Path $path_base\gen.hpp -Destination $path_rel
Copy-Item -Verbose -Path $path_base\gen.cpp -Destination $path_release_content
Copy-Item -Verbose -Path $path_base\gen.dep.hpp -Destination $path_release_content
Copy-Item -Verbose -Path $path_base\gen.dep.cpp -Destination $path_release_content
Copy-Item -Verbose -Path $path_base\auxillary\builder.hpp -Destination $path_release_content\auxillary
Copy-Item -Verbose -Path $path_base\auxillary\builder.cpp -Destination $path_release_content\auxillary
Copy-Item -Verbose -Path $path_base\auxillary\scanner.hpp -Destination $path_release_content\auxillary
Copy-Item -Verbose -Path $path_base\auxillary\scanner.cpp -Destination $path_release_content\auxillary
Copy-Item -Verbose -Path $path_base\auxiliary\builder.hpp -Destination $path_release_content\auxiliary
Copy-Item -Verbose -Path $path_base\auxiliary\builder.cpp -Destination $path_release_content\auxiliary
Copy-Item -Verbose -Path $path_base\auxiliary\scanner.hpp -Destination $path_release_content\auxiliary
Copy-Item -Verbose -Path $path_base\auxiliary\scanner.cpp -Destination $path_release_content\auxiliary
New-Item -ItemType Directory -Force -Path "$path_release_content\components"
New-Item -ItemType Directory -Force -Path "$path_release_content\components\gen"

90
scripts/uncrustify.cfg Normal file
View File

@ -0,0 +1,90 @@
# Basic indentation settings
indent_columns = 4
indent_with_tabs = 1
indent_case_brace = 0
indent_switch_case = 4
indent_col1_comment = true
indent_namespace = true
indent_class = true
indent_extern = true
# Alignment settings
align_assign_span = 1
align_assign_thresh = 0
align_enum_equ_span = 1
align_var_def_span = 1
align_var_def_thresh = 0
align_var_def_inline = true
align_right_cmt_span = 1
align_pp_define_span = 1
align_typedef_span = 1
align_typedef_gap = 0
# Spacing settings
sp_before_square = remove
sp_inside_square = remove
sp_after_comma = force
sp_before_comma = remove
sp_after_cast = remove
sp_inside_paren = remove
sp_inside_fparen = remove
sp_inside_sparen = remove
sp_before_sparen = force
sp_after_operator = remove
sp_after_operator_sym = remove
sp_after_ptr_star = remove
sp_before_ptr_star = force
sp_between_ptr_star = remove
# Code style settings
mod_full_brace_do = force
mod_full_brace_for = force
mod_full_brace_if = force
mod_full_brace_while = force
mod_paren_on_return = remove
mod_full_brace_nl = 1
mod_remove_extra_semicolon = true
# Line breaking
nl_after_brace_open = true
nl_after_brace_close = true
nl_after_return = true
nl_before_case = true
nl_fcall_brace = force
nl_enum_brace = force
nl_struct_brace = force
nl_union_brace = force
nl_if_brace = force
nl_brace_else = force
nl_elseif_brace = force
nl_else_brace = force
nl_else_if = remove
nl_while_brace = force
nl_do_brace = force
nl_for_brace = force
nl_max = 4
nl_after_func_proto = 2
nl_after_func_body = 2
# Template settings
sp_inside_angle = remove
sp_after_angle = force
sp_angle_paren = remove
sp_angle_word = force
# Other settings
cmt_indent_multi = true
cmt_c_group = false
cmt_cpp_group = false
indent_func_call_param = true
indent_func_def_param = true
indent_func_proto_param = true
indent_template_param = true
indent_relative_single_line_comments = true
# Preprocessor settings
pp_indent = remove
pp_space = remove
# Column limit
code_width = 160

2
test/Readme.md
View File

@ -1,3 +1,3 @@
# Test
The implementaiton here has been gutted and will be rewritten...
The implementation here has been gutted and will be rewritten...

6
test/c_library/test.c
View File

@ -1,3 +1,7 @@
#if GEN_INTELLISENSE_DIRECTIVES
#include "../../gen_c_library/gen/gen_singleheader.h"
#endif
#define GEN_IMPLEMENTATION
#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
#include "gen_singleheader.h"
@ -16,7 +20,7 @@ int main()
gen_CodeVar hello_var = gen_parse_variable(code(
char const* hello_gencpp_str = "HELLO GENCPP C11 !";
));
gen_builder_print( & src_hello, (gen_Code)hello_var );
gen_builder_print( & src_hello, hello_var );
gen_builder_write(& src_hello);
gen_CodeBody body = gen_parse_file("gen/hello.c");