Add wrappers for malloc/realloc/free. See #43.

diff --git a/Makefile b/Makefile
index 5dfbb7f96f1187f5483dcf3e4fb42d8ea4e0ddaf..cbaf5040ca410e332d8e7692f555a4e0a254b71d 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -24,7 +24,7 @@ version.gen.h: VERSION
        sed 's/.*/#define JQ_VERSION "&"/' $^ > $@
 main.c: version.gen.h
 
-JQ_SRC=parser.gen.c lexer.gen.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c jv_aux.c
+JQ_SRC=parser.gen.c lexer.gen.c opcode.c bytecode.c compile.c execute.c builtin.c jv.c jv_parse.c jv_print.c jv_dtoa.c jv_unicode.c jv_aux.c jv_alloc.c
 
 jq_test: CFLAGS += -DJQ_DEBUG=1
 jq_test: $(JQ_SRC) jq_test.c

diff --git a/bytecode.c b/bytecode.c
index e66bffbb291d43f6466589491feecc10afabe95a..39381204eb8cfeaa1a86d756dea57fb01d2a158c 100644 (file)
--- a/bytecode.c
+++ b/bytecode.c
@@ -4,6 +4,7 @@
 
 #include "bytecode.h"
 #include "opcode.h"
+#include "jv_alloc.h"
 
 static int bytecode_operation_length(uint16_t* codeptr) {
   int length = opcode_describe(*codeptr)->length;
@@ -72,17 +73,17 @@ void dump_operation(struct bytecode* bc, uint16_t* codeptr) {
 }
 
 void symbol_table_free(struct symbol_table* syms) {
-  free(syms->cfunctions);
-  free(syms);
+  jv_mem_free(syms->cfunctions);
+  jv_mem_free(syms);
 }
 
 void bytecode_free(struct bytecode* bc) {
-  free(bc->code);
+  jv_mem_free(bc->code);
   jv_free(bc->constants);
   for (int i=0; i<bc->nsubfunctions; i++)
     bytecode_free(bc->subfunctions[i]);
   if (!bc->parent)
     symbol_table_free(bc->globals);
-  free(bc->subfunctions);
-  free(bc);
+  jv_mem_free(bc->subfunctions);
+  jv_mem_free(bc);
 }

diff --git a/compile.c b/compile.c
index 3a094721b92007fd42f0fe1fc02ee078374df658..139b64bc2e34ce50e91064fcbe4c512a0a59d724 100644 (file)
--- a/compile.c
+++ b/compile.c
@@ -1,3 +1,4 @@
+#define _GNU_SOURCE // for strdup
 #include <assert.h>
 #include <string.h>
 #include <stdlib.h>
@@ -5,6 +6,7 @@
 #include "compile.h"
 #include "bytecode.h"
 #include "locfile.h"
+#include "jv_alloc.h"
 
 /*
   The intermediate representation for jq filters is as a sequence of
@@ -57,7 +59,7 @@ struct inst {
 };
 
 static inst* inst_new(opcode op) {
-  inst* i = malloc(sizeof(inst));
+  inst* i = jv_mem_alloc(sizeof(inst));
   i->next = i->prev = 0;
   i->op = op;
   i->bytecode_pos = -1;
@@ -70,13 +72,13 @@ static inst* inst_new(opcode op) {
 }
 
 static void inst_free(struct inst* i) {
-  free(i->symbol);
+  jv_mem_free(i->symbol);
   block_free(i->subfn);
   block_free(i->arglist);
   if (opcode_describe(i->op)->flags & OP_HAS_CONSTANT) {
     jv_free(i->imm.constant);
   }
-  free(i);
+  jv_mem_free(i);
 }
 
 static block inst_block(inst* i) {
@@ -546,10 +548,10 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
     }
   }
   if (bc->nsubfunctions) {
-    bc->subfunctions = malloc(sizeof(struct bytecode*) * bc->nsubfunctions);
+    bc->subfunctions = jv_mem_alloc(sizeof(struct bytecode*) * bc->nsubfunctions);
     for (inst* curr = b.first; curr; curr = curr->next) {
       if (curr->op == CLOSURE_CREATE) {
-        struct bytecode* subfn = malloc(sizeof(struct bytecode));
+        struct bytecode* subfn = jv_mem_alloc(sizeof(struct bytecode));
         bc->subfunctions[curr->imm.intval] = subfn;
         subfn->globals = bc->globals;
         subfn->parent = bc;
@@ -568,7 +570,7 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
     bc->subfunctions = 0;
   }
   bc->codelen = pos;
-  uint16_t* code = malloc(sizeof(uint16_t) * bc->codelen);
+  uint16_t* code = jv_mem_alloc(sizeof(uint16_t) * bc->codelen);
   bc->code = code;
   pos = 0;
   jv constant_pool = jv_array();
@@ -620,13 +622,13 @@ static int compile(struct locfile* locations, struct bytecode* bc, block b) {
 }
 
 int block_compile(block b, struct locfile* locations, struct bytecode** out) {
-  struct bytecode* bc = malloc(sizeof(struct bytecode));
+  struct bytecode* bc = jv_mem_alloc(sizeof(struct bytecode));
   bc->parent = 0;
   bc->nclosures = 0;
-  bc->globals = malloc(sizeof(struct symbol_table));
+  bc->globals = jv_mem_alloc(sizeof(struct symbol_table));
   int ncfunc = count_cfunctions(b);
   bc->globals->ncfunctions = 0;
-  bc->globals->cfunctions = malloc(sizeof(struct cfunction) * ncfunc);
+  bc->globals->cfunctions = jv_mem_alloc(sizeof(struct cfunction) * ncfunc);
   int nerrors = compile(locations, bc, b);
   assert(bc->globals->ncfunctions == ncfunc);
   if (nerrors > 0) {

diff --git a/execute.c b/execute.c
index 8b8036a1f48f51bf7fac2988df5d3a507cb3a1b0..a4719aae24762549bef081cdaa04c8bf58d62ccd 100644 (file)
--- a/execute.c
+++ b/execute.c
@@ -11,6 +11,7 @@
 #include "forkable_stack.h"
 #include "frame_layout.h"
 
+#include "jv_alloc.h"
 #include "locfile.h"
 #include "jv.h"
 #include "jv_aux.h"
@@ -33,7 +34,7 @@ int path_push(stackval sv, jv val) {
   if (pos == pathsize) {
     int oldpathsize = pathsize;
     pathsize = oldpathsize ? oldpathsize * 2 : 100;
-    pathbuf = realloc(pathbuf, sizeof(pathbuf[0]) * pathsize);
+    pathbuf = jv_mem_realloc(pathbuf, sizeof(pathbuf[0]) * pathsize);
     for (int i=oldpathsize; i<pathsize; i++) {
       pathbuf[i] = jv_invalid();
     }
@@ -491,7 +492,7 @@ void jq_teardown() {
   for (int i=0; i<pathsize; i++) {
     jv_free(pathbuf[i]);
   }
-  free(pathbuf);
+  jv_mem_free(pathbuf);
   pathbuf = 0;
   pathsize = 0;
 }

diff --git a/forkable_stack.h b/forkable_stack.h
index a94a1ec347f5d8dfe06b68331d9a6dadea84782e..041bfac48388fdf8690b70a836e00b8105e8668c 100644 (file)
--- a/forkable_stack.h
+++ b/forkable_stack.h
@@ -1,9 +1,9 @@
 #ifndef FORKABLE_STACK_H
 #define FORKABLE_STACK_H
-#include <stdlib.h>
 #include <stddef.h>
 #include <assert.h>
 #include <string.h>
+#include "jv_alloc.h"
 
 struct forkable_stack_header {
   /* distance in bytes between this header and the header
@@ -18,7 +18,7 @@ struct forkable_stack {
   char* stk;
 
   // stk+length is just past end of allocated area
-  // stk = malloc(length)
+  // stk = jv_mem_alloc(length)
   int length;
 
   // stk+pos is header of top object, or stk+length if empty
@@ -40,7 +40,7 @@ static int forkable_stack_empty(struct forkable_stack* s) {
 }
 
 static void forkable_stack_init(struct forkable_stack* s, size_t sz) {
-  s->stk = malloc(sz);
+  s->stk = jv_mem_alloc(sz);
   s->length = sz;
   s->pos = s->length;
   s->savedlimit = s->length;
@@ -50,7 +50,7 @@ static void forkable_stack_init(struct forkable_stack* s, size_t sz) {
 static void forkable_stack_free(struct forkable_stack* s) {
   assert(forkable_stack_empty(s));
   assert(s->savedlimit == s->length);
-  free(s->stk);
+  jv_mem_free(s->stk);
   s->stk = 0;
 }
 
@@ -62,7 +62,7 @@ static void* forkable_stack_push(struct forkable_stack* s, size_t sz_size) {
   if (curr - size < 0) {
     int oldlen = s->length;
     s->length = (size + oldlen + 1024) * 2;
-    s->stk = realloc(s->stk, s->length);
+    s->stk = jv_mem_realloc(s->stk, s->length);
     int shift = s->length - oldlen;
     memmove(s->stk + shift, s->stk, oldlen);
     s->pos += shift;

diff --git a/jv.c b/jv.c
index 77937a8dde405ebc23af55d8aa164bb10e44fecc..abbeb6d43890f81c8e7e9bafbbcd4b5efe1bf583 100644 (file)
--- a/jv.c
+++ b/jv.c
@@ -6,6 +6,7 @@
 #include <string.h>
 #include <stdarg.h>
 
+#include "jv_alloc.h"
 #include "jv.h"
 
 /*
@@ -86,7 +87,7 @@ jv jv_invalid_with_msg(jv err) {
   jv x;
   x.kind = JV_KIND_INVALID;
   x.val.complex.i[0] = x.val.complex.i[1] = 0;
-  jvp_invalid* i = malloc(sizeof(jvp_invalid));
+  jvp_invalid* i = jv_mem_alloc(sizeof(jvp_invalid));
   x.val.complex.ptr = &i->refcnt;
   i->refcnt.count = 1;
   i->errmsg = err;
@@ -113,7 +114,7 @@ int jv_invalid_has_msg(jv inv) {
 static void jvp_invalid_free(jv_complex* x) {
   if (jvp_refcnt_dec(x)) {
     jv_free(((jvp_invalid*)x->ptr)->errmsg);
-    free(x->ptr);
+    jv_mem_free(x->ptr);
   }
 }
 
@@ -157,7 +158,7 @@ static jvp_array* jvp_array_ptr(jv_complex* a) {
 }
 
 static jvp_array* jvp_array_alloc(unsigned size) {
-  jvp_array* a = malloc(sizeof(jvp_array) + sizeof(jv) * size);
+  jvp_array* a = jv_mem_alloc(sizeof(jvp_array) + sizeof(jv) * size);
   a->refcnt.count = 1;
   a->length = 0;
   a->alloc_length = size;
@@ -175,7 +176,7 @@ static void jvp_array_free(jv_complex* a) {
     for (int i=0; i<array->length; i++) {
       jv_free(array->elements[i]);
     }
-    free(array);
+    jv_mem_free(array);
   }
 }
 
@@ -371,7 +372,7 @@ static jvp_string* jvp_string_ptr(jv_complex* a) {
 }
 
 static jvp_string* jvp_string_alloc(uint32_t size) {
-  jvp_string* s = malloc(sizeof(jvp_string) + size + 1);
+  jvp_string* s = jv_mem_alloc(sizeof(jvp_string) + size + 1);
   s->refcnt.count = 1;
   s->alloc_length = size;
   return s;
@@ -389,7 +390,7 @@ static jv_complex jvp_string_new(const char* data, uint32_t length) {
 static void jvp_string_free(jv_complex* s) {
   if (jvp_refcnt_dec(s)) {
     jvp_string* str = jvp_string_ptr(s);
-    free(str);
+    jv_mem_free(str);
   }
 }
 
@@ -569,17 +570,17 @@ jv jv_string_append_str(jv a, const char* str) {
 jv jv_string_fmt(const char* fmt, ...) {
   int size = 1024;
   while (1) {
-    char* buf = malloc(size);
+    char* buf = jv_mem_alloc(size);
     va_list args;
     va_start(args, fmt);
     int n = vsnprintf(buf, size, fmt, args);
     va_end(args);
     if (n < size) {
       jv ret = jv_string_sized(buf, n);
-      free(buf);
+      jv_mem_free(buf);
       return ret;
     } else {
-      free(buf);
+      jv_mem_free(buf);
       size = n * 2;
     }
   }
@@ -609,9 +610,9 @@ static jv_complex jvp_object_new(int size) {
 
   // size must be a power of two
   assert(size > 0 && (size & (size - 1)) == 0);
-  jvp_object* obj = malloc(sizeof(jvp_object) + 
-                           sizeof(struct object_slot) * size +
-                           sizeof(int) * (size * 2));
+  jvp_object* obj = jv_mem_alloc(sizeof(jvp_object) + 
+                                 sizeof(struct object_slot) * size +
+                                 sizeof(int) * (size * 2));
   obj->refcnt.count = 1;
   for (int i=0; i<size; i++) {
     obj->elements[i].next = i - 1;
@@ -711,7 +712,7 @@ static void jvp_object_free(jv_complex* o) {
         jv_free(slot->value);
       }
     }
-    free(jvp_object_ptr(o));
+    jv_mem_free(jvp_object_ptr(o));
   }
 }
 
@@ -730,7 +731,7 @@ static void jvp_object_rehash(jv_complex* object) {
     new_slot->value = slot->value;
   }
   // references are transported, just drop the old table
-  free(jvp_object_ptr(object));
+  jv_mem_free(jvp_object_ptr(object));
   *object = new_object;
 }
 
@@ -1037,4 +1038,4 @@ int jv_contains(jv a, jv b) {
   jv_free(a);
   jv_free(b);
   return r;
-}
\ No newline at end of file
+}

diff --git a/jv_alloc.c b/jv_alloc.c
new file mode 100644 (file)
index 0000000..3e1c8fe
--- /dev/null
+++ b/jv_alloc.c
@@ -0,0 +1,15 @@
+#include <stdlib.h>
+#include "jv_alloc.h"
+
+
+void* jv_mem_alloc(size_t sz) {
+  return malloc(sz);
+}
+
+void jv_mem_free(void* p) {
+  free(p);
+}
+
+void* jv_mem_realloc(void* p, size_t sz) {
+  return realloc(p, sz);
+}

diff --git a/jv_alloc.h b/jv_alloc.h
new file mode 100644 (file)
index 0000000..0613d58
--- /dev/null
+++ b/jv_alloc.h
@@ -0,0 +1,10 @@
+#ifndef JV_ALLOC_H
+#define JV_ALLOC_H
+
+#include <stddef.h>
+
+void* jv_mem_alloc(size_t);
+void jv_mem_free(void*);
+__attribute__((warn_unused_result)) void* jv_mem_realloc(void*, size_t);
+
+#endif

diff --git a/jv_aux.c b/jv_aux.c
index 15bc3de7c45d1328810089744ab408c36deefac7..a4bfddd28c76e6cf7b850b11c8bae78e32641000 100644 (file)
--- a/jv_aux.c
+++ b/jv_aux.c
@@ -1,6 +1,7 @@
 #include "jv_aux.h"
 #include <string.h>
 #include <stdlib.h>
+#include "jv_alloc.h"
 
 jv jv_lookup(jv t, jv k) {
   jv v;
@@ -78,7 +79,7 @@ static int string_cmp(const void* pa, const void* pb){
 jv jv_keys(jv x) {
   if (jv_get_kind(x) == JV_KIND_OBJECT) {
     int nkeys = jv_object_length(jv_copy(x));
-    jv* keys = malloc(sizeof(jv) * nkeys);
+    jv* keys = jv_mem_alloc(sizeof(jv) * nkeys);
     int kidx = 0;
     jv_object_foreach(i, x) {
       keys[kidx++] = jv_object_iter_key(x, i);
@@ -88,7 +89,7 @@ jv jv_keys(jv x) {
     for (int i = 0; i<nkeys; i++) {
       answer = jv_array_append(answer, keys[i]);
     }
-    free(keys);
+    jv_mem_free(keys);
     jv_free(x);
     return answer;
   } else if (jv_get_kind(x) == JV_KIND_ARRAY) {
@@ -199,7 +200,7 @@ static struct sort_entry* sort_items(jv objects, jv keys) {
   assert(jv_get_kind(keys) == JV_KIND_ARRAY);
   assert(jv_array_length(jv_copy(objects)) == jv_array_length(jv_copy(keys)));
   int n = jv_array_length(jv_copy(objects));
-  struct sort_entry* entries = malloc(sizeof(struct sort_entry) * n);
+  struct sort_entry* entries = jv_mem_alloc(sizeof(struct sort_entry) * n);
   for (int i=0; i<n; i++) {
     entries[i].object = jv_array_get(jv_copy(objects), i);
     entries[i].key = jv_array_get(jv_copy(keys), i);
@@ -221,7 +222,7 @@ jv jv_sort(jv objects, jv keys) {
     jv_free(entries[i].key);
     ret = jv_array_set(ret, i, entries[i].object);
   }
-  free(entries);
+  jv_mem_free(entries);
   return ret;
 }
 
@@ -247,6 +248,6 @@ jv jv_group(jv objects, jv keys) {
   }
   jv_free(curr_key);
   ret = jv_array_append(ret, group);
-  free(entries);
+  jv_mem_free(entries);
   return ret;
 }

diff --git a/jv_dtoa.c b/jv_dtoa.c
index b200c462b9b55c8f8ed6e4fd1b6244d5bc9b6dd4..251a691606a01465707b7171d6b385401adfaf30 100644 (file)
--- a/jv_dtoa.c
+++ b/jv_dtoa.c
@@ -195,6 +195,11 @@
 
 #include "jv_dtoa.h"
 
+#include "jv_alloc.h"
+#define MALLOC jv_mem_alloc
+#define FREE jv_mem_free
+
+
 
 #ifndef Long
 #define Long long
@@ -572,7 +577,7 @@ void jvp_dtoa_context_free(struct dtoa_context* C) {
     while (C->freelist[k]) {
       Bigint* v = C->freelist[k];
       C->freelist[k] = v->next;
-      free(v);
+      FREE(v);
     }
   }
 }

diff --git a/jv_parse.c b/jv_parse.c
index 738beb940670b768301fb8c176e266949f628b3d..0d4f1549d87f6d5056c7d4b253e2fc9ddf068ea4 100644 (file)
--- a/jv_parse.c
+++ b/jv_parse.c
@@ -5,6 +5,7 @@
 #include "jv_dtoa.h"
 #include "jv_parse.h"
 #include "jv_unicode.h"
+#include "jv_alloc.h"
 
 typedef const char* presult;
 
@@ -32,8 +33,8 @@ void jv_parser_free(struct jv_parser* p) {
   jv_free(p->next);
   for (int i=0; i<p->stackpos; i++) 
     jv_free(p->stack[i]);
-  free(p->stack);
-  free(p->tokenbuf);
+  jv_mem_free(p->stack);
+  jv_mem_free(p->tokenbuf);
   jvp_dtoa_context_free(&p->dtoa);
 }
 
@@ -48,7 +49,7 @@ static void push(struct jv_parser* p, jv v) {
   assert(p->stackpos <= p->stacklen);
   if (p->stackpos == p->stacklen) {
     p->stacklen = p->stacklen * 2 + 10;
-    p->stack = realloc(p->stack, p->stacklen * sizeof(jv));
+    p->stack = jv_mem_realloc(p->stack, p->stacklen * sizeof(jv));
   }
   assert(p->stackpos < p->stacklen);
   p->stack[p->stackpos++] = v;
@@ -142,7 +143,7 @@ static void tokenadd(struct jv_parser* p, char c) {
   assert(p->tokenpos <= p->tokenlen);
   if (p->tokenpos == p->tokenlen) {
     p->tokenlen = p->tokenlen*2 + 256;
-    p->tokenbuf = realloc(p->tokenbuf, p->tokenlen);
+    p->tokenbuf = jv_mem_realloc(p->tokenbuf, p->tokenlen);
   }
   assert(p->tokenpos < p->tokenlen);
   p->tokenbuf[p->tokenpos++] = c;

diff --git a/lexer.l b/lexer.l
index b09ccce47634a4e1f06c26d627cb62133ab6d698..7090de31e9555cf8891f928dea90de0921ee278c 100644 (file)
--- a/lexer.l
+++ b/lexer.l
@@ -1,4 +1,5 @@
 %{
+#include "jv_alloc.h"
 #include "compile.h"
 
 struct lexer_param;
@@ -25,6 +26,7 @@ struct lexer_param;
 %}
 
 %option noyywrap nounput noinput nodefault
+%option noyyalloc noyyrealloc noyyfree
 %option reentrant
 %option extra-type="int"
 %option bison-bridge bison-locations
@@ -153,3 +155,13 @@ static int enter(int c, int currstate, yyscan_t yyscanner) {
   yy_push_state(state, yyscanner);
   return c;
 }
+
+void* yyalloc(size_t sz, void* extra) {
+  return jv_mem_alloc(sz);
+}
+void* yyrealloc(void* p, size_t sz, void* extra) {
+  return jv_mem_realloc(p, sz);
+}
+void yyfree(void* p, void* extra) {
+  jv_mem_free(p);
+}

diff --git a/locfile.h b/locfile.h
index 77b1aef1d7eb92343dccd5c2262406be55fa20ce..710cfbd1d733e4a8c0a897fed729acf2a8ad836c 100644 (file)
--- a/locfile.h
+++ b/locfile.h
@@ -4,6 +4,7 @@
 #include <stdio.h>
 #include <assert.h>
 #include <stdarg.h>
+#include "jv_alloc.h"
 typedef struct {
   int start, end;
 } location;
@@ -24,7 +25,7 @@ static void locfile_init(struct locfile* l, const char* data, int length) {
   for (int i=0; i<length; i++) {
     if (data[i] == '\n') l->nlines++;
   }
-  l->linemap = malloc(sizeof(int) * (l->nlines + 1));
+  l->linemap = jv_mem_alloc(sizeof(int) * (l->nlines + 1));
   l->linemap[0] = 0;
   int line = 1;
   for (int i=0; i<length; i++) {
@@ -37,7 +38,7 @@ static void locfile_init(struct locfile* l, const char* data, int length) {
 }
 
 static void locfile_free(struct locfile* l) {
-  free(l->linemap);
+  jv_mem_free(l->linemap);
 }
 
 static int locfile_get_line(struct locfile* l, int pos) {

diff --git a/main.c b/main.c
index 252ebd5a13981054a1b7d63b898b6c722fc89ca1..711d03ad8f2c4044b3ace8d2238f89b965618c1b 100644 (file)
--- a/main.c
+++ b/main.c
@@ -1,3 +1,4 @@
+#define _POSIX_SOURCE
 #include <stdio.h>
 #include <errno.h>
 #include <string.h>
@@ -10,6 +11,7 @@
 #include "locfile.h"
 #include "parser.h"
 #include "execute.h"
+#include "jv_alloc.h"
 #include "version.gen.h"
 
 static const char* progname;
@@ -135,7 +137,7 @@ int main(int argc, char* argv[]) {
   if (argc) progname = argv[0];
 
   const char* program = 0;
-  input_filenames = malloc(sizeof(const char*) * argc);
+  input_filenames = jv_mem_alloc(sizeof(const char*) * argc);
   ninput_files = 0;
   int further_args_are_files = 0;
   for (int i=1; i<argc; i++) {
@@ -256,7 +258,7 @@ int main(int argc, char* argv[]) {
       process(slurped);
     }
   }
-  free(input_filenames);
+  jv_mem_free(input_filenames);
   bytecode_free(bc);
   return 0;
 }

diff --git a/parser.y b/parser.y
index a2c765cd170e531b3371653903103e33b6436fd0..807db7047128a00c7a8fb4af1004870aedf6d6f7 100644 (file)
--- a/parser.y
+++ b/parser.y
@@ -2,6 +2,9 @@
 #include <stdio.h>
 #include <string.h>
 #include "compile.h"
+#include "jv_alloc.h"
+#define YYMALLOC jv_mem_alloc
+#define YYFREE jv_mem_free
 
 struct lexer_param;