base layer defined type info tables experiment - can ideally be used as a more whole solution for the ctrl meta eval info stuff

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"

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"
 

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 = &params->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)
+{
+  
+}

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

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')`
 }
 
 ////////////////////////////////

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;
       }
     }
   }

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] =

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];

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
 }