gunslinger/generator/source/generator.c

#include <stdio.h>
#include <stdarg.h>

#include "common/gs_util.h"
#include "common/gs_containers.h"
#include "lexer/gs_lexer.h"
#include "base/gs_meta_class.h"

/*========================
// Parsing utilities
=========================*/

typedef struct parser
{
	gs_lexer* lex;
	u32 indention;
	u32 status;
} parser;

#define fmt_print_tab( ct )\
	do {\
		for ( u32 __i = 0; __i < ( ct ); ++__i ) { printf( "\t" ); };\
	} while( 0 )
	
_inline void fmt_tabbed_print( u32 indent, const char* fmt, ... )
{
	fmt_print_tab( indent );
	va_list args;
	va_start ( args, fmt );
	vprintf( fmt, args );
	va_end( args );
}

b8 parser_can_parse( parser* p )
{
	return ( p && gs_lexer_can_lex( p->lex ) && p->status );
}

typedef struct meta_attribute
{
	char* tag;
} meta_attribute;

typedef struct meta_field
{
	gs_dyn_array( meta_attribute ) attributes;
	char* type;
	char* identifier;
	char* default_value;
} meta_field;

typedef struct meta_struct
{
	gs_dyn_array( meta_field ) fields;
	char* base;
	char* identifier;
	char* defaults_ctor;
	char* serialize_func;
	char* deserialize_func;
} meta_struct;

meta_struct meta_struct_ctor()
{
	meta_struct ms = ( meta_struct ){};
	ms.fields = gs_dyn_array_new( meta_field );
	return ms;
}

#define meta_set_str( meta, prop, token )\
do {\
	if ( meta->prop != NULL )\
	{\
		printf( "prop: %s\n", #prop );\
		gs_free( meta->prop );\
	}\
	meta->prop = gs_malloc( token.len + 1 );\
	memset( meta->prop, 0, token.len + 1 );\
	memcpy( meta->prop, token.text, token.len );\
} while( 0 );

void meta_struct_dtor( meta_struct* ms )
{
	gs_dyn_array_free( ms->fields );
}

meta_field meta_field_ctor()
{
	meta_field field = { 0 };
	field.attributes = gs_dyn_array_new( meta_attribute );
	field.type = ( char* )NULL;
	field.identifier = ( char* )NULL;
	field.default_value = ( char* )NULL;
	return field;
}

meta_attribute meta_attribute_ctor()
{
	meta_attribute attr = { 0 };
	attr.tag = ( char* )NULL;
	return attr;
}

void meta_struct_debug_print( meta_struct* ms )
{
	gs_printf( "struct:\n" );

	// Print struct identifier
	gs_printf( "\tidentifier: %s\n", ms->identifier );

	// Print struct base
	gs_printf( "\tbase: %s\n", ms->base );

	// Print struct fields
	gs_printf( "\tfields:\n");
	gs_for_range_i( gs_dyn_array_size( ms->fields ) )
	{
		gs_printf( "\t\tfield:\n");

		meta_field* mf = &ms->fields[ i ];
		gs_printf( "\t\t\ttype: %s\n", mf->type );
		gs_printf( "\t\t\tidentifier: %s\n", mf->identifier );

		gs_printf( "\t\t\tattributes:\n");
		gs_for_range_j( gs_dyn_array_size( mf->attributes ) )
		{
			gs_printf( "\t\t\t\t%s\n", mf->attributes[ j ].tag );
		}
	}

	gs_printf( "\n" );
}

#define parse_print_current_token( p, label, indent )\
	do {\
		fmt_print_tab( indent );\
		printf( "%s: ", label );\
		gs_token_print_text( gs_lexer_current_token( p->lex ) );\
	} while( 0 )


#define parse_func( p, ... )\
{\
	const char* __at = p->lex->at;\
	u32 __cur_idention = p->indention;\
	__VA_ARGS__\
	p->lex->at = __at;\
	p->indention = __cur_idention;\
	return false;\
}

#define parser_capture( p, func )\
	p->status &= ( func )

b8 parse_identifier( parser* p, meta_struct* ms )
{
	parse_func( p, 
	{
		if ( gs_lexer_require_token_type( p->lex, "identifier" ) )
		{
			return true;		
		}
	});
}

// Would rather not have to update this every time a new attribute tag is added.
const char* gs_field_tags[] = 
{
	"_non_serializable",
	"_immutable",
	"_ignore",
	"_default",
	"_attributes"
};

b8 parse_is_token_a_field_tag( gs_token t )
{
	gs_for_range_i( gs_array_size( gs_field_tags ) )
	{
		if ( gs_token_compare_text( t, gs_field_tags[ i ] ) )
		{
			return true;
		}
	}
	return false;
}

b8 parse_struct_field_attribute_default_value( parser* p, meta_field* mf )
{
	// expression = term
	// term = identifier | number
	// expression = ( expression ) | expression
	// default_value_tag := _default = expression
	parse_func( p, 
	{
		if ( gs_token_compare_text( gs_lexer_current_token( p->lex ), "_default" ) )
		{
		  	parser_capture( p, gs_lexer_require_token_type( p->lex, "lparen" ) );

		  	// These have to match to be done with parsing this expression
		  	u32 num_lparen = 1;
		  	u32 num_rparen = 0;

		  	// Eat all whitespace up to first valid character
		  	gs_lexer_eat_whitespace( p->lex );

		  	// Capture the current position of the lexer
		  	const char* at = p->lex->at;
		  	const char* to = at;

		  	// Now need to go until a few specific conditions are met
		  	while ( num_lparen != num_rparen )
		  	{
		  		gs_token t = gs_lexer_next_token( p->lex );

		  		if ( gs_token_compare_type( t, "lparen" ) )
		  		{
		  			num_lparen++;
		  		}
		  		else if ( gs_token_compare_type( t, "rparen" ) )
		  		{
		  			num_rparen++;
		  		}

	  			// Store the to if still parsing statement
		  		if ( num_lparen != num_rparen )
		  		{
		  			to = p->lex->at;
		  		}
		  	}

		  	// Calculate size of string
		  	usize len = ( to - at );

		  	// Have the default value, so store in the meta field
		  	mf->default_value = NULL;
		  	mf->default_value = gs_malloc( len + 1 );
		  	gs_assert( mf->default_value );
		  	memcpy( mf->default_value, at, len );
		  	mf->default_value[ len ] = '\0';

			return true;
		}
	});
}

b8 parse_struct_field_attribute_tag( parser* p, meta_field* mf )
{
	parse_func( p, 
	{
		// Push back new attribute and set tag
		if ( gs_lexer_optional_token_type( p->lex, "identifier" ) )
		{
			if ( parse_struct_field_attribute_default_value( p, mf ) )
			{
				return true;	
			}
			else
			{
				gs_dyn_array_push( mf->attributes, meta_attribute_ctor() );
				meta_set_str( gs_dyn_array_back( mf->attributes ), tag, gs_lexer_current_token( p->lex ) );
				return true;
			}
		}
	});
}

b8 parse_struct_field_attribute_tags( parser* p, meta_struct* ms )
{
	// default_value_assignment := _default = expression
	// attribute_tag := identifier | empty
	// attribute_tag := default_value_assignment	
	// attribute_tags := identifier { ,attribute_tags }

	parse_func( p, 
	{
		// Grab last field
		meta_field* mf = gs_dyn_array_back( ms->fields );

		// Optional tags for group
		if ( parse_struct_field_attribute_tag( p, mf ) )
		{
			// Look for tag groups ( { , attribute_tag }* )
			while ( gs_token_compare_type( gs_lexer_peek_next_token( p->lex ), "comma" ) )
			{
				gs_lexer_require_token_type( p->lex, "comma" );

				parse_struct_field_attribute_tag( p, mf );
			}

			return true;
		}
	});
}

b8 parse_struct_field_attribute_tag_group( parser* p, meta_struct* ms )
{
	// attribute_tag_group := _attributes( { attribute_tags } )

	parse_func( p, 
	{
		// Found
		if ( gs_lexer_optional_token_text( p->lex, "_attributes" ) )
		{
			// Push on new meta field
			gs_dyn_array_push( ms->fields, meta_field_ctor() );

			// Parse attribute tags
			// Have found the _attributes tag, so now require paren
			parser_capture( p, gs_lexer_require_token_type( p->lex, "lparen" ) );

			parser_capture( p, parse_struct_field_attribute_tags( p, ms ) );

			parser_capture( p, gs_lexer_require_token_type( p->lex, "rparen") );

			return true;
		} 
	});
}

b8 parse_struct_field_ignore_tag( parser* p, meta_struct* ms )
{
	parse_func( p, 
	{
		if ( gs_lexer_optional_token_text( p->lex, "_ignore" ) )
		{
			return true;
		}
	});
}

b8 parse_struct_field_defaults_tag( parser* p, meta_struct* ms )
{
	// defaults_tag := _defaults( args )
	parse_func( p, 
	{
		b32 success = true;
		u32 lparen_count = 0, rparen_count = 0;
		if ( gs_lexer_optional_token_text( p->lex, "_defaults" ) )
		{
			success &= gs_lexer_require_token_type( p->lex, "lparen" );
			lparen_count++;
			const char* at = p->lex->at;
			const char* stop = NULL;
			gs_token token = gs_lexer_current_token( p->lex );
			gs_token start_token = gs_lexer_peek_next_token( p->lex );
			while ( lparen_count != rparen_count )
			{
				if ( gs_token_compare_type( gs_lexer_peek_next_token( p->lex ), "rparen" ) )
				{
					rparen_count++;
					stop = p->lex->at;
				}
				else if ( gs_token_compare_type( gs_lexer_peek_next_token( p->lex ), "lparen" ) )
				{
					lparen_count++;	
				}
				token = gs_lexer_next_token( p->lex );
			}
			u32 len = ( stop - start_token.text );
			ms->defaults_ctor = malloc( len + 1 );
			memcpy( ms->defaults_ctor, start_token.text, len );
			ms->defaults_ctor[ len ] = '\0';
			success &= gs_token_compare_type( gs_lexer_current_token( p->lex ), "rparen" );
			if ( success )
			{
				return true;
			}
		}
	});
}

b8 parse_struct_field_serialize_tag( parser* p, meta_struct* ms )
{
	parse_func( p, 
	{
		b32 success = true;
		u32 lparen_count = 0, rparen_count = 0;
		if ( gs_lexer_optional_token_text( p->lex, "_serialize" ) )
		{
			success &= gs_lexer_require_token_type( p->lex, "lparen" );
			lparen_count++;
			const char* at = p->lex->at;
			const char* stop = NULL;
			gs_token token = gs_lexer_current_token( p->lex );
			gs_token start_token = gs_lexer_peek_next_token( p->lex );
			while ( lparen_count != rparen_count )
			{
				if ( gs_token_compare_type( gs_lexer_peek_next_token( p->lex ), "rparen" ) )
				{
					rparen_count++;
					stop = p->lex->at;
				}
				else if ( gs_token_compare_type( gs_lexer_peek_next_token( p->lex ), "lparen" ) )
				{
					lparen_count++;	
				}
				token = gs_lexer_next_token( p->lex );
			}
			u32 len = ( stop - start_token.text );
			ms->serialize_func = malloc( len + 1 );
			memcpy( ms->serialize_func, start_token.text, len );
			ms->serialize_func[ len ] = '\0';
			success &= gs_token_compare_type( gs_lexer_current_token( p->lex ), "rparen" );
			gs_assert( success );
			return true;
		}
	});
}

b8 parse_struct_field_deserialize_tag( parser* p, meta_struct* ms )
{
	parse_func( p, 
	{
		b32 success = true;
		u32 lparen_count = 0, rparen_count = 0;
		if ( gs_lexer_optional_token_text( p->lex, "_deserialize" ) )
		{
			success &= gs_lexer_require_token_type( p->lex, "lparen" );
			lparen_count++;
			const char* at = p->lex->at;
			const char* stop = NULL;
			gs_token token = gs_lexer_current_token( p->lex );
			gs_token start_token = gs_lexer_peek_next_token( p->lex );
			while ( lparen_count != rparen_count )
			{
				if ( gs_token_compare_type( gs_lexer_peek_next_token( p->lex ), "rparen" ) )
				{
					rparen_count++;
					stop = p->lex->at;
				}
				else if ( gs_token_compare_type( gs_lexer_peek_next_token( p->lex ), "lparen" ) )
				{
					lparen_count++;	
				}
				token = gs_lexer_next_token( p->lex );
			}
			u32 len = ( stop - start_token.text );
			ms->deserialize_func = malloc( len + 1 );
			memcpy( ms->deserialize_func, start_token.text, len );
			ms->deserialize_func[ len ] = '\0';
			success &= gs_token_compare_type( gs_lexer_current_token( p->lex ), "rparen" );
			if ( success )
			{
				return true;
			}
		}
	});
}

b8 parse_struct_field( parser* p, meta_struct* ms )
{
	// field_type := identifier
	// field_identifier := identifier
	// field := _attributes( tags ) field_type field_identifier
	// field := field_type identifier | _attributes( tags ) field_type field_identifier | empty

	parse_func( p, 
	{
		// Ignore tag
		if ( parse_struct_field_ignore_tag( p, ms ) )
		{
			// Continue to semi colon
			gs_lexer_advance_before_next_token_type_occurence( p->lex, "semi_colon" );
			return true;
		}
		else if ( parse_struct_field_defaults_tag( p, ms ) )
		{
			return true;
		}
		else if ( parse_struct_field_serialize_tag( p, ms ) )
		{
			return true;
		} 
		else if ( parse_struct_field_deserialize_tag( p, ms ) )
		{
			return true;
		}
		// Optional attribute tag group ( but if found, field cannot be empty )
		else if ( parse_struct_field_attribute_tag_group( p, ms ) )
		{
			b8 success = true;

			// Pushed back a previous field - so grab it
			meta_field* mf = gs_dyn_array_back( ms->fields );

			success &= gs_lexer_require_token_type( p->lex, "identifier" ); 	// field_type
			meta_set_str( mf, type, gs_lexer_current_token( p->lex ) );

			success &= gs_lexer_require_token_type( p->lex, "identifier" ); 	// field_identifier
			meta_set_str( mf, identifier, gs_lexer_current_token( p->lex ) );

			if ( success )
			{
				return true;
			}
		}
		// No attribute tag, so attempt to parse struct field ( optional )
		else
		{
			if ( gs_lexer_optional_token_type( p->lex, "identifier") )
			{
				b8 success = true;

				// Push on new meta field
				gs_dyn_array_push( ms->fields, meta_field_ctor() );
				meta_field* mf = gs_dyn_array_back( ms->fields );

				gs_token t_field_type = gs_lexer_current_token( p->lex ); 			// field_type
				meta_set_str( mf, type, t_field_type );

				success &= gs_lexer_require_token_type( p->lex, "identifier" ); 	// field_identifier
				meta_set_str( mf, identifier, gs_lexer_current_token( p->lex ) );

				if ( success )
				{
					return true;
				}
			}
			else
			{
				return true;
			}
		}
	});
}

b8 parse_struct_fields( parser* p, meta_struct* ms )
{
	// Parsing individual field
	parse_func( p, 
	{
		// If found one, search for fields
		if ( parse_struct_field( p, ms ) )
		{
			while ( gs_token_compare_type( gs_lexer_peek_next_token( p->lex ), "semi_colon" ) )
			{
				gs_lexer_require_token_type( p->lex, "semi_colon" );	// semi_colon required
				parse_struct_field( p, ms );							// attempt to parse another struct field
			}
		} 

		return true;
	});
}

b8 parse_struct_base_tag( parser* p, meta_struct* ms )
{
	// base_tag := _base( field_type )

	parse_func( p, 
	{
		gs_lexer_require_token_text( p->lex, "_base" );
		gs_lexer_require_token_type( p->lex, "lparen" ); 

		// Base
		gs_lexer_require_token_type( p->lex, "identifier" );
		gs_token derive_t = gs_lexer_current_token( p->lex );

		// Store struct base token
		meta_set_str( ms, base, derive_t );

		gs_lexer_require_token_type( p->lex, "rparen" );

		if ( gs_token_compare_type( gs_lexer_current_token( p->lex ), "rparen" ) )
		{
			return true;
		}
	});
}

b8 parse_struct_body( parser* p, meta_struct* ms )
{
	// struct_body := derive_tag fields

	parse_func( p, 
	{
		if ( parse_struct_base_tag( p, ms ) && 
			 parse_struct_fields( p, ms ) )
		{
			return true;
		}
	});
}

b8 parse_struct_block( parser* p, meta_struct* ms )
{
	// struct_block := { struct_body };

	parse_func( p, 
	{
		if ( gs_lexer_require_token_type( p->lex, "lbrace" ) && 
			 parse_struct_body( p, ms ) && 
			 gs_lexer_require_token_type( p->lex, "rbrace" ) )
		{
			return true;
		}
	})
}

b8 parse_typedef_struct( parser* p, meta_struct* ms )
{
	// typedef_struct := typedef struct { identifier } struct_block identifier;

	parse_func( p, 
	{
		parser_capture( p, gs_lexer_require_token_text( p->lex, "typedef" ) );
		parser_capture( p, gs_lexer_require_token_text( p->lex, "struct" ) );
		gs_lexer_optional_token_type( p->lex, "identifier" );

		parser_capture( p, parse_struct_block( p, ms ) );

		// Struct identifier
		parser_capture( p, gs_lexer_require_token_type( p->lex, "identifier" ) );
		gs_token t_identifier = gs_lexer_current_token( p->lex );

		// Store identifier
		meta_set_str( ms, identifier, t_identifier );

		parser_capture( p, gs_lexer_require_token_type( p->lex, "semi_colon" ) );

		// NOTE(john): Really don't like this... just doesn't make sense, really
		// No errors occurred
		if ( p->status )
		{
			return true;
		}
	});
}

b8 parse_struct( parser* p, meta_struct* ms )
{
	// struct := typedef_struct
	// struct := struct_def; 

	parse_func( p, 
	{
		/*
			// Possible struct definition variations
			1). typedef struct [ name ] { _base( parent ) fields; } name_t;
			2). struct name_t { _base( parent ) fields; };
		*/
		// Version 1). 
		gs_token t = gs_lexer_peek_next_token( p->lex );
		if ( gs_token_compare_text( gs_lexer_peek_next_token( p->lex ), "typedef"  ) )
		{
			if ( parse_typedef_struct( p, ms ) )
			{
				return true;
			}
		}
		// Version 2). 
		// else if ( parse_standard_struct( p, indent + 1 ) )
		// {
		// 	return true;
		// }
	});
}

b8 parse_introspection( parser* p, gs_dyn_array( meta_struct )* meta_structs )
{
	// introspected_struct := _introspection struct

	parse_func( p, 
	{
		meta_struct ms = meta_struct_ctor();
		if ( parse_struct( p, &ms ) )
		{
			gs_dyn_array_push( *meta_structs, ms );
			return true;
		}
	});
}

typedef struct
{
	gs_dyn_array( meta_struct ) meta_struct_arr;
	gs_dyn_array( const char* ) file_arr;
	const char* root_dir;
	const char* proj_name;
} introspection_ctx;


/*========================
// Function Decls.
=========================*/

void compile_generated_reflection( introspection_ctx* ctx );

/*========================
// Main Entry Point
=========================*/

int main( int argc, char** argv )
{
	gs_println( "Starting reflection generation..." );

	// Context to use for parsing introspection data
	introspection_ctx ctx = ( introspection_ctx ){};
	ctx.file_arr = gs_dyn_array_new( const char* );
	ctx.meta_struct_arr= gs_dyn_array_new( meta_struct );

	// Collect all files for reflection
	gs_for_range_i( argc )
	{
		if ( gs_string_compare_equal( argv[ i ], "--files" ) )
		{
			for ( u32 j = i + 1; j < argc; ++j )
			{
				gs_dyn_array_push( ctx.file_arr, argv[ j ] );
			}
		} 
		else if ( gs_string_compare_equal( argv[ i ], "--proj_name" ) )
		{
			ctx.proj_name = argv[ i + 1 ];
		}
		else if ( gs_string_compare_equal( argv[ i ], "--root_dir" ) )
		{
			ctx.root_dir = argv[ i + 1 ];
		}
	}

	// Construct lexer with null contents
	gs_lexer_c lex = gs_lexer_c_ctor( NULL );

	// Parse all files
	gs_for_range_i( gs_dyn_array_size( ctx.file_arr ) )
	{
		// Read in source file to parse ( first elem )
		usize sz = 0;
		const char* src = gs_read_file_contents_into_string_null_term( ctx.file_arr[ i ], "r", &sz );

		// If file does not exist or allocation fails, skip
		if ( !src )
		{
			continue;
		}

		gs_println( "Generating reflection for: %s", ctx.file_arr[ i ] );	

		gs_lexer_set_contents( gs_cast( gs_lexer, &lex ), src );

		// Construct new parser
		parser parse = { gs_cast( gs_lexer, &lex ), 0, true };

		// Parse file
		while ( parser_can_parse( &parse ) )
		{
			// Simple debug ( just output next valid token from stream )
			gs_token t = gs_lexer_next_token( gs_cast( gs_lexer, &lex ) );

			if ( gs_token_compare_text( t, "_introspect" ) )
			{
				parse_introspection( &parse, &ctx.meta_struct_arr );
			}
		}
	}

	// Debug print out all information
	compile_generated_reflection( &ctx );

	gs_println( "Reflection generation complete.\n" );

	return 0;	
}

void compile_generated_reflection( introspection_ctx* ctx )
{
	// Temporary stack buffer to use 
	char temp_stack_buffer_header_file[ 1024 ];
	char temp_stack_buffer_source_file[ 1024 ];

	// Output header file name
	gs_snprintf( temp_stack_buffer_header_file, 1024, "%s/include/generated/%s_generated.h", ctx->root_dir, ctx->proj_name );
	gs_snprintf( temp_stack_buffer_source_file, 1024, "%s/source/generated/%s_generated.c", ctx->root_dir, ctx->proj_name );

	// Open header file for writing
	FILE* fp_header = fopen( temp_stack_buffer_header_file, "w" );

	gs_assert( fp_header );

	// Cache off meta struct array
	gs_dyn_array( meta_struct ) meta_struct_arr = ctx->meta_struct_arr;
	// Cache off header file array
	gs_dyn_array( const char* ) header_file_arr = ctx->file_arr;

	/*==============================================
	// Reflection Generation
	==============================================*/

	/*==============================================
	// gs_generated.h
	==============================================*/

	gs_fprintln( fp_header, "// This file has been generated. Any and all modifications will be lost." );
	gs_fprintln( fp_header, "" );

	gs_fprintln( fp_header, "#ifndef %s_GENERATED_H", ctx->proj_name );
	gs_fprintln( fp_header, "#define %s_GENERATED_H", ctx->proj_name );
	gs_fprintln( fp_header, "" );

	gs_fprintln( fp_header, "#include \"base/gs_meta_class.h\"" );
	gs_fprintln( fp_header, "" );

	/*==============================================
	// static property type hashes
	==============================================*/

	gs_fprintln( fp_header, "// Generated static hashes of string version of base types" );
	gs_for_range_i( gs_meta_property_type_count )
	{
		const char* meta_prop_str = gs_meta_property_to_str( ( gs_meta_property_type )i );
		gs_fprintln( fp_header, "#define gs_meta_property_type_%s_hash\t\t%zu", meta_prop_str, gs_hash_str( meta_prop_str ) );	
	}
	gs_fprintln( fp_header, "" );

	// gs_fprintln( fp_header, "// Generated static hashes of string version of base types" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_s8_hash 			5863760" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_u8_hash 			5863826" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_s16_hash 			193503903" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_u16_hash 			193506081" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_s32_hash 			193503965" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_u32_hash 			193506143" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_s64_hash 			193504066" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_u64_hash 			193506244" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_f32_hash 			193489808" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_f64_hash 			193489909" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_gs_vec2_hash 		262723214" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_gs_vec3_hash 		262723215" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_gs_vec4_hash 		262723216" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_gs_mat4_hash 		262395988" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_gs_quat_hash 		262560953" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_gs_vqs_hash 		7961720" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_gs_uuid_hash 		262704949" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_gs_entity_hash 	1983784891" );
	// gs_fprintln( fp_header, "#define gs_meta_property_type_gs_enum_hash 		262122739" );
	// gs_fprintln( fp_header, "" );

	/*==============================================
	// gs_meta_class_type enum decl
	==============================================*/

	const u32 col_alignment = 57;

	// Output generated 'gs_meta_class_type' enum
	gs_fprintln( fp_header, "/*==============================================");
	gs_fprintln( fp_header, "// Meta Class Id" );
	gs_fprintln( fp_header, "==============================================*/");
	gs_fprintln( fp_header, "" );

	gs_fprintln( fp_header, "typedef enum\n{" );
	gs_for_range_i( gs_dyn_array_size( meta_struct_arr ) )
	{
		usize len = gs_string_length( meta_struct_arr[ i ].identifier );
		u32 cur_col_num = 5 + gs_string_length( "gs_meta_class_id_" ) + len; 
		gs_fprintf( fp_header, "\tgs_meta_class_id_%s", meta_struct_arr[ i ].identifier );
		gs_for_range_i( ( col_alignment - cur_col_num ) ) { gs_fprintf( fp_header, " "); };
		gs_fprintln( fp_header, "= %d,", i );

	}
	gs_fprintln( fp_header, "\tgs_meta_class_id_count");
	gs_fprintln( fp_header, "} gs_meta_class_type;" );
	gs_fprintln( fp_header, "" );

	/*============================================================
	// Function decls
	============================================================*/

	gs_for_range_i( gs_dyn_array_size( meta_struct_arr ) )
	{
		gs_fprintln( fp_header, "/*==============================================");
		gs_fprintln( fp_header, "// %s", meta_struct_arr[ i ].identifier );
		gs_fprintln( fp_header, "==============================================*/");
		gs_fprintln( fp_header, "" );

		gs_fprintln( fp_header, "_inline u32 gs_type_id_%s()", meta_struct_arr[ i ].identifier ); 
		gs_fprintln( fp_header, "{" );
		gs_fprintln( fp_header, "\treturn ( u32 )gs_meta_class_id_%s;", meta_struct_arr[ i ].identifier );
		gs_fprintln( fp_header, "}" );

		gs_fprintln( fp_header, "" );
		gs_fprintln( fp_header, "const struct gs_object* __gs_default_object_%s();", meta_struct_arr[ i ].identifier );
		gs_fprintln( fp_header, "" );

		gs_fprintln( fp_header, "" );
		gs_fprintln( fp_header, "struct gs_object* __gs_default_object_%s_heap();", meta_struct_arr[ i ].identifier );
		gs_fprintln( fp_header, "" );
	}

	// End
	gs_fprintln( fp_header, "#endif" );

	// Close file
	fclose( fp_header );
	fp_header = NULL;

	/*==============================================
	// gs_generated.c 
	==============================================*/

	// Open source file for writing
	FILE* fp_src = fopen( temp_stack_buffer_source_file, "w" );

	gs_assert( fp_src );

	gs_fprintln( fp_src, "// This file has been generated. Any and all modifications will be lost." );
	gs_fprintln( fp_src, "" );

	gs_fprintln( fp_src, "#include \"base/gs_meta_class.h\"" );
	gs_fprintln( fp_src, "#include \"generated/gs_generated.h\"" );
	gs_fprintln( fp_src, "" );

	gs_fprintln( fp_src, "// Included introspected files" );
	gs_for_range_i( gs_dyn_array_size( header_file_arr ) )
	{
		gs_fprintln( fp_src, "#include \"%s\"", header_file_arr[ i ] );
	}
	gs_fprintln( fp_src, "" );

	gs_fprintln( fp_src, "#include <stdlib.h>" );
	gs_fprintln( fp_src, "#include <stdio.h>" );
	gs_fprintln( fp_src, "" );

	/*==============================================
	// Meta class labels 
	==============================================*/

	gs_fprintln( fp_src, "// Labels for all introspected types" );
	gs_fprintln( fp_src, "const char* gs_meta_class_labels[] = {" );
	gs_for_range_i( gs_dyn_array_size( meta_struct_arr ) )
	{
		u8 delim = i < gs_dyn_array_size( meta_struct_arr ) - 1 ? ',' : ' ';
		gs_fprintln( fp_src, "\t\"%s\"%c", meta_struct_arr[ i ].identifier, delim );
	}
	gs_fprintln( fp_src, "};" );
	gs_fprintln( fp_src, "" );

	/*==============================================
	// Default struct instances 
	==============================================*/

	gs_fprintln( fp_src, "/*==============================================");
	gs_fprintln( fp_src, "// Default Structures" );
	gs_fprintln( fp_src, "==============================================*/");
	gs_fprintln( fp_src, "" );

	gs_for_range_i( gs_dyn_array_size( meta_struct_arr ) )
	{
		const char* id = meta_struct_arr[ i ].identifier;
		// gs_fprintln( fp_src, "// %s", id );
		gs_fprintln( fp_src, "%s %s_default;", id, id, id );
	}
	gs_fprintln( fp_src, "" );

	/*==============================================
	// Default struct init function 
	==============================================*/

	gs_fprintln( fp_src, "void gs_init_default_struct_instances()" );
	gs_fprintln( fp_src, "{" );

	gs_for_range_i( gs_dyn_array_size( meta_struct_arr ) )
	{
		const char* id = meta_struct_arr[ i ].identifier;
		gs_fprintln( fp_src, "\t// %s", id );
		gs_fprintf( fp_src, "\t%s_default =", id );

		b32 empty = gs_dyn_array_empty( meta_struct_arr[ i ].fields );
		b32 has_defaults_ctor = meta_struct_arr[ i ].defaults_ctor != NULL;
		b32 has_any_default_values = empty;
		if ( !empty )
		{
			gs_for_range_j( gs_dyn_array_size( meta_struct_arr[ i ].fields ) )
			{
				meta_field* field = &meta_struct_arr[ i ].fields[ j ];
				has_any_default_values |= ( field->default_value != NULL );
			}
		}

		if ( ( empty || !has_any_default_values ) && !has_defaults_ctor ) 
		{
			gs_fprintf( fp_src, " ( %s ){};", id );
		} 
		else 
		{
			gs_fprintf( fp_src, "\n\t( %s )\n\t{\n ", id );

			// Output default values for fields
			b8 first_default = true;
			gs_for_range_j( gs_dyn_array_size( meta_struct_arr[ i ].fields ) )
			{
				meta_field* field = &meta_struct_arr[ i ].fields[ j ];
				if ( field->default_value )
				{
					if ( first_default ) 
					{
						first_default = false;
						gs_fprintf( fp_src, "\t\t.%s = %s", field->identifier, field->default_value );
					} 
					else 
					{
						gs_fprintf( fp_src, ",\n\t\t.%s = %s", field->identifier, field->default_value );
					}
				}
			}
			// Default ctor
			if ( meta_struct_arr[ i ].defaults_ctor )
			{
				if ( gs_dyn_array_size( meta_struct_arr[ i ].fields ) )
				{
					gs_fprintf( fp_src, ",\n\t\t%s", meta_struct_arr[ i ].defaults_ctor );
				}
				else
				{
					gs_fprintf( fp_src, "\t\t%s", meta_struct_arr[ i ].defaults_ctor );
				}
			}
			gs_fprintf( fp_src, "\n\t};" );
		}
		gs_fprintln( fp_src, "\n" );
	}

	gs_for_range_i( gs_dyn_array_size( meta_struct_arr ) )
	{
		const char* id = meta_struct_arr[ i ].identifier;
		gs_fprintln( fp_src, "\tgs_cast( gs_object, &%s_default )->type_id = &gs_type_id_%s;", id, id );
	}

	gs_fprintln( fp_src, "}" );
	gs_fprintln( fp_src, "" );

	/*==============================================
	// Registry init function
	==============================================*/

	gs_fprintln( fp_src, "void gs_meta_class_registry_init_meta_properties( gs_meta_class_registry* restrict registry )" );
	gs_fprintln( fp_src, "{" );
	gs_fprintln( fp_src, "\t// Construct registry" );
	gs_fprintln( fp_src, "\tregistry->classes = ( gs_meta_class* )gs_malloc( sizeof( gs_meta_class ) * gs_meta_class_id_count );" );
	gs_fprintln( fp_src, "" );

		gs_fprintln( fp_src, "\t// Set the ids for all the meta class information" );
		gs_fprintln( fp_src, "\tfor( usize i = 0; i < (usize)gs_meta_class_id_count; ++i )" );
		gs_fprintln( fp_src, "\t{" );
			gs_fprintln( fp_src, "\t\tregistry->classes[ i ].id = ( gs_meta_class_id )i;" );
		gs_fprintln( fp_src, "\t};" );
		gs_fprintln( fp_src, "" );

		gs_fprintln( fp_src, "\t// Meta class variable to use for these ops" );
		gs_fprintln( fp_src, "\tgs_meta_class* cls = NULL;" );
		gs_fprintln( fp_src, "" );

		gs_fprintln( fp_src, "\t// Meta class initialization" );
		gs_fprintln( fp_src, "" );

		// Print out all type information for introspected structs
		gs_for_range_i( gs_dyn_array_size( meta_struct_arr ) )
		{
			const char* cls_id = meta_struct_arr[ i ].identifier;
			gs_dyn_array( meta_field ) fields = meta_struct_arr[ i ].fields;
			u32 field_count = gs_dyn_array_size( fields );
			gs_fprintln( fp_src, "\t// %s meta class initialization", cls_id );
			gs_fprintln( fp_src, "\tcls = &registry->classes[ (usize)gs_meta_class_id_%s ];", cls_id ); 
			gs_fprintln( fp_src, "\tcls->label = \"%s\";", cls_id );
			gs_fprintln( fp_src, "\tcls->id = %d;", i );
			gs_fprintln( fp_src, "\tcls->property_count = %d;", field_count );
			gs_fprintln( fp_src, "\tcls->properties = ( gs_meta_property* )gs_malloc( sizeof( gs_meta_property ) * cls->property_count );" );
			gs_fprintln( fp_src, "\tcls->serialize_func = &%s;",
						meta_struct_arr[ i ].serialize_func ? 
						meta_struct_arr[ i ].serialize_func : 
						"__gs_object_serialization_base" );
			gs_fprintln( fp_src, "\tcls->deserialize_func = &%s;",
						meta_struct_arr[ i ].deserialize_func ? 
						meta_struct_arr[ i ].deserialize_func : 
						"__gs_object_deserialization_base" );

			// Output field information
			gs_for_range_j( field_count )
			{
				const char* field_id = fields[ j ].identifier;
				const char* field_type = fields[ j ].type;
				gs_fprintln( fp_src, "\tcls->properties[ %d ] = gs_meta_property_ctor( \"%s\", gs_type_to_meta_property_type( %s ), gs_offset( %s, %s ) );",
								j, field_id, field_type, cls_id, field_id );

			}

			gs_fprintln( fp_src, "\tcls->property_name_to_index_table = gs_hash_table_new( u32, gs_meta_property_ptr );" );

			gs_for_range_j( field_count )
			{
				const char* field_id = fields[ j ].identifier;
				gs_fprintln( fp_src, "\tgs_hash_table_insert( cls->property_name_to_index_table, gs_hash_str( \"%s\" ), &cls->properties[ %d ] );", 
								field_id, j );
			}

			gs_fprintln( fp_src, "" );
		}

		gs_fprintln( fp_src, "\tregistry->count = %d;", gs_dyn_array_size( meta_struct_arr ) );
		gs_fprintln( fp_src, "" );

		gs_fprintln( fp_src, "\tgs_init_default_struct_instances();" );
	gs_fprintln( fp_src, "}" );
	gs_fprintln( fp_src, "" );

	/*==============================================
	// Utility functions for meta classes
	==============================================*/

	gs_fprintln( fp_src, "const char* gs_meta_class_get_label( gs_meta_class* restrict cls )" );
	gs_fprintln( fp_src, "{" );
	gs_fprintln( fp_src, "\treturn gs_meta_class_labels[ cls->id ];" );
	gs_fprintln( fp_src, "}" );
	gs_fprintln( fp_src, "" );

	gs_fprintln( fp_src, "const char* gs_type_name_obj( gs_object* restrict obj )" );
	gs_fprintln( fp_src, "{" );
	gs_fprintln( fp_src, "\treturn ( gs_meta_class_labels[ gs_type_id( obj ) ] );" );
	gs_fprintln( fp_src, "}" );
	gs_fprintln( fp_src, "" );

	gs_fprintln( fp_src, "const char* __gs_type_name_cls( u32 id )" );
	gs_fprintln( fp_src, "{" );
	gs_fprintln( fp_src, "\treturn gs_meta_class_labels[ id ];" );
	gs_fprintln( fp_src, "}" );
	gs_fprintln( fp_src, "" );

	/*==============================================
	// Default object accessors
	==============================================*/

	gs_for_range_i( gs_dyn_array_size( meta_struct_arr ) )
	{
		const char* cls_id = meta_struct_arr[ i ].identifier;

		gs_fprintln( fp_src, "// %s", cls_id );
		gs_fprintln( fp_src, "const struct gs_object* __gs_default_object_%s()", cls_id ); 
		gs_fprintln( fp_src, "{" );
		gs_fprintln( fp_src, "\treturn ( gs_cast( gs_object, &%s_default ) );", cls_id );
		gs_fprintln( fp_src, "}" );
		gs_fprintln( fp_src, "" );

		gs_fprintln( fp_src, "struct gs_object* __gs_default_object_%s_heap()", cls_id );
		gs_fprintln( fp_src, "{" );
		gs_fprintln( fp_src, "\t%s* obj = gs_malloc( sizeof( %s ) );", cls_id, cls_id );
		gs_fprintln( fp_src, "\t*obj = %s_default;", cls_id, cls_id );
		gs_fprintln( fp_src, "\treturn ( gs_cast( gs_object, obj ) );" );
		gs_fprintln( fp_src, "}" );
		gs_fprintln( fp_src, "" );
	}
	gs_fprintln( fp_src, "" );

	/*==============================================
	// Finished Reflection Generation
	==============================================*/
}