diff --git a/examples/base64_sem1.c b/examples/base64_sem1.c
index 46e58da23dcf49a7189c7d89a92ba8fff2780eea..4da171f355c9f8b7312ae29e231d58592602b901 100644
--- a/examples/base64_sem1.c
+++ b/examples/base64_sem1.c
@@ -23,7 +23,7 @@
 // They must be named act_<rulename>.
 ///
 
-HParsedToken *act_bsfdig(const HParseResult *p)
+HParsedToken *act_bsfdig(const HParseResult *p, void* user_data)
 {
     HParsedToken *res = H_MAKE_UINT(0);
 
@@ -54,7 +54,7 @@ H_ACT_APPLY(act_index0, h_act_index, 0);
 #define act_document     act_index0
 
 // General-form action to turn a block of base64 digits into bytes.
-HParsedToken *act_base64_n(int n, const HParseResult *p)
+HParsedToken *act_base64_n(int n, const HParseResult *p, void* user_data)
 {
     HParsedToken *res = H_MAKE_SEQN(n);
 
@@ -83,7 +83,7 @@ H_ACT_APPLY(act_base64_3, act_base64_n, 3);
 H_ACT_APPLY(act_base64_2, act_base64_n, 2);
 H_ACT_APPLY(act_base64_1, act_base64_n, 1);
 
-HParsedToken *act_base64(const HParseResult *p)
+HParsedToken *act_base64(const HParseResult *p, void* user_data)
 {
     assert(p->ast->token_type == TT_SEQUENCE);
     assert(p->ast->seq->used == 2);
diff --git a/examples/base64_sem2.c b/examples/base64_sem2.c
index 84155da23b7f09ca84a6487dedf031c27955e4e9..b7a2263efc1810a0140785f3494dc29a4d204f03 100644
--- a/examples/base64_sem2.c
+++ b/examples/base64_sem2.c
@@ -49,7 +49,7 @@ uint8_t bsfdig_value(const HParsedToken *p)
 // helper: append a byte value to a sequence
 #define seq_append_byte(res, b) h_seq_snoc(res, H_MAKE_UINT(b))
 
-HParsedToken *act_base64(const HParseResult *p)
+HParsedToken *act_base64(const HParseResult *p, void* user_data)
 {
     assert(p->ast->token_type == TT_SEQUENCE);
     assert(p->ast->seq->used == 2);
diff --git a/examples/dns.c b/examples/dns.c
index 3f730b970cd6d59677b7d8a38dcec8ea7b10ef48..5effb8951a60c9c14b1e3d9b8008d88eabf5bcf5 100644
--- a/examples/dns.c
+++ b/examples/dns.c
@@ -86,7 +86,7 @@ void set_rdata(struct dns_rr *rr, HCountedArray *rdata) {
   }
 }
 
-HParsedToken* act_header(const HParseResult *p) {
+HParsedToken* act_header(const HParseResult *p, void* user_data) {
   HParsedToken **fields = h_seq_elements(p->ast);
   dns_header_t header_ = {
     .id     = H_CAST_UINT(fields[0]),
@@ -109,7 +109,7 @@ HParsedToken* act_header(const HParseResult *p) {
   return H_MAKE(dns_header_t, header);
 }
 
-HParsedToken* act_label(const HParseResult *p) {
+HParsedToken* act_label(const HParseResult *p, void* user_data) {
   dns_label_t *r = H_ALLOC(dns_label_t);
 
   r->len = h_seq_len(p->ast);
@@ -121,7 +121,7 @@ HParsedToken* act_label(const HParseResult *p) {
   return H_MAKE(dns_label_t, r);
 }
 
-HParsedToken* act_rr(const HParseResult *p) {
+HParsedToken* act_rr(const HParseResult *p, void* user_data) {
   dns_rr_t *rr = H_ALLOC(dns_rr_t);
 
   rr->name     = *H_FIELD(dns_domain_t, 0);
@@ -136,7 +136,7 @@ HParsedToken* act_rr(const HParseResult *p) {
   return H_MAKE(dns_rr_t, rr);
 }
 
-HParsedToken* act_question(const HParseResult *p) {
+HParsedToken* act_question(const HParseResult *p, void* user_data) {
   dns_question_t *q = H_ALLOC(dns_question_t);
   HParsedToken **fields = h_seq_elements(p->ast);
 
@@ -153,7 +153,7 @@ HParsedToken* act_question(const HParseResult *p) {
   return H_MAKE(dns_question_t, q);
 }
 
-HParsedToken* act_message(const HParseResult *p) {
+HParsedToken* act_message(const HParseResult *p, void* user_data) {
   h_pprint(stdout, p->ast, 0, 2);
   dns_message_t *msg = H_ALLOC(dns_message_t);
 
diff --git a/examples/dns_common.c b/examples/dns_common.c
index 01dd8f0fb4630680174f8fff657c70f845775624..3cdd04e0be2b8e1fce4e0a02b008c63f2c26d059 100644
--- a/examples/dns_common.c
+++ b/examples/dns_common.c
@@ -18,7 +18,7 @@ bool validate_label(HParseResult *p) {
 
 #define act_label h_act_flatten
 
-HParsedToken* act_domain(const HParseResult *p) {
+HParsedToken* act_domain(const HParseResult *p, void* user_data) {
   HParsedToken *ret = NULL;
   char *arr = NULL;
 
diff --git a/examples/dns_common.h b/examples/dns_common.h
index 8af014b2f22c28da36e3312b56e355e1d5500e73..3e30770ad60a6acd4f375f2d36b5a9def5c8906a 100644
--- a/examples/dns_common.h
+++ b/examples/dns_common.h
@@ -7,6 +7,6 @@
 HParser* init_domain();
 HParser* init_character_string();
 
-HParsedToken* act_index0(const HParseResult *p);
+HParsedToken* act_index0(const HParseResult *p, void* user_data);
 
 #endif
diff --git a/examples/rr.c b/examples/rr.c
index dd250637a7eaccf1074f9441bb6d273452cc130d..4a7c4be687afd66b22b5c2a6bf76ea02c8bc444d 100644
--- a/examples/rr.c
+++ b/examples/rr.c
@@ -17,7 +17,7 @@ bool validate_null(HParseResult *p) {
   return (65536 > p->ast->seq->used);
 }
 
-HParsedToken *act_null(const HParseResult *p) {
+HParsedToken *act_null(const HParseResult *p, void* user_data) {
   dns_rr_null_t *null = H_ALLOC(dns_rr_null_t);
 
   size_t len = h_seq_len(p->ast);
@@ -28,7 +28,7 @@ HParsedToken *act_null(const HParseResult *p) {
   return H_MAKE(dns_rr_null_t, null);
 }
 
-HParsedToken *act_txt(const HParseResult *p) {
+HParsedToken *act_txt(const HParseResult *p, void* user_data) {
   dns_rr_txt_t *txt = H_ALLOC(dns_rr_txt_t);
 
   const HCountedArray *arr = H_CAST_SEQ(p->ast);
@@ -47,7 +47,7 @@ HParsedToken *act_txt(const HParseResult *p) {
   return H_MAKE(dns_rr_txt_t, txt);
 }
 
-HParsedToken* act_cstr(const HParseResult *p) {
+HParsedToken* act_cstr(const HParseResult *p, void* user_data) {
   dns_cstr_t *cs = H_ALLOC(dns_cstr_t);
 
   const HCountedArray *arr = H_CAST_SEQ(p->ast);
@@ -60,7 +60,7 @@ HParsedToken* act_cstr(const HParseResult *p) {
   return H_MAKE(dns_cstr_t, cs);
 }
 
-HParsedToken* act_soa(const HParseResult *p) {
+HParsedToken* act_soa(const HParseResult *p, void* user_data) {
   dns_rr_soa_t *soa = H_ALLOC(dns_rr_soa_t);
 
   soa->mname   = *H_FIELD(dns_domain_t, 0);
@@ -74,7 +74,7 @@ HParsedToken* act_soa(const HParseResult *p) {
   return H_MAKE(dns_rr_soa_t, soa);
 }
 
-HParsedToken* act_wks(const HParseResult *p) {
+HParsedToken* act_wks(const HParseResult *p, void* user_data) {
   dns_rr_wks_t *wks = H_ALLOC(dns_rr_wks_t);
 
   wks->address  = H_FIELD_UINT(0);
@@ -87,7 +87,7 @@ HParsedToken* act_wks(const HParseResult *p) {
   return H_MAKE(dns_rr_wks_t, wks);
 }
 
-HParsedToken* act_hinfo(const HParseResult *p) {
+HParsedToken* act_hinfo(const HParseResult *p, void* user_data) {
   dns_rr_hinfo_t *hinfo = H_ALLOC(dns_rr_hinfo_t);
 
   hinfo->cpu = *H_FIELD(dns_cstr_t, 0);
@@ -96,7 +96,7 @@ HParsedToken* act_hinfo(const HParseResult *p) {
   return H_MAKE(dns_rr_hinfo_t, hinfo);
 }
 
-HParsedToken* act_minfo(const HParseResult *p) {
+HParsedToken* act_minfo(const HParseResult *p, void* user_data) {
   dns_rr_minfo_t *minfo = H_ALLOC(dns_rr_minfo_t);
 
   minfo->rmailbx = *H_FIELD(dns_domain_t, 0);
@@ -105,7 +105,7 @@ HParsedToken* act_minfo(const HParseResult *p) {
   return H_MAKE(dns_rr_minfo_t, minfo);
 }
 
-HParsedToken* act_mx(const HParseResult *p) {
+HParsedToken* act_mx(const HParseResult *p, void* user_data) {
   dns_rr_mx_t *mx = H_ALLOC(dns_rr_mx_t);
 
   mx->preference = H_FIELD_UINT(0);
@@ -184,7 +184,7 @@ HParser* init_rdata(uint16_t type) {
   for(uint16_t i = 0; i<RDATA_TYPE_MAX+1; i++) {
     if(parsers[i]) {
       parsers[i] = h_action(h_sequence(parsers[i], h_end_p(), NULL),
-			    act_index0);
+			    act_index0, NULL);
     }
   }
 
diff --git a/src/backends/llk.c b/src/backends/llk.c
index c0cf6afef75aae37c9b9479cdc44223244326ab7..39ac07a6740f0e1d4febabea6736fab6f168a9a9 100644
--- a/src/backends/llk.c
+++ b/src/backends/llk.c
@@ -372,13 +372,13 @@ HParseResult *h_llk_parse(HAllocator* mm__, const HParser* parser, HInputStream*
 
     // perform token reshape if indicated
     if(x->reshape)
-      tok = (HParsedToken *)x->reshape(make_result(arena, tok));
+      tok = (HParsedToken *)x->reshape(make_result(arena, tok), x->user_data);
 
     // call validation and semantic action, if present
     if(x->pred && !x->pred(make_result(tarena, tok)))
       goto no_parse;    // validation failed -> no parse
     if(x->action)
-      tok = (HParsedToken *)x->action(make_result(arena, tok));
+      tok = (HParsedToken *)x->action(make_result(arena, tok), x->user_data);
 
     // append to result sequence
     h_carray_append(seq, tok);
diff --git a/src/backends/lr.c b/src/backends/lr.c
index d258e8a7831d11985e82d4ae76ba692e05bc6900..3739ec9bad306bb67a747a866a9ad3df2d526791 100644
--- a/src/backends/lr.c
+++ b/src/backends/lr.c
@@ -307,13 +307,13 @@ bool h_lrengine_step(HLREngine *engine, const HLRAction *action)
 
     // perform token reshape if indicated
     if(symbol->reshape)
-      value = (HParsedToken *)symbol->reshape(make_result(arena, value));
+      value = (HParsedToken *)symbol->reshape(make_result(arena, value), symbol->user_data);
 
     // call validation and semantic action, if present
     if(symbol->pred && !symbol->pred(make_result(tarena, value)))
       return false;     // validation failed -> no parse; terminate
     if(symbol->action)
-      value = (HParsedToken *)symbol->action(make_result(arena, value));
+      value = (HParsedToken *)symbol->action(make_result(arena, value), symbol->user_data);
 
     // this is LR, building a right-most derivation bottom-up, so no reduce can
     // follow a reduce. we can also assume no conflict follows for GLR if we
diff --git a/src/glue.c b/src/glue.c
index 5e3804d0e0ec266cf3185867c975dada86f785dc..c2d915aeaab8e8d58646569f33edc5402af43023 100644
--- a/src/glue.c
+++ b/src/glue.c
@@ -5,7 +5,7 @@
 #include "parsers/parser_internal.h"
 
 // Helper to build HAction's that pick one index out of a sequence.
-HParsedToken *h_act_index(int i, const HParseResult *p)
+HParsedToken *h_act_index(int i, const HParseResult *p, void* user_data)
 {
     if(!p) return NULL;
 
@@ -23,7 +23,7 @@ HParsedToken *h_act_index(int i, const HParseResult *p)
         return tok->seq->elements[i];
 }
 
-HParsedToken *h_act_first(const HParseResult *p) {
+HParsedToken *h_act_first(const HParseResult *p, void* user_data) {
   assert(p->ast);
   assert(p->ast->token_type == TT_SEQUENCE);
   assert(p->ast->seq->used > 0);
@@ -31,7 +31,7 @@ HParsedToken *h_act_first(const HParseResult *p) {
   return p->ast->seq->elements[0];
 }
 
-HParsedToken *h_act_second(const HParseResult *p) {
+HParsedToken *h_act_second(const HParseResult *p, void* user_data) {
   assert(p->ast);
   assert(p->ast->token_type == TT_SEQUENCE);
   assert(p->ast->seq->used > 0);
@@ -39,7 +39,7 @@ HParsedToken *h_act_second(const HParseResult *p) {
   return p->ast->seq->elements[1];
 }
 
-HParsedToken *h_act_last(const HParseResult *p) {
+HParsedToken *h_act_last(const HParseResult *p, void* user_data) {
   assert(p->ast);
   assert(p->ast->token_type == TT_SEQUENCE);
   assert(p->ast->seq->used > 0);
@@ -59,7 +59,7 @@ static void act_flatten_(HCountedArray *seq, const HParsedToken *tok) {
   }
 }
 
-HParsedToken *h_act_flatten(const HParseResult *p) {
+HParsedToken *h_act_flatten(const HParseResult *p, void* user_data) {
   HCountedArray *seq = h_carray_new(p->arena);
 
   act_flatten_(seq, p->ast);
@@ -72,7 +72,7 @@ HParsedToken *h_act_flatten(const HParseResult *p) {
   return res;
 }
 
-HParsedToken *h_act_ignore(const HParseResult *p) {
+HParsedToken *h_act_ignore(const HParseResult *p, void* user_data) {
   return NULL;
 }
 
diff --git a/src/glue.h b/src/glue.h
index 54b598507927b656f9bd1d17a363cd3a7bd723ac..7486e46c57c2a4a832159e171395ea93bc9c3dc1 100644
--- a/src/glue.h
+++ b/src/glue.h
@@ -56,13 +56,19 @@
 
 
 #define H_RULE(rule, def)  HParser *rule = def
-#define H_ARULE(rule, def) HParser *rule = h_action(def, act_ ## rule)
+#define H_ARULE(rule, def) HParser *rule = h_action(def, act_ ## rule, NULL)
 #define H_VRULE(rule, def) HParser *rule = \
-  h_attr_bool(def, validate_ ## rule)
+    h_attr_bool(def, validate_ ## rule)
 #define H_VARULE(rule, def) HParser *rule = \
-  h_attr_bool(h_action(def, act_ ## rule), validate_ ## rule)
+    h_attr_bool(h_action(def, act_ ## rule, NULL), validate_ ## rule)
 #define H_AVRULE(rule, def) HParser *rule = \
-  h_action(h_attr_bool(def, validate_ ## rule), act_ ## rule)
+    h_action(h_attr_bool(def, validate_ ## rule), act_ ## rule, NULL)
+#define H_ADRULE(rule, def, data) HParser *rule =	\
+    h_action(def, act_ ## rule, data)
+#define H_VADRULE(rule, def, data) HParser *rule =		\
+    h_attr_bool(h_action(def, act_ ## rule, data), validate_ ## rule)
+#define H_AVDRULE(rule, def, data) HParser *rule =		\
+    h_action(h_attr_bool(def, validate_ ## rule), act_ ## rule, data)
 
 
 //
@@ -88,18 +94,18 @@
 // action such as h_act_index.
 //
 
-HParsedToken *h_act_index(int i, const HParseResult *p);
-HParsedToken *h_act_first(const HParseResult *p);
-HParsedToken *h_act_second(const HParseResult *p);
-HParsedToken *h_act_last(const HParseResult *p);
-HParsedToken *h_act_flatten(const HParseResult *p);
-HParsedToken *h_act_ignore(const HParseResult *p);
+HParsedToken *h_act_index(int i, const HParseResult *p, void* user_data);
+HParsedToken *h_act_first(const HParseResult *p, void* user_data);
+HParsedToken *h_act_second(const HParseResult *p, void* user_data);
+HParsedToken *h_act_last(const HParseResult *p, void* user_data);
+HParsedToken *h_act_flatten(const HParseResult *p, void* user_data);
+HParsedToken *h_act_ignore(const HParseResult *p, void* user_data);
 
 // Define 'myaction' as a specialization of 'paction' by supplying the leading
 // parameters.
 #define H_ACT_APPLY(myaction, paction, ...) \
-  HParsedToken *myaction(const HParseResult *p) { \
-    return paction(__VA_ARGS__, p); \
+  HParsedToken *myaction(const HParseResult *p, void* user_data) {	\
+    return paction(__VA_ARGS__, p, user_data);				\
   }
 
 
diff --git a/src/hammer.h b/src/hammer.h
index 0175142e509da61fadb79b36eb6095cac1265465..bd3ae02290855006d80b8005ebac9dc01af4b902 100644
--- a/src/hammer.h
+++ b/src/hammer.h
@@ -113,7 +113,7 @@ typedef struct HBitWriter_ HBitWriter;
  * say, structs) and stuff values for them into the void* in the 
  * tagged union in HParsedToken. 
  */
-typedef HParsedToken* (*HAction)(const HParseResult *p);
+typedef HParsedToken* (*HAction)(const HParseResult *p, void* user_data);
 
 /**
  * Type of a boolean attribute-checking function, used in the 
@@ -349,7 +349,7 @@ HAMMER_FN_DECL(HParser*, h_middle, const HParser* p, const HParser* x, const HPa
  *
  * Result token type: any
  */
-HAMMER_FN_DECL(HParser*, h_action, const HParser* p, const HAction a);
+HAMMER_FN_DECL(HParser*, h_action, const HParser* p, const HAction a, void* user_data);
 
 /**
  * Parse a single character in the given charset. 
@@ -621,11 +621,11 @@ void h_bit_writer_free(HBitWriter* w);
 
 // General-purpose actions for use with h_action
 // XXX to be consolidated with glue.h when merged upstream
-HParsedToken *h_act_first(const HParseResult *p);
-HParsedToken *h_act_second(const HParseResult *p);
-HParsedToken *h_act_last(const HParseResult *p);
-HParsedToken *h_act_flatten(const HParseResult *p);
-HParsedToken *h_act_ignore(const HParseResult *p);
+HParsedToken *h_act_first(const HParseResult *p, void* userdata);
+HParsedToken *h_act_second(const HParseResult *p, void* userdata);
+HParsedToken *h_act_last(const HParseResult *p, void* userdata);
+HParsedToken *h_act_flatten(const HParseResult *p, void* userdata);
+HParsedToken *h_act_ignore(const HParseResult *p, void* userdata);
 
 // {{{ Benchmark functions
 HAMMER_FN_DECL(HBenchmarkResults *, h_benchmark, HParser* parser, HParserTestcase* testcases);
diff --git a/src/internal.h b/src/internal.h
index 89cb38054333fef477e08fbce804ba207b492a23..3c639d02fcb7c1b949f8285e03ef25020dc0a1f4 100644
--- a/src/internal.h
+++ b/src/internal.h
@@ -365,6 +365,7 @@ struct HCFChoice_ {
                     // to execute before action and pred are applied.
   HAction action;
   HPredicate pred;
+  void* user_data;
 };
 
 struct HCFSequence_ {
diff --git a/src/parsers/action.c b/src/parsers/action.c
index 52c9bc1e9fdb12c0274f350d546dcde4a73036f6..e254a894320099d930e6fe08ddaa30e8d39ff18c 100644
--- a/src/parsers/action.c
+++ b/src/parsers/action.c
@@ -4,6 +4,7 @@
 typedef struct {
   const HParser *p;
   HAction action;
+  void* user_data;
 } HParseAction;
 
 static HParseResult* parse_action(void *env, HParseState *state) {
@@ -12,8 +13,8 @@ static HParseResult* parse_action(void *env, HParseState *state) {
     HParseResult *tmp = h_do_parse(a->p, state);
     //HParsedToken *tok = a->action(h_do_parse(a->p, state));
     if(tmp) {
-        const HParsedToken *tok = a->action(tmp);
-        return make_result(state->arena, (HParsedToken*)tok);
+      const HParsedToken *tok = a->action(tmp, a->user_data);
+      return make_result(state->arena, (HParsedToken*)tok);
     } else
       return NULL;
   } else // either the parser's missing or the action's missing
@@ -27,6 +28,7 @@ static void desugar_action(HAllocator *mm__, HCFStack *stk__, void *env) {
     HCFS_BEGIN_SEQ() {
       HCFS_DESUGAR(a->p);
     } HCFS_END_SEQ();
+    HCFS_THIS_CHOICE->user_data = a->user_data;
     HCFS_THIS_CHOICE->action = a->action;
     HCFS_THIS_CHOICE->reshape = h_act_first;
   } HCFS_END_CHOICE();
@@ -44,7 +46,7 @@ static bool action_isValidCF(void *env) {
 
 static bool h_svm_action_action(HArena *arena, HSVMContext *ctx, void* arg) {
   HParseResult res;
-  HAction action = arg;
+  HParseAction *a = arg;
   assert(ctx->stack_count >= 1);
   if (ctx->stack[ctx->stack_count-1]->token_type != TT_MARK) {
     assert(ctx->stack_count >= 2 && ctx->stack[ctx->stack_count-2]->token_type == TT_MARK);
@@ -56,7 +58,7 @@ static bool h_svm_action_action(HArena *arena, HSVMContext *ctx, void* arg) {
   }
   res.arena = arena;
 
-  HParsedToken *tok = action(&res);
+  HParsedToken *tok = a->action(&res, a->user_data);
   if (tok != NULL)
     ctx->stack[ctx->stack_count-1] = tok;
   else
@@ -69,7 +71,7 @@ static bool action_ctrvm(HRVMProg *prog, void* env) {
   h_rvm_insert_insn(prog, RVM_PUSH, 0);
   if (!h_compile_regex(prog, a->p))
     return false;
-  h_rvm_insert_insn(prog, RVM_ACTION, h_rvm_create_action(prog, h_svm_action_action, a->action));
+  h_rvm_insert_insn(prog, RVM_ACTION, h_rvm_create_action(prog, h_svm_action_action, a));
   return true;
 }
 
@@ -81,13 +83,14 @@ static const HParserVtable action_vt = {
   .compile_to_rvm = action_ctrvm,
 };
 
-HParser* h_action(const HParser* p, const HAction a) {
-  return h_action__m(&system_allocator, p, a);
+HParser* h_action(const HParser* p, const HAction a, void* user_data) {
+  return h_action__m(&system_allocator, p, a, user_data);
 }
 
-HParser* h_action__m(HAllocator* mm__, const HParser* p, const HAction a) {
+HParser* h_action__m(HAllocator* mm__, const HParser* p, const HAction a, void* user_data) {
   HParseAction *env = h_new(HParseAction, 1);
   env->p = p;
   env->action = a;
+  env->user_data = user_data;
   return h_new_parser(mm__, &action_vt, env);
 }
diff --git a/src/parsers/bits.c b/src/parsers/bits.c
index 93b4aef60e9bac7f5fa112d3087192197d3dd0ca..716524ce61a0a35cb0f9581646f72a0efa491c7f 100644
--- a/src/parsers/bits.c
+++ b/src/parsers/bits.c
@@ -17,7 +17,9 @@ static HParseResult* parse_bits(void* env, HParseState *state) {
   return make_result(state->arena, result);
 }
 
-static HParsedToken *reshape_bits(const HParseResult *p, bool signedp) {
+static HParsedToken *reshape_bits(const HParseResult *p, void* signedp_p) {
+  // signedp == NULL iff unsigned
+  bool signedp = (signedp_p != NULL);
   // XXX works only for whole bytes
   // XXX assumes big-endian
   assert(p->ast);
@@ -45,12 +47,6 @@ static HParsedToken *reshape_bits(const HParseResult *p, bool signedp) {
 
   return ret;
 }
-static HParsedToken *reshape_bits_unsigned(const HParseResult *p) {
-  return reshape_bits(p, false);
-}
-static HParsedToken *reshape_bits_signed(const HParseResult *p) {
-  return reshape_bits(p, true);
-}
 
 static void desugar_bits(HAllocator *mm__, HCFStack *stk__, void *env) {
   struct bits_env *bits = (struct bits_env*)env;
@@ -67,9 +63,9 @@ static void desugar_bits(HAllocator *mm__, HCFStack *stk__, void *env) {
 	HCFS_ADD_CHARSET(match_all);
       }
     } HCFS_END_SEQ();
-    HCFS_THIS_CHOICE->reshape = bits->signedp
-      ? reshape_bits_signed
-      : reshape_bits_unsigned;
+    HCFS_THIS_CHOICE->reshape = reshape_bits;
+    HCFS_THIS_CHOICE->user_data = bits->signedp ? HCFS_THIS_CHOICE : NULL; // HCFS_THIS_CHOICE is an arbitrary non-null pointer
+    
   } HCFS_END_CHOICE();
 }
 
diff --git a/src/parsers/optional.c b/src/parsers/optional.c
index c4282a914fb81ae82b1b2ec18bd5d91ec001b5c3..ff9fc15bbf465bd36a0edd4fd1906c1f6077c1b1 100644
--- a/src/parsers/optional.c
+++ b/src/parsers/optional.c
@@ -22,7 +22,7 @@ static bool opt_isValidCF(void *env) {
   return p->vtable->isValidCF(p->env);
 }
 
-static HParsedToken* reshape_optional(const HParseResult *p) {
+static HParsedToken* reshape_optional(const HParseResult *p, void* user_data) {
   assert(p->ast);
   assert(p->ast->token_type == TT_SEQUENCE);
 
@@ -52,6 +52,7 @@ static void desugar_optional(HAllocator *mm__, HCFStack *stk__, void *env) {
     HCFS_BEGIN_SEQ() {
     } HCFS_END_SEQ();
     HCFS_THIS_CHOICE->reshape = reshape_optional;
+    HCFS_THIS_CHOICE->user_data = NULL;
   } HCFS_END_CHOICE();
 }
 
diff --git a/src/parsers/sequence.c b/src/parsers/sequence.c
index bdea8c02a45c4346a7523de97a7f6238ba12c246..42c0913d91e16c973299506976ddd882e993b957 100644
--- a/src/parsers/sequence.c
+++ b/src/parsers/sequence.c
@@ -43,7 +43,7 @@ static bool sequence_isValidCF(void *env) {
   return true;
 }
 
-static HParsedToken *reshape_sequence(const HParseResult *p) {
+static HParsedToken *reshape_sequence(const HParseResult *p, void* user_data) {
   assert(p->ast);
   assert(p->ast->token_type == TT_SEQUENCE);
 
@@ -72,6 +72,7 @@ static void desugar_sequence(HAllocator *mm__, HCFStack *stk__, void *env) {
 	HCFS_DESUGAR(s->p_array[i]);
     } HCFS_END_SEQ();
     HCFS_THIS_CHOICE->reshape = reshape_sequence;
+    HCFS_THIS_CHOICE->user_data = NULL;
   } HCFS_END_CHOICE();
 }
 
diff --git a/src/parsers/token.c b/src/parsers/token.c
index 97886b7afaef94124028c927e354198a705352d1..0a43f8d497180fe3a82e2b86cb4de6826ed1a2cc 100644
--- a/src/parsers/token.c
+++ b/src/parsers/token.c
@@ -20,7 +20,7 @@ static HParseResult* parse_token(void *env, HParseState *state) {
 }
 
 
-static HParsedToken *reshape_token(const HParseResult *p) {
+static HParsedToken *reshape_token(const HParseResult *p, void* user_data) {
   // fetch sequence of uints from p
   assert(p->ast);
   assert(p->ast->token_type == TT_SEQUENCE);
@@ -52,6 +52,7 @@ static void desugar_token(HAllocator *mm__, HCFStack *stk__, void *env) {
 	HCFS_ADD_CHAR(tok->str[i]);
     } HCFS_END_SEQ();
     HCFS_THIS_CHOICE->reshape = reshape_token;
+    HCFS_THIS_CHOICE->user_data = NULL;
   } HCFS_END_CHOICE();
 }
 
diff --git a/src/t_parser.c b/src/t_parser.c
index bba0148aecd5777a8f8199deb4e4b4df4de14bd5..292d1c456fa932265ddc834de0132bbad349f439 100644
--- a/src/t_parser.c
+++ b/src/t_parser.c
@@ -162,7 +162,7 @@ static void test_middle(gconstpointer backend) {
 
 #include <ctype.h>
 
-HParsedToken* upcase(const HParseResult *p) {
+HParsedToken* upcase(const HParseResult *p, void* user_data) {
   switch(p->ast->token_type) {
   case TT_SEQUENCE:
     {
@@ -202,7 +202,8 @@ static void test_action(gconstpointer backend) {
 							h_ch('B'), 
 						      NULL), 
 					       NULL), 
-				    upcase);
+				    upcase,
+				    NULL);
   
   g_check_parse_match(action_, (HParserBackend)GPOINTER_TO_INT(backend), "ab", 2, "(u0x41 u0x42)");
   g_check_parse_match(action_, (HParserBackend)GPOINTER_TO_INT(backend), "AB", 2, "(u0x41 u0x42)");
@@ -433,7 +434,7 @@ static void test_ambiguous(gconstpointer backend) {
   HParser *p_ = h_ch('+');
   HParser *E_ = h_indirect();
   h_bind_indirect(E_, h_choice(h_sequence(E_, p_, E_, NULL), d_, NULL));
-  HParser *expr_ = h_action(E_, h_act_flatten);
+  HParser *expr_ = h_action(E_, h_act_flatten, NULL);
 
   g_check_parse_match(expr_, (HParserBackend)GPOINTER_TO_INT(backend), "d", 1, "(u0x64)");
   g_check_parse_match(expr_, (HParserBackend)GPOINTER_TO_INT(backend), "d+d", 3, "(u0x64 u0x2b u0x64)");