fix ordering of local itypes within itype blocks in type name map; latter added itypes need to come *first*

The current horizontal chunk motion (ctrl + left/right arrow by default) does not work like most other editors, subverting the users expectation. The behaviour of most editors from my experience is as follows:
1. Skip any leading whitespace in the motion
2. If the next char is:
    - Alphanumeric or `_`, move up until the next symbol that isn't one of those
    - not one of the above move either up until: the next whitespace character or the same rules as above if an alphanumeric or `_` is encountered before whitespace.

e.g. Assume the current cursor position and string `... |mystruct.member ...`
The current code will move to the end of the whole struct accessor: `... mystruct.member| ...`
Most other editors would move to the end of the struct name: `... mystruct|.member ...`
In this case the current behaviour may not seem _that_ agregious, but in other cases its much more annoying
especially if you're looking to copy into a watch window or something as in this case:
`|ui_nav_scanned_column_from_column(String8 string, ...)`
the cursor will move to: `ui_nav_scanned_column_from_column(String8| string, ...)`
which is almost certainly not what the user wanted.

This behaviour means that if you want to copy a symbol, you can consistantly achieve this by chunk moving to one end, pressing shift, then chunk moving to the other end without ever getting extra symbols/whitespace. This is currently not possible with existing chunk motions.

README.md

@@ -5,6 +5,11 @@ currently only supports local-machine Windows x64 debugging with PDBs, with
 plans to expand and port in the future. In the future we'll expand to also
 support native Linux debugging and DWARF debug info.
 
+The RAD Debugger is currently in *ALPHA*. In order to get the debugger bullet-
+proof, it'd greatly help out if you submitted the issues you find here, along
+with any information you can gather, like dump files (along with the build you
+used), instructions to reproduce, test executables, and so on.
+
 You can download pre-built binaries for the debugger
 [here](https://github.com/EpicGames/raddebugger/releases).
 
@@ -13,8 +18,10 @@ unifying the underlying debug info format. In that pursuit we've built
 the RADDBG debug info format, which is what the debugger parses and uses. To
 work with existing toolchains, we convert PDB (and eventually PE/ELF files
 with embedded DWARF) into the RADDBG format on-demand. This conversion process
-is currently unoptimized but quite fast for smaller PDB files (in many cases
-faster than many other programs simply deserialize the PDBs).
+is currently an unoptimized reference version. Nevertheless it's still quite
+fast for smaller PDB files (in many cases faster than many other programs
+simply deserialize the PDBs). It is much slower for much larger projects at the
+moment, but we expect this will vastly improve overtime.
 
 The RADDBG format is currently specified in code, in the files within the
 `src/raddbg_format` folder. The other relevant folders for working with the
@@ -78,9 +85,12 @@ build
 You should see the following output:
 
 ```
+[debug mode]
+[msvc compile]
+[default mode, assuming `raddbg` build]
 metagen_main.c
-searching path/to/codebase/src... 591 files found
-parsing metadesk... 25 metadesk files parsed
+searching C:\devel\raddebugger/src... 299 files found
+parsing metadesk... 12 metadesk files parsed
 gathering tables... 37 tables found
 generating layer code...
 raddbg.cpp
@@ -89,6 +99,76 @@ raddbg.cpp
 If everything worked correctly, there will be a `build` folder in the root
 level of the codebase, and it will contain a freshly-built `raddbg.exe`.
 
+## Short-To-Medium-Term Roadmap
+
+### The Initial Alpha Battle-Testing Phase
+
+The first priority for the project is to ensure that the most crucial debugger
+components are functioning extremely reliably for local, x64, Windows
+debugging. This would include parts like debug info conversion, debug info
+loading, process control, stepping, evaluation (correct usage of both location
+info and type info), and a robust frontend which ensures the lower level parts
+are usable.
+
+We feel that the debugger has already come a long way in all of these respects,
+but given the massive set of possible combinations of languages, build
+settings, toolchains, used language features, and patterns of generated code,
+there are still cases where the debugger has not been tested, and so there are
+still issues. So, we feel that the top priority is eliminating these issues,
+such that the debugging experience is rock solid.
+
+Additionally, the debug info conversion process is not fast (nor wide) enough
+to support extremely large projects. This is for two reasons: (a) the
+PDB-to-RADDBG converter is an unoptimized reference implementation, and (b) the
+debugger learns of new modules (and thus which PDBs to load) in a
+serially-dependent way (this is necessarily the case for correct debugging
+results). We expect that the conversion process' performance can be massively
+improved, and also that some heuristics can be used to begin converting PDBs
+to RADDBGs before the debugger knows those PDBs are needed, thus ensuring the
+associated RADDBG files are ready instantaneously when the associated modules
+are finally loaded by the debugger. Improving this situation is a major part of
+this phase, as it will make the debugger much more usable for large projects.
+
+### Local x64 Linux Debugging Phase
+
+The next priority for the project is to take the rock solid x64 Windows
+debugging experience, and port all of the relevant pieces to support local x64
+Linux debugging also.
+
+The debugger has been written to abstract over the parts that need to differ on
+either Linux or Windows, and this is mainly going to be a task in building out
+different backends for those abstraction layers.
+
+The major parts of this phase are:
+
+- Porting the `src/demon` layer to implement the Demon local process control
+abstraction API.
+- Porting the `src/unwind` layer to support x64 ELF unwinding (currently, there
+is only an x64 PE unwinding implementation).
+- Creating a DWARF-to-RADDBG converter (in the same way that we've built a PDB-
+to-RADDBG converter). A partial implementation of this is in
+`src/raddbg_convert/dwarf`.
+- Porting the `src/render` layer to implement all of the rendering features the
+frontend needs on a Linux-compatible API (the backend used on Windows is D3D11).
+- Porting the `src/font_provider` layer to a Linux-compatible font
+rasterization backend, like FreeType (the backend used on Windows is
+DirectWrite).
+- Porting the `src/os` layers to Linux. This includes core operating system
+abstraction (virtual memory allocation, threading and synchronization
+primitives, and so on), and graphical operating system abstraction (windows,
+input events, and so on).
+
+Once the above list is complete, and once every part is rock solid, the Windows
+debugging experience we'll have worked diligently to create will also be
+available natively on Linux machines.
+
+### And Beyond!
+
+There are several directions we might take after these two major phases,
+like remote debugging, porting to different architectures, further improving
+the debugger's features (like improving the visualization engine), and so on.
+But for now, we're mostly focused on those first two phases.
+
 ## Top-Level Directory Descriptions
 
 - `data`: Small binary files which are used when building, either to embed
@@ -177,7 +257,7 @@ A list of the layers in the codebase and their associated namespaces is below:
 - `hash_store` (`HS_`): Implements a cache for general data blobs, keyed by a
   128-bit hash of the data. Used as a general data store by other layers.
 - `metagen` (`MG_`): A metaprogram which is used to generate primarily code and
-  data tables. Consumes Metadesk files, stored with the extension `.mc`, and
+  data tables. Consumes Metadesk files, stored with the extension `.mdesk`, and
   generates C code which is then included by hand-written C code. Currently, it
   does not analyze the codebase's hand-written C code, but in principle this is
   possible. This allows easier & less-error-prone management of large data

build.bat

@@ -42,13 +42,13 @@ if "%asan%"=="1"      set auto_compile_flags=%auto_compile_flags% -fsanitize=add
 
 :: --- Compile/Link Line Definitions ------------------------------------------
 set cl_common=     /I..\src\ /I..\local\ /nologo /FC /Z7 /MP
-set clang_common=  -I..\src\ -I..\local\ -maes -mssse3 -msse4 -gcodeview -fdiagnostics-absolute-paths -Wall -Wno-missing-braces -Wno-unused-function -Wno-writable-strings -Wno-unused-value -Wno-unused-variable -Wno-unused-local-typedef -Wno-deprecated-register -Wno-deprecated-declarations -Wno-unused-but-set-variable -Wno-single-bit-bitfield-constant-conversion -Xclang -flto-visibility-public-std -D_USE_MATH_DEFINES -Dstrdup=_strdup -Dgnu_printf=printf
-set cl_debug=      cl /Od /D_DEBUG %cl_common%
-set cl_release=    cl /O2 /DNDEBUG %cl_common%
-set clang_debug=   clang -g -O0 /D_DEBUG %clang_common%
-set clang_release= clang -g -O3 /DNDEBUG %clang_common% 
-set cl_link=       /link /natvis:%~dp0\src\natvis\base.natvis
-set clang_link=    -Xlinker /natvis:%~dp0\src\natvis\base.natvis
+set clang_common=  -I..\src\ -I..\local\ -maes -mssse3 -msse4 -gcodeview -fdiagnostics-absolute-paths -Wall -Wno-unknown-warning-option -Wno-missing-braces -Wno-unused-function -Wno-writable-strings -Wno-unused-value -Wno-unused-variable -Wno-unused-local-typedef -Wno-deprecated-register -Wno-deprecated-declarations -Wno-unused-but-set-variable -Wno-single-bit-bitfield-constant-conversion -Xclang -flto-visibility-public-std -D_USE_MATH_DEFINES -Dstrdup=_strdup -Dgnu_printf=printf
+set cl_debug=      call cl /Od /D_DEBUG %cl_common%
+set cl_release=    call cl /O2 /DNDEBUG %cl_common%
+set clang_debug=   call clang -g -O0 -D_DEBUG %clang_common%
+set clang_release= call clang -g -O3 -DNDEBUG %clang_common% 
+set cl_link=       /link /natvis:"%~dp0\src\natvis\base.natvis"
+set clang_link=    -Xlinker /natvis:"%~dp0\src\natvis\base.natvis"
 set cl_out=        /out:
 set clang_out=     -o
 
@@ -85,13 +85,13 @@ if not "%no_meta%"=="1" (
 
 :: --- Build Everything (@build_targets) --------------------------------------
 pushd build
-if "%raddbg%"=="1"             %compile% %gfx%       ..\src\raddbg\raddbg.cpp                                     %compile_link% %out%raddbg.exe
+if "%raddbg%"=="1"             %compile% %gfx%       ..\src\raddbg\raddbg_main.cpp                                %compile_link% %out%raddbg.exe
 if "%raddbg_from_pdb%"=="1"    %compile%             ..\src\raddbg_convert\pdb\raddbg_from_pdb_main.c             %compile_link% %out%raddbg_from_pdb.exe
 if "%raddbg_from_dwarf%"=="1"  %compile%             ..\src\raddbg_convert\dwarf\raddbg_from_dwarf.c              %compile_link% %out%raddbg_from_dwarf.exe
 if "%raddbg_dump%"=="1"        %compile%             ..\src\raddbg_dump\raddbg_dump.c                             %compile_link% %out%raddbg_dump.exe
 if "%ryan_scratch%"=="1"       %compile%             ..\src\scratch\ryan_scratch.c                                %compile_link% %out%ryan_scratch.exe
 if "%look_at_raddbg%"=="1"     %compile%             ..\src\scratch\look_at_raddbg.c                              %compile_link% %out%look_at_raddbg.exe
-if "%mule_main%"=="1"          del vc*.pdb mule*.pdb && %cl_release% /c ..\src\mule\mule_inline.cpp && %cl_release% /c ..\src\mule\mule_o2.cpp && %cl_debug% /EHsc ..\src\mule\mule_main.cpp mule\mule_c.c mule_inline.obj mule_o2.obj
+if "%mule_main%"=="1"          del vc*.pdb mule*.pdb && %cl_release% /c ..\src\mule\mule_inline.cpp && %cl_release% /c ..\src\mule\mule_o2.cpp && %cl_debug% /EHsc ..\src\mule\mule_main.cpp ..\src\mule\mule_c.c mule_inline.obj mule_o2.obj
 if "%mule_module%"=="1"        %compile%             ..\src\mule\mule_module.cpp                                  %compile_link% %link_dll% %out%mule_module.dll
 popd
 

project.4coder

@@ -18,9 +18,8 @@ patterns =
   "*.bfs",
   "*.html",
   "*.txt",
-  "*.ds",
   "*.md",
-  "*.mc",
+  "*.mdesk",
   "*.asm",
 };
 
@@ -82,6 +81,15 @@ commands =
     .save_dirty_files = true,
     .cursor_at_end = false,
   },
+  .build_raddbg_dump =
+  {
+    .win = "build raddbg_dump",
+    .linux = "",
+    .out = "*compilation*",
+    .footer_panel = true,
+    .save_dirty_files = true,
+    .cursor_at_end = false,
+  },
   .build_mule_main =
   {
     .win = "build mule_main",

src/ctrl/ctrl_core.c

@@ -1516,6 +1516,7 @@ ctrl_thread__next_demon_event(Arena *arena, CTRL_Msg *msg, DEMON_RunCtrls *run_c
       out_evt->stack_base = demon_stack_base_vaddr_from_thread(event->thread);
       out_evt->tls_root   = demon_tls_root_vaddr_from_thread(event->thread);
       out_evt->rip_vaddr  = event->instruction_pointer;
+      out_evt->string     = event->string;
     }break;
     case DEMON_EventKind_LoadModule:
     {

src/ctrl/ctrl_core.h

@@ -538,7 +538,7 @@ internal Architecture ctrl_arch_from_handle(CTRL_MachineID machine, CTRL_Handle
 //- rjf: process memory reading/writing
 internal U64 ctrl_process_read(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, void *dst);
 internal String8 ctrl_query_cached_data_from_process_vaddr_range(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range);
-internal String8 ctrl_query_cached_zero_terminated_data_from_process_vaddr_limit(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, U64 vaddr, U64 limit);
+internal String8 ctrl_query_cached_zero_terminated_data_from_process_vaddr_limit(Arena *arena, CTRL_MachineID machine_id, CTRL_Handle process, U64 vaddr, U64 limit, U64 endt_us);
 internal B32 ctrl_process_write_data(CTRL_MachineID machine_id, CTRL_Handle process, U64 vaddr, String8 data);
 internal U128 ctrl_stored_hash_from_process_vaddr_range(CTRL_MachineID machine_id, CTRL_Handle process, Rng1U64 range, B32 zero_terminated);
 

src/dasm/dasm.h

@@ -33,7 +33,7 @@ struct DASM_InstChunkNode
   U64 count;
 };
 
-typedef struct DASM_InstChunkNode DASM_InstChunkNode;
+typedef struct DASM_InstChunkList DASM_InstChunkList;
 struct DASM_InstChunkList
 {
   DASM_InstChunkNode *first;

src/dbgi/dbgi.c

@@ -653,7 +653,7 @@ dbgi_parse_thread_entry_point(void *p)
               }
               if(os_now_microseconds()-start_wait_t > 10000000 && og_dbg_props.size < MB(64))
               {
-                os_graphical_message(1, str8_lit("RADDBG INTERNAL DEVELOPMENT MESSAGE"), str8_lit("this is taking a while... indicative of something that seemed like a bug that Jeff hit before. attach with debugger now & see where the callstack is?"));
+                // os_graphical_message(1, str8_lit("RADDBG INTERNAL DEVELOPMENT MESSAGE"), str8_lit("this is taking a while... indicative of something that seemed like a bug that Jeff hit before. attach with debugger now & see where the callstack is?"));
               }
             }
           }

src/demon/win32/demon_os_win32.c

@@ -4,6 +4,8 @@
 ////////////////////////////////
 //~ rjf: Globals
 
+global GetThreadDescriptionFunctionType *demon_w32_GetThreadDescription = 0;
+
 global B32   demon_w32_resume_needed = 0;
 global DWORD demon_w32_resume_pid = 0;
 global DWORD demon_w32_resume_tid = 0;
@@ -26,6 +28,17 @@ global String8List demon_w32_environment = {0};
 ////////////////////////////////
 //~ rjf: Helpers
 
+internal U64
+demon_w32_hash_from_string(String8 string)
+{
+  U64 result = 5381;
+  for(U64 i = 0; i < string.size; i += 1)
+  {
+    result = ((result << 5) + result) + string.str[i];
+  }
+  return result;
+}
+
 internal DEMON_W32_Ext*
 demon_w32_ext_alloc(void){
   DEMON_W32_Ext *result = demon_w32_proc_ext_free;
@@ -351,6 +364,11 @@ demon_os_init(void){
   demon_w32_ext_arena = arena_alloc();
   demon_w32_detach_proc_arena = arena_alloc();
   
+  // rjf: load Windows 10+ GetThreadDescription API
+  {
+    demon_w32_GetThreadDescription = (GetThreadDescriptionFunctionType *)GetProcAddress(GetModuleHandleA("Kernel32.dll"), "GetThreadDescription");
+  }
+  
   // rjf: setup environment variables
   {
     CHAR *this_proc_env = GetEnvironmentStrings();
@@ -771,6 +789,19 @@ demon_os_run(Arena *arena, DEMON_OS_RunCtrls *ctrls){
             DWORD sus_result = SuspendThread(thread_ext->thread.handle);
             (void)sus_result;
             
+            // rjf: unpack thread name
+            String8 thread_name = {0};
+            if(demon_w32_GetThreadDescription != 0)
+            {
+              WCHAR *thread_name_w = 0;
+              HRESULT hr = demon_w32_GetThreadDescription(evt.u.CreateThread.hThread, &thread_name_w);
+              if(SUCCEEDED(hr))
+              {
+                thread_name = str8_from_16(arena, str16_cstring((U16 *)thread_name_w));
+                LocalFree(thread_name_w);
+              }
+            }
+            
             // rjf: determine if this is the halter thread
             B32 is_halter = (evt.dwThreadId == demon_w32_halter_thread_id);
             
@@ -780,6 +811,7 @@ demon_os_run(Arena *arena, DEMON_OS_RunCtrls *ctrls){
               e->process = demon_ent_handle_from_ptr(process);
               e->thread = demon_ent_handle_from_ptr(thread);
               e->code = evt.dwThreadId;
+              e->string = thread_name;
             }
           }
         }break;
@@ -925,7 +957,9 @@ demon_os_run(Arena *arena, DEMON_OS_RunCtrls *ctrls){
             }
             
             // rjf: check if trap
-            B32 is_trap = (!first_bp && exception->ExceptionCode == DEMON_W32_EXCEPTION_BREAKPOINT);
+            B32 is_trap = (!first_bp &&
+                           (exception->ExceptionCode == DEMON_W32_EXCEPTION_BREAKPOINT ||
+                            exception->ExceptionCode == DEMON_W32_EXCEPTION_STACK_BUFFER_OVERRUN));
             
             // rjf: check if this trap is currently registered
             B32 hit_user_trap = 0;
@@ -947,7 +981,8 @@ demon_os_run(Arena *arena, DEMON_OS_RunCtrls *ctrls){
                 // TODO(rjf): x86/x64 specific check
                 // TODO(rjf): do we need to check to make sure the instruction
                 // pointer has not changed?
-                hit_explicit_trap = (instruction_byte == 0xCC);
+                hit_explicit_trap = (instruction_byte == 0xCC ||
+                                     instruction_byte == 0xCD);
               }
             }
             
@@ -1006,6 +1041,11 @@ demon_os_run(Arena *arena, DEMON_OS_RunCtrls *ctrls){
                   e->kind = report_event_kind;
                 }break;
                 
+                case DEMON_W32_EXCEPTION_STACK_BUFFER_OVERRUN:
+                {
+                  e->kind = DEMON_EventKind_Trap;
+                }break;
+                
                 case DEMON_W32_EXCEPTION_SINGLE_STEP:
                 {
                   e->kind = DEMON_EventKind_SingleStep;
@@ -1140,6 +1180,48 @@ demon_os_run(Arena *arena, DEMON_OS_RunCtrls *ctrls){
       }
     }
     
+    //- rjf: gather new thread-names
+    if(demon_w32_GetThreadDescription != 0)
+    {
+      for(DEMON_Entity *process = demon_ent_root->first;
+          process != 0;
+          process = process->next)
+      {
+        if(process->kind != DEMON_EntityKind_Process) { continue; }
+        for(DEMON_Entity *thread = process->first;
+            thread != 0;
+            thread = thread->next)
+        {
+          if(thread->kind != DEMON_EntityKind_Thread) { continue; }
+          DEMON_W32_Ext *thread_ext = demon_w32_ext(thread);
+          if(thread_ext->thread.last_name_hash == 0 ||
+             thread_ext->thread.name_gather_time_us+1000000 <= os_now_microseconds())
+          {
+            String8 name = {0};
+            {
+              WCHAR *thread_name_w = 0;
+              HRESULT hr = demon_w32_GetThreadDescription(thread_ext->thread.handle, &thread_name_w);
+              if(SUCCEEDED(hr))
+              {
+                name = str8_from_16(scratch.arena, str16_cstring((U16 *)thread_name_w));
+                LocalFree(thread_name_w);
+              }
+            }
+            U64 name_hash = demon_w32_hash_from_string(name);
+            if(name.size != 0 && name_hash != thread_ext->thread.last_name_hash)
+            {
+              DEMON_Event *e = demon_push_event(arena, &result, DEMON_EventKind_SetThreadName);
+              e->process = demon_ent_handle_from_ptr(process);
+              e->thread = demon_ent_handle_from_ptr(thread);
+              e->string = push_str8_copy(arena, name);
+            }
+            thread_ext->thread.name_gather_time_us = os_now_microseconds();
+            thread_ext->thread.last_name_hash = name_hash;
+          }
+        }
+      }
+    }
+    
     // TODO(allen): handle errors? if (!got_new_event) ? if (!good_state) ?
     
     // TODO(allen): per-Architecture

src/demon/win32/demon_os_win32.h

@@ -35,6 +35,8 @@ union DEMON_W32_Ext
   struct{
     HANDLE handle;
     U64 thread_local_base;
+    U64 last_name_hash;
+    U64 name_gather_time_us;
   } thread;
   struct{
     HANDLE handle;
@@ -68,6 +70,7 @@ struct DEMON_W32_EntityNode
   DEMON_Entity *entity;
 };
 
+typedef HRESULT GetThreadDescriptionFunctionType(HANDLE hThread, WCHAR **ppszThreadDescription);
 
 ////////////////////////////////
 //~ NOTE(allen): Win32 Demon Exceptions
@@ -352,6 +355,7 @@ struct DEMON_PeOptionalHeader32Plus
 ////////////////////////////////
 //~ rjf: Helpers
 
+internal U64 demon_w32_hash_from_string(String8 string);
 internal DEMON_W32_Ext* demon_w32_ext_alloc(void);
 internal DEMON_W32_Ext* demon_w32_ext(DEMON_Entity *entity);
 

src/df/core/df_core.c

@@ -1852,6 +1852,7 @@ df_entity_change_parent(DF_StateDeltaHistory *hist, DF_Entity *entity, DF_Entity
 internal void
 df_entity_equip_txt_pt(DF_Entity *entity, TxtPt point)
 {
+  df_require_entity_nonnil(entity, return);
   entity->text_point = point;
   entity->flags |= DF_EntityFlag_HasTextPoint;
   df_entity_notify_mutation(entity);
@@ -1860,6 +1861,7 @@ df_entity_equip_txt_pt(DF_Entity *entity, TxtPt point)
 internal void
 df_entity_equip_txt_pt_alt(DF_Entity *entity, TxtPt point)
 {
+  df_require_entity_nonnil(entity, return);
   entity->text_point_alt = point;
   entity->flags |= DF_EntityFlag_HasTextPointAlt;
   df_entity_notify_mutation(entity);
@@ -1868,6 +1870,7 @@ df_entity_equip_txt_pt_alt(DF_Entity *entity, TxtPt point)
 internal void
 df_entity_equip_entity_handle(DF_Entity *entity, DF_Handle handle)
 {
+  df_require_entity_nonnil(entity, return);
   entity->entity_handle = handle;
   entity->flags |= DF_EntityFlag_HasEntityHandle;
   df_entity_notify_mutation(entity);
@@ -1876,6 +1879,7 @@ df_entity_equip_entity_handle(DF_Entity *entity, DF_Handle handle)
 internal void
 df_entity_equip_b32(DF_Entity *entity, B32 b32)
 {
+  df_require_entity_nonnil(entity, return);
   entity->b32 = b32;
   entity->flags |= DF_EntityFlag_HasB32;
   df_entity_notify_mutation(entity);
@@ -1884,6 +1888,7 @@ df_entity_equip_b32(DF_Entity *entity, B32 b32)
 internal void
 df_entity_equip_u64(DF_Entity *entity, U64 u64)
 {
+  df_require_entity_nonnil(entity, return);
   entity->u64 = u64;
   entity->flags |= DF_EntityFlag_HasU64;
   df_entity_notify_mutation(entity);
@@ -1892,6 +1897,7 @@ df_entity_equip_u64(DF_Entity *entity, U64 u64)
 internal void
 df_entity_equip_rng1u64(DF_Entity *entity, Rng1U64 range)
 {
+  df_require_entity_nonnil(entity, return);
   entity->rng1u64 = range;
   entity->flags |= DF_EntityFlag_HasRng1U64;
   df_entity_notify_mutation(entity);
@@ -1900,6 +1906,7 @@ df_entity_equip_rng1u64(DF_Entity *entity, Rng1U64 range)
 internal void
 df_entity_equip_color_rgba(DF_Entity *entity, Vec4F32 rgba)
 {
+  df_require_entity_nonnil(entity, return);
   Vec3F32 rgb = v3f32(rgba.x, rgba.y, rgba.z);
   Vec3F32 hsv = hsv_from_rgb(rgb);
   Vec4F32 hsva = v4f32(hsv.x, hsv.y, hsv.z, rgba.w);
@@ -1909,6 +1916,7 @@ df_entity_equip_color_rgba(DF_Entity *entity, Vec4F32 rgba)
 internal void
 df_entity_equip_color_hsva(DF_Entity *entity, Vec4F32 hsva)
 {
+  df_require_entity_nonnil(entity, return);
   entity->color_hsva = hsva;
   entity->flags |= DF_EntityFlag_HasColor;
   df_entity_notify_mutation(entity);
@@ -1917,6 +1925,7 @@ df_entity_equip_color_hsva(DF_Entity *entity, Vec4F32 hsva)
 internal void
 df_entity_equip_death_timer(DF_Entity *entity, F32 seconds_til_death)
 {
+  df_require_entity_nonnil(entity, return);
   entity->flags |= DF_EntityFlag_DiesWithTime;
   entity->life_left = seconds_til_death;
   df_entity_notify_mutation(entity);
@@ -1925,6 +1934,7 @@ df_entity_equip_death_timer(DF_Entity *entity, F32 seconds_til_death)
 internal void
 df_entity_equip_cfg_src(DF_Entity *entity, DF_CfgSrc cfg_src)
 {
+  df_require_entity_nonnil(entity, return);
   entity->cfg_src = cfg_src;
   df_entity_notify_mutation(entity);
 }
@@ -1934,6 +1944,7 @@ df_entity_equip_cfg_src(DF_Entity *entity, DF_CfgSrc cfg_src)
 internal void
 df_entity_equip_ctrl_machine_id(DF_Entity *entity, CTRL_MachineID machine_id)
 {
+  df_require_entity_nonnil(entity, return);
   entity->ctrl_machine_id = machine_id;
   entity->flags |= DF_EntityFlag_HasCtrlMachineID;
   df_entity_notify_mutation(entity);
@@ -1942,6 +1953,7 @@ df_entity_equip_ctrl_machine_id(DF_Entity *entity, CTRL_MachineID machine_id)
 internal void
 df_entity_equip_ctrl_handle(DF_Entity *entity, CTRL_Handle handle)
 {
+  df_require_entity_nonnil(entity, return);
   entity->ctrl_handle = handle;
   entity->flags |= DF_EntityFlag_HasCtrlHandle;
   df_entity_notify_mutation(entity);
@@ -1950,6 +1962,7 @@ df_entity_equip_ctrl_handle(DF_Entity *entity, CTRL_Handle handle)
 internal void
 df_entity_equip_arch(DF_Entity *entity, Architecture arch)
 {
+  df_require_entity_nonnil(entity, return);
   entity->arch = arch;
   entity->flags |= DF_EntityFlag_HasArch;
   df_entity_notify_mutation(entity);
@@ -1958,6 +1971,7 @@ df_entity_equip_arch(DF_Entity *entity, Architecture arch)
 internal void
 df_entity_equip_ctrl_id(DF_Entity *entity, U32 id)
 {
+  df_require_entity_nonnil(entity, return);
   entity->ctrl_id = id;
   entity->flags |= DF_EntityFlag_HasCtrlID;
   df_entity_notify_mutation(entity);
@@ -1966,6 +1980,7 @@ df_entity_equip_ctrl_id(DF_Entity *entity, U32 id)
 internal void
 df_entity_equip_stack_base(DF_Entity *entity, U64 stack_base)
 {
+  df_require_entity_nonnil(entity, return);
   entity->stack_base = stack_base;
   entity->flags |= DF_EntityFlag_HasStackBase;
   df_entity_notify_mutation(entity);
@@ -1974,6 +1989,7 @@ df_entity_equip_stack_base(DF_Entity *entity, U64 stack_base)
 internal void
 df_entity_equip_tls_root(DF_Entity *entity, U64 tls_root)
 {
+  df_require_entity_nonnil(entity, return);
   entity->tls_root = tls_root;
   entity->flags |= DF_EntityFlag_HasTLSRoot;
   df_entity_notify_mutation(entity);
@@ -1982,6 +1998,7 @@ df_entity_equip_tls_root(DF_Entity *entity, U64 tls_root)
 internal void
 df_entity_equip_vaddr_rng(DF_Entity *entity, Rng1U64 range)
 {
+  df_require_entity_nonnil(entity, return);
   entity->vaddr_rng = range;
   entity->flags |= DF_EntityFlag_HasVAddrRng;
   df_entity_notify_mutation(entity);
@@ -1990,6 +2007,7 @@ df_entity_equip_vaddr_rng(DF_Entity *entity, Rng1U64 range)
 internal void
 df_entity_equip_vaddr(DF_Entity *entity, U64 vaddr)
 {
+  df_require_entity_nonnil(entity, return);
   entity->vaddr = vaddr;
   entity->flags |= DF_EntityFlag_HasVAddr;
   df_entity_notify_mutation(entity);
@@ -2000,7 +2018,19 @@ df_entity_equip_vaddr(DF_Entity *entity, U64 vaddr)
 internal void
 df_entity_equip_name(DF_StateDeltaHistory *hist, DF_Entity *entity, String8 name)
 {
-  entity->name = df_name_alloc(hist, name);
+  df_require_entity_nonnil(entity, return);
+  if(entity->name.size != 0)
+  {
+    df_name_release(hist, entity->name);
+  }
+  if(name.size != 0)
+  {
+    entity->name = df_name_alloc(hist, name);
+  }
+  else
+  {
+    entity->name = str8_zero();
+  }
   entity->name_generation += 1;
   df_entity_notify_mutation(entity);
 }
@@ -2839,6 +2869,23 @@ df_trap_net_from_thread__step_into_line(Arena *arena, DF_Entity *thread)
       {
         trap_addr = point->jump_dest_vaddr;
         flags &= ~CTRL_TrapFlag_SingleStepAfterHit;
+        
+        // rjf: read instruction one layer deep after a jump and determine if
+        // it is just jumping to an unconditional jump (e.g. a function
+        // dispatch table) - if so, then just follow one more layer
+        String8 dst_machine_code = {0};
+        dst_machine_code.str = push_array_no_zero(scratch.arena, U8, max_instruction_size_from_arch(arch));
+        dst_machine_code.size = ctrl_process_read(process->ctrl_machine_id, process->ctrl_handle, r1u64(trap_addr, trap_addr+max_instruction_size_from_arch(arch)), dst_machine_code.str);
+        if(dst_machine_code.size != 0)
+        {
+          DF_Inst inst = df_single_inst_from_machine_code(scratch.arena, arch, 0, dst_machine_code);
+          if((inst.flags & DF_InstFlag_UnconditionalJump ||
+              inst.flags & DF_InstFlag_Call) &&
+             inst.rel_voff != 0)
+          {
+            trap_addr = (U64)(trap_addr + (S64)((S32)inst.rel_voff));
+          }
+        }
       }
     }
     
@@ -7094,63 +7141,97 @@ df_core_begin_frame(Arena *arena, DF_CmdList *cmds, F32 dt)
         case DF_CoreCmdKind_LoadUser:
         case DF_CoreCmdKind_LoadProfile:
         {
-          String8 new_path = params.file_path;
           B32 load_cfg[DF_CfgSrc_COUNT] = {0};
           for(DF_CfgSrc src = (DF_CfgSrc)0; src < DF_CfgSrc_COUNT; src = (DF_CfgSrc)(src+1))
           {
             load_cfg[src] = (core_cmd_kind == df_g_cfg_src_load_cmd_kind_table[src]);
           }
           
-          //- rjf: set new config paths
-          for(DF_CfgSrc src = (DF_CfgSrc)0; src < DF_CfgSrc_COUNT; src = (DF_CfgSrc)(src+1))
+          //- rjf: normalize path
+          String8 new_path = path_normalized_from_string(scratch.arena, params.file_path);
+          
+          //- rjf: path -> data
+          FileProperties props = {0};
+          String8 data = {0};
           {
-            if(load_cfg[src])
+            OS_Handle file = os_file_open(OS_AccessFlag_Shared|OS_AccessFlag_Read, new_path);
+            props = os_properties_from_file(file);
+            data = os_string_from_file_range(scratch.arena, file, r1u64(0, props.size));
+            os_file_close(file);
+          }
+          
+          //- rjf: investigate file path/data
+          B32 file_is_okay = 1;
+          if(props.modified != 0 && data.size != 0 && !str8_match(str8_prefix(data, 9), str8_lit("// raddbg"), 0))
+          {
+            file_is_okay = 0;
+          }
+          
+          //- rjf: set new config paths
+          if(file_is_okay)
+          {
+            for(DF_CfgSrc src = (DF_CfgSrc)0; src < DF_CfgSrc_COUNT; src = (DF_CfgSrc)(src+1))
             {
-              arena_clear(df_state->cfg_path_arenas[src]);
-              df_state->cfg_paths[src] = path_normalized_from_string(df_state->cfg_path_arenas[src], params.file_path);
+              if(load_cfg[src])
+              {
+                arena_clear(df_state->cfg_path_arenas[src]);
+                df_state->cfg_paths[src] = push_str8_copy(df_state->cfg_path_arenas[src], new_path);
+              }
             }
           }
           
           //- rjf: get config files
           DF_Entity *cfg_files[DF_CfgSrc_COUNT] = {0};
-          for(DF_CfgSrc src = (DF_CfgSrc)0; src < DF_CfgSrc_COUNT; src = (DF_CfgSrc)(src+1))
+          if(file_is_okay)
           {
-            String8 path = df_cfg_path_from_src(src);
-            cfg_files[src] = df_entity_from_path(path, DF_EntityFromPathFlag_OpenMissing|DF_EntityFromPathFlag_OpenAsNeeded);
+            for(DF_CfgSrc src = (DF_CfgSrc)0; src < DF_CfgSrc_COUNT; src = (DF_CfgSrc)(src+1))
+            {
+              String8 path = df_cfg_path_from_src(src);
+              cfg_files[src] = df_entity_from_path(path, DF_EntityFromPathFlag_OpenMissing|DF_EntityFromPathFlag_OpenAsNeeded);
+            }
           }
           
           //- rjf: load files
           String8 cfg_data[DF_CfgSrc_COUNT] = {0};
           U64 cfg_timestamps[DF_CfgSrc_COUNT] = {0};
-          for(DF_CfgSrc src = (DF_CfgSrc)0; src < DF_CfgSrc_COUNT; src = (DF_CfgSrc)(src+1))
+          if(file_is_okay)
           {
-            DF_Entity *file_entity = cfg_files[src];
-            String8 path = df_full_path_from_entity(scratch.arena, file_entity);
-            OS_Handle file = os_file_open(OS_AccessFlag_Shared|OS_AccessFlag_Read, path);
-            FileProperties props = os_properties_from_file(file);
-            String8 data = os_string_from_file_range(scratch.arena, file, r1u64(0, props.size));
-            if(data.size != 0)
+            for(DF_CfgSrc src = (DF_CfgSrc)0; src < DF_CfgSrc_COUNT; src = (DF_CfgSrc)(src+1))
             {
-              cfg_data[src] = data;
-              cfg_timestamps[src] = props.modified;
+              DF_Entity *file_entity = cfg_files[src];
+              String8 path = df_full_path_from_entity(scratch.arena, file_entity);
+              OS_Handle file = os_file_open(OS_AccessFlag_Shared|OS_AccessFlag_Read, path);
+              FileProperties props = os_properties_from_file(file);
+              String8 data = os_string_from_file_range(scratch.arena, file, r1u64(0, props.size));
+              if(data.size != 0)
+              {
+                cfg_data[src] = data;
+                cfg_timestamps[src] = props.modified;
+              }
+              os_file_close(file);
             }
-            os_file_close(file);
           }
           
           //- rjf: determine if we need to save config
           B32 cfg_save[DF_CfgSrc_COUNT] = {0};
-          for(DF_CfgSrc src = (DF_CfgSrc)0; src < DF_CfgSrc_COUNT; src = (DF_CfgSrc)(src+1))
+          if(file_is_okay)
           {
-            cfg_save[src] = (load_cfg[src] && cfg_files[src]->flags & DF_EntityFlag_IsMissing);
+            for(DF_CfgSrc src = (DF_CfgSrc)0; src < DF_CfgSrc_COUNT; src = (DF_CfgSrc)(src+1))
+            {
+              cfg_save[src] = (load_cfg[src] && cfg_files[src]->flags & DF_EntityFlag_IsMissing);
+            }
           }
           
           //- rjf: determine if we need to reload config
           B32 cfg_load[DF_CfgSrc_COUNT] = {0};
           B32 cfg_load_any = 0;
-          for(DF_CfgSrc src = (DF_CfgSrc)0; src < DF_CfgSrc_COUNT; src = (DF_CfgSrc)(src+1))
+          if(file_is_okay)
           {
-            cfg_load[src] = (load_cfg[src] && ((cfg_save[src] == 0 && df_state->cfg_cached_timestamp[src] != cfg_timestamps[src]) || cfg_files[src]->timestamp == 0));
-            cfg_load_any = cfg_load_any || cfg_load[src];
+            for(DF_CfgSrc src = (DF_CfgSrc)0; src < DF_CfgSrc_COUNT; src = (DF_CfgSrc)(src+1))
+            {
+              cfg_load[src] = (load_cfg[src] && ((cfg_save[src] == 0 && df_state->cfg_cached_timestamp[src] != cfg_timestamps[src]) || cfg_files[src]->timestamp == 0));
+              cfg_load_any = cfg_load_any || cfg_load[src];
+            }
           }
           
           //- rjf: load => build new config table
@@ -7169,27 +7250,42 @@ df_core_begin_frame(Arena *arena, DF_CmdList *cmds, F32 dt)
           // NOTE(rjf): must happen before `save`. we need to create a default before saving, which
           // occurs in the 'apply' path.
           //
-          for(DF_CfgSrc src = (DF_CfgSrc)0; src < DF_CfgSrc_COUNT; src = (DF_CfgSrc)(src+1))
+          if(file_is_okay)
           {
-            if(cfg_load[src])
+            for(DF_CfgSrc src = (DF_CfgSrc)0; src < DF_CfgSrc_COUNT; src = (DF_CfgSrc)(src+1))
             {
-              DF_CoreCmdKind cmd_kind = df_g_cfg_src_apply_cmd_kind_table[src];
-              DF_CmdParams params = df_cmd_params_zero();
-              df_cmd_list_push(arena, cmds, &params, df_cmd_spec_from_core_cmd_kind(cmd_kind));
-              df_state->cfg_cached_timestamp[src] = cfg_timestamps[src];
+              if(cfg_load[src])
+              {
+                DF_CoreCmdKind cmd_kind = df_g_cfg_src_apply_cmd_kind_table[src];
+                DF_CmdParams params = df_cmd_params_zero();
+                df_cmd_list_push(arena, cmds, &params, df_cmd_spec_from_core_cmd_kind(cmd_kind));
+                df_state->cfg_cached_timestamp[src] = cfg_timestamps[src];
+              }
             }
           }
           
           //- rjf: save => dispatch write
-          for(DF_CfgSrc src = (DF_CfgSrc)0; src < DF_CfgSrc_COUNT; src = (DF_CfgSrc)(src+1))
+          if(file_is_okay)
           {
-            if(cfg_save[src])
+            for(DF_CfgSrc src = (DF_CfgSrc)0; src < DF_CfgSrc_COUNT; src = (DF_CfgSrc)(src+1))
             {
-              DF_CoreCmdKind cmd_kind = df_g_cfg_src_write_cmd_kind_table[src];
-              DF_CmdParams params = df_cmd_params_zero();
-              df_cmd_list_push(arena, cmds, &params, df_cmd_spec_from_core_cmd_kind(cmd_kind));
+              if(cfg_save[src])
+              {
+                DF_CoreCmdKind cmd_kind = df_g_cfg_src_write_cmd_kind_table[src];
+                DF_CmdParams params = df_cmd_params_zero();
+                df_cmd_list_push(arena, cmds, &params, df_cmd_spec_from_core_cmd_kind(cmd_kind));
+              }
             }
           }
+          
+          //- rjf: bad file -> alert user
+          if(!file_is_okay)
+          {
+            DF_CmdParams p = params;
+            p.string = push_str8f(scratch.arena, "\"%S\" appears to refer to an existing file which is not a RADDBG config file. This would overwrite the file.", new_path);
+            df_cmd_params_mark_slot(&p, DF_CmdParamSlot_String);
+            df_cmd_list_push(arena, cmds, &p, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_Error));
+          }
         }break;
         
         //- rjf: loading/applying stateful config changes

src/df/core/df_core.h

@@ -1355,6 +1355,7 @@ internal DF_CoreCmdKind df_core_cmd_kind_from_string(String8 string);
 
 //- rjf: nil
 internal B32 df_entity_is_nil(DF_Entity *entity);
+#define df_require_entity_nonnil(entity, if_nil_stmts) do{if(df_entity_is_nil(entity)){if_nil_stmts;}}while(0)
 
 //- rjf: handle <-> entity conversions
 internal U64 df_index_from_entity(DF_Entity *entity);

src/df/core/df_core.mdesk

@@ -80,22 +80,23 @@ DF_EntityKindTable:
 @table(name, name_lower, c_type)
 DF_CmdParamSlotTable:
 {
-  {Window,            window,      `DF_Handle`}
-  {Panel,             panel,       `DF_Handle`}
-  {DestPanel,         dest_panel,  `DF_Handle`}
-  {PrevView,          prev_view,   `DF_Handle`}
-  {View,              view,        `DF_Handle`}
-  {Entity,            entity,      `DF_Handle`}
-  {EntityList,        entity_list, `DF_HandleList`}
-  {String,            string,      `String8`}
-  {FilePath,          file_path,   `String8`}
-  {TextPoint,         text_point,  `TxtPt`}
-  {CmdSpec,           cmd_spec,    `struct DF_CmdSpec *`}
-  {VirtualAddr,       vaddr,       `U64`}
-  {VirtualOff,        voff,        `U64`}
-  {Index,             index,       `U64`}
-  {ID,                id,          `U64`}
-  {PreferDisassembly, prefer_dasm, `B32`}
+  {Window,            window,       `DF_Handle`}
+  {Panel,             panel,        `DF_Handle`}
+  {DestPanel,         dest_panel,   `DF_Handle`}
+  {PrevView,          prev_view,    `DF_Handle`}
+  {View,              view,         `DF_Handle`}
+  {Entity,            entity,       `DF_Handle`}
+  {EntityList,        entity_list,  `DF_HandleList`}
+  {String,            string,       `String8`}
+  {FilePath,          file_path,    `String8`}
+  {TextPoint,         text_point,   `TxtPt`}
+  {CmdSpec,           cmd_spec,     `struct DF_CmdSpec *`}
+  {VirtualAddr,       vaddr,        `U64`}
+  {VirtualOff,        voff,         `U64`}
+  {Index,             index,        `U64`}
+  {ID,                id,           `U64`}
+  {PreferDisassembly, prefer_dasm,  `B32`}
+  {ForceConfirm,      force_confirm,`B32`}
 }
 
 @table(name, display_string, args_desc)
@@ -185,6 +186,10 @@ DF_CoreCmdTable:
   {CloseWindow                    0            0            0           0               0                 Window             Null               Null                     Null                        Null                 0                                    0                                                Window                "close_window"                "Close Window"                                "Closes an opened window."                                                                                         ""                               }
   {ToggleFullscreen               0            0            0           0               0                 Window             Null               Null                     Null                        Null                 0                                    0                                                Window                "toggle_fullscreen"           "Toggle Fullscreen"                           "Toggles fullscreen view on the active window."                                                                    ""                               }
   
+  //- rjf: confirmations
+  {ConfirmAccept                  1            0            0           0               0                 Null               Null               Null                     Null                        Null                 0                                    0                                                Null                  "confirm_accept"              "Confirm Accept"                              "Accepts the active confirmation prompt."                                                                          ""                               }
+  {ConfirmCancel                  1            0            0           0               0                 Null               Null               Null                     Null                        Null                 0                                    0                                                Null                  "confirm_cancel"              "Confirm Cancel"                              "Cancels the active confirmation prompt."                                                                          ""                               }
+  
   //- rjf: panel splitting
   {ResetToDefaultPanels           0            0            0           0               0                 Window             Null               Null                     Null                        Null                 0                                    0                                                Window                "reset_to_default_panels"     "Reset To Default Panel Layout"               "Resets the window to the default panel layout."                                                                   "panel"                          }
   {NewPanelRight                  0            0            0           0               0                 Window             Panel              Null                     Null                        Null                 0                                    0                                                XSplit                "new_panel_right"             "Split Panel Vertically"                      "Creates a new panel to the right of the active panel."                                                            "panel"                          }

src/df/core/generated/df_core.meta.c

@@ -54,6 +54,8 @@ DF_CmdSpecInfo df_g_core_cmd_kind_spec_info_table[] =
 { str8_lit_comp("open_window"), str8_lit_comp("Opens a new window."), str8_lit_comp(""), str8_lit_comp("Open New Window"), (DF_CmdSpecFlag_OmitFromLists*0) | (DF_CmdSpecFlag_RunKeepsQuery*0) | (DF_CmdSpecFlag_QueryUsesOldInput*0) | (DF_CmdSpecFlag_AppliesToView*0) | (DF_CmdSpecFlag_QueryIsCode*0), {DF_CmdParamSlot_Null, DF_CmdParamSlot_Null, DF_CmdParamSlot_Null}, DF_CmdQueryRule_Null, DF_IconKind_Window, {0, 0}},
 { str8_lit_comp("close_window"), str8_lit_comp("Closes an opened window."), str8_lit_comp(""), str8_lit_comp("Close Window"), (DF_CmdSpecFlag_OmitFromLists*0) | (DF_CmdSpecFlag_RunKeepsQuery*0) | (DF_CmdSpecFlag_QueryUsesOldInput*0) | (DF_CmdSpecFlag_AppliesToView*0) | (DF_CmdSpecFlag_QueryIsCode*0), {DF_CmdParamSlot_Window, DF_CmdParamSlot_Null, DF_CmdParamSlot_Null}, DF_CmdQueryRule_Null, DF_IconKind_Window, {0, 0}},
 { str8_lit_comp("toggle_fullscreen"), str8_lit_comp("Toggles fullscreen view on the active window."), str8_lit_comp(""), str8_lit_comp("Toggle Fullscreen"), (DF_CmdSpecFlag_OmitFromLists*0) | (DF_CmdSpecFlag_RunKeepsQuery*0) | (DF_CmdSpecFlag_QueryUsesOldInput*0) | (DF_CmdSpecFlag_AppliesToView*0) | (DF_CmdSpecFlag_QueryIsCode*0), {DF_CmdParamSlot_Window, DF_CmdParamSlot_Null, DF_CmdParamSlot_Null}, DF_CmdQueryRule_Null, DF_IconKind_Window, {0, 0}},
+{ str8_lit_comp("confirm_accept"), str8_lit_comp("Accepts the active confirmation prompt."), str8_lit_comp(""), str8_lit_comp("Confirm Accept"), (DF_CmdSpecFlag_OmitFromLists*1) | (DF_CmdSpecFlag_RunKeepsQuery*0) | (DF_CmdSpecFlag_QueryUsesOldInput*0) | (DF_CmdSpecFlag_AppliesToView*0) | (DF_CmdSpecFlag_QueryIsCode*0), {DF_CmdParamSlot_Null, DF_CmdParamSlot_Null, DF_CmdParamSlot_Null}, DF_CmdQueryRule_Null, DF_IconKind_Null, {0, 0}},
+{ str8_lit_comp("confirm_cancel"), str8_lit_comp("Cancels the active confirmation prompt."), str8_lit_comp(""), str8_lit_comp("Confirm Cancel"), (DF_CmdSpecFlag_OmitFromLists*1) | (DF_CmdSpecFlag_RunKeepsQuery*0) | (DF_CmdSpecFlag_QueryUsesOldInput*0) | (DF_CmdSpecFlag_AppliesToView*0) | (DF_CmdSpecFlag_QueryIsCode*0), {DF_CmdParamSlot_Null, DF_CmdParamSlot_Null, DF_CmdParamSlot_Null}, DF_CmdQueryRule_Null, DF_IconKind_Null, {0, 0}},
 { str8_lit_comp("reset_to_default_panels"), str8_lit_comp("Resets the window to the default panel layout."), str8_lit_comp("panel"), str8_lit_comp("Reset To Default Panel Layout"), (DF_CmdSpecFlag_OmitFromLists*0) | (DF_CmdSpecFlag_RunKeepsQuery*0) | (DF_CmdSpecFlag_QueryUsesOldInput*0) | (DF_CmdSpecFlag_AppliesToView*0) | (DF_CmdSpecFlag_QueryIsCode*0), {DF_CmdParamSlot_Window, DF_CmdParamSlot_Null, DF_CmdParamSlot_Null}, DF_CmdQueryRule_Null, DF_IconKind_Window, {0, 0}},
 { str8_lit_comp("new_panel_right"), str8_lit_comp("Creates a new panel to the right of the active panel."), str8_lit_comp("panel"), str8_lit_comp("Split Panel Vertically"), (DF_CmdSpecFlag_OmitFromLists*0) | (DF_CmdSpecFlag_RunKeepsQuery*0) | (DF_CmdSpecFlag_QueryUsesOldInput*0) | (DF_CmdSpecFlag_AppliesToView*0) | (DF_CmdSpecFlag_QueryIsCode*0), {DF_CmdParamSlot_Window, DF_CmdParamSlot_Panel, DF_CmdParamSlot_Null}, DF_CmdQueryRule_Null, DF_IconKind_XSplit, {0, 0}},
 { str8_lit_comp("new_panel_down"), str8_lit_comp("Creates a new panel at the bottom of the active panel."), str8_lit_comp("panel"), str8_lit_comp("Split Panel Horizontally"), (DF_CmdSpecFlag_OmitFromLists*0) | (DF_CmdSpecFlag_RunKeepsQuery*0) | (DF_CmdSpecFlag_QueryUsesOldInput*0) | (DF_CmdSpecFlag_AppliesToView*0) | (DF_CmdSpecFlag_QueryIsCode*0), {DF_CmdParamSlot_Window, DF_CmdParamSlot_Panel, DF_CmdParamSlot_Null}, DF_CmdQueryRule_Null, DF_IconKind_YSplit, {0, 0}},

src/df/core/generated/df_core.meta.h

@@ -104,6 +104,8 @@ DF_CoreCmdKind_DecCodeFontScale,
 DF_CoreCmdKind_OpenWindow,
 DF_CoreCmdKind_CloseWindow,
 DF_CoreCmdKind_ToggleFullscreen,
+DF_CoreCmdKind_ConfirmAccept,
+DF_CoreCmdKind_ConfirmCancel,
 DF_CoreCmdKind_ResetToDefaultPanels,
 DF_CoreCmdKind_NewPanelRight,
 DF_CoreCmdKind_NewPanelDown,
@@ -368,6 +370,7 @@ DF_CmdParamSlot_VirtualOff,
 DF_CmdParamSlot_Index,
 DF_CmdParamSlot_ID,
 DF_CmdParamSlot_PreferDisassembly,
+DF_CmdParamSlot_ForceConfirm,
 DF_CmdParamSlot_COUNT
 } DF_CmdParamSlot;
 
@@ -407,6 +410,7 @@ U64 voff;
 U64 index;
 U64 id;
 B32 prefer_dasm;
+B32 force_confirm;
 };
 
 DF_CORE_VIEW_RULE_EVAL_RESOLUTION_FUNCTION_DEF(array);

src/df/gfx/df_gfx.c

@@ -1145,6 +1145,7 @@ df_window_update_and_render(Arena *arena, OS_EventList *events, DF_Window *ws, D
 {
   ProfBeginFunction();
   B32 window_is_focused = os_window_is_focused(ws->os);
+  B32 confirm_open = df_gfx_state->confirm_active;
   B32 hover_eval_is_open = (ws->hover_eval_string.size != 0 && ws->hover_eval_first_frame_idx+20 < ws->hover_eval_last_frame_idx && df_frame_index()-ws->hover_eval_last_frame_idx < 20);
   B32 any_query_is_focused = !df_panel_is_nil(ws->focused_panel) && !df_view_is_nil(df_query_view_from_panel(ws->focused_panel));
   if(!window_is_focused)
@@ -1842,8 +1843,18 @@ df_window_update_and_render(Arena *arena, OS_EventList *events, DF_Window *ws, D
               keep_child->size_pct_of_parent.v[split_axis] *= size_pct_of_parent.v[split_axis];
               keep_child->size_pct_of_parent.v[axis2_flip(split_axis)] *= size_pct_of_parent.v[axis2_flip(split_axis)];
               
+              // rjf: reset focus, if needed
+              if(ws->focused_panel == discard_child)
+              {
+                ws->focused_panel = keep_child;
+                for(DF_Panel *grandchild = ws->focused_panel; !df_panel_is_nil(grandchild); grandchild = grandchild->first)
+                {
+                  ws->focused_panel = grandchild;
+                }
+              }
+              
               // rjf: keep-child split-axis == grandparent split-axis? bubble keep-child up into grandparent's children
-              if(grandparent->split_axis == keep_child->split_axis && !df_panel_is_nil(keep_child->first))
+              if(!df_panel_is_nil(grandparent) && grandparent->split_axis == keep_child->split_axis && !df_panel_is_nil(keep_child->first))
               {
                 df_panel_remove(grandparent, keep_child);
                 DF_Panel *prev = parent_prev;
@@ -1858,16 +1869,6 @@ df_window_update_and_render(Arena *arena, OS_EventList *events, DF_Window *ws, D
                 }
                 df_panel_release(ws, keep_child);
               }
-              
-              // rjf: reset focus, if needed
-              if(ws->focused_panel == discard_child)
-              {
-                ws->focused_panel = keep_child;
-                for(DF_Panel *grandchild = ws->focused_panel; !df_panel_is_nil(grandchild); grandchild = grandchild->first)
-                {
-                  ws->focused_panel = grandchild;
-                }
-              }
             }
             // NOTE(rjf): Otherwise we can just remove this child.
             else
@@ -3222,6 +3223,7 @@ df_window_update_and_render(Arena *arena, OS_EventList *events, DF_Window *ws, D
             }
             avg_ui_hash_chain_length = chain_length_sum / chain_count;
           }
+          ui_labelf("Target Hz: %.2f", 1.f/df_dt());
           ui_labelf("Ctrl Run Index: %I64u", ctrl_run_idx());
           ui_labelf("Window %p", window);
           ui_set_next_pref_width(ui_children_sum(1));
@@ -3860,6 +3862,55 @@ df_window_update_and_render(Arena *arena, OS_EventList *events, DF_Window *ws, D
       scratch_end(scratch);
     }
     
+    //- rjf: confirmation popup
+    {
+      if(df_gfx_state->confirm_t > 0.005f) UI_Focus(1) UI_TextAlignment(UI_TextAlign_Center)
+      {
+        Vec2F32 window_dim = dim_2f32(window_rect);
+        UI_Box *bg_box = &ui_g_nil_box;
+        UI_Rect(window_rect) UI_ChildLayoutAxis(Axis2_X)
+        {
+          Vec4F32 bg_color = ui_top_background_color();
+          bg_color.w *= df_gfx_state->confirm_t;
+          ui_set_next_blur_size(10*df_gfx_state->confirm_t);
+          ui_set_next_background_color(bg_color);
+          bg_box = ui_build_box_from_stringf(UI_BoxFlag_FixedSize|UI_BoxFlag_Floating|UI_BoxFlag_Clickable|UI_BoxFlag_Scroll|UI_BoxFlag_DefaultFocusNav|UI_BoxFlag_DrawBackgroundBlur|UI_BoxFlag_DrawBackground, "###confirm_popup_%p", ws);
+        }
+        if(df_gfx_state->confirm_active) UI_Parent(bg_box)
+        {
+          ui_ctx_menu_close();
+          UI_WidthFill UI_PrefHeight(ui_children_sum(1.f)) UI_Column UI_Padding(ui_pct(1, 0))
+          {
+            UI_FontSize(ui_top_font_size()*2.f) UI_PrefHeight(ui_em(3.f, 1.f)) ui_label(df_gfx_state->confirm_title);
+            UI_PrefHeight(ui_em(3.f, 1.f)) UI_TextColor(df_rgba_from_theme_color(DF_ThemeColor_WeakText)) ui_label(df_gfx_state->confirm_msg);
+            ui_spacer(ui_em(1.5f, 1.f));
+            UI_Row UI_Padding(ui_pct(1.f, 0.f)) UI_WidthFill UI_PrefHeight(ui_em(5.f, 1.f))
+            {
+              UI_CornerRadius00(ui_top_font_size()*0.25f)
+                UI_CornerRadius01(ui_top_font_size()*0.25f)
+                if(ui_buttonf("Cancel").clicked || os_key_press(ui_events(), ui_window(), 0, OS_Key_Esc))
+              {
+                DF_CmdParams p = df_cmd_params_zero();
+                df_push_cmd__root(&p, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_ConfirmCancel));
+              }
+              UI_CornerRadius10(ui_top_font_size()*0.25f)
+                UI_CornerRadius11(ui_top_font_size()*0.25f)
+                UI_BackgroundColor(df_rgba_from_theme_color(DF_ThemeColor_ActionBackground))
+                UI_TextColor(df_rgba_from_theme_color(DF_ThemeColor_ActionText))
+                UI_BorderColor(df_rgba_from_theme_color(DF_ThemeColor_ActionBorder))
+                if(ui_buttonf("OK").clicked || os_key_press(ui_events(), ui_window(), 0, OS_Key_Return))
+              {
+                DF_CmdParams p = df_cmd_params_zero();
+                df_push_cmd__root(&p, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_ConfirmAccept));
+              }
+            }
+            ui_spacer(ui_em(3.f, 1.f));
+          }
+        }
+        ui_signal_from_box(bg_box);
+      }
+    }
+    
     //- rjf: build auto-complete lister
     ProfScope("build autocomplete lister")
       if(!ws->autocomp_force_closed && !ui_key_match(ws->autocomp_root_key, ui_key_zero()) && ws->autocomp_last_frame_idx+1 >= df_frame_index())
@@ -4333,7 +4384,6 @@ df_window_update_and_render(Arena *arena, OS_EventList *events, DF_Window *ws, D
           {
             DF_CoreCmdKind cmds[] =
             {
-              DF_CoreCmdKind_Commands,
               DF_CoreCmdKind_Targets,
               DF_CoreCmdKind_Scheduler,
               DF_CoreCmdKind_CallStack,
@@ -4352,7 +4402,6 @@ df_window_update_and_render(Arena *arena, OS_EventList *events, DF_Window *ws, D
             };
             U32 codepoints[] =
             {
-              'c',
               't',
               's',
               'k',
@@ -4454,19 +4503,33 @@ df_window_update_and_render(Arena *arena, OS_EventList *events, DF_Window *ws, D
           UI_Key help_menu_key = ui_key_from_string(ui_key_zero(), str8_lit("_help_menu_key_"));
           UI_CtxMenu(help_menu_key) UI_PrefWidth(ui_em(40.f, 1.f))
           {
-            ui_label(str8_lit_comp(RADDBG_TITLE_STRING_LITERAL));
-            ui_spacer(ui_em(0.75f, 1.f));
-            ui_label_multiline(ui_top_font_size()*30.f, str8_lit("If you run into issues, please send an email describing them to:"));
+            UI_Row UI_TextAlignment(UI_TextAlign_Center) UI_TextColor(df_rgba_from_theme_color(DF_ThemeColor_WeakText))
+              ui_label(str8_lit(RADDBG_TITLE_STRING_LITERAL));
+            ui_spacer(ui_em(0.25f, 1.f));
+            UI_Row
+              UI_PrefWidth(ui_text_dim(10, 1))
+              UI_TextAlignment(UI_TextAlign_Center)
+              UI_Padding(ui_pct(1, 0))
+            {
+              ui_labelf("Search for commands by pressing ");
+              DF_CmdSpec *spec = df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_Commands);
+              UI_TextColor(df_rgba_from_theme_color(DF_ThemeColor_PlainText))
+                UI_Flags(UI_BoxFlag_DrawBorder)
+                UI_TextAlignment(UI_TextAlign_Center)
+                df_cmd_binding_button(spec);
+            }
+            ui_spacer(ui_em(0.25f, 1.f));
+            UI_Row UI_TextAlignment(UI_TextAlign_Center) ui_label(str8_lit("Submit issues to the GitHub at:"));
             UI_TextAlignment(UI_TextAlign_Center)
             {
-              UI_Signal email_sig = ui_buttonf("ryan.fleury@epicgames.com");
-              if(email_sig.hovering) UI_Tooltip
+              UI_Signal url_sig = ui_buttonf("github.com/EpicGames/raddebugger");
+              if(url_sig.hovering) UI_Tooltip
               {
                 ui_labelf("Copy To Clipboard");
               }
-              if(email_sig.clicked)
+              if(url_sig.clicked)
               {
-                os_set_clipboard_text(str8_lit("ryan.fleury@epicgames.com"));
+                os_set_clipboard_text(str8_lit("https://github.com/EpicGames/raddebugger"));
               }
             }
           }
@@ -4927,7 +4990,8 @@ df_window_update_and_render(Arena *arena, OS_EventList *events, DF_Window *ws, D
                   }break;
                   case CTRL_EventCause_InterruptedByTrap:
                   {
-                    
+                    icon = DF_IconKind_WarningBig;
+                    explanation = push_str8f(scratch.arena, "%S interrupted by trap - 0x%x", thread_display_string, stop_event.exception_code);
                   }break;
                   case CTRL_EventCause_InterruptedByHalt:
                   {
@@ -5632,7 +5696,6 @@ df_window_update_and_render(Arena *arena, OS_EventList *events, DF_Window *ws, D
                 }
                 UI_TextColor(df_rgba_from_theme_color(view_is_selected ? DF_ThemeColor_PlainText : DF_ThemeColor_WeakText))
                   UI_PrefWidth(ui_pct(1, 0))
-                  UI_FontSize(ui_top_font_size()*(view_is_selected ? 1.f : 0.75f))
                   ui_label(label);
                 UI_PrefWidth(ui_em(2.35f, 1.f)) UI_TextAlignment(UI_TextAlign_Center)
                   UI_Font(df_font_from_slot(DF_FontSlot_Icons))
@@ -7542,7 +7605,7 @@ df_text_search_thread_entry_point(void *p)
 {
   TCTX tctx_;
   tctx_init_and_equip(&tctx_);
-#if !DE2CTRL
+#if 0
   // TODO(rjf): [ ] @de2ctrl text searcher -- wound up in DE_Hash
   
   //- rjf: types
@@ -7737,84 +7800,6 @@ df_text_search_thread_entry_point(void *p)
 #endif
 }
 
-internal DF_TextSearchMatchArray
-df_text_search_match_array_from_hash_needle(Arena *arena, U128 hash, String8 needle, DF_TextSliceFlags text_slice_flags, TxtPt start_pt)
-{
-  // TODO(rjf): [ ] @de2ctrl text searching lookup -- wound up with DE_Hash
-  DF_TextSearchMatchArray result = {0};
-  {
-    //- rjf: hash -> slot/stripe info
-    U64 little_hash              = df_text_search_little_hash_from_hash(hash);
-    U64 slot_idx                 = little_hash%df_gfx_state->tsrch_slot_count;
-    DF_TextSearchCacheSlot *slot = &df_gfx_state->tsrch_slots[slot_idx];
-    U64 stripe_idx               = slot_idx%df_gfx_state->tsrch_stripe_count;
-    OS_Handle stripe_rw_mutex    = df_gfx_state->tsrch_stripe_rw_mutexes[stripe_idx];
-    
-    //- rjf: find matches from existing node
-    B32 found_node = 0;
-    {
-      os_rw_mutex_take_r(stripe_rw_mutex);
-      for(DF_TextSearchCacheNode *node = slot->first; node != 0; node = node->next)
-      {
-        if(MemoryMatchStruct(&node->hash, &hash) &&
-           str8_match(node->needle, needle, StringMatchFlag_CaseInsensitive) &&
-           node->flags == text_slice_flags)
-        {
-          found_node = 1;
-          result = df_text_search_match_array_from_chunk_list(arena, &node->search_matches);
-          U64 time_current_us = os_now_microseconds();
-          ins_atomic_u64_eval_assign(&node->last_time_touched_us, time_current_us);
-          break;
-        }
-      }
-      os_rw_mutex_drop_r(stripe_rw_mutex);
-    }
-    
-    //- rjf: no existing node -> allocate new
-    if(found_node == 0)
-    {
-      os_rw_mutex_take_w(stripe_rw_mutex);
-      {
-        Arena *node_arena = arena_alloc();
-        DF_TextSearchCacheNode *node = push_array(node_arena, DF_TextSearchCacheNode, 1);
-        node->arena = node_arena;
-        node->hash = hash;
-        node->needle = push_str8_copy(node_arena, needle);
-        node->flags = text_slice_flags;
-        node->start_pt = start_pt;
-        DLLPushBack(slot->first, slot->last, node);
-      }
-      os_rw_mutex_drop_w(stripe_rw_mutex);
-      os_condition_variable_signal(df_gfx_state->tsrch_wakeup_cv);
-    }
-  }
-  return result;
-}
-
-internal DF_TextSearchMatchArray
-df_text_search_match_array_from_entity_needle(Arena *arena, DF_Entity *entity, String8 needle, DF_TextSliceFlags flags, TxtPt start_pt)
-{
-  // TODO(rjf): [ ] @de2ctrl text search lookup
-  DF_TextSearchMatchArray matches = {0};
-#if !DE2CTRL
-  if(entity->kind == DF_EntityKind_File && needle.size != 0)
-  {
-    Temp scratch = scratch_begin(&arena, 1);
-    String8 path = df_full_path_from_entity(scratch.arena, entity);
-    DE_PipelineHint hint = zero_struct;
-    DE_Key path2hash_key = de_key_path(DE_KeyFunc_HashFromPath, path, entity->timestamp);
-    DE_Val *path2hash_val = de_user_peek_lookup(de_user, de_shared, &hint, &path2hash_key);
-    DE_Hash hash = path2hash_val->hash;
-    if(!de_hash_is_empty(&hash))
-    {
-      matches = df_text_search_match_array_from_hash_needle(arena, hash, needle, flags, start_pt);
-    }
-    scratch_end(scratch);
-  }
-#endif
-  return matches;
-}
-
 internal int
 df_text_search_match_array_qsort_compare(TxtPt *a, TxtPt *b)
 {
@@ -8305,17 +8290,11 @@ df_cfg_strings_from_gfx(Arena *arena, String8 root_path, DF_CfgSrc source)
   //- rjf: serialize fonts
   if(source == DF_CfgSrc_User)
   {
-    String8 code_font_path_absolute = f_path_from_tag(df_gfx_state->cfg_font_tags[DF_FontSlot_Code]);
-    String8 main_font_path_absolute = f_path_from_tag(df_gfx_state->cfg_font_tags[DF_FontSlot_Main]);
-    String8 code_font_path_relative = path_relative_dst_from_absolute_dst_src(arena, code_font_path_absolute, root_path);
-    String8 main_font_path_relative = path_relative_dst_from_absolute_dst_src(arena, main_font_path_absolute, root_path);
-    {
-      str8_list_push(arena, &strs, str8_lit("/// fonts /////////////////////////////////////////////////////////////////////\n"));
-      str8_list_push(arena, &strs, str8_lit("\n"));
-      str8_list_pushf(arena, &strs, "code_font: \"%S\"\n", code_font_path_relative);
-      str8_list_pushf(arena, &strs, "main_font: \"%S\"\n", main_font_path_relative);
-      str8_list_push(arena, &strs, str8_lit("\n"));
-    }
+    str8_list_push(arena, &strs, str8_lit("/// fonts /////////////////////////////////////////////////////////////////////\n"));
+    str8_list_push(arena, &strs, str8_lit("\n"));
+    str8_list_pushf(arena, &strs, "code_font: \"%S\"\n", df_gfx_state->cfg_code_font_path);
+    str8_list_pushf(arena, &strs, "main_font: \"%S\"\n", df_gfx_state->cfg_main_font_path);
+    str8_list_push(arena, &strs, str8_lit("\n"));
   }
   
   ProfEnd();
@@ -10970,6 +10949,7 @@ df_gfx_init(OS_WindowRepaintFunctionType *window_repaint_entry_point, DF_StateDe
   df_gfx_state->num_frames_requested = 2;
   df_gfx_state->hist = hist;
   df_gfx_state->key_map_arena = arena_alloc();
+  df_gfx_state->confirm_arena = arena_alloc();
   df_gfx_state->view_spec_table_size = 256;
   df_gfx_state->view_spec_table = push_array(arena, DF_ViewSpec *, df_gfx_state->view_spec_table_size);
   df_gfx_state->view_rule_spec_table_size = 1024;
@@ -10980,6 +10960,8 @@ df_gfx_init(OS_WindowRepaintFunctionType *window_repaint_entry_point, DF_StateDe
   df_gfx_state->cmd2view_slots = push_array(arena, DF_String2ViewSlot, df_gfx_state->cmd2view_slot_count);
   df_gfx_state->string_search_arena = arena_alloc();
   df_gfx_state->repaint_hook = window_repaint_entry_point;
+  df_gfx_state->cfg_main_font_path_arena = arena_alloc();
+  df_gfx_state->cfg_code_font_path_arena = arena_alloc();
   df_clear_bindings();
   
   // rjf: register gfx layer views
@@ -11002,20 +10984,6 @@ df_gfx_init(OS_WindowRepaintFunctionType *window_repaint_entry_point, DF_StateDe
     }
   }
   
-  // rjf: set up background text searching thread
-  {
-    df_gfx_state->tsrch_slot_count = 64;
-    df_gfx_state->tsrch_stripe_count = df_gfx_state->tsrch_slot_count/8;
-    df_gfx_state->tsrch_slots = push_array(df_gfx_state->arena, DF_TextSearchCacheSlot, df_gfx_state->tsrch_slot_count);
-    df_gfx_state->tsrch_stripe_rw_mutexes = push_array(df_gfx_state->arena, OS_Handle, df_gfx_state->tsrch_stripe_count);
-    for(U64 stripe_idx = 0; stripe_idx < df_gfx_state->tsrch_stripe_count; stripe_idx += 1)
-    {
-      df_gfx_state->tsrch_stripe_rw_mutexes[stripe_idx] = os_rw_mutex_alloc();
-    }
-    df_gfx_state->tsrch_wakeup_mutex = os_mutex_alloc();
-    df_gfx_state->tsrch_wakeup_cv = os_condition_variable_alloc();
-    //df_gfx_state->tsrch_thread = os_launch_thread(df_text_search_thread_entry_point, 0, 0);
-  }
   ProfEnd();
 }
 
@@ -11026,6 +10994,17 @@ df_gfx_begin_frame(Arena *arena, DF_CmdList *cmds)
   arena_clear(df_gfx_state->frame_arena);
   df_gfx_state->hover_line_set_this_frame = 0;
   
+  //- rjf: animate confirmation
+  {
+    F32 rate = 1 - pow_f32(2, (-10.f * df_dt()));
+    B32 confirm_open = df_gfx_state->confirm_active;
+    df_gfx_state->confirm_t += rate * ((F32)!!confirm_open-df_gfx_state->confirm_t);
+    if(abs_f32(df_gfx_state->confirm_t - (F32)!!confirm_open) > 0.005f)
+    {
+      df_gfx_request_frame();
+    }
+  }
+  
   //- rjf: capture is active? -> keep rendering
   if(ProfIsCapturing())
   {
@@ -11086,10 +11065,32 @@ df_gfx_begin_frame(Arena *arena, DF_CmdList *cmds)
           DF_Window *ws = df_window_from_handle(params.window);
           if(ws != 0)
           {
+            DF_EntityList running_processes = df_query_cached_entity_list_with_kind(DF_EntityKind_Process);
+            
+            // NOTE(rjf): if this is the last window, and targets are running, but
+            // this command is not force-confirmed, then we should query the user
+            // to ensure they want to close the debugger before exiting
+            UI_Key key = ui_key_from_string(ui_key_zero(), str8_lit("lossy_exit_confirmation"));
+            if(!ui_key_match(key, df_gfx_state->confirm_key) && running_processes.count != 0 && ws == df_gfx_state->first_window && ws == df_gfx_state->last_window && !params.force_confirm)
+            {
+              df_gfx_state->confirm_key = key;
+              df_gfx_state->confirm_active = 1;
+              arena_clear(df_gfx_state->confirm_arena);
+              MemoryZeroStruct(&df_gfx_state->confirm_cmds);
+              df_gfx_state->confirm_title = push_str8f(df_gfx_state->confirm_arena, "Are you sure you want to exit?");
+              df_gfx_state->confirm_msg = push_str8f(df_gfx_state->confirm_arena, "The debugger is still attached to %slive process%s.",
+                                                     running_processes.count == 1 ? "a " : "",
+                                                     running_processes.count == 1 ? ""   : "es");
+              DF_CmdParams p = df_cmd_params_from_window(ws);
+              p.force_confirm = 1;
+              df_cmd_params_mark_slot(&p, DF_CmdParamSlot_ForceConfirm);
+              df_cmd_list_push(df_gfx_state->confirm_arena, &df_gfx_state->confirm_cmds, &p, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_CloseWindow));
+            }
+            
             // NOTE(rjf): if this is the last window, and it is being closed, then
             // we need to auto-save, and provide one last chance to process saving
             // commands. after doing so, we can retry.
-            if(ws == df_gfx_state->first_window && ws == df_gfx_state->last_window && df_gfx_state->last_window_queued_save == 0)
+            else if(ws == df_gfx_state->first_window && ws == df_gfx_state->last_window && df_gfx_state->last_window_queued_save == 0)
             {
               df_gfx_state->last_window_queued_save = 1;
               {
@@ -11131,6 +11132,22 @@ df_gfx_begin_frame(Arena *arena, DF_CmdList *cmds)
           }
         }break;
         
+        //- rjf: confirmations
+        case DF_CoreCmdKind_ConfirmAccept:
+        {
+          df_gfx_state->confirm_active = 0;
+          df_gfx_state->confirm_key = ui_key_zero();
+          for(DF_CmdNode *n = df_gfx_state->confirm_cmds.first; n != 0; n = n->next)
+          {
+            df_push_cmd__root(&n->cmd.params, n->cmd.spec);
+          }
+        }break;
+        case DF_CoreCmdKind_ConfirmCancel:
+        {
+          df_gfx_state->confirm_active = 0;
+          df_gfx_state->confirm_key = ui_key_zero();
+        }break;
+        
         //- rjf: commands with implications for graphical systems, but generated
         // without context needed - pick selected window & dispatch
         case DF_CoreCmdKind_SelectThread:
@@ -11206,13 +11223,7 @@ df_gfx_begin_frame(Arena *arena, DF_CmdList *cmds)
               f_tag_from_static_data_string(&df_g_default_code_font_bytes),
               f_tag_from_static_data_string(&df_g_icon_font_bytes),
             };
-            for(DF_FontSlot slot = (DF_FontSlot)0; slot < DF_FontSlot_COUNT; slot = (DF_FontSlot)(slot+1))
-            {
-              if(f_tag_match(f_tag_zero(), df_gfx_state->cfg_font_tags[slot]))
-              {
-                df_gfx_state->cfg_font_tags[slot] = defaults[slot];
-              }
-            }
+            MemoryZeroArray(df_gfx_state->cfg_font_tags);
             {
               DF_CfgVal *code_font_val = df_cfg_val_from_string(table, str8_lit("code_font"));
               DF_CfgVal *main_font_val = df_cfg_val_from_string(table, str8_lit("main_font"));
@@ -11220,17 +11231,34 @@ df_gfx_begin_frame(Arena *arena, DF_CmdList *cmds)
               DF_CfgNode *main_font_cfg = main_font_val->last;
               String8 code_font_relative_path = code_font_cfg->first->string;
               String8 main_font_relative_path = main_font_cfg->first->string;
+              if(code_font_cfg != &df_g_nil_cfg_node)
+              {
+                arena_clear(df_gfx_state->cfg_code_font_path_arena);
+                df_gfx_state->cfg_code_font_path = push_str8_copy(df_gfx_state->cfg_code_font_path_arena, code_font_relative_path);
+              }
+              if(main_font_cfg != &df_g_nil_cfg_node)
+              {
+                arena_clear(df_gfx_state->cfg_main_font_path_arena);
+                df_gfx_state->cfg_main_font_path = push_str8_copy(df_gfx_state->cfg_main_font_path_arena, main_font_relative_path);
+              }
               String8 code_font_path = path_absolute_dst_from_relative_dst_src(scratch.arena, code_font_relative_path, cfg_folder);
               String8 main_font_path = path_absolute_dst_from_relative_dst_src(scratch.arena, main_font_relative_path, cfg_folder);
-              if(code_font_cfg != &df_g_nil_cfg_node && code_font_relative_path.size != 0)
+              if(os_file_path_exists(code_font_path) && code_font_cfg != &df_g_nil_cfg_node && code_font_relative_path.size != 0)
               {
                 df_gfx_state->cfg_font_tags[DF_FontSlot_Code] = f_tag_from_path(code_font_path);
               }
-              if(main_font_cfg != &df_g_nil_cfg_node && main_font_relative_path.size != 0)
+              if(os_file_path_exists(main_font_path) && main_font_cfg != &df_g_nil_cfg_node && main_font_relative_path.size != 0)
               {
                 df_gfx_state->cfg_font_tags[DF_FontSlot_Main] = f_tag_from_path(main_font_path);
               }
             }
+            for(DF_FontSlot slot = (DF_FontSlot)0; slot < DF_FontSlot_COUNT; slot = (DF_FontSlot)(slot+1))
+            {
+              if(f_tag_match(f_tag_zero(), df_gfx_state->cfg_font_tags[slot]))
+              {
+                df_gfx_state->cfg_font_tags[slot] = defaults[slot];
+              }
+            }
           }
           
           //- rjf: build windows & panel layouts
@@ -11507,7 +11535,10 @@ df_gfx_begin_frame(Arena *arena, DF_CmdList *cmds)
           }
           
           //- rjf: apply keybindings
-          df_clear_bindings();
+          if(src == DF_CfgSrc_User)
+          {
+            df_clear_bindings();
+          }
           DF_CfgVal *keybindings = df_cfg_val_from_string(table, str8_lit("keybindings"));
           for(DF_CfgNode *keybinding_set = keybindings->first;
               keybinding_set != &df_g_nil_cfg_node;
@@ -11602,8 +11633,27 @@ df_gfx_begin_frame(Arena *arena, DF_CmdList *cmds)
             }
           }
           
+          //- rjf: if theme colors are all zeroes, then set to default - config appears busted
+          {
+            B32 all_colors_are_zero = 1;
+            Vec4F32 zero_color = {0};
+            for(DF_ThemeColor c = (DF_ThemeColor)(DF_ThemeColor_Null+1); c < DF_ThemeColor_COUNT; c = (DF_ThemeColor)(c+1))
+            {
+              if(!MemoryMatchStruct(&df_gfx_state->cfg_theme_target.colors[c], &zero_color))
+              {
+                all_colors_are_zero = 0;
+                break;
+              }
+            }
+            if(all_colors_are_zero)
+            {
+              MemoryCopy(df_gfx_state->cfg_theme_target.colors, df_g_theme_preset_colors__default_dark, sizeof(df_g_theme_preset_colors__default_dark));
+              MemoryCopy(df_gfx_state->cfg_theme.colors, df_g_theme_preset_colors__default_dark, sizeof(df_g_theme_preset_colors__default_dark));
+            }
+          }
+          
           //- rjf: if config opened 0 windows, we need to do some sensible default
-          if(df_gfx_state->first_window == 0)
+          if(src == DF_CfgSrc_User && windows->first == &df_g_nil_cfg_node)
           {
             OS_Handle preferred_monitor = os_primary_monitor();
             Vec2F32 monitor_dim = os_dim_from_monitor(preferred_monitor);
@@ -11614,7 +11664,7 @@ df_gfx_begin_frame(Arena *arena, DF_CmdList *cmds)
           }
           
           //- rjf: if config bound 0 keys, we need to do some sensible default
-          if(df_gfx_state->key_map_total_count == 0)
+          if(src == DF_CfgSrc_User && df_gfx_state->key_map_total_count == 0)
           {
             for(U64 idx = 0; idx < ArrayCount(df_g_default_binding_table); idx += 1)
             {

src/df/gfx/df_gfx.h

@@ -345,7 +345,7 @@ enum
 #define DF_GFX_VIEW_RULE_ROW_UI_FUNCTION_NAME(name) df_gfx_view_rule_row_ui__##name
 #define DF_GFX_VIEW_RULE_ROW_UI_FUNCTION_DEF(name) DF_GFX_VIEW_RULE_ROW_UI_FUNCTION_SIG(DF_GFX_VIEW_RULE_ROW_UI_FUNCTION_NAME(name))
 
-#define DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_SIG(name) void name(DF_Window *ws, DF_ExpandKey key, DF_Eval eval, DBGI_Scope *dbgi_scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, struct DF_CfgNode *cfg, Vec2F32 dim)
+#define DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_SIG(name) void name(struct DF_Window *ws, DF_ExpandKey key, DF_Eval eval, DBGI_Scope *dbgi_scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, struct DF_CfgNode *cfg, Vec2F32 dim)
 #define DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_NAME(name) df_gfx_view_rule_block_ui__##name
 #define DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_DEF(name) DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_SIG(DF_GFX_VIEW_RULE_BLOCK_UI_FUNCTION_NAME(name))
 
@@ -681,6 +681,15 @@ struct DF_GfxState
   DF_CmdSpec *bind_change_cmd_spec;
   DF_Binding bind_change_binding;
   
+  // rjf: confirmation popup state
+  UI_Key confirm_key;
+  B32 confirm_active;
+  F32 confirm_t;
+  Arena *confirm_arena;
+  DF_CmdList confirm_cmds;
+  String8 confirm_title;
+  String8 confirm_msg;
+  
   // rjf: string search state
   Arena *string_search_arena;
   String8 string_search_string;
@@ -726,16 +735,11 @@ struct DF_GfxState
   // rjf: running theme state
   DF_Theme cfg_theme_target;
   DF_Theme cfg_theme;
+  Arena *cfg_main_font_path_arena;
+  Arena *cfg_code_font_path_arena;
+  String8 cfg_main_font_path;
+  String8 cfg_code_font_path;
   F_Tag cfg_font_tags[DF_FontSlot_COUNT];
-  
-  // rjf: text search state
-  U64 tsrch_slot_count;
-  U64 tsrch_stripe_count;
-  DF_TextSearchCacheSlot *tsrch_slots;
-  OS_Handle *tsrch_stripe_rw_mutexes;
-  OS_Handle tsrch_wakeup_mutex;
-  OS_Handle tsrch_wakeup_cv;
-  OS_Handle tsrch_thread;
 };
 
 ////////////////////////////////
@@ -960,14 +964,12 @@ internal void df_set_search_string(String8 string);
 internal String8 df_push_search_string(Arena *arena);
 
 ////////////////////////////////
-//~ rjf: Background Text Searching Thread
+//~ rjf: Text Searching
 
 internal void df_text_search_match_chunk_list_push(Arena *arena, DF_TextSearchMatchChunkList *list, U64 cap, DF_TextSearchMatch *match);
 internal DF_TextSearchMatchArray df_text_search_match_array_from_chunk_list(Arena *arena, DF_TextSearchMatchChunkList *chunks);
 internal U64 df_text_search_little_hash_from_hash(U128 hash);
 internal void df_text_search_thread_entry_point(void *p);
-internal DF_TextSearchMatchArray df_text_search_match_array_from_hash_needle(Arena *arena, U128 hash, String8 needle, DF_TextSliceFlags text_slice_flags, TxtPt start_pt);
-internal DF_TextSearchMatchArray df_text_search_match_array_from_entity_needle(Arena *arena, DF_Entity *entity, String8 needle, DF_TextSliceFlags flags, TxtPt start_pt);
 internal int df_text_search_match_array_qsort_compare(TxtPt *a, TxtPt *b);
 internal void df_text_search_match_array_sort_in_place(DF_TextSearchMatchArray *array);
 internal DF_TextSearchMatch df_text_search_match_array_find_nearest__linear_scan(DF_TextSearchMatchArray *array, TxtPt pt, Side side);

src/df/gfx/df_view_rule_hooks.h

@@ -32,7 +32,7 @@ struct DF_TxtTopologyInfo
 ////////////////////////////////
 //~ rjf: Helpers
 
-internal Vec4F32 df_view_rule_hooks__rgba_from_eval(DF_Eval eval, TG_Graph *graph, RADDBG_Parsed *raddbg);
+internal Vec4F32 df_view_rule_hooks__rgba_from_eval(DF_Eval eval, TG_Graph *graph, RADDBG_Parsed *raddbg, DF_Entity *process);
 internal void df_view_rule_hooks__eval_commit_rgba(DF_Eval eval, TG_Graph *graph, RADDBG_Parsed *raddbg, DF_CtrlCtx *ctrl_ctx, Vec4F32 rgba);
 internal DF_BitmapTopologyInfo df_view_rule_hooks__bitmap_topology_info_from_cfg(DBGI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, DF_CfgNode *cfg);
 internal DF_GeoTopologyInfo df_view_rule_hooks__geo_topology_info_from_cfg(DBGI_Scope *scope, DF_CtrlCtx *ctrl_ctx, EVAL_ParseCtx *parse_ctx, DF_CfgNode *cfg);

src/df/gfx/df_views.c

@@ -4989,7 +4989,7 @@ DF_VIEW_UI_FUNCTION_DEF(Code)
   //- rjf: search query -> matches
   //
   DF_TextSearchMatchArray search_query_matches = {0};
-#if !DE2CTRL
+#if 0
   {
     search_query_matches = df_text_search_match_array_from_entity_needle(scratch.arena, entity, search_query, entity_line_string_flags, tv->cursor);
     df_text_search_match_array_sort_in_place(&search_query_matches);
@@ -5153,7 +5153,7 @@ DF_VIEW_UI_FUNCTION_DEF(Code)
   if(txti_buffer_is_ready) UI_Parent(container_box)
   {
     //- rjf: build fractional space
-    container_box->view_off.x = view->scroll_pos.x.idx + view->scroll_pos.x.off;
+    container_box->view_off.x = container_box->view_off_target.x = view->scroll_pos.x.idx + view->scroll_pos.x.off;
     container_box->view_off.y = container_box->view_off_target.y = code_line_height*mod_f32(view->scroll_pos.y.off, 1.f) + code_line_height*(view->scroll_pos.y.off < 0) - code_line_height*(view->scroll_pos.y.off == -1.f && view->scroll_pos.y.idx == 1);
     
     //- rjf: build code slice
@@ -5359,7 +5359,7 @@ DF_VIEW_UI_FUNCTION_DEF(Code)
     if(search_query.size != 0 && next_match.line != 0)
     {
       // TODO(rjf): [ ] @de2ctrl
-#if !DE2CTRL
+#if 0
       DF_TextSlice match_line_slice = df_text_slice_from_entity(scratch.arena, entity, r1s64(next_match.line, next_match.line), entity_line_string_flags);
       String8 match_line = match_line_slice.visible_range_text;
       F32 match_advance = f_dim_from_tag_size_string(code_font, code_font_size, str8_prefix(match_line, next_match.column-1)).x;
@@ -6033,7 +6033,7 @@ DF_VIEW_UI_FUNCTION_DEF(Disassembly)
   if(has_disasm) UI_Parent(container_box)
   {
     //- rjf: build fractional space
-    container_box->view_off.x = view->scroll_pos.x.idx + view->scroll_pos.x.off;
+    container_box->view_off.x = container_box->view_off_target.x = view->scroll_pos.x.idx + view->scroll_pos.x.off;
     container_box->view_off.y = container_box->view_off_target.y = code_line_height*mod_f32(view->scroll_pos.y.off, 1.f) + code_line_height*(view->scroll_pos.y.off < 0) - code_line_height*(view->scroll_pos.y.off == -1.f && view->scroll_pos.y.idx == 1);
     
     //- rjf: build code slice
@@ -6803,7 +6803,7 @@ DF_VIEW_UI_FUNCTION_DEF(Output)
   //- rjf: search query -> matches
   //
   DF_TextSearchMatchArray search_query_matches = {0};
-#if !DE2CTRL
+#if 0
   {
     search_query_matches = df_text_search_match_array_from_entity_needle(scratch.arena, entity, search_query, entity_line_string_flags, tv->cursor);
     df_text_search_match_array_sort_in_place(&search_query_matches);
@@ -6967,7 +6967,7 @@ DF_VIEW_UI_FUNCTION_DEF(Output)
   if(txti_buffer_is_ready) UI_Parent(container_box)
   {
     //- rjf: build fractional space
-    container_box->view_off.x = view->scroll_pos.x.idx + view->scroll_pos.x.off;
+    container_box->view_off.x = container_box->view_off_target.x = view->scroll_pos.x.idx + view->scroll_pos.x.off;
     container_box->view_off.y = container_box->view_off_target.y = code_line_height*mod_f32(view->scroll_pos.y.off, 1.f) + code_line_height*(view->scroll_pos.y.off < 0) - code_line_height*(view->scroll_pos.y.off == -1.f && view->scroll_pos.y.idx == 1);
     
     //- rjf: build code slice
@@ -7030,7 +7030,7 @@ DF_VIEW_UI_FUNCTION_DEF(Output)
     if(search_query.size != 0 && next_match.line != 0)
     {
       // TODO(rjf): [ ] @de2ctrl
-#if !DE2CTRL
+#if 0
       DF_TextSlice match_line_slice = df_text_slice_from_entity(scratch.arena, entity, r1s64(next_match.line, next_match.line), entity_line_string_flags);
       String8 match_line = match_line_slice.visible_range_text;
       F32 match_advance = f_dim_from_tag_size_string(code_font, code_font_size, str8_prefix(match_line, next_match.column-1)).x;
@@ -7316,6 +7316,10 @@ DF_VIEW_UI_FUNCTION_DEF(Memory)
     viz_range_rows.max = clamp_1s64(scroll_idx_rng, viz_range_rows.max);
     viz_range_bytes.min = viz_range_rows.min*mv->num_columns;
     viz_range_bytes.max = (viz_range_rows.max+1)*mv->num_columns+1;
+    if(viz_range_bytes.min > viz_range_bytes.max)
+    {
+      Swap(U64, viz_range_bytes.min, viz_range_bytes.max);
+    }
   }
   
   //////////////////////////////
@@ -7719,7 +7723,7 @@ DF_VIEW_UI_FUNCTION_DEF(Memory)
                                                UI_BoxFlag_AllowOverflowX|
                                                UI_BoxFlag_AllowOverflowY,
                                                "scrollable_box");
-    scrollable_box->view_off.x = view->scroll_pos.x.idx + view->scroll_pos.x.off;
+    container_box->view_off.x = container_box->view_off_target.x = view->scroll_pos.x.idx + view->scroll_pos.x.off;
     scrollable_box->view_off.y = scrollable_box->view_off_target.y = floor_f32(row_height_px*mod_f32(view->scroll_pos.y.off, 1.f) + row_height_px*(view->scroll_pos.y.off < 0));
   }
   
@@ -8596,7 +8600,8 @@ DF_VIEW_UI_FUNCTION_DEF(Theme)
       color < DF_ThemeColor_COUNT;
       color = (DF_ThemeColor)(color+1))
   {
-    UI_PrefWidth(ui_em(28.5f, 1)) UI_PrefHeight(ui_children_sum(1.f)) UI_CtxMenu(color_ctx_menu_keys[color]) UI_Padding(ui_em(1.5f, 1.f))
+    UI_CtxMenu(color_ctx_menu_keys[color]) UI_Padding(ui_em(1.5f, 1.f))
+      UI_PrefWidth(ui_em(28.5f, 1)) UI_PrefHeight(ui_children_sum(1.f))
     {
       // rjf: build title
       UI_Row
@@ -8817,8 +8822,10 @@ DF_VIEW_UI_FUNCTION_DEF(Theme)
                                                       "###color_%I64x", (U64)color);
         UI_Parent(color_row)
         {
-          Vec4F32 text_rgba = rgba;
-          text_rgba.w = ClampBot(text_rgba.w, 0.2f);
+          Vec4F32 bg_color = ui_top_background_color();
+          Vec4F32 default_text_color = ui_top_text_color();
+          F32 default_fallback_factor = clamp_1f32(r1f32(0.3f, 1), dot_4f32(normalize_4f32(rgba), normalize_4f32(bg_color))) - 0.3f;
+          Vec4F32 text_rgba = mix_4f32(rgba, default_text_color, default_fallback_factor);
           UI_WidthFill UI_TextColor(text_rgba) ui_label(df_g_theme_color_display_string_table[color]);
           ui_set_next_pref_width(ui_top_pref_height());
           UI_HeightFill UI_Column UI_Padding(ui_em(0.3f, 1))
@@ -8846,6 +8853,10 @@ DF_VIEW_UI_FUNCTION_DEF(Theme)
           DF_CmdParams p = df_cmd_params_from_panel(ws, panel);
           df_push_cmd__root(&p, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_FocusPanel));
         }
+        if(color_row_sig.hovering) UI_Tooltip
+        {
+          ui_label(df_g_theme_color_display_string_table[color]);
+        }
       }
     }
   }

src/metagen/metagen_main.c

@@ -86,7 +86,7 @@ int main(int argument_count, char **arguments)
     {
       String8 file_path = n->string;
       String8 file_ext = str8_skip_last_dot(file_path);
-      if(str8_match(file_ext, str8_lit("mc"), 0))
+      if(str8_match(file_ext, str8_lit("mdesk"), 0))
       {
         String8 data = os_data_from_file_path(mg_arena, file_path);
         MD_TokenizeResult tokenize = md_tokenize_from_text(mg_arena, data);

src/mule/mule_main.cpp

@@ -371,6 +371,9 @@ type_coverage_eval_tests(void){
   stks *stks_first = &stks_test[0];
   stks *stks_ptr = stks_first + 8;
   
+  TestFunction *function = mule_get_module_function("dll_type_eval_tests");
+  function();
+  
   int x = (int)(Anonymous_D);
 }
 
@@ -1314,7 +1317,53 @@ extended_type_coverage_eval_tests(void){
 }
 
 ////////////////////////////////
-// NOTE(allen): C Type Coverage
+//~ rjf: Templated Function Eval Tests
+
+typedef struct TemplateArg TemplateArg;
+struct TemplateArg
+{
+  int x;
+  int y;
+  int z;
+  float a;
+  float b;
+  float c;
+  char *name;
+};
+
+template<typename T> static T
+templated_factorial(T t)
+{
+  T result = t;
+  if(t > 1)
+  {
+    result *= templated_factorial<T>(t-1);
+  }
+  return result;
+}
+
+template<typename T> static T
+compute_template_arg_info(T t)
+{
+  int sum = t.x + t.y + t.z;
+  int size = sizeof(t);
+  float sum_f = t.a + t.b + t.c;
+  OutputDebugStringA(t.name);
+  return t;
+}
+
+static void
+templated_function_eval_tests(void)
+{
+  int int_factorial = templated_factorial<int>(10);
+  float float_factorial = templated_factorial<float>(10);
+  TemplateArg arg = {1, 2, 3, 4.f, 5.f, 6.f, "my template arg"};
+  compute_template_arg_info(arg);
+  int x = 0;
+}
+
+////////////////////////////////
+//~ NOTE(allen): C Type Coverage
 
 extern "C"{
 #include "mule_c.h"
@@ -2340,6 +2389,8 @@ mule_main(int argc, char** argv){
   
   extended_type_coverage_eval_tests();
   
+  templated_function_eval_tests();
+  
   c_type_coverage_eval_tests();
   
   c_type_with_bitfield_usage();

src/mule/mule_module.cpp

@@ -1,38 +1,42 @@
 // Copyright (c) 2024 Epic Games Tools
 // Licensed under the MIT license (https://opensource.org/license/mit/)
 
-/*
-** Program to run in debugger organized to provide tests for
-** stepping, breakpoints, evaluation, cross-module calls.
-*/
-
-////////////////////////////////
-// NOTE(allen): Setup
-
-
 #if _WIN32
 #define export_function extern "C" __declspec(dllexport)
 #else
 #define export_function extern "C"
 #endif
 
-
-////////////////////////////////
-// NOTE(allen): TLS Eval
-
 #if _WIN32
 # define thread_var __declspec(thread)
 #else
 # define thread_var __thread
 #endif
 
+typedef struct Basics Basics;
+struct Basics
+{
+  int a;
+  int b;
+  int c;
+  int d;
+};
+
 thread_var float tls_a = 1.015625f;
 thread_var int   tls_b = -100;
 
 export_function void
-dll_tls_eval_test(void){
+dll_tls_eval_test(void)
+{
   tls_a *= 1.5f;
   tls_b *= -2;
 }
 
-
+export_function void
+dll_type_eval_tests(void)
+{
+  Basics basics1 = {1, 2, 3, 4};
+  Basics basics2 = {4, 5, 6, 7};
+  int x = 0;
+  (void)x;
+}

src/os/gfx/stub/os_gfx_stub.c

@@ -0,0 +1,223 @@
+////////////////////////////////
+//~ rjf: @os_hooks Main Initialization API (Implemented Per-OS)
+
+internal void
+os_graphical_init(void)
+{
+}
+
+////////////////////////////////
+//~ rjf: @os_hooks Clipboards (Implemented Per-OS)
+
+internal void
+os_set_clipboard_text(String8 string)
+{
+}
+
+internal String8
+os_get_clipboard_text(Arena *arena)
+{
+  return str8_zero();
+}
+
+////////////////////////////////
+//~ rjf: @os_hooks Windows (Implemented Per-OS)
+
+internal OS_Handle
+os_window_open(Vec2F32 resolution, String8 title)
+{
+  OS_Handle handle = {1};
+  return handle;
+}
+
+internal void
+os_window_close(OS_Handle window)
+{
+}
+
+internal void
+os_window_first_paint(OS_Handle window)
+{
+}
+
+internal void
+os_window_equip_repaint(OS_Handle window, OS_WindowRepaintFunctionType *repaint, void *user_data)
+{
+}
+
+internal void
+os_window_focus(OS_Handle window)
+{
+}
+
+internal B32
+os_window_is_focused(OS_Handle window)
+{
+  return 0;
+}
+
+internal B32
+os_window_is_fullscreen(OS_Handle window)
+{
+  return 0;
+}
+
+internal void
+os_window_set_fullscreen(OS_Handle window, B32 fullscreen)
+{
+}
+
+internal B32
+os_window_is_maximized(OS_Handle window)
+{
+  return 0;
+}
+
+internal void
+os_window_set_maximized(OS_Handle window, B32 maximized)
+{
+}
+
+internal void
+os_window_bring_to_front(OS_Handle window)
+{
+}
+
+internal void
+os_window_set_monitor(OS_Handle window, OS_Handle monitor)
+{
+}
+
+internal Rng2F32
+os_rect_from_window(OS_Handle window)
+{
+  Rng2F32 rect = r2f32(v2f32(0, 0), v2f32(500, 500));
+  return rect;
+}
+
+internal Rng2F32
+os_client_rect_from_window(OS_Handle window)
+{
+  Rng2F32 rect = r2f32(v2f32(0, 0), v2f32(500, 500));
+  return rect;
+}
+
+internal F32
+os_dpi_from_window(OS_Handle window)
+{
+  return 96.f;
+}
+
+////////////////////////////////
+//~ rjf: @os_hooks Monitors (Implemented Per-OS)
+
+internal OS_HandleArray
+os_push_monitors_array(Arena *arena)
+{
+  OS_HandleArray arr = {0};
+  return arr;
+}
+
+internal OS_Handle
+os_primary_monitor(void)
+{
+  OS_Handle handle = {1};
+  return handle;
+}
+
+internal OS_Handle
+os_monitor_from_window(OS_Handle window)
+{
+  OS_Handle handle = {1};
+  return handle;
+}
+
+internal String8
+os_name_from_monitor(Arena *arena, OS_Handle monitor)
+{
+  return str8_zero();
+}
+
+internal Vec2F32
+os_dim_from_monitor(OS_Handle monitor)
+{
+  Vec2F32 v = v2f32(1000, 1000);
+  return v;
+}
+
+////////////////////////////////
+//~ rjf: @os_hooks Events (Implemented Per-OS)
+
+internal void
+os_send_wakeup_event(void)
+{
+}
+
+internal OS_EventList
+os_get_events(Arena *arena, B32 wait)
+{
+  OS_EventList evts = {0};
+  return evts;
+}
+
+internal OS_EventFlags
+os_get_event_flags(void)
+{
+  OS_EventFlags f = 0;
+  return f;
+}
+
+internal B32
+os_key_is_down(OS_Key key)
+{
+  return 0;
+}
+
+internal Vec2F32
+os_mouse_from_window(OS_Handle window)
+{
+  return v2f32(0, 0);
+}
+
+////////////////////////////////
+//~ rjf: @os_hooks Cursors (Implemented Per-OS)
+
+internal void
+os_set_cursor(OS_Cursor cursor)
+{
+}
+
+////////////////////////////////
+//~ rjf: @os_hooks System Properties (Implemented Per-OS)
+
+internal F32
+os_double_click_time(void)
+{
+  return 1.f;
+}
+
+internal F32
+os_caret_blink_time(void)
+{
+  return 1.f;
+}
+
+internal F32
+os_default_refresh_rate(void)
+{
+  return 60.f;
+}
+
+internal B32
+os_granular_sleep_enabled(void)
+{
+  return 1;
+}
+
+////////////////////////////////
+//~ rjf: @os_hooks Native Messages & Panics (Implemented Per-OS)
+
+internal void
+os_graphical_message(B32 error, String8 title, String8 message)
+{
+}

src/os/gfx/stub/os_gfx_stub.h

@@ -0,0 +1,7 @@
+// Copyright (c) 2024 Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+#ifndef OS_GFX_STUB_H
+#define OS_GFX_STUB_H
+
+#endif // OS_GFX_STUB_H

src/os/os_inc.c

@@ -19,7 +19,7 @@
 # if OS_FEATURE_SOCKET
 #  include "socket/win32/os_socket_win32.c"
 # endif
-# if OS_FEATURE_GRAPHICAL
+# if OS_FEATURE_GRAPHICAL && !OS_GFX_STUB
 #  include "gfx/win32/os_gfx_win32.c"
 # endif
 #elif OS_LINUX
@@ -27,3 +27,7 @@
 #else
 # error no OS layer setup
 #endif
+
+#if OS_GFX_STUB
+#include "gfx/stub/os_gfx_stub.c"
+#endif

src/os/os_inc.h

@@ -12,6 +12,10 @@
 # define OS_FEATURE_GRAPHICAL 0
 #endif
 
+#if !defined(OS_GFX_STUB)
+# define OS_GFX_STUB 0
+#endif
+
 #include "core/os_core.h"
 
 #if OS_FEATURE_SOCKET
@@ -27,7 +31,7 @@
 # if OS_FEATURE_SOCKET
 #  include "socket/win32/os_socket_win32.h"
 # endif
-# if OS_FEATURE_GRAPHICAL
+# if OS_FEATURE_GRAPHICAL && !OS_GFX_STUB
 #  include "gfx/win32/os_gfx_win32.h"
 # endif
 #elif OS_LINUX
@@ -36,4 +40,8 @@
 # error no OS layer setup
 #endif
 
+#if OS_GFX_STUB
+#include "gfx/stub/os_gfx_stub.h"
+#endif
+
 #endif //OS_SWITCH_H

src/raddbg/raddbg.c

@@ -0,0 +1,636 @@
+// Copyright (c) 2024 Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+////////////////////////////////
+//~ rjf: Frontend Entry Points
+
+internal void
+update_and_render(OS_Handle repaint_window_handle, void *user_data)
+{
+  ProfTick(0);
+  ProfBeginFunction();
+  Temp scratch = scratch_begin(0, 0);
+  
+  //- rjf: tick cache layers
+  txt_user_clock_tick();
+  geo_user_clock_tick();
+  tex_user_clock_tick();
+  
+  //- rjf: pick target hz
+  // TODO(rjf): maximize target, given all windows and their monitors
+  F32 target_hz = os_default_refresh_rate();
+  if(frame_time_us_history_idx > 32)
+  {
+    // rjf: calculate average frame time out of the last N
+    U64 num_frames_in_history = Min(ArrayCount(frame_time_us_history), frame_time_us_history_idx);
+    U64 frame_time_history_sum_us = 0;
+    for(U64 idx = 0; idx < num_frames_in_history; idx += 1)
+    {
+      frame_time_history_sum_us += frame_time_us_history[idx];
+    }
+    U64 frame_time_history_avg_us = frame_time_history_sum_us/num_frames_in_history;
+    
+    // rjf: pick among a number of sensible targets to snap to, given how well
+    // we've been performing
+    F32 possible_alternate_hz_targets[] = {target_hz, 60.f, 120.f, 144.f, 240.f};
+    F32 best_target_hz = target_hz;
+    S64 best_target_hz_frame_time_us_diff = max_S64;
+    for(U64 idx = 0; idx < ArrayCount(possible_alternate_hz_targets); idx += 1)
+    {
+      F32 candidate = possible_alternate_hz_targets[idx];
+      if(candidate <= target_hz)
+      {
+        U64 candidate_frame_time_us = 1000000/(U64)candidate;
+        S64 frame_time_us_diff = (S64)frame_time_history_avg_us - (S64)candidate_frame_time_us;
+        if(abs_s64(frame_time_us_diff) < best_target_hz_frame_time_us_diff)
+        {
+          best_target_hz = candidate;
+          best_target_hz_frame_time_us_diff = frame_time_us_diff;
+        }
+      }
+    }
+    target_hz = best_target_hz;
+  }
+  
+  //- rjf: target Hz -> delta time
+  F32 dt = 1.f/target_hz;
+  
+  //- rjf: get events from the OS
+  OS_EventList events = {0};
+  if(os_handle_match(repaint_window_handle, os_handle_zero()))
+  {
+    events = os_get_events(scratch.arena, df_gfx_state->num_frames_requested == 0);
+  }
+  
+  //- rjf: begin measuring actual per-frame work
+  U64 begin_time_us = os_now_microseconds();
+  
+  //- rjf: bind change
+  if(!df_gfx_state->confirm_active && df_gfx_state->bind_change_active)
+  {
+    if(os_key_press(&events, os_handle_zero(), 0, OS_Key_Esc))
+    {
+      df_gfx_state->bind_change_active = 0;
+    }
+    if(os_key_press(&events, os_handle_zero(), 0, OS_Key_Delete))
+    {
+      df_unbind_spec(df_gfx_state->bind_change_cmd_spec, df_gfx_state->bind_change_binding);
+      df_gfx_state->bind_change_active = 0;
+      DF_CmdParams p = df_cmd_params_from_gfx();
+      df_push_cmd__root(&p, df_cmd_spec_from_core_cmd_kind(df_g_cfg_src_write_cmd_kind_table[DF_CfgSrc_User]));
+    }
+    for(OS_Event *event = events.first, *next = 0; event != 0; event = next)
+    {
+      if(event->kind == OS_EventKind_Press &&
+         event->key != OS_Key_Esc &&
+         event->key != OS_Key_Return &&
+         event->key != OS_Key_Backspace &&
+         event->key != OS_Key_Delete &&
+         event->key != OS_Key_LeftMouseButton &&
+         event->key != OS_Key_RightMouseButton &&
+         event->key != OS_Key_Ctrl &&
+         event->key != OS_Key_Alt &&
+         event->key != OS_Key_Shift)
+      {
+        df_gfx_state->bind_change_active = 0;
+        DF_Binding binding = zero_struct;
+        {
+          binding.key = event->key;
+          binding.flags = event->flags;
+        }
+        df_unbind_spec(df_gfx_state->bind_change_cmd_spec, df_gfx_state->bind_change_binding);
+        df_bind_spec(df_gfx_state->bind_change_cmd_spec, binding);
+        U32 codepoint = os_codepoint_from_event_flags_and_key(event->flags, event->key);
+        os_text(&events, os_handle_zero(), codepoint);
+        os_eat_event(&events, event);
+        DF_CmdParams p = df_cmd_params_from_gfx();
+        df_push_cmd__root(&p, df_cmd_spec_from_core_cmd_kind(df_g_cfg_src_write_cmd_kind_table[DF_CfgSrc_User]));
+        break;
+      }
+    }
+  }
+  
+  //- rjf: take hotkeys
+  {
+    for(OS_Event *event = events.first, *next = 0;
+        event != 0;
+        event = next)
+    {
+      next = event->next;
+      DF_Window *window = df_window_from_os_handle(event->window);
+      DF_CmdParams params = window ? df_cmd_params_from_window(window) : df_cmd_params_from_gfx();
+      if(event->kind == OS_EventKind_Press)
+      {
+        DF_Binding binding = {event->key, event->flags};
+        DF_CmdSpecList spec_candidates = df_cmd_spec_list_from_binding(scratch.arena, binding);
+        if(spec_candidates.first != 0 && !df_cmd_spec_is_nil(spec_candidates.first->spec))
+        {
+          DF_CmdSpec *spec = spec_candidates.first->spec;
+          params.cmd_spec = spec;
+          df_cmd_params_mark_slot(&params, DF_CmdParamSlot_CmdSpec);
+          U32 hit_char = os_codepoint_from_event_flags_and_key(event->flags, event->key);
+          os_eat_event(&events, event);
+          df_push_cmd__root(&params, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_CommandFastPath));
+          if(event->flags & OS_EventFlag_Alt)
+          {
+            window->menu_bar_focus_press_started = 0;
+          }
+        }
+        df_gfx_request_frame();
+      }
+      else if(event->kind == OS_EventKind_Text)
+      {
+        String32 insertion32 = str32(&event->character, 1);
+        String8 insertion8 = str8_from_32(scratch.arena, insertion32);
+        DF_CmdSpec *spec = df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_InsertText);
+        params.string = insertion8;
+        df_cmd_params_mark_slot(&params, DF_CmdParamSlot_String);
+        df_push_cmd__root(&params, spec);
+        df_gfx_request_frame();
+      }
+    }
+  }
+  
+  //- rjf: menu bar focus
+  {
+    for(OS_Event *event = events.first, *next = 0; event != 0; event = next)
+    {
+      next = event->next;
+      DF_Window *ws = df_window_from_os_handle(event->window);
+      if(ws == 0)
+      {
+        continue;
+      }
+      if(event->kind == OS_EventKind_Press && event->key == OS_Key_Alt && event->is_repeat == 0)
+      {
+        ws->menu_bar_focused_on_press = ws->menu_bar_focused;
+        ws->menu_bar_key_held = 1;
+        ws->menu_bar_focus_press_started = 1;
+      }
+      if(event->kind == OS_EventKind_Release && event->key == OS_Key_Alt && event->is_repeat == 0)
+      {
+        ws->menu_bar_key_held = 0;
+      }
+      if(ws->menu_bar_focused && event->kind == OS_EventKind_Press && event->key == OS_Key_Alt && event->is_repeat == 0)
+      {
+        os_eat_event(&events, event);
+        ws->menu_bar_focused = 0;
+      }
+      else if(ws->menu_bar_focus_press_started && !ws->menu_bar_focused && event->kind == OS_EventKind_Release && event->key == OS_Key_Alt && event->is_repeat == 0)
+      {
+        os_eat_event(&events, event);
+        ws->menu_bar_focused = !ws->menu_bar_focused_on_press;
+        ws->menu_bar_focus_press_started = 0;
+      }
+      else if(event->kind == OS_EventKind_Press && event->key == OS_Key_Esc && ws->menu_bar_focused && !ui_any_ctx_menu_is_open())
+      {
+        os_eat_event(&events, event);
+        ws->menu_bar_focused = 0;
+      }
+    }
+  }
+  
+  //- rjf: gather root-level commands
+  DF_CmdList cmds = df_core_gather_root_cmds(scratch.arena);
+  
+  //- rjf: begin frame
+  df_core_begin_frame(scratch.arena, &cmds, dt);
+  df_gfx_begin_frame(scratch.arena, &cmds);
+  
+  //- rjf: queue drop for drag/drop
+  if(df_drag_is_active())
+  {
+    for(OS_Event *event = events.first; event != 0; event = event->next)
+    {
+      if(event->kind == OS_EventKind_Release && event->key == OS_Key_LeftMouseButton)
+      {
+        df_queue_drag_drop();
+        break;
+      }
+    }
+  }
+  
+  //- rjf: auto-focus moused-over windows while dragging
+  if(df_drag_is_active())
+  {
+    B32 over_focused_window = 0;
+    {
+      for(DF_Window *window = df_gfx_state->first_window; window != 0; window = window->next)
+      {
+        Vec2F32 mouse = os_mouse_from_window(window->os);
+        Rng2F32 rect = os_client_rect_from_window(window->os);
+        if(os_window_is_focused(window->os) && contains_2f32(rect, mouse))
+        {
+          over_focused_window = 1;
+          break;
+        }
+      }
+    }
+    if(!over_focused_window)
+    {
+      for(DF_Window *window = df_gfx_state->first_window; window != 0; window = window->next)
+      {
+        Vec2F32 mouse = os_mouse_from_window(window->os);
+        Rng2F32 rect = os_client_rect_from_window(window->os);
+        if(!os_window_is_focused(window->os) && contains_2f32(rect, mouse))
+        {
+          os_window_focus(window->os);
+          break;
+        }
+      }
+    }
+  }
+  
+  //- rjf: update & render
+  {
+    d_begin_frame();
+    for(DF_Window *w = df_gfx_state->first_window; w != 0; w = w->next)
+    {
+      df_window_update_and_render(scratch.arena, &events, w, &cmds);
+    }
+  }
+  
+  //- rjf: end frontend frame, send signals, etc.
+  df_gfx_end_frame();
+  df_core_end_frame();
+  
+  //- rjf: submit rendering to all windows
+  {
+    r_begin_frame();
+    for(DF_Window *w = df_gfx_state->first_window; w != 0; w = w->next)
+    {
+      r_window_begin_frame(w->os, w->r);
+      d_submit_bucket(w->os, w->r, w->draw_bucket);
+      r_window_end_frame(w->os, w->r);
+    }
+    r_end_frame();
+  }
+  
+  //- rjf: take window closing events
+  for(OS_Event *e = events.first; e; e = e->next)
+  {
+    if(e->kind == OS_EventKind_WindowClose)
+    {
+      for(DF_Window *w = df_gfx_state->first_window; w != 0; w = w->next)
+      {
+        if(os_handle_match(w->os, e->window))
+        {
+          DF_CmdParams params = df_cmd_params_from_window(w);
+          df_push_cmd__root(&params, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_CloseWindow));
+          break;
+        }
+      }
+    }
+  }
+  
+  //- rjf: determine frame time, record into history
+  U64 end_time_us = os_now_microseconds();
+  U64 frame_time_us = end_time_us-begin_time_us;
+  frame_time_us_history[frame_time_us_history_idx%ArrayCount(frame_time_us_history)] = frame_time_us;
+  frame_time_us_history_idx += 1;
+  
+  scratch_end(scratch);
+  ProfEnd();
+}
+
+internal CTRL_WAKEUP_FUNCTION_DEF(wakeup_hook)
+{
+  os_send_wakeup_event();
+}
+
+internal void
+entry_point(int argc, char **argv)
+{
+  Temp scratch = scratch_begin(0, 0);
+#if PROFILE_TELEMETRY
+  local_persist U8 tm_data[MB(64)];
+  tmLoadLibrary(TM_RELEASE);
+  tmSetMaxThreadCount(1024);
+  tmInitialize(sizeof(tm_data), (char *)tm_data);
+#endif
+  ThreadName("[main]");
+  
+  //- rjf: initialize basic dependencies
+  os_init(argc, argv);
+  
+  //- rjf: parse command line arguments
+  CmdLine cmdln = cmd_line_from_string_list(scratch.arena, os_get_command_line_arguments());
+  ExecMode exec_mode = ExecMode_Normal;
+  String8 user_cfg_path = str8_lit("");
+  String8 profile_cfg_path = str8_lit("");
+  B32 capture = 0;
+  B32 auto_run = 0;
+  B32 auto_step = 0;
+  B32 jit_attach = 0;
+  U64 jit_pid = 0;
+  U64 jit_code = 0;
+  U64 jit_addr = 0;
+  {
+    if(cmd_line_has_flag(&cmdln, str8_lit("ipc")))
+    {
+      exec_mode = ExecMode_IPCSender;
+    }
+    else if(cmd_line_has_flag(&cmdln, str8_lit("convert")))
+    {
+      exec_mode = ExecMode_Converter;
+    }
+    else if(cmd_line_has_flag(&cmdln, str8_lit("?")) ||
+            cmd_line_has_flag(&cmdln, str8_lit("help")))
+    {
+      exec_mode = ExecMode_Help;
+    }
+    user_cfg_path = cmd_line_string(&cmdln, str8_lit("user"));
+    profile_cfg_path = cmd_line_string(&cmdln, str8_lit("profile"));
+    capture = cmd_line_has_flag(&cmdln, str8_lit("capture"));
+    auto_run = cmd_line_has_flag(&cmdln, str8_lit("auto_run"));
+    auto_step = cmd_line_has_flag(&cmdln, str8_lit("auto_step"));
+    String8 jit_pid_string = {0};
+    String8 jit_code_string = {0};
+    String8 jit_addr_string = {0};
+    jit_pid_string = cmd_line_string(&cmdln, str8_lit("jit_pid"));
+    jit_code_string = cmd_line_string(&cmdln, str8_lit("jit_code"));
+    jit_addr_string = cmd_line_string(&cmdln, str8_lit("jit_addr"));
+    try_u64_from_str8_c_rules(jit_pid_string, &jit_pid);
+    try_u64_from_str8_c_rules(jit_code_string, &jit_code);
+    try_u64_from_str8_c_rules(jit_addr_string, &jit_addr);
+    jit_attach = (jit_addr != 0);
+  }
+  
+  //- rjf: auto-start capture
+  if(capture)
+  {
+    ProfBeginCapture("raddbg");
+  }
+  
+  //- rjf: set default user/profile paths
+  {
+    String8 user_program_data_path = os_string_from_system_path(scratch.arena, OS_SystemPath_UserProgramData);
+    String8 user_data_folder = push_str8f(scratch.arena, "%S/%S", user_program_data_path, str8_lit("raddbg"));
+    os_make_directory(user_data_folder);
+    if(user_cfg_path.size == 0)
+    {
+      user_cfg_path = push_str8f(scratch.arena, "%S/default.raddbg_user", user_data_folder);
+    }
+    if(profile_cfg_path.size == 0)
+    {
+      profile_cfg_path = push_str8f(scratch.arena, "%S/default.raddbg_profile", user_data_folder);
+    }
+  }
+  
+  //- rjf: dispatch to top-level codepath based on execution mode
+  switch(exec_mode)
+  {
+    //- rjf: normal execution
+    default:
+    case ExecMode_Normal:
+    {
+      //- rjf: set up shared memory for ipc
+      OS_Handle ipc_shared_memory = os_shared_memory_alloc(IPC_SHARED_MEMORY_BUFFER_SIZE, ipc_shared_memory_name);
+      void *ipc_shared_memory_base = os_shared_memory_view_open(ipc_shared_memory, r1u64(0, IPC_SHARED_MEMORY_BUFFER_SIZE));
+      OS_Handle ipc_semaphore = os_semaphore_alloc(1, 1, ipc_semaphore_name);
+      IPCInfo *ipc_info = (IPCInfo *)ipc_shared_memory_base;
+      ipc_info->msg_size = 0;
+      
+      //- rjf: initialize stuff we depend on
+      {
+        hs_init();
+        txt_init();
+        dbgi_init();
+        txti_init();
+        demon_init();
+        ctrl_init(wakeup_hook);
+        dasm_init();
+        os_graphical_init();
+        fp_init();
+        r_init(&cmdln);
+        tex_init();
+        geo_init();
+        f_init();
+        DF_StateDeltaHistory *hist = df_state_delta_history_alloc();
+        df_core_init(user_cfg_path, profile_cfg_path, hist);
+        df_gfx_init(update_and_render, hist);
+        os_set_cursor(OS_Cursor_Pointer);
+      }
+      
+      //- rjf: setup initial target from command line args
+      {
+        String8List args = cmdln.inputs;
+        if(args.node_count > 0 && args.first->string.size != 0)
+        {
+          Temp scratch = scratch_begin(0, 0);
+          DF_Entity *target = df_entity_alloc(0, df_entity_root(), DF_EntityKind_Target);
+          df_entity_equip_b32(target, 1);
+          df_entity_equip_cfg_src(target, DF_CfgSrc_CommandLine);
+          String8List passthrough_args_list = {0};
+          for(String8Node *n = args.first->next; n != 0; n = n->next)
+          {
+            str8_list_push(scratch.arena, &passthrough_args_list, n->string);
+          }
+          
+          // rjf: equip exe
+          if(args.first->string.size != 0)
+          {
+            DF_Entity *exe = df_entity_alloc(0, target, DF_EntityKind_Executable);
+            df_entity_equip_name(0, exe, args.first->string);
+          }
+          
+          // rjf: equip path
+          String8 path_part_of_arg = str8_chop_last_slash(args.first->string);
+          if(path_part_of_arg.size != 0)
+          {
+            String8 path = push_str8f(scratch.arena, "%S/", path_part_of_arg);
+            DF_Entity *execution_path = df_entity_alloc(0, target, DF_EntityKind_ExecutionPath);
+            df_entity_equip_name(0, execution_path, path);
+          }
+          
+          // rjf: equip args
+          StringJoin join = {str8_lit(""), str8_lit(" "), str8_lit("")};
+          String8 args_str = str8_list_join(scratch.arena, &passthrough_args_list, &join);
+          if(args_str.size != 0)
+          {
+            DF_Entity *args_entity = df_entity_alloc(0, target, DF_EntityKind_Arguments);
+            df_entity_equip_name(0, args_entity, args_str);
+          }
+          scratch_end(scratch);
+        }
+      }
+      
+      //- rjf: main application loop
+      {
+        for(;;)
+        {
+          //- rjf: get IPC messages & dispatch ui commands from them
+          {
+            if(os_semaphore_take(ipc_semaphore, max_U64))
+            {
+              if(ipc_info->msg_size != 0)
+              {
+                U8 *buffer = (U8 *)(ipc_info+1);
+                U64 msg_size = ipc_info->msg_size;
+                String8 cmd_string = str8(buffer, msg_size);
+                ipc_info->msg_size = 0;
+                DF_Window *dst_window = df_gfx_state->first_window;
+                for(DF_Window *window = dst_window; window != 0; window = window->next)
+                {
+                  if(os_window_is_focused(window->os))
+                  {
+                    dst_window = window;
+                    break;
+                  }
+                }
+                if(dst_window != 0)
+                {
+                  Temp scratch = scratch_begin(0, 0);
+                  String8 cmd_spec_string = df_cmd_name_part_from_string(cmd_string);
+                  DF_CmdSpec *cmd_spec = df_cmd_spec_from_string(cmd_spec_string);
+                  if(!df_cmd_spec_is_nil(cmd_spec))
+                  {
+                    DF_CmdParams params = df_cmd_params_from_gfx();
+                    DF_CtrlCtx ctrl_ctx = df_ctrl_ctx_from_window(dst_window);
+                    String8 error = df_cmd_params_apply_spec_query(scratch.arena, &ctrl_ctx, &params, cmd_spec, df_cmd_arg_part_from_string(cmd_string));
+                    if(error.size == 0)
+                    {
+                      df_push_cmd__root(&params, cmd_spec);
+                    }
+                    else
+                    {
+                      DF_CmdParams params = df_cmd_params_from_window(dst_window);
+                      params.string = error;
+                      df_cmd_params_mark_slot(&params, DF_CmdParamSlot_String);
+                      df_push_cmd__root(&params, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_Error));
+                    }
+                  }
+                  scratch_end(scratch);
+                }
+              }
+              os_semaphore_drop(ipc_semaphore);
+            }
+          }
+          
+          //- rjf: update & render frame
+          OS_Handle repaint_window = {0};
+          update_and_render(repaint_window, 0);
+          
+          //- rjf: auto run
+          if(auto_run)
+          {
+            auto_run = 0;
+            DF_CmdParams params = df_cmd_params_from_gfx();
+            df_push_cmd__root(&params, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_LaunchAndRun));
+          }
+          
+          //- rjf: auto step
+          if(auto_step)
+          {
+            auto_step = 0;
+            DF_CmdParams params = df_cmd_params_from_gfx();
+            df_push_cmd__root(&params, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_StepInto));
+          }
+          
+          //- rjf: jit attach
+          if(jit_attach)
+          {
+            jit_attach = 0;
+            DF_CmdParams params = df_cmd_params_from_gfx();
+            df_cmd_params_mark_slot(&params, DF_CmdParamSlot_ID);
+            params.id = jit_pid;
+            df_push_cmd__root(&params, df_cmd_spec_from_core_cmd_kind(DF_CoreCmdKind_Attach));
+          }
+          
+          //- rjf: quit if no windows are left
+          if(df_gfx_state->first_window == 0)
+          {
+            break;
+          }
+        }
+      }
+      
+    }break;
+    
+    //- rjf: inter-process communication message sender
+    case ExecMode_IPCSender:
+    {
+      Temp scratch = scratch_begin(0, 0);
+      
+      //- rjf: grab ipc shared memory
+      OS_Handle ipc_shared_memory = os_shared_memory_open(ipc_shared_memory_name);
+      void *ipc_shared_memory_base = os_shared_memory_view_open(ipc_shared_memory, r1u64(0, MB(16)));
+      if(ipc_shared_memory_base != 0)
+      {
+        OS_Handle ipc_semaphore = os_semaphore_open(ipc_semaphore_name);
+        IPCInfo *ipc_info = (IPCInfo *)ipc_shared_memory_base;
+        if(os_semaphore_take(ipc_semaphore, os_now_microseconds() + Million(6)))
+        {
+          U8 *buffer = (U8 *)(ipc_info+1);
+          U64 buffer_max = IPC_SHARED_MEMORY_BUFFER_SIZE - sizeof(IPCInfo);
+          StringJoin join = {str8_lit(""), str8_lit(" "), str8_lit("")};
+          String8 msg = str8_list_join(scratch.arena, &cmdln.inputs, &join);
+          ipc_info->msg_size = Min(buffer_max, msg.size);
+          MemoryCopy(buffer, msg.str, ipc_info->msg_size);
+          os_semaphore_drop(ipc_semaphore);
+        }
+      }
+      
+      scratch_end(scratch);
+    }break;
+    
+    //- rjf: built-in pdb/dwarf -> raddbg converter mode
+    case ExecMode_Converter:
+    {
+      Temp scratch = scratch_begin(0, 0);
+      
+      //- rjf: parse arguments
+      PDBCONV_Params *params = pdb_convert_params_from_cmd_line(scratch.arena, &cmdln);
+      
+      //- rjf: open output file
+      String8 output_name = push_str8_copy(scratch.arena, params->output_name);
+      OS_Handle out_file = os_file_open(OS_AccessFlag_Read|OS_AccessFlag_Write, output_name);
+      B32 out_file_is_good = !os_handle_match(out_file, os_handle_zero());
+      
+      //- rjf: convert
+      PDBCONV_Out *out = 0;
+      if(out_file_is_good)
+      {
+        out = pdbconv_convert(scratch.arena, params);
+      }
+      
+      //- rjf: bake file
+      if(out != 0 && params->output_name.size > 0)
+      {
+        String8List baked = {0};
+        cons_bake_file(scratch.arena, out->root, &baked);
+        U64 off = 0;
+        for(String8Node *node = baked.first; node != 0; node = node->next)
+        {
+          os_file_write(out_file, r1u64(off, off+node->string.size), node->string.str);
+          off += node->string.size;
+        }
+      }
+      
+      //- rjf: close output file
+      os_file_close(out_file);
+      
+      scratch_end(scratch);
+    }break;
+    
+    //- rjf: help message box
+    case ExecMode_Help:
+    {
+      os_graphical_message(0,
+                           str8_lit("The RAD Debugger - Help"),
+                           str8_lit("The following options may be used when starting the RAD Debugger from the command line:\n\n"
+                                    "--user:<path>\n"
+                                    "Use to specify the location of a user file which should be used. User files are used to store settings for users, including window and panel setups, path mapping, and visual settings. If this file does not exist, it will be created as necessary. This file will be autosaved as user-related changes are made.\n\n"
+                                    "--profile:<path>\n"
+                                    "Use to specify the location of a profile file which should be used. Profile files are used to store settings for users and projects. If this file does not exist, it will be created as necessary. This file will be autosaved as profile-related changes are made.\n\n"
+                                    "--auto_step\n"
+                                    "This will step into all targets after the debugger initially starts.\n\n"
+                                    "--auto_run\n"
+                                    "This will run all targets after the debugger initially starts.\n\n"
+                                    "--ipc <command>\n"
+                                    "This will launch the debugger in the non-graphical IPC mode, which is used to communicate with another running instance of the debugger. The debugger instance will launch, send the specified command, then immediately terminate. This may be used by editors or other programs to control the debugger.\n\n"));
+    }break;
+  }
+  
+  scratch_end(scratch);
+}

src/raddbg/raddbg.h

@@ -0,0 +1,466 @@
+// Copyright (c) 2024 Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+////////////////////////////////
+//~ rjf: Hot, High Priority Tasks (Complete Unusability, Crashes, Fire-Worthy)
+//
+// [ ] ** Thread/process control bullet-proofing, including solo-step mode
+// [ ] ** ASAN targets
+// [ ] ** while typing, "Alt" Windows menu things should not happen
+//
+// [ ] ** I can't seem to get the .raddbg files to update consistently, or
+//     something. I can't seem to reproduce it reliably, but sometimes when I
+//     rebuild, for example, it seems to keep using the old PDB data
+//     effectively - like it doesn't think it needs to update the raddbg file,
+//     or something? But if I manually delete the raddbg file and relaunch,
+//     then it will have the new debug info. It would be nice if there was
+//     some kind of way to interrogate this in the debugger so I can send a
+//     more constructive report, like some way to get a hash of the PDB that
+//     is thinks it has converted to the RAD format, and then a way I can hash
+//     the PDB on the drive, or something, so I can figure out if they are
+//     mismatching for sure?
+//
+// [ ] ** In solo-stepping mode, if I step over something like CreateFileA, it
+//     pseudo-hangs the debugger. I can't seem to do anything else, including
+//     "Kill All". I have to close the debugger and restart it, AFAICT?
+//
+// [ ] ** I tried to debug a console program, and "step into" didn't seem to
+//     work. Instead, it just started running the program, but the program
+//     seemed to hang, and then the debugger pseudo-hung with a continual
+//     progress bar in the disassembly window. I had to close and restart. Is
+//     console app debugging not working yet, perhaps?
+//
+//  [ ] Setting the code_font/main_font values to a font name doesn't work.
+//      Should probably make note that you have to set it to a path to a TTF,
+//      since that's not normally how Windows fonts work.
+
+// [ ] ** Converter performance & heuristics for asynchronously doing it early
+//
+// [ ] disasm animation & go-to-address
+//
+// [ ] visualize mismatched source code and debug info
+// [ ] visualize remapped files (via path map)
+
+////////////////////////////////
+//~ rjf: Hot, Medium Priority Tasks (Low-Hanging-Fruit Features, UI Jank, Cleanup)
+//
+//  [ ] I was a little confused about what a profile file was. I understood
+//      what the user file was, but the profile file sounded like it should
+//      perhaps be per-project, yet it sounded like it was meant to be somewhat
+//      global? I don't have any feedback here because it probably will make
+//      sense once I use the debugger more, but I just thought I'd make a note
+//      to say that I was confused about it after reading the manual, so
+//      perhaps you could elaborate a little more on it in there.
+//
+// [ ] ** "Find Name" may not be working as advertised. In the description, it
+//     says you can jump to a file, but if I type in the complete filename of
+//     a file in the project and hit return, it just turns red and says it
+//     couldn't find it. This happens even if the file is already open in a
+//     tab.
+//   [ ] "Find Name" would be a lot more useful if you could type partial
+//       things, and it displayed a list, more like what happens in a
+//       traditional text editor. Typing the entire name of a function to jump
+//       to it is too laborious.
+//
+// [ ] Right-clicking on a thread in the Scheduler window pops up a context
+//     menu, but you can't actually see it because the tooltip for the thread
+//     draws on top of it, so you can't see the menu.
+//
+//  [ ] In a "hover watch" (where you hover over a variable and it shows a pop-
+//      up watch window), if you expand an item near the bottom of the listing,
+//      it will be clipped to the bottom of the listing instead of showing the
+//      actual items (ie., it doesn't resize the listing based on what's
+//      actually visible)
+//
+//  [ ] ** Function breakpoints should show up in the source listing. Without
+//      them being visible, it is confusing when you run and you stop there,
+//      because you're like "wait why did it stop" and then you later remember
+//      that's because there was a function breakpoint there.
+//
+//  [ ] ** One very nice feature of RemedyBG that I use all the time is the
+//      ability to put "$err, hr" into the watch window, which will just show
+//      the value of GetLastError() as a string. This is super useful for
+//      debugging, so you don't have to litter your own code with it.
+//
+//  [ ] Tooltip Coverage:
+//   [ ] lock icon
+//   [ ] "rotation arrow" icon next to executables
+//
+//  [ ] Using the word "symbol" in "Code (Symbol)" seems like a bad idea, since
+//      you're referring to non-identifier characters, but in a debugger
+//      "symbol" usually means something defined in the debug information.
+//
+//  [ ] I LOVE ALT-W to add watch under cursor, but I would prefer to have it
+//      add what's under the MOUSE cursor instead of the keyboard cursor. Can
+//      we get a command for that so I can bind ALT-W to that instead?
+//
+//  [ ] For theme editing, when you hove the mouse over a theme color entry and
+//      it highlights that entry, it might help to temporarily change that
+//      color to white (or the inverse of the background color, or whatever) so
+//      that the user can see what things on the screen use that theme color.
+//
+//  [ ] I couldn't figure out how to affect the "dim" color in constants that
+//      have alternating bright/dim letters to show sections of a number. Is
+//      this in the theme colors somewhere?
+//
+//  [ ] For breakpoint-on-function, it would be great if it showed a list of
+//      (partial) matches as you type, so you can stop typing once it gets the
+//      right function instead of having to type the entire function name.
+//
+//  [ ] Hovering over a source tab that is clipped should probably display the
+//      full thing that was in that tab (like the whole filename, etc.). Right
+//      now, hovering does nothing AFAICT.
+//
+//  [ ] ** I couldn't figure out how to really view threads in the debugger.
+//      The only place I found a thread list was in "The Scheduler", but it
+//      only lists threads by ID, which is hard to use. I can hover over them
+//      to get the stack, which helps, but it would be much nicer if the top
+//      function was displayed in the window by default next to the thread.
+//  [ ] ** It would be nice if thread listings displayed the name of the
+//      thread, instead of just the ID.
+//
+//  [ ] ** Scrollbars are barely visible for me, for some reason. I could not
+//      find anything in the theme that would fill them with a solid, bright
+//      color. Instead they are just a thin outline and the same color as the
+//      scroll bar background.
+//
+//  [ ] Dragging a window tab (like Locals or Registers or whatnot) and
+//      canceling with ESC should revert the window tab to where it was.
+//      Currently, it leaves the window tab reordered if you dragged over its
+//      window and shuffled its position.
+//
+//  [ ] Many of the UI elements, like the menus, would like better if they had
+//      a little bit of margin. Having the text right next to the edges, and
+//      with no line spacing, makes it harder to read things quickly.
+//
+//  [ ] Menus take too long to show up. I would prefer it if they were instant.
+//      The animation doesn't really provide any useful cues, since I know
+//      where the menu came from.
+//
+//  [ ] Theme window should include font scaling. I was able to find the
+//      command for increasing the font scale, but I imagine most people
+//      wouldn't think to look there.
+//  [ ] I had to go into the user file to change the font. That should probably
+//      be in the theme window?
+//
+//  [ ] The way the "commands" view worked was idiosyncratic. All the other
+//      views stay up, but that one goes away whenever I select a command for
+//      some reason.
+//   [ ] Also, I could not move the commands window anywhere AFAICT. It seems
+//       to just pop up over whatever window I currently have selected. This
+//       would make sense for a hotkey (which I assume is the way it was
+//       designed), but it seems like it should be permanent if you can select
+//       it from the View menu.
+//  [ ] If the command window is not wide enough, you cannot read the
+//      description of a command because it doesn't word-wrap, nor can you
+//      hover over it to get the description in a tooltip (AFAICT).
+//
+//  [ ] It'd be nice to have a "goto byte" option for source views, for jumping
+//      to error messages that are byte-based instead of line-based.
+//
+//  [ ] Pressing the left mouse button on the menu bar and dragging does not
+//      move through the menus as expected - instead, it opens the one you
+//      clicked down on, then does nothing until you release, at which point it
+//      opens the menu you released on.
+//  [ ] Similarly, pressing the left mouse button on a menu and dragging to an
+//      item, then releasing, does not trigger that item as expected. Instead,
+//      it is a nop, and it waits for you to click again on the item.
+//
+//  [ ] Working with panels felt cumbersome. I couldn't figure out any way to
+//      quickly arrange the display without manually selecting "split panel"
+//      and "close panel" and stuff from the menu, which took a long time.
+//   - @polish @feature ui for dragging tab -> bundling panel split options
+//
+//  [ ] I found the "context menu" convention to be confusing. For example, if
+//      I left-click on a tab, it selects the tab. If I right-click on a tab,
+//      it opens the context menu. However, if I left-click on a module, it
+//      opens the context window. It seems like maybe menus should be right,
+//      and left should do the default action, more consistently?
+//
+//  [ ] Hovering over disassembly highlights blocks of instructions, which I
+//      assume correspond to source lines. But perhaps it should also highlight
+//      the source lines? The inverse hover works (you hover over source, and
+//      it highlights ASM), but ASM->source doesn't.
+//
+//  [ ] It wasn't clear to me how you save a user or profile file. I can see
+//      how to load them, but not how you save them. Obviously I can just copy
+//      the files myself in the shell, but it seemed weird that there was no
+//      "save" option in the menus.
+//
+// [ ] @cleanup @feature double & triple click select in source views
+// [ ] @feature hovering truncated text in UI for some amount of time -> show
+//     tooltip with full text
+// [ ] @feature disasm keyboard navigation & copy/paste
+// [ ] @feature debug info overrides (both path-based AND module-based)
+// [ ] configure tab size
+// [ ] run-to-line needs to work if no processes are running
+//     - place temp bp, attach "die on hit" flag or something like that?
+// [ ] auto-scroll output window
+//
+// [ ] C++ single & multi inheritance member visualization in watch window
+
+////////////////////////////////
+//~ rjf: Hot, Low Priority Tasks (UI Opinions, Less-Serious Jank, Preferences, Cleanup)
+//
+//  [ ] ** In the call stack, I would like to be able to click quickly and move
+//      around the stack. Right now, you can do that with the first and third
+//      column, but the second column drops down a context menu. Since right
+//      click is already for context menus, can it not just be that double-
+//      clicking any column jumps to that stack frame?
+//
+//  [ ] ** I find it really hard to read the code with the heavyweight lines
+//      running through it for breakpoints and stepping and things. Is there a
+//      way to turn the lines off? AFAICT they are based on thread and
+//      breakpoint color, so you can't really control the line drawing? I might
+//      be fine with them, but they would have to be much more light (like
+//      alpha 0.1 or something)
+//
+//  [ ] It's confusing that ENTER is the way you expand and collapse things in
+//      the watch window, but then also how you edit them if they are not
+//      expandable? It seems like this should be consistent (one way to edit,
+//      one way to expand/collapse, that are distinct)
+//
+//  [ ] I didn't understand the terminology "Equip With Color". Does that just
+//      mean specify the color used to display it? Is "Apply Color" perhaps a
+//      bit more user-friendly?
+//
+//  [ ] The cursor feels a bit too huge vertically.
+//
+//  [ ] The hex format for color values in the config file was a real
+//      mindbender. It's prefixed with "0x", so I was assuming it was either
+//      Windows Big Endian (0xAARRGGBB) or Mac Little Endian (0xAABBGGRR). To
+//      my surprise, it was neither - it was actually web format (RRGGBBAA),
+//      which I was not expecting because that is normally written with a
+//      number sign (#AARRGGBB) not an 0x.
+//
+//  [ ] Clicking on either side of a scroll bar is idiosyncratic. Normally,
+//      that is "page up" / "page down", but here it is "smooth scroll upward"
+//      / "smooth scroll downward" for some reason?
+//
+//  [ ] Hitting ESC during a color picker drag should abort the color picking
+//      and revert to the previous color. Currently, it just accepts the last
+//      drag result as the new color.
+//
+//  [ ] It was not clear to me why a small "tab picker" appeared when I got to
+//      a certain number of tabs. It seemed to appear even if the tabs were
+//      quite large, and there was no need to a drop-down menu to pick them. It
+//      feels like either it should always be there, or it should only show up
+//      if at least one tab gets small enough to have its name cut off?
+//
+//  [ ]  can it ignore stepping into _RTC_CheckStackVars generated functions?
+//  [ ]  mouse back button should make view to go back after I double clicked
+//       on function to open it
+//  [ ]  middle mouse button on tab should close it
+//  [ ]  pressing random keyboard keys in source code advances text cursor like
+//       you were inputting text, very strange.
+//  [ ]  Alt+8 to switch to disassembly would be nice (regardless on which
+//       panel was previous, don't want to use ctrl+, multiple times)
+//       Alt+8 for disasm and Alt+6 for memory view are shortcuts I often use
+//       in VS
+//  [ ]  what's up with decimal number coloring where every group of 3 are in
+//       different color? can I turn it off? And why sometimes digits in number
+//       start with brighter color, but sometimes with darker - shouldn't it
+//       always have the same color ordering?
+//  [ ]  it would be nice to have "show in explorer" for right click on source
+//       file tab (opens explorer & selects the file)
+//  [ ]  it would be nice if Alt+o in source file would switch between .h and
+//       .c/cpp file (just look for same name in same folder)
+//  [ ]  in watch window when I enter some new expression and then click mouse
+//       away from cell, then it should behave the same as if I pressed enter.
+//       Currently it does the same as if I have pressed esc and I have lost my
+//       expression
+//  [ ]  default font size is too small for me - not only source code, but
+//       menus/tab/watch names (which don't resize). Maybe you could query
+//       Windows for initial font size?
+//  [ ]  zooming behaves very strangely - sometimes it zooms source code,
+//       sometimes both source code and menu/tab/watch font size, sometimes
+//       just menu/tab/watch font size not source size.
+//  [ ]  icon fonts glyphs sometimes disappear for specific font size, but they
+//       reappear if you go +1 higher or -1 lower. Mostly red triangle in watch
+//       values for "unknown identifier". But also yellow arrow in call stack
+//       disappears if font size gets too large.
+//  [ ]  undo close tab would be nice. If not for everything, then at least
+//       just for source files
+
+////////////////////////////////
+//~ rjf: Hot, Feature Tasks (Not really "low priority" but less urgent than fixes)
+//
+// [ ] For the Scheduler window, it would be nice if you could dim or
+//     folderize threads that are not your threads - eg., if a thread doesn't
+//     have any resolved stack pointers in your executable code, then you can
+//     ignore it when you are focusing on your own code. I don't know what the
+//     best way to detect this is, other than by walking the call stack... one
+//     way might be to just have a way to separate threads you've named from
+//     threads you haven't? Or, there could even be a debugger-specific API
+//     that you use to tag them. Just some way that would make it easier to
+//     focus on your own threads.
+//
+// [ ] autocomplete lister should respect position in edited expression,
+//     tabbing through should autocomplete but not exit, etc.
+//
+// [ ] Fancy View Rules
+//  [ ] table column boundaries should be checked against *AFTER* table
+//      contents, not before
+//  [ ] `text[:lang]` - interpret memory as text, in lang `lang`
+//  [ ] `disasm:arch` - interpret memory as machine code for isa `arch`
+//  [ ] `memory` - view memory in usual memory hex-editor view
+//  NOTE(rjf): When the visualization system is solid, layers like dasm, txti,
+//  and so on can be dispensed with, as things like the source view, disasm
+//  view, or memory view will simply be specializations of the general purpose
+//  viz system.
+//  [ ] view rule hook for standalone visualization ui, granted its own
+//      tab
+//
+// [ ] search-in-all-files
+//
+// [ ] Memory View
+//  [ ] memory view mutation controls
+//  [ ] memory view user-made annotations
+//
+// [ ] undo/redo
+// [ ] proper "go back" + "go forward" history navigations
+//
+// [ ] globally disable/configure default view rule-like things (string
+//     viz for u8s in particular)
+// [ ] globally disable/configure bp/ip lines in source view
+//
+// [ ] @feature processor/data breakpoints
+// [ ] @feature automatically snap to search matches when searching source files
+// [ ] @feature entity views: filtering & reordering
+
+////////////////////////////////
+//~ rjf: Cold, Clean-up Tasks That Probably Only Ryan Notices
+// (E.G. Because They Are Code-Related Or Because Nobody Cares)
+//
+// [ ] @bug view-snapping in scroll-lists, accounting for mapping between
+//     visual positions & logical positions (variably sized rows in watch,
+//     table headers, etc.)
+// [ ] @bug selected frame should be keyed by run_idx or something so that it
+//     can gracefully reset to the top frame when running
+// [ ] @cleanup collapse DF_CfgNodes into just being MD trees, find another way
+//     to encode config source - don't need it at every node
+// [ ] @cleanup straighten out index/number space & types & terminology for
+//     scroll lists
+// [ ] @cleanup simplification pass over eval visualization pipeline & types,
+//     including view rule hooks
+// [ ] @cleanup naming pass over eval visualization part of the frontend,
+//     "blocks" vs. "canvas" vs. "expansion" - etc.
+// [ ] @cleanup central worker thread pool - eliminate per-layer thread pools
+
+////////////////////////////////
+//~ rjf: Cold, Unsorted Notes (Deferred Until Existing Lists Mostly Exhausted)
+//
+// [ ] @feature types -> auto view rules (don't statefully fill view rules
+//     given types, just query if no other view rule is present, & autofill
+//     when editing)
+// [ ] @feature eval system -> somehow evaluate breakpoint hit counts? "meta"
+//     variables?
+// [ ] @feature watch window labels
+// [ ] @feature scheduler -> thread grid view?
+//
+// [ ] @feature disasm view improvement features
+//  [ ] interleaved src/dasm view
+//  [ ] visualize jump destinations in disasm
+//
+// [ ] @feature eval ui improvement features
+//  [ ] serializing eval view maps
+//  [ ] view rule editors in hover-eval
+//  [ ] view rule hook coverage
+//   [ ] `each:(expr addition)` - apply some additional expression to all
+//        elements in an array/linked list would be useful to look at only a
+//        subset of an array of complex structs
+//   [ ] `slider:(min max)` view rule
+//   [ ] `v2f32` view rule
+//   [ ] `v3` view rule
+//   [ ] `quat` view rule
+//   [ ] `matrix` view rule
+//   [ ] `audio` waveform view rule
+//  [ ] smart scopes - expression operators for "grab me the first type X"
+//  [ ] "pinning" watch expressions, to attach it to a particular ctrl_ctx
+//
+// [ ] @feature header file for target -> debugger communication; printf, log,
+//     etc.
+// [ ] @feature just-in-time debugging
+// [ ] @feature step-out-of-loop
+//
+//-[ ] long-term future notes from martins
+//  [ ] core dump saving/loading
+//  [ ] parallel call stacks view
+//  [ ] parallel watch view
+//  [ ] mixed native/interpreted/jit debugging
+//      - it seems python has a top-level linked list of interpreter states,
+//        which should allow the debugger to map native callstacks to python
+//        code
+//
+// [ ] fancy string runs can include "weakness" information for text truncation
+//     ... can prioritize certain parts of strings to be truncated before
+//     others. would be good for e.g. the middle of a path
+// [ ] ui code maintenance, simplification, design, & robustness pass
+//  [ ] page-up & page-down correct handling in keyboard nav
+//  [ ] collapse context menus & command lister into same codepaths. filter by
+//      context. parameterize by context.
+//  [ ] collapse text cells & command lister & etc. into same codepath (?)
+//  [ ] nested context menus
+//  [ ] unified top-level cursor/typing/lister helper
+//  [ ] font selection lister
+// [ ] font cache eviction (both for font tags, closing fp handles, and
+//     rasterizations)
+// [ ] frontend speedup opportunities
+//  [ ] tables in UI -> currently building per-row, could probably cut down on
+//      # of boxes and # of draws by doing per-column in some cases?
+//  [ ] font cache layer -> can probably cache (string*font*size) -> (run) too
+//      (not just rasterization)... would save a *lot*, there is a ton of work
+//      just in looking up & stitching stuff repeatedly
+//  [ ] convert UI layout pass to not be naive recursive version
+//  [ ] (big change) parallelize window ui build codepaths per-panel
+
+#ifndef RADDBG_H
+#define RADDBG_H
+
+////////////////////////////////
+//~ rjf: Build Settings
+
+#define RADDBG_VERSION_MAJOR 0
+#define RADDBG_VERSION_MINOR 9
+#define RADDBG_VERSION_PATCH 3
+#define RADDBG_VERSION_STRING_LITERAL Stringify(RADDBG_VERSION_MAJOR) "." Stringify(RADDBG_VERSION_MINOR) "." Stringify(RADDBG_VERSION_PATCH)
+#if defined(NDEBUG)
+# define RADDBG_TITLE_STRING_LITERAL "The RAD Debugger (" RADDBG_VERSION_STRING_LITERAL " ALPHA) - " __DATE__ ""
+#else
+# define RADDBG_TITLE_STRING_LITERAL "The RAD Debugger (" RADDBG_VERSION_STRING_LITERAL " ALPHA) - " __DATE__ " [Debug]"
+#endif
+
+////////////////////////////////
+//~ rjf: Top-Level Execution Types
+
+typedef enum ExecMode
+{
+  ExecMode_Normal,
+  ExecMode_IPCSender,
+  ExecMode_Converter,
+  ExecMode_Help,
+}
+ExecMode;
+
+typedef struct IPCInfo IPCInfo;
+struct IPCInfo
+{
+  U64 msg_size;
+};
+
+////////////////////////////////
+//~ rjf: Globals
+
+#define IPC_SHARED_MEMORY_BUFFER_SIZE MB(16)
+StaticAssert(IPC_SHARED_MEMORY_BUFFER_SIZE > sizeof(IPCInfo), ipc_buffer_size_requirement);
+read_only global String8 ipc_shared_memory_name = str8_lit_comp("_raddbg_ipc_shared_memory_");
+read_only global String8 ipc_semaphore_name = str8_lit_comp("_raddbg_ipc_semaphore_");
+global U64 frame_time_us_history[64] = {0};
+global U64 frame_time_us_history_idx = 0;
+
+////////////////////////////////
+//~ rjf: Frontend Entry Points
+
+internal void update_and_render(OS_Handle repaint_window_handle, void *user_data);
+
+#endif // RADDBG_H

src/raddbg/raddbg_main.cpp

@@ -0,0 +1,176 @@
+////////////////////////////////
+//~ rjf: Includes
+
+//- rjf: [h]
+#include "base/base_inc.h"
+#include "os/os_inc.h"
+#include "mdesk/mdesk.h"
+#include "hash_store/hash_store.h"
+#include "text_cache/text_cache.h"
+#include "path/path.h"
+#include "txti/txti.h"
+#include "coff/coff.h"
+#include "pe/pe.h"
+#include "raddbg_format/raddbg_format.h"
+#include "raddbg_format/raddbg_format_parse.h"
+#include "raddbg_cons/raddbg_cons.h"
+#include "raddbg_convert/pdb/raddbg_coff.h"
+#include "raddbg_convert/pdb/raddbg_codeview.h"
+#include "raddbg_convert/pdb/raddbg_msf.h"
+#include "raddbg_convert/pdb/raddbg_pdb.h"
+#include "raddbg_convert/pdb/raddbg_coff_conversion.h"
+#include "raddbg_convert/pdb/raddbg_codeview_conversion.h"
+#include "raddbg_convert/pdb/raddbg_from_pdb.h"
+#include "raddbg_convert/pdb/raddbg_codeview_stringize.h"
+#include "raddbg_convert/pdb/raddbg_pdb_stringize.h"
+#include "regs/regs.h"
+#include "regs/raddbg/regs_raddbg.h"
+#include "type_graph/type_graph.h"
+#include "dbgi/dbgi.h"
+#include "demon/demon_inc.h"
+#include "eval/eval_compiler.h"
+#include "eval/eval_machine.h"
+#include "eval/eval_parser.h"
+#include "unwind/unwind.h"
+#include "ctrl/ctrl_inc.h"
+#include "dasm/dasm.h"
+#include "font_provider/font_provider_inc.h"
+#include "render/render_inc.h"
+#include "texture_cache/texture_cache.h"
+#include "geo_cache/geo_cache.h"
+#include "font_cache/font_cache.h"
+#include "draw/draw.h"
+#include "ui/ui_inc.h"
+#include "df/df_inc.h"
+#include "raddbg.h"
+
+//- rjf: [c]
+#include "base/base_inc.c"
+#include "os/os_inc.c"
+#include "mdesk/mdesk.c"
+#include "hash_store/hash_store.c"
+#include "text_cache/text_cache.c"
+#include "path/path.c"
+#include "txti/txti.c"
+#include "coff/coff.c"
+#include "pe/pe.c"
+#include "raddbg_format/raddbg_format.c"
+#include "raddbg_format/raddbg_format_parse.c"
+#include "raddbg_cons/raddbg_cons.c"
+#include "raddbg_convert/pdb/raddbg_msf.c"
+#include "raddbg_convert/pdb/raddbg_codeview.c"
+#include "raddbg_convert/pdb/raddbg_pdb.c"
+#include "raddbg_convert/pdb/raddbg_coff_conversion.c"
+#include "raddbg_convert/pdb/raddbg_codeview_conversion.c"
+#include "raddbg_convert/pdb/raddbg_codeview_stringize.c"
+#include "raddbg_convert/pdb/raddbg_pdb_stringize.c"
+#include "raddbg_convert/pdb/raddbg_from_pdb.c"
+#include "regs/regs.c"
+#include "regs/raddbg/regs_raddbg.c"
+#include "type_graph/type_graph.c"
+#include "dbgi/dbgi.c"
+#include "demon/demon_inc.c"
+#include "eval/eval_compiler.c"
+#include "eval/eval_machine.c"
+#include "eval/eval_parser.c"
+#include "unwind/unwind.c"
+#include "ctrl/ctrl_inc.c"
+#include "dasm/dasm.c"
+#include "font_provider/font_provider_inc.c"
+#include "render/render_inc.c"
+#include "texture_cache/texture_cache.c"
+#include "geo_cache/geo_cache.c"
+#include "font_cache/font_cache.c"
+#include "draw/draw.c"
+#include "ui/ui_inc.c"
+#include "df/df_inc.c"
+#include "raddbg.c"
+
+////////////////////////////////
+//~ rjf: Low-Level Entry Points
+
+//- rjf: windows
+#if OS_WINDOWS
+
+global DWORD g_saved_exception_code = 0;
+
+internal DWORD
+win32_exception_filter(DWORD dwExceptionCode)
+{
+  g_saved_exception_code = dwExceptionCode;
+  return EXCEPTION_EXECUTE_HANDLER;
+}
+
+int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
+{
+  HANDLE output_handles[3] =
+  {
+    GetStdHandle(STD_INPUT_HANDLE),
+    GetStdHandle(STD_OUTPUT_HANDLE),
+    GetStdHandle(STD_ERROR_HANDLE),
+  };
+  for(U64 idx = 0; idx < ArrayCount(output_handles); idx += 1)
+  {
+    B32 duplicate = 0;
+    for(U64 idx2 = 0; idx2 < idx; idx2 += 1)
+    {
+      if(output_handles[idx2] == output_handles[idx])
+      {
+        duplicate = 1;
+        break;
+      }
+    }
+    if(duplicate)
+    {
+      output_handles[idx] = 0;
+    }
+  }
+  for(U64 idx = 0; idx < ArrayCount(output_handles); idx += 1)
+  {
+    if(output_handles[idx] != 0)
+    {
+      CloseHandle(output_handles[idx]);
+    }
+  }
+  SetStdHandle(STD_INPUT_HANDLE, 0);
+  SetStdHandle(STD_OUTPUT_HANDLE, 0);
+  SetStdHandle(STD_ERROR_HANDLE, 0);
+  static TCTX main_thread_tctx = {0};
+  tctx_init_and_equip(&main_thread_tctx);
+  Arena *perm_arena = arena_alloc();
+  WCHAR *command_line = GetCommandLineW();
+  int argc;
+  WCHAR **argv_16 = CommandLineToArgvW(command_line, &argc);
+  char **argv = push_array(perm_arena, char *, argc);
+  for(int i = 0; i < argc; i += 1)
+  {
+    String16 arg16 = str16_cstring((U16 *)argv_16[i]);
+    String8 arg8 = str8_from_16(perm_arena, arg16);
+    argv[i] = (char *)arg8.str;
+  }
+  __try
+  {
+    entry_point(argc, argv);
+  }
+  __except(win32_exception_filter(GetExceptionCode()))
+  {
+    char buffer[256] = {0};
+    raddbg_snprintf(buffer, sizeof(buffer), "A fatal exception (code 0x%x) occurred. The process is terminating.", (U32)g_saved_exception_code);
+    os_graphical_message(1, str8_lit("Fatal Exception"), str8_cstring(buffer));
+    ExitProcess(1);
+  }
+  return 0;
+}
+
+//- rjf: linux
+#elif OS_LINUX
+
+int main(int argument_count, char **arguments)
+{
+  static TCTX main_thread_tctx = {0};
+  tctx_init_and_equip(&main_thread_tctx);
+  entry_point(argument_count, arguments);
+  return 0;
+}
+
+#endif

src/raddbg_convert/pdb/raddbg_from_pdb.c

@@ -2935,7 +2935,7 @@ str8_list_pushf(arena, &out->errors, fmt, __VA_ARGS__);\
   if (tpi != 0) ProfScope("parse tpi hash"){
     String8 hash_data = msf_data_from_stream(msf, tpi->hash_sn);
     String8 aux_data = msf_data_from_stream(msf, tpi->hash_sn_aux);
-    tpi_hash = pdb_tpi_hash_from_data(arena, tpi, hash_data, aux_data);
+    tpi_hash = pdb_tpi_hash_from_data(arena, strtbl, tpi, hash_data, aux_data);
     
     PARSE_CHECK_ERROR(tpi_hash, "TPI hash table");
   }
@@ -2954,7 +2954,7 @@ str8_list_pushf(arena, &out->errors, fmt, __VA_ARGS__);\
   if (ipi != 0) ProfScope("parse ipi hash"){
     String8 hash_data = msf_data_from_stream(msf, ipi->hash_sn);
     String8 aux_data = msf_data_from_stream(msf, ipi->hash_sn_aux);
-    ipi_hash = pdb_tpi_hash_from_data(arena, ipi, hash_data, aux_data);
+    ipi_hash = pdb_tpi_hash_from_data(arena, strtbl, ipi, hash_data, aux_data);
     
     PARSE_CHECK_ERROR(tpi_hash, "IPI hash table");
   }

src/raddbg_convert/pdb/raddbg_pdb.c

@@ -303,7 +303,7 @@ pdb_tpi_from_data(Arena *arena, String8 data){
 }
 
 static PDB_TpiHashParsed*
-pdb_tpi_hash_from_data(Arena *arena, PDB_TpiParsed *tpi, String8 data, String8 aux_data){
+pdb_tpi_hash_from_data(Arena *arena, PDB_Strtbl *strtbl, PDB_TpiParsed *tpi, String8 data, String8 aux_data){
   ProfBegin("pdb_tpi_hash_from_data");
   
   PDB_TpiHashParsed *result = 0;
@@ -335,7 +335,11 @@ pdb_tpi_hash_from_data(Arena *arena, PDB_TpiParsed *tpi, String8 data, String8 a
           block = push_array(arena, PDB_TpiHashBlock, 1);
           SLLStackPush(buckets[bucket_idx], block);
         }
-        block->itypes[block->local_count] = itype;
+        if(block->local_count != 0)
+        {
+          MemoryCopy(block->itypes+1, block->itypes, sizeof(CV_TypeId)*block->local_count);
+        }
+        block->itypes[0] = itype;
         block->local_count += 1;
       }
       
@@ -344,15 +348,85 @@ pdb_tpi_hash_from_data(Arena *arena, PDB_TpiParsed *tpi, String8 data, String8 a
       itype += 1;
     }
     
+    //- rjf: compute bucket mask
+    U32 bucket_mask = 0;
+    if(IsPow2OrZero(bucket_count))
+    {
+      bucket_mask = bucket_count-1;
+    }
+    
+    //- rjf: apply hash adjustments, to pull correct type IDs to the front of
+    // the chains
+    if(tpi->hash_adj_size != 0)
+    {
+      // NOTE(rjf): this table is laid out in the following format:
+      //
+      // pair_count: U32 -> # of name_index/type_index pairs
+      // slot_count: U32 -> # of slots in this hash table
+      // present_bit_array_count: U32 -> count for next array
+      // present_bit_array: U32[present_bit_array_count] -> 1 bit per slot, "is present"
+      // deleted_bit_array_count: U32 -> count for next array
+      // deleted_bit_array: U32[deleted_bit_array_count] -> 1 bit per slot, "is deleted"
+      // (U32, U32)[pair_count] -> array of name_index/type_index pairs
+      //
+      U8 *adjs = data.str + tpi->hash_adj_off;
+      U8 *adjs_opl = adjs + tpi->hash_adj_size;
+      U8 *adjs_cursor = adjs;
+      U32 pair_count = *(U32 *)adjs_cursor;
+      adjs_cursor += sizeof(U32);
+      U32 slot_count = *(U32 *)adjs_cursor;
+      adjs_cursor += sizeof(U32);
+      U32 present_bit_array_count = *(U32 *)adjs_cursor; // skip present_bit_array
+      adjs_cursor += sizeof(U32);
+      adjs_cursor += present_bit_array_count*sizeof(U32);
+      U32 deleted_bit_array_count = *(U32 *)adjs_cursor; // skip deleted_bit_array
+      adjs_cursor += sizeof(U32);
+      adjs_cursor += deleted_bit_array_count*sizeof(U32);
+      U32 adjs_stride = sizeof(U32)*2;
+      U32 pair_idx = 0;
+      for(;adjs_cursor < adjs_opl && pair_idx < pair_count;
+          adjs_cursor += adjs_stride, pair_idx += 1)
+      {
+        U32 name_off = ((U32 *)adjs_cursor)[0];
+        CV_TypeId type_id = ((CV_TypeId *)adjs_cursor)[1];
+        String8 string = pdb_strtbl_string_from_off(strtbl, name_off);
+        U32 hash = pdb_string_hash1(string);
+        U32 bucket_idx = ((bucket_mask != 0) ? hash&bucket_mask : hash%bucket_count);
+        PDB_TpiHashBlock *prev_block = 0;
+        for(PDB_TpiHashBlock *block = buckets[bucket_idx];
+            block != 0;
+            prev_block = block, block = block->next)
+        {
+          for(U32 local_idx = 0;
+              local_idx < block->local_count && local_idx < ArrayCount(block->itypes);
+              local_idx += 1)
+          {
+            if(block->itypes[local_idx] == type_id)
+            {
+              if(prev_block != 0)
+              {
+                prev_block->next = block->next;
+                block->next = buckets[bucket_idx];
+                buckets[bucket_idx] = block;
+              }
+              if(local_idx != 0)
+              {
+                Swap(CV_TypeId, block->itypes[0], block->itypes[local_idx]);
+              }
+              break;
+            }
+          }
+        }
+      }
+    }
+    
     // fill result
     result = push_array(arena, PDB_TpiHashParsed, 1);
     result->data = data;
     result->aux_data = aux_data;
     result->buckets = buckets;
     result->bucket_count = bucket_count;
-    if (IsPow2OrZero(bucket_count)){
-      result->bucket_mask = bucket_count - 1;
-    }
+    result->bucket_mask = bucket_mask;
   }
   
   ProfEnd();

src/raddbg_convert/pdb/raddbg_pdb.h

@@ -407,6 +407,7 @@ static PDB_Strtbl*          pdb_strtbl_from_data(Arena *arena, String8 strtbl_da
 static PDB_DbiParsed*       pdb_dbi_from_data(Arena *arena, String8 dbi_data);
 static PDB_TpiParsed*       pdb_tpi_from_data(Arena *arena, String8 tpi_data);
 static PDB_TpiHashParsed*   pdb_tpi_hash_from_data(Arena *arena,
+                                                   PDB_Strtbl *strtbl,
                                                    PDB_TpiParsed *tpi,
                                                    String8 tpi_hash_data,
                                                    String8 tpi_hash_aux_data);

src/render/d3d11/render_d3d11.cpp

@@ -131,7 +131,7 @@ r_d3d11_instance_buffer_from_size(U64 size)
 //- rjf: top-level layer initialization
 
 r_hook void
-r_init(void)
+r_init(CmdLine *cmdln)
 {
   ProfBeginFunction();
   HRESULT error = 0;
@@ -143,24 +143,45 @@ r_init(void)
   //- rjf: create base device
   UINT creation_flags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
 #if !defined(NDEBUG)
-  creation_flags |= D3D11_CREATE_DEVICE_DEBUG;
+  if(!cmd_line_has_flag(cmdln, str8_lit("disable_d3d11_debug")))
+  {
+    creation_flags |= D3D11_CREATE_DEVICE_DEBUG;
+  }
 #endif
   D3D_FEATURE_LEVEL feature_levels[] = { D3D_FEATURE_LEVEL_11_0 };
+  D3D_DRIVER_TYPE driver_type = D3D_DRIVER_TYPE_HARDWARE;
+  if(cmd_line_has_flag(cmdln, str8_lit("force_d3d11_software")))
+  {
+    driver_type = D3D_DRIVER_TYPE_WARP;
+  }
   error = D3D11CreateDevice(0,
-                            D3D_DRIVER_TYPE_HARDWARE,
+                            driver_type,
                             0,
                             creation_flags,
                             feature_levels, ArrayCount(feature_levels),
                             D3D11_SDK_VERSION,
                             &r_d3d11_state->base_device, 0, &r_d3d11_state->base_device_ctx);
+  if(!SUCCEEDED(error))
+  {
+    char buffer[256] = {0};
+    raddbg_snprintf(buffer, sizeof(buffer), "D3D11 device creation failure (%x). The process is terminating.", error);
+    os_graphical_message(1, str8_lit("Fatal Error"), str8_cstring(buffer));
+    os_exit_process(1);
+  }
   
   //- rjf: enable break-on-error
 #if !defined(NDEBUG)
-  ID3D11InfoQueue *info = 0;
-  error = r_d3d11_state->base_device->QueryInterface(__uuidof(ID3D11InfoQueue), (void **)(&info));
-  error = info->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, TRUE);
-  error = info->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, TRUE);
-  info->Release();
+  if(!cmd_line_has_flag(cmdln, str8_lit("disable_d3d11_debug")))
+  {
+    ID3D11InfoQueue *info = 0;
+    error = r_d3d11_state->base_device->QueryInterface(__uuidof(ID3D11InfoQueue), (void **)(&info));
+    if(SUCCEEDED(error))
+    {
+      error = info->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, TRUE);
+      error = info->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, TRUE);
+      info->Release();
+    }
+  }
 #endif
   
   //- rjf: get main device
@@ -531,9 +552,15 @@ r_tex2d_alloc(R_Tex2DKind kind, Vec2S32 size, R_Tex2DFormat format, void *data)
     switch(format)
     {
       default:{}break;
-      case R_Tex2DFormat_R8:{dxgi_format = DXGI_FORMAT_R8_UNORM;}break;
-      case R_Tex2DFormat_RGBA8:{}break;
-      case R_Tex2DFormat_BGRA8:{dxgi_format = DXGI_FORMAT_B8G8R8A8_UNORM;}break;
+      case R_Tex2DFormat_R8:    {dxgi_format = DXGI_FORMAT_R8_UNORM;}break;
+      case R_Tex2DFormat_RG8:   {dxgi_format = DXGI_FORMAT_R8G8_UNORM;}break;
+      case R_Tex2DFormat_RGBA8: {dxgi_format = DXGI_FORMAT_R8G8B8A8_UNORM;}break;
+      case R_Tex2DFormat_BGRA8: {dxgi_format = DXGI_FORMAT_B8G8R8A8_UNORM;}break;
+      case R_Tex2DFormat_R16:   {dxgi_format = DXGI_FORMAT_R16_UNORM;}break;
+      case R_Tex2DFormat_RGBA16:{dxgi_format = DXGI_FORMAT_R16G16B16A16_UNORM;}break;
+      case R_Tex2DFormat_R32:   {dxgi_format = DXGI_FORMAT_R32_FLOAT;}break;
+      case R_Tex2DFormat_RG32:  {dxgi_format = DXGI_FORMAT_R32G32_FLOAT;}break;
+      case R_Tex2DFormat_RGBA32:{dxgi_format = DXGI_FORMAT_R32G32B32A32_FLOAT;}break;
     }
   }
   

src/render/generated/render.meta.h

@@ -9,8 +9,14 @@
 typedef enum R_Tex2DFormat
 {
 R_Tex2DFormat_R8,
+R_Tex2DFormat_RG8,
 R_Tex2DFormat_RGBA8,
 R_Tex2DFormat_BGRA8,
+R_Tex2DFormat_R16,
+R_Tex2DFormat_RGBA16,
+R_Tex2DFormat_R32,
+R_Tex2DFormat_RG32,
+R_Tex2DFormat_RGBA32,
 R_Tex2DFormat_COUNT
 } R_Tex2DFormat;
 
@@ -55,15 +61,27 @@ R_PassKind_COUNT
 String8 r_tex2d_format_display_string_table[] =
 {
 str8_lit_comp("R8"),
+str8_lit_comp("RG8"),
 str8_lit_comp("RGBA8"),
 str8_lit_comp("BGRA8"),
+str8_lit_comp("R16"),
+str8_lit_comp("RGBA16"),
+str8_lit_comp("R32"),
+str8_lit_comp("RG32"),
+str8_lit_comp("RGBA32"),
 };
 
 U8 r_tex2d_format_bytes_per_pixel_table[] =
 {
 1,
+2,
 4,
 4,
+2,
+8,
+4,
+8,
+16,
 };
 
 String8 r_tex2d_kind_display_string_table[] =

src/render/render_core.h

@@ -269,7 +269,7 @@ internal R_Pass *r_pass_from_kind(Arena *arena, R_PassList *list, R_PassKind kin
 //~ rjf: Backend Hooks
 
 //- rjf: top-level layer initialization
-r_hook void              r_init(void);
+r_hook void              r_init(CmdLine *cmdln);
 
 //- rjf: window setup/teardown
 r_hook R_Handle          r_window_equip(OS_Handle window);

src/render/render_core.mdesk

@@ -8,8 +8,14 @@
 R_Tex2DFormatTable:
 {
   {R8       "R8"       1}
+  {RG8      "RG8"      2}
   {RGBA8    "RGBA8"    4}
   {BGRA8    "BGRA8"    4}
+  {R16      "R16"      2}
+  {RGBA16   "RGBA16"   8}
+  {R32      "R32"      4}
+  {RG32     "RG32"     8}
+  {RGBA32   "RGBA32"  16}
 }
 
 @table(name, display_string)

src/render/render_inc.c

@@ -4,7 +4,9 @@
 #include "render_core.c"
 
 #if LANG_CPP
-# if R_BACKEND == R_BACKEND_D3D11
+# if R_BACKEND == R_BACKEND_STUB
+#  include "stub/render_stub.c"
+# elif R_BACKEND == R_BACKEND_D3D11
 #  include "d3d11/render_d3d11.cpp"
 # else
 #  error Renderer backend not specified.

src/render/render_inc.h

@@ -7,6 +7,7 @@
 ////////////////////////////////
 //~ rjf: Backend Constants
 
+#define R_BACKEND_STUB 0
 #define R_BACKEND_D3D11 1
 
 ////////////////////////////////
@@ -25,7 +26,9 @@
 //~ rjf: Backend Includes
 
 #if LANG_CPP
-# if R_BACKEND == R_BACKEND_D3D11
+# if R_BACKEND == R_BACKEND_STUB
+#  include "stub/render_stub.h"
+# elif R_BACKEND == R_BACKEND_D3D11
 #  include "d3d11/render_d3d11.h"
 # else
 #  error Renderer backend not specified.

src/render/stub/render_stub.c

@@ -0,0 +1,106 @@
+// Copyright (c) 2024 Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+//- rjf: top-level layer initialization
+
+r_hook void
+r_init(CmdLine *cmdln)
+{
+}
+
+//- rjf: window setup/teardown
+
+r_hook R_Handle
+r_window_equip(OS_Handle window)
+{
+  R_Handle handle = {0};
+  handle.u64[0] = 1;
+  return handle;
+}
+
+r_hook void
+r_window_unequip(OS_Handle window, R_Handle window_equip)
+{
+}
+
+//- rjf: textures
+
+r_hook R_Handle
+r_tex2d_alloc(R_Tex2DKind kind, Vec2S32 size, R_Tex2DFormat format, void *data)
+{
+  R_Handle handle = {0};
+  handle.u64[0] = 1;
+  return handle;
+}
+
+r_hook void
+r_tex2d_release(R_Handle texture)
+{
+}
+
+r_hook R_Tex2DKind
+r_kind_from_tex2d(R_Handle texture)
+{
+  return R_Tex2DKind_Static;
+}
+
+r_hook Vec2S32
+r_size_from_tex2d(R_Handle texture)
+{
+  return v2s32(1, 1);
+}
+
+r_hook R_Tex2DFormat
+r_format_from_tex2d(R_Handle texture)
+{
+  return R_Tex2DFormat_RGBA8;
+}
+
+r_hook void
+r_fill_tex2d_region(R_Handle texture, Rng2S32 subrect, void *data)
+{
+}
+
+//- rjf: buffers
+
+r_hook R_Handle
+r_buffer_alloc(R_BufferKind kind, U64 size, void *data)
+{
+  R_Handle handle = {0};
+  handle.u64[0] = 1;
+  return handle;
+}
+
+r_hook void
+r_buffer_release(R_Handle buffer)
+{
+}
+
+//- rjf: frame markers
+
+r_hook void
+r_begin_frame(void)
+{
+}
+
+r_hook void
+r_end_frame(void)
+{
+}
+
+r_hook void
+r_window_begin_frame(OS_Handle window, R_Handle window_equip)
+{
+}
+
+r_hook void
+r_window_end_frame(OS_Handle window, R_Handle window_equip)
+{
+}
+
+//- rjf: render pass submission
+
+r_hook void
+r_window_submit(OS_Handle window, R_Handle window_equip, R_PassList *passes)
+{
+}

src/render/stub/render_stub.h

@@ -0,0 +1,7 @@
+// Copyright (c) 2024 Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+#ifndef RENDER_STUB_H
+#define RENDER_STUB_H
+
+#endif // RENDER_STUB_H

src/scratch/ryan_scratch.c

@@ -1,307 +1,49 @@
 // Copyright (c) 2024 Epic Games Tools
 // Licensed under the MIT license (https://opensource.org/license/mit/)
 
-#include "base/base_inc.h"
-#include "os/os_inc.h"
-#include "mdesk/mdesk.h"
+// build with:
+// cl /Zi /nologo look_at_raddbg.c
 
-#include "base/base_inc.c"
-#include "os/os_inc.c"
-#include "mdesk/mdesk.c"
+#include <windows.h>
+#include <stdint.h>
+#include "raddbg_format/raddbg_format.h"
+#include "raddbg_format/raddbg_format_parse.h"
+#include "raddbg_format/raddbg_format.c"
+#include "raddbg_format/raddbg_format_parse.c"
 
-typedef enum MG_StrExprOpKind
+typedef struct Foo Foo;
+struct Foo
 {
-  MG_StrExprOpKind_Null,
-  MG_StrExprOpKind_Prefix,
-  MG_StrExprOpKind_Postfix,
-  MG_StrExprOpKind_Binary,
-  MG_StrExprOpKind_COUNT
-}
-MG_StrExprOpKind;
-
-typedef enum MG_StrExprOp
-{
-  MG_StrExprOp_Null,
-  
-#define MG_StrExprOp_FirstString MG_StrExprOp_Dot
-  MG_StrExprOp_Dot,
-  MG_StrExprOp_ExpandIfTrue,
-  MG_StrExprOp_Concat,
-  MG_StrExprOp_BumpToColumn,
-#define MG_StrExprOp_LastString MG_StrExprOp_BumpToColumn
-  
-#define MG_StrExprOp_FirstNumeric MG_StrExprOp_Add
-  MG_StrExprOp_Add,
-  MG_StrExprOp_Subtract,
-  MG_StrExprOp_Multiply,
-  MG_StrExprOp_Divide,
-  MG_StrExprOp_Modulo,
-  MG_StrExprOp_LeftShift,
-  MG_StrExprOp_RightShift,
-  MG_StrExprOp_BitwiseAnd,
-  MG_StrExprOp_BitwiseOr,
-  MG_StrExprOp_BitwiseXor,
-  MG_StrExprOp_BitwiseNegate,
-  MG_StrExprOp_BooleanAnd,
-  MG_StrExprOp_BooleanOr,
-  MG_StrExprOp_BooleanNot,
-  MG_StrExprOp_Equals,
-  MG_StrExprOp_DoesNotEqual,
-#define MG_StrExprOp_LastNumeric MG_StrExprOp_DoesNotEqual
-  
-  MG_StrExprOp_COUNT,
-}
-MG_StrExprOp;
-
-read_only global String8 mg_str_expr_op_symbol_string_table[MG_StrExprOp_COUNT] =
-{
-  str8_lit_comp(""),
-  str8_lit_comp("."),  // MG_StrExprOp_Dot
-  str8_lit_comp("->"), // MG_StrExprOp_ExpandIfTrue
-  str8_lit_comp(".."), // MG_StrExprOp_Concat
-  str8_lit_comp("=>"), // MG_StrExprOp_BumpToColumn
-  str8_lit_comp("+"),  // MG_StrExprOp_Add
-  str8_lit_comp("-"),  // MG_StrExprOp_Subtract
-  str8_lit_comp("*"),  // MG_StrExprOp_Multiply
-  str8_lit_comp("/"),  // MG_StrExprOp_Divide
-  str8_lit_comp("%"),  // MG_StrExprOp_Modulo
-  str8_lit_comp("<<"), // MG_StrExprOp_LeftShift
-  str8_lit_comp(">>"), // MG_StrExprOp_RightShift
-  str8_lit_comp("&"),  // MG_StrExprOp_BitwiseAnd
-  str8_lit_comp("|"),  // MG_StrExprOp_BitwiseOr
-  str8_lit_comp("^"),  // MG_StrExprOp_BitwiseXor
-  str8_lit_comp("~"),  // MG_StrExprOp_BitwiseNegate
-  str8_lit_comp("&&"), // MG_StrExprOp_BooleanAnd
-  str8_lit_comp("||"), // MG_StrExprOp_BooleanOr
-  str8_lit_comp("!"),  // MG_StrExprOp_BooleanNot
-  str8_lit_comp("=="), // MG_StrExprOp_Equals
-  str8_lit_comp("!="), // MG_StrExprOp_DoesNotEqual
+  int x;
+  int y;
+  int z;
 };
 
-read_only global S8 mg_str_expr_op_precedence_table[MG_StrExprOp_COUNT] =
-{
-  0,
-  20, // MG_StrExprOp_Dot
-  1,  // MG_StrExprOp_ExpandIfTrue
-  2,  // MG_StrExprOp_Concat
-  12, // MG_StrExprOp_BumpToColumn
-  5,  // MG_StrExprOp_Add
-  5,  // MG_StrExprOp_Subtract
-  6,  // MG_StrExprOp_Multiply
-  6,  // MG_StrExprOp_Divide
-  6,  // MG_StrExprOp_Modulo
-  7,  // MG_StrExprOp_LeftShift
-  7,  // MG_StrExprOp_RightShift
-  8,  // MG_StrExprOp_BitwiseAnd
-  10, // MG_StrExprOp_BitwiseOr
-  9,  // MG_StrExprOp_BitwiseXor
-  11, // MG_StrExprOp_BitwiseNegate
-  3,  // MG_StrExprOp_BooleanAnd
-  3,  // MG_StrExprOp_BooleanOr
-  11, // MG_StrExprOp_BooleanNot
-  4,  // MG_StrExprOp_Equals
-  4,  // MG_StrExprOp_DoesNotEqual
-};
-
-read_only global MG_StrExprOpKind mg_str_expr_op_kind_table[MG_StrExprOp_COUNT] =
-{
-  MG_StrExprOpKind_Null,
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_Dot
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_ExpandIfTrue
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_Concat
-  MG_StrExprOpKind_Prefix, // MG_StrExprOp_BumpToColumn
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_Add
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_Subtract
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_Multiply
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_Divide
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_Modulo
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_LeftShift
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_RightShift
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_BitwiseAnd
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_BitwiseOr
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_BitwiseXor
-  MG_StrExprOpKind_Prefix, // MG_StrExprOp_BitwiseNegate
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_BooleanAnd
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_BooleanOr
-  MG_StrExprOpKind_Prefix, // MG_StrExprOp_BooleanNot
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_Equals
-  MG_StrExprOpKind_Binary, // MG_StrExprOp_DoesNotEqual
-};
-
-typedef struct MG_StrExpr MG_StrExpr;
-struct MG_StrExpr
-{
-  MG_StrExpr *parent;
-  MG_StrExpr *left;
-  MG_StrExpr *right;
-  MG_StrExprOp op;
-  MD_Node *node;
-};
-
-typedef struct MG_StrExprParseResult MG_StrExprParseResult;
-struct MG_StrExprParseResult
-{
-  MG_StrExpr *root;
-  MD_MsgList msgs;
-  MD_Node *next_node;
-};
-
-global MG_StrExpr mg_str_expr_nil = {&mg_str_expr_nil, &mg_str_expr_nil, &mg_str_expr_nil};
-
-internal MG_StrExpr *
-mg_push_str_expr(Arena *arena, MG_StrExprOp op, MD_Node *node)
-{
-  MG_StrExpr *expr = push_array(arena, MG_StrExpr, 1);
-  MemoryCopyStruct(expr, &mg_str_expr_nil);
-  expr->op = op;
-  expr->node = node;
-  return expr;
-}
-
-internal MG_StrExprParseResult
-mg_str_expr_parse_from_first_opl__min_prec(Arena *arena, MD_Node *first, MD_Node *opl, S8 min_prec)
-{
-  MG_StrExprParseResult parse = {&mg_str_expr_nil};
-  {
-    MD_Node *it = first;
-    
-    //- rjf: consume prefix operators
-    MG_StrExpr *leafmost_op = &mg_str_expr_nil;
-    for(;it < opl && !md_node_is_nil(it);)
-    {
-      MG_StrExprOp found_op = MG_StrExprOp_Null;
-      for(MG_StrExprOp op = (MG_StrExprOp)(MG_StrExprOp_Null+1);
-          op < MG_StrExprOp_COUNT;
-          op = (MG_StrExprOp)(op+1))
-      {
-        if(mg_str_expr_op_kind_table[op] == MG_StrExprOpKind_Prefix &&
-           str8_match(it->string, mg_str_expr_op_symbol_string_table[op], 0) &&
-           mg_str_expr_op_precedence_table[op] >= min_prec)
-        {
-          found_op = op;
-          break;
-        }
-      }
-      if(found_op != MG_StrExprOp_Null)
-      {
-        MG_StrExpr *op_expr = mg_push_str_expr(arena, found_op, it);
-        if(leafmost_op == &mg_str_expr_nil)
-        {
-          leafmost_op = op_expr;
-        }
-        op_expr->left = parse.root;
-        parse.root = op_expr;
-        it = it->next;
-      }
-      else
-      {
-        break;
-      }
-    }
-    
-    //- rjf: parse atom
-    {
-      MG_StrExpr *atom = &mg_str_expr_nil;
-      if(it->flags & MD_NodeFlag_Identifier|MD_NodeFlag_Numeric|MD_NodeFlag_StringLiteral &&
-         md_node_is_nil(it->first))
-      {
-        atom = mg_push_str_expr(arena, MG_StrExprOp_Null, it);
-        it = it->next;
-      }
-      else if(!md_node_is_nil(it->first))
-      {
-        MG_StrExprParseResult subparse = mg_str_expr_parse_from_first_opl__min_prec(arena, it->first, &md_nil_node, 0);
-        atom = subparse.root;
-        md_msg_list_concat_in_place(&parse.msgs, &subparse.msgs);
-        it = it->next;
-      }
-      if(leafmost_op != &mg_str_expr_nil)
-      {
-        leafmost_op->left = atom;
-      }
-      else
-      {
-        parse.root = atom;
-      }
-    }
-    
-    //- rjf: parse binary operator extensions at this precedence level
-    for(;it < opl && !md_node_is_nil(it);)
-    {
-      // rjf: find binary op kind of `it`
-      MG_StrExprOp found_op = MG_StrExprOp_Null;
-      for(MG_StrExprOp op = (MG_StrExprOp)(MG_StrExprOp_Null+1);
-          op < MG_StrExprOp_COUNT;
-          op = (MG_StrExprOp)(op+1))
-      {
-        if(mg_str_expr_op_kind_table[op] == MG_StrExprOpKind_Binary &&
-           str8_match(it->string, mg_str_expr_op_symbol_string_table[op], 0) &&
-           mg_str_expr_op_precedence_table[op] >= min_prec)
-        {
-          found_op = op;
-          break;
-        }
-      }
-      
-      // rjf: good found_op -> build binary expr
-      if(found_op != MG_StrExprOp_Null)
-      {
-        MG_StrExpr *op_expr = mg_push_str_expr(arena, found_op, it);
-        if(leafmost_op == &mg_str_expr_nil)
-        {
-          leafmost_op = op_expr;
-        }
-        op_expr->left = parse.root;
-        parse.root = op_expr;
-        it = it->next;
-      }
-      else
-      {
-        break;
-      }
-      
-      // rjf: parse right hand side of binary operator
-      MG_StrExprParseResult subparse = mg_str_expr_parse_from_first_opl__min_prec(arena, it, opl, mg_str_expr_op_precedence_table[found_op]+1);
-      parse.root->right = subparse.root;
-      md_msg_list_concat_in_place(&parse.msgs, &subparse.msgs);
-      if(subparse.root == &mg_str_expr_nil)
-      {
-        md_msg_list_pushf(arena, &parse.msgs, it, MD_MsgKind_Error, "Missing right-hand-side of '%S'.", mg_str_expr_op_symbol_string_table[found_op]);
-      }
-      it = subparse.next_node;
-    }
-    
-    // rjf: store next node for more caller-side parsing
-    parse.next_node = it;
-  }
-  return parse;
-}
-
-internal MG_StrExprParseResult
-mg_str_expr_parse_from_first_opl(Arena *arena, MD_Node *first, MD_Node *opl)
-{
-  MG_StrExprParseResult parse = mg_str_expr_parse_from_first_opl__min_prec(arena, first, opl, 0);
-  return parse;
-}
-
-internal MG_StrExprParseResult
-mg_str_expr_parse_from_root(Arena *arena, MD_Node *root)
-{
-  MG_StrExprParseResult parse = mg_str_expr_parse_from_first_opl__min_prec(arena, root->first, &md_nil_node, 0);
-  return parse;
-}
-
 int main(int argument_count, char **arguments)
 {
-  static TCTX main_thread_tctx = {0};
-  tctx_init_and_equip(&main_thread_tctx);
-  os_init(argument_count, arguments);
-  
-  Arena *arena = arena_alloc();
-  String8 text = str8_lit("(a.vr == \"x\" -> \"DF_GFX_VIEW_RULE_VIZ_ROW_PROD_FUNCTION_DEF(\" .. a.name_lower .. \");\")");
-  MD_TokenizeResult tokenize = md_tokenize_from_text(arena, text);
-  MD_ParseResult base_parse = md_parse_from_text_tokens(arena, str8_lit(""), text, tokenize.tokens);
-  MG_StrExprParseResult strexpr_parse = mg_str_expr_parse_from_root(arena, base_parse.root->first);
-  
+  Foo foo = {123, 456, 789};
+  HANDLE file = CreateFileA(arguments[1], GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
+  DWORD size_hi32 = 0;
+  DWORD size_lo32 = GetFileSize(file, &size_hi32);
+  HANDLE map = CreateFileMappingA(file, 0, PAGE_READONLY, 0, 0, 0);
+  uint64_t data_size = (size_lo32 | ((uint64_t)size_hi32 << 32));
+  uint8_t *data = (uint8_t *)MapViewOfFile(map, FILE_MAP_READ, 0, 0, data_size);
+  RADDBG_Parsed rdbg = {0};
+  RADDBG_ParseStatus parse_status = raddbg_parse(data, data_size, &rdbg);
+  uint64_t foo_count = 0;
+  for(uint64_t idx = 0; idx < rdbg.type_node_count; idx += 1)
+  {
+    RADDBG_TypeNode *type_node = &rdbg.type_nodes[idx];
+    if(RADDBG_TypeKind_FirstUserDefined <= type_node->kind && type_node->kind <= RADDBG_TypeKind_LastUserDefined)
+    {
+      uint64_t name_size = 0;
+      uint8_t *name = raddbg_string_from_idx(&rdbg, type_node->user_defined.name_string_idx, &name_size);
+      if(name_size == 3 && name[0] == 'f' && name[1] == 'o' && name[2] == 'o')
+      {
+        foo_count += 1;
+      }
+    }
+  }
+  printf("%s -> %I64u foos\n", arguments[1], foo_count);
   return 0;
 }

src/type_graph/type_graph.c

@@ -318,7 +318,7 @@ tg_type_from_graph_raddbg_key(Arena *arena, TG_Graph *graph, RADDBG_Parsed *rdbg
                 RADDBG_UDT *udt = &rdbg->udts[udt_idx];
                 members_count = udt->member_count;
                 members = push_array(arena, TG_Member, members_count);
-                if(0 <= udt->member_first && udt->member_first+udt->member_count < rdbg->member_count)
+                if(members_count != 0 && 0 <= udt->member_first && udt->member_first+udt->member_count <= rdbg->member_count)
                 {
                   for(U32 member_idx = udt->member_first;
                       member_idx < udt->member_first+udt->member_count;

src/ui/ui_core.c

@@ -115,11 +115,10 @@ ui_nav_eat_action_node(UI_NavActionList *list, UI_NavActionNode *node)
 
 ////////////////////////////////
 //~ rjf: High Level Navigation Action => Text Operations
-
 internal B32
-ui_nav_char_is_scan_boundary(U8 c)
+ui_nav_char_is_code_symbol(U8 c)
 {
-  return char_is_space(c) || char_is_slash(c);
+  return (char_is_alpha(c) || char_is_digit(c, 10) || c == '_');
 }
 
 internal S64
@@ -127,20 +126,26 @@ ui_nav_scanned_column_from_column(String8 string, S64 start_column, Side side)
 {
   S64 new_column = start_column;
   S64 delta = (!!side)*2 - 1;
-  B32 found_boundary = 0;
-  for(S64 col = start_column+delta; 1 <= col && col <= string.size+1; col += delta)
+  B32 found_text = 0;
+  B32 found_non_space = 0;
+  S64 start_off = delta < 0 ? delta : 0;
+  for(S64 col = start_column+start_off; 1 <= col && col <= string.size+1; col += delta)
   {
     U8 byte = (col <= string.size) ? string.str[col-1] : 0;
-    B32 is_boundary = (ui_nav_char_is_scan_boundary(byte) ^ !(side == Side_Max));
-    if((found_boundary && !is_boundary) ||
-       (col == 1 || col == string.size+1))
+    B32 is_non_space = !char_is_space(byte);
+    B32 is_name = ui_nav_char_is_code_symbol(byte);
+    
+    if (((side == Side_Min) && (col == 1)) || 
+        ((side == Side_Max) && (col == string.size+1)) ||
+        (found_non_space && !is_non_space) || 
+        (found_text && !is_name))
     {
       new_column = col + (!side && col != 1);  
       break;
-    }
-    else if(!found_boundary && is_boundary)
-    {
-      found_boundary = 1;
+    } else if (!found_text && is_name) {
+      found_text = 1;
+    } else if (!found_non_space && is_non_space ) {
+      found_non_space = 1;
     }
   }
   return new_column;
@@ -903,7 +908,7 @@ ui_begin_build(OS_EventList *events, OS_Handle window, UI_NavActionList *nav_act
     UI_FixedX(anchor.x) UI_FixedY(anchor.y) UI_PrefWidth(ui_children_sum(1.f)) UI_PrefHeight(ui_children_sum(1.f)) UI_Focus(ui_state->ctx_menu_open)
     {
       ui_set_next_child_layout_axis(Axis2_Y);
-      ui_state->ctx_menu_root = ui_build_box_from_stringf(UI_BoxFlag_DrawDropShadow|(ui_state->ctx_menu_open*UI_BoxFlag_DefaultFocusNavY), "###ctx_menu_%I64x", window.u64[0]);
+      ui_state->ctx_menu_root = ui_build_box_from_stringf(UI_BoxFlag_Clickable|UI_BoxFlag_DrawDropShadow|(ui_state->ctx_menu_open*UI_BoxFlag_DefaultFocusNavY), "###ctx_menu_%I64x", window.u64[0]);
     }
   }
   
@@ -1015,16 +1020,6 @@ ui_end_build(void)
     ui_ctx_menu_close();
   }
   
-  //- rjf: close ctx menu if unconsumed clicks
-  for(OS_Event *event = ui_events()->first; event != 0; event = event->next)
-  {
-    if(event->kind == OS_EventKind_Press && os_handle_match(event->window, ui_window()) &&
-       (event->key == OS_Key_LeftMouseButton || event->key == OS_Key_RightMouseButton))
-    {
-      ui_ctx_menu_close();
-    }
-  }
-  
   //- rjf: stick ctx menu to anchor
   if(ui_state->ctx_menu_touched_this_frame)
   {
@@ -1214,6 +1209,22 @@ ui_end_build(void)
     root->rect.y1 = root->rect.y0 + dim_2f32(rect).y * ui_state->ctx_menu_open_t;
   }
   
+  //- rjf: fall-through interact with context menu
+  if(ui_state->ctx_menu_open)
+  {
+    ui_signal_from_box(ui_state->ctx_menu_root);
+  }
+  
+  //- rjf: close ctx menu if unconsumed clicks
+  for(OS_Event *event = ui_events()->first; event != 0; event = event->next)
+  {
+    if(event->kind == OS_EventKind_Press && os_handle_match(event->window, ui_window()) &&
+       (event->key == OS_Key_LeftMouseButton || event->key == OS_Key_RightMouseButton))
+    {
+      ui_ctx_menu_close();
+    }
+  }
+  
   //- rjf: hover cursor
   {
     UI_Box *hot = ui_box_from_key(ui_state->hot_box_key);
@@ -2304,7 +2315,7 @@ ui_signal_from_box(UI_Box *box)
   B32 ctx_menu_is_ancestor = 0;
   ProfScope("check context menu ancestor")
   {
-    for(UI_Box *parent = box->parent; !ui_box_is_nil(parent); parent = parent->parent)
+    for(UI_Box *parent = box; !ui_box_is_nil(parent); parent = parent->parent)
     {
       if(parent == ui_state->ctx_menu_root)
       {
@@ -2562,8 +2573,10 @@ ui_signal_from_box(UI_Box *box)
   }
   
   //- rjf: set hovering status
-  result.hovering = mouse_is_over && (ui_key_match(ui_state->active_box_key[Side_Min], ui_key_zero()) ||
-                                      ui_key_match(ui_state->active_box_key[Side_Min], box->key));
+  result.hovering = mouse_is_over && ((ui_key_match(ui_state->hot_box_key, ui_key_zero()) ||
+                                       ui_key_match(ui_state->hot_box_key, box->key)) &&
+                                      (ui_key_match(ui_state->active_box_key[Side_Min], ui_key_zero()) ||
+                                       ui_key_match(ui_state->active_box_key[Side_Min], box->key)));
   result.mouse_over = mouse_is_over;
   
   //- rjf: clicking in default nav -> set navigation state to this box