wrap all allocs of HParser in helper h_new_parser

src/parsers/action.c

@@ -56,11 +56,8 @@ const HParser* h_action(const HParser* p, const HAction 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 = h_new(HParseAction, 1);
   env->p = p;
   env->action = a;
-  res->env = (void*)env;
-  return res;
+  return h_new_parser(mm__, &action_vt, env);
 }

src/parsers/and.c

@@ -30,8 +30,5 @@ const HParser* h_and(const HParser* p) {
 }
 const HParser* h_and__m(HAllocator* mm__, const HParser* p) {
   // zero-width postive lookahead
-  HParser *res = h_new(HParser, 1);
-  res->env = (void*)p;
-  res->vtable = &and_vt;
-  return res;
+  return h_new_parser(mm__, &and_vt, (void *)p);
 }

src/parsers/attr_bool.c

@@ -59,11 +59,8 @@ 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 = h_new(HAttrBool, 1);
   env->p = p;
   env->pred = pred;
-  res->env = (void*)env;
-  return res;
+  return h_new_parser(mm__, &attr_bool_vt, env);
 }

src/parsers/bits.c

@@ -54,10 +54,7 @@ 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 = h_new(HParser, 1);
-  res->vtable = &bits_vt;
-  res->env = env;
-  return res;
+  return h_new_parser(mm__, &bits_vt, env);
 }
 
 #define SIZED_BITS(name_pre, len, signedp) \

src/parsers/butnot.c

@@ -52,9 +52,8 @@ const HParser* h_butnot(const HParser* p1, const HParser* 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 = h_new(HParser, 1);
-  ret->vtable = &butnot_vt; ret->env = (void*)env;
-  return ret;
+  env->p1 = p1;
+  env->p2 = p2;
+  return h_new_parser(mm__, &butnot_vt, env);
 }
 

src/parsers/ch.c

@@ -31,8 +31,5 @@ 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 = (void*)(unsigned long)(c);
-  return (const HParser*)ret;
+  return h_new_parser(mm__, &ch_vt, (void *)(uintptr_t)c);
 }

src/parsers/charset.c

@@ -33,27 +33,21 @@ const HParser* h_ch_range(const uint8_t lower, const uint8_t upper) {
   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;
-  ret->env = (void*)cs;
-  return (const HParser*)ret;
+  return h_new_parser(mm__, &charset_vt, cs);
 }
 
 
 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++)
     charset_set(cs, options[i], val);
 
-  ret->vtable = &charset_vt;
-  ret->env = (void*)cs;
-  return (const HParser*)ret;
+  return h_new_parser(mm__, &charset_vt, cs);
 }
 
 const HParser* h_in(const uint8_t *options, size_t count) {

src/parsers/choice.c

@@ -103,8 +103,6 @@ const HParser* h_choice__mv(HAllocator* mm__, const HParser* p, va_list ap_) {
   va_end(ap);
 
   s->len = len;
-  HParser *ret = h_new(HParser, 1);
-  ret->vtable = &choice_vt; ret->env = (void*)s;
-  return ret;
+  return h_new_parser(mm__, &choice_vt, s);
 }
 

src/parsers/difference.c

@@ -51,8 +51,7 @@ const HParser* h_difference(const HParser* p1, const HParser* 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 = h_new(HParser, 1);
-  ret->vtable = &difference_vt; ret->env = (void*)env;
-  return ret;
+  env->p1 = p1;
+  env->p2 = p2;
+  return h_new_parser(mm__, &difference_vt, env);
 }

src/parsers/end.c

@@ -29,8 +29,5 @@ const HParser* h_end_p() {
 }
 
 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;
+  return h_new_parser(mm__, &end_vt, NULL);
 }

src/parsers/ignore.c

@@ -36,8 +36,5 @@ const HParser* h_ignore(const HParser* p) {
   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;
+  return h_new_parser(mm__, &ignore_vt, (void *)p);
 }

src/parsers/ignoreseq.c

@@ -81,10 +81,7 @@ static const HParser* h_leftright__m(HAllocator* mm__, const HParser* p, const H
   seq->len = 2;
   seq->which = which;
 
-  HParser *ret = h_new(HParser, 1);
-  ret->vtable = &ignoreseq_vt;
-  ret->env = (void*)seq;
-  return ret;
+  return h_new_parser(mm__, &ignoreseq_vt, seq);
 }
 
 const HParser* h_left(const HParser* p, const HParser* q) {
@@ -114,8 +111,5 @@ const HParser* h_middle__m(HAllocator* mm__, const HParser* p, const HParser* x,
   seq->len = 3;
   seq->which = 1;
 
-  HParser *ret = h_new(HParser, 1);
-  ret->vtable = &ignoreseq_vt;
-  ret->env = (void*)seq;
-  return ret;
+  return h_new_parser(mm__, &ignoreseq_vt, seq);
 }

src/parsers/indirect.c

@@ -32,8 +32,5 @@ HParser* h_indirect() {
   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;
+  return h_new_parser(mm__, &indirect_vt, NULL);
 }

src/parsers/int_range.c

@@ -143,8 +143,5 @@ const HParser* h_int_range__m(HAllocator* mm__, const HParser *p, const int64_t
   r_env->p = p;
   r_env->lower = lower;
   r_env->upper = upper;
-  HParser *ret = h_new(HParser, 1);
-  ret->vtable = &int_range_vt;
-  ret->env = (void*)r_env;
-  return ret;
+  return h_new_parser(mm__, &int_range_vt, r_env);
 }

src/parsers/many.c

@@ -123,75 +123,60 @@ const HParser* h_many(const HParser* p) {
   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__m(mm__);
   env->count = 0;
   env->min_p = true;
-  res->vtable = &many_vt;
-  res->env = env;
-  return res;
+  return h_new_parser(mm__, &many_vt, env);
 }
 
 const HParser* h_many1(const HParser* p) {
   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__m(mm__);
   env->count = 1;
   env->min_p = true;
-  res->vtable = &many_vt;
-  res->env = env;
-  return res;
+  return h_new_parser(mm__, &many_vt, env);
 }
 
 const HParser* h_repeat_n(const HParser* p, const size_t n) {
   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__m(mm__);
   env->count = n;
   env->min_p = false;
-  res->vtable = &many_vt;
-  res->env = env;
-  return res;
+  return h_new_parser(mm__, &many_vt, env);
 }
 
 const HParser* h_sepBy(const HParser* p, const HParser* sep) {
   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;
   env->min_p = true;
-  res->vtable = &many_vt;
-  res->env = env;
-  return res;
+  return h_new_parser(mm__, &many_vt, env);
 }
 
 const HParser* h_sepBy1(const HParser* p, const HParser* sep) {
   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;
   env->min_p = true;
-  res->vtable = &many_vt;
-  res->env = env;
-  return res;
+  return h_new_parser(mm__, &many_vt, env);
 }
 
 typedef struct {
@@ -232,11 +217,8 @@ const HParser* h_length_value(const HParser* length, const HParser* value) {
   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 = h_new(HLenVal, 1);
   env->length = length;
   env->value = value;
-  res->env = (void*)env;
-  return res;
+  return h_new_parser(mm__, &length_value_vt, env);
 }

src/parsers/not.c

@@ -26,8 +26,5 @@ const HParser* h_not(const HParser* p) {
   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;
+  return h_new_parser(mm__, &not_vt, (void *)p);
 }

src/parsers/nothing.c

@@ -26,7 +26,5 @@ 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;
+  return h_new_parser(mm__, &nothing_vt, NULL);
 }

src/parsers/optional.c

@@ -39,9 +39,6 @@ const HParser* h_optional(const HParser* 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 = h_new(HParser, 1);
-  ret->vtable = &optional_vt;
-  ret->env = (void*)p;
-  return ret;
+  return h_new_parser(mm__, &optional_vt, (void *)p);
 }
 

src/parsers/sequence.c

@@ -107,7 +107,5 @@ const HParser* h_sequence__mv(HAllocator* mm__, const HParser *p, va_list ap_) {
   va_end(ap);
 
   s->len = len;
-  HParser *ret = h_new(HParser, 1);
-  ret->vtable = &sequence_vt; ret->env = (void*)s;
-  return ret;
+  return h_new_parser(mm__, &sequence_vt, s);
 }

src/parsers/token.c

@@ -50,8 +50,5 @@ const HParser* h_token(const uint8_t *str, const size_t 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 = h_new(HParser, 1);
-  ret->vtable = &token_vt;
-  ret->env = t;
-  return (const HParser*)ret;
+  return h_new_parser(mm__, &token_vt, t);
 }

src/parsers/whitespace.c

@@ -60,8 +60,5 @@ const HParser* h_whitespace(const HParser* p) {
   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;
+  return h_new_parser(mm__, &whitespace_vt, (void *)p);
 }

src/parsers/xor.c

@@ -48,8 +48,7 @@ const HParser* h_xor(const HParser* p1, const HParser* 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 = h_new(HParser, 1);
-  ret->vtable = &xor_vt; ret->env = (void*)env;
-  return ret;
+  env->p1 = p1;
+  env->p2 = p2;
+  return h_new_parser(mm__, &xor_vt, env);
 }