ed/gencpp
1
0
Fork 0
mirror of https://github.com/Ed94/gencpp.git synced 2024-11-10 02:54:53 -08:00
Code Issues Packages Projects Releases Wiki Activity

Moved the indentation for the library over

Browse Source 
The entire project uses the namespace and it felt redundant.

There is a fix for array append_at. Finally got csv parsing working with it.
This commit is contained in:
Edward R. Gonzalez 2023-07-19 23:42:28 -04:00
parent d1c061769c
commit 8bb0db8145
7 changed files with 6206 additions and 6167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
project/Readme.md
View File

@ -1,6 +1,9 @@
# Documentation # Documentation
All the library code is contained in two files: `gen.hpp` and `gen.cpp` The core library is contained within `gen.hpp` and `gen.cpp`.
Things related to the editor and scanner are in their own respective files. (Ex: `gen.scanner.<hpp/cpp>` )
## gen.hpp ## gen.hpp

11590
project/gen.cpp
View File

File diff suppressed because it is too large Load Diff

38
project/gen.dep.cpp
View File

@ -39,6 +39,24 @@
# endif # endif
# endif # endif
#include <sys/stat.h>
#ifdef GEN_SYSTEM_MACOS
# include <copyfile.h>
#endif
#ifdef GEN_SYSTEM_CYGWIN
# include <windows.h>
#endif
#if defined( GEN_SYSTEM_WINDOWS ) && ! defined( GEN_COMPILER_GCC )
# include <io.h>
#endif
#if defined( GEN_SYSTEM_LINUX )
# include <sys/types.h>
#endif
#ifdef GEN_BENCHMARK #ifdef GEN_BENCHMARK
// Timing includes // Timing includes
#if defined( GEN_SYSTEM_MACOS ) || GEN_SYSTEM_UNIX #if defined( GEN_SYSTEM_MACOS ) || GEN_SYSTEM_UNIX
@ -63,7 +81,6 @@
#pragma endregion Macros & Includes #pragma endregion Macros & Includes
namespace gen { namespace gen {
#pragma region Debug #pragma region Debug
@ -2062,9 +2079,15 @@ namespace gen {
GEN_ASSERT_NOT_NULL( root ); GEN_ASSERT_NOT_NULL( root );
GEN_ASSERT_NOT_NULL( text ); GEN_ASSERT_NOT_NULL( text );
zero_item( root ); zero_item( root );
adt_make_branch( root, allocator, NULL, has_header ? false : true ); adt_make_branch( root, allocator, NULL, has_header ? false : true );
char *p = text, *b = p, *e = p;
sw colc = 0, total_colc = 0; char* p = text;
char* b = p;
char* e = p;
sw colc = 0;
sw total_colc = 0;
do do
{ {
@ -2074,7 +2097,7 @@ namespace gen {
break; break;
ADT_Node row_item = { 0 }; ADT_Node row_item = { 0 };
row_item.type = EADT_TYPE_STRING; row_item.type = EADT_TYPE_STRING;
#ifndef ZPL_PARSER_DISABLE_ANALYSIS #ifndef GEN_PARSER_DISABLE_ANALYSIS
row_item.name_style = EADT_NAME_STYLE_NO_QUOTES; row_item.name_style = EADT_NAME_STYLE_NO_QUOTES;
#endif #endif
@ -2083,7 +2106,7 @@ namespace gen {
{ {
p = b = e = p + 1; p = b = e = p + 1;
row_item.string = b; row_item.string = b;
#ifndef ZPL_PARSER_DISABLE_ANALYSIS #ifndef GEN_PARSER_DISABLE_ANALYSIS
row_item.name_style = EADT_NAME_STYLE_DOUBLE_QUOTE; row_item.name_style = EADT_NAME_STYLE_DOUBLE_QUOTE;
#endif #endif
do do
@ -2229,7 +2252,7 @@ namespace gen {
{ {
case EADT_TYPE_STRING : case EADT_TYPE_STRING :
{ {
#ifndef ZPL_PARSER_DISABLE_ANALYSIS #ifndef GEN_PARSER_DISABLE_ANALYSIS
switch ( node->name_style ) switch ( node->name_style )
{ {
case EADT_NAME_STYLE_DOUBLE_QUOTE : case EADT_NAME_STYLE_DOUBLE_QUOTE :
@ -2244,7 +2267,7 @@ namespace gen {
{ {
#endif #endif
str_fmt_file( file, "%s", node->string ); str_fmt_file( file, "%s", node->string );
#ifndef ZPL_PARSER_DISABLE_ANALYSIS #ifndef GEN_PARSER_DISABLE_ANALYSIS
} }
break; break;
} }
@ -3244,3 +3267,4 @@ namespace gen {
// namespace gen // namespace gen
} }

693
project/gen.dep.hpp
View File

@ -10,7 +10,7 @@
# define GEN_ARCH_64_BIT 1 # define GEN_ARCH_64_BIT 1
# endif # endif
#else #else
# ifndef GEN_ARCH_32_BIT # ifndef GEN_ARCH_32_BItxt_StrCaT
# define GEN_ARCH_32_BIT 1 # define GEN_ARCH_32_BIT 1
# endif # endif
#endif #endif
@ -91,6 +91,15 @@
# define GEN_HAS_ATTRIBUTE( attribute ) ( 0 ) # define GEN_HAS_ATTRIBUTE( attribute ) ( 0 )
#endif #endif
#if defined(GEN_GCC_VERSION_CHECK)
# undef GEN_GCC_VERSION_CHECK
#endif
#if defined(GEN_GCC_VERSION)
# define GEN_GCC_VERSION_CHECK(major,minor,patch) (GEN_GCC_VERSION >= GEN_VERSION_ENCODE(major, minor, patch))
#else
# define GEN_GCC_VERSION_CHECK(major,minor,patch) (0)
#endif
#define GEN_DEF_INLINE static #define GEN_DEF_INLINE static
#define GEN_IMPL_INLINE static inline #define GEN_IMPL_INLINE static inline
@ -149,7 +158,7 @@ namespace gen {
// Num Arguments (Varadics) // Num Arguments (Varadics)
#if defined(__GNUC__) || defined(__clang__) #if defined(__GNUC__) || defined(__clang__)
// Supports 0-10 arguments // Supports 0-10 arguments
#define num_args_impl( _0, \ #define num_args_impl( _0, \
_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \ _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
_11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \ _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \
N, ... \ N, ... \
@ -159,8 +168,8 @@ namespace gen {
// _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, // _41, _42, _43, _44, _45, _46, _47, _48, _49, _50,
// ## deletes preceding comma if _VA_ARGS__ is empty (GCC, Clang) // ## deletes preceding comma if _VA_ARGS__ is empty (GCC, Clang)
#define num_args(...) \ #define num_args(...) \
num_args_impl(_, ## __VA_ARGS__, \ num_args_impl(_, ## __VA_ARGS__, \
20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \ 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, \ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, \
0 \ 0 \
@ -170,14 +179,14 @@ namespace gen {
// 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, // 30, 29, 28, 27, 26, 25, 24, 23, 22, 21,
#else #else
// Supports 1-10 arguments // Supports 1-10 arguments
#define num_args_impl( \ #define num_args_impl( \
_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \ _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
_11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \ _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \
N, ... \ N, ... \
) N ) N
#define num_args(...) \ #define num_args(...) \
num_args_impl( __VA_ARGS__, \ num_args_impl( __VA_ARGS__, \
20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \ 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, \
10, 9, 8, 7, 6, 5, 4, 3, 2, 1 \ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 \
) )
@ -1283,6 +1292,7 @@ struct Array
Type* target = Data + idx; Type* target = Data + idx;
mem_move( target + 1, target, (header->Num - idx) * sizeof(Type) ); mem_move( target + 1, target, (header->Num - idx) * sizeof(Type) );
header->Num++;
return true; return true;
} }
@ -1309,7 +1319,6 @@ struct Array
mem_move( target, src, (header->Num - idx) * sizeof(Type) ); mem_move( target, src, (header->Num - idx) * sizeof(Type) );
mem_copy( src, items, item_num * sizeof(Type) ); mem_copy( src, items, item_num * sizeof(Type) );
header->Num += item_num; header->Num += item_num;
return true; return true;
@ -1730,378 +1739,378 @@ u64 crc64( void const* data, sw len );
#pragma endregion Hashing #pragma endregion Hashing
#pragma region String #pragma region String
// Constant string with length. // Constant string with length.
struct StrC struct StrC
{ {
sw Len; sw Len;
char const* Ptr; char const* Ptr;
operator char const* () const operator char const* () const
{ {
return Ptr; return Ptr;
} }
};
#define txt_StrC( text ) \
StrC { sizeof( text ) - 1, text }
StrC to_StrC( char const* str )
{
return { str_len( str ), str };
}
sw StrC_len( char const* str )
{
return (sw) ( str - 1 );
}
// Dynamic String
// This is directly based off the ZPL string api.
// They used a header pattern
// I kept it for simplicty of porting but its not necessary to keep it that way.
struct String
{
struct Header
{
AllocatorInfo Allocator;
sw Length;
sw Capacity;
}; };
#define txt_StrC( text ) \ static
(StrC){ sizeof( text ) - 1, text } uw grow_formula( uw value )
StrC to_StrC( char const* str )
{ {
return { str_len( str ), str }; // Using a very aggressive growth formula to reduce time mem_copying with recursive calls to append in this library.
return 4 * value + 8;
} }
sw StrC_len( char const* str ) static
String make( AllocatorInfo allocator, char const* str )
{ {
return (sw) ( str - 1 ); sw length = str ? str_len( str ) : 0;
return make_length( allocator, str, length );
} }
// Dynamic String static
// This is directly based off the ZPL string api. String make( AllocatorInfo allocator, StrC str )
// They used a header pattern
// I kept it for simplicty of porting but its not necessary to keep it that way.
struct String
{ {
struct Header return make_length( allocator, str.Ptr, str.Len );
{ }
AllocatorInfo Allocator;
sw Length;
sw Capacity;
};
static static
uw grow_formula( uw value ) String make_reserve( AllocatorInfo allocator, sw capacity )
{
constexpr sw header_size = sizeof( Header );
s32 alloc_size = header_size + capacity + 1;
void* allocation = alloc( allocator, alloc_size );
if ( allocation == nullptr )
return { nullptr };
mem_set( allocation, 0, alloc_size );
Header*
header = rcast(Header*, allocation);
header->Allocator = allocator;
header->Capacity = capacity;
header->Length = 0;
String result = { (char*)allocation + header_size };
return result;
}
static
String make_length( AllocatorInfo allocator, char const* str, sw length )
{
constexpr sw header_size = sizeof( Header );
s32 alloc_size = header_size + length + 1;
void* allocation = alloc( allocator, alloc_size );
if ( allocation == nullptr )
return { nullptr };
Header&
header = * rcast(Header*, allocation);
header = { allocator, length, length };
String result = { rcast( char*, allocation) + header_size };
if ( length && str )
mem_copy( result, str, length );
else
mem_set( result, 0, alloc_size - header_size );
result[ length ] = '\0';
return result;
}
static
String fmt( AllocatorInfo allocator, char* buf, sw buf_size, char const* fmt, ... );
static
String fmt_buf( AllocatorInfo allocator, char const* fmt, ... );
static
String join( AllocatorInfo allocator, char const** parts, sw num_parts, char const* glue )
{
String result = make( allocator, "" );
for ( sw idx = 0; idx < num_parts; ++idx )
{ {
// Using a very aggressive growth formula to reduce time mem_copying with recursive calls to append in this library. result.append( parts[ idx ] );
return 4 * value + 8;
if ( idx < num_parts - 1 )
result.append( glue );
} }
static return result;
String make( AllocatorInfo allocator, char const* str ) }
{
sw length = str ? str_len( str ) : 0;
return make_length( allocator, str, length );
}
static static
String make( AllocatorInfo allocator, StrC str ) bool are_equal( String lhs, String rhs )
{ {
return make_length( allocator, str.Ptr, str.Len ); if ( lhs.length() != rhs.length() )
} return false;
static for ( sw idx = 0; idx < lhs.length(); ++idx )
String make_reserve( AllocatorInfo allocator, sw capacity ) if ( lhs[ idx ] != rhs[ idx ] )
{
constexpr sw header_size = sizeof( Header );
s32 alloc_size = header_size + capacity + 1;
void* allocation = alloc( allocator, alloc_size );
if ( allocation == nullptr )
return { nullptr };
mem_set( allocation, 0, alloc_size );
Header*
header = rcast(Header*, allocation);
header->Allocator = allocator;
header->Capacity = capacity;
header->Length = 0;
String result = { (char*)allocation + header_size };
return result;
}
static
String make_length( AllocatorInfo allocator, char const* str, sw length )
{
constexpr sw header_size = sizeof( Header );
s32 alloc_size = header_size + length + 1;
void* allocation = alloc( allocator, alloc_size );
if ( allocation == nullptr )
return { nullptr };
Header&
header = * rcast(Header*, allocation);
header = { allocator, length, length };
String result = { rcast( char*, allocation) + header_size };
if ( length && str )
mem_copy( result, str, length );
else
mem_set( result, 0, alloc_size - header_size );
result[ length ] = '\0';
return result;
}
static
String fmt( AllocatorInfo allocator, char* buf, sw buf_size, char const* fmt, ... );
static
String fmt_buf( AllocatorInfo allocator, char const* fmt, ... );
static
String join( AllocatorInfo allocator, char const** parts, sw num_parts, char const* glue )
{
String result = make( allocator, "" );
for ( sw idx = 0; idx < num_parts; ++idx )
{
result.append( parts[ idx ] );
if ( idx < num_parts - 1 )
result.append( glue );
}
return result;
}
static
bool are_equal( String lhs, String rhs )
{
if ( lhs.length() != rhs.length() )
return false; return false;
for ( sw idx = 0; idx < lhs.length(); ++idx ) return true;
if ( lhs[ idx ] != rhs[ idx ] ) }
return false;
bool make_space_for( char const* str, sw add_len )
{
sw available = avail_space();
// NOTE: Return if there is enough space left
if ( available >= add_len )
{
return true; return true;
} }
else
bool make_space_for( char const* str, sw add_len )
{ {
sw available = avail_space(); sw new_len, old_size, new_size;
// NOTE: Return if there is enough space left void* ptr;
if ( available >= add_len ) void* new_ptr;
{
return true;
}
else
{
sw new_len, old_size, new_size;
void* ptr; AllocatorInfo allocator = get_header().Allocator;
void* new_ptr; Header* header = nullptr;
AllocatorInfo allocator = get_header().Allocator; new_len = grow_formula( length() + add_len );
Header* header = nullptr; ptr = & get_header();
old_size = size_of( Header ) + length() + 1;
new_size = size_of( Header ) + new_len + 1;
new_len = grow_formula( length() + add_len ); new_ptr = resize( allocator, ptr, old_size, new_size );
ptr = & get_header();
old_size = size_of( Header ) + length() + 1;
new_size = size_of( Header ) + new_len + 1;
new_ptr = resize( allocator, ptr, old_size, new_size ); if ( new_ptr == nullptr )
return false;
if ( new_ptr == nullptr ) header = zpl_cast( Header* ) new_ptr;
return false; header->Allocator = allocator;
header->Capacity = new_len;
header = zpl_cast( Header* ) new_ptr; Data = rcast( char*, header + 1 );
header->Allocator = allocator;
header->Capacity = new_len;
Data = rcast( char*, header + 1 );
return str;
}
}
bool append( char const* str )
{
return append( str, str_len( str ) );
}
bool append( char const* str, sw length )
{
if ( sptr(str) > 0 )
{
sw curr_len = this->length();
if ( ! make_space_for( str, length ) )
return false;
Header& header = get_header();
mem_copy( Data + curr_len, str, length );
Data[ curr_len + length ] = '\0';
header.Length = curr_len + length;
}
return str; return str;
} }
}
bool append( StrC str) bool append( char const* str )
{
return append( str, str_len( str ) );
}
bool append( char const* str, sw length )
{
if ( sptr(str) > 0 )
{ {
return append( str.Ptr, str.Len ); sw curr_len = this->length();
}
bool append( const String other ) if ( ! make_space_for( str, length ) )
{ return false;
return append( other.Data, other.length() );;
}
bool append_fmt( char const* fmt, ... );
sw avail_space() const
{
Header const&
header = * rcast( Header const*, Data - sizeof( Header ));
return header.Capacity - header.Length;
}
sw capacity() const
{
Header const&
header = * rcast( Header const*, Data - sizeof( Header ));
return header.Capacity;
}
void clear()
{
get_header().Length = 0;
}
String duplicate( AllocatorInfo allocator )
{
return make_length( allocator, Data, length() );
}
void free()
{
if ( ! Data )
return;
Header& header = get_header(); Header& header = get_header();
gen::free( header.Allocator, & header ); mem_copy( Data + curr_len, str, length );
Data[ curr_len + length ] = '\0';
header.Length = curr_len + length;
} }
return str;
}
Header& get_header() bool append( StrC str)
{
return *(Header*)(Data - sizeof(Header));
}
sw length() const
{
Header const&
header = * rcast( Header const*, Data - sizeof( Header ));
return header.Length;
}
void trim( char const* cut_set )
{
sw len = 0;
char* start_pos = Data;
char* end_pos = Data + length() - 1;
while ( start_pos <= end_pos && char_first_occurence( cut_set, *start_pos ) )
start_pos++;
while ( end_pos > start_pos && char_first_occurence( cut_set, *end_pos ) )
end_pos--;
len = scast( sw, ( start_pos > end_pos ) ? 0 : ( ( end_pos - start_pos ) + 1 ) );
if ( Data != start_pos )
mem_move( Data, start_pos, len );
Data[ len ] = '\0';
get_header().Length = len;
}
void trim_space()
{
return trim( " \t\r\n\v\f" );
}
// For-range support
char* begin()
{
return Data;
}
char* end()
{
Header const&
header = * rcast( Header const*, Data - sizeof( Header ));
return Data + header.Length;
}
operator bool()
{
return Data;
}
operator char* ()
{
return Data;
}
operator char const* () const
{
return Data;
}
operator StrC() const
{
return
{
length(),
Data
};
}
// Used with cached strings
// Essentially makes the string a string view.
String const& operator = ( String const& other ) const
{
if ( this == & other )
return *this;
String& this_ = ccast( String, *this );
this_.Data = other.Data;
return this_;
}
char& operator [] ( sw index )
{
return Data[ index ];
}
char const& operator [] ( sw index ) const
{
return Data[ index ];
}
char* Data = nullptr;
};
struct String_POD
{ {
char* Data; return append( str.Ptr, str.Len );
}
operator String() bool append( const String other )
{
return append( other.Data, other.length() );;
}
bool append_fmt( char const* fmt, ... );
sw avail_space() const
{
Header const&
header = * rcast( Header const*, Data - sizeof( Header ));
return header.Capacity - header.Length;
}
sw capacity() const
{
Header const&
header = * rcast( Header const*, Data - sizeof( Header ));
return header.Capacity;
}
void clear()
{
get_header().Length = 0;
}
String duplicate( AllocatorInfo allocator )
{
return make_length( allocator, Data, length() );
}
void free()
{
if ( ! Data )
return;
Header& header = get_header();
gen::free( header.Allocator, & header );
}
Header& get_header()
{
return *(Header*)(Data - sizeof(Header));
}
sw length() const
{
Header const&
header = * rcast( Header const*, Data - sizeof( Header ));
return header.Length;
}
void trim( char const* cut_set )
{
sw len = 0;
char* start_pos = Data;
char* end_pos = Data + length() - 1;
while ( start_pos <= end_pos && char_first_occurence( cut_set, *start_pos ) )
start_pos++;
while ( end_pos > start_pos && char_first_occurence( cut_set, *end_pos ) )
end_pos--;
len = scast( sw, ( start_pos > end_pos ) ? 0 : ( ( end_pos - start_pos ) + 1 ) );
if ( Data != start_pos )
mem_move( Data, start_pos, len );
Data[ len ] = '\0';
get_header().Length = len;
}
void trim_space()
{
return trim( " \t\r\n\v\f" );
}
// For-range support
char* begin()
{
return Data;
}
char* end()
{
Header const&
header = * rcast( Header const*, Data - sizeof( Header ));
return Data + header.Length;
}
operator bool()
{
return Data;
}
operator char* ()
{
return Data;
}
operator char const* () const
{
return Data;
}
operator StrC() const
{
return
{ {
return * rcast(String*, this); length(),
} Data
}; };
static_assert( sizeof( String_POD ) == sizeof( String ), "String is not a POD" ); }
// Used with cached strings
// Essentially makes the string a string view.
String const& operator = ( String const& other ) const
{
if ( this == & other )
return *this;
String& this_ = ccast( String, *this );
this_.Data = other.Data;
return this_;
}
char& operator [] ( sw index )
{
return Data[ index ];
}
char const& operator [] ( sw index ) const
{
return Data[ index ];
}
char* Data = nullptr;
};
struct String_POD
{
char* Data;
operator String()
{
return * rcast(String*, this);
}
};
static_assert( sizeof( String_POD ) == sizeof( String ), "String is not a POD" );
#pragma endregion String #pragma endregion String
#pragma region File Handling #pragma region File Handling
@ -2336,7 +2345,7 @@ GEN_DEF_INLINE s64 file_tell( FileInfo* file );
* @param buffer Buffer to read from * @param buffer Buffer to read from
* @param size Size to read * @param size Size to read
*/ */
b32 file_write( FileInfo* file, void const* buffer, sw size ); GEN_DEF_INLINE b32 file_write( FileInfo* file, void const* buffer, sw size );
/** /**
* Writes to file at a specific offset * Writes to file at a specific offset
@ -2543,7 +2552,7 @@ struct ADT_Node
/* properties */ /* properties */
ADT_Type type : 4; ADT_Type type : 4;
u8 props : 4; u8 props : 4;
#ifndef ZPL_PARSER_DISABLE_ANALYSIS #ifndef GEN_PARSER_DISABLE_ANALYSIS
u8 cfg_mode : 1; u8 cfg_mode : 1;
u8 name_style : 2; u8 name_style : 2;
u8 assign_style : 2; u8 assign_style : 2;
@ -2566,7 +2575,7 @@ struct ADT_Node
s64 integer; s64 integer;
}; };
#ifndef ZPL_PARSER_DISABLE_ANALYSIS #ifndef GEN_PARSER_DISABLE_ANALYSIS
/* number analysis */ /* number analysis */
s32 base; s32 base;
s32 base2; s32 base2;

8
project/gen.editor.hpp
View File

@ -1,6 +1,6 @@
#pragma once #pragma once
#include "gen.hpp" #include "gen.scanner.hpp"
namespace gen { namespace gen {
@ -52,9 +52,9 @@ struct Editor
static void set_allocator( AllocatorInfo allocator ); static void set_allocator( AllocatorInfo allocator );
Array(FileInfo) Files; Array<FileInfo> Files;
String Buffer; String Buffer;
Array(RequestEntry) Requests; Array<RequestEntry> Requests;
void add_files( s32 num, char const** files ); void add_files( s32 num, char const** files );
@ -66,7 +66,7 @@ struct Editor
void refactor( char const* file_path, char const* specification_path ); void refactor( char const* file_path, char const* specification_path );
# endif # endif
bool process_requests( Array(Receipt) out_receipts ); bool process_requests( Array<Receipt> out_receipts );
}; };
// namespace gen // namespace gen

26
project/gen.hpp
View File

@ -14,7 +14,7 @@
#include "gen.push_ignores.inline.hpp" #include "gen.push_ignores.inline.hpp"
//! If its desired to roll your own dependencies, define GENCPP_PROVIDE_DEPENDENCIES before including this file. //! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl // Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
#ifndef GEN_ROLL_OWN_DEPENDENCIES #ifndef GEN_ROLL_OWN_DEPENDENCIES
# include "gen.dep.hpp" # include "gen.dep.hpp"
@ -240,9 +240,9 @@ namespace ESpecifier
# pragma push_macro( "global" ) # pragma push_macro( "global" )
# pragma push_macro( "internal" ) # pragma push_macro( "internal" )
# pragma push_macro( "local_persist" ) # pragma push_macro( "local_persist" )
# define global global # undef global
# define internal internal # undef internal
# define local_persist local_persist # undef local_persist
# define Entry( Spec_, Code_ ) { sizeof(stringize(Code_)), stringize(Code_) }, # define Entry( Spec_, Code_ ) { sizeof(stringize(Code_)), stringize(Code_) },
Define_Specifiers Define_Specifiers
@ -348,7 +348,7 @@ namespace Attribute
constexpr char const* API_Import = stringize( GEN_API_Import_Code ); constexpr char const* API_Import = stringize( GEN_API_Import_Code );
constexpr char const* Keyword = stringize( GEN_Attribute_Keyword); constexpr char const* Keyword = stringize( GEN_Attribute_Keyword);
#elif GEN_HAS_ATTRIBUTE( visibility ) || GEN_GCC_VERSION_CHECK( 3, 3, 0 ) || GEN_INTEL_VERSION_CHECK( 13, 0, 0 ) #elif GEN_HAS_ATTRIBUTE( visibility ) || GEN_GCC_VERSION_CHECK( 3, 3, 0 )
# define GEN_API_Export_Code __attribute__ ((visibility ("default"))) # define GEN_API_Export_Code __attribute__ ((visibility ("default")))
# define GEN_API_Import_Code __attribute__ ((visibility ("default"))) # define GEN_API_Import_Code __attribute__ ((visibility ("default")))
# define GEN_Attribute_Keyword __attribute__ # define GEN_Attribute_Keyword __attribute__
@ -1244,7 +1244,7 @@ static_assert( sizeof(AST_Type) == sizeof(AST), "ERROR: AST_Type is not the same
struct AST_Typedef struct AST_Typedef
{ {
union { union {
char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ]; char _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
struct struct
{ {
CodeAttributes Attributes; CodeAttributes Attributes;
@ -1253,13 +1253,13 @@ struct AST_Typedef
char _PAD_PROPERTIES_[ sizeof(AST*) * 2 ]; char _PAD_PROPERTIES_[ sizeof(AST*) * 2 ];
}; };
}; };
Code Prev; Code Prev;
Code Next; Code Next;
Code Parent; Code Parent;
StringCached Name; StringCached Name;
CodeT Type; CodeT Type;
ModuleFlag ModuleFlags; ModuleFlag ModuleFlags;
char _PAD_UNUSED_[ sizeof(u32) ]; char _PAD_UNUSED_[ sizeof(u32) ];
}; };
static_assert( sizeof(AST_Typedef) == sizeof(AST), "ERROR: AST_Typedef is not the same size as AST"); static_assert( sizeof(AST_Typedef) == sizeof(AST), "ERROR: AST_Typedef is not the same size as AST");

9
project/gen.scanner.hpp
View File

@ -29,15 +29,16 @@ struct Scanner
static void set_allocator( AllocatorInfo allocator ); static void set_allocator( AllocatorInfo allocator );
Array(FileInfo) Files; Array<FileInfo> Files;
String Buffer; String Buffer;
Array(RequestEntry) Requests; Array<RequestEntry> Requests;
void add_files( s32 num, char const** files ); void add_files( s32 num, char const** files );
void add( SymbolInfo signature, Policy policy ); void add( SymbolInfo signature, Policy policy );
bool process_requests( Array(Receipt) out_receipts ); bool process_requests( Array<Receipt> out_receipts );
}; };
k
// namespace gen
} }