a couple fixes

Author: UplinkCoder

cache/cached_tree.c

@@ -13,7 +13,7 @@ typedef struct counted_string
     uint32_t size;
 } counted_string;
 
-
+#define LENGTH_SHIFT 16
 #if 0
 counted_string StripLastComponent(counted_string *path)
 {
@@ -35,7 +35,7 @@ meta_data_entry_t* LookupDirPathByKey(cache_t* cache, const char* dir_path,
 {
     uint32_t toc_size = cache->toc_size;
     meta_data_entry_t* result = 0;
-    size_t path_length = (entry_key >> 16);
+    size_t path_length = (entry_key >> LENGTH_SHIFT);
 
     toc_entry_t* one_past_last = cache->toc_entries + toc_size;
     for(toc_entry_t* toc_entry = cache->toc_entries;
@@ -111,7 +111,7 @@ name_cache_ptr_t GetOrAddNameByKey(cache_t* cache, const char* name,
                                    uint32_t entry_key)
 {
 	name_cache_ptr_t result = {0};
-    size_t length = (entry_key >> 16);
+    size_t length = (entry_key >> LENGTH_SHIFT);
     if (!length)
         return result;
 
@@ -228,7 +228,7 @@ meta_data_entry_t* LookupInDirectoryByKey(cache_t* cache, cached_dir_t* lookupDi
 {
     meta_data_entry_t* result = 0;
 
-    const size_t name_length = (entry_key >> 16);
+    const size_t name_length = (entry_key >> LENGTH_SHIFT);
 
     meta_data_entry_t const * one_past_last_entry =
         lookupDir->entries + lookupDir->entries_size;

parser/metac_preproc.c

@@ -441,6 +441,10 @@ void MetaCPreProcessor_Init(metac_preprocessor_t *self, metac_lexer_t* lexer,
                             metac_alloc_t* alloc,
                             metac_file_storage_t* fs, const char* filepath)
 {
+    {
+        metac_preprocessor_t zero = {0};
+        *self = zero;
+    }
     self->FileStorage = fs;
     if (filepath)
         self->File = MetaCFileStorage_LoadFile(fs, filepath);

semantic/metac_expr_semantic.c

@@ -466,23 +466,29 @@ void ResolveIdentifierToExp(metac_sema_state_t* self,
     }
     else if (node->Kind == node_decl_type_struct)
     {
+        metac_type_aggregate_t* t_agg = cast(metac_type_aggregate_t*)node;
         result->Kind = expr_type;
         result->TypeExp.v =
-            TYPE_INDEX_V(type_index_struct, StructIndex(self, cast(metac_type_aggregate_t*)node));
+            TYPE_INDEX_V(type_index_struct, StructIndex(self, t_agg));
         result->TypeIndex.v = TYPE_INDEX_V(type_index_basic, type_type);
+        // hash = t_agg->Hash; ? where is hash
     }
     else if (node->Kind == node_decl_type_typedef)
     {
+        metac_type_typedef_t* t_def = cast(metac_type_typedef_t*)node;
         result->Kind = expr_type;
         result->TypeExp.v =
-            TYPE_INDEX_V(type_index_typedef, TypedefIndex(self, cast(metac_type_typedef_t*)node));
+            TYPE_INDEX_V(type_index_typedef, TypedefIndex(self, t_def));
+        result->TypeIndex.v = TYPE_INDEX_V(type_index_basic, type_type);
+        // hash = t_def->Hash; // where is hash
     }
     else if (node->Kind == node_decl_function)
     {
         sema_decl_function_t* func = cast(sema_decl_function_t*) node;
         result->Kind = expr_function;
         result->Function = func;
         result->TypeIndex = func->TypeIndex;
+        hash = func->Hash;
     }
     else if (node->Kind == node_expr_unknown_value)
     {
@@ -1250,7 +1256,7 @@ metac_sema_expr_t* MetaCSemantic_doExprSemantic_(metac_sema_state_t* self,
             if (e1->TypeIndex.v == TYPE_INDEX_V(type_index_basic, type_type))
             {
                 // if the expression is any other kind of expression and it is of type type
-                // it indicates we want this sizeof be resolved at a later time
+                // it indicates we want this typeof be resolved at a later time
                 // possibly when calling a function
             }
 

semantic/metac_type_table.h

@@ -2,7 +2,7 @@
 #define _METAC_TYPE_TABLE_H_
 
 #include "../os/compat.h"
-#include "metac_type.h"
+#include "../semantic/metac_type.h"
 
 uint32_t EntangleInts(uint32_t a, uint32_t b);
 uint32_t UntangleInts(uint32_t tangled);
@@ -28,7 +28,7 @@ typedef struct  metac_type_table_t
     (A == B ? true : Expr_IsEqual_(A, B))
 
 bool Expr_IsEqual_(const struct metac_sema_expr_t* a,
-                         const struct metac_sema_expr_t* b);
+                   const struct metac_sema_expr_t* b);
 
 static inline const bool EnumSlotsEqual(const metac_type_table_slot_t* a,
                                         const metac_type_table_slot_t* b)
@@ -185,8 +185,8 @@ static inline const bool TupleSlotsEqual(const metac_type_table_slot_t* a,
    return result;
 }
 
-static inline const bool MetaCExpr_Equal(const metac_expr_t* a,
-                                         const metac_expr_t* b)
+static inline const bool MetaCExpr_Equal(const struct metac_expr_t* a,
+                                         const struct metac_expr_t* b)
 {
     // assert(0);
     return false;
@@ -215,7 +215,7 @@ static inline const bool TemplateSlotsEqual(const metac_type_table_slot_t* a,
        for(uint32_t i = 0; i < argumentCount; i++)
        {
            metac_expr_t argA = slotA->Arguments[i];
-           metac_expr_t argB = slotA->Arguments[i];
+           metac_expr_t argB = slotB->Arguments[i];
            if (argA.Hash != argB.Hash)
            {
                result = false;