Fix a couple of bugs

Author: UplinkCoder

codegen/metac_codegen.c

@@ -896,9 +896,10 @@ void MetaCCodegen_doDeref(metac_bytecode_ctx_t* ctx,
                           metac_type_index_t varType,
                           BCValue* result)
 {
-    {
-        assert(!"doDeref not implemented right now");
-    }
+    BackendInterface gen = *ctx->gen;
+    void* c = ctx->c;
+    // this only works for pointers to 32bit basic types
+    gen.Load32(c, result, addr);
 }
 
 static void MetaCCodegen_doCastExpr(metac_bytecode_ctx_t* ctx,
@@ -1011,7 +1012,7 @@ static void MetaCCodegen_doArrowExpr(metac_bytecode_ctx_t* ctx,
     metac_type_index_kind_t aggKind = type_index_invalid;
     metac_type_aggregate_field_t* field = 0;
     metac_type_index_t aggTypeIndex;
-    BCType addrType = {BCTypeEnum_Ptr};
+    BCType addrType = {BCTypeEnum_i32};
     BCValue addr;
     BCValue e1Value = {BCValueType_Unknown};
     BCValue offsetVal = {BCValueType_Unknown};

compiler_intrinsics/metac_compiler_interface.c

@@ -75,25 +75,6 @@ metac_node_t compiler_ResolveNode(struct metac_compiler_t* compilerP, const char
 
 
 
-    uint32_t (*CurrentTimeStamp) ();
-   
-    const char* (*Help) ();
-
-    void (*Message) (struct metac_compiler_t* compilerP,
-                     const char* str);
-
-    void (*Error) (struct metac_compiler_t* compilerP,
-                   const char* str);
-
-    type_kind_t (*GetTypeKind) (struct metac_compiler_t* compilerP, type* T);
-
-    void (*PrintInt) (int32_t value);
-
-    metac_enum_members_t* (*GetEnumMembers) (struct metac_compiler_t* compilerP, type* T);
-
-    metac_node_t (*ResolveNode)(struct metac_compiler_t* compilerP, const char* name);
-
-
 metac_compiler_t compiler = {
     0,
 
@@ -112,5 +93,6 @@ metac_compiler_t compiler = {
     compiler_ResolveNode,
 
      "v0.1",
+     20260205,
 };
 

compiler_intrinsics/metac_compiler_interface.h

@@ -5,6 +5,9 @@
   typedef void* type;
 #  endif
 
+typedef unsigned int uint32_t;
+typedef int int32_t;
+
 typedef enum type_kind_t
 {
     TypeKind_Invalid,
@@ -43,7 +46,9 @@ typedef struct metac_compiler_t
     metac_node_t (*ResolveNode)(struct metac_compiler_t* compilerP, const char* name);
 
     const char* Version;
+    unsigned int IntVersion;
 } metac_compiler_t;
+//    uint32_t ;
 
 /* Proposed Interface:
 typedef struct {

libinterpret/bc_common.c

@@ -589,6 +589,30 @@ EXTERN_C bool BCValue_isStackValueOrParameter(const BCValue* val)
 #define VM_SIZE_RO_METADATA       (256 * 1024 * 1024)
 #define VM_LIMIT_RECURSION        2000
 
+uint32_t AddressFrom(address_kind_t kind, uint32_t offset)
+{
+    uint32_t result = 0;
+    switch (kind)
+    {
+        case AddressKind_Heap: {
+            result = VM_ADDR_HEAP_START + offset;
+        } break;
+        case AddressKind_Stack: {
+            result = VM_ADDR_STACK_START + offset;
+        } break;
+        case AddressKind_Register: {
+            result = VM_ADDR_REG_PAGE + offset;
+        } break;
+        case AddressKind_ROMetadata: {
+            result = VM_ADDR_RO_METADATA + offset;
+        } break;
+        case AddressKind_External: {
+            result = VM_ADDR_EXTERNAL_START + offset;
+        } break;
+        default : assert(0);
+    }
+    return result;
+}
 
 address_kind_t ClassifyAddress(uint32_t addr, uint32_t* out_offset)
 {
@@ -607,7 +631,7 @@ address_kind_t ClassifyAddress(uint32_t addr, uint32_t* out_offset)
     else if (top == 0)
     {
         // Stack grows up, starts at 0x4000
-        if (addr >= VM_ADDR_STACK_START) 
+        if (addr >= VM_ADDR_STACK_START)
         {
             kind   = AddressKind_Stack;
             offset = addr - VM_ADDR_STACK_START;
@@ -618,10 +642,10 @@ address_kind_t ClassifyAddress(uint32_t addr, uint32_t* out_offset)
              // kind = AddressKind_Invalid; // Guard Hit
         }
         // 4KB Register Page (0x2000 - 0x2FFF)
-        else if (addr >= 0x2000)
+        else if (addr >= VM_ADDR_REG_PAGE)
         {
             kind   = AddressKind_Register;
-            offset = addr - 0x2000;
+            offset = addr - VM_ADDR_REG_PAGE;
         }
         // 8KB NULL trap (0x0000 - 0x1FFF)
         else
@@ -635,7 +659,7 @@ address_kind_t ClassifyAddress(uint32_t addr, uint32_t* out_offset)
     {
         // Shadow Return Stack (dedicated for 32-bit return addresses)
         // this is address invalid
-        if (addr < VM_ADDR_RETURN_STACK) 
+        if (addr < VM_ADDR_RETURN_STACK)
         {
             // kind   = AddressKind_ReturnStack;
             // offset = addr - VM_ADDR_RETURN_STACK;
@@ -658,7 +682,7 @@ address_kind_t ClassifyAddress(uint32_t addr, uint32_t* out_offset)
     else if (top <= 32)
     {
         kind   = AddressKind_External;
-        offset = VM_ADDR_EXTERNAL_START;
+        offset = addr - VM_ADDR_EXTERNAL_START;
     }
 
     *out_offset = offset;

libinterpret/bc_common.h

@@ -219,18 +219,6 @@ typedef struct CndJmpBegin
     bool ifTrue;
 } CndJmpBegin;
 
-// heap address 00 - 10
-// external address 10
-// stack address 11
-
-
-#define AddrMask  ((1U << 31) | \
-                   (1U << 30))
-
-#define stackAddrMask  ((1U << 31) | (1U << 30))
-#define externalAddrMask (1U << 31 | 0U << 30)
-#define heapAddrMask (0U << 31 | 0U << 30)
-
 typedef enum address_kind_t
 {
     AddressKind_Invalid,

libinterpret/bc_interpreter_backend.c

@@ -1949,7 +1949,7 @@ BCValue BCGen_interpret(BCGen* self, uint32_t fnIdx, BCValue* args, uint32_t n_a
 
                 external.size = mapSize;
                 external.addr = (void*) addrInt;
-                external.mapAddr = state.mapPtr | externalAddrMask;
+                external.mapAddr = AddressFrom(AddressKind_External, state.mapPtr);
                 state.mapPtr += align4(external.size);
 
                 state.externals[state.externalsCount++] = external;

repl/completion_trie.c

@@ -456,7 +456,6 @@ void CompletionTrie_Add(completion_trie_root_t* root, const char* word, uint32_t
     completion_trie_node_t* parentNode =
         CompletionTrie_FindLongestMatchingPrefix(root, word, &remaining_length);
 
-
     if (remaining_length)
     {
         int posWord = length - remaining_length;

repl/repl.c

@@ -306,6 +306,7 @@ void Presemantic_(repl_state_t* self)
     {
         metac_lpp_t tmpLpp;
         decl_array_t decls = {0};
+        AddIdentifierToCompletion(self, "Compiler");
         {
             MetaCLPP_Init(&tmpLpp, &PresemanticAlloc, 0);
 #if 1

semantic/metac_type_semantic.c

@@ -1135,7 +1135,7 @@ metac_type_index_t MetaCSemantic_TypeSemantic(metac_sema_state_t* self,
 
         metac_type_typedef_t key = {
             {decl_type_typedef, 0, hash},
-            zeroIdx, elementTypeIndex, typedef_->Identifier
+            zeroIdx, elementTypeIndex, semaId
         };
 
         result =