move over all expansion view rules to new eval-system lookup hooks; eliminate most of old hooks

Author: ryanfleury

src/ctrl/ctrl.mdesk

@@ -4,17 +4,17 @@
 ////////////////////////////////
 //~ rjf: Entity Kinds
 
-@table(name display_string)
+@table(name  code_name  display_string)
 CTRL_EntityKindTable:
 {
-  {Root                      "Root"                      }
-  {Machine                   "Machine"                   }
-  {Process                   "Process"                   }
-  {Thread                    "Thread"                    }
-  {Module                    "Module"                    }
-  {EntryPoint                "Entry Point"               }
-  {DebugInfoPath             "Debug Info Path"           }
-  {PendingThreadName         "Pending Thread Name"       }
+  {Root                      root                 "Root"                      }
+  {Machine                   machine              "Machine"                   }
+  {Process                   process              "Process"                   }
+  {Thread                    thread               "Thread"                    }
+  {Module                    module               "Module"                    }
+  {EntryPoint                entry_point          "Entry Point"               }
+  {DebugInfoPath             debug_info_path      "Debug Info Path"           }
+  {PendingThreadName         pending_thread_name  "Pending Thread Name"       }
 }
 
 @enum CTRL_EntityKind:
@@ -24,6 +24,12 @@ CTRL_EntityKindTable:
   COUNT,
 }
 
+@data(String8) ctrl_entity_kind_code_name_table:
+{
+  `{0}`,
+  @expand(CTRL_EntityKindTable a) `str8_lit_comp("$(a.code_name)")`
+}
+
 @data(String8) ctrl_entity_kind_display_string_table:
 {
   `{0}`,

src/ctrl/ctrl_core.c

@@ -91,6 +91,21 @@ ctrl_string_from_msg_kind(CTRL_MsgKind kind)
   return result;
 }
 
+internal CTRL_EntityKind
+ctrl_entity_kind_from_string(String8 string)
+{
+  CTRL_EntityKind result = CTRL_EntityKind_Null;
+  for EachNonZeroEnumVal(CTRL_EntityKind, k)
+  {
+    if(str8_match(ctrl_entity_kind_code_name_table[k], string, 0))
+    {
+      result = k;
+      break;
+    }
+  }
+  return result;
+}
+
 ////////////////////////////////
 //~ rjf: Machine/Handle Pair Type Functions
 

src/ctrl/ctrl_core.h

@@ -951,6 +951,7 @@ internal U64 ctrl_hash_from_handle(CTRL_Handle handle);
 internal CTRL_EventCause ctrl_event_cause_from_dmn_event_kind(DMN_EventKind event_kind);
 internal String8 ctrl_string_from_event_kind(CTRL_EventKind kind);
 internal String8 ctrl_string_from_msg_kind(CTRL_MsgKind kind);
+internal CTRL_EntityKind ctrl_entity_kind_from_string(String8 string);
 
 ////////////////////////////////
 //~ rjf: Handle Type Functions

src/ctrl/generated/ctrl.meta.c

@@ -4,6 +4,19 @@
 //- GENERATED CODE
 
 C_LINKAGE_BEGIN
+String8 ctrl_entity_kind_code_name_table[9] =
+{
+{0},
+str8_lit_comp("root"),
+str8_lit_comp("machine"),
+str8_lit_comp("process"),
+str8_lit_comp("thread"),
+str8_lit_comp("module"),
+str8_lit_comp("entry_point"),
+str8_lit_comp("debug_info_path"),
+str8_lit_comp("pending_thread_name"),
+};
+
 String8 ctrl_entity_kind_display_string_table[9] =
 {
 {0},

src/ctrl/generated/ctrl.meta.h

@@ -64,6 +64,7 @@ CTRL_ExceptionCodeKind_COUNT,
 } CTRL_ExceptionCodeKind;
 
 C_LINKAGE_BEGIN
+extern String8 ctrl_entity_kind_code_name_table[9];
 extern String8 ctrl_entity_kind_display_string_table[9];
 extern U32 ctrl_exception_code_kind_code_table[38];
 extern String8 ctrl_exception_code_kind_display_string_table[38];

src/eval/eval_ir.c

@@ -90,6 +90,11 @@ e_lookup_rule_map_insert(Arena *arena, E_LookupRuleMap *map, E_LookupRule *rule)
   E_LookupRuleNode *n = push_array(arena, E_LookupRuleNode, 1);
   SLLQueuePush(map->slots[slot_idx].first, map->slots[slot_idx].last, n);
   MemoryCopyStruct(&n->v, rule);
+  if(n->v.info == 0)       { n->v.info = E_LOOKUP_INFO_FUNCTION_NAME(default); }
+  if(n->v.access == 0)     { n->v.access = E_LOOKUP_ACCESS_FUNCTION_NAME(default); }
+  if(n->v.range == 0)      { n->v.range = E_LOOKUP_RANGE_FUNCTION_NAME(default); }
+  if(n->v.id_from_num == 0){ n->v.id_from_num = E_LOOKUP_ID_FROM_NUM_FUNCTION_NAME(default); }
+  if(n->v.num_from_id == 0){ n->v.num_from_id = E_LOOKUP_NUM_FROM_ID_FUNCTION_NAME(default); }
   n->v.name = push_str8_copy(arena, n->v.name);
 }
 
@@ -155,9 +160,18 @@ E_LOOKUP_INFO_FUNCTION_DEF(default)
   return lookup_info;
 }
 
-E_LOOKUP_FUNCTION_DEF(default)
+E_LOOKUP_ACCESS_FUNCTION_DEF(default)
 {
-  E_Lookup lookup = {{&e_irnode_nil}};
+  //
+  // TODO(rjf): need to define what it means to access a set expression
+  // whose type *does not* define its IR generation rules, BUT it does
+  // define specific child expressions. so e.g. `watches`, does not
+  // define `watches[0]`, because it has defined that `watches[0]`
+  // maps to another expression, which is whatever the first watch
+  // expression is (e.g. `basics`). so, in that case, we can just use
+  // the lookup-range rule, grab the Nth expression, and IR-ify *that*.
+  //
+  E_LookupAccess result = {{&e_irnode_nil}};
   switch(kind)
   {
     default:{}break;
@@ -180,7 +194,7 @@ E_LOOKUP_FUNCTION_DEF(default)
         check_type_key = e_type_unwrap(e_type_direct_from_key(e_type_unwrap(l_restype)));
         check_type_kind = e_type_kind_from_key(check_type_key);
       }
-      e_msg_list_concat_in_place(&lookup.irtree_and_type.msgs, &l.msgs);
+      e_msg_list_concat_in_place(&result.irtree_and_type.msgs, &l.msgs);
 
       // rjf: look up member
       B32 r_found = 0;
@@ -234,20 +248,20 @@ E_LOOKUP_FUNCTION_DEF(default)
       }
       else if(exprr->kind != E_ExprKind_LeafMember)
       {
-        e_msgf(arena, &lookup.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprl->location, "Expected member name.");
+        e_msgf(arena, &result.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprl->location, "Expected member name.");
         break;
       }
       else if(!r_found)
       {
-        e_msgf(arena, &lookup.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Could not find a member named `%S`.", exprr->string);
+        e_msgf(arena, &result.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Could not find a member named `%S`.", exprr->string);
         break;
       }
       else if(check_type_kind != E_TypeKind_Struct &&
               check_type_kind != E_TypeKind_Class &&
               check_type_kind != E_TypeKind_Union &&
               check_type_kind != E_TypeKind_Enum)
       {
-        e_msgf(arena, &lookup.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprl->location, "Cannot perform member access on this type.");
+        e_msgf(arena, &result.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprl->location, "Cannot perform member access on this type.");
         break;
       }
 
@@ -275,9 +289,9 @@ E_LOOKUP_FUNCTION_DEF(default)
         }
 
         // rjf: fill
-        lookup.irtree_and_type.root     = new_tree;
-        lookup.irtree_and_type.type_key = r_type;
-        lookup.irtree_and_type.mode     = mode;
+        result.irtree_and_type.root     = new_tree;
+        result.irtree_and_type.type_key = r_type;
+        result.irtree_and_type.mode     = mode;
       }
     }break;
 
@@ -302,8 +316,8 @@ E_LOOKUP_FUNCTION_DEF(default)
       direct_type = e_type_direct_from_key(direct_type);
       direct_type = e_type_unwrap(direct_type);
       U64 direct_type_size = e_type_byte_size_from_key(direct_type);
-      e_msg_list_concat_in_place(&lookup.irtree_and_type.msgs, &l.msgs);
-      e_msg_list_concat_in_place(&lookup.irtree_and_type.msgs, &r.msgs);
+      e_msg_list_concat_in_place(&result.irtree_and_type.msgs, &l.msgs);
+      e_msg_list_concat_in_place(&result.irtree_and_type.msgs, &r.msgs);
 
       // rjf: bad conditions? -> error if applicable, exit
       if(r.root->op == 0)
@@ -312,22 +326,22 @@ E_LOOKUP_FUNCTION_DEF(default)
       }
       else if(l_restype_kind != E_TypeKind_Ptr && l_restype_kind != E_TypeKind_Array)
       {
-        e_msgf(arena, &lookup.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprl->location, "Cannot index into this type.");
+        e_msgf(arena, &result.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprl->location, "Cannot index into this type.");
         break;
       }
       else if(!e_type_kind_is_integer(r_restype_kind))
       {
-        e_msgf(arena, &lookup.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Cannot index with this type.");
+        e_msgf(arena, &result.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Cannot index with this type.");
         break;
       }
       else if(l_restype_kind == E_TypeKind_Ptr && direct_type_size == 0)
       {
-        e_msgf(arena, &lookup.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Cannot index into pointers of zero-sized types.");
+        e_msgf(arena, &result.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Cannot index into pointers of zero-sized types.");
         break;
       }
       else if(l_restype_kind == E_TypeKind_Array && direct_type_size == 0)
       {
-        e_msgf(arena, &lookup.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Cannot index into arrays of zero-sized types.");
+        e_msgf(arena, &result.irtree_and_type.msgs, E_MsgKind_MalformedInput, exprr->location, "Cannot index into arrays of zero-sized types.");
         break;
       }
 
@@ -381,12 +395,64 @@ E_LOOKUP_FUNCTION_DEF(default)
       }
 
       // rjf: fill
-      lookup.irtree_and_type.root     = new_tree;
-      lookup.irtree_and_type.type_key = direct_type;
-      lookup.irtree_and_type.mode     = l.mode;
+      result.irtree_and_type.root     = new_tree;
+      result.irtree_and_type.type_key = direct_type;
+      result.irtree_and_type.mode     = l.mode;
     }break;
   }
-  return lookup;
+  return result;
+}
+
+E_LOOKUP_RANGE_FUNCTION_DEF(default)
+{
+  E_LookupRange result = {0};
+  Temp scratch = scratch_begin(&arena, 1);
+  {
+    E_IRTreeAndType lhs_irtree = e_irtree_and_type_from_expr(scratch.arena, lhs);
+    E_TypeKey lhs_type_key = lhs_irtree.type_key;
+    E_TypeKind lhs_type_kind = e_type_kind_from_key(lhs_type_key);
+    if(lhs_type_kind == E_TypeKind_Struct ||
+       lhs_type_kind == E_TypeKind_Union ||
+       lhs_type_kind == E_TypeKind_Class ||
+       lhs_type_kind == E_TypeKind_Enum)
+    {
+      E_Type *lhs_type = e_type_from_key(scratch.arena, lhs_type_key);
+      Rng1U64 legal_idx_range = r1u64(0, lhs_type->count);
+      Rng1U64 read_range = intersect_1u64(legal_idx_range, idx_range);
+      U64 read_range_count = dim_1u64(read_range);
+      result.exprs_count = read_range_count;
+      result.exprs = push_array(arena, E_Expr *, result.exprs_count);
+      for(U64 idx = 0; idx < result.exprs_count; idx += 1)
+      {
+        U64 member_idx = idx + read_range.min;
+        String8 member_name = (lhs_type->members   ? lhs_type->members[member_idx].name :
+                               lhs_type->enum_vals ? lhs_type->enum_vals[member_idx].name : str8_lit(""));
+        result.exprs[idx] = e_expr_ref_member_access(arena, lhs, member_name);
+      }
+    }
+    else if(lhs_type_kind == E_TypeKind_Set)
+    {
+      result.exprs_count = dim_1u64(idx_range);
+      result.exprs = push_array(arena, E_Expr *, result.exprs_count);
+      result.exprs_strings = push_array(arena, String8, result.exprs_count);
+      for(U64 idx = 0; idx < result.exprs_count; idx += 1)
+      {
+        result.exprs[idx] = e_expr_ref_array_index(arena, lhs, idx_range.min + idx);
+      }
+    }
+  }
+  scratch_end(scratch);
+  return result;
+}
+
+E_LOOKUP_ID_FROM_NUM_FUNCTION_DEF(default)
+{
+  return num;
+}
+
+E_LOOKUP_NUM_FROM_ID_FUNCTION_DEF(default)
+{
+  return id;
 }
 
 ////////////////////////////////
@@ -716,9 +782,9 @@ e_irtree_and_type_from_expr__space(Arena *arena, E_Space *current_space, E_Expr
       }
       E_Expr *rhs = lhs->next;
       E_LookupRule *lookup_rule = e_lookup_rule_from_string(lookup_rule_name);
-      E_LookupInfo lookup_info = lookup_rule->lookup_info(arena, lhs);
-      E_Lookup lookup = lookup_rule->lookup(arena, expr->kind, lhs, rhs, lookup_info.user_data);
-      result = lookup.irtree_and_type;
+      E_LookupInfo lookup_info = lookup_rule->info(arena, lhs, str8_zero());
+      E_LookupAccess lookup_access = lookup_rule->access(arena, expr->kind, lhs, rhs, lookup_info.user_data);
+      result = lookup_access.irtree_and_type;
       scratch_end(scratch);
     }break;
 

src/eval/eval_ir.h

@@ -66,31 +66,60 @@ struct E_LookupInfo
   U64 idxed_expr_count;
 };
 
-typedef struct E_Lookup E_Lookup;
-struct E_Lookup
+typedef struct E_LookupAccess E_LookupAccess;
+struct E_LookupAccess
 {
   E_IRTreeAndType irtree_and_type;
 };
 
-#define E_LOOKUP_INFO_FUNCTION_SIG(name) E_LookupInfo name(Arena *arena, E_Expr *lhs)
+typedef struct E_LookupRange E_LookupRange;
+struct E_LookupRange
+{
+  U64 exprs_count;
+  E_Expr **exprs;
+  String8 *exprs_strings;
+};
+
+#define E_LOOKUP_INFO_FUNCTION_SIG(name) E_LookupInfo name(Arena *arena, E_Expr *lhs, String8 filter)
 #define E_LOOKUP_INFO_FUNCTION_NAME(name) e_lookup_info_##name
 #define E_LOOKUP_INFO_FUNCTION_DEF(name) internal E_LOOKUP_INFO_FUNCTION_SIG(E_LOOKUP_INFO_FUNCTION_NAME(name))
 typedef E_LOOKUP_INFO_FUNCTION_SIG(E_LookupInfoFunctionType);
 
-#define E_LOOKUP_FUNCTION_SIG(name) E_Lookup name(Arena *arena, E_ExprKind kind, E_Expr *lhs, E_Expr *rhs, void *user_data)
-#define E_LOOKUP_FUNCTION_NAME(name) e_lookup_##name
-#define E_LOOKUP_FUNCTION_DEF(name) internal E_LOOKUP_FUNCTION_SIG(E_LOOKUP_FUNCTION_NAME(name))
-typedef E_LOOKUP_FUNCTION_SIG(E_LookupFunctionType);
+#define E_LOOKUP_ACCESS_FUNCTION_SIG(name) E_LookupAccess name(Arena *arena, E_ExprKind kind, E_Expr *lhs, E_Expr *rhs, void *user_data)
+#define E_LOOKUP_ACCESS_FUNCTION_NAME(name) e_lookup_access_##name
+#define E_LOOKUP_ACCESS_FUNCTION_DEF(name) internal E_LOOKUP_ACCESS_FUNCTION_SIG(E_LOOKUP_ACCESS_FUNCTION_NAME(name))
+typedef E_LOOKUP_ACCESS_FUNCTION_SIG(E_LookupAccessFunctionType);
+
+#define E_LOOKUP_RANGE_FUNCTION_SIG(name) E_LookupRange name(Arena *arena, E_Expr *lhs, Rng1U64 idx_range, void *user_data)
+#define E_LOOKUP_RANGE_FUNCTION_NAME(name) e_lookup_range_##name
+#define E_LOOKUP_RANGE_FUNCTION_DEF(name) internal E_LOOKUP_RANGE_FUNCTION_SIG(E_LOOKUP_RANGE_FUNCTION_NAME(name))
+typedef E_LOOKUP_RANGE_FUNCTION_SIG(E_LookupRangeFunctionType);
+
+#define E_LOOKUP_ID_FROM_NUM_FUNCTION_SIG(name) U64 name(U64 num, void *user_data)
+#define E_LOOKUP_ID_FROM_NUM_FUNCTION_NAME(name) e_lookup_id_from_num_##name
+#define E_LOOKUP_ID_FROM_NUM_FUNCTION_DEF(name) internal E_LOOKUP_ID_FROM_NUM_FUNCTION_SIG(E_LOOKUP_ID_FROM_NUM_FUNCTION_NAME(name))
+typedef E_LOOKUP_ID_FROM_NUM_FUNCTION_SIG(E_LookupIDFromNumFunctionType);
+
+#define E_LOOKUP_NUM_FROM_ID_FUNCTION_SIG(name) U64 name(U64 id, void *user_data)
+#define E_LOOKUP_NUM_FROM_ID_FUNCTION_NAME(name) e_lookup_num_from_id_##name
+#define E_LOOKUP_NUM_FROM_ID_FUNCTION_DEF(name) internal E_LOOKUP_NUM_FROM_ID_FUNCTION_SIG(E_LOOKUP_NUM_FROM_ID_FUNCTION_NAME(name))
+typedef E_LOOKUP_NUM_FROM_ID_FUNCTION_SIG(E_LookupNumFromIDFunctionType);
 
 E_LOOKUP_INFO_FUNCTION_DEF(default);
-E_LOOKUP_FUNCTION_DEF(default);
+E_LOOKUP_ACCESS_FUNCTION_DEF(default);
+E_LOOKUP_RANGE_FUNCTION_DEF(default);
+E_LOOKUP_ID_FROM_NUM_FUNCTION_DEF(default);
+E_LOOKUP_NUM_FROM_ID_FUNCTION_DEF(default);
 
 typedef struct E_LookupRule E_LookupRule;
 struct E_LookupRule
 {
   String8 name;
-  E_LookupInfoFunctionType *lookup_info;
-  E_LookupFunctionType *lookup;
+  E_LookupInfoFunctionType *info;
+  E_LookupAccessFunctionType *access;
+  E_LookupRangeFunctionType *range;
+  E_LookupIDFromNumFunctionType *id_from_num;
+  E_LookupNumFromIDFunctionType *num_from_id;
 };
 
 typedef struct E_LookupRuleNode E_LookupRuleNode;
@@ -131,7 +160,10 @@ local_persist read_only E_LookupRule e_lookup_rule__default =
 {
   str8_lit_comp("default"),
   E_LOOKUP_INFO_FUNCTION_NAME(default),
-  E_LOOKUP_FUNCTION_NAME(default),
+  E_LOOKUP_ACCESS_FUNCTION_NAME(default),
+  E_LOOKUP_RANGE_FUNCTION_NAME(default),
+  E_LOOKUP_ID_FROM_NUM_FUNCTION_NAME(default),
+  E_LOOKUP_NUM_FROM_ID_FUNCTION_NAME(default),
 };
 global read_only E_IRNode e_irnode_nil = {&e_irnode_nil, &e_irnode_nil, &e_irnode_nil};
 thread_static E_IRCtx *e_ir_ctx = 0;
@@ -153,11 +185,9 @@ internal void e_select_ir_ctx(E_IRCtx *ctx);
 
 internal E_LookupRuleMap e_lookup_rule_map_make(Arena *arena, U64 slots_count);
 internal void e_lookup_rule_map_insert(Arena *arena, E_LookupRuleMap *map, E_LookupRule *rule);
-#define e_lookup_rule_map_insert_new(arena, map, name_, lookup_info_, lookup_) e_lookup_rule_map_insert((arena), (map), &(E_LookupRule){.name = (name_), .lookup_info = (lookup_info_), .lookup = (lookup_)})
+#define e_lookup_rule_map_insert_new(arena, map, name_, ...) e_lookup_rule_map_insert((arena), (map), &(E_LookupRule){.name = (name_), __VA_ARGS__})
 
 internal E_LookupRule *e_lookup_rule_from_string(String8 string);
-E_LOOKUP_INFO_FUNCTION_DEF(default);
-E_LOOKUP_FUNCTION_DEF(default);
 
 ////////////////////////////////
 //~ rjf: IR-ization Functions