gencpp/project/gen.hpp

/*
	gencpp: An attempt at "simple" staged metaprogramming for c/c++.

	See Readme.md for more information from the project repository.

	Public Address:
	https://github.com/Ed94/gencpp
*/
#pragma once

#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
#error Gen.hpp : GEN_TIME not defined
#endif

#include "gen.push_ignores.inline.hpp"

//! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
#ifndef GEN_ROLL_OWN_DEPENDENCIES
#	include "gen.dep.hpp"
#endif

namespace gen {

#pragma region Types
using LogFailType = sw(*)(char const*, ...);

// By default this library will either crash or exit if an error is detected while generating codes.
// Even if set to not use fatal, fatal will still be used for memory failures as the library is unusable when they occur.
#ifdef GEN_DONT_USE_FATAL
	constexpr LogFailType log_failure = log_fmt;
#else
	constexpr LogFailType log_failure = fatal;
#endif

namespace ECode
{
#	define Define_Types           \
	Entry( Untyped )              \
	Entry( Comment )              \
	Entry( Access_Private )       \
	Entry( Access_Protected )     \
	Entry( Access_Public )        \
	Entry( PlatformAttributes )   \
	Entry( Class )                \
	Entry( Class_Fwd )            \
	Entry( Class_Body )           \
	Entry( Enum )                 \
	Entry( Enum_Fwd )             \
	Entry( Enum_Body )            \
	Entry( Enum_Class )           \
	Entry( Enum_Class_Fwd )       \
	Entry( Execution )            \
	Entry( Export_Body )          \
	Entry( Extern_Linkage )       \
	Entry( Extern_Linkage_Body )  \
	Entry( Friend )               \
	Entry( Function )             \
	Entry( Function_Fwd )         \
	Entry( Function_Body )        \
	Entry( Global_Body )          \
	Entry( Module )               \
	Entry( Namespace )            \
	Entry( Namespace_Body )       \
	Entry( Operator )             \
	Entry( Operator_Fwd )         \
	Entry( Operator_Member )      \
	Entry( Operator_Member_Fwd )  \
	Entry( Operator_Cast )		  \
	Entry( Operator_Cast_Fwd )    \
	Entry( Parameters )           \
	Entry( Preprocessor_Include ) \
	Entry( Specifiers )           \
	Entry( Struct )               \
	Entry( Struct_Fwd )           \
	Entry( Struct_Body )          \
	Entry( Template )             \
	Entry( Typedef )              \
	Entry( Typename )             \
	Entry( Union )			      \
	Entry( Union_Body) 		      \
	Entry( Using )                \
	Entry( Using_Namespace )      \
	Entry( Variable )

	enum Type : u32
	{
	#	define Entry( Type ) Type,
		Define_Types
	#	undef Entry

		Num_Types,
		Invalid
	};

	inline
	StrC to_str( Type type )
	{
		static
		StrC lookup[Num_Types] = {
		#	define Entry( Type ) { sizeof(stringize(Type)), stringize(Type) },
			Define_Types
		#	undef Entry
		};

		return lookup[ type ];
	}

#	undef Define_Types
}
using CodeT = ECode::Type;

// Used to indicate if enum definitoin is an enum class or regular enum.
enum class EnumT : u8
{
	Regular,
	Class
};

constexpr EnumT EnumClass   = EnumT::Class;
constexpr EnumT EnumRegular = EnumT::Regular;

namespace EOperator
{
#	define Define_Operators       \
	Entry( Assign,          =  )  \
	Entry( Assign_Add,      += )  \
	Entry( Assign_Subtract, -= )  \
	Entry( Assign_Multiply, *= )  \
	Entry( Assign_Divide,   /= )  \
	Entry( Assign_Modulo,   %= )  \
	Entry( Assign_BAnd,     &= )  \
	Entry( Assign_BOr,      |= )  \
	Entry( Assign_BXOr,     ^= )  \
	Entry( Assign_LShift,   <<= ) \
	Entry( Assign_RShift,   >>= ) \
	Entry( Increment,       ++ )  \
	Entry( Decrement,       -- )  \
	Entry( Unary_Plus,      + )   \
	Entry( Unary_Minus,     - )   \
	Entry( UnaryNot,        ! )   \
	Entry( Add,             + )   \
	Entry( Subtract,        - )   \
	Entry( Multiply,        * )   \
	Entry( Divide,          / )   \
	Entry( Modulo,          % )   \
	Entry( BNot,            ~ )   \
	Entry( BAnd,            & )   \
	Entry( BOr,             | )   \
	Entry( BXOr,            ^ )   \
	Entry( LShift,          << )  \
	Entry( RShift,          >> )  \
	Entry( LAnd,            && )  \
	Entry( LOr,             || )  \
	Entry( LEqual,          == )  \
	Entry( LNot,            != )  \
	Entry( Lesser,          < )   \
	Entry( Greater,         > )   \
	Entry( LesserEqual,     <= )  \
	Entry( GreaterEqual,    >= )  \
	Entry( Subscript,       [] )  \
	Entry( Indirection,     * )   \
	Entry( AddressOf,       & )   \
	Entry( MemberOfPointer, -> )  \
	Entry( PtrToMemOfPtr,   ->* ) \
	Entry( FunctionCall,    () )

	enum Type : u32
	{
	#	define Entry( Type_, Token_ ) Type_,
		Define_Operators
	#	undef Entry
		Comma,

		Num_Ops,
		Invalid
	};

	inline
	char const* to_str( Type op )
	{
		local_persist
		char const* lookup[ Num_Ops ] = {
		#	define Entry( Type_, Token_ ) stringize(Token_),
			Define_Operators
		#	undef Entry
			","
		};

		return lookup[ op ];
	}

#	undef Define_Operators
}
using OperatorT = EOperator::Type;

namespace ESpecifier
{
/*
	Note: The following are handled separately:
	attributes
	alignas
*/

#	define Define_Specifiers                     \
	Entry( Invalid,          INVALID )           \
	Entry( Const,            const )             \
	Entry( Consteval,        consteval )         \
	Entry( Constexpr,        constexpr )         \
	Entry( Constinit,        constinit )         \
	Entry( External_Linkage, extern )            \
	Entry( Global,           global )            \
	Entry( Inline,           inline )            \
	Entry( Internal_Linkage, internal )          \
	Entry( Local_Persist,    local_persist )     \
	Entry( Mutable,          mutable )           \
	Entry( Ptr,              * )                 \
	Entry( Ref,              & )                 \
	Entry( Register,         register )          \
	Entry( RValue,           && )                \
	Entry( Static,           static  )           \
	Entry( Thread_Local,     thread_local )      \
	Entry( Volatile,         volatile )

	enum Type : u32
	{
	#	define Entry( Specifier, Code ) Specifier,
		Define_Specifiers
	#	undef Entry

		Num_Specifiers,
	};

	// Specifier to string
	inline
	StrC to_str( Type specifier )
	{
		local_persist
		StrC lookup[ Num_Specifiers ] = {
		#	pragma push_macro( "global" )
		#	pragma push_macro( "internal" )
		#	pragma push_macro( "local_persist" )
		#	undef global
		#	undef internal
		#	undef local_persist

		#	define Entry( Spec_, Code_ ) { sizeof(stringize(Code_)), stringize(Code_) },
			Define_Specifiers
		#	undef Entry

		#	pragma pop_macro( "global" )
		#	pragma pop_macro( "internal" )
		#	pragma pop_macro( "local_persist" )
		};

		return lookup[ specifier ];
	}

	inline
	Type to_type( StrC str )
	{
		local_persist
		u32 keymap[ Num_Specifiers ];
		do_once_start
			for ( u32 index = 0; index < Num_Specifiers; index++ )
			{
				StrC enum_str = to_str( (Type)index );

				// We subtract 1 to remove the null terminator
				// This is because the tokens lexed are not null terminated.
				keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1);
			}
		do_once_end

		u32 hash = crc32( str.Ptr, str.Len );

		for ( u32 index = 0; index < Num_Specifiers; index++ )
		{
			if ( keymap[index] == hash )
				return (Type)index;
		}

		return Invalid;
	}

#	undef Define_Specifiers
}
using SpecifierT = ESpecifier::Type;

enum class AccessSpec : u32
{
	Default,
	Public,
	Protected,
	Private,

	Num_AccessSpec,
	Invalid,
};

inline
char const* to_str( AccessSpec type )
{
	local_persist
	char const* lookup[ (u32)AccessSpec::Num_AccessSpec ] = {
		"",
		"public",
		"protected",
		"private",
	};

	if ( type > AccessSpec::Public )
		return "Invalid";

	return lookup[ (u32)type ];
}

enum class ModuleFlag : u32
{
	None    = 0,
	Export  = bit(0),
	Import  = bit(1),
	// Private = bit(2),

	Num_ModuleFlags,
	Invalid,
};

ModuleFlag operator|( ModuleFlag A, ModuleFlag B)
{
	return (ModuleFlag)( (u32)A | (u32)B );
}

/*
	Predefined attributes

	Used for the parser constructors to identify non-standard attributes
*/
namespace Attribute
{
#if defined(GEN_SYSTEM_WINDOWS) || defined( __CYGWIN__ )
#	define GEN_API_
#	define GEN_API_Export_Code   __declspec(dllexport)
#	define GEN_API_Import_Code   __declspec(dllimport)
#	define GEN_Attribute_Keyword __declspec

	constexpr char const* API_Export = stringize( GEN_API_Export_Code  );
	constexpr char const* API_Import = stringize( GEN_API_Import_Code  );
	constexpr char const* Keyword    = stringize( GEN_Attribute_Keyword);

#elif GEN_HAS_ATTRIBUTE( visibility ) || GEN_GCC_VERSION_CHECK( 3, 3, 0 )
#	define GEN_API_Export_Code   __attribute__ ((visibility ("default")))
#	define GEN_API_Import_Code   __attribute__ ((visibility ("default")))
#	define GEN_Attribute_Keyword __attribute__

	constexpr char const* API_Export = stringize( GEN_API_Export_Code );
	constexpr char const* API_Import = stringize( GEN_API_Import_Code );
	constexpr char const* Keyword    = stringize( GEN_Attribute_Keyword);

#else
#	define GEN_API_Export_Code
#	define GEN_API_Import_Code
#	define GEN_Attribute_Keyword

	constexpr char const* API_Export = "";
	constexpr char const* API_Import = "";
	constexpr char const* Keyword    = "";
#endif
}
#pragma endregion Types

#pragma region Data Structures
// Implements basic string interning. Data structure is based off the ZPL Hashtable.
using StringTable = HashTable<String const>;

// Represents strings cached with the string table.
// Should never be modified, if changed string is desired, cache_string( str ) another.
using StringCached = String const;

struct AST;
struct AST_Body;
struct AST_Attributes;
struct AST_Comment;
struct AST_Class;
struct AST_Enum;
struct AST_Exec;
struct AST_Extern;
struct AST_Include;
struct AST_Friend;
struct AST_Fn;
struct AST_Module;
struct AST_Namespace;
struct AST_Operator;
struct AST_OpCast;
struct AST_Param;
struct AST_Specifier;
struct AST_Struct;
struct AST_Template;
struct AST_Type;
struct AST_Typedef;
struct AST_Union;
struct AST_Using;
struct AST_UsingNamespace;
struct AST_Var;

struct Code;
struct CodeBody;
// These are to offer ease of use and optionally strong type safety for the AST.
struct CodeAttributes;
struct CodeComment;
struct CodeClass;
struct CodeEnum;
struct CodeExec;
struct CodeExtern;
struct CodeInclude;
struct CodeFriend;
struct CodeFn;
struct CodeModule;
struct CodeNamespace;
struct CodeOperator;
struct CodeOpCast;
struct CodeParam;
struct CodeSpecifier;
struct CodeStruct;
struct CodeTemplate;
struct CodeType;
struct CodeTypedef;
struct CodeUnion;
struct CodeUsing;
struct CodeUsingNamespace;
struct CodeVar;

/*
	AST* wrapper
	- Not constantly have to append the '*' as this is written often..
	- Allows for implicit conversion to any of the ASTs (raw or filtered).
*/
struct Code
{
#	pragma region Statics
	// Used to identify ASTs that should always be duplicated. (Global constant ASTs)
	static Code Global;

	// Used to identify invalid generated code.
	static Code Invalid;
#	pragma endregion Statics

	#define Using_Code( Typename )         \
	char const* debug_str();               \
	Code        duplicate();			   \
	bool        is_equal( Code other );    \
	bool        is_valid();                \
	void        set_global();              \
	String      to_string();               \
	Typename&   operator = ( AST* other ); \
	Typename&   operator = ( Code other ); \
	bool        operator ==( Code other ); \
	bool        operator !=( Code other ); \
	operator bool()                        \
	{                                      \
		return ast != nullptr;             \
	}

	template< class Type >
	Type cast()
	{
		return * rcast( Type*, this );
	}

	AST* operator ->()
	{
		return ast;
	}
	Code& operator ++();
	Code& operator*()
	{
		return *this;
	}

	Using_Code( Code );

	AST* ast;

#ifdef GEN_ENFORCE_STRONG_CODE_TYPES
#	define operator explicit operator
#endif
	operator CodeAttributes() const;
	operator CodeComment() const;
	operator CodeClass() const;
	operator CodeExec() const;
	operator CodeEnum() const;
	operator CodeExtern() const;
	operator CodeInclude() const;
	operator CodeFriend() const;
	operator CodeFn() const;
	operator CodeModule() const;
	operator CodeNamespace() const;
	operator CodeOperator() const;
	operator CodeOpCast() const;
	operator CodeParam() const;
	operator CodeSpecifier() const;
	operator CodeStruct() const;
	operator CodeTemplate() const;
	operator CodeType() const;
	operator CodeTypedef() const;
	operator CodeUnion() const;
	operator CodeUsing() const;
	operator CodeUsingNamespace() const;
	operator CodeVar() const;
	operator CodeBody() const;
	#undef operator
};

struct Code_POD
{
	AST* ast;
};

static_assert( sizeof(Code) == sizeof(Code_POD), "ERROR: Code is not POD" );

// Desired width of the AST data structure.
constexpr u32 AST_POD_Size = 128;

/*
	Simple AST POD with functionality to seralize into C++ syntax.
*/
struct AST
{
#	pragma region Member Functions
	void        append     ( AST* other );
	char const* debug_str  ();
	AST*        duplicate  ();
	Code&       entry      ( u32 idx );
	bool        has_entries();
	bool        is_equal   ( AST* other );
	String      to_string  ();
	char const* type_str();
	bool        validate_body();

	template< class Type >
	Type cast()
	{
		return * this;
	}

	operator Code();
	operator CodeBody();
	operator CodeAttributes();
	operator CodeComment();
	operator CodeClass();
	operator CodeEnum();
	operator CodeExec();
	operator CodeExtern();
	operator CodeInclude();
	operator CodeFriend();
	operator CodeFn();
	operator CodeModule();
	operator CodeNamespace();
	operator CodeOperator();
	operator CodeOpCast();
	operator CodeParam();
	operator CodeSpecifier();
	operator CodeStruct();
	operator CodeTemplate();
	operator CodeType();
	operator CodeTypedef();
	operator CodeUnion();
	operator CodeUsing();
	operator CodeUsingNamespace();
	operator CodeVar();
#	pragma endregion Member Functions

	constexpr static
	uw ArrSpecs_Cap =
	(
			AST_POD_Size
			- sizeof(AST*) * 3
			- sizeof(StringCached)
			- sizeof(CodeT)
			- sizeof(ModuleFlag)
			- sizeof(s32)
	)
	/ sizeof(SpecifierT) -1; // -1 for 4 extra bytes

	union {
		struct
		{
			AST*      Attributes;     // Class, Enum, Function, Struct, Typedef, Union, Using, Variable
			AST*      Specs;          // Function, Operator, Type symbol, Variable
			union {
				AST*  ParentType;     // Class, Struct
				AST*  ReturnType;     // Function, Operator
				AST*  UnderlyingType; // Enum, Typedef
				AST*  ValueType;      // Parameter, Variable
			};
			AST*      Params;         // Function, Operator, Template
			union {
				AST*  ArrExpr;        // Type Symbol
				AST*  Body;           // Class, Enum, Function, Namespace, Struct, Union
				AST*  Declaration;    // Friend, Template
				AST*  Value;          // Parameter, Variable
			};
		};
		StringCached  Content;        // Attributes, Comment, Execution, Include
		SpecifierT    ArrSpecs[AST::ArrSpecs_Cap]; // Specifiers
	};
	union {
		AST* Prev;
		AST* Front;
		AST* Last;
	};
	union {
		AST* Next;
		AST* Back;
	};
	AST*              Parent;
	StringCached      Name;
	CodeT             Type;
	ModuleFlag        ModuleFlags;
	union {
		OperatorT     Op;
		AccessSpec    ParentAccess;
		s32           NumEntries;
	};
};

struct AST_POD
{
	union {
		struct
		{
			AST*      Attributes;     // Class, Enum, Function, Struct, Typedef, Union, Using, Variable
			AST*      Specs;          // Function, Operator, Type symbol, Variable
			union {
				AST*  ParentType;     // Class, Struct
				AST*  ReturnType;     // Function, Operator
				AST*  UnderlyingType; // Enum, Typedef
				AST*  ValueType;      // Parameter, Variable
			};
			AST*      Params;         // Function, Operator, Template
			union {
				AST*  ArrExpr;        // Type Symbol
				AST*  Body;           // Class, Enum, Function, Namespace, Struct, Union
				AST*  Declaration;    // Friend, Template
				AST*  Value;          // Parameter, Variable
			};
		};
		StringCached  Content;        // Attributes, Comment, Execution, Include
		SpecifierT    ArrSpecs[AST::ArrSpecs_Cap]; // Specifiers
	};
	union {
		AST* Prev;
		AST* Front;
		AST* Last;
	};
	union {
		AST* Next;
		AST* Back;
	};
	AST*              Parent;
	StringCached      Name;
	CodeT             Type;
	ModuleFlag        ModuleFlags;
	union {
		OperatorT     Op;
		AccessSpec    ParentAccess;
		s32           NumEntries;
	};
};

// Its intended for the AST to have equivalent size to its POD.
// All extra functionality within the AST namespace should just be syntatic sugar.
static_assert( sizeof(AST)     == sizeof(AST_POD), "ERROR: AST IS NOT POD" );
static_assert( sizeof(AST_POD) == AST_POD_Size,    "ERROR: AST POD is not size of AST_POD_Size" );

// Used when the its desired when omission is allowed in a definition.
#define NoCode      { nullptr }
#define CodeInvalid (* Code::Invalid.ast) // Uses an implicitly overloaded cast from the AST to the desired code type.

#pragma region Code Types
#define Define_CodeType( Typename )                           \
struct Code##Typename                                         \
{                                                             \
	Using_Code( Code##Typename );                             \
	AST* raw() 				                                  \
	{                                                         \
		return rcast( AST*, ast );                            \
	}                                                         \
	operator Code()                                           \
	{                                                         \
		return * rcast( Code*, this );                        \
	}                                                         \
	AST_##Typename* operator->()                              \
	{                                                         \
		if ( ast == nullptr )                                 \
		{                                                     \
			log_failure("Attempt to dereference a nullptr!"); \
			return nullptr;                                   \
		}                                                     \
		return ast;                                           \
	}                                                         \
	AST_##Typename* ast;                                      \
}

struct CodeBody
{
	Using_Code( CodeBody );

	void append( Code other )
	{
		raw()->append( other.ast );
	}
	void append( CodeBody body )
	{
		for ( Code entry : body )
		{
			append( entry );
		}
	}
	bool has_entries()
	{
		return rcast( AST*, ast )->has_entries();
	}
	AST* raw()
	{
		return rcast( AST*, ast );
	}
	AST_Body* operator->()
	{
		return ast;
	}
	operator Code()
	{
		return * rcast( Code*, this );
	}
#pragma region Iterator
	Code begin()
	{
		if ( ast )
			return { rcast( AST*, ast)->Front };

		return { nullptr };
	}
	Code end()
	{
		return { rcast(AST*, ast)->Back->Next };
	}
#pragma endregion Iterator

	AST_Body* ast;
};

Define_CodeType( Attributes );
Define_CodeType( Comment );
Define_CodeType( Class );
Define_CodeType( Enum );
Define_CodeType( Exec );
Define_CodeType( Extern );
Define_CodeType( Include );
Define_CodeType( Friend );
Define_CodeType( Fn );
Define_CodeType( Module );
Define_CodeType( Namespace );
Define_CodeType( Operator );
Define_CodeType( OpCast );
Define_CodeType( Struct );
Define_CodeType( Template );
Define_CodeType( Type );
Define_CodeType(Typedef);
Define_CodeType( Union );
Define_CodeType( Using );
Define_CodeType( Var );

struct CodeParam
{
	Using_Code( CodeParam );

	void append( CodeParam other );

	CodeParam get( s32 idx );
	bool has_entries();
	AST* raw()
	{
		return rcast( AST*, ast );
	}
	AST_Param* operator->()
	{
		if ( ast == nullptr )
		{
			log_failure("Attempt to dereference a nullptr!");
			return nullptr;
		}
		return ast;
	}
	operator Code()
	{
		return { (AST*)ast };
	}
#pragma region Iterator
	CodeParam begin()
	{
		if ( ast )
			return { ast };

		return { nullptr };
	}
	CodeParam end()
	{
		return { (AST_Param*) rcast( AST*, ast)->Last };
	}
	CodeParam& operator++();
	CodeParam operator*()
	{
		return * this;
	}
#pragma endregion Iterator

	AST_Param* ast;
};

struct CodeSpecifier
{
	Using_Code( CodeSpecifier );

	bool append( SpecifierT spec )
	{
		if ( raw()->NumEntries == AST::ArrSpecs_Cap )
		{
			log_failure("CodeSpecifier: Attempted to append over %d specifiers to a specifiers AST!", AST::ArrSpecs_Cap );
			return false;
		}

		raw()->ArrSpecs[ raw()->NumEntries ] = spec;
		raw()->NumEntries++;
		return true;
	}
	s32 has( SpecifierT spec )
	{
		for ( s32 idx = 0; idx < raw()->NumEntries; idx++ )
		{
			if ( raw()->ArrSpecs[ raw()->NumEntries ] == spec )
				return idx;
		}

		return -1;
	}
	AST* raw()
	{
		return rcast( AST*, ast );
	}
	AST_Specifier* operator->()
	{
		if ( ast == nullptr )
		{
			log_failure("Attempt to dereference a nullptr!");
			return nullptr;
		}
		return ast;
	}
	operator Code()
	{
		return { (AST*) ast };
	}
#pragma region Iterator
	SpecifierT* begin()
	{
		if ( ast )
			return & raw()->ArrSpecs[0];

		return nullptr;
	}
	SpecifierT* end()
	{
		return raw()->ArrSpecs + raw()->NumEntries;
	}
#pragma endregion Iterator

	AST_Specifier* ast;
};

#undef Define_CodeType
#undef Using_Code
#pragma endregion Code Types

#pragma region Filtered ASTs
/*
	Show only relevant members of the AST for its type.
	AST* fields are replaced with Code types.
		- Guards assignemnts to AST* fields to ensure the AST is duplicated if assigned to another parent.
*/

struct AST_Body
{
	char              _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
	Code              Front;
	Code              Back;
	Code              Parent;
	StringCached      Name;
	CodeT             Type;
	char              _PAD_UNUSED_[ sizeof(ModuleFlag) ];
	s32 			  NumEntries;
};
static_assert( sizeof(AST_Body) == sizeof(AST), "ERROR: AST_Filtered is not the same size as AST");

struct AST_Attributes
{
	union {
		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		StringCached  Content;
	};
	Code              Prev;
	Code              Next;
	Code              Parent;
	StringCached      Name;
	CodeT             Type;
	char              _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
};
static_assert( sizeof(AST_Attributes) == sizeof(AST), "ERROR: AST_Attributes is not the same size as AST");

struct AST_Comment
{
	union {
		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		StringCached  Content;
	};
	Code              Prev;
	Code              Next;
	Code              Parent;
	StringCached      Name;
	CodeT             Type;
	char              _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
};
static_assert( sizeof(AST_Comment) == sizeof(AST), "ERROR: AST_Comment is not the same size as AST");

struct AST_Class
{
	union {
		char                _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			CodeAttributes  Attributes;
			char 	        _PAD_SPECS_ [ sizeof(AST*) ];
			CodeType        ParentType;
			char 	        _PAD_PARAMS_[ sizeof(AST*) ];
			CodeBody        Body;
		};
	};
	Code                    Prev;
	Code                    Next;
	Code                    Parent;
	StringCached            Name;
	CodeT                   Type;
	ModuleFlag              ModuleFlags;
	AccessSpec              ParentAccess;
};
static_assert( sizeof(AST_Class) == sizeof(AST), "ERROR: AST_Class is not the same size as AST");

struct AST_Enum
{
	union {
		char                _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			CodeAttributes Attributes;
			char           _PAD_SPEC_  [ sizeof(AST*) ];
			CodeType       UnderlyingType;
			char	       _PAD_PARAMS_[ sizeof(AST*) ];
			CodeBody       Body;
		};
	};
	Code                   Prev;
	Code                   Next;
	Code                   Parent;
	StringCached           Name;
	CodeT                  Type;
	ModuleFlag             ModuleFlags;
	char 			       _PAD_UNUSED_[ sizeof(u32) ];
};
static_assert( sizeof(AST_Enum) == sizeof(AST), "ERROR: AST_Enum is not the same size as AST");

struct AST_Exec
{
	union {
		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			char      _PAD_PROPERTIES_[ sizeof(AST*) * 5 ];
		};
	};
	Code              Prev;
	Code              Next;
	Code              Parent;
	StringCached      Name;
	CodeT             Type;
	char              _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
};
static_assert( sizeof(AST_Exec) == sizeof(AST), "ERROR: AST_Exec is not the same size as AST");

struct AST_Extern
{
	union {
		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			char      _PAD_PROPERTIES_[ sizeof(AST*) * 4 ];
			CodeBody  Body;
		};
	};
	Code              Prev;
	Code              Next;
	Code              Parent;
	StringCached      Name;
	CodeT             Type;
	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
};
static_assert( sizeof(AST_Extern) == sizeof(AST), "ERROR: AST_Extern is not the same size as AST");

struct AST_Include
{
	union {
		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		StringCached  Content;
	};
	Code              Prev;
	Code              Next;
	Code              Parent;
	StringCached      Name;
	CodeT             Type;
	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
};
static_assert( sizeof(AST_Include) == sizeof(AST), "ERROR: AST_Include is not the same size as AST");

struct AST_Friend
{
	union {
		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			char      _PAD_PROPERTIES_[ sizeof(AST*) * 4 ];
			Code      Declaration;
		};
	};
	Code              Prev;
	Code              Next;
	Code              Parent;
	StringCached      Name;
	CodeT             Type;
	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
};
static_assert( sizeof(AST_Friend) == sizeof(AST), "ERROR: AST_Friend is not the same size as AST");

struct AST_Fn
{
	union {
		char                _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			CodeAttributes  Attributes;
			CodeSpecifier   Specs;
			CodeType        ReturnType;
			CodeParam 	    Params;
			CodeBody        Body;
		};
	};
	Code                    Prev;
	Code                    Parent;
	Code                    Next;
	StringCached            Name;
	CodeT                   Type;
	ModuleFlag              ModuleFlags;
	char 			        _PAD_UNUSED_[ sizeof(u32) ];
};
static_assert( sizeof(AST_Fn) == sizeof(AST), "ERROR: AST_Fn is not the same size as AST");

struct AST_Module
{
	char              _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
	Code              Prev;
	Code              Next;
	Code              Parent;
	StringCached      Name;
	CodeT             Type;
	ModuleFlag        ModuleFlags;
	char 			  _PAD_UNUSED_[ sizeof(u32) ];
};
static_assert( sizeof(AST_Module) == sizeof(AST), "ERROR: AST_Module is not the same size as AST");

struct AST_Namespace
{
	union {
		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct {
			char 	  _PAD_PROPERTIES_[ sizeof(AST*) * 4 ];
			CodeBody  Body;
		};
	};
	Code              Prev;
	Code              Next;
	Code              Parent;
	StringCached      Name;
	CodeT             Type;
	ModuleFlag        ModuleFlags;
	char 			  _PAD_UNUSED_[ sizeof(u32) ];
};
static_assert( sizeof(AST_Namespace) == sizeof(AST), "ERROR: AST_Namespace is not the same size as AST");

struct AST_Operator
{
	union {
		char                _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			CodeAttributes  Attributes;
			CodeSpecifier   Specs;
			CodeType        ReturnType;
			CodeParam 	    Params;
			CodeBody        Body;
		};
	};
	Code                    Prev;
	Code                    Next;
	Code                    Parent;
	StringCached            Name;
	CodeT                   Type;
	ModuleFlag              ModuleFlags;
	OperatorT               Op;
};
static_assert( sizeof(AST_Operator) == sizeof(AST), "ERROR: AST_Operator is not the same size as AST");

struct AST_OpCast
{
	union {
		char          _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			char 	  _PAD_PROPERTIES_[ sizeof(AST*) * 2 ];
			CodeType  ValueType;
			char 	  _PAD_PROPERTIES_2_[ sizeof(AST*) ];
			CodeBody  Body;
		};
	};
	Code              Prev;
	Code              Next;
	Code              Parent;
	StringCached      Name;
	CodeT             Type;
	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
};
static_assert( sizeof(AST_OpCast) == sizeof(AST), "ERROR: AST_OpCast is not the same size as AST");

struct AST_Param
{
	union {
		char 		  _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			char 	  _PAD_PROPERTIES_2_[ sizeof(AST*) * 2 ];
			CodeType  ValueType;
			char 	  _PAD_PROPERTIES_[ sizeof(AST*) ];
			Code      Value;
		};
	};
	CodeParam         Last;
	CodeParam         Next;
	Code              Parent;
	StringCached      Name;
	CodeT             Type;
	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) ];
	s32               NumEntries;
};
static_assert( sizeof(AST_Param) == sizeof(AST), "ERROR: AST_Param is not the same size as AST");

struct AST_Specifier
{
	SpecifierT        ArrSpecs[ AST::ArrSpecs_Cap ];
	Code              Prev;
	Code              Next;
	Code              Parent;
	StringCached      Name;
	CodeT             Type;
	char 			  _PAD_UNUSED_[ sizeof(ModuleFlag) ];
	s32               NumEntries;
};
	static_assert( sizeof(AST_Specifier) == sizeof(AST), "ERROR: AST_Specifier is not the same size as AST");

struct AST_Struct
{
	union {
		char               _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			CodeAttributes Attributes;
			char 	       _PAD_SPECS_ [ sizeof(AST*) ];
			CodeType       ParentType;
			char 	       _PAD_PARAMS_[ sizeof(AST*) ];
			CodeBody       Body;
		};
	};
	Code                   Prev;
	Code                   Next;
	Code                   Parent;
	StringCached           Name;
	CodeT                  Type;
	ModuleFlag             ModuleFlags;
	AccessSpec             ParentAccess;
};
static_assert( sizeof(AST_Struct) == sizeof(AST), "ERROR: AST_Struct is not the same size as AST");

struct AST_Template
{
	union {
		char 		       _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			char 	       _PAD_PROPERTIES_[ sizeof(AST*) * 3 ];
			CodeParam 	   Params;
			Code           Declaration;
		};
	};
	Code                   Prev;
	Code                   Next;
	Code                   Parent;
	StringCached           Name;
	CodeT                  Type;
	ModuleFlag             ModuleFlags;
	char 			       _PAD_UNUSED_[ sizeof(u32) ];
};
static_assert( sizeof(AST_Template) == sizeof(AST), "ERROR: AST_Template is not the same size as AST");

struct AST_Type
{
	union {
		char 		       _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			CodeAttributes Attributes;
			CodeSpecifier  Specs;
			char 	       _PAD_PROPERTIES_[ sizeof(AST*) * 2 ];
			Code           ArrExpr;
		};
	};
	Code                   Prev;
	Code                   Next;
	Code                   Parent;
	StringCached           Name;
	CodeT                  Type;
	char 			       _PAD_UNUSED_[ sizeof(ModuleFlag) + sizeof(u32) ];
};
static_assert( sizeof(AST_Type) == sizeof(AST), "ERROR: AST_Type is not the same size as AST");

struct AST_Typedef
{
	union {
		char 		       _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			CodeAttributes Attributes;
			char 	       _PAD_SPECS_     [ sizeof(AST*) ];
			Code           UnderlyingType;
			char 	       _PAD_PROPERTIES_[ sizeof(AST*) * 2 ];
		};
	};
	Code                   Prev;
	Code                   Next;
	Code                   Parent;
	StringCached           Name;
	CodeT                  Type;
	ModuleFlag             ModuleFlags;
	char 			       _PAD_UNUSED_[ sizeof(u32) ];
};
static_assert( sizeof(AST_Typedef) == sizeof(AST), "ERROR: AST_Typedef is not the same size as AST");

struct AST_Union
{
	union {
		char 		       _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			CodeAttributes Attributes;
			char 	       _PAD_PROPERTIES_[ sizeof(AST*) * 3 ];
			CodeBody       Body;
		};
	};
	Code                   Prev;
	Code                   Next;
	Code                   Parent;
	StringCached           Name;
	CodeT                  Type;
	ModuleFlag             ModuleFlags;
	char 			       _PAD_UNUSED_[ sizeof(u32) ];
};
static_assert( sizeof(AST_Union) == sizeof(AST), "ERROR: AST_Union is not the same size as AST");

struct AST_Using
{
	union {
		char 		        _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			CodeAttributes  Attributes;
			char 	        _PAD_SPECS_     [ sizeof(AST*) ];
			CodeType        UnderlyingType;
			char 	        _PAD_PROPERTIES_[ sizeof(AST*) * 2 ];
		};
	};
	Code                    Prev;
	Code                    Next;
	Code                    Parent;
	StringCached            Name;
	CodeT                   Type;
	ModuleFlag              ModuleFlags;
	char 			        _PAD_UNUSED_[ sizeof(u32) ];
};
static_assert( sizeof(AST_Using) == sizeof(AST), "ERROR: AST_Using is not the same size as AST");

struct AST_Var
{
	union {
		char               _PAD_[ sizeof(SpecifierT) * AST::ArrSpecs_Cap ];
		struct
		{
			CodeAttributes Attributes;
			CodeSpecifier  Specs;
			CodeType       ValueType;
			char 	       _PAD_PROPERTIES_[ sizeof(AST*) ];
			Code           Value;
		};
	};
	Code                   Prev;
	Code                   Next;
	Code                   Parent;
	StringCached           Name;
	CodeT                  Type;
	ModuleFlag             ModuleFlags;
	char 			       _PAD_UNUSED_[ sizeof(u32) ];
};
static_assert( sizeof(AST_Var) == sizeof(AST), "ERROR: AST_Var is not the same size as AST");
#pragma endregion Filtered ASTs

#pragma endregion Data Structures

#pragma region Gen Interface
// Initialize the library.
// This currently just initializes the CodePool.
void init();

// Currently manually free's the arenas, code for checking for leaks.
// However on Windows at least, it doesn't need to occur as the OS will clean up after the process.
void deinit();

// Clears the allocations, but doesn't return to the heap, the calls init() again.
// Ease of use.
void reset();

// Used internally to retrive or make string allocations.
// Strings are stored in a series of string arenas of fixed size (SizePer_StringArena)
StringCached get_cached_string( StrC str );

/*
	This provides a fresh Code AST.
	The gen interface use this as their method from getting a new AST object from the CodePool.
	Use this if you want to make your own API for formatting the supported Code Types.
*/
Code make_code();

// Set these before calling gen's init() procedure.
// Data

void set_allocator_data_arrays       ( AllocatorInfo data_array_allocator );
void set_allocator_code_pool         ( AllocatorInfo pool_allocator );
void set_allocator_lexer             ( AllocatorInfo lex_allocator );
void set_allocator_string_arena      ( AllocatorInfo string_allocator );
void set_allocator_string_table      ( AllocatorInfo string_allocator );
void set_allocator_type_table        ( AllocatorInfo type_reg_allocator );

#pragma region Upfront
CodeAttributes def_attributes( StrC content );
CodeComment    def_comment   ( StrC content );

CodeClass def_class( StrC name
	, Code           body         = NoCode
	, CodeType       parent       = NoCode, AccessSpec access = AccessSpec::Default
	, CodeAttributes attributes   = NoCode
	, ModuleFlag mflags = ModuleFlag::None );

CodeEnum def_enum( StrC name
	, Code         body      = NoCode,      CodeType       type       = NoCode
	, EnumT        specifier = EnumRegular, CodeAttributes attributes = NoCode
	, ModuleFlag   mflags    = ModuleFlag::None );

CodeExec   def_execution  ( StrC content );
CodeExtern def_extern_link( StrC name, Code body );
CodeFriend def_friend     ( Code symbol );

CodeFn def_function( StrC name
	, CodeParam      params     = NoCode, CodeType       ret_type   = NoCode, Code body = NoCode
	, CodeSpecifier specifiers = NoCode, CodeAttributes attributes = NoCode
	, ModuleFlag mflags     = ModuleFlag::None );

CodeInclude   def_include  ( StrC content );
CodeModule    def_module   ( StrC name,            ModuleFlag mflags = ModuleFlag::None );
CodeNamespace def_namespace( StrC name, Code body, ModuleFlag mflags = ModuleFlag::None );

CodeOperator def_operator( OperatorT op
	, CodeParam      params     = NoCode, CodeType       ret_type   = NoCode, Code body = NoCode
	, CodeSpecifier specifiers = NoCode, CodeAttributes attributes = NoCode
	, ModuleFlag     mflags     = ModuleFlag::None );

CodeOpCast def_operator_cast( CodeType type, Code body = NoCode );

CodeParam      def_param    ( CodeType type, StrC name, Code value = NoCode );
CodeSpecifier def_specifier( SpecifierT specifier );

CodeStruct def_struct( StrC name
	, Code           body       = NoCode
	, CodeType       parent     = NoCode, AccessSpec access = AccessSpec::Default
	, CodeAttributes attributes = NoCode
	, ModuleFlag     mflags     = ModuleFlag::None );

CodeTemplate def_template( CodeParam params, Code definition, ModuleFlag mflags = ModuleFlag::None );

CodeType    def_type   ( StrC name, Code arrayexpr = NoCode, CodeSpecifier specifiers = NoCode, CodeAttributes attributes = NoCode );
CodeTypedef def_typedef( StrC name, Code type, CodeAttributes attributes = NoCode, ModuleFlag mflags = ModuleFlag::None );

CodeUnion def_union( StrC name, Code body, CodeAttributes attributes = NoCode, ModuleFlag mflags = ModuleFlag::None );

CodeUsing def_using( StrC name, CodeType type = NoCode
	, CodeAttributes attributess = NoCode
	, ModuleFlag     mflags      = ModuleFlag::None );

CodeUsing def_using_namespace( StrC name );

CodeVar def_variable( CodeType type, StrC name, Code value = NoCode
	, CodeSpecifier specifiers = NoCode, CodeAttributes attributes = NoCode
	, ModuleFlag     mflags     = ModuleFlag::None );

// Constructs an empty body. Use AST::validate_body() to check if the body is was has valid entries.
CodeBody def_body( CodeT type );

// There are two options for defining a struct body, either varadically provided with the args macro to auto-deduce the arg num,
/// or provide as an array of Code objects.

CodeBody      def_class_body      ( s32 num, ... );
CodeBody      def_class_body      ( s32 num, Code* codes );
CodeBody      def_enum_body       ( s32 num, ... );
CodeBody      def_enum_body       ( s32 num, Code* codes );
CodeBody      def_export_body     ( s32 num, ... );
CodeBody      def_export_body     ( s32 num, Code* codes);
CodeBody      def_extern_link_body( s32 num, ... );
CodeBody      def_extern_link_body( s32 num, Code* codes );
CodeBody      def_function_body   ( s32 num, ... );
CodeBody      def_function_body   ( s32 num, Code* codes );
CodeBody      def_global_body     ( s32 num, ... );
CodeBody      def_global_body     ( s32 num, Code* codes );
CodeBody      def_namespace_body  ( s32 num, ... );
CodeBody      def_namespace_body  ( s32 num, Code* codes );
CodeParam     def_params          ( s32 num, ... );
CodeParam     def_params          ( s32 num, CodeParam* params );
CodeSpecifier def_specifiers      ( s32 num, ... );
CodeSpecifier def_specifiers      ( s32 num, SpecifierT* specs );
CodeBody      def_struct_body     ( s32 num, ... );
CodeBody      def_struct_body     ( s32 num, Code* codes );
CodeBody      def_union_body      ( s32 num, ... );
CodeBody      def_union_body      ( s32 num, Code* codes );
#pragma endregion Upfront

#pragma region Parsing
CodeClass      parse_class        ( StrC class_def     );
CodeEnum       parse_enum         ( StrC enum_def      );
CodeBody       parse_export_body  ( StrC export_def    );
CodeExtern     parse_extern_link  ( StrC exten_link_def);
CodeFriend     parse_friend       ( StrC friend_def    );
CodeFn         parse_function     ( StrC fn_def        );
CodeBody       parse_global_body  ( StrC body_def      );
CodeNamespace  parse_namespace    ( StrC namespace_def );
CodeOperator   parse_operator     ( StrC operator_def  );
CodeOpCast     parse_operator_cast( StrC operator_def  );
CodeStruct     parse_struct       ( StrC struct_def    );
CodeTemplate   parse_template     ( StrC template_def  );
CodeType       parse_type         ( StrC type_def      );
CodeTypedef    parse_typedef      ( StrC typedef_def   );
CodeUnion      parse_union        ( StrC union_def     );
CodeUsing      parse_using        ( StrC using_def     );
CodeVar        parse_variable     ( StrC var_def       );
#pragma endregion Parsing

#pragma region Untyped text
sw   token_fmt_va( char* buf, uw buf_size, s32 num_tokens, va_list va );
StrC token_fmt_impl( sw, ... );

Code untyped_str      ( StrC content);
Code untyped_fmt      ( char const* fmt, ... );
Code untyped_token_fmt( char const* fmt, s32 num_tokens, ... );
#pragma endregion Untyped text

#pragma endregion Gen Interaface

struct Builder
{
	FileInfo File;
	String   Buffer;

	void print( Code );
	void print_fmt( char const* fmt, ... );

	bool open( char const* path );
	void write();
};

#pragma region Inlines
void AST::append( AST* other )
{
	if ( other->Parent )
		other = other->duplicate();

	other->Parent = this;

	if ( Front == nullptr )
	{
		Front = other;
		Back  = other;

		NumEntries++;
		return;
	}

	AST*
	Current       = Back;
	Current->Next = other;
	other->Prev   = Current;
	Back          = other;
	NumEntries++;
}

char const* AST::debug_str()
{
	char const* fmt = stringize(
		\nCode Debug:
		\nType    : %s
		\nParent  : %s
		\nName    : %s
		\nComment : %s
	);

	// These should be used immediately in a log.
	// Thus if its desired to keep the debug str
	// for multiple calls to bprintf,
	// allocate this to proper string.
	return str_fmt_buf( fmt
	,	type_str()
	,	Parent   ? Parent->Name : ""
	,	Name     ? Name         : ""
	);
}

Code& AST::entry( u32 idx )
{
	AST** current = & Front;
	while ( idx >= 0 && current != nullptr )
	{
		if ( idx == 0 )
			return * rcast( Code*, current);

		current = & ( * current )->Next;
		idx--;
	}

	return * rcast( Code*, current);
}

bool AST::has_entries()
{
	return NumEntries;
}

char const* AST::type_str()
{
	return ECode::to_str( Type );
}

AST::operator Code()
{
	return { this };
}

Code& Code::operator ++()
{
	if ( ast )
		ast = ast->Next;

	return *this;
}

#pragma region AST & Code Gen Common
#define Define_CodeImpl( Typename )                                                  \
char const* Typename::debug_str()                                                    \
{                                                                                    \
	if ( ast == nullptr )                                                            \
		return "Code::debug_str: AST is null!";                                      \
																				     \
	return rcast(AST*, ast)->debug_str();                                            \
}                                                                                    \
Code Typename::duplicate()														     \
{                                                                                    \
	if ( ast == nullptr )                                                            \
	{                                                                                \
		log_failure("Code::duplicate: Cannot duplicate code, AST is null!");         \
		return Code::Invalid;                                                        \
	}                                                                                \
																				     \
	return { rcast(AST*, ast)->duplicate() };                                        \
}                                                                                    \
bool Typename::is_equal( Code other )                                                \
{                                                                                    \
	if ( ast == nullptr || other.ast == nullptr )                                    \
	{                                                                                \
		log_failure("Code::is_equal: Cannot compare code, AST is null!");            \
		return false;                                                                \
	}                                                                                \
																				     \
	return rcast(AST*, ast)->is_equal( other.ast );                                  \
}                                                                                    \
bool Typename::is_valid()                                                            \
{                                                                                    \
	return (AST*) ast != nullptr && rcast( AST*, ast)->Type != CodeT::Invalid;       \
}                                                                                    \
void Typename::set_global()                                                          \
{                                                                                    \
	if ( ast == nullptr )                                                            \
	{                                                                                \
		log_failure("Code::set_global: Cannot set code as global, AST is null!");    \
		return;                                                                      \
	}                                                                                \
																					 \
	rcast(AST*, ast)->Parent = Code::Global.ast;                                     \
}                                                                                    \
String Typename::to_string()													     \
{                                                                                    \
	if ( ast == nullptr )                                                            \
	{                                                                                \
		log_failure("Code::to_string: Cannot convert code to string, AST is null!"); \
		return { nullptr };                                                          \
	}                                                                                \
																					 \
	return rcast(AST*, ast)->to_string();                                            \
}                                                                                    \
Typename& Typename::operator =( Code other )                                         \
{                                                                                    \
	if ( other.ast && other->Parent )                                                \
	{                                                                                \
		ast = rcast( decltype(ast), other.ast->duplicate() );                        \
		rcast( AST*, ast)->Parent = nullptr;                                         \
	}                                                                                \
																				     \
	ast = rcast( decltype(ast), other.ast );                                         \
	return *this;                                                                    \
}                                                                                    \
bool Typename::operator ==( Code other )                                             \
{                                                                                    \
	return (AST*) ast == other.ast;                                                  \
}                                                                                    \
bool Typename::operator !=( Code other )                                             \
{                                                                                    \
	return (AST*) ast != other.ast;                                                  \
}

Define_CodeImpl( Code );
Define_CodeImpl( CodeBody );
Define_CodeImpl( CodeAttributes );
Define_CodeImpl( CodeComment );
Define_CodeImpl( CodeClass );
Define_CodeImpl( CodeEnum );
Define_CodeImpl( CodeExec );
Define_CodeImpl( CodeExtern );
Define_CodeImpl( CodeInclude );
Define_CodeImpl( CodeFriend );
Define_CodeImpl( CodeFn );
Define_CodeImpl( CodeModule );
Define_CodeImpl( CodeNamespace );
Define_CodeImpl( CodeOperator );
Define_CodeImpl( CodeOpCast );
Define_CodeImpl( CodeParam );
Define_CodeImpl( CodeSpecifier );
Define_CodeImpl( CodeStruct );
Define_CodeImpl( CodeTemplate );
Define_CodeImpl( CodeType );
Define_CodeImpl( CodeTypedef );
Define_CodeImpl( CodeUnion );
Define_CodeImpl( CodeUsing );
Define_CodeImpl( CodeVar );
#undef Define_CodeImpl

#define Define_AST_Cast( typename )              \
AST::operator Code ## typename()                 \
{                                                \
	return { rcast( AST_ ## typename*, this ) }; \
}

Define_AST_Cast( Body );
Define_AST_Cast( Attributes );
Define_AST_Cast( Comment );
Define_AST_Cast( Class );
Define_AST_Cast( Enum );
Define_AST_Cast( Exec );
Define_AST_Cast( Extern );
Define_AST_Cast( Include );
Define_AST_Cast( Friend );
Define_AST_Cast( Fn );
Define_AST_Cast( Module );
Define_AST_Cast( Namespace );
Define_AST_Cast( Operator );
Define_AST_Cast( OpCast );
Define_AST_Cast( Param );
Define_AST_Cast( Specifier );
Define_AST_Cast( Struct );
Define_AST_Cast( Template );
Define_AST_Cast( Type );
Define_AST_Cast( Typedef );
Define_AST_Cast( Union );
Define_AST_Cast( Using );
Define_AST_Cast( Var );
#undef Define_AST_Cast

#define Define_CodeCast( type )     \
Code::operator Code ## type() const \
{                                   \
	return { (AST_ ## type*) ast }; \
}

Define_CodeCast( Attributes );
Define_CodeCast( Comment );
Define_CodeCast( Class );
Define_CodeCast( Exec );
Define_CodeCast( Enum );
Define_CodeCast( Extern );
Define_CodeCast( Include );
Define_CodeCast( Friend );
Define_CodeCast( Fn );
Define_CodeCast( Module );
Define_CodeCast( Namespace );
Define_CodeCast( Operator );
Define_CodeCast( OpCast );
Define_CodeCast( Param );
Define_CodeCast( Specifier );
Define_CodeCast( Struct );
Define_CodeCast( Template );
Define_CodeCast( Type );
Define_CodeCast( Typedef );
Define_CodeCast( Union );
Define_CodeCast( Using );
Define_CodeCast( Var );
Define_CodeCast( Body);
#undef Define_CodeCast
#pragma endregion AST & Code Gen Common

void CodeParam::append( CodeParam other )
{
	AST* self  = (AST*) ast;
	AST* entry = (AST*) other.ast;

	if ( entry->Parent )
		entry = entry->duplicate();

	entry->Parent = self;

	if ( self->Last == nullptr )
	{
		self->Last = entry;
		self->Next = entry;
		self->NumEntries++;
		return;
	}

	self->Last->Next = entry;
	self->Last       = entry;
	self->NumEntries++;
}

CodeParam CodeParam::get( s32 idx )
{
	CodeParam param = *this;
	do
	{
		if ( ! ++ param )
			return { nullptr };

		return { (AST_Param*) param.raw()->Next };
	}
	while ( --idx );

	return { nullptr };
}

bool CodeParam::has_entries()
{
	return ast->NumEntries > 0;
}

CodeParam& CodeParam::operator ++()
{
	ast = ast->Next.ast;
	return * this;
}

CodeBody def_body( CodeT type )
{
	switch ( type )
	{
		using namespace ECode;
		case Class_Body:
		case Enum_Body:
		case Export_Body:
		case Extern_Linkage:
		case Function_Body:
		case Global_Body:
		case Namespace_Body:
		case Struct_Body:
		case Union_Body:
		break;

		default:
			log_failure( "def_body: Invalid type %s", (char const*)ECode::to_str(type) );
			return (CodeBody)Code::Invalid;
	}

	Code
	result       = make_code();
	result->Type = type;
	return (CodeBody)result;
}

//! Do not use directly. Use the token_fmt macro instead.
// Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC of the formatted string.
StrC token_fmt_impl( sw num, ... )
{
	local_persist thread_local
	char buf[GEN_PRINTF_MAXLEN] = { 0 };
	mem_set( buf, 0, GEN_PRINTF_MAXLEN );

	va_list va;
	va_start(va, num );
	sw result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
	va_end(va);

	return { result, buf };
}
#pragma endregion Inlines

// namespace gen
}

#pragma region Constants
#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
namespace gen
{
	// Predefined typename codes. Are set to readonly and are setup during gen::init()

	extern CodeType t_b32;

	extern CodeType t_s8;
	extern CodeType t_s16;
	extern CodeType t_s32;
	extern CodeType t_s64;

	extern CodeType t_u8;
	extern CodeType t_u16;
	extern CodeType t_u32;
	extern CodeType t_u64;

	extern CodeType t_sw;
	extern CodeType t_uw;

	extern CodeType t_f32;
	extern CodeType t_f64;
}
#endif

namespace gen
{
	// These constexprs are used for allocation behavior of data structures
	// or string handling while constructing or serializing.
	// Change them to suit your needs.

	constexpr s32 InitSize_DataArrays  = 16;
	constexpr s32 InitSize_StringTable = megabytes(4);

	// NOTE: This limits the maximum size of an allocation
	// If you are generating a string larger than this, increase the size of the bucket here.
	constexpr uw Global_BucketSize          = megabytes(10);
	constexpr s32 CodePool_NumBlocks        = kilobytes(64);
	constexpr s32 SizePer_StringArena       = megabytes(1);

	constexpr s32 MaxCommentLineLength      = 1024;
	constexpr s32 MaxNameLength             = 128;
	constexpr s32 MaxUntypedStrLength       = kilobytes(640);
	constexpr s32 StringTable_MaxHashLength = kilobytes(1);
	constexpr s32 TokenFmt_TokenMap_MemSize	= kilobytes(4);
	constexpr s32 LexAllocator_Size         = megabytes(10);
	constexpr s32 Builder_StrBufferReserve  = megabytes(1);

	extern CodeType t_auto;
	extern CodeType t_void;
	extern CodeType t_int;
	extern CodeType t_bool;
	extern CodeType t_char;
	extern CodeType t_wchar_t;
	extern CodeType t_class;
	extern CodeType t_typename;

	extern Code access_public;
	extern Code access_protected;
	extern Code access_private;

	extern Code module_global_fragment;
	extern Code module_private_fragment;

	extern Code pragma_once;

	extern CodeSpecifier spec_const;
	extern CodeSpecifier spec_consteval;
	extern CodeSpecifier spec_constexpr;
	extern CodeSpecifier spec_constinit;
	extern CodeSpecifier spec_extern_linkage;
	extern CodeSpecifier spec_global;
	extern CodeSpecifier spec_inline;
	extern CodeSpecifier spec_internal_linkage;
	extern CodeSpecifier spec_local_persist;
	extern CodeSpecifier spec_mutable;
	extern CodeSpecifier spec_ptr;
	extern CodeSpecifier spec_ref;
	extern CodeSpecifier spec_register;
	extern CodeSpecifier spec_rvalue;
	extern CodeSpecifier spec_static_member;
	extern CodeSpecifier spec_thread_local;
	extern CodeSpecifier spec_volatile;
}
#pragma endregion Constants

#pragma region Macros
#	define gen_main main

#	define __ NoCode

//	Convienence for defining any name used with the gen api.
//  Lets you provide the length and string literal to the functions without the need for the DSL.
#	define name( Id_ )   { sizeof(stringize( Id_ )) - 1, stringize(Id_) }

//  Same as name just used to indicate intention of literal for code instead of names.
#	define code( ... ) { sizeof(stringize(__VA_ARGS__)) - 1, stringize( __VA_ARGS__ ) }

#	define args( ... ) num_args( __VA_ARGS__ ), __VA_ARGS__

#	define code_str( ... ) gen::untyped_str( code( __VA_ARGS__ ) )
#	define code_fmt( ... ) gen::untyped_str( token_fmt( __VA_ARGS__ ) )

// Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC of the formatted string.
#	define token_fmt( ... ) gen::token_fmt_impl( (num_args( __VA_ARGS__ ) + 1) / 2, __VA_ARGS__ )
#pragma endregion Macros

#ifdef GEN_EXPOSE_BACKEND
namespace gen
{
	// Global allocator used for data with process lifetime.
	extern AllocatorInfo  GlobalAllocator;
	extern Array< Arena > Global_AllocatorBuckets;
	extern Array< Pool >  CodePools;
	extern Array< Arena > StringArenas;

	extern StringTable StringCache;

	extern Arena LexArena;

	extern AllocatorInfo Allocator_DataArrays;
	extern AllocatorInfo Allocator_CodePool;
	extern AllocatorInfo Allocator_Lexer;
	extern AllocatorInfo Allocator_StringArena;
	extern AllocatorInfo Allocator_StringTable;
	extern AllocatorInfo Allocator_TypeTable;
}
#endif

#include "gen.pop_ignores.inline.hpp"