Refactor map functions and fix problem on Windows

src/alloc.c

@@ -278,13 +278,15 @@ static void *key_block_alloc(struct BlockAllocator *a, uint32_t nblocks)
     }
 }
 
-#define COMPUTE_NBLOCKS(nbytes) CHECK_EXP(BLOCK_SIZE == 8 && (nbytes) > 12, \
-                                          ((nbytes) + 11) / BLOCK_SIZE)
+#define TOO_MANY_BLOCKS(nbytes) ((nbytes + 11) / BLOCK_SIZE > UINT32_MAX)
+#define COMPUTE_NUM_BLOCKS(nbytes) CHECK_EXP(BLOCK_SIZE == 8 && (nbytes) > 12, \
+                                             ((nbytes) + 11) / BLOCK_SIZE)
 
 // Modified from SQLite (mem3.c)
 static void *block_malloc(struct BlockAllocator *a, size_t nbytes)
 {
-    uint32_t nblocks = COMPUTE_NBLOCKS(nbytes);
+    if (TOO_MANY_BLOCKS(nbytes)) return NULL;
+    uint32_t nblocks = COMPUTE_NUM_BLOCKS(nbytes);
     paw_assert(nblocks >= 2);
 
     // search for an exact fit
@@ -327,7 +329,8 @@ static void *block_malloc(struct BlockAllocator *a, size_t nbytes)
 // Modified from SQLite (mem3.c)
 static void block_free(struct BlockAllocator *a, void *ptr, size_t nbytes)
 {
-    uint32_t nblocks = COMPUTE_NBLOCKS(nbytes);
+    paw_assert(!TOO_MANY_BLOCKS(nbytes));
+    uint32_t nblocks = COMPUTE_NUM_BLOCKS(nbytes);
     paw_assert(nblocks >= 2);
     struct Block *b = ptr;
     paw_assert(b > a->blocks && b < &a->blocks[a->nblocks]);

src/api.c

@@ -319,7 +319,7 @@ int paw_call(paw_Env *P, int argc)
 
 int paw_get_count(paw_Env *P)
 {
-    return P->top.p - P->cf->base.p;
+    return CAST(P->top.p - P->cf->base.p, int);
 }
 
 static int upvalue_index(int nup, int index)

src/call.c

@@ -105,7 +105,7 @@ void pawC_stack_grow(paw_Env *P, int n)
 {
     paw_assert(n > 0);
     paw_assert(P->bound.p >= P->stack.p);
-    const int alloc = CAST_SIZE(P->bound.p - P->stack.p);
+    const int alloc = CAST(P->bound.p - P->stack.p, int);
     pawC_stack_realloc(P, NEXT_ALLOC(alloc, n));
 }
 

src/codegen.c

@@ -1246,7 +1246,7 @@ static void add_builtin_func(struct Generator *G, const char *name)
     const int g = pawE_new_global(P, str);
     GlobalVar *gv = pawE_get_global(P, g);
     const Value key = {.o = CAST_OBJECT(str)};
-    const Value *pv = pawH_get_(P->builtin, key);
+    const Value *pv = pawH_get(P->builtin, key);
     gv->value = *pv;
 }
 

src/compile.c

@@ -29,7 +29,7 @@ paw_Type pawP_type2code(struct Compiler *C, struct HirType *type)
 String *pawP_scan_nstring(paw_Env *P, Map *st, const char *s, size_t n)
 {
     const Value *pv = pawC_pushns(P, s, n);
-    Value *value = pawH_action(P, st, *pv, MAP_ACTION_CREATE);
+    Value *value = pawH_create(P, st, *pv);
     *value = *pv; // anchor in map
     pawC_pop(P);
     CHECK_GC(P);

src/hir.h

@@ -33,7 +33,7 @@ struct Resolver;
         X(CallExpr,       call)   \
         X(Index,          index)  \
         X(Selector,       select) \
-        X(StructField,     sitem)  \
+        X(StructField,    sitem)  \
         X(MapElem,        mitem)
 
 #define HIR_TYPE_LIST(X)    \

src/lib.c

@@ -392,9 +392,9 @@ static int string_clone(paw_Env *P)
 
 static int map_get(paw_Env *P)
 {
-    const Value key = CF_BASE(1 /*TODO*/ + 1);
-    Map *m = v_map(CF_BASE(0 /*TODO*/ + 1));
-    const Value *pv = pawH_get(P, m, key);
+    Map *m = v_map(CF_BASE(1));
+    const Value key = CF_BASE(2);
+    const Value *pv = pawH_get(m, key);
     if (pv != NULL) {
         // replace default value
         P->top.p[-1] = *pv;
@@ -404,14 +404,14 @@ static int map_get(paw_Env *P)
 
 static int map_erase(paw_Env *P)
 {
-    Map *m = v_map(CF_BASE(0 /*TODO*/ + 1));
-    pawH_remove(P, m, CF_BASE(1 /*TODO*/ + 1));
+    Map *m = v_map(CF_BASE(1));
+    pawH_erase(m, CF_BASE(2));
     return 0;
 }
 
 static int map_clone(paw_Env *P)
 {
-    Map *m = v_map(CF_BASE(0 /*TODO*/ + 1));
+    Map *m = v_map(CF_BASE(1));
     Value *pv = pawC_push0(P);
     pawH_clone(P, pv, m);
     return 1;
@@ -468,10 +468,9 @@ static paw_Bool load_cached(paw_Env *P, const char *name)
     paw_push_string(P, name);
     const Value key = P->top.p[-1];
 
-    Value *pvalue = pawH_get(P, P->libs, key);
-    if (!pvalue) {
-        return PAW_FALSE;
-    }
+    Value *pvalue = pawH_get(P->libs, key);
+    if (pvalue == NULL) return PAW_FALSE;
+
     // replace library name
     pawC_pushv(P, *pvalue);
     paw_shift(P, 1);

src/map.c

@@ -57,6 +57,7 @@ static void rehash_map(Map old_m, Map *m)
     const size_t count = m->length;
     m->length = 0;
     for (size_t i = 0; m->length < count; ++i) {
+        paw_assert(i < old_m.capacity);
         if (mm[i].state == MAP_ITEM_OCCUPIED) {
             add_item(m, ks[i], vs[i]);
         }
@@ -141,7 +142,7 @@ paw_Bool pawH_equals(paw_Env *P, Map *lhs, Map *rhs)
     }
     MapCursor mc = {lhs, 0};
     while (mc.index < lhs->capacity) {
-        Value *v = pawH_action(P, rhs, *h_cursor_key(&mc), MAP_ACTION_NONE);
+        Value *v = pawH_get(rhs, *h_cursor_key(&mc));
         if (v == NULL || !items_equal(*h_cursor_value(&mc), *v)) {
             return PAW_FALSE;
         }
@@ -156,7 +157,7 @@ void pawH_extend(paw_Env *P, Map *dst, Map *src)
     while (mc.index < src->capacity) {
         if (h_get_state(&mc) != MAP_ITEM_OCCUPIED) {
             const Value key = *h_cursor_key(&mc);
-            Value *value = pawH_action(P, dst, key, MAP_ACTION_CREATE);
+            Value *value = pawH_create(P, dst, key);
             *value = *h_cursor_value(&mc);
         }
         ++mc.index;

src/map.h

@@ -86,83 +86,37 @@ static inline size_t pawH_length(const Map *m)
     return m->length; 
 }
 
-static inline Value *pawH_get_(Map *m, Value key)
+static inline Value *pawH_get(Map *m, Value key)
 {
-    if (m->length == 0) {
-        return NULL;
-    }
+    if (m->length == 0) return NULL;
     MapCursor mc = h_cursor_lookup(m, key);
-    if (h_is_occupied(&mc)) {
-        return h_cursor_value(&mc);
-    }
-    return NULL;
-}
-
-
-typedef enum MapAction {
-    MAP_ACTION_NONE,
-    MAP_ACTION_CREATE,
-    MAP_ACTION_REMOVE,
-} MapAction;
-
-static inline Value *pawH_action(paw_Env *P, Map *m, Value key,
-                                 MapAction action)
-{
-    if (action == MAP_ACTION_CREATE) {
-        return pawH_create(P, m, key);
-    } else if (m->length == 0) {
-        return NULL;
-    }
-    MapCursor mc = h_cursor_lookup(m, key);
-    if (!h_is_occupied(&mc)) {
-        return NULL;
-    }
-    if (action == MAP_ACTION_REMOVE) {
-        h_set_state(&mc, MAP_ITEM_ERASED);
-        --m->length;
-
-        // Return the address of the slot to indicate success.
-        return h_cursor_key(&mc);
-    }
-    paw_assert(action == MAP_ACTION_NONE);
+    if (!h_is_occupied(&mc)) return NULL;
     return h_cursor_value(&mc);
 }
 
-static inline paw_Bool pawH_contains(paw_Env *P, Map *m, Value key)
+static inline void pawH_erase(Map *m, Value key)
 {
-    return pawH_action(P, m, key, MAP_ACTION_NONE) != NULL;
+    if (m->length == 0) return;
+    MapCursor mc = h_cursor_lookup(m, key);
+    if (!h_is_occupied(&mc)) return;
+    h_set_state(&mc, MAP_ITEM_ERASED);
+    --m->length;
 }
 
 static inline void pawH_insert(paw_Env *P, Map *m, Value key, Value value)
 {
-    Value *slot = pawH_action(P, m, key, MAP_ACTION_CREATE);
-    if (!slot) {
-        pawH_key_error(P, key, PAW_TSTRING); // TODO: key type
-    }
-    *slot = value;
-}
-
-static inline void pawH_remove(paw_Env *P, Map *m, Value key)
-{
-    if (!pawH_action(P, m, key, MAP_ACTION_REMOVE)) {
-        pawH_key_error(P, key, PAW_TSTRING); // TODO: key type
-    }
-}
-
-static inline Value *pawH_get(paw_Env *P, Map *m, Value key)
-{
-    return pawH_action(P, m, key, MAP_ACTION_NONE);
+    *pawH_create(P, m, key) = value;
 }
 
-static inline void pawH_set(paw_Env *P, Map *m, Value key, Value value)
+static inline paw_Bool pawH_contains(Map *m, Value key)
 {
-    *pawH_get(P, m, key) = value;
+    return pawH_get(m, key) != NULL;
 }
 
-static inline paw_Bool pawH_iter(const Map *m, paw_Int *itr)
+static inline paw_Bool pawH_iter(const Map *m, paw_Int *pi)
 {
-    for (++*itr; *itr < paw_cast_int(m->capacity); ++*itr) {
-        const MapMeta *mm = pawH_meta(m, *itr);
+    for (++*pi; *pi < paw_cast_int(m->capacity); ++*pi) {
+        const MapMeta *mm = pawH_meta(m, *pi);
         if (mm->state == MAP_ITEM_OCCUPIED) {
             return PAW_TRUE;
         }

src/resolve.c

@@ -1604,19 +1604,19 @@ static struct HirType *resolve_composite_lit(struct Resolver *R, struct AstCompo
         struct HirExpr *hir_item = resolve_expr(R, ast_item);
         struct HirStructField *item = HirGetStructField(hir_item);
         v_set_object(&key, item->name);
-        if (pawH_contains(P, map, key)) {
+        if (pawH_contains(map, key)) {
             NAME_ERROR(R, hir_item->hdr.line, "duplicate field '%s' in initializer for struct '%s'", 
                        item->name->text, pack.name->text);
         }
-        Value *value = pawH_action(P, map, key, MAP_ACTION_CREATE);
+        Value *value = pawH_create(P, map, key);
         v_set_int(value, i);
         pawHir_expr_list_push(R->hir, order, hir_item);
     }
     for (int i = 0; i < pack.fields->count; ++i) {
         struct HirDecl *decl = pack.fields->data[i];
         struct HirFieldDecl *field = HirGetFieldDecl(decl);
         v_set_object(&key, field->name);
-        Value *value = pawH_get(P, map, key);
+        Value *value = pawH_get(map, key);
         if (value == NULL) {
             NAME_ERROR(R, field->line, "missing initializer for field '%s' in struct '%s'",
                        field->name->text, pack.name->text);
@@ -1629,7 +1629,7 @@ static struct HirType *resolve_composite_lit(struct Resolver *R, struct AstCompo
         struct HirType *item_t = expr_type(R, item);
         item->sitem.index = i;
         unify(R, item_t, field_t);
-        pawH_remove(P, map, key);
+        pawH_erase(map, key);
     }
     paw_Int iter = PAW_ITER_INIT;
     while (pawH_iter(map, &iter)) {

src/rt.c

@@ -695,7 +695,7 @@ static void other_binop(paw_Env *P, BinaryOp binop, paw_Type t, Value x,
             v_set_bool(pv, pawV_vec_contains(P, v_vector(y), x));
         } else {
             paw_assert(t == PAW_TMAP);
-            v_set_bool(pv, pawH_contains(P, v_map(y), x));
+            v_set_bool(pv, pawH_contains(v_map(y), x));
         }
         vm_pop(1);
     } else if (t == PAW_TSTRING) {
@@ -803,7 +803,7 @@ static void getitem_vector(paw_Env *P, Vector *vector, paw_Int index)
 
 static int getitem_map(paw_Env *P, Map *map, Value key)
 {
-    const Value *pv = pawH_get(P, map, key);
+    const Value *pv = pawH_get(map, key);
     if (pv) {
         *vm_top(2) = *pv;
         vm_pop(1);

src/value.h

@@ -331,7 +331,7 @@ typedef enum MapState {
 } MapState;
 
 typedef struct MapMeta {
-    MapState state : 2;
+    uint8_t state : 2;
 } MapMeta;
 
 typedef struct Map {