Change memory allocation API to require size for free and realloc.

dpgeorge · dpgeorge · commit 732407f1bf12 · 2013-12-29T19:33:23.000Z
diff --git a/py/asmthumb.c b/py/asmthumb.c
@@ -44,7 +44,7 @@ asm_thumb_t *asm_thumb_new(uint max_num_labels) {
 
 void asm_thumb_free(asm_thumb_t *as, bool free_code) {
     if (free_code) {
-        m_free(as->code_base);
+        m_del(byte, as->code_base, as->code_size);
     }
     /*
     if (as->label != NULL) {
@@ -58,7 +58,7 @@ void asm_thumb_free(asm_thumb_t *as, bool free_code) {
         g_array_free(as->label, true);
     }
     */
-    m_free(as);
+    m_del_obj(asm_thumb_t, as);
 }
 
 void asm_thumb_start_pass(asm_thumb_t *as, int pass) {
diff --git a/py/asmx64.c b/py/asmx64.c
@@ -128,7 +128,7 @@ void asm_x64_free(asm_x64_t* as, bool free_code) {
         g_array_free(as->label, true);
     }
     */
-    m_free(as);
+    m_del_obj(asm_x64_t, as);
 }
 
 void asm_x64_start_pass(asm_x64_t *as, int pass) {
diff --git a/py/builtin.c b/py/builtin.c
@@ -158,7 +158,7 @@ mp_obj_t mp_builtin_chr(mp_obj_t o_in) {
         char *str = m_new(char, 2);
         str[0] = ord;
         str[1] = '\0';
-        return mp_obj_new_str(qstr_from_str_take(str));
+        return mp_obj_new_str(qstr_from_str_take(str, 2));
     } else {
         nlr_jump(mp_obj_new_exception_msg(rt_q_ValueError, "chr() arg not in range(0x110000)"));
     }
diff --git a/py/compile.c b/py/compile.c
@@ -1184,7 +1184,7 @@ void do_import_name(compiler_t *comp, mp_parse_node_t pn, qstr *q1, qstr *q2) {
                 }
                 strcat(str, qstr_str(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i])));
             }
-            *q2 = qstr_from_str_take(str);
+            *q2 = qstr_from_str_take(str, len + 1);
             EMIT(import_name, *q2);
             if (is_as) {
                 for (int i = 1; i < n; i++) {
@@ -2127,7 +2127,7 @@ void compile_atom_string(compiler_t *comp, mp_parse_node_struct_t *pns) {
         strcat(cat_str, str);
     }
 
-    EMIT(load_const_str, qstr_from_str_take(cat_str), string_kind == MP_PARSE_NODE_BYTES);
+    EMIT(load_const_str, qstr_from_str_take(cat_str, n_bytes + 1), string_kind == MP_PARSE_NODE_BYTES);
 }
 
 // pns needs to have 2 nodes, first is lhs of comprehension, second is PN_comp_for node
@@ -3105,7 +3105,7 @@ bool mp_compile(mp_parse_node_t pn, bool is_repl) {
         }
     }
 
-    m_free(comp);
+    m_del_obj(compiler_t, comp);
 
     return !comp->had_error;
 }
diff --git a/py/emitpass1.c b/py/emitpass1.c
@@ -26,7 +26,7 @@ emit_t *emit_pass1_new(qstr qstr___class__) {
 }
 
 void emit_pass1_free(emit_t *emit) {
-    m_free(emit);
+    m_del_obj(emit_t, emit);
 }
 
 static void emit_pass1_dummy(emit_t *emit) {
diff --git a/py/lexer.c b/py/lexer.c
@@ -183,8 +183,8 @@ static void next_char(mp_lexer_t *lex) {
 
 void indent_push(mp_lexer_t *lex, uint indent) {
     if (lex->num_indent_level >= lex->alloc_indent_level) {
+        lex->indent_level = m_renew(uint16_t, lex->indent_level, lex->alloc_indent_level, lex->alloc_indent_level * 2);
         lex->alloc_indent_level *= 2;
-        lex->indent_level = m_renew(uint16_t, lex->indent_level, lex->alloc_indent_level);
     }
     lex->indent_level[lex->num_indent_level++] = indent;
 }
@@ -639,7 +639,7 @@ void mp_lexer_free(mp_lexer_t *lex) {
             lex->stream_close(lex->stream_data);
         }
         vstr_clear(&lex->vstr);
-        m_free(lex);
+        m_del_obj(mp_lexer_t, lex);
     }
 }
 
diff --git a/py/lexerunix.c b/py/lexerunix.c
@@ -24,9 +24,9 @@ unichar str_buf_next_char(str_buf_t *sb) {
 void str_buf_free(str_buf_t *sb) {
     if (sb) {
         if (sb->free) {
-            m_free((char*)sb->src_beg);
+            m_del(char, (char*)sb->src_beg, 0 /* unknown size of src_beg */);
         }
-        m_free(sb);
+        m_del_obj(str_buf_t, sb);
     }
 }
 
@@ -52,7 +52,7 @@ mp_lexer_t *mp_lexer_new_from_file(const char *filename) {
     close(fd);
     if (read_size != size) {
         printf("error reading file %s\n", filename);
-        m_free(data);
+        m_del(char, data, size);
         return NULL;
     }
 
diff --git a/py/malloc.c b/py/malloc.c
@@ -5,12 +5,6 @@
 
 static int total_bytes_allocated = 0;
 
-void m_free(void *ptr) {
-    if (ptr != NULL) {
-        free(ptr);
-    }
-}
-
 void *m_malloc(int num_bytes) {
     if (num_bytes == 0) {
         return NULL;
@@ -37,20 +31,26 @@ void *m_malloc0(int num_bytes) {
     return ptr;
 }
 
-void *m_realloc(void *ptr, int num_bytes) {
-    if (num_bytes == 0) {
+void *m_realloc(void *ptr, int old_num_bytes, int new_num_bytes) {
+    if (new_num_bytes == 0) {
         free(ptr);
         return NULL;
     }
-    ptr = realloc(ptr, num_bytes);
+    ptr = realloc(ptr, new_num_bytes);
     if (ptr == NULL) {
-        printf("could not allocate memory, reallocating %d bytes\n", num_bytes);
+        printf("could not allocate memory, reallocating %d bytes\n", new_num_bytes);
         return NULL;
     }
-    total_bytes_allocated += num_bytes;
+    total_bytes_allocated += new_num_bytes;
     return ptr;
 }
 
+void m_free(void *ptr, int num_bytes) {
+    if (ptr != NULL) {
+        free(ptr);
+    }
+}
+
 int m_get_total_bytes_allocated(void) {
     return total_bytes_allocated;
 }
diff --git a/py/map.c b/py/map.c
@@ -64,7 +64,7 @@ mp_map_elem_t* mp_map_lookup_helper(mp_map_t *map, mp_obj_t index, bool add_if_n
                             mp_map_lookup_helper(map, old_table[i].key, true)->value = old_table[i].value;
                         }
                     }
-                    m_free(old_table);
+                    m_del(mp_map_elem_t, old_table, old_alloc);
                     // restart the search for the new element
                     pos = hash % map->alloc;
                 } else {
@@ -124,7 +124,7 @@ mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, bool add_if_not_found) {
                             mp_set_lookup(set, old_table[i], true);
                         }
                     }
-                    m_free(old_table);
+                    m_del(mp_obj_t, old_table, old_alloc);
                     // restart the search for the new element
                     pos = hash % set->alloc;
                 } else {
diff --git a/py/misc.h b/py/misc.h
@@ -16,16 +16,20 @@ typedef unsigned int uint;
 
 /** memomry allocation ******************************************/
 
+// TODO make a lazy m_renew that can increase by a smaller amount than requested (but by at least 1 more element)
+
 #define m_new(type, num) ((type*)(m_malloc(sizeof(type) * (num))))
 #define m_new0(type, num) ((type*)(m_malloc0(sizeof(type) * (num))))
-#define m_renew(type, ptr, num) ((type*)(m_realloc((ptr), sizeof(type) * (num))))
 #define m_new_obj(type) (m_new(type, 1))
 #define m_new_obj_var(obj_type, var_type, var_num) ((obj_type*)m_malloc(sizeof(obj_type) + sizeof(var_type) * (var_num)))
+#define m_renew(type, ptr, old_num, new_num) ((type*)(m_realloc((ptr), sizeof(type) * (old_num), sizeof(type) * (new_num))))
+#define m_del(type, ptr, num) m_free(ptr, sizeof(type) * (num))
+#define m_del_obj(type, ptr) (m_del(type, ptr, 1))
 
-void m_free(void *ptr);
 void *m_malloc(int num_bytes);
 void *m_malloc0(int num_bytes);
-void *m_realloc(void *ptr, int num_bytes);
+void *m_realloc(void *ptr, int old_num_bytes, int new_num_bytes);
+void m_free(void *ptr, int num_bytes);
 
 int m_get_total_bytes_allocated(void);
 
@@ -96,7 +100,7 @@ typedef unsigned int qstr;
 
 void qstr_init(void);
 qstr qstr_from_str_static(const char *str);
-qstr qstr_from_str_take(char *str);
+qstr qstr_from_str_take(char *str, int alloc_len);
 qstr qstr_from_strn_copy(const char *str, int len);
 const char* qstr_str(qstr qstr);
 
diff --git a/py/objclass.c b/py/objclass.c
@@ -37,7 +37,7 @@ mp_obj_t class_call_n(mp_obj_t self_in, int n_args, const mp_obj_t *args) {
             memcpy(args2, args, n_args * sizeof(mp_obj_t));
             args2[n_args] = o;
             init_ret = rt_call_function_n(init_fn->value, n_args + 1, args2);
-            m_free(args2);
+            m_del(mp_obj_t, args2, n_args + 1);
         }
         if (init_ret != mp_const_none) {
             nlr_jump(mp_obj_new_exception_msg_1_arg(rt_q_TypeError, "__init__() should return None, not '%s'", mp_obj_get_type_str(init_ret)));
diff --git a/py/objfun.c b/py/objfun.c
@@ -58,7 +58,7 @@ mp_obj_t fun_native_call_n(mp_obj_t self_in, int n_args, const mp_obj_t *args) {
         }
 
         mp_obj_t res = ((mp_fun_var_t)self->fun)(n_args, args_ordered);
-        m_free(args_ordered);
+        m_del(mp_obj_t, args_ordered, n_args);
 
         return res;
     }
diff --git a/py/objlist.c b/py/objlist.c
@@ -57,8 +57,8 @@ mp_obj_t mp_obj_list_append(mp_obj_t self_in, mp_obj_t arg) {
     assert(MP_OBJ_IS_TYPE(self_in, &list_type));
     mp_obj_list_t *self = self_in;
     if (self->len >= self->alloc) {
+        self->items = m_renew(mp_obj_t, self->items, self->alloc, self->alloc * 2);
         self->alloc *= 2;
-        self->items = m_renew(mp_obj_t, self->items, self->alloc);
     }
     self->items[self->len++] = arg;
     return mp_const_none; // return None, as per CPython
diff --git a/py/objstr.c b/py/objstr.c
@@ -36,9 +36,10 @@ mp_obj_t str_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
             if (MP_OBJ_IS_TYPE(rhs_in, &str_type)) {
                 // add 2 strings
                 const char *rhs_str = qstr_str(((mp_obj_str_t*)rhs_in)->qstr);
-                char *val = m_new(char, strlen(lhs_str) + strlen(rhs_str) + 1);
+                int alloc_len = strlen(lhs_str) + strlen(rhs_str) + 1;
+                char *val = m_new(char, alloc_len);
                 stpcpy(stpcpy(val, lhs_str), rhs_str);
-                return mp_obj_new_str(qstr_from_str_take(val));
+                return mp_obj_new_str(qstr_from_str_take(val, alloc_len));
             }
             break;
     }
@@ -78,7 +79,7 @@ mp_obj_t str_join(mp_obj_t self_in, mp_obj_t arg) {
         }
         strcat(joined_str, s2);
     }
-    return mp_obj_new_str(qstr_from_str_take(joined_str));
+    return mp_obj_new_str(qstr_from_str_take(joined_str, required_len + 1));
 
 bad_arg:
     nlr_jump(mp_obj_new_exception_msg(rt_q_TypeError, "?str.join expecting a list of str's"));
@@ -115,7 +116,7 @@ mp_obj_t str_format(int n_args, const mp_obj_t *args) {
         }
     }
 
-    return mp_obj_new_str(qstr_from_str_take(vstr->buf));
+    return mp_obj_new_str(qstr_from_str_take(vstr->buf, vstr->alloc));
 }
 
 static MP_DEFINE_CONST_FUN_OBJ_2(str_join_obj, str_join);
diff --git a/py/parse.c b/py/parse.c
@@ -94,8 +94,8 @@ typedef struct _parser_t {
 
 static void push_rule(parser_t *parser, const rule_t *rule, int arg_i) {
     if (parser->rule_stack_top >= parser->rule_stack_alloc) {
+        parser->rule_stack = m_renew(rule_stack_t, parser->rule_stack, parser->rule_stack_alloc, parser->rule_stack_alloc * 2);
         parser->rule_stack_alloc *= 2;
-        parser->rule_stack = m_renew(rule_stack_t, parser->rule_stack, parser->rule_stack_alloc);
     }
     parser->rule_stack[parser->rule_stack_top].rule_id = rule->rule_id;
     parser->rule_stack[parser->rule_stack_top].arg_i = arg_i;
diff --git a/py/qstr.c b/py/qstr.c
@@ -16,8 +16,8 @@ void qstr_init(void) {
 
 static qstr qstr_add(const char *str) {
     if (qstrs_len >= qstrs_alloc) {
+        qstrs = m_renew(const char*, qstrs, qstrs_alloc, qstrs_alloc * 2);
         qstrs_alloc *= 2;
-        qstrs = m_renew(const char*, qstrs, qstrs_alloc);
     }
     qstrs[qstrs_len++] = str;
     return qstrs_len - 1;
@@ -32,10 +32,10 @@ qstr qstr_from_str_static(const char *str) {
     return qstr_add(str);
 }
 
-qstr qstr_from_str_take(char *str) {
+qstr qstr_from_str_take(char *str, int alloc_len) {
     for (int i = 0; i < qstrs_len; i++) {
         if (strcmp(qstrs[i], str) == 0) {
-            m_free(str);
+            m_del(char, str, alloc_len);
             return i;
         }
     }
diff --git a/py/scope.c b/py/scope.c
@@ -69,8 +69,8 @@ id_info_t *scope_find_or_add_id(scope_t *scope, qstr qstr, bool *added) {
 
     // make sure we have enough memory
     if (scope->id_info_len >= scope->id_info_alloc) {
+        scope->id_info = m_renew(id_info_t, scope->id_info, scope->id_info_alloc, scope->id_info_alloc * 2);
         scope->id_info_alloc *= 2;
-        scope->id_info = m_renew(id_info_t, scope->id_info, scope->id_info_alloc);
     }
 
     id_info_t *id_info;
diff --git a/py/vstr.c b/py/vstr.c
@@ -11,7 +11,6 @@ void vstr_init(vstr_t *vstr) {
     vstr->len = 0;
     vstr->buf = m_new(char, vstr->alloc);
     if (vstr->buf == NULL) {
-        m_free(vstr);
         vstr->had_error = true;
         return;
     }
@@ -20,7 +19,7 @@ void vstr_init(vstr_t *vstr) {
 }
 
 void vstr_clear(vstr_t *vstr) {
-    m_free(vstr->buf);
+    m_del(char, vstr->buf, vstr->alloc);
     vstr->buf = NULL;
 }
 
@@ -35,8 +34,8 @@ vstr_t *vstr_new(void) {
 
 void vstr_free(vstr_t *vstr) {
     if (vstr != NULL) {
-        m_free(vstr->buf);
-        m_free(vstr);
+        m_del(char, vstr->buf, vstr->alloc);
+        m_del_obj(vstr_t, vstr);
     }
 }
 
@@ -67,7 +66,7 @@ int vstr_len(vstr_t *vstr) {
 bool vstr_ensure_extra(vstr_t *vstr, int size) {
     if (vstr->len + size + 1 > vstr->alloc) {
         int new_alloc = ROUND_ALLOC((vstr->len + size + 1) * 2);
-        char *new_buf = m_renew(char, vstr->buf, new_alloc);
+        char *new_buf = m_renew(char, vstr->buf, vstr->alloc, new_alloc);
         if (new_buf == NULL) {
             vstr->had_error = true;
             return false;
diff --git a/stm/lexerstm.c b/stm/lexerstm.c
@@ -17,7 +17,7 @@ unichar str_buf_next_char(mp_lexer_str_buf_t *sb) {
 
 void str_buf_free(mp_lexer_str_buf_t *sb) {
     if (sb->free) {
-        m_free((char*)sb->src_beg);
+        m_del(char, (char*)sb->src_beg, 0 /* don't know allocated size of src */);
     }
 }
 
diff --git a/stm/main.c b/stm/main.c
@@ -706,7 +706,7 @@ mp_obj_t file_obj_read(mp_obj_t self_in, mp_obj_t arg) {
     UINT n_out;
     f_read(&self->fp, buf, n, &n_out);
     buf[n_out] = 0;
-    return mp_obj_new_str(qstr_from_str_take(buf));
+    return mp_obj_new_str(qstr_from_str_take(buf, n + 1));
 }
 
 mp_obj_t file_obj_write(mp_obj_t self_in, mp_obj_t arg) {
diff --git a/stm/pybwlan.c b/stm/pybwlan.c
@@ -191,7 +191,7 @@ mp_obj_t pyb_wlan_http_get(mp_obj_t host_name, mp_obj_t host_path) {
             vstr_add_strn(vstr, buf, ret);
         }
 
-        mp_ret = mp_obj_new_str(qstr_from_str_take(vstr_str(vstr)));
+        mp_ret = mp_obj_new_str(qstr_from_str_take(vstr->buf, vstr->alloc));
     }
 
     closesocket(sd);
diff --git a/unix/main.c b/unix/main.c
@@ -1,6 +1,7 @@
 #include <stdint.h>
 #include <stdio.h>
 #include <string.h>
+#include <malloc.h>
 
 #include "nlr.h"
 #include "misc.h"
@@ -44,8 +45,8 @@ static void do_repl(void) {
                     break;
                 }
                 char *line3 = str_join(line, '\n', line2);
-                m_free(line);
-                m_free(line2);
+                free(line);
+                free(line2);
                 line = line3;
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ asm_thumb_t *asm_thumb_new(uint max_num_labels) {`
`44`	`44`
`45`	`45`	`void asm_thumb_free(asm_thumb_t *as, bool free_code) {`
`46`	`46`	`if (free_code) {`
`47`		`- m_free(as->code_base);`
	`47`	`+ m_del(byte, as->code_base, as->code_size);`
`48`	`48`	`}`
`49`	`49`	`/*`
`50`	`50`	`if (as->label != NULL) {`
`@@ -58,7 +58,7 @@ void asm_thumb_free(asm_thumb_t *as, bool free_code) {`
`58`	`58`	`g_array_free(as->label, true);`
`59`	`59`	`}`
`60`	`60`	`*/`
`61`		`- m_free(as);`
	`61`	`+ m_del_obj(asm_thumb_t, as);`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`void asm_thumb_start_pass(asm_thumb_t *as, int pass) {`
Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,7 @@ void asm_x64_free(asm_x64_t* as, bool free_code) {`
`128`	`128`	`g_array_free(as->label, true);`
`129`	`129`	`}`
`130`	`130`	`*/`
`131`		`- m_free(as);`
	`131`	`+ m_del_obj(asm_x64_t, as);`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`void asm_x64_start_pass(asm_x64_t *as, int pass) {`
Original file line number	Diff line number	Diff line change
`@@ -158,7 +158,7 @@ mp_obj_t mp_builtin_chr(mp_obj_t o_in) {`
`158`	`158`	`char *str = m_new(char, 2);`
`159`	`159`	`str[0] = ord;`
`160`	`160`	`str[1] = '\0';`
`161`		`- return mp_obj_new_str(qstr_from_str_take(str));`
	`161`	`+ return mp_obj_new_str(qstr_from_str_take(str, 2));`
`162`	`162`	`} else {`
`163`	`163`	`nlr_jump(mp_obj_new_exception_msg(rt_q_ValueError, "chr() arg not in range(0x110000)"));`
`164`	`164`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1184,7 +1184,7 @@ void do_import_name(compiler_t comp, mp_parse_node_t pn, qstr q1, qstr *q2) {`
`1184`	`1184`	`}`
`1185`	`1185`	`strcat(str, qstr_str(MP_PARSE_NODE_LEAF_ARG(pns->nodes[i])));`
`1186`	`1186`	`}`
`1187`		`- *q2 = qstr_from_str_take(str);`
	`1187`	`+ *q2 = qstr_from_str_take(str, len + 1);`
`1188`	`1188`	`EMIT(import_name, *q2);`
`1189`	`1189`	`if (is_as) {`
`1190`	`1190`	`for (int i = 1; i < n; i++) {`
`@@ -2127,7 +2127,7 @@ void compile_atom_string(compiler_t comp, mp_parse_node_struct_t pns) {`
`2127`	`2127`	`strcat(cat_str, str);`
`2128`	`2128`	`}`
`2129`	`2129`
`2130`		`- EMIT(load_const_str, qstr_from_str_take(cat_str), string_kind == MP_PARSE_NODE_BYTES);`
	`2130`	`+ EMIT(load_const_str, qstr_from_str_take(cat_str, n_bytes + 1), string_kind == MP_PARSE_NODE_BYTES);`
`2131`	`2131`	`}`
`2132`	`2132`
`2133`	`2133`	`// pns needs to have 2 nodes, first is lhs of comprehension, second is PN_comp_for node`
`@@ -3105,7 +3105,7 @@ bool mp_compile(mp_parse_node_t pn, bool is_repl) {`
`3105`	`3105`	`}`
`3106`	`3106`	`}`
`3107`	`3107`
`3108`		`- m_free(comp);`
	`3108`	`+ m_del_obj(compiler_t, comp);`
`3109`	`3109`
`3110`	`3110`	`return !comp->had_error;`
`3111`	`3111`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ emit_t *emit_pass1_new(qstr qstr___class__) {`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`void emit_pass1_free(emit_t *emit) {`
`29`		`- m_free(emit);`
	`29`	`+ m_del_obj(emit_t, emit);`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`static void emit_pass1_dummy(emit_t *emit) {`
Original file line number	Diff line number	Diff line change
`@@ -183,8 +183,8 @@ static void next_char(mp_lexer_t *lex) {`
`183`	`183`
`184`	`184`	`void indent_push(mp_lexer_t *lex, uint indent) {`
`185`	`185`	`if (lex->num_indent_level >= lex->alloc_indent_level) {`
	`186`	`+ lex->indent_level = m_renew(uint16_t, lex->indent_level, lex->alloc_indent_level, lex->alloc_indent_level * 2);`
`186`	`187`	`lex->alloc_indent_level *= 2;`
`187`		`- lex->indent_level = m_renew(uint16_t, lex->indent_level, lex->alloc_indent_level);`
`188`	`188`	`}`
`189`	`189`	`lex->indent_level[lex->num_indent_level++] = indent;`
`190`	`190`	`}`
`@@ -639,7 +639,7 @@ void mp_lexer_free(mp_lexer_t *lex) {`
`639`	`639`	`lex->stream_close(lex->stream_data);`
`640`	`640`	`}`
`641`	`641`	`vstr_clear(&lex->vstr);`
`642`		`- m_free(lex);`
	`642`	`+ m_del_obj(mp_lexer_t, lex);`
`643`	`643`	`}`
`644`	`644`	`}`
`645`	`645`
Original file line number	Diff line number	Diff line change
`@@ -24,9 +24,9 @@ unichar str_buf_next_char(str_buf_t *sb) {`
`24`	`24`	`void str_buf_free(str_buf_t *sb) {`
`25`	`25`	`if (sb) {`
`26`	`26`	`if (sb->free) {`
`27`		`- m_free((char*)sb->src_beg);`
	`27`	`+ m_del(char, (char)sb->src_beg, 0 / unknown size of src_beg */);`
`28`	`28`	`}`
`29`		`- m_free(sb);`
	`29`	`+ m_del_obj(str_buf_t, sb);`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`@@ -52,7 +52,7 @@ mp_lexer_t mp_lexer_new_from_file(const char filename) {`
`52`	`52`	`close(fd);`
`53`	`53`	`if (read_size != size) {`
`54`	`54`	`printf("error reading file %s\n", filename);`
`55`		`- m_free(data);`
	`55`	`+ m_del(char, data, size);`
`56`	`56`	`return NULL;`
`57`	`57`	`}`
`58`	`58`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ mp_map_elem_t* mp_map_lookup_helper(mp_map_t *map, mp_obj_t index, bool add_if_n`
`64`	`64`	`mp_map_lookup_helper(map, old_table[i].key, true)->value = old_table[i].value;`
`65`	`65`	`}`
`66`	`66`	`}`
`67`		`- m_free(old_table);`
	`67`	`+ m_del(mp_map_elem_t, old_table, old_alloc);`
`68`	`68`	`// restart the search for the new element`
`69`	`69`	`pos = hash % map->alloc;`
`70`	`70`	`} else {`
`@@ -124,7 +124,7 @@ mp_obj_t mp_set_lookup(mp_set_t *set, mp_obj_t index, bool add_if_not_found) {`
`124`	`124`	`mp_set_lookup(set, old_table[i], true);`
`125`	`125`	`}`
`126`	`126`	`}`
`127`		`- m_free(old_table);`
	`127`	`+ m_del(mp_obj_t, old_table, old_alloc);`
`128`	`128`	`// restart the search for the new element`
`129`	`129`	`pos = hash % set->alloc;`
`130`	`130`	`} else {`