eval: specify formal way in which tags (view rules) can fit into expression language, both in parsing & in structure; introduce ir-generation hook step in eval pipeline, transfer most of the default non-vbisualization view rule features to that layer

Author: ryanfleury

src/eval/eval.mdesk

@@ -117,6 +117,8 @@ E_ExprKindTable:
 
   { Ternary              Null                0        "? "                ""        "?"       ":"}
 
+  { Call                 Null                0        "()"                "("       ","       ")"}
+  
   { LeafBytecode         Null                0        "bytecode"          ""        ""        "" }
   { LeafMember           Null                0        "member"            ""        ""        "" }
   { LeafStringLiteral    Null                0        "string_literal"    ""        ""        "" }
@@ -136,6 +138,8 @@ E_ExprKindTable:
   { Line                 Binary              1        ":"                 ""        ":"       "" }
 
   { Define               Binary              13       "="                 ""        "="       "" }
+  
+  { Tag                  Null                0        "=>"                "=>"      ","       "" }
 }
 
 @table(name display_string)

src/eval/eval_ir.c

@@ -42,6 +42,7 @@ struct E_IRNode
   E_IRNode *last;
   E_IRNode *next;
   RDI_EvalOp op;
+  E_Space space;
   String8 string;
   E_Value value;
 };
@@ -84,31 +85,30 @@ struct E_LookupRange
 #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);
+E_LOOKUP_INFO_FUNCTION_DEF(default);
 
 #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);
+E_LOOKUP_ACCESS_FUNCTION_DEF(default);
 
 #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);
+E_LOOKUP_RANGE_FUNCTION_DEF(default);
 
 #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);
+E_LOOKUP_ID_FROM_NUM_FUNCTION_DEF(default);
 
 #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_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;
@@ -143,6 +143,68 @@ struct E_LookupRuleMap
   U64 slots_count;
 };
 
+////////////////////////////////
+//~ rjf: IR Generation Hooks
+
+#define E_IRGEN_FUNCTION_SIG(name) E_IRTreeAndType name(Arena *arena, E_Expr *expr, E_Expr *tag)
+#define E_IRGEN_FUNCTION_NAME(name) e_irgen_##name
+#define E_IRGEN_FUNCTION_DEF(name) internal E_IRGEN_FUNCTION_SIG(E_IRGEN_FUNCTION_NAME(name))
+typedef E_IRGEN_FUNCTION_SIG(E_IRGenFunctionType);
+E_IRGEN_FUNCTION_DEF(default);
+
+typedef struct E_IRGenRule E_IRGenRule;
+struct E_IRGenRule
+{
+  String8 name;
+  E_IRGenFunctionType *irgen;
+};
+
+typedef struct E_IRGenRuleNode E_IRGenRuleNode;
+struct E_IRGenRuleNode
+{
+  E_IRGenRuleNode *next;
+  E_IRGenRule v;
+};
+
+typedef struct E_IRGenRuleSlot E_IRGenRuleSlot;
+struct E_IRGenRuleSlot
+{
+  E_IRGenRuleNode *first;
+  E_IRGenRuleNode *last;
+};
+
+typedef struct E_IRGenRuleMap E_IRGenRuleMap;
+struct E_IRGenRuleMap
+{
+  U64 slots_count;
+  E_IRGenRuleSlot *slots;
+};
+
+////////////////////////////////
+//~ rjf: Used Tag Map Data Structure
+
+typedef struct E_UsedTagNode E_UsedTagNode;
+struct E_UsedTagNode
+{
+  E_UsedTagNode *next;
+  E_UsedTagNode *prev;
+  E_Expr *tag;
+};
+
+typedef struct E_UsedTagSlot E_UsedTagSlot;
+struct E_UsedTagSlot
+{
+  E_UsedTagNode *first;
+  E_UsedTagNode *last;
+};
+
+typedef struct E_UsedTagMap E_UsedTagMap;
+struct E_UsedTagMap
+{
+  U64 slots_count;
+  E_UsedTagSlot *slots;
+};
+
 ////////////////////////////////
 //~ rjf: Parse Context
 
@@ -151,6 +213,8 @@ struct E_IRCtx
 {
   E_String2ExprMap *macro_map;
   E_LookupRuleMap *lookup_rule_map;
+  E_IRGenRuleMap *irgen_rule_map;
+  E_UsedTagMap *used_tag_map;
 };
 
 ////////////////////////////////
@@ -165,6 +229,11 @@ local_persist read_only E_LookupRule e_lookup_rule__default =
   E_LOOKUP_ID_FROM_NUM_FUNCTION_NAME(default),
   E_LOOKUP_NUM_FROM_ID_FUNCTION_NAME(default),
 };
+local_persist read_only E_IRGenRule e_irgen_rule__default =
+{
+  str8_lit_comp("default"),
+  E_IRGEN_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;
 
@@ -189,6 +258,15 @@ internal void e_lookup_rule_map_insert(Arena *arena, E_LookupRuleMap *map, E_Loo
 
 internal E_LookupRule *e_lookup_rule_from_string(String8 string);
 
+////////////////////////////////
+//~ rjf: IR Gen Rules
+
+internal E_IRGenRuleMap e_irgen_rule_map_make(Arena *arena, U64 slots_count);
+internal void e_irgen_rule_map_insert(Arena *arena, E_IRGenRuleMap *map, E_IRGenRule *rule);
+#define e_irgen_rule_map_insert_new(arena, map, name_, ...) e_irgen_rule_map_insert((arena), (map), &(E_IRGenRule){.name = (name_), __VA_ARGS__})
+
+internal E_IRGenRule *e_irgen_rule_from_string(String8 string);
+
 ////////////////////////////////
 //~ rjf: IR-ization Functions
 
@@ -221,11 +299,10 @@ internal E_IRNode *e_irtree_convert_hi(Arena *arena, E_IRNode *c, E_TypeKey out,
 internal E_IRNode *e_irtree_resolve_to_value(Arena *arena, E_Mode from_mode, E_IRNode *tree, E_TypeKey type_key);
 
 //- rjf: top-level irtree/type extraction
-internal E_IRTreeAndType e_irtree_and_type_from_expr__space(Arena *arena, E_Space *current_space, E_Expr *expr);
 internal E_IRTreeAndType e_irtree_and_type_from_expr(Arena *arena, E_Expr *expr);
 
 //- rjf: irtree -> linear ops/bytecode
-internal void e_append_oplist_from_irtree(Arena *arena, E_IRNode *root, E_OpList *out);
+internal void e_append_oplist_from_irtree(Arena *arena, E_IRNode *root, E_Space *current_space, E_OpList *out);
 internal E_OpList e_oplist_from_irtree(Arena *arena, E_IRNode *root);
 internal String8 e_bytecode_from_oplist(Arena *arena, E_OpList *oplist);
 

src/eval/eval_ir.h

@@ -15,6 +15,7 @@ global read_only String8 e_multichar_symbol_strings[] =
   str8_lit_comp("!="),
   str8_lit_comp("&&"),
   str8_lit_comp("||"),
+  str8_lit_comp("=>"),
 };
 
 global read_only S64 e_max_precedence = 15;
@@ -649,7 +650,7 @@ internal E_Expr *
 e_push_expr(Arena *arena, E_ExprKind kind, void *location)
 {
   E_Expr *e = push_array(arena, E_Expr, 1);
-  e->first = e->last = e->next = e->ref = &e_expr_nil;
+  e->first = e->last = e->next = e->ref = e->first_tag = e->last_tag = &e_expr_nil;
   e->location = location;
   e->kind = kind;
   return e;
@@ -673,6 +674,12 @@ e_expr_remove_child(E_Expr *parent, E_Expr *child)
   DLLRemove_NPZ(&e_expr_nil, parent->first, parent->last, child, next, prev);
 }
 
+internal void
+e_expr_push_tag(E_Expr *parent, E_Expr *child)
+{
+  DLLPushBack_NPZ(&e_expr_nil, parent->first_tag, parent->last_tag, child, next, prev);
+}
+
 internal E_Expr *
 e_expr_ref(Arena *arena, E_Expr *ref)
 {
@@ -744,6 +751,78 @@ e_expr_ref_bswap(Arena *arena, E_Expr *rhs)
   return root;
 }
 
+internal E_Expr *
+e_expr_copy(Arena *arena, E_Expr *src)
+{
+  E_Expr *result = &e_expr_nil;
+  Temp scratch = scratch_begin(&arena, 1);
+  {
+    typedef struct Task Task;
+    struct Task
+    {
+      Task *next;
+      E_Expr *dst_parent;
+      E_Expr *src;
+      B32 is_ref;
+      B32 is_tag;
+    };
+    Task start_task = {0, &e_expr_nil, src};
+    Task *first_task = &start_task;
+    Task *last_task = first_task;
+    for(Task *t = first_task; t != 0; t = t->next)
+    {
+      E_Expr *dst = e_push_expr(arena, t->src->kind, t->src->location);
+      dst->mode      = t->src->mode;
+      dst->space     = t->src->space;
+      dst->type_key  = t->src->type_key;
+      dst->value     = t->src->value;
+      dst->string    = push_str8_copy(arena, t->src->string);
+      dst->bytecode  = push_str8_copy(arena, t->src->bytecode);
+      if(t->dst_parent == &e_expr_nil)
+      {
+        result = dst;
+      }
+      else if(t->is_ref)
+      {
+        t->dst_parent->ref = dst;
+      }
+      else if(t->is_tag)
+      {
+        e_expr_push_tag(t->dst_parent, dst);
+      }
+      else
+      {
+        e_expr_push_child(t->dst_parent, dst);
+      }
+      if(t->src->ref != &e_expr_nil)
+      {
+        Task *task = push_array(scratch.arena, Task, 1);
+        task->dst_parent = dst;
+        task->src = t->src->ref;
+        task->is_ref = 1;
+        SLLQueuePush(first_task, last_task, task);
+      }
+      for(E_Expr *src_child = t->src->first; src_child != &e_expr_nil; src_child = src_child->next)
+      {
+        Task *task = push_array(scratch.arena, Task, 1);
+        task->dst_parent = dst;
+        task->src = src_child;
+        SLLQueuePush(first_task, last_task, task);
+      }
+      for(E_Expr *src_child = t->src->first_tag; src_child != &e_expr_nil; src_child = src_child->next)
+      {
+        Task *task = push_array(scratch.arena, Task, 1);
+        task->dst_parent = dst;
+        task->src = src_child;
+        task->is_tag = 1;
+        SLLQueuePush(first_task, last_task, task);
+      }
+    }
+  }
+  scratch_end(scratch);
+  return result;
+}
+
 ////////////////////////////////
 //~ rjf: Expression Tree -> String Conversions
 
@@ -1943,6 +2022,44 @@ e_parse_expr_from_text_tokens__prec(Arena *arena, String8 text, E_TokenArray *to
       }
     }
 
+    // rjf: calls
+    if(token.kind == E_TokenKind_Symbol &&
+       str8_match(token_string, str8_lit("("), 0))
+    {
+      it += 1;
+      E_Expr *callee_expr = atom;
+      E_Expr *call_expr = e_push_expr(arena, E_ExprKind_Call, token_string.str);
+      e_expr_push_child(call_expr, callee_expr);
+      for(B32 done = 0; !done && it < it_opl;)
+      {
+        E_Token token = e_token_at_it(it, tokens);
+        String8 token_string = str8_substr(text, token.range);
+        if(token.kind == E_TokenKind_Symbol && str8_match(token_string, str8_lit(")"), 0))
+        {
+          done = 1;
+          it += 1;
+        }
+        else
+        {
+          E_TokenArray idx_expr_parse_tokens = e_token_array_make_first_opl(it, it_opl);
+          E_Parse arg_parse = e_parse_expr_from_text_tokens__prec(arena, text, tokens, e_max_precedence);
+          e_msg_list_concat_in_place(&result.msgs, &arg_parse.msgs);
+          if(arg_parse.expr != &e_expr_nil)
+          {
+            e_expr_push_child(call_expr, arg_parse.expr);
+          }
+          it = arg_parse.last_token;
+          E_Token maybe_comma = e_token_at_it(it, tokens);
+          String8 maybe_comma_string = str8_substr(text, token.range);
+          if(maybe_comma.kind == E_TokenKind_Symbol && str8_match(maybe_comma_string, str8_lit(","), 0))
+          {
+            it += 1;
+          }
+        }
+      }
+      atom = call_expr;
+    }
+    
     // rjf: quit if this doesn't look like any patterns of postfix unary we know
     if(!is_postfix_unary)
     {
@@ -2100,6 +2217,46 @@ e_parse_expr_from_text_tokens__prec(Arena *arena, String8 text, E_TokenArray *to
       }
     }
 
+    //- rjf: parse tags
+    {
+      if(token.kind == E_TokenKind_Symbol && str8_match(token_string, str8_lit("=>"), 0))
+      {
+        for(B32 done = 0; !done && it < it_opl;)
+        {
+          E_Token maybe_identifier = e_token_at_it(it, tokens);
+          E_Token maybe_open_paren = e_token_at_it(it+1, tokens);
+          String8 maybe_open_paren_string = str8_substr(text, maybe_open_paren.range);
+          if(maybe_identifier.kind == E_TokenKind_Identifier &&
+             maybe_open_paren.kind == E_TokenKind_Symbol &&
+             str8_match(maybe_open_paren_string, str8_lit("("), 0))
+          {
+            E_TokenArray tag_tokens = e_token_array_make_first_opl(it, it_opl);
+            E_Parse tag_parse = e_parse_expr_from_text_tokens(arena, text, &tag_tokens);
+            e_msg_list_concat_in_place(&result.msgs, &tag_parse.msgs);
+            it = tag_parse.last_token;
+            if(tag_parse.expr != &e_expr_nil)
+            {
+              e_expr_push_tag(atom, tag_parse.expr);
+            }
+            else
+            {
+              done = 1;
+            }
+            E_Token maybe_comma = e_token_at_it(it, tokens);
+            String8 maybe_comma_string = str8_substr(text, token.range);
+            if(maybe_comma.kind == E_TokenKind_Symbol && str8_match(maybe_comma_string, str8_lit(","), 0))
+            {
+              it += 1;
+            }
+          }
+          else
+          {
+            done = 1;
+          }
+        }
+      }
+    }
+    
     // rjf: if we parsed nothing successfully, we're done
     if(it == start_it)
     {