diff --git a/src/base/base_inc.c b/src/base/base_inc.c index 6e8ccd55..dc2916bf 100644 --- a/src/base/base_inc.c +++ b/src/base/base_inc.c @@ -15,5 +15,6 @@ #include "base_thread_context.c" #include "base_command_line.c" #include "base_markup.c" +#include "base_meta.c" #include "base_log.c" #include "base_entry_point.c" diff --git a/src/base/base_inc.h b/src/base/base_inc.h index 76437b09..a878cacc 100644 --- a/src/base/base_inc.h +++ b/src/base/base_inc.h @@ -17,6 +17,7 @@ #include "base_thread_context.h" #include "base_command_line.h" #include "base_markup.h" +#include "base_meta.h" #include "base_log.h" #include "base_entry_point.h" diff --git a/src/base/base_meta.c b/src/base/base_meta.c new file mode 100644 index 00000000..90e18c99 --- /dev/null +++ b/src/base/base_meta.c @@ -0,0 +1,188 @@ +// Copyright (c) 2024 Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +//////////////////////////////// +//~ rjf: Type Info Lookups + +internal Member * +member_from_name(Type *type, String8 name) +{ + Member *member = &member_nil; + if(type->members != 0) + { + for(U64 idx = 0; idx < type->count; idx += 1) + { + if(str8_match(type->members[idx].name, name, 0)) + { + member = &type->members[idx]; + break; + } + } + } + return member; +} + +//////////////////////////////// +//~ rjf: Type Info * Instance Operations + +internal String8 +serialized_from_typed_data(Arena *arena, Type *type, void *ptr, TypeSerializeParams *params) +{ + Temp scratch = scratch_begin(&arena, 1); + String8List strings = {0}; + str8_serial_begin(scratch.arena, &strings); + { + typedef struct Task Task; + struct Task + { + Task *next; + Type *type; + void *ptr; + U64 count; + Type *containing_type; + void *containing_ptr; + }; + Task start_task = {0, type, ptr, 1}; + Task *first_task = &start_task; + Task *last_task = first_task; + for(Task *t = first_task; t != 0; t = t->next) + { + switch(t->type->kind) + { + //- rjf: leaf serialiation -> just write the data directly + default: + if(TypeKind_FirstLeaf <= t->type->kind && t->type->kind <= TypeKind_LastLeaf) + { + str8_serial_push_string(scratch.arena, &strings, str8((U8 *)t->ptr, type_leaves[t->type->kind].size*t->count)); + }break; + + //- rjf: pointers -> try to interpret/understand pointer & write, otherwise skip + case TypeKind_Ptr: + { + // rjf: gather info about pointer references of this type + TypeSerializePtrRefInfo *ptr_ref_info = 0; + for(U64 idx = 0; idx < params->ptr_ref_infos_count; idx += 1) + { + if(params->ptr_ref_infos[idx].type == t->type->direct) + { + ptr_ref_info = ¶ms->ptr_ref_infos[idx]; + break; + } + } + + // rjf: read ptr value + void *ptr_value = 0; + MemoryCopy(&ptr_value, t->ptr, sizeof(ptr_value)); + + // rjf: indexification -> subtract base, divide direct size, write index + if(ptr_ref_info != 0 && ptr_ref_info->indexify_base != 0) + { + U64 ptr_offsetified = (U8 *)ptr_value - (U8 *)ptr_ref_info->indexify_base; + U64 ptr_indexified = ptr_offsetified / t->type->direct->size; + str8_serial_push_struct(scratch.arena, &strings, &ptr_indexified); + } + + // rjf: explicit identification -> descend to ID member at destination, write that + else if(ptr_ref_info != 0 && ptr_ref_info->id_member.size != 0) + { + Member *member = member_from_name(t->type->direct, ptr_ref_info->id_member); + if(member != &member_nil) + { + Task *task = push_array(scratch.arena, Task, 1); + task->type = member->type; + task->ptr = ((U8 *)ptr_value) + member->value; + task->count = 1; + task->containing_type = t->type->direct; + task->containing_ptr = ptr_value; + SLLQueuePush(first_task, last_task, task); + } + } + + // rjf: count-delimited pointers -> read count from member in containing type, + // descend & write destination that way + else if(t->type->count_delimiter_name.size != 0 && t->containing_type != 0) + { + Member *count_member = member_from_name(t->containing_type, t->type->count_delimiter_name); + if(count_member != &member_nil) + { + U64 count = 0; + MemoryCopy(&count, (U8 *)t->containing_ptr + count_member->value, count_member->type->size); + Task *task = push_array(scratch.arena, Task, 1); + task->type = t->type->direct; + task->ptr = ptr_value; + task->count = count; + task->containing_type = t->containing_type; + task->containing_ptr = t->containing_ptr; + SLLQueuePush(first_task, last_task, task); + } + } + + // rjf: any other nonzero pointer -> descend to pointer destination. trust usage code + else if(ptr_value != 0) + { + Task *task = push_array(scratch.arena, Task, 1); + task->type = t->type->direct; + task->ptr = ptr_value; + task->count = 1; + SLLQueuePush(first_task, last_task, task); + } + }break; + + //- rjf: arrays -> descend to underlying type, + count + case TypeKind_Array: + { + Task *task = push_array(scratch.arena, Task, 1); + task->type = t->type->direct; + task->ptr = t->ptr; + task->count = t->type->count; + task->containing_type = t->containing_type; + task->containing_ptr = t->containing_ptr; + SLLQueuePush(first_task, last_task, task); + }break; + + //- rjf: struct -> descend to members + case TypeKind_Struct: + { + for(U64 idx = 0; idx < t->count; idx += 1) + { + for(U64 member_idx = 0; member_idx < t->type->count; member_idx += 1) + { + if(t->type->members[member_idx].flags & MemberFlag_DoNotSerialize) + { + continue; + } + Task *task = push_array(scratch.arena, Task, 1); + task->type = t->type->members[member_idx].type; + task->ptr = (U8 *)t->ptr + t->type->size*idx + t->type->members[member_idx].value; + task->count = 1; + task->containing_type = t->type; + task->containing_ptr = t->ptr; + SLLQueuePush(first_task, last_task, task); + } + } + }break; + + //- rjf: enum -> descend to basic type interpretation + case TypeKind_Enum: + { + Task *task = push_array(scratch.arena, Task, 1); + task->type = t->type->direct; + task->ptr = t->ptr; + task->count = t->count; + task->containing_type = t->containing_type; + task->containing_ptr = t->containing_ptr; + SLLQueuePush(first_task, last_task, task); + }break; + } + } + } + String8 result = str8_serial_end(scratch.arena, &strings); + scratch_end(scratch); + return result; +} + +internal void * +data_from_typed_serialized(Arena *arena, Type *type, String8 string, TypeSerializeParams *params) +{ + +} diff --git a/src/base/base_meta.h b/src/base/base_meta.h new file mode 100644 index 00000000..c43df323 --- /dev/null +++ b/src/base/base_meta.h @@ -0,0 +1,191 @@ +// Copyright (c) 2024 Epic Games Tools +// Licensed under the MIT license (https://opensource.org/license/mit/) + +#ifndef BASE_META_H +#define BASE_META_H + +//////////////////////////////// +//~ rjf: Meta Markup Features + +#define EmbedFile(name, path) +#define TweakB32(name, default) (TWEAK_##name) +#define TweakF32(name, default, min, max) (TWEAK_##name) + +//////////////////////////////// +//~ rjf: Tweak Info Tables + +typedef struct TweakB32Info TweakB32Info; +struct TweakB32Info +{ + String8 name; + B32 default_value; + B32 *value_ptr; +}; + +typedef struct TweakF32Info TweakF32Info; +struct TweakF32Info +{ + String8 name; + F32 default_value; + Rng1F32 value_range; + F32 *value_ptr; +}; + +typedef struct TweakB32InfoTable TweakB32InfoTable; +struct TweakB32InfoTable +{ + TweakB32Info *v; + U64 count; +}; + +typedef struct TweakF32InfoTable TweakF32InfoTable; +struct TweakF32InfoTable +{ + TweakF32Info *v; + U64 count; +}; + +typedef struct EmbedInfo EmbedInfo; +struct EmbedInfo +{ + String8 name; + String8 *data; + U128 *hash; +}; + +typedef struct EmbedInfoTable EmbedInfoTable; +struct EmbedInfoTable +{ + EmbedInfo *v; + U64 count; +}; + +//////////////////////////////// +//~ rjf: Type Info Types + +typedef U32 TypeFlags; +enum +{ + TypeFlag_Indexified = (1<<0), +}; + +typedef enum TypeKind +{ + TypeKind_Null, + + // rjf: leaves + TypeKind_Void, TypeKind_FirstLeaf = TypeKind_Void, + TypeKind_U8, + TypeKind_U16, + TypeKind_U32, + TypeKind_U64, + TypeKind_S8, + TypeKind_S16, + TypeKind_S32, + TypeKind_S64, + TypeKind_B8, + TypeKind_B16, + TypeKind_B32, + TypeKind_B64, + TypeKind_F32, + TypeKind_F64, TypeKind_LastLeaf = TypeKind_F64, + + // rjf: operators + TypeKind_Ptr, + TypeKind_Array, + + // rjf: user-defined-types + TypeKind_Struct, + TypeKind_Union, + TypeKind_Enum, + + TypeKind_COUNT +} +TypeKind; + +typedef U32 MemberFlags; +enum +{ + MemberFlag_DoNotSerialize = (1<<0), +}; + +typedef struct Type Type; +typedef struct Member Member; +struct Member +{ + String8 name; + Type *type; + U64 value; + MemberFlags flags; +}; + +typedef struct Type Type; +struct Type +{ + TypeKind kind; + TypeFlags flags; + U64 size; + Type *direct; + String8 name; + String8 count_delimiter_name; // gathered from surrounding members, turns *->[1] into *->[N] + U64 count; + Member *members; +}; + +//////////////////////////////// +//~ rjf: Type Serialization Parameters + +typedef struct TypeSerializePtrRefInfo TypeSerializePtrRefInfo; +struct TypeSerializePtrRefInfo +{ + Type *type; // pointers to this + void *indexify_base; // can be indexified using this + String8 id_member; // or ID'd via this member of the pointed-to-instance +}; + +typedef struct TypeSerializeParams TypeSerializeParams; +struct TypeSerializeParams +{ + TypeSerializePtrRefInfo *ptr_ref_infos; + U64 ptr_ref_infos_count; +}; + +//////////////////////////////// +//~ rjf: Globals + +read_only global Type type_leaves[] = +{ + {TypeKind_Null, 0, 0, &type_leaves[0], str8_lit_comp("null")}, + {TypeKind_Void, 0, 0, &type_leaves[0], str8_lit_comp("void")}, + {TypeKind_U8, 0, sizeof(U8), &type_leaves[0], str8_lit_comp("U8")}, + {TypeKind_U16, 0, sizeof(U16), &type_leaves[0], str8_lit_comp("U16")}, + {TypeKind_U32, 0, sizeof(U32), &type_leaves[0], str8_lit_comp("U32")}, + {TypeKind_U64, 0, sizeof(U64), &type_leaves[0], str8_lit_comp("U64")}, + {TypeKind_S8, 0, sizeof(S8), &type_leaves[0], str8_lit_comp("S8")}, + {TypeKind_S16, 0, sizeof(S16), &type_leaves[0], str8_lit_comp("S16")}, + {TypeKind_S32, 0, sizeof(S32), &type_leaves[0], str8_lit_comp("S32")}, + {TypeKind_S64, 0, sizeof(S64), &type_leaves[0], str8_lit_comp("S64")}, + {TypeKind_B8, 0, sizeof(B8), &type_leaves[0], str8_lit_comp("B8")}, + {TypeKind_B16, 0, sizeof(B16), &type_leaves[0], str8_lit_comp("B16")}, + {TypeKind_B32, 0, sizeof(B32), &type_leaves[0], str8_lit_comp("B32")}, + {TypeKind_B64, 0, sizeof(B64), &type_leaves[0], str8_lit_comp("B64")}, + {TypeKind_F32, 0, sizeof(F32), &type_leaves[0], str8_lit_comp("F32")}, + {TypeKind_F64, 0, sizeof(F64), &type_leaves[0], str8_lit_comp("F64")}, +}; +read_only global Member member_nil = {{0}, &type_leaves[0]}; + +//////////////////////////////// +//~ rjf: Type Info Lookups + +#define type(T) &(T##__type) +internal Member *member_from_name(Type *type, String8 name); + +//////////////////////////////// +//~ rjf: Type Info * Instance Operations + +internal String8 serialized_from_typed_data(Arena *arena, Type *type, void *ptr, TypeSerializeParams *params); +internal void *data_from_typed_serialized(Arena *arena, Type *type, String8 string, TypeSerializeParams *params); +#define serialized_from_struct(arena, T, ptr, ...) serialized_from_typed_data((arena), type(T), (ptr), &(TypeSerializeParams){.ptr_ref_infos = 0, __VA_ARGS__}) +#define struct_from_serialized(arena, T, string, ...) (T *)data_from_typed_serialized((arena), type(T), (string), &(TypeSerializeParams){.ptr_ref_infos = 0, __VA_ARGS__}) + +#endif // BASE_META_H diff --git a/src/ctrl/ctrl.mdesk b/src/ctrl/ctrl.mdesk index b34f3a8f..346bb79f 100644 --- a/src/ctrl/ctrl.mdesk +++ b/src/ctrl/ctrl.mdesk @@ -4,23 +4,31 @@ //////////////////////////////// //~ rjf: Meta Evaluation Type Information -@table(name info_type eval_type dynamic) +@table(name info_type eval_type dynamic_kind) CTRL_MetaEvalMemberTable: { - {enabled S32 S32 } - {frozen S32 S32 } - {hit_count U64 U64 } - {id U64 U64 } - {color U32 U32 } - {label String8 U64 x } - {location String8 U64 x } - {condition String8 U64 x } + {enabled S32 S32 } + {frozen S32 S32 } + {hit_count U64 U64 } + {id U64 U64 } + {color U32 U32 } + {label String8 U64 String8 } + {location String8 U64 String8 } + {condition String8 U64 String8 } + {callstack CTRL_MetaEvalFrameArray U64 FrameArray } +} + +@struct CTRL_MetaEvalFrameArray: +{ + `U64 *frames`; + `U64 count`; } @enum CTRL_MetaEvalDynamicKind: { Null, String8, + FrameArray, COUNT } @@ -56,7 +64,7 @@ CTRL_MetaEvalMemberTable: @data(CTRL_MetaEvalDynamicKind) ctrl_meta_eval_member_dynamic_kind_table: { - @expand(CTRL_MetaEvalMemberTable a) `$(a.dynamic == 'x' -> 'CTRL_MetaEvalDynamicKind_'..a.info_type)$(a.dynamic == '' -> 'CTRL_MetaEvalDynamicKind_Null')` + @expand(CTRL_MetaEvalMemberTable a) `$(a.dynamic_kind != '' -> 'CTRL_MetaEvalDynamicKind_'..a.dynamic_kind)$(a.dynamic_kind == '' -> 'CTRL_MetaEvalDynamicKind_Null')` } //////////////////////////////// diff --git a/src/ctrl/ctrl_core.c b/src/ctrl/ctrl_core.c index 29d97ef2..b5c9db72 100644 --- a/src/ctrl/ctrl_core.c +++ b/src/ctrl/ctrl_core.c @@ -211,6 +211,10 @@ ctrl_meta_eval_from_info(Arena *arena, CTRL_MetaEvalInfo *info) U64 off = (string_copy.str - (U8 *)eval); MemoryCopy((U8 *)eval + ctrl_meta_eval_member_range_table[idx].min, &off, sizeof(U64)); }break; + case CTRL_MetaEvalDynamicKind_FrameArray: + { + + }break; } } } diff --git a/src/ctrl/generated/ctrl.meta.c b/src/ctrl/generated/ctrl.meta.c index 2fe79dd1..f2ace71a 100644 --- a/src/ctrl/generated/ctrl.meta.c +++ b/src/ctrl/generated/ctrl.meta.c @@ -4,7 +4,7 @@ //- GENERATED CODE C_LINKAGE_BEGIN -String8 ctrl_meta_eval_member_name_table[8] = +String8 ctrl_meta_eval_member_name_table[9] = { str8_lit_comp("enabled"), str8_lit_comp("frozen"), @@ -14,9 +14,10 @@ str8_lit_comp("color"), str8_lit_comp("label"), str8_lit_comp("location"), str8_lit_comp("condition"), +str8_lit_comp("callstack"), }; -Rng1U64 ctrl_meta_eval_info_member_range_table[8] = +Rng1U64 ctrl_meta_eval_info_member_range_table[9] = { {OffsetOf(CTRL_MetaEvalInfo, enabled), OffsetOf(CTRL_MetaEvalInfo, enabled) + sizeof(S32)}, {OffsetOf(CTRL_MetaEvalInfo, frozen), OffsetOf(CTRL_MetaEvalInfo, frozen) + sizeof(S32)}, @@ -26,9 +27,10 @@ Rng1U64 ctrl_meta_eval_info_member_range_table[8] = {OffsetOf(CTRL_MetaEvalInfo, label), OffsetOf(CTRL_MetaEvalInfo, label) + sizeof(String8)}, {OffsetOf(CTRL_MetaEvalInfo, location), OffsetOf(CTRL_MetaEvalInfo, location) + sizeof(String8)}, {OffsetOf(CTRL_MetaEvalInfo, condition), OffsetOf(CTRL_MetaEvalInfo, condition) + sizeof(String8)}, +{OffsetOf(CTRL_MetaEvalInfo, callstack), OffsetOf(CTRL_MetaEvalInfo, callstack) + sizeof(CTRL_MetaEvalFrameArray)}, }; -Rng1U64 ctrl_meta_eval_member_range_table[8] = +Rng1U64 ctrl_meta_eval_member_range_table[9] = { {OffsetOf(CTRL_MetaEval, enabled), OffsetOf(CTRL_MetaEval, enabled) + sizeof(S32)}, {OffsetOf(CTRL_MetaEval, frozen), OffsetOf(CTRL_MetaEval, frozen) + sizeof(S32)}, @@ -38,9 +40,10 @@ Rng1U64 ctrl_meta_eval_member_range_table[8] = {OffsetOf(CTRL_MetaEval, label), OffsetOf(CTRL_MetaEval, label) + sizeof(U64)}, {OffsetOf(CTRL_MetaEval, location), OffsetOf(CTRL_MetaEval, location) + sizeof(U64)}, {OffsetOf(CTRL_MetaEval, condition), OffsetOf(CTRL_MetaEval, condition) + sizeof(U64)}, +{OffsetOf(CTRL_MetaEval, callstack), OffsetOf(CTRL_MetaEval, callstack) + sizeof(U64)}, }; -E_TypeKind ctrl_meta_eval_member_type_kind_table[8] = +E_TypeKind ctrl_meta_eval_member_type_kind_table[9] = { E_TypeKind_S32, E_TypeKind_S32, @@ -50,9 +53,10 @@ E_TypeKind_U32, E_TypeKind_U64, E_TypeKind_U64, E_TypeKind_U64, +E_TypeKind_U64, }; -CTRL_MetaEvalDynamicKind ctrl_meta_eval_member_dynamic_kind_table[8] = +CTRL_MetaEvalDynamicKind ctrl_meta_eval_member_dynamic_kind_table[9] = { CTRL_MetaEvalDynamicKind_Null, CTRL_MetaEvalDynamicKind_Null, @@ -62,6 +66,7 @@ CTRL_MetaEvalDynamicKind_Null, CTRL_MetaEvalDynamicKind_String8, CTRL_MetaEvalDynamicKind_String8, CTRL_MetaEvalDynamicKind_String8, +CTRL_MetaEvalDynamicKind_FrameArray, }; String8 ctrl_entity_kind_display_string_table[8] = diff --git a/src/ctrl/generated/ctrl.meta.h b/src/ctrl/generated/ctrl.meta.h index 7ada03fb..7fddebd9 100644 --- a/src/ctrl/generated/ctrl.meta.h +++ b/src/ctrl/generated/ctrl.meta.h @@ -10,6 +10,7 @@ typedef enum CTRL_MetaEvalDynamicKind { CTRL_MetaEvalDynamicKind_Null, CTRL_MetaEvalDynamicKind_String8, +CTRL_MetaEvalDynamicKind_FrameArray, CTRL_MetaEvalDynamicKind_COUNT, } CTRL_MetaEvalDynamicKind; @@ -69,6 +70,13 @@ CTRL_ExceptionCodeKind_Win32DirectXDebugLayer, CTRL_ExceptionCodeKind_COUNT, } CTRL_ExceptionCodeKind; +typedef struct CTRL_MetaEvalFrameArray CTRL_MetaEvalFrameArray; +struct CTRL_MetaEvalFrameArray +{ +U64 *frames; +U64 count; +}; + typedef struct CTRL_MetaEvalInfo CTRL_MetaEvalInfo; struct CTRL_MetaEvalInfo { @@ -80,6 +88,7 @@ U32 color; String8 label; String8 location; String8 condition; +CTRL_MetaEvalFrameArray callstack; }; typedef struct CTRL_MetaEval CTRL_MetaEval; @@ -93,14 +102,15 @@ U32 color; U64 label; U64 location; U64 condition; +U64 callstack; }; C_LINKAGE_BEGIN -extern String8 ctrl_meta_eval_member_name_table[8]; -extern Rng1U64 ctrl_meta_eval_info_member_range_table[8]; -extern Rng1U64 ctrl_meta_eval_member_range_table[8]; -extern E_TypeKind ctrl_meta_eval_member_type_kind_table[8]; -extern CTRL_MetaEvalDynamicKind ctrl_meta_eval_member_dynamic_kind_table[8]; +extern String8 ctrl_meta_eval_member_name_table[9]; +extern Rng1U64 ctrl_meta_eval_info_member_range_table[9]; +extern Rng1U64 ctrl_meta_eval_member_range_table[9]; +extern E_TypeKind ctrl_meta_eval_member_type_kind_table[9]; +extern CTRL_MetaEvalDynamicKind ctrl_meta_eval_member_dynamic_kind_table[9]; extern String8 ctrl_entity_kind_display_string_table[8]; extern U32 ctrl_exception_code_kind_code_table[38]; extern String8 ctrl_exception_code_kind_display_string_table[38]; diff --git a/src/scratch/ryan_scratch.c b/src/scratch/ryan_scratch.c index 52056791..c707e363 100644 --- a/src/scratch/ryan_scratch.c +++ b/src/scratch/ryan_scratch.c @@ -5,7 +5,7 @@ //~ rjf: Build Options #define BUILD_TITLE "ryan_scratch" -#define OS_FEATURE_GRAPHICAL 1 +// #define OS_FEATURE_GRAPHICAL 1 //////////////////////////////// //~ rjf: Includes @@ -43,9 +43,130 @@ //////////////////////////////// //~ rjf: Entry Point +typedef struct FooBar FooBar; +struct FooBar +{ + U64 x; + U64 y; + U64 z; + String8 name; +}; + +//- + +Type String8__str_ptr_type = {TypeKind_Ptr, 0, sizeof(void *), &type_leaves[TypeKind_U8], {0}, str8_lit_comp("size")}; + +Member String8__members[] = +{ + {str8_lit_comp("str"), &String8__str_ptr_type, OffsetOf(String8, str)}, + {str8_lit_comp("size"), &type_leaves[TypeKind_U64], OffsetOf(String8, size)}, +}; + +Type String8__type = +{ + TypeKind_Struct, + 0, + sizeof(String8), + &type_leaves[0], + str8_lit_comp("String8"), + {0}, + ArrayCount(String8__members), + String8__members, +}; + +//- + +extern Type String8Node__type; +Type String8Node__ptr_type = {TypeKind_Ptr, 0, sizeof(void *), &String8Node__type}; + +Member String8Node__members[] = +{ + {str8_lit_comp("next"), &String8Node__ptr_type, OffsetOf(String8Node, next)}, + {str8_lit_comp("string"), type(String8), OffsetOf(String8Node, string)}, +}; + +Type String8Node__type = +{ + TypeKind_Struct, + 0, + sizeof(String8Node), + &type_leaves[0], + str8_lit_comp("String8Node"), + {0}, + ArrayCount(String8Node__members), + String8Node__members, +}; + +//- + +Member String8List__members[] = +{ + {str8_lit_comp("first"), &String8Node__ptr_type, OffsetOf(String8List, first)}, + {str8_lit_comp("last"), &String8Node__ptr_type, OffsetOf(String8List, last), MemberFlag_DoNotSerialize}, + {str8_lit_comp("node_count"), &type_leaves[TypeKind_U64], OffsetOf(String8List, node_count)}, + {str8_lit_comp("total_size"), &type_leaves[TypeKind_U64], OffsetOf(String8List, total_size)}, +}; + +Type String8List__type = +{ + TypeKind_Struct, + 0, + sizeof(String8List), + &type_leaves[0], + str8_lit_comp("String8List"), + {0}, + ArrayCount(String8List__members), + String8List__members, +}; + +//- + +Member FooBar__members[] = +{ + {str8_lit_comp("x"), &type_leaves[TypeKind_U64], OffsetOf(FooBar, x)}, + {str8_lit_comp("y"), &type_leaves[TypeKind_U64], OffsetOf(FooBar, y)}, + {str8_lit_comp("z"), &type_leaves[TypeKind_U64], OffsetOf(FooBar, z)}, + {str8_lit_comp("name"), type(String8), OffsetOf(FooBar, name)}, +}; + +Type FooBar__type = +{ + TypeKind_Struct, + 0, + sizeof(FooBar), + &type_leaves[0], + str8_lit_comp("FooBar"), + {0}, + ArrayCount(FooBar__members), + FooBar__members, +}; + internal void entry_point(CmdLine *cmdline) { + Arena *arena = arena_alloc(); + + String8List strs = {0}; + str8_list_pushf(arena, &strs, "foobar: %i", 123); + str8_list_pushf(arena, &strs, "xyzxyzxyz"); + str8_list_pushf(arena, &strs, "abc abc abc"); + str8_list_pushf(arena, &strs, "123"); + str8_list_pushf(arena, &strs, "456"); + str8_list_pushf(arena, &strs, "789"); + str8_list_pushf(arena, &strs, "111"); + str8_list_pushf(arena, &strs, "222"); + str8_list_pushf(arena, &strs, "333"); + String8 strs_serialized = serialized_from_struct(arena, String8List, &strs); + + String8 test_name = str8_lit("foobar 123"); + String8 test_name_serialized = serialized_from_struct(arena, String8, &test_name); + + FooBar foobar = {1, 2, 3, str8_lit("foobar 123 hello world")}; + String8 foobar_serialized = serialized_from_struct(arena, FooBar, &foobar); + + int x = 0; + +#if 0 OS_Handle window = os_window_open(v2f32(1280, 720), 0, str8_lit("Window")); os_window_first_paint(window); for(B32 quit = 0; !quit;) @@ -70,4 +191,5 @@ entry_point(CmdLine *cmdline) } scratch_end(scratch); } +#endif }