mirror of
https://github.com/Ed94/gencpp.git
synced 2024-11-10 02:54:53 -08:00
WIP: Still reworking based on design changes.
This commit is contained in:
parent
9957ef0e7d
commit
2e8d4a3d93
@ -11,3 +11,10 @@ indent_size = 4
|
||||
[*.cpp]
|
||||
indent_style = tab
|
||||
indent_size = 4
|
||||
|
||||
[*.h]
|
||||
indent_style = tab
|
||||
indent_size = 4
|
||||
|
||||
[*.hpp]
|
||||
indent_style = tab
|
||||
|
||||
3
.vscode/settings.json
vendored
3
.vscode/settings.json
vendored
@ -6,6 +6,7 @@
|
||||
"type_traits": "cpp",
|
||||
"utility": "cpp",
|
||||
"xtr1common": "cpp",
|
||||
"xutility": "cpp"
|
||||
"xutility": "cpp",
|
||||
"initializer_list": "cpp"
|
||||
}
|
||||
}
|
||||
183
Readme.md
183
Readme.md
@ -2,18 +2,22 @@
|
||||
|
||||
An attempt at simple staged metaprogramming for c/c++.
|
||||
|
||||
This library is intended for small-to midsize projects that want rapid complation times.
|
||||
for fast debugging.
|
||||
This library is intended for small-to midsize projects.
|
||||
|
||||
### TOC
|
||||
|
||||
* [Notes](#Notes)
|
||||
* [Building](#Notes)
|
||||
|
||||
## Notes
|
||||
|
||||
This project is not minimum feature complete yet.
|
||||
Version 1 will have c and a subset of c++ features available to it.
|
||||
Version 1 will have C and a subset of C++ features available to it.
|
||||
|
||||
I will generate with this library a C99 or 11 variant when Version 1 is complete.
|
||||
A single-header version will also be genrated.
|
||||
A single-header version will also be generated.
|
||||
|
||||
## How it works
|
||||
## Usage
|
||||
|
||||
A metaprogram is built to generate files before the main program is built. We'll term runtime for this program as `gen_time`. The metaprogram's core implementation are within `gen.hpp` and `gen.cpp` in the project directory.
|
||||
|
||||
@ -44,6 +48,66 @@ u32 gen_main()
|
||||
```
|
||||
This is ofc entirely optional and the metaprogram can be quite separated from the runtime in file organization.
|
||||
|
||||
The design a constructive builder of a sort of AST for the code to generate.
|
||||
|
||||
In the current version of the library, constructions are defined with thier paramters in one go.
|
||||
Example:
|
||||
```cpp
|
||||
// Get a Code AST from the CodePool.
|
||||
Code header = make_struct( "Header" );
|
||||
{
|
||||
// Make a struct body.
|
||||
Code body = header.body();
|
||||
|
||||
// Members
|
||||
body->add( def_varaible( uw, "Num") );
|
||||
body->add( def_varaible( uw, "Capacity") );
|
||||
body->add( def_varaible( allocator, "Allocator") );
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
We first define a Code variable called header. We then open a stack frame for header's components.
|
||||
Header will be a struct so we need to define its body, in this case struct acts a pure POD with only variable member symbols.
|
||||
The components are defined first, then the struct body is constructed. Finally the body is provided the def_struct function.
|
||||
|
||||
This will generate the following C code:
|
||||
```cpp
|
||||
struct ArrayHeader
|
||||
{
|
||||
uw Num;
|
||||
uw Capacity;
|
||||
allocator Allocator;
|
||||
};
|
||||
```
|
||||
**Note: The formatting shown here is not how it will look. For your desired formatting its recommended to run a pass through the files with an auto-formatter.**
|
||||
|
||||
## Gen's DSL
|
||||
|
||||
If you don't mind a low amount of macros (29 lines), a DSL may be optionally defined with:
|
||||
```cpp
|
||||
GEN_DEFINE_DSL
|
||||
```
|
||||
|
||||
Using the previous example to show usage:
|
||||
```cpp
|
||||
make( struct, ArrayHeader )
|
||||
{
|
||||
Code
|
||||
body = ArrayHeader.body();
|
||||
body->add_var( uw, Num );
|
||||
body->add_var( uw, Capacity );
|
||||
body->add_var( allocaotr, Allocator );
|
||||
}
|
||||
```
|
||||
|
||||
The `__` represents the `UnusedCode` value constant, of unneeded varaibles.
|
||||
The DSL purposefully has no nested macros, with the follwing exceptions:
|
||||
* `__VA_ARGS__` for parameter expnasion
|
||||
* `VA_NARGS( __VA_ARGS__ )` for determing number of paramters
|
||||
* `txt(Value_)` and `txt_with_length(Value_)` to serialize a value type identifier.
|
||||
|
||||
## Building
|
||||
|
||||
An example of building is provided in the test directory.
|
||||
@ -56,6 +120,113 @@ Both of them build the same source file: `test.cpp`. The only differences betwee
|
||||
This method is setup where all the metaprogram's code are the within the same files as the regular program's code.
|
||||
If in your use case, decide to have exclusive separation or partial separation of the metaprogam's code from the program's code files then your build configuration would need to change to reflect that (specifically the sources).
|
||||
|
||||
## Outline
|
||||
|
||||
### *WHAT IS NOT PROVIDED* :
|
||||
* Macro or template generation : This library is to avoid those,
|
||||
adding support for them adds unnecessary complexity. If you desire define them outside the gen_time scopes.
|
||||
* Expression validation : Execution expressions are defined using the untyped string API. There is no parse API for validating expression (possibly will add in the future)
|
||||
* Complete file parser DSL : This isn't like the unreal header tool. Code injection to file or based off a file contents is not supported by the api. However nothing is stopping you using the library for that purpose.
|
||||
* Modern c++ (STL library) features
|
||||
|
||||
|
||||
### There are four different of construction of Code ast's the library provides:
|
||||
|
||||
* Upfront construction
|
||||
* Incremental construction
|
||||
* Parse construction
|
||||
* Untyped
|
||||
|
||||
### Upfront Construction:
|
||||
All component ASTs must be previously constructed, and provided on creation of the code AST.
|
||||
The construction will fail and return InvalidCode otherwise.
|
||||
|
||||
API:
|
||||
|
||||
* def_forward_decl
|
||||
* def_class
|
||||
* def_global_body
|
||||
* def_proc
|
||||
* def_proc_body
|
||||
* def_namespace
|
||||
* def_namespace_body
|
||||
* def_param
|
||||
* def_params
|
||||
* def_operator
|
||||
* def_specifier
|
||||
* def_specifiers
|
||||
* def_struct
|
||||
* def_struct_body
|
||||
* def_variable
|
||||
* def_type
|
||||
* def_using
|
||||
* def_using_namespace
|
||||
|
||||
### Incremental construction:
|
||||
A Code ast is provided but only completed upfront if all components are provided.
|
||||
Components are then added using the AST API for adding ASTs:
|
||||
|
||||
* code.add( AST* ) // Adds AST with validation.
|
||||
* code.add_entry( AST* ) // Adds AST entry without validation.
|
||||
* code.add_content( AST* ) // Adds AST string content without validation.
|
||||
|
||||
API:
|
||||
|
||||
* make_forward_decl
|
||||
* make_class
|
||||
* make_global_body
|
||||
* make_proc
|
||||
* make_namespace
|
||||
* make_params
|
||||
* make_operator
|
||||
* make_specifiers
|
||||
* make_struct
|
||||
* make_variable
|
||||
* make_type
|
||||
* make_using
|
||||
* make_using_namespace
|
||||
|
||||
### Parse construction:
|
||||
A string provided to the API is parsed for the intended language construct.
|
||||
|
||||
API:
|
||||
|
||||
* parse_forward_decl
|
||||
* parse_class
|
||||
* parse_glboal_body
|
||||
* parse_proc
|
||||
* parse_namespace
|
||||
* parse_params
|
||||
* parse_operator
|
||||
* parse_specifiers
|
||||
* parse_struct
|
||||
* parse_variable
|
||||
* parse_type
|
||||
* parse_using
|
||||
* parse_using
|
||||
|
||||
The parse API treats any execution scope definitions with no validation and are turned into untyped Code ASTs.
|
||||
This includes the assignmetn of variables; due to the library not yet supporting c/c++ expression parsing.
|
||||
|
||||
Untyped constructions:
|
||||
Code ASTs are constructed using unvalidated strings.
|
||||
|
||||
API:
|
||||
|
||||
* untyped_str
|
||||
* untyped_fmt
|
||||
* untyped_token_fmt
|
||||
|
||||
During serialization any untyped Code AST is has its string value directly injected inline of
|
||||
whatever context the content existed as an entry within.
|
||||
Even though thse are not validated from somewhat correct c/c++ syntax or components, it doesn't mean that
|
||||
Untyped code can be added as any component of a Code AST:
|
||||
|
||||
* Untyped code cannot have children, thus there cannot be recursive injection this way.
|
||||
* Untyped code can only be a child of a parent of body AST, or for values of an assignment.
|
||||
|
||||
These restrictions help prevent abuse of untyped code to some extent.
|
||||
|
||||
## Why
|
||||
|
||||
Macros in c/c++ are usually painful to debug, and templates can be unless your on a monsterous IDE (and even then fail often).
|
||||
@ -81,3 +252,5 @@ However, if the code being generated becomes complex, or from a datatable or dat
|
||||
* Make a test suite made up of collections based of the ZPL library templated colllection macros and the memory module.
|
||||
* Generate a single-header library.
|
||||
* Generate a C-supported single-header library.
|
||||
* Remove full ZPL dependency, move into Bloat header/source only what is used.
|
||||
* This library has heavy string allocations, most likely will make a string flyweight for it.
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
#define BLOAT_IMPL
|
||||
#include "Bloat.hpp"
|
||||
|
||||
|
||||
namespace Global
|
||||
{
|
||||
bool ShouldShowDebug = false;
|
||||
@ -40,131 +41,88 @@ namespace Memory
|
||||
}
|
||||
|
||||
|
||||
bool opts_custom_add(opts* options, opts_entry *t, char* b)
|
||||
struct TokEntry
|
||||
{
|
||||
if (t->type != ZPL_OPTS_STRING)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
char const* Str;
|
||||
s32 Length;
|
||||
};
|
||||
|
||||
t->text = string_append_length(t->text, " ", 1);
|
||||
t->text = string_appendc( t->text, b );
|
||||
ZPL_TABLE( static, TokMap, tokmap_, TokEntry )
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
b32 opts_custom_compile(opts *options, int argc, char **argv)
|
||||
sw token_fmt_va( char* buf, uw buf_size, char const* fmt, s32 num_tokens, va_list va )
|
||||
{
|
||||
b32 had_errors = false;
|
||||
char const* buf_begin = buf;
|
||||
sw remaining = buf_size;
|
||||
|
||||
for (int i = 1; i < argc; ++i)
|
||||
TokMap tok_map;
|
||||
{
|
||||
char* arg = argv[i];
|
||||
tokmap_init( & tok_map, g_allocator );
|
||||
|
||||
if (*arg)
|
||||
s32 left = num_tokens;
|
||||
|
||||
while ( left-- )
|
||||
{
|
||||
arg = (char*)str_trim(arg, false);
|
||||
char const* token = va_arg( va, char const* );
|
||||
char const* value = va_arg( va, char const* );
|
||||
|
||||
if (*arg == '-')
|
||||
TokEntry entry
|
||||
{
|
||||
opts_entry* entry = 0;
|
||||
b32 checkln = false;
|
||||
if ( *(arg + 1) == '-')
|
||||
value,
|
||||
zpl_strnlen(value, 128)
|
||||
};
|
||||
|
||||
u32 key = crc32( token, zpl_strnlen(token, 32) );
|
||||
|
||||
tokmap_set( & tok_map, key, entry );
|
||||
}
|
||||
}
|
||||
|
||||
sw result = 0;
|
||||
char current = *fmt;
|
||||
|
||||
while ( current )
|
||||
{
|
||||
checkln = true;
|
||||
++arg;
|
||||
}
|
||||
sw len = 0;
|
||||
|
||||
char *b = arg + 1, *e = b;
|
||||
|
||||
while (char_is_alphanumeric(*e) || *e == '-' || *e == '_') {
|
||||
++e;
|
||||
}
|
||||
|
||||
entry = zpl__opts_find(options, b, (e - b), checkln);
|
||||
|
||||
if (entry)
|
||||
while ( current && current != '{' && remaining )
|
||||
{
|
||||
char *ob = b;
|
||||
b = e;
|
||||
*buf = *fmt;
|
||||
buf++;
|
||||
fmt++;
|
||||
|
||||
/**/
|
||||
if (*e == '=')
|
||||
{
|
||||
if (entry->type == ZPL_OPTS_FLAG)
|
||||
{
|
||||
*e = '\0';
|
||||
zpl__opts_push_error(options, ob, ZPL_OPTS_ERR_EXTRA_VALUE);
|
||||
had_errors = true;
|
||||
|
||||
continue;
|
||||
current = *fmt;
|
||||
}
|
||||
|
||||
b = e = e + 1;
|
||||
}
|
||||
else if (*e == '\0')
|
||||
if ( current == '{' )
|
||||
{
|
||||
char *sp = argv[i+1];
|
||||
char const* scanner = fmt;
|
||||
|
||||
if (sp && *sp != '-' && (array_count(options->positioned) < 1 || entry->type != ZPL_OPTS_FLAG))
|
||||
{
|
||||
if (entry->type == ZPL_OPTS_FLAG)
|
||||
{
|
||||
zpl__opts_push_error(options, b, ZPL_OPTS_ERR_EXTRA_VALUE);
|
||||
had_errors = true;
|
||||
s32 tok_len = 0;
|
||||
|
||||
continue;
|
||||
while ( *scanner != '}' )
|
||||
{
|
||||
tok_len++;
|
||||
scanner++;
|
||||
}
|
||||
|
||||
arg = sp;
|
||||
b = e = sp;
|
||||
++i;
|
||||
}
|
||||
else
|
||||
char const* token = fmt;
|
||||
|
||||
s32 key = crc32( token, tok_len );
|
||||
TokEntry value = * tokmap_get( & tok_map, key );
|
||||
s32 left = value.Length;
|
||||
|
||||
while ( left-- )
|
||||
{
|
||||
if (entry->type != ZPL_OPTS_FLAG)
|
||||
{
|
||||
zpl__opts_push_error(options, ob, ZPL_OPTS_ERR_MISSING_VALUE);
|
||||
had_errors = true;
|
||||
continue;
|
||||
*buf = *value.Str;
|
||||
buf++;
|
||||
value.Str++;
|
||||
}
|
||||
|
||||
entry->met = true;
|
||||
|
||||
continue;
|
||||
scanner++;
|
||||
fmt = scanner;
|
||||
current = *fmt;
|
||||
}
|
||||
}
|
||||
|
||||
e = (char *)str_control_skip(e, '\0');
|
||||
zpl__opts_set_value(options, entry, b);
|
||||
|
||||
if ( (i + 1) < argc )
|
||||
{
|
||||
for ( b = argv[i + 1]; i < argc && b[0] != '-'; i++, b = argv[i + 1] )
|
||||
{
|
||||
opts_custom_add(options, entry, b );
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
zpl__opts_push_error(options, b, ZPL_OPTS_ERR_OPTION);
|
||||
had_errors = true;
|
||||
}
|
||||
}
|
||||
else if (array_count(options->positioned))
|
||||
{
|
||||
opts_entry *l = array_back(options->positioned);
|
||||
array_pop(options->positioned);
|
||||
zpl__opts_set_value(options, l, arg);
|
||||
}
|
||||
else
|
||||
{
|
||||
zpl__opts_push_error(options, arg, ZPL_OPTS_ERR_VALUE);
|
||||
had_errors = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return !had_errors;
|
||||
return result;
|
||||
}
|
||||
|
||||
@ -1,35 +1,15 @@
|
||||
/*
|
||||
BLOAT.
|
||||
|
||||
This contians all definitions not directly related to the project.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#if defined(__GNUC__) || defined(__clang__) || 1
|
||||
// Supports 0-10 arguments
|
||||
#define VA_NARGS_IMPL( _0, \
|
||||
_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
|
||||
_11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \
|
||||
_21, _22, _23, _24, _25, _26, _27, _28, _29, _30, \
|
||||
N, ...) N
|
||||
// ## deletes preceding comma if _VA_ARGS__ is empty (GCC, Clang)
|
||||
#define VA_NARGS(...) VA_NARGS_IMPL(_, ## __VA_ARGS__, \
|
||||
30, 29, 28, 27, 26, 25, 24, 23, 22, 21, \
|
||||
20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \
|
||||
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, \
|
||||
0)
|
||||
|
||||
#else
|
||||
// Supports 1-10 arguments
|
||||
#define VA_NARGS_IMPL(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
|
||||
#define VA_NARGS(...) VA_NARGS_IMPL(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
|
||||
#endif
|
||||
|
||||
#define VA_NARGS2(...) ((int)(sizeof((int[]){ __VA_ARGS__ })/sizeof(int)))
|
||||
|
||||
#ifdef BLOAT_IMPL
|
||||
# define ZPL_IMPLEMENTATION
|
||||
#endif
|
||||
|
||||
|
||||
#pragma region ZPL INCLUDE
|
||||
#if __clang__
|
||||
# pragma clang diagnostic push
|
||||
@ -47,7 +27,7 @@
|
||||
// # define ZPL_MODULE_REGEX
|
||||
// # define ZPL_MODULE_EVENT
|
||||
// # define ZPL_MODULE_DLL
|
||||
# define ZPL_MODULE_OPTS
|
||||
// # define ZPL_MODULE_OPTS
|
||||
// # define ZPL_MODULE_PROCESS
|
||||
// # define ZPL_MODULE_MAT
|
||||
// # define ZPL_MODULE_THREADING
|
||||
@ -61,7 +41,6 @@
|
||||
#pragma endregion ZPL INCLUDE
|
||||
|
||||
|
||||
|
||||
#if __clang__
|
||||
# pragma clang diagnostic ignored "-Wunused-const-variable"
|
||||
# pragma clang diagnostic ignored "-Wswitch"
|
||||
@ -70,16 +49,41 @@
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(__GNUC__) || defined(__clang__) || 1
|
||||
// Supports 0-10 arguments
|
||||
#define VA_NARGS_IMPL( _0, \
|
||||
_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
|
||||
_11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \
|
||||
_21, _22, _23, _24, _25, _26, _27, _28, _29, _30, \
|
||||
_31, _32, _33, _34, _35, _36, _37, _38, _39, _40, \
|
||||
_41, _42, _43, _44, _45, _46, _47, _48, _49, _50, \
|
||||
N, ...) N
|
||||
// ## deletes preceding comma if _VA_ARGS__ is empty (GCC, Clang)
|
||||
#define VA_NARGS(...) VA_NARGS_IMPL(_, ## __VA_ARGS__, \
|
||||
50, 49, 48, 47, 46, 45, 44, 43, 42, 41, \
|
||||
40, 39, 38, 37, 36, 35, 34, 33, 32, 31, \
|
||||
30, 29, 28, 27, 26, 25, 24, 23, 22, 21, \
|
||||
20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \
|
||||
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, \
|
||||
0)
|
||||
#else
|
||||
// Supports 1-10 arguments
|
||||
#define VA_NARGS_IMPL(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
|
||||
#define VA_NARGS(...) VA_NARGS_IMPL(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
|
||||
#endif
|
||||
|
||||
#define bit( Value_ ) ( 1 << Value_ )
|
||||
#define bitfield_is_equal( Field_, Mask_ ) ( ( Mask_ & Field_ ) == Mask_ )
|
||||
#define ct constexpr
|
||||
#define forceinline ZPL_ALWAYS_INLINE
|
||||
#define print_nl( _) zpl_printf("\n")
|
||||
#define ccast( Type_, Value_ ) * const_cast< Type_* >( & Value_ )
|
||||
#define scast( Type_, Value_ ) static_cast< Type_ >( Value_ )
|
||||
#define rcast( Type_, Value_ ) reinterpret_cast< Type_ >( Value_ )
|
||||
#define pcast( Type_, Value_ ) ( * (Type_*)( & Value_ ) )
|
||||
#define txt( Value_ ) ZPL_STRINGIFY_EX( Value_ )
|
||||
#define txt_impl( Value_ ) #Value_
|
||||
#define txt( Value_ ) txt_impl( Value_ )
|
||||
#define txt_with_length( Value_ ) txt_impl( Value_ ), sizeof( txt_impl( Value_) )
|
||||
|
||||
#define do_once() \
|
||||
do \
|
||||
@ -90,7 +94,7 @@ do \
|
||||
return; \
|
||||
Done = true; \
|
||||
} \
|
||||
while(0) \
|
||||
while(0)
|
||||
|
||||
#define do_once_start \
|
||||
do \
|
||||
@ -105,14 +109,8 @@ do \
|
||||
} \
|
||||
while(0);
|
||||
|
||||
|
||||
using Line = char*;
|
||||
using Array_Line = array( Line );
|
||||
|
||||
|
||||
ct char const* Msg_Invalid_Value = "INVALID VALUE PROVIDED";
|
||||
|
||||
|
||||
namespace Global
|
||||
{
|
||||
extern bool ShouldShowDebug;
|
||||
@ -124,6 +122,8 @@ namespace Memory
|
||||
|
||||
extern arena Global_Arena;
|
||||
// #define g_allocator arena_allocator( & Memory::Global_Arena)
|
||||
|
||||
// Heap allocator is being used for now to isolate errors from being memory related (tech debt till ready to address)
|
||||
#define g_allocator heap()
|
||||
|
||||
void setup();
|
||||
@ -131,9 +131,19 @@ namespace Memory
|
||||
void cleanup();
|
||||
}
|
||||
|
||||
// Had to be made to support multiple sub-arguments per "opt" argument.
|
||||
b32 opts_custom_compile(opts *options, int argc, char **argv);
|
||||
inline
|
||||
char const* token_fmt( char const* fmt, sw num_tokens, ... )
|
||||
{
|
||||
local_persist thread_local
|
||||
char buf[ZPL_PRINTF_MAXLEN] = { 0 };
|
||||
|
||||
va_list va;
|
||||
va_start(va, fmt);
|
||||
token_fmt_va(buf, ZPL_PRINTF_MAXLEN, fmt, num_tokens, va);
|
||||
va_end(va);
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
||||
inline
|
||||
sw log_fmt(char const *fmt, ...)
|
||||
@ -152,7 +162,7 @@ sw log_fmt(char const *fmt, ...)
|
||||
}
|
||||
|
||||
inline
|
||||
void fatal(char const *fmt, ...)
|
||||
sw fatal(char const *fmt, ...)
|
||||
{
|
||||
local_persist thread_local
|
||||
char buf[ZPL_PRINTF_MAXLEN] = { 0 };
|
||||
@ -165,11 +175,13 @@ void fatal(char const *fmt, ...)
|
||||
va_end(va);
|
||||
|
||||
assert_crash(buf);
|
||||
return -1;
|
||||
#else
|
||||
va_start(va, fmt);
|
||||
zpl_printf_err_va( fmt, va);
|
||||
va_end(va);
|
||||
|
||||
zpl_exit(1);
|
||||
return -1;
|
||||
#endif
|
||||
}
|
||||
|
||||
18
project/Bloat.undef.hpp
Normal file
18
project/Bloat.undef.hpp
Normal file
@ -0,0 +1,18 @@
|
||||
/*
|
||||
Remvoe any macro definitions related to the Bloat header.
|
||||
*/
|
||||
|
||||
#undef bit
|
||||
#undef bitfield_is_equal
|
||||
#undef ct
|
||||
#undef forceinline
|
||||
#undef print_nl
|
||||
#undef scast
|
||||
#undef rcast
|
||||
#undef pcast
|
||||
#undef txt
|
||||
|
||||
#undef do_once
|
||||
#undef do_once_start
|
||||
#undef do_once_end
|
||||
|
||||
724
project/gen.cpp
724
project/gen.cpp
File diff suppressed because it is too large
Load Diff
624
project/gen.hpp
624
project/gen.hpp
@ -1,105 +1,163 @@
|
||||
/*
|
||||
gencpp: A simple staged metaprogramming library for C++.
|
||||
|
||||
This library is intended for small-to midsize projects that want rapid complation times
|
||||
for fast debugging.
|
||||
This library is intended for small-to midsize projects.
|
||||
|
||||
AST type checking supports only a small subset of c++.
|
||||
See the 'ECode' namespace and 'gen API' region to see what is supported.
|
||||
|
||||
There is no support for accessability fields in structs.
|
||||
WHAT IS NOT PROVIDED:
|
||||
* Macro or template generation : This library is to avoid those, adding support for them
|
||||
adds unnecessary complexity.
|
||||
If you desire define them outside the gen_time scopes.
|
||||
|
||||
* Modern c++ (STL library) features :
|
||||
* Expression validation : Execution expressions are defined using the untyped string API.
|
||||
: There is no parse API for validating expression (possibly will add in the future)
|
||||
|
||||
* Complete file parser DSL : This isn't like the unreal header tool.
|
||||
Code injection to file or based off a file contents is not supported by the api.
|
||||
However nothing is stopping you using the library for that purpose.
|
||||
|
||||
|
||||
There are four different of construction of Code ast's the library provides:
|
||||
* Upfront construction
|
||||
* Incremental construction
|
||||
* Parse construction
|
||||
* Untyped
|
||||
|
||||
Upfront Construction:
|
||||
All component ASTs must be previously constructed, and provided on creation of the code AST.
|
||||
The construction will fail and return InvalidCode otherwise.
|
||||
|
||||
API:
|
||||
* def_forward_decl
|
||||
* def_class
|
||||
* def_global_body
|
||||
* def_proc
|
||||
* def_proc_body
|
||||
* def_namespace
|
||||
* def_namespace_body
|
||||
* def_param
|
||||
* def_params
|
||||
* def_operator
|
||||
* def_specifier
|
||||
* def_specifiers
|
||||
* def_struct
|
||||
* def_struct_body
|
||||
* def_variable
|
||||
* def_type
|
||||
* def_using
|
||||
* def_using_namespace
|
||||
|
||||
Incremental construction:
|
||||
A Code ast is provided but only completed upfront if all components are provided.
|
||||
Components are then added using the AST API for adding ASTs:
|
||||
* code.add( AST* ) // Adds AST with validation.
|
||||
* code.add_entry( AST* ) // Adds AST entry without validation.
|
||||
* code.add_content( AST* ) // Adds AST string content without validation.
|
||||
|
||||
API:
|
||||
* make_forward_decl
|
||||
* make_class
|
||||
* make_global_body
|
||||
* make_proc
|
||||
* make_namespace
|
||||
* make_params
|
||||
* make_operator
|
||||
* make_specifiers
|
||||
* make_struct
|
||||
* make_variable
|
||||
* make_type
|
||||
* make_using
|
||||
* make_using_namespace
|
||||
|
||||
Parse construction:
|
||||
A string provided to the API is parsed for the intended language construct.
|
||||
|
||||
API:
|
||||
* parse_forward_decl
|
||||
* parse_class
|
||||
* parse_glboal_body
|
||||
* parse_proc
|
||||
* parse_namespace
|
||||
* parse_params
|
||||
* parse_operator
|
||||
* parse_specifiers
|
||||
* parse_struct
|
||||
* parse_variable
|
||||
* parse_type
|
||||
* parse_using
|
||||
* parse_using
|
||||
|
||||
The parse API treats any execution scope definitions with no validation and are turned into untyped Code ASTs.
|
||||
This includes the assignmetn of variables; due to the library not yet supporting c/c++ expression parsing.
|
||||
|
||||
Untyped constructions:
|
||||
Code ASTs are constructed using unvalidated strings.
|
||||
|
||||
API:
|
||||
* untyped_str
|
||||
* untyped_fmt
|
||||
* untyped_token_fmt
|
||||
|
||||
During serialization any untyped Code AST is has its string value directly injected inline of
|
||||
whatever context the content existed as an entry within.
|
||||
Even though thse are not validated from somewhat correct c/c++ syntax or components, it doesn't mean that
|
||||
Untyped code can be added as any component of a Code AST:
|
||||
* Untyped code cannot have children, thus there cannot be recursive injection this way.
|
||||
* Untyped code can only be a child of a parent of body AST, or for values of an assignment.
|
||||
These restrictions help prevent abuse of untyped code to some extent.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "Bloat.hpp"
|
||||
|
||||
// Defined by default.
|
||||
|
||||
#define GEN_ENABLE_READONLY_AST
|
||||
// #define GEN_DEFINE_DSL
|
||||
|
||||
// Temporarily here for debugging purposes.
|
||||
#define gen_time
|
||||
#define GEN_ENFORCE_READONLY_AST
|
||||
// #define GEN_DEFINE_DSL
|
||||
#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
|
||||
// #define GEN_BAN_CPP_TEMPLATES
|
||||
// #define GEN_USE_FATAL
|
||||
|
||||
#ifdef gen_time
|
||||
namespace gen
|
||||
{
|
||||
#if 0
|
||||
ct sw ColumnLimit = 256;
|
||||
ct sw MaxLines = kilobytes(256);
|
||||
using LogFailType = sw(*)(char const*, ...);
|
||||
|
||||
using LineStr = char[ColumnLimit];
|
||||
#endif
|
||||
#ifdef GEN_BAN_CPP_TEMPLATES
|
||||
#define template static_assert("Templates are banned within gen_time scope blocks")
|
||||
#endif
|
||||
|
||||
// Specifier Type
|
||||
enum Specifier : u8
|
||||
{
|
||||
Alignas, // alignas(#)
|
||||
Constexpr, // constexpr
|
||||
Inline, // inline
|
||||
#ifdef GEN_USE_FATAL
|
||||
ct LogFailType log_failure = fatal;
|
||||
#else
|
||||
ct LogFailType log_failure = log_fmt;
|
||||
#endif
|
||||
|
||||
C_Linkage, // extern "C"
|
||||
API_Import, // Vendor specific way dynamic import symbol
|
||||
API_Export, // Vendor specific way to dynamic export
|
||||
External_Linkage, // extern
|
||||
Internal_Linkage, // static (within unit file)
|
||||
Static_Member, // static (within sturct/class)
|
||||
Local_Persist, // static (within function)
|
||||
Thread_Local, // thread_local
|
||||
|
||||
Num_Specifiers
|
||||
};
|
||||
|
||||
// Specifier to string
|
||||
inline
|
||||
char const* specifier_str( Specifier specifier )
|
||||
{
|
||||
static
|
||||
char const* lookup[ Num_Specifiers ] = {
|
||||
"alignas",
|
||||
"constexpr",
|
||||
"inline",
|
||||
|
||||
"extern \"C\"",
|
||||
#if defined(ZPL_SYSTEM_WINDOWS)
|
||||
"__declspec(dllexport)",
|
||||
"__declspec(dllimport)",
|
||||
#elif defined(ZPL_SYSTEM_MACOS)
|
||||
"__attribute__ ((visibility ("default")))",
|
||||
"__attribute__ ((visibility ("default")))",
|
||||
#endif
|
||||
"extern",
|
||||
"static",
|
||||
"static",
|
||||
"static",
|
||||
"thread_local"
|
||||
};
|
||||
|
||||
return lookup[ specifier ];
|
||||
}
|
||||
|
||||
// Code Type
|
||||
namespace ECode
|
||||
{
|
||||
enum Type : u8
|
||||
{
|
||||
Invalid,
|
||||
|
||||
Untyped, // User provided raw string.
|
||||
|
||||
Decl_Function, // Forward a function
|
||||
Decl_Type, // Forward a type.
|
||||
Invalid, // Used only with improperly created Code nodes
|
||||
Untyped, // User provided raw string
|
||||
Decl_Function, // <specifier> <type> <name> ( <params> )
|
||||
Decl_Type, // <type> <name>;
|
||||
Function, // <type> <name>( <parameters> )
|
||||
Function_Body, // { <body> }
|
||||
Namespace,
|
||||
Namespace_Body,
|
||||
Parameters, // Used with functions.
|
||||
Specifiers,
|
||||
Struct,
|
||||
Struct_Body,
|
||||
Variable,
|
||||
Typedef,
|
||||
Typename,
|
||||
Using,
|
||||
Namespace, // Define a namespace
|
||||
Namespace_Body, // { <body> }
|
||||
Parameters, // <type> <param> ...
|
||||
Specifiers, // Used with functions, structs, variables
|
||||
Struct, // struct <specifier> <name> <parent>
|
||||
Struct_Body, // {<body> }
|
||||
Variable, // <type> <name>
|
||||
Typedef, // typedef <type> <alias>
|
||||
Typename, // Typename, used with other types
|
||||
Using, // using <name> = <type>
|
||||
Unit, // Represents a file.
|
||||
|
||||
Num_Types
|
||||
};
|
||||
@ -110,11 +168,9 @@ namespace gen
|
||||
static
|
||||
char const* lookup[Num_Types] = {
|
||||
"Invalid",
|
||||
|
||||
"Untyped",
|
||||
|
||||
"Decl_Function",
|
||||
"Decl_type",
|
||||
"Decl_Type",
|
||||
"Function",
|
||||
"Function_Body",
|
||||
"Namespace",
|
||||
@ -126,7 +182,8 @@ namespace gen
|
||||
"Variable",
|
||||
"Typedef",
|
||||
"Typename",
|
||||
"using"
|
||||
"Using",
|
||||
"Unit",
|
||||
};
|
||||
|
||||
return lookup[ type ];
|
||||
@ -134,6 +191,116 @@ namespace gen
|
||||
}
|
||||
using CodeT = ECode::Type;
|
||||
|
||||
namespace EOperator
|
||||
{
|
||||
enum Type : u8
|
||||
{
|
||||
Add,
|
||||
Subtract,
|
||||
Multiply,
|
||||
Divide,
|
||||
Modulo,
|
||||
|
||||
Num_Ops
|
||||
};
|
||||
|
||||
inline
|
||||
char const* str( Type op )
|
||||
{
|
||||
static
|
||||
char const* lookup[ Num_Ops ] = {
|
||||
"+",
|
||||
"-",
|
||||
"*",
|
||||
"/",
|
||||
};
|
||||
|
||||
return lookup[ op ];
|
||||
}
|
||||
}
|
||||
using OperatorT = EOperator::Type;
|
||||
|
||||
namespace ESpecifier
|
||||
{
|
||||
enum Type : u8
|
||||
{
|
||||
Attribute, // [ <attributes ]
|
||||
Alignas, // alignas(#)
|
||||
Constexpr, // constexpr
|
||||
Const, // const
|
||||
Inline, // inline
|
||||
RValue, //
|
||||
|
||||
C_Linkage, // extern "C"
|
||||
API_Import, // Vendor specific way dynamic import symbol
|
||||
API_Export, // Vendor specific way to dynamic export
|
||||
External_Linkage, // extern
|
||||
Internal_Linkage, // static (within unit file)
|
||||
Static_Member, // static (within sturct/class)
|
||||
Local_Persist, // static (within function)
|
||||
Thread_Local, // thread_local
|
||||
|
||||
Num_Specifiers,
|
||||
Invalid
|
||||
};
|
||||
|
||||
// Specifier to string
|
||||
inline
|
||||
char const* to_str( Type specifier )
|
||||
{
|
||||
static
|
||||
char const* lookup[ Num_Specifiers ] = {
|
||||
"alignas",
|
||||
"constexpr",
|
||||
"const",
|
||||
"inline",
|
||||
|
||||
"extern \"C\"",
|
||||
|
||||
#if defined(ZPL_SYSTEM_WINDOWS) && 0// API_Import and API_Export strings
|
||||
"__declspec(dllexport)",
|
||||
"__declspec(dllimport)",
|
||||
#elif defined(ZPL_SYSTEM_MACOS) || 1
|
||||
"__attribute__ ((visibility (\"default\")))",
|
||||
"__attribute__ ((visibility (\"default\")))",
|
||||
#endif
|
||||
|
||||
"extern",
|
||||
"static",
|
||||
"static",
|
||||
"static",
|
||||
"thread_local"
|
||||
};
|
||||
|
||||
return lookup[ specifier ];
|
||||
}
|
||||
|
||||
Type to_type( char const* str, s32 length )
|
||||
{
|
||||
static
|
||||
u32 keymap[ Num_Specifiers ];
|
||||
do_once_start
|
||||
for ( u32 index = 0; index < Num_Specifiers; index++ )
|
||||
{
|
||||
char const* enum_str = to_str( (Type)index );
|
||||
|
||||
keymap[index] = crc32( enum_str, strnlen(enum_str, 42) );
|
||||
}
|
||||
do_once_end
|
||||
|
||||
u32 hash = crc32(str, length );
|
||||
|
||||
for ( u32 index = 0; index < Num_Specifiers; index++ )
|
||||
{
|
||||
if ( keymap[index] == hash )
|
||||
return (Type)index;
|
||||
}
|
||||
|
||||
return Invalid;
|
||||
}
|
||||
}
|
||||
using SpecifierT = ESpecifier::Type;
|
||||
|
||||
// TODO: If perf needs it, convert layout an SOA format.
|
||||
/*
|
||||
Simple AST POD with functionality to seralize into C++ syntax.
|
||||
@ -154,38 +321,40 @@ namespace gen
|
||||
}
|
||||
|
||||
forceinline
|
||||
bool has_entries()
|
||||
bool has_entries() const
|
||||
{
|
||||
static bool lookup[ ECode::Num_Types] = {
|
||||
false, // Invalid
|
||||
false, // Unused
|
||||
false, // Untyped
|
||||
true, // Decl_Type
|
||||
true, // Decl_Function
|
||||
true, // Parameter
|
||||
true, // Struct
|
||||
true, // Decl_Type
|
||||
true, // Function
|
||||
false, // Specifier
|
||||
true, // Parameters
|
||||
false, // Specifies
|
||||
true, // Struct
|
||||
true, // Struct_Body
|
||||
true, // Variable
|
||||
true, // Typedef
|
||||
true, // Typename
|
||||
true, // Using
|
||||
};
|
||||
|
||||
return lookup[Type];
|
||||
}
|
||||
|
||||
forceinline
|
||||
bool is_invalid()
|
||||
bool is_invalid() const
|
||||
{
|
||||
return Type != ECode::Invalid;
|
||||
}
|
||||
|
||||
forceinline
|
||||
char const* type_str()
|
||||
char const* type_str() const
|
||||
{
|
||||
return ECode::str( Type );
|
||||
}
|
||||
|
||||
string to_string();
|
||||
string to_string() const;
|
||||
|
||||
#pragma endregion Member API
|
||||
|
||||
@ -215,7 +384,7 @@ namespace gen
|
||||
/*
|
||||
AST* typedef as to not constantly have to add the '*' as this is written often..
|
||||
|
||||
If GEN_ENABLE_READONLY_AST is defined, readonly assertions will be done on any member dreference,
|
||||
If GEN_ENFORCE_READONLY_AST is defined, readonly assertions will be done on any member dreference,
|
||||
and the 'gen API' related functions. will set their created ASTs to readonly before returning.
|
||||
|
||||
Casting to AST* will bypass.
|
||||
@ -224,13 +393,32 @@ namespace gen
|
||||
{
|
||||
AST* ast;
|
||||
|
||||
forceinline
|
||||
operator bool()
|
||||
Code body()
|
||||
{
|
||||
return ast->is_invalid();
|
||||
if ( ast->Type == ECode::Invalid )
|
||||
fatal("Code::body: Type is invalid, cannot get");
|
||||
|
||||
if ( ast->Entries == nullptr || array_count(ast->Entries) == 0 )
|
||||
fatal("Code::body: Entries of ast not properly setup.");
|
||||
|
||||
return pcast( Code, ast->Entries[0]);
|
||||
}
|
||||
|
||||
bool operator ==( Code other )
|
||||
forceinline
|
||||
void lock()
|
||||
{
|
||||
#ifdef GEN_ENFORCE_READONLY_AST
|
||||
ast->Readonly = true;
|
||||
#endif
|
||||
}
|
||||
|
||||
forceinline
|
||||
operator bool() const
|
||||
{
|
||||
return ast && ast->is_invalid();
|
||||
}
|
||||
|
||||
bool operator ==( Code other ) const
|
||||
{
|
||||
return ast == other.ast;
|
||||
}
|
||||
@ -247,28 +435,27 @@ namespace gen
|
||||
return *this;
|
||||
}
|
||||
|
||||
#ifdef GEN_ENABLE_READONLY_AST
|
||||
forceinline
|
||||
AST* operator ->()
|
||||
{
|
||||
#ifdef GEN_ENFORCE_READONLY_AST
|
||||
if ( ast == nullptr )
|
||||
fatal("Attempt to dereference a nullptr!");
|
||||
|
||||
if ( ast->Readonly )
|
||||
fatal("Attempted to access a member from a readonly ast!");
|
||||
#endif
|
||||
|
||||
return ast;
|
||||
}
|
||||
|
||||
Code& operator *() = delete;
|
||||
#endif
|
||||
};
|
||||
static_assert( sizeof(Code) == sizeof(AST*), "ERROR: Code is not POD" );
|
||||
|
||||
// Used when the its desired when omission is allowed in a definition.
|
||||
ct Code UnusedCode = { nullptr };
|
||||
|
||||
// Used internally for the most part to identify invaidly generated code.
|
||||
ct CodePOD InvalidCode = { ECode::Invalid, false, nullptr, nullptr, nullptr, { nullptr } };
|
||||
extern const Code InvalidCode;
|
||||
|
||||
/*
|
||||
Type registy: Used to store Typename ASTs. Types are registered by their string literal value.
|
||||
@ -277,7 +464,7 @@ namespace gen
|
||||
Strings made with the Typename ASTs are stored in thier own arena allocator.
|
||||
TODO: Implement and replace usage of def_type.
|
||||
*/
|
||||
// ZPL_TABLE_DECLARE( ZPL_EXTERN, TypeRegistry, type_reg_, Code );
|
||||
ZPL_TABLE_DECLARE( ZPL_EXTERN, TypeRegistry, type_reg_, Code );
|
||||
|
||||
#pragma region gen API
|
||||
/*
|
||||
@ -286,17 +473,18 @@ namespace gen
|
||||
*/
|
||||
void init();
|
||||
|
||||
#pragma region Upfront
|
||||
/*
|
||||
Foward Declare a type:
|
||||
<specifiers> <type> <name>;
|
||||
*/
|
||||
Code decl_type( char const* name, Code type, Code specifiers = UnusedCode );
|
||||
Code def_fwd_type( Code type, char const* name, Code specifiers = UnusedCode );
|
||||
|
||||
/*
|
||||
Foward Declare a function:
|
||||
<specifiers> <name> ( <params> );
|
||||
*/
|
||||
Code decl_fn( char const* name
|
||||
Code def_fwd_proc( char const* name
|
||||
, Code specifiers
|
||||
, Code params
|
||||
, Code ret_type
|
||||
@ -305,8 +493,10 @@ namespace gen
|
||||
/*
|
||||
Define an expression:
|
||||
< c/c++ expression >
|
||||
|
||||
TODO: Evalute if you want to validiate at the execution layer during gen_time (dosen't seem necessary)
|
||||
*/
|
||||
Code def_expression( Code value );
|
||||
// Code def_expression( Code value );
|
||||
|
||||
/*
|
||||
Define a function:
|
||||
@ -315,7 +505,7 @@ namespace gen
|
||||
<body>
|
||||
}
|
||||
*/
|
||||
Code def_function( char const* name
|
||||
Code def_proc( char const* name
|
||||
, Code specifiers
|
||||
, Code params
|
||||
, Code ret_type
|
||||
@ -330,9 +520,10 @@ namespace gen
|
||||
...
|
||||
}
|
||||
|
||||
Each entry is provided an empty line separation.
|
||||
There will be an empty line separation between entires
|
||||
*/
|
||||
Code def_function_body( s32 num, ... );
|
||||
Code def_proc_body( s32 num, ... );
|
||||
Code def_proc_body( s32 num, Code* codes );
|
||||
|
||||
/*
|
||||
Define a namespace;
|
||||
@ -351,7 +542,7 @@ namespace gen
|
||||
...
|
||||
}
|
||||
|
||||
Each entry is provided an empty line separation.
|
||||
There will be an empty line separation between entires
|
||||
*/
|
||||
Code def_namespace_body( s32 num, ... );
|
||||
|
||||
@ -359,12 +550,23 @@ namespace gen
|
||||
Define a set of parameters for a function:
|
||||
<name> <type>, ...
|
||||
*/
|
||||
Code def_parameters( s32 num, ... );
|
||||
Code def_params( s32 num, ... );
|
||||
Code def_params( s32 num, char const** params );
|
||||
|
||||
/*
|
||||
Define an operator definition.
|
||||
*/
|
||||
Code def_operator( OperatorT op, Code specifiers, Code params, Code ret_type, Code body );
|
||||
|
||||
/*
|
||||
Define a set of specifiers for a function, struct, type, or varaible
|
||||
|
||||
Note:
|
||||
If alignas is specified the procedure expects the next argument to be the alignment value.
|
||||
If attribute is specified the procedure expects the next argument to be its content as a string.
|
||||
*/
|
||||
Code def_specifiers( s32 num , ... );
|
||||
Code def_specifiers( s32 num, SpecifierT* specs );
|
||||
|
||||
/*
|
||||
Define a struct:
|
||||
@ -383,19 +585,26 @@ namespace gen
|
||||
...
|
||||
}
|
||||
|
||||
Each entry is provided an empty line separation.
|
||||
There will be an empty line separation between entires
|
||||
*/
|
||||
Code def_struct_body( s32 num, ... );
|
||||
Code def_struct_body( s32 num, Code* codes );
|
||||
|
||||
/*
|
||||
Define a variable:
|
||||
<specifiers> <type> <name> = <value>;
|
||||
*/
|
||||
Code def_variable( char const* name, Code type, Code value = UnusedCode, Code specifiers = UnusedCode );
|
||||
Code def_variable( Code type, char const* name, Code value = UnusedCode, Code specifiers = UnusedCode );
|
||||
|
||||
/*
|
||||
Define a type AST value.
|
||||
Useless by itself, its intended to be used in conjunction with
|
||||
Define a typename AST value.
|
||||
Useless by itself, its intended to be used in conjunction with other Code.
|
||||
|
||||
Planned - Not yet Implemented:
|
||||
Typename Codes are not held in the CodePool, instead they are stored in a
|
||||
type registry (hastable where the key is a crc hash of the name string).
|
||||
|
||||
If a key exists the existing code value will be provided.
|
||||
*/
|
||||
Code def_type( char const* name );
|
||||
|
||||
@ -412,7 +621,88 @@ namespace gen
|
||||
Can only be used in either a
|
||||
*/
|
||||
Code def_using_namespace( char const* name );
|
||||
#pragma endregion Upfront
|
||||
|
||||
#pragma region Incremental
|
||||
/*
|
||||
Provides an incomplete procedure AST but sets the intended type.
|
||||
Any adds will be type checked.
|
||||
|
||||
Body is automatically made. Use body() to retrieve.
|
||||
*/
|
||||
Code make_proc( char const* name
|
||||
, Code specifiers = UnusedCode
|
||||
, Code params = UnusedCode
|
||||
, Code ret_type = UnusedCode
|
||||
);
|
||||
|
||||
/*
|
||||
Provides an incomplete struct AST but sets the intended type.
|
||||
Any adds will be type checked.
|
||||
|
||||
Body is automatically made. Use body() to retrieve.
|
||||
*/
|
||||
Code make_struct( char const* name, Code parent = UnusedCode, Code specifiers = UnusedCode );
|
||||
|
||||
/*
|
||||
Creates a unit file.
|
||||
|
||||
These represent an encapsulation of a generated file
|
||||
Used this if you need to pass around a group of Code entires at file scope level.
|
||||
|
||||
The name provided is the name of the file.
|
||||
*/
|
||||
Code make_file_body( char const* name );
|
||||
#pragma endregion Incremental
|
||||
|
||||
/*
|
||||
*/
|
||||
Code parse_variable( char const* var_def, s32 length );
|
||||
|
||||
/*
|
||||
*/
|
||||
Code parse_using( char const* using_def, s32 length );
|
||||
|
||||
/*
|
||||
|
||||
*/
|
||||
Code parse_operator( char const* operator_def, s32 length );
|
||||
|
||||
/*
|
||||
Define a procedure by parsing a string.
|
||||
|
||||
Note: This parser only supports the language features the library supports
|
||||
Any other features used and the lex or parse operation will fail.
|
||||
|
||||
This is not a full-on c/c++ parser, it literally only grabs
|
||||
what it needs to reconstruct the Code AST for seralization in the
|
||||
builder, nothing else.
|
||||
*/
|
||||
Code parse_proc( char const* proc_def, s32 length );
|
||||
|
||||
/*
|
||||
Define a struct by parsing a string.
|
||||
|
||||
Note: This parser only supports the language features the library supports
|
||||
Any other features used and the lex or parse operation will fail.
|
||||
|
||||
This is not a full-on c/c++ parser, it literally only grabs
|
||||
what it needs to reconstruct the Code AST for seralization in the
|
||||
builder, nothing else.
|
||||
*/
|
||||
Code parse_struct( char const* struct_def, s32 length );
|
||||
|
||||
/*
|
||||
|
||||
*/
|
||||
s32 parse_vars( char const* vars_def, s32 length, Code* out_vars_codes );
|
||||
|
||||
/*
|
||||
|
||||
*/
|
||||
s32 parse_usings( char const* usings_def, s32 length, Code* out_usings_codes );
|
||||
|
||||
#pragma region Untyped text
|
||||
/*
|
||||
Define an untyped code string.
|
||||
|
||||
@ -423,6 +713,7 @@ namespace gen
|
||||
Consider this an a preprocessor define.
|
||||
*/
|
||||
Code untyped_str( char const* str );
|
||||
Code untyped_str( char const* str, s32 length);
|
||||
|
||||
/*
|
||||
Define an untyped code string using traditional 'printf'.
|
||||
@ -449,18 +740,8 @@ namespace gen
|
||||
Because the code within it is untyped, errors will naturally not be provided.
|
||||
Consider this an a preprocessor define.
|
||||
*/
|
||||
Code token_fmt( char const* fmt, s32 num_tokens, ... );
|
||||
|
||||
|
||||
/*
|
||||
Creates a unit file.
|
||||
|
||||
These represent an encapsulation of a generated file
|
||||
Used this if you need to pass around a group of Code entires at file scope level.
|
||||
|
||||
The name provided is the name of the file.
|
||||
*/
|
||||
Code create_Unit( char const* name );
|
||||
Code untyped_token_fmt( char const* fmt, s32 num_tokens, ... );
|
||||
#pragma endregion Untyped text
|
||||
|
||||
/*
|
||||
Used to generate the files.
|
||||
@ -492,62 +773,93 @@ namespace gen
|
||||
|
||||
#pragma region MACROS
|
||||
# define gen_main main
|
||||
|
||||
# define __ UnusedCode
|
||||
|
||||
/*
|
||||
gen's Domain Specific Langauge.
|
||||
|
||||
Completely optional, makes the code gen syntax less verbose..
|
||||
Completely optional, makes the code gen syntax less verbose and cumbersome...
|
||||
Since its C macros ends up looking like a lisp dialect...
|
||||
|
||||
Longforms auto-define the variable.
|
||||
Shorthands are just the function call.
|
||||
|
||||
Anything below the make() macro is intended to be syntacticall used int he follwing format:
|
||||
make( <type>, <name> )
|
||||
{
|
||||
...
|
||||
}
|
||||
|
||||
Where ... are whatever is deemed necessary to produce the definition for the def( <name> ).
|
||||
|
||||
The code macros are used to embed c/c++ to insert into the desired lcoation.
|
||||
*/
|
||||
#ifdef GEN_DEFINE_DSL
|
||||
# define type( Name_, Value_ ) Code Name_ = gen::def_type( txt(Value_) )
|
||||
# define type_fmt( Name_, Fmt_, ... ) Code Name_ = gen::def_type( bprintf( Fmt_, __VA_ARGS__ ) )
|
||||
# define value( Name_, Value_ ) Code Name_ = gen::untyped_str( Value_ )
|
||||
# define specifiers( Name_, ... ) Code Name_ = gen::def_specifiers( VA_NARGS( __VA_ARGS__ ), __VA_ARGS__ )
|
||||
# define using( Name_, Type_ ) Code Name_ = gen::def_using( #Name_, Type_ )
|
||||
# define untyped_code( Name_, Value_ ) Code Name_ = gen::untyped_str( txt(Value_) )
|
||||
# define typename( Name_, Value_ ) Code t_##Name_ = gen::def_type( txt(Value_) )
|
||||
# define typename_fmt( Name_, Fmt_, ... ) Code t_##Name_ = gen::def_type( bprintf( Fmt_, __VA_ARGS__ ) )
|
||||
# define using_type( Name_, Type_ ) Code Name_ = gen::def_using( #Name_, t_##Type_ )
|
||||
# define variable( Type_, Name_, ... ) Code Name_ = gen::def_variable( t_##Type_, #Name_, __VA_ARGS__ )
|
||||
|
||||
# define var( Name_, Type_, Value_, Specifiers_ ) \
|
||||
Code Name_ = gen::def_variable( #Name_, Type_, untyped_str( #Value_ ), Specifiers_ )
|
||||
# define untyped( Value_ ) gen::untyped_str( txt(Value_) )
|
||||
# define code_token( Fmt_, ... ) gen::untyped_token_fmt( Fmt_, VA_NARGS( __VA_ARGS__), __VA_ARGS__ )
|
||||
# define code_fmt( Fmt_, ... ) gen::untyped_fmt( Fmt_, __VA_ARGS__ )
|
||||
# define specifiers( ... ) gen::def_specifiers( VA_NARGS( __VA_ARGS__ ), __VA_ARGS__ )
|
||||
# define type( Value_ ) gen::def_type( txt(Value_) )
|
||||
# define type_fmt( Fmt_, ... ) gen::def_type( bprintf( Fmt_, __VA_ARGS__ ) )
|
||||
# define using( Name_, Type_ ) gen::def_using( #Name_, Type_ )
|
||||
# define var( Type_, Name_, ... ) gen::def_variable( Type_, #Name_, __VA_ARGS__ )
|
||||
|
||||
// # define def ( Name _ ) Code Name_;
|
||||
# define make( Type_, Name_, ... ) Code Name_ = make_##Type_( #Name_, __VA_ARGS__ );
|
||||
# define proc( Name_, Specifiers_, RetType_, Parameters_, Body_ ) Name_ = gen::def_proc( #Name_, Specifiers_, Parameters_, RetType_, Body_ )
|
||||
# define proc_body( ... ) gen::def_proc_body( VA_NARGS( __VA_ARS__ ), __VA_ARGS__ )
|
||||
# define params( ... ) gen::def_params( VA_NARGS( __VA_ARGS__ ) / 2, __VA_ARGS__ )
|
||||
# define struct( Name_, Parent_, Specifiers_, Body_ ) Name_ = gen::def_struct( #Name_, Body_, Parent_, Specifiers_ )
|
||||
# define struct_body( ... ) gen::def_struct_body( VA_NARGS( __VA_ARGS__ ), __VA_ARGS__ )
|
||||
|
||||
# define params( ... ) gen::def_parameters( VA_NARGS( __VA_ARGS__ ) / 2, __VA_ARGS__ )
|
||||
# define add_var( Type_, Name_, ... ) add( gen::def_variable( t_##Type_, #Name_, __VA_ARGS__ ) )
|
||||
# define add_untyped( Value_ ) add( gen::untyped_str( txt( Value ) ) )
|
||||
# define add_ret_type( ... )
|
||||
# define add_params( ... )
|
||||
|
||||
/*
|
||||
Defines scoped symbol.
|
||||
|
||||
Used with:
|
||||
- function
|
||||
- namespace
|
||||
- struct
|
||||
*/
|
||||
# define def( Name_ ) Code Name_;
|
||||
|
||||
# define function( Name_, Specifiers_, ReturnType_, Parameters_, Body_ ) \
|
||||
Name_ = gen::def_function( #Name_, Specifiers_, Parameters_, ReturnType_, Body_ )
|
||||
|
||||
# define function_body( ... ) \
|
||||
gen::def_function_body( VA_NARGS( __VA_ARS__ ), __VA_ARGS__ )
|
||||
|
||||
# define struct( Name_, Parent_, Specifiers_, Body_ ) \
|
||||
Name_ = gen::def_struct( #Name_, Body_, Parent_, Specifiers_ )
|
||||
|
||||
# define struct_body( ... ) \
|
||||
gen::def_struct_body( VA_NARGS( __VA_ARGS__ ), __VA_ARGS__ )
|
||||
# define proc_code( Def_ ) gen::parse_proc( txt( Def_ ), sizeof( txt( Def_ )) )
|
||||
# define struct_code( Def_ ) gen::parse_struct( txt( Def_ ), sizeof( txt( Def_ )) )
|
||||
#endif
|
||||
#pragma endregion MACROS
|
||||
|
||||
#pragma region CONSTANTS
|
||||
#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
|
||||
namespace gen
|
||||
{
|
||||
// Predefined typename codes.
|
||||
// These are not set until gen::init is called.
|
||||
// This just preloads a bunch of Code types into the code pool.
|
||||
|
||||
extern const Code t_void;
|
||||
|
||||
extern const Code t_bool;
|
||||
extern const Code t_char;
|
||||
extern const Code t_wchar_t;
|
||||
|
||||
extern const Code t_s8;
|
||||
extern const Code t_s16;
|
||||
extern const Code t_s32;
|
||||
extern const Code t_s64;
|
||||
|
||||
extern const Code t_u8;
|
||||
extern const Code t_u16;
|
||||
extern const Code t_u32;
|
||||
extern const Code t_u64;
|
||||
|
||||
extern const Code t_sw;
|
||||
extern const Code t_uw;
|
||||
|
||||
extern const Code t_f32;
|
||||
extern const Code t_f64;
|
||||
|
||||
extern const Code spec_constexpr;
|
||||
extern const Code spec_inline;
|
||||
}
|
||||
#endif
|
||||
#pragma endregion CONSTANTS
|
||||
#endif
|
||||
|
||||
608
test/Array.hpp
608
test/Array.hpp
@ -1,5 +1,8 @@
|
||||
/*
|
||||
This is based of the array container implementation in the zpl.h library.
|
||||
|
||||
This specific header has two implementations of the array generator;
|
||||
One showing use of the gen api directly, the other using it's DSL.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
@ -8,21 +11,18 @@
|
||||
#include "gen.hpp"
|
||||
|
||||
#ifdef gen_time
|
||||
using namespace gen;
|
||||
|
||||
Code gen__array_base()
|
||||
{
|
||||
// Make these global consts to be accessed anywhere...
|
||||
Code t_sw = def_type( txt(sw) );
|
||||
Code t_uw = def_type( txt(uw) );
|
||||
#ifndef GEN_DEFINE_DSL
|
||||
using namespace gen;
|
||||
|
||||
Code t_allocator = def_type( txt(allocator) );
|
||||
|
||||
#ifndef GEN_DEFINE_DSL
|
||||
Code header;
|
||||
{
|
||||
Code num = def_variable( "Num", t_uw );
|
||||
Code capacity = def_variable( "Capacity", t_uw );
|
||||
Code allocator_var = def_variable( "Allocator", t_allocator );
|
||||
Code num = def_variable( t_uw, "Num" );
|
||||
Code capacity = def_variable( t_uw, "Capacity" );
|
||||
Code allocator_var = def_variable( t_allocator, "Allocator" );
|
||||
Code header_body = def_struct_body( 3, num, capacity, allocator_var );
|
||||
|
||||
header = def_struct( "ArrayHeader", header_body );
|
||||
@ -30,36 +30,35 @@
|
||||
|
||||
Code grow_formula;
|
||||
{
|
||||
Code spec = def_specifiers(1, Specifier::Inline);
|
||||
Code params = def_parameters(1, t_uw, "value" );
|
||||
Code body = untyped_str( "return 2 * value * 8;" );
|
||||
Code spec = def_specifiers(1, ESpecifier::Inline);
|
||||
Code params = def_params(1, t_uw, "value" );
|
||||
Code body = untyped_str( txt( return 2 * value * 8; ) );
|
||||
|
||||
grow_formula = def_function( "grow_formula", spec, params, t_sw, body );
|
||||
grow_formula = def_proc( "grow_formula", spec, params, t_sw, body );
|
||||
}
|
||||
|
||||
Code body = def_struct_body(2, header, grow_formula);
|
||||
Code ArrayBase = def_struct( "ArrayBase", body );
|
||||
|
||||
#else
|
||||
def( ArrayBase )
|
||||
def ( Header )
|
||||
typename( allocator, allocator );
|
||||
|
||||
Code Header;
|
||||
{
|
||||
var( Num, t_uw, __, __ );
|
||||
var( Capacity, t_uw, __, __);
|
||||
var( Allocator, t_allocator, __, __);
|
||||
variable( uw, Num, );
|
||||
variable( uw, Capacity );
|
||||
variable( allocator, Allocator );
|
||||
|
||||
Code body = struct_body( Num, Capacity, Allocator );
|
||||
|
||||
struct( Header, __, __, body );
|
||||
}
|
||||
|
||||
def( grow_formula )
|
||||
{
|
||||
function( grow_formula, spec_inline, t_uw, params( t_uw, "value" ), untyped_str("return 2 * value * 8") );
|
||||
}
|
||||
Code proc( grow_formula, spec_inline, t_uw, params( t_uw, "value" ),
|
||||
untyped( return 2 * value * 8 )
|
||||
);
|
||||
|
||||
Code body = struct_body( Header, grow_formula );
|
||||
struct( ArrayBase, __, __, body );
|
||||
Code struct( ArrayBase, __, __, struct_body( Header, grow_formula ) );
|
||||
#endif
|
||||
|
||||
return ArrayBase;
|
||||
@ -70,16 +69,11 @@
|
||||
{
|
||||
#ifndef GEN_DEFINE_DSL
|
||||
// Make these global consts to be accessed anywhere...
|
||||
Code t_uw = def_type( txt(uw) );
|
||||
Code t_sw = def_type( txt(sw) );
|
||||
Code t_bool = def_type( txt(bool) );
|
||||
Code t_allocator = def_type( txt(allocator) );
|
||||
Code t_void = def_type( txt(void) );
|
||||
|
||||
Code v_nullptr = untyped_str( "nullptr" );
|
||||
|
||||
Code spec_ct = def_specifiers(1, Specifier::Constexpr );
|
||||
Code spec_inline = def_specifiers(1, Specifier::Inline );
|
||||
Code spec_ct = def_specifiers(1, ESpecifier::Constexpr );
|
||||
|
||||
Code type = def_type( type_str );
|
||||
Code ptr_type = def_type( bprintf( "%s*", type_str ) );
|
||||
@ -93,44 +87,50 @@
|
||||
Code array_def;
|
||||
{
|
||||
Code using_type = def_using( "Type", type );
|
||||
Code data = def_variable( "Data", ptr_type );
|
||||
Code data = def_variable( ptr_type, "Data" );
|
||||
|
||||
// This getter is used often in all the member procedures
|
||||
Code header = def_variable( ref_header, "header", untyped_str( txt( get_header() )));
|
||||
|
||||
Code init;
|
||||
{
|
||||
Code params = def_parameters( 1, t_allocator, "mem_handler" );
|
||||
Code body = untyped_str( "return init_reserve( mem_handler, grow_formula(0) );" );
|
||||
Code params = def_params( 1, t_allocator, "mem_handler" );
|
||||
Code body = untyped_str( txt( return init_reserve( mem_handler, grow_formula(0) ); ) );
|
||||
|
||||
init = def_function( "init", UnusedCode, params, t_bool, body );
|
||||
init = def_proc( "init", UnusedCode, params, t_bool, body );
|
||||
}
|
||||
|
||||
Code init_reserve;
|
||||
{
|
||||
Code params = def_parameters( 2, t_allocator, "mem_handler", t_sw, "capacity" );
|
||||
Code params = def_params( 2, t_allocator, "mem_handler", t_sw, "capacity" );
|
||||
Code body;
|
||||
{
|
||||
Code header_value = untyped_str(
|
||||
"rcast( Header*, alloc( mem_handler, sizeof( Header ) + sizeof(Type) + capacity ))"
|
||||
);
|
||||
Code header = def_variable( "header", ptr_header, header_value );
|
||||
Code header_value = untyped_str( txt(
|
||||
rcast( Header*, alloc( mem_handler, sizeof( Header ) + sizeof(Type) + capacity ))
|
||||
));
|
||||
|
||||
Code null_check = untyped_str(
|
||||
"if (header == nullptr)"
|
||||
"\n" "return false;"
|
||||
);
|
||||
Code header = def_variable( ptr_header, "header", header_value );
|
||||
|
||||
Code header_init = untyped_str(
|
||||
"header->Num = 0;"
|
||||
"\n""header->Capacity = capacity;"
|
||||
"\n""header->Allocator = mem_handler;"
|
||||
);
|
||||
Code null_check = untyped_str( txt(
|
||||
if (header == nullptr)
|
||||
return false;
|
||||
));
|
||||
|
||||
Code assign_data = untyped_str(
|
||||
Code header_init = untyped_str( txt(
|
||||
header->Num = 0;
|
||||
header->Capacity = capacity;
|
||||
header->Allocator = mem_handler;
|
||||
));
|
||||
|
||||
Code assign_data = untyped_fmt(
|
||||
"Data = rcast( %s, header + 1 );", ptr_type
|
||||
);
|
||||
|
||||
Code ret_true = untyped_str( "\t""return true" );
|
||||
Code ret_true = untyped_str( txt(
|
||||
return true
|
||||
));
|
||||
|
||||
body = def_function_body( 5
|
||||
body = def_proc_body( 5
|
||||
, header
|
||||
, null_check
|
||||
, header_init
|
||||
@ -139,135 +139,125 @@
|
||||
);
|
||||
}
|
||||
|
||||
init_reserve = def_function( "init_reserve", UnusedCode, params, t_bool, body );
|
||||
init_reserve = def_proc( "init_reserve", UnusedCode, params, t_bool, body );
|
||||
}
|
||||
|
||||
Code free;
|
||||
{
|
||||
Code body = untyped_str(
|
||||
"Header& header = get_header();"
|
||||
"\n""::free( header.Allocator, & get_header() );"
|
||||
);
|
||||
Code body = untyped_str( txt(
|
||||
Header& header = get_header();
|
||||
::free( header.Allocator, & get_header() );
|
||||
));
|
||||
|
||||
free = def_function( "free", UnusedCode, UnusedCode, t_void, body );
|
||||
free = def_proc( "free", UnusedCode, UnusedCode, t_void, body );
|
||||
}
|
||||
|
||||
Code append;
|
||||
Code append = make_proc( "append" );
|
||||
{
|
||||
Code params = def_parameters( 1, type, "value" );
|
||||
Code body;
|
||||
{
|
||||
Code header = def_variable( "header", ref_header, untyped_str( "get_header()") );
|
||||
append->add( def_params( 1, type, "value") );
|
||||
|
||||
Code check_cap = untyped_str(
|
||||
"if ( header.Capacity < header.Num + 1 )"
|
||||
"\n" "if ( ! grow(0) )"
|
||||
"\n" "return false;"
|
||||
Code
|
||||
body = append.body();
|
||||
body->add(
|
||||
untyped_str( txt(
|
||||
if ( header.Capacity < header.Num + 1 )
|
||||
if ( ! grow(0) )
|
||||
return false;
|
||||
))
|
||||
);
|
||||
|
||||
Code assign = untyped_str(
|
||||
"Data[ header.Num ] = value;"
|
||||
"\n" "header.Num++;"
|
||||
"\n"
|
||||
"\n" "return true;"
|
||||
);
|
||||
body->add( untyped_str( txt(
|
||||
Data[ header.Num ] = value;
|
||||
header.Num++;
|
||||
|
||||
body = def_function_body( 3, header, check_cap, assign );
|
||||
}
|
||||
|
||||
append = def_function( "append", UnusedCode, params, t_void, body );
|
||||
return true;
|
||||
)));
|
||||
}
|
||||
|
||||
Code back;
|
||||
{
|
||||
Code body = untyped_str(
|
||||
"Header& header = get_header();"
|
||||
"\n" "return data[ header.Num - 1 ];"
|
||||
);
|
||||
Code body = untyped_str( txt(
|
||||
Header& header = get_header();
|
||||
|
||||
back = def_function( "back", UnusedCode, UnusedCode, type, body );
|
||||
return data[ header.Num - 1 ];
|
||||
));
|
||||
|
||||
back = def_proc( "back", UnusedCode, UnusedCode, type, body );
|
||||
}
|
||||
|
||||
Code clear;
|
||||
{
|
||||
Code body = untyped_str( "get_header().Num = 0;" );
|
||||
Code body = untyped_str( txt( get_header().Num = 0; ));
|
||||
|
||||
clear = def_function( "clear", UnusedCode, UnusedCode, t_void, body );
|
||||
clear = def_proc( "clear", UnusedCode, UnusedCode, t_void, body );
|
||||
}
|
||||
|
||||
Code fill;
|
||||
{
|
||||
Code params = def_parameters( 3, t_uw, "begin", t_uw, "end", type, "value" );
|
||||
Code params = def_params( 3, t_uw, "begin", t_uw, "end", type, "value" );
|
||||
Code body;
|
||||
{
|
||||
Code header = def_variable( "header", ref_header, untyped_str( "get_header()") );
|
||||
Code check = untyped_str( txt(
|
||||
if ( begin < 0 || end >= header.Num )
|
||||
fatal( "Range out of bounds" );
|
||||
));
|
||||
|
||||
Code check = untyped_str(
|
||||
"if ( begin < 0 || end >= header.Num )"
|
||||
"\n" "fatal( \"Range out of bounds\" );"
|
||||
);
|
||||
Code iter = untyped_str( txt(
|
||||
for ( sw index = begin; index < end; index++ )
|
||||
Data[index] = vallue;
|
||||
));
|
||||
|
||||
Code iter = untyped_str(
|
||||
"for ( sw index = begin; index < end; index++ )"
|
||||
"\n" "Data[index] = vallue;"
|
||||
);
|
||||
|
||||
body = def_function_body( 3, header, check, iter );
|
||||
body = def_proc_body( 3, header, check, iter );
|
||||
}
|
||||
|
||||
fill = def_function( "fill", UnusedCode, params, t_void, body );
|
||||
fill = def_proc( "fill", UnusedCode, params, t_void, body );
|
||||
}
|
||||
|
||||
Code get_header;
|
||||
{
|
||||
Code body = untyped_str( "return pcast( Header, Data - 1 );" );
|
||||
Code body = untyped_str( txt( return pcast( Header, Data - 1 ); ));
|
||||
|
||||
get_header = def_function( "get_header", spec_inline, UnusedCode, ref_header, body );
|
||||
get_header = def_proc( "get_header", spec_inline, UnusedCode, ref_header, body );
|
||||
}
|
||||
|
||||
Code grow;
|
||||
{
|
||||
Code param = def_parameters( 1, t_uw, "min_capacity" );
|
||||
Code param = def_params( 1, t_uw, "min_capacity" );
|
||||
Code body;
|
||||
{
|
||||
Code header = def_variable( "header", ref_header, untyped_str("get_header()") );
|
||||
Code new_capacity = def_variable( "new_capacity", t_uw, untyped_str("grow_formula( header.Capacity )") );
|
||||
Code new_capacity = def_variable( t_uw, "new_capacity", untyped_str("grow_formula( header.Capacity )") );
|
||||
|
||||
Code check_n_set = untyped_str(
|
||||
"if ( new_capacity < min_capacity )"
|
||||
"\n" "new_capacity = min_capacity;"
|
||||
);
|
||||
Code check_n_set = untyped_str( txt(
|
||||
if ( new_capacity < min_capacity )
|
||||
new_capacity = min_capacity;
|
||||
));
|
||||
|
||||
Code ret = untyped_str( "return set_capacity( new_capacity );" );
|
||||
|
||||
body = def_function_body( 4, header, new_capacity, check_n_set, ret );
|
||||
body = def_proc_body( 4, header, new_capacity, check_n_set, ret );
|
||||
}
|
||||
|
||||
grow = def_function( "grow", UnusedCode, param, t_bool, body );
|
||||
grow = def_proc( "grow", UnusedCode, param, t_bool, body );
|
||||
}
|
||||
|
||||
Code pop;
|
||||
{
|
||||
Code body;
|
||||
{
|
||||
Code header = def_variable( "header", ref_header, untyped_str("get_header()") );
|
||||
|
||||
Code assertion = untyped_str( "assert( header.Num > 0 );" );
|
||||
Code decrement = untyped_str( "header.Num--; " );
|
||||
|
||||
body = def_function_body( 3, header, assertion, decrement );
|
||||
body = def_proc_body( 3, header, assertion, decrement );
|
||||
}
|
||||
|
||||
pop = def_function( "pop", UnusedCode, UnusedCode, t_void, body );
|
||||
pop = def_proc( "pop", UnusedCode, UnusedCode, t_void, body );
|
||||
}
|
||||
|
||||
Code reserve;
|
||||
{
|
||||
Code params = def_parameters( 1, t_uw, "new_capacity" );
|
||||
Code params = def_params( 1, t_uw, "new_capacity" );
|
||||
Code body;
|
||||
{
|
||||
Code header = def_variable( "header", ref_header, untyped_str("get_header()") );
|
||||
|
||||
Code check_n_set = untyped_str(
|
||||
"if ( header.Capacity < new_capacity )"
|
||||
"\n" "return set_capacity( new_capacity );"
|
||||
@ -275,80 +265,65 @@
|
||||
|
||||
Code ret = untyped_str( "\t" "return true" );
|
||||
|
||||
body = def_function_body( 3, header, check_n_set, ret );
|
||||
body = def_proc_body( 3, header, check_n_set, ret );
|
||||
}
|
||||
|
||||
reserve = def_function( "reserve", UnusedCode, params, t_bool, body );
|
||||
reserve = def_proc( "reserve", UnusedCode, params, t_bool, body );
|
||||
}
|
||||
|
||||
Code resize;
|
||||
{
|
||||
Code param = def_parameters( 1, t_uw, "new_num" );
|
||||
Code param = def_params( 1, t_uw, "new_num" );
|
||||
|
||||
Code body;
|
||||
{
|
||||
Code header = def_variable( "header", ref_header, untyped_str("get_header()") );
|
||||
|
||||
Code check_n_grow = untyped_str(
|
||||
"if ( header.Capacity < new_num )"
|
||||
"\n" "if ( ! grow( new_num) )"
|
||||
"\n" "return false;"
|
||||
);
|
||||
Code check_n_grow = untyped_str( txt(
|
||||
if ( header.Capacity < new_num )
|
||||
if ( ! grow( new_num) )
|
||||
return false;
|
||||
));
|
||||
|
||||
Code set_n_ret = untyped_str(
|
||||
"header.Count = new_num;"
|
||||
"\n""return true;"
|
||||
);
|
||||
|
||||
body = def_function_body( 3, header, check_n_grow, set_n_ret );
|
||||
body = def_proc_body( 3, header, check_n_grow, set_n_ret );
|
||||
}
|
||||
|
||||
resize = def_function( "resize", UnusedCode, param, t_bool, body );
|
||||
resize = def_proc( "resize", UnusedCode, param, t_bool, body );
|
||||
}
|
||||
|
||||
Code set_capacity;
|
||||
Code set_capacity = parse_proc( txt_with_length(
|
||||
bool set_capacity( new_capacity )
|
||||
{
|
||||
Code param = def_parameters( 1, t_uw, "capacity" );
|
||||
Header& header = get_header();
|
||||
|
||||
Code body;
|
||||
{
|
||||
Code header = def_variable( "header", ref_header, untyped_str("get_header()") );
|
||||
if ( capacity == header.Capacity )
|
||||
return true;
|
||||
|
||||
Code checks = untyped_str(
|
||||
"if ( capacity == header.Capacity )"
|
||||
"\n" "return true;"
|
||||
if ( capacity < header.Num )
|
||||
header.Num = capacity;
|
||||
|
||||
"if ( capacity < header.Num )"
|
||||
"\n" "header.Num = capacity;"
|
||||
);
|
||||
uw size = sizeof(Header) + sizeof(Type) * capacity;
|
||||
Header* new_header = rcast( Header* alloc( header.Allocator, size ));
|
||||
|
||||
Code size = def_variable( "size", t_uw, untyped_str("sizeof(Header) + sizeof(Type) * capacity"));
|
||||
Code new_header = def_variable( "new_header", ptr_header, untyped_str("rcast( Header*, alloc( header.Allocator, size ));"));
|
||||
if ( new_header == nullptr )
|
||||
return false;
|
||||
|
||||
Code check_n_move = untyped_str(
|
||||
"if ( new_header == nullptr )"
|
||||
"\n" "return false;"
|
||||
"\n"
|
||||
"\n" "memmove( new_header, & header, sizeof(Header) + sizeof(Type) * header.Num );"
|
||||
);
|
||||
memmove( new_header, & header, sizeof( Header ) + sizeof(Type) * header.Num );
|
||||
|
||||
Code set_free_ret = untyped_str(
|
||||
"new_header->Allocator = header.Allocator;"
|
||||
"\n" "new_header->Num = header.Num;"
|
||||
"\n" "new_header->Capacity = header.Capacity;"
|
||||
"\n"
|
||||
"\n" "zpl_free( header );"
|
||||
"\n"
|
||||
"\n" "*Data = new_header + 1;"
|
||||
"\n"
|
||||
"\n" "return true;"
|
||||
);
|
||||
new_header->Allocator = header.Allocator;
|
||||
new_header->Num = header.Num;
|
||||
new_header->Capacity = header.Capacity;
|
||||
|
||||
body = def_function_body( 6, header, checks, size, new_header, check_n_move, set_free_ret );
|
||||
}
|
||||
|
||||
set_capacity = def_function( "set_capacity", UnusedCode, param, t_bool, body );
|
||||
free( header );
|
||||
|
||||
*Data = new_header + 1;
|
||||
|
||||
return true;
|
||||
}
|
||||
));
|
||||
|
||||
string name = bprintf( "Array_%s", type_str );
|
||||
|
||||
@ -374,256 +349,219 @@
|
||||
array_def = def_struct( name, body, parent );
|
||||
}
|
||||
#else
|
||||
type( t_uw, uw );
|
||||
type( t_sw, sw );
|
||||
type( t_bool, bool );
|
||||
type( t_allocator, allocator );
|
||||
type( t_void, void );
|
||||
typename( allocator, allocator );
|
||||
|
||||
value( v_nullptr, nullptr );
|
||||
untyped( v_nullptr, nullptr );
|
||||
|
||||
specifiers( spec_ct, Specifier::Constexpr );
|
||||
specifiers( spec_inline, Specifier::Inline );
|
||||
|
||||
type_fmt( type, type_str, __);
|
||||
type_fmt( ptr_type, "%s*", type_str );
|
||||
type_fmt( ref_type, "%&", type_str );
|
||||
typename( elem_type, type_str );
|
||||
typename_fmt( ptr_type, "%s*", type_str );
|
||||
typename_fmt( ref_type, "%&", type_str );
|
||||
|
||||
|
||||
// From ArrayBase
|
||||
type( t_header, Header );
|
||||
type( ptr_header, Header* );
|
||||
type( ref_header, Header& );
|
||||
typename( header, Header );
|
||||
typename( ptr_header, Header* );
|
||||
typename( ref_header, Header& );
|
||||
|
||||
def( array_def )
|
||||
Code array_def;
|
||||
{
|
||||
using( Type, type );
|
||||
var( Data, ptr_type, __, __ );
|
||||
using_type( Type, elem_type );
|
||||
|
||||
def( init )
|
||||
variable( ptr_type, Data );
|
||||
variable( ref_header, header, untyped_str("get_header()") );
|
||||
|
||||
Code init;
|
||||
{
|
||||
Code body = function_body( untyped_str("return init_reserve( mem_handler, grow_formula(0) );" ));
|
||||
Code body = proc_body( untyped(
|
||||
return init_reserve( mem_handler, grow_formula(0) );
|
||||
));
|
||||
|
||||
function( init, __, t_bool, params( t_allocator, "mem_handler" ), body );
|
||||
proc( init, __, t_bool, params( t_allocator, "mem_handler" ), body );
|
||||
}
|
||||
|
||||
def( init_reserve )
|
||||
make( proc, init_reserve, __, params( t_ref_type, "mem_handler" ), t_bool);
|
||||
{
|
||||
def( body )
|
||||
{
|
||||
var(header, ptr_header, untyped_str("rcast( Header*, alloc( mem_handler, sizeof(Header) + sizeof(Type) + capacity))" ), __);
|
||||
Code
|
||||
body = init_reserve.body();
|
||||
body->add_var( ptr_header, header, untyped(
|
||||
value_str( rcast( Header*, alloc( mem_handler, sizeof(Header) + sizeof(Type) + capacity)) )
|
||||
) );
|
||||
|
||||
Code null_check = untyped_str(
|
||||
"if (header == nullptr)"
|
||||
"\n" "return false;"
|
||||
body->add_untyped(
|
||||
if (header == nullptr)
|
||||
return false;
|
||||
);
|
||||
|
||||
Code header_init = untyped_str(
|
||||
"header->Num = 0;"
|
||||
"\n""header->Capacity = capacity;"
|
||||
"\n""header->Allocator = mem_handler;"
|
||||
body->add_untyped(
|
||||
header->Num = 0;
|
||||
header->Capacity = capacity;
|
||||
header->Allocator = mem_handler;
|
||||
);
|
||||
|
||||
Code assign_data = untyped_str( "Data = rcast( Type*, header + 1 );" );
|
||||
Code ret_true = untyped_str( "return true" );
|
||||
|
||||
Code body = function_body( header, null_check, header_init, assign_data, ret_true );
|
||||
body->add_untyped(
|
||||
Data = rcast( Type*, header + 1 );
|
||||
return true;
|
||||
);
|
||||
}
|
||||
|
||||
function( init_reserve, __, t_bool, params( ref_type, "mem_handler" ) , body);
|
||||
}
|
||||
|
||||
def( free )
|
||||
Code free;
|
||||
{
|
||||
Code body = untyped_str(
|
||||
"Header& header = get_header();"
|
||||
"\n""free( header.Allocator, & get_header() );"
|
||||
proc( free, __, t_void, __, untyped(
|
||||
Header& header = get_header();
|
||||
|
||||
free( header.Allocator, & get_header() );
|
||||
));
|
||||
}
|
||||
|
||||
make( proc, append )
|
||||
{
|
||||
append->add_params( t_elem_value, "value" );
|
||||
append->add_ret_type( void );
|
||||
|
||||
Code
|
||||
body = append.body();
|
||||
body->add_untyped(
|
||||
if ( header.Capacity < header.Num + 1 )
|
||||
if ( ! grow(0) )
|
||||
return false;
|
||||
);
|
||||
|
||||
function( free, __, t_void, __, body );
|
||||
body->add_untyped( assign,
|
||||
Data[ header.Num ] = value;
|
||||
header.Num++;
|
||||
|
||||
return true;
|
||||
);
|
||||
}
|
||||
|
||||
def( append )
|
||||
Code back;
|
||||
{
|
||||
def( body )
|
||||
{
|
||||
var( header, ref_header, untyped_str("get_header()"), __ );
|
||||
Code body = untyped(
|
||||
Header& header = get_header();
|
||||
|
||||
Code check_cap = untyped_str(
|
||||
"if ( header.Capacity < header.Num + 1 )"
|
||||
"\n" "if ( ! grow(0) )"
|
||||
"\n" "return false;"
|
||||
return data[ header.Num - 1 ];
|
||||
);
|
||||
|
||||
Code assign = untyped_str(
|
||||
"Data[ header.Num ] = value;"
|
||||
"\n" "header.Num++;"
|
||||
"\n"
|
||||
"\n" "return true;"
|
||||
proc( back, __, t_elem_type, __, body );
|
||||
}
|
||||
|
||||
Code clear;
|
||||
proc( clear, __, t_void, __, untyped_str("get_header().Num = 0;") );
|
||||
|
||||
Code fill;
|
||||
{
|
||||
Code check = untyped(
|
||||
if ( begin < 0 || end >= header.Num )
|
||||
fatal( "Range out of bounds" );
|
||||
);
|
||||
|
||||
body = function_body( header, check_cap, assign );
|
||||
}
|
||||
|
||||
function( append, __, t_void, params( type, "value" ), body );
|
||||
}
|
||||
|
||||
def( back );
|
||||
{
|
||||
Code body = untyped_str(
|
||||
"Header& header = get_header();"
|
||||
"\n" "return data[ header.Num - 1 ];"
|
||||
Code iter = untyped(
|
||||
for ( sw index = begin; index < end; index++ )
|
||||
Data[index] = vallue;
|
||||
);
|
||||
|
||||
function( back, __, type, __, body );
|
||||
Code body = proc_body( header, check, iter );
|
||||
|
||||
proc( fill, __, t_void, params( t_uw, "begin", t_uw, "end", t_elem_type, "value" ), body );
|
||||
}
|
||||
|
||||
def( clear )
|
||||
function( clear, __, t_void, __, untyped_str("get_header().Num = 0;") );
|
||||
Code get_header;
|
||||
proc( get_header, spec_inline, t_ref_header, __, untyped_str("return pcast( Header, Data - 1);") );
|
||||
|
||||
def( fill );
|
||||
Code grow;
|
||||
{
|
||||
def( body )
|
||||
Code body;
|
||||
{
|
||||
var( header, ref_header, untyped_str("get_header()"), __ );
|
||||
variable( uw, new_capacity, untyped( grow_formula( header.Capacity) ));
|
||||
|
||||
Code check = untyped_str(
|
||||
"if ( begin < 0 || end >= header.Num )"
|
||||
"\n" "fatal( \"Range out of bounds\" );"
|
||||
Code check_n_set = untyped(
|
||||
if ( new_capacity < min_capacity )
|
||||
new_capacity = min_capacity;
|
||||
);
|
||||
|
||||
Code iter = untyped_str(
|
||||
"for ( sw index = begin; index < end; index++ )"
|
||||
"\n" "Data[index] = vallue;"
|
||||
);
|
||||
Code ret = untyped( return set_capacity( new_capacity ); );
|
||||
|
||||
function_body( header, check, iter );
|
||||
body = proc_body( header, new_capacity, check_n_set, ret );
|
||||
}
|
||||
|
||||
function( fill, __, t_void, params( t_uw, "begin", t_uw, "end", type, "value" ), body );
|
||||
proc( grow, __, t_bool, params( t_uw, "min_capacity" ), body );
|
||||
}
|
||||
|
||||
def( get_header )
|
||||
function( get_header, spec_inline, ref_header, __, untyped_str("return pcast( Header, Data - 1);") );
|
||||
|
||||
def( grow )
|
||||
Code pop;
|
||||
{
|
||||
def( body )
|
||||
{
|
||||
var( header, ref_header, untyped_str("get_header()"), __ );
|
||||
var( new_capacity, t_uw, untyped_str("grow_formula( header.Capacity)"), __);
|
||||
untyped_code( assertion, assert( header.Num > 0 ); );
|
||||
untyped_code( decrement, header.Num--; );
|
||||
|
||||
Code check_n_set = untyped_str(
|
||||
"if ( new_capacity < min_capacity )"
|
||||
"new_capacity = min_capacity;"
|
||||
);
|
||||
Code body = proc_body( header, assertion, decrement );
|
||||
|
||||
Code ret = untyped_str( "return set_capacity( new_capacity );" );
|
||||
|
||||
body = function_body( header, new_capacity, check_n_set, ret );
|
||||
proc( pop, __, t_void, __, body );
|
||||
}
|
||||
|
||||
function( grow, __, t_bool, params( t_uw, "min_capacity" ), body );
|
||||
}
|
||||
|
||||
def( pop )
|
||||
Code reserve;
|
||||
{
|
||||
def( body )
|
||||
{
|
||||
var( header, ref_header, get_header(), UnusedCode );
|
||||
|
||||
Code assertion = untyped_str( "assert( header.Num > 0 );" );
|
||||
Code decrement = untyped_str( "header.Num--; " );
|
||||
|
||||
body = function_body( header, assertion, decrement );
|
||||
}
|
||||
|
||||
function( pop, __, t_void, __, body );
|
||||
}
|
||||
|
||||
def( reserve )
|
||||
{
|
||||
def( body )
|
||||
{
|
||||
var( header, ref_header, untyped_str("get_header()"), __ );
|
||||
|
||||
Code check_n_set = untyped_str(
|
||||
"if ( header.Capacity < new_capacity )"
|
||||
"return set_capacity( new_capacity );"
|
||||
untyped_code( check_n_set,
|
||||
if ( header.Capacity < new_capacity )
|
||||
return set_capacity( new_capacity );
|
||||
);
|
||||
|
||||
Code ret = untyped_str("return true");
|
||||
|
||||
body = function_body( header, check_n_set, ret );
|
||||
Code body = proc_body( header, check_n_set, ret );
|
||||
|
||||
proc( reserve, __, t_bool, params( t_uw, "new_capacity" ), body );
|
||||
}
|
||||
|
||||
function( reserve, __, t_bool, params( t_uw, "new_capacity" ), body );
|
||||
}
|
||||
|
||||
def( resize )
|
||||
Code resize;
|
||||
{
|
||||
def( body )
|
||||
Code body;
|
||||
{
|
||||
var( header, ref_header, untyped_str("get_header()"), __ );
|
||||
|
||||
Code check_n_grow = untyped_str(
|
||||
"if ( header.Capacity < new_num )"
|
||||
"if ( ! grow( new_num) )"
|
||||
"return false;"
|
||||
untyped_code( check_n_grow,
|
||||
if ( header.Capacity < new_num )
|
||||
if ( ! grow( new_num) )
|
||||
return false;
|
||||
);
|
||||
|
||||
Code set_n_ret = untyped_str(
|
||||
"header.Count = new_num;"
|
||||
"return true;"
|
||||
untyped_code( set_n_ret,
|
||||
header.Count = new_num;
|
||||
return true;
|
||||
);
|
||||
|
||||
body = function_body( header, check_n_grow, set_n_ret );
|
||||
body = proc_body( header, check_n_grow, set_n_ret );
|
||||
}
|
||||
|
||||
function( resize, __, t_bool, params( t_uw, "new_num" ), body );
|
||||
proc( resize, __, t_bool, params( t_uw, "new_num" ), body );
|
||||
}
|
||||
|
||||
def( set_capacity )
|
||||
Code set_capacity = proc_code(
|
||||
bool set_capacity( new_capacity )
|
||||
{
|
||||
def( body )
|
||||
{
|
||||
var( header, ref_header, untyped_str("get_header()"), __ );
|
||||
Header& header = get_header();
|
||||
|
||||
Code checks = untyped_str(
|
||||
"if ( capacity == header.Capacity )"
|
||||
"return true;"
|
||||
"\n\n"
|
||||
"if ( capacity < header.Num )"
|
||||
"header.Num = capacity;"
|
||||
);
|
||||
if ( capacity == header.Capacity )
|
||||
return true;
|
||||
|
||||
var( size, t_uw, untyped_str("sizeof(Header) + sizeof(Type) * capacity"), __ );
|
||||
var( new_header, ptr_header, untyped_str("rcast( Header*, alloc( header.Allocator, size ))"), __ );
|
||||
if ( capacity < header.Num )
|
||||
header.Num = capacity;
|
||||
|
||||
Code check_n_move = untyped_str(
|
||||
"if ( new_header == nullptr )"
|
||||
"return false;"
|
||||
"\n\n"
|
||||
"memmove( new_header, & header, sizeof(Header) + sizeof(Type) * header.Num );"
|
||||
);
|
||||
uw size = sizeof(Header) + sizeof(Type) * capacity;
|
||||
Header* new_header = rcast( Header* alloc( header.Allocator, size ));
|
||||
|
||||
Code set_free_ret = untyped_str(
|
||||
"new_header->Allocator = header.Allocator;"
|
||||
"new_header->Num = header.Num;"
|
||||
"new_header->Capacity = header.Capacity;"
|
||||
"\n\n"
|
||||
"zpl_free( header );"
|
||||
"\n\n"
|
||||
"*Data = new_header + 1;"
|
||||
"\n\n"
|
||||
"return true;"
|
||||
);
|
||||
if ( new_header == nullptr )
|
||||
return false;
|
||||
|
||||
body = function_body( header, checks, size, new_header, check_n_move, set_free_ret );
|
||||
}
|
||||
|
||||
function( set_capacity, __, t_bool, params( t_uw, "capacity" ), body );
|
||||
memmove( new_header, & header, sizeof( Header ) + sizeof(Type) * header.Num );
|
||||
|
||||
new_header->Allocator = header.Allocator;
|
||||
new_header->Num = header.Num;
|
||||
new_header->Capacity = header.Capacity;
|
||||
|
||||
free( header );
|
||||
|
||||
*Data = new_header + 1;
|
||||
|
||||
return true;
|
||||
}
|
||||
);
|
||||
|
||||
char const* name = bprintf( "Array_%s", type_str );
|
||||
|
||||
|
||||
12
test/Readme.md
Normal file
12
test/Readme.md
Normal file
@ -0,0 +1,12 @@
|
||||
# Test
|
||||
|
||||
The following tests focus on attempting to generate some math, containers, and the memory module of zpl.
|
||||
|
||||
Not all the files are written how I would practically use the librarry,
|
||||
there is a bunch of conditionally compiled code for testing different aspects of the library.
|
||||
|
||||
Specifically, Array.hpp is far more complicated that it would need to be;
|
||||
with at least double the code that it would actually have to define itself.
|
||||
|
||||
There will be down the line a proper container, and memory libraries made with this gen library
|
||||
once the stress test files are complete.
|
||||
@ -25,18 +25,34 @@
|
||||
#ifndef GEN_DEFINE_DSL
|
||||
string name = string_sprintf( g_allocator, (char*)sprintf_buf, ZPL_PRINTF_MAXLEN, "square", type );
|
||||
|
||||
#if 1
|
||||
Code square;
|
||||
{
|
||||
Code params = def_parameters( 1, integral_type, "value" );
|
||||
Code specifiers = def_specifiers( 1, Specifier::Inline );
|
||||
Code ret_stmt = untyped_fmt( "return value * value;" );
|
||||
Code params = def_params( 1, integral_type, "value" );
|
||||
Code specifiers = def_specifiers( 1, SpecifierT::Inline );
|
||||
Code ret_stmt = untyped_str( txt( return value * value; ));
|
||||
|
||||
square = def_function( name, specifiers, params, integral_type, ret_stmt );
|
||||
square = def_proc( name, specifiers, params, integral_type, ret_stmt );
|
||||
}
|
||||
|
||||
#else
|
||||
def( square )
|
||||
function( square, __, integral_type, params( integral_type, "value" ), untyped_str("return value * value") );
|
||||
// Test of token template str.
|
||||
char const* tmpl = txt(
|
||||
{type} square( {type} value )
|
||||
{
|
||||
return value * value;
|
||||
}
|
||||
);
|
||||
char const* gen_code = token_fmt( tmpl, 1, type );
|
||||
|
||||
Code square = parse_proc(gen_code);
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
Code proc( square, __, integral_type, params( integral_type, "value" ),
|
||||
untyped(return value * value)
|
||||
);
|
||||
#endif
|
||||
|
||||
if ( ! square )
|
||||
|
||||
@ -17,7 +17,7 @@ int gen_main()
|
||||
|
||||
int
|
||||
result = gen_math();
|
||||
result = gen_array_file();
|
||||
// result = gen_array_file();
|
||||
|
||||
Memory::cleanup();
|
||||
return result;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user