Replaced glib memory allocation

src/parsers/action.c

@@ -23,10 +23,14 @@ static const HParserVtable action_vt = {
   .parse = parse_action,
 };
 
-const HParser* h_action(const HParser* p, const HAction a) { 
-  HParser *res = g_new(HParser, 1);
+const HParser* h_action(const HParser* p, const HAction a) {
+  return h_action__m(&system_allocator, p, a);
+}
+
+const HParser* h_action__m(HAllocator* mm__, const HParser* p, const HAction a) {
+  HParser *res = h_new(HParser, 1);
   res->vtable = &action_vt;
-  HParseAction *env = g_new(HParseAction, 1);
+  HParseAction *env = h_new(HParseAction, 1);
   env->p = p;
   env->action = a;
   res->env = (void*)env;

src/parsers/and.c

@@ -13,9 +13,13 @@ static const HParserVtable and_vt = {
   .parse = parse_and,
 };
 
+
 const HParser* h_and(const HParser* p) {
+  return h_and__m(&system_allocator, p);
+}
+const HParser* h_and__m(HAllocator* mm__, const HParser* p) {
   // zero-width postive lookahead
-  HParser *res = g_new(HParser, 1);
+  HParser *res = h_new(HParser, 1);
   res->env = (void*)p;
   res->vtable = &and_vt;
   return res;

src/parsers/attr_bool.c

@@ -21,10 +21,14 @@ static const HParserVtable attr_bool_vt = {
   .parse = parse_attr_bool,
 };
 
-const HParser* h_attr_bool(const HParser* p, HPredicate pred) { 
-  HParser *res = g_new(HParser, 1);
+
+const HParser* h_attr_bool(const HParser* p, HPredicate pred) {
+  return h_attr_bool__m(&system_allocator, p, pred);
+}
+const HParser* h_attr_bool__m(HAllocator* mm__, const HParser* p, HPredicate pred) { 
+  HParser *res = h_new(HParser, 1);
   res->vtable = &attr_bool_vt;
-  HAttrBool *env = g_new(HAttrBool, 1);
+  HAttrBool *env = h_new(HAttrBool, 1);
   env->p = p;
   env->pred = pred;
   res->env = (void*)env;

src/parsers/bits.c

@@ -20,18 +20,24 @@ static const HParserVtable bits_vt = {
   .parse = parse_bits,
 };
 const HParser* h_bits(size_t len, bool sign) {
-  struct bits_env *env = g_new(struct bits_env, 1);
+  return h_bits__m(&system_allocator, len, sign);
+}
+const HParser* h_bits__m(HAllocator* mm__, size_t len, bool sign) {
+  struct bits_env *env = h_new(struct bits_env, 1);
   env->length = len;
   env->signedp = sign;
-  HParser *res = g_new(HParser, 1);
+  HParser *res = h_new(HParser, 1);
   res->vtable = &bits_vt;
   res->env = env;
   return res;
 }
 
 #define SIZED_BITS(name_pre, len, signedp) \
-  const HParser* h_##name_pre##len () {	       \
-    return h_bits(len, signedp);	       \
+  const HParser* h_##name_pre##len () {				\
+    return h_bits__m(&system_allocator, len, signedp);		\
+  }								\
+  const HParser* h_##name_pre##len##__m(HAllocator* mm__) {	\
+    return h_bits__m(mm__, len, signedp);			\
   }
 SIZED_BITS(int, 8, true)
 SIZED_BITS(int, 16, true)

src/parsers/butnot.c

@@ -39,10 +39,13 @@ static const HParserVtable butnot_vt = {
   .parse = parse_butnot,
 };
 
-const HParser* h_butnot(const HParser* p1, const HParser* p2) { 
-  HTwoParsers *env = g_new(HTwoParsers, 1);
+const HParser* h_butnot(const HParser* p1, const HParser* p2) {
+  return h_butnot__m(&system_allocator, p1, p2);
+}
+const HParser* h_butnot__m(HAllocator* mm__, const HParser* p1, const HParser* p2) {
+  HTwoParsers *env = h_new(HTwoParsers, 1);
   env->p1 = p1; env->p2 = p2;
-  HParser *ret = g_new(HParser, 1);
+  HParser *ret = h_new(HParser, 1);
   ret->vtable = &butnot_vt; ret->env = (void*)env;
   return ret;
 }

src/parsers/ch.c

@@ -15,8 +15,12 @@ static HParseResult* parse_ch(void* env, HParseState *state) {
 static const HParserVtable ch_vt = {
   .parse = parse_ch,
 };
-const HParser* h_ch(const uint8_t c) {  
-  HParser *ret = g_new(HParser, 1);
+
+const HParser* h_ch(const uint8_t c) {
+  return h_ch__m(&system_allocator, c);
+}
+const HParser* h_ch__m(HAllocator* mm__, const uint8_t c) {  
+  HParser *ret = h_new(HParser, 1);
   ret->vtable = &ch_vt;
   ret->env = GUINT_TO_POINTER(c);
   return (const HParser*)ret;

src/parsers/charset.c

@@ -1,5 +1,24 @@
+#include <string.h>
 #include "parser_internal.h"
 
+typedef unsigned int *HCharset;
+
+static inline HCharset new_charset(HAllocator* mm__) {
+  HCharset cs = h_new(unsigned int, 256 / sizeof(unsigned int));
+  memset(cs, 0, 256);
+  return cs;
+}
+
+static inline int charset_isset(HCharset cs, uint8_t pos) {
+  return !!(cs[pos / sizeof(*cs)] & (1 << (pos % sizeof(*cs))));
+}
+
+static inline void charset_set(HCharset cs, uint8_t pos, int val) {
+  cs[pos / sizeof(*cs)] =
+    val
+    ? cs[pos / sizeof(*cs)] |  (1 << (pos % sizeof(*cs)))
+    : cs[pos / sizeof(*cs)] & ~(1 << (pos % sizeof(*cs)));
+}
 
 static HParseResult* parse_charset(void *env, HParseState *state) {
   uint8_t in = h_read_bits(&state->input_stream, 8, false);
@@ -18,8 +37,11 @@ static const HParserVtable charset_vt = {
 };
 
 const HParser* h_ch_range(const uint8_t lower, const uint8_t upper) {
-  HParser *ret = g_new(HParser, 1);
-  HCharset cs = new_charset();
+  return h_ch_range__m(&system_allocator, lower, upper);
+}
+const HParser* h_ch_range__m(HAllocator* mm__, const uint8_t lower, const uint8_t upper) {
+  HParser *ret = h_new(HParser, 1);
+  HCharset cs = new_charset(mm__);
   for (int i = 0; i < 256; i++)
     charset_set(cs, i, (lower <= i) && (i <= upper));
   ret->vtable = &charset_vt;
@@ -28,9 +50,9 @@ const HParser* h_ch_range(const uint8_t lower, const uint8_t upper) {
 }
 
 
-const HParser* h_in_or_not(const uint8_t *options, size_t count, int val) {
-  HParser *ret = g_new(HParser, 1);
-  HCharset cs = new_charset();
+static const HParser* h_in_or_not__m(HAllocator* mm__, const uint8_t *options, size_t count, int val) {
+  HParser *ret = h_new(HParser, 1);
+  HCharset cs = new_charset(mm__);
   for (size_t i = 0; i < 256; i++)
     charset_set(cs, i, 1-val);
   for (size_t i = 0; i < count; i++)
@@ -42,10 +64,18 @@ const HParser* h_in_or_not(const uint8_t *options, size_t count, int val) {
 }
 
 const HParser* h_in(const uint8_t *options, size_t count) {
-  return h_in_or_not(options, count, 1);
+  return h_in_or_not__m(&system_allocator, options, count, 1);
+}
+
+const HParser* h_in__m(HAllocator* mm__, const uint8_t *options, size_t count) {
+  return h_in_or_not__m(mm__, options, count, 1);
 }
 
 const HParser* h_not_in(const uint8_t *options, size_t count) {
-  return h_in_or_not(options, count, 0);
+  return h_in_or_not__m(&system_allocator, options, count, 0);
+}
+
+const HParser* h_not_in__m(HAllocator* mm__, const uint8_t *options, size_t count) {
+  return h_in_or_not__m(mm__, options, count, 0);
 }
 

src/parsers/choice.c

@@ -25,20 +25,40 @@ static const HParserVtable choice_vt = {
 };
 
 const HParser* h_choice(const HParser* p, ...) {
+  va_list ap;
+  va_start(ap, p);
+  const HParser* ret = h_choice__mv(&system_allocator, p,  ap);
+  va_end(ap);
+  return ret;
+}
+
+const HParser* h_choice__m(HAllocator* mm__, const HParser* p, ...) {
+  va_list ap;
+  va_start(ap, p);
+  const HParser* ret = h_choice__mv(mm__, p,  ap);
+  va_end(ap);
+  return ret;
+}
+
+const HParser* h_choice__v(const HParser* p, va_list ap) {
+  return h_choice__mv(&system_allocator, p, ap);
+}
+
+const HParser* h_choice__mv(HAllocator* mm__, const HParser* p, va_list ap_) {
   va_list ap;
   size_t len = 0;
-  HSequence *s = g_new(HSequence, 1);
+  HSequence *s = h_new(HSequence, 1);
 
   const HParser *arg;
-  va_start(ap, p);
+  va_copy(ap, ap_);
   do {
     len++;
     arg = va_arg(ap, const HParser *);
   } while (arg);
   va_end(ap);
-  s->p_array = g_new(const HParser *, len);
+  s->p_array = h_new(const HParser *, len);
 
-  va_start(ap, p);
+  va_copy(ap, ap_);
   s->p_array[0] = p;
   for (size_t i = 1; i < len; i++) {
     s->p_array[i] = va_arg(ap, const HParser *);
@@ -46,7 +66,7 @@ const HParser* h_choice(const HParser* p, ...) {
   va_end(ap);
 
   s->len = len;
-  HParser *ret = g_new(HParser, 1);
+  HParser *ret = h_new(HParser, 1);
   ret->vtable = &choice_vt; ret->env = (void*)s;
   return ret;
 }

src/parsers/difference.c

@@ -38,10 +38,13 @@ static HParserVtable difference_vt = {
   .parse = parse_difference,
 };
 
-const HParser* h_difference(const HParser* p1, const HParser* p2) { 
-  HTwoParsers *env = g_new(HTwoParsers, 1);
+const HParser* h_difference(const HParser* p1, const HParser* p2) {
+  return h_difference__m(&system_allocator, p1, p2);
+}
+const HParser* h_difference__m(HAllocator* mm__, const HParser* p1, const HParser* p2) { 
+  HTwoParsers *env = h_new(HTwoParsers, 1);
   env->p1 = p1; env->p2 = p2;
-  HParser *ret = g_new(HParser, 1);
+  HParser *ret = h_new(HParser, 1);
   ret->vtable = &difference_vt; ret->env = (void*)env;
   return ret;
 }

src/parsers/end.c

@@ -14,8 +14,13 @@ static const HParserVtable end_vt = {
   .parse = parse_end,
 };
 
-const HParser* h_end_p() { 
-  HParser *ret = g_new(HParser, 1);
-  ret->vtable = &end_vt; ret->env = NULL;
+const HParser* h_end_p() {
+  return h_end_p__m(&system_allocator);
+}
+
+const HParser* h_end_p__m(HAllocator* mm__) { 
+  HParser *ret = h_new(HParser, 1);
+  ret->vtable = &end_vt;
+  ret->env = NULL;
   return (const HParser*)ret;
 }

src/parsers/epsilon.c

@@ -20,3 +20,6 @@ static const HParser epsilon_p = {
 const HParser* h_epsilon_p() {
   return &epsilon_p;
 }
+const HParser* h_epsilon_p__m(HAllocator* mm__) {
+  return &epsilon_p;
+}

src/parsers/ignore.c

@@ -15,7 +15,10 @@ static const HParserVtable ignore_vt = {
 };
 
 const HParser* h_ignore(const HParser* p) {
-  HParser* ret = g_new(HParser, 1);
+  return h_ignore__m(&system_allocator, p);
+}
+const HParser* h_ignore__m(HAllocator* mm__, const HParser* p) {
+  HParser* ret = h_new(HParser, 1);
   ret->vtable = &ignore_vt;
   ret->env = (void*)p;
   return ret;

src/parsers/ignoreseq.c

@@ -35,38 +35,48 @@ static const HParserVtable ignoreseq_vt = {
 // API frontends
 //
 
-static const HParser* h_leftright(const HParser* p, const HParser* q, size_t which) {
-  HIgnoreSeq *seq = g_new(HIgnoreSeq, 1);
-  seq->parsers = g_new(const HParser*, 2);
+static const HParser* h_leftright__m(HAllocator* mm__, const HParser* p, const HParser* q, size_t which) {
+  HIgnoreSeq *seq = h_new(HIgnoreSeq, 1);
+  seq->parsers = h_new(const HParser*, 2);
   seq->parsers[0] = p;
   seq->parsers[1] = q;
   seq->count = 2;
   seq->which = which;
 
-  HParser *ret = g_new(HParser, 1);
+  HParser *ret = h_new(HParser, 1);
   ret->vtable = &ignoreseq_vt;
   ret->env = (void*)seq;
   return ret;
 }
 
 const HParser* h_left(const HParser* p, const HParser* q) {
-  return h_leftright(p, q, 0);
+  return h_leftright__m(&system_allocator, p, q, 0);
+}
+const HParser* h_left__m(HAllocator* mm__, const HParser* p, const HParser* q) {
+  return h_leftright__m(mm__, p, q, 0);
 }
 
 const HParser* h_right(const HParser* p, const HParser* q) {
-  return h_leftright(p, q, 1);
+  return h_leftright__m(&system_allocator, p, q, 1);
+}
+const HParser* h_right__m(HAllocator* mm__, const HParser* p, const HParser* q) {
+  return h_leftright__m(mm__, p, q, 1);
 }
 
+
 const HParser* h_middle(const HParser* p, const HParser* x, const HParser* q) {
-  HIgnoreSeq *seq = g_new(HIgnoreSeq, 1);
-  seq->parsers = g_new(const HParser*, 3);
+  return h_middle__m(&system_allocator, p, x, q);
+}
+const HParser* h_middle__m(HAllocator* mm__, const HParser* p, const HParser* x, const HParser* q) {
+  HIgnoreSeq *seq = h_new(HIgnoreSeq, 1);
+  seq->parsers = h_new(const HParser*, 3);
   seq->parsers[0] = p;
   seq->parsers[1] = x;
   seq->parsers[2] = q;
   seq->count = 3;
   seq->which = 1;
 
-  HParser *ret = g_new(HParser, 1);
+  HParser *ret = h_new(HParser, 1);
   ret->vtable = &ignoreseq_vt;
   ret->env = (void*)seq;
   return ret;

src/parsers/indirect.c

@@ -13,7 +13,10 @@ void h_bind_indirect(HParser* indirect, const HParser* inner) {
 }
 
 HParser* h_indirect() {
-  HParser *res = g_new(HParser, 1);
+  return h_indirect__m(&system_allocator);
+}
+HParser* h_indirect__m(HAllocator* mm__) {
+  HParser *res = h_new(HParser, 1);
   res->vtable = &indirect_vt;
   res->env = NULL;
   return res;

src/parsers/int_range.c

@@ -33,6 +33,9 @@ static const HParserVtable int_range_vt = {
 };
 
 const HParser* h_int_range(const HParser *p, const int64_t lower, const int64_t upper) {
+  return h_int_range__m(&system_allocator, p, lower, upper);
+}
+const HParser* h_int_range__m(HAllocator* mm__, const HParser *p, const int64_t lower, const int64_t upper) {
   // p must be an integer parser, which means it's using parse_bits
   // TODO: re-add this check
   //assert_message(p->vtable == &bits_vt, "int_range requires an integer parser"); 
@@ -40,11 +43,11 @@ const HParser* h_int_range(const HParser *p, const int64_t lower, const int64_t
   // and regardless, the bounds need to fit in the parser in question
   // TODO: check this as well.
 
-  HRange *r_env = g_new(HRange, 1);
+  HRange *r_env = h_new(HRange, 1);
   r_env->p = p;
   r_env->lower = lower;
   r_env->upper = upper;
-  HParser *ret = g_new(HParser, 1);
+  HParser *ret = h_new(HParser, 1);
   ret->vtable = &int_range_vt;
   ret->env = (void*)r_env;
   return ret;

src/parsers/many.c

@@ -49,10 +49,13 @@ static const HParserVtable many_vt = {
 };
 
 const HParser* h_many(const HParser* p) {
-  HParser *res = g_new(HParser, 1);
-  HRepeat *env = g_new(HRepeat, 1);
+  return h_many__m(&system_allocator, p);
+}
+const HParser* h_many__m(HAllocator* mm__, const HParser* p) {
+  HParser *res = h_new(HParser, 1);
+  HRepeat *env = h_new(HRepeat, 1);
   env->p = p;
-  env->sep = h_epsilon_p();
+  env->sep = h_epsilon_p__m(mm__);
   env->count = 0;
   env->min_p = true;
   res->vtable = &many_vt;
@@ -61,10 +64,13 @@ const HParser* h_many(const HParser* p) {
 }
 
 const HParser* h_many1(const HParser* p) {
-  HParser *res = g_new(HParser, 1);
-  HRepeat *env = g_new(HRepeat, 1);
+  return h_many1__m(&system_allocator, p);
+}
+const HParser* h_many1__m(HAllocator* mm__, const HParser* p) {
+  HParser *res = h_new(HParser, 1);
+  HRepeat *env = h_new(HRepeat, 1);
   env->p = p;
-  env->sep = h_epsilon_p();
+  env->sep = h_epsilon_p__m(mm__);
   env->count = 1;
   env->min_p = true;
   res->vtable = &many_vt;
@@ -73,10 +79,13 @@ const HParser* h_many1(const HParser* p) {
 }
 
 const HParser* h_repeat_n(const HParser* p, const size_t n) {
-  HParser *res = g_new(HParser, 1);
-  HRepeat *env = g_new(HRepeat, 1);
+  return h_repeat_n__m(&system_allocator, p, n);
+}
+const HParser* h_repeat_n__m(HAllocator* mm__, const HParser* p, const size_t n) {
+  HParser *res = h_new(HParser, 1);
+  HRepeat *env = h_new(HRepeat, 1);
   env->p = p;
-  env->sep = h_epsilon_p();
+  env->sep = h_epsilon_p__m(mm__);
   env->count = n;
   env->min_p = false;
   res->vtable = &many_vt;
@@ -85,8 +94,11 @@ const HParser* h_repeat_n(const HParser* p, const size_t n) {
 }
 
 const HParser* h_sepBy(const HParser* p, const HParser* sep) {
-  HParser *res = g_new(HParser, 1);
-  HRepeat *env = g_new(HRepeat, 1);
+  return h_sepBy__m(&system_allocator, p, sep);
+}
+const HParser* h_sepBy__m(HAllocator* mm__, const HParser* p, const HParser* sep) {
+  HParser *res = h_new(HParser, 1);
+  HRepeat *env = h_new(HRepeat, 1);
   env->p = p;
   env->sep = sep;
   env->count = 0;
@@ -97,8 +109,11 @@ const HParser* h_sepBy(const HParser* p, const HParser* sep) {
 }
 
 const HParser* h_sepBy1(const HParser* p, const HParser* sep) {
-  HParser *res = g_new(HParser, 1);
-  HRepeat *env = g_new(HRepeat, 1);
+  return h_sepBy1__m(&system_allocator, p, sep);
+}
+const HParser* h_sepBy1__m(HAllocator* mm__, const HParser* p, const HParser* sep) {
+  HParser *res = h_new(HParser, 1);
+  HRepeat *env = h_new(HRepeat, 1);
   env->p = p;
   env->sep = sep;
   env->count = 1;
@@ -135,9 +150,12 @@ static const HParserVtable length_value_vt = {
 };
 
 const HParser* h_length_value(const HParser* length, const HParser* value) {
-  HParser *res = g_new(HParser, 1);
+  return h_length_value__m(&system_allocator, length, value);
+}
+const HParser* h_length_value__m(HAllocator* mm__, const HParser* length, const HParser* value) {
+  HParser *res = h_new(HParser, 1);
   res->vtable = &length_value_vt;
-  HLenVal *env = g_new(HLenVal, 1);
+  HLenVal *env = h_new(HLenVal, 1);
   env->length = length;
   env->value = value;
   res->env = (void*)env;

src/parsers/not.c

@@ -15,7 +15,10 @@ static const HParserVtable not_vt = {
 };
 
 const HParser* h_not(const HParser* p) {
-  HParser *res = g_new(HParser, 1);
+  return h_not__m(&system_allocator, p);
+}
+const HParser* h_not__m(HAllocator* mm__, const HParser* p) {
+  HParser *res = h_new(HParser, 1);
   res->vtable = &not_vt;
   res->env = (void*)p;
   return res;

src/parsers/nothing.c

@@ -10,8 +10,11 @@ static const HParserVtable nothing_vt = {
   .parse = parse_nothing,
 };
 
-const HParser* h_nothing_p() { 
-  HParser *ret = g_new(HParser, 1);
+const HParser* h_nothing_p() {
+  return h_nothing_p__m(&system_allocator);
+}
+const HParser* h_nothing_p__m(HAllocator* mm__) { 
+  HParser *ret = h_new(HParser, 1);
   ret->vtable = &nothing_vt; ret->env = NULL;
   return (const HParser*)ret;
 }

src/parsers/optional.c

@@ -16,9 +16,12 @@ static const HParserVtable optional_vt = {
 };
 
 const HParser* h_optional(const HParser* p) {
+  return h_optional__m(&system_allocator, p);
+}
+const HParser* h_optional__m(HAllocator* mm__, const HParser* p) {
   // TODO: re-add this
   //assert_message(p->vtable != &ignore_vt, "Thou shalt ignore an option, rather than the other way 'round.");
-  HParser *ret = g_new(HParser, 1);
+  HParser *ret = h_new(HParser, 1);
   ret->vtable = &optional_vt;
   ret->env = (void*)p;
   return ret;

src/parsers/sequence.c

@@ -27,20 +27,40 @@ static const HParserVtable sequence_vt = {
   .parse = parse_sequence,
 };
 
-const HParser* h_sequence(const HParser *p, ...) {
+const HParser* h_sequence(const HParser* p, ...) {
+  va_list ap;
+  va_start(ap, p);
+  const HParser* ret = h_sequence__mv(&system_allocator, p,  ap);
+  va_end(ap);
+  return ret;
+}
+
+const HParser* h_sequence__m(HAllocator* mm__, const HParser* p, ...) {
+  va_list ap;
+  va_start(ap, p);
+  const HParser* ret = h_sequence__mv(mm__, p,  ap);
+  va_end(ap);
+  return ret;
+}
+
+const HParser* h_sequence__v(const HParser* p, va_list ap) {
+  return h_sequence__mv(&system_allocator, p, ap);
+}
+
+const HParser* h_sequence__mv(HAllocator* mm__, const HParser *p, va_list ap_) {
   va_list ap;
   size_t len = 0;
   const HParser *arg;
-  va_start(ap, p);
+  va_copy(ap, ap_);
   do {
     len++;
     arg = va_arg(ap, const HParser *);
   } while (arg);
   va_end(ap);
-  HSequence *s = g_new(HSequence, 1);
-  s->p_array = g_new(const HParser *, len);
+  HSequence *s = h_new(HSequence, 1);
+  s->p_array = h_new(const HParser *, len);
 
-  va_start(ap, p);
+  va_copy(ap, ap_);
   s->p_array[0] = p;
   for (size_t i = 1; i < len; i++) {
     s->p_array[i] = va_arg(ap, const HParser *);
@@ -48,7 +68,7 @@ const HParser* h_sequence(const HParser *p, ...) {
   va_end(ap);
 
   s->len = len;
-  HParser *ret = g_new(HParser, 1);
+  HParser *ret = h_new(HParser, 1);
   ret->vtable = &sequence_vt; ret->env = (void*)s;
   return ret;
 }

src/parsers/token.c

@@ -24,10 +24,13 @@ const const HParserVtable token_vt = {
   .parse = parse_token,
 };
 
-const HParser* h_token(const uint8_t *str, const size_t len) { 
-  HToken *t = g_new(HToken, 1);
+const HParser* h_token(const uint8_t *str, const size_t len) {
+  return h_token__m(&system_allocator, str, len);
+}
+const HParser* h_token__m(HAllocator* mm__, const uint8_t *str, const size_t len) { 
+  HToken *t = h_new(HToken, 1);
   t->str = (uint8_t*)str, t->len = len;
-  HParser *ret = g_new(HParser, 1);
+  HParser *ret = h_new(HParser, 1);
   ret->vtable = &token_vt;
   ret->env = t;
   return (const HParser*)ret;

src/parsers/unimplemented.c

@@ -24,3 +24,6 @@ static HParser unimplemented = {
 const HParser* h_unimplemented() {
   return &unimplemented;
 }
+const HParser* h_unimplemented__m(HAllocator* mm__) {
+  return &unimplemented;
+}

src/parsers/whitespace.c

@@ -19,7 +19,10 @@ static const HParserVtable whitespace_vt = {
 };
 
 const HParser* h_whitespace(const HParser* p) {
-  HParser *ret = g_new(HParser, 1);
+  return h_whitespace__m(&system_allocator, p);
+}
+const HParser* h_whitespace__m(HAllocator* mm__, const HParser* p) {
+  HParser *ret = h_new(HParser, 1);
   ret->vtable = &whitespace_vt;
   ret->env = (void*)p;
   return ret;

src/parsers/xor.c

@@ -35,10 +35,13 @@ static const HParserVtable xor_vt = {
   .parse = parse_xor,
 };
 
-const HParser* h_xor(const HParser* p1, const HParser* p2) { 
-  HTwoParsers *env = g_new(HTwoParsers, 1);
+const HParser* h_xor(const HParser* p1, const HParser* p2) {
+  return h_xor__m(&system_allocator, p1, p2);
+}
+const HParser* h_xor__m(HAllocator* mm__, const HParser* p1, const HParser* p2) { 
+  HTwoParsers *env = h_new(HTwoParsers, 1);
   env->p1 = p1; env->p2 = p2;
-  HParser *ret = g_new(HParser, 1);
+  HParser *ret = h_new(HParser, 1);
   ret->vtable = &xor_vt; ret->env = (void*)env;
   return ret;
 }