diff --git a/src/hammer.h b/src/hammer.h
index 0791769d729f83a059dcfa030a8b692636e30759..ecb606545e56dd2e3bf8e17041d20bba1f4df02a 100644
--- a/src/hammer.h
+++ b/src/hammer.h
@@ -112,6 +112,8 @@ typedef bool (*HPredicate)(HParseResult *p);
 
 typedef struct HParserVtable_ {
   HParseResult* (*parse)(void *env, HParseState *state);
+  bool (*isValidRegular)(void *env);
+  bool (*isValidCF)(void *env);
 } HParserVtable;
 
 typedef struct HParser_ {
diff --git a/src/parsers/action.c b/src/parsers/action.c
index 0f1686f22245d91e9147ffa0054b512ecfc89fd4..33e33bc38844fbdb114605cae12368fa3cc96190 100644
--- a/src/parsers/action.c
+++ b/src/parsers/action.c
@@ -19,8 +19,20 @@ static HParseResult* parse_action(void *env, HParseState *state) {
     return NULL;
 }
 
+static bool action_isValidRegular(void *env) {
+  HParseAction *a = (HParseAction*)env;
+  return a->p->vtable->isValidRegular(a->p->env);
+}
+
+static bool action_isValidCF(void *env) {
+  HParseAction *a = (HParseAction*)env;
+  return a->p->vtable->isValidCF(a->p->env);
+}
+
 static const HParserVtable action_vt = {
   .parse = parse_action,
+  .isValidRegular = action_isValidRegular,
+  .isValidCF = action_isValidCF,
 };
 
 const HParser* h_action(const HParser* p, const HAction a) {
diff --git a/src/parsers/and.c b/src/parsers/and.c
index 532cbbaf7c249f2fb06c4af47495325614550807..ac51be2902a12c8d1a327c7868dccae2beaf6ba9 100644
--- a/src/parsers/and.c
+++ b/src/parsers/and.c
@@ -11,6 +11,11 @@ static HParseResult *parse_and(void* env, HParseState* state) {
 
 static const HParserVtable and_vt = {
   .parse = parse_and,
+  .isValidRegular = h_false, /* TODO: strictly speaking this should be regular,
+				but it will be a huge amount of work and difficult
+				to get right, so we're leaving it for a future
+				revision. --mlp, 18/12/12 */
+  .isValidCF = h_false,      /* despite TODO above, this remains false. */
 };
 
 
diff --git a/src/parsers/attr_bool.c b/src/parsers/attr_bool.c
index 6fa36f844d94725369d1079e583723b2e0e90356..bfc4976a62da7a83f17a7312874f783afc5a6cbd 100644
--- a/src/parsers/attr_bool.c
+++ b/src/parsers/attr_bool.c
@@ -17,8 +17,20 @@ static HParseResult* parse_attr_bool(void *env, HParseState *state) {
     return NULL;
 }
 
+static bool ab_isValidRegular(void *env) {
+  HAttrBool *ab = (HAttrBool*)env;
+  return ab->p->vtable->isValidRegular(ab->p->env);
+}
+
+static bool ab_isValidCF(void *env) {
+  HAttrBool *ab = (HAttrBool*)env;
+  return ab->p->vtable->isValidCF(ab->p->env);
+}
+
 static const HParserVtable attr_bool_vt = {
   .parse = parse_attr_bool,
+  .isValidRegular = ab_isValidRegular,
+  .isValidCF = ab_isValidCF,
 };
 
 
diff --git a/src/parsers/bits.c b/src/parsers/bits.c
index 196e33bba25d6eab243d18570ac2188acad060a0..c3a40da656cce7e9755601fbda5e5975fd9bed4c 100644
--- a/src/parsers/bits.c
+++ b/src/parsers/bits.c
@@ -18,6 +18,8 @@ static HParseResult* parse_bits(void* env, HParseState *state) {
 
 static const HParserVtable bits_vt = {
   .parse = parse_bits,
+  .isValidRegular = h_true,
+  .isValidCF = h_true,
 };
 const HParser* h_bits(size_t len, bool sign) {
   return h_bits__m(&system_allocator, len, sign);
diff --git a/src/parsers/butnot.c b/src/parsers/butnot.c
index 422e0e1fd64309e57b46b9d17918282aea4a5193..4d5bf5783ef04b7af1fb6bfaac01c84920d4b5bb 100644
--- a/src/parsers/butnot.c
+++ b/src/parsers/butnot.c
@@ -35,8 +35,16 @@ static HParseResult* parse_butnot(void *env, HParseState *state) {
   }
 }
 
+static bool bn_isValidCF(void *env) {
+  HTwoParsers *tp = (HTwoParsers*)env;
+  return (tp->p1->vtable->isValidCF(tp->p1->env) &&
+	  tp->p2->vtable->isValidCF(tp->p2->env));
+}
+
 static const HParserVtable butnot_vt = {
   .parse = parse_butnot,
+  .isValidRegular = h_false,
+  .isValidCF = bn_isValidCF,
 };
 
 const HParser* h_butnot(const HParser* p1, const HParser* p2) {
diff --git a/src/parsers/ch.c b/src/parsers/ch.c
index 032731e9d215019e30f8457925af388b4cb53447..8b67744e16aebe1325faaea4b2d130f819026277 100644
--- a/src/parsers/ch.c
+++ b/src/parsers/ch.c
@@ -14,6 +14,8 @@ static HParseResult* parse_ch(void* env, HParseState *state) {
 
 static const HParserVtable ch_vt = {
   .parse = parse_ch,
+  .isValidRegular = h_true,
+  .isValidCF = h_true,
 };
 
 const HParser* h_ch(const uint8_t c) {
diff --git a/src/parsers/charset.c b/src/parsers/charset.c
index f11715ff1ac1670d229ab4c1906c92da59fffc20..7341e0074372bab16bd219aacf5c46a3c4346959 100644
--- a/src/parsers/charset.c
+++ b/src/parsers/charset.c
@@ -34,6 +34,8 @@ static HParseResult* parse_charset(void *env, HParseState *state) {
 
 static const HParserVtable charset_vt = {
   .parse = parse_charset,
+  .isValidRegular = h_true,
+  .isValidCF = h_true,
 };
 
 const HParser* h_ch_range(const uint8_t lower, const uint8_t upper) {
diff --git a/src/parsers/choice.c b/src/parsers/choice.c
index 73dedde6cdb1b7c8ff3f2d036b52e1ce9e8b9d3a..d48ed229db32b6d9b542f3054298514a8f717542 100644
--- a/src/parsers/choice.c
+++ b/src/parsers/choice.c
@@ -21,8 +21,28 @@ static HParseResult* parse_choice(void *env, HParseState *state) {
   return NULL;
 }
 
+static bool choice_isValidRegular(void *env) {
+  HSequence *s = (HSequence*)env;
+  for (size_t i=0; i<s->len; ++i) {
+    if (!s->p_array[i]->vtable->isValidRegular(s->p_array[i]->env))
+      return false;
+  }
+  return true;
+}
+
+static bool choice_isValidCF(void *env) {
+  HSequence *s = (HSequence*)env;
+  for (size_t i=0; i<s->len; ++i) {
+    if (!s->p_array[i]->vtable->isValidCF(s->p_array[i]->env))
+      return false;
+  }
+  return true;
+}
+
 static const HParserVtable choice_vt = {
   .parse = parse_choice,
+  .isValidRegular = choice_isValidRegular,
+  .isValidCF = choice_isValidCF,
 };
 
 const HParser* h_choice(const HParser* p, ...) {
diff --git a/src/parsers/difference.c b/src/parsers/difference.c
index c6cc69cef86bfba3537b3c98c8a2777447c4f598..e3c41ec33a7f2e36b80f681bf0de9e8f71faa2b4 100644
--- a/src/parsers/difference.c
+++ b/src/parsers/difference.c
@@ -34,8 +34,16 @@ static HParseResult* parse_difference(void *env, HParseState *state) {
   }
 }
 
+static bool diff_isValidCF(void *env) {
+  HTwoParsers *tp = (HTwoParsers*)env;
+  return (tp->p1->vtable->isValidCF(tp->p1->env) &&
+	  tp->p2->vtable->isValidCF(tp->p2->env));
+}
+
 static HParserVtable difference_vt = {
   .parse = parse_difference,
+  .isValidRegular = h_false,
+  .isValidCF = diff_isValidCF,
 };
 
 const HParser* h_difference(const HParser* p1, const HParser* p2) {
diff --git a/src/parsers/end.c b/src/parsers/end.c
index 0f0d1c7d6c66375256f540f2a00b849ff82170fa..45ba37d99ae0df6a282df0540513064b3ecf030a 100644
--- a/src/parsers/end.c
+++ b/src/parsers/end.c
@@ -12,6 +12,8 @@ static HParseResult* parse_end(void *env, HParseState *state) {
 
 static const HParserVtable end_vt = {
   .parse = parse_end,
+  .isValidRegular = h_true,
+  .isValidCF = h_true,
 };
 
 const HParser* h_end_p() {
diff --git a/src/parsers/epsilon.c b/src/parsers/epsilon.c
index ae959cd5455d55cb31446316001ade32904a63c4..5ae91e360fcc3b273e1345ff057d764edabd0312 100644
--- a/src/parsers/epsilon.c
+++ b/src/parsers/epsilon.c
@@ -10,6 +10,8 @@ static HParseResult* parse_epsilon(void* env, HParseState* state) {
 
 static const HParserVtable epsilon_vt = {
   .parse = parse_epsilon,
+  .isValidRegular = h_true,
+  .isValidCF = h_true,
 };
 
 static const HParser epsilon_p = {
diff --git a/src/parsers/ignore.c b/src/parsers/ignore.c
index 03cdc107102841e16449aa7483171a8f3e42b33f..6191eff91ffe068049b597ef11662fc4311a924c 100644
--- a/src/parsers/ignore.c
+++ b/src/parsers/ignore.c
@@ -10,8 +10,20 @@ static HParseResult* parse_ignore(void* env, HParseState* state) {
   return res;
 }
 
+static bool ignore_isValidRegular(void *env) {
+  HParser *p = (HParser*)env;
+  return (p->vtable->isValidRegular(p->env));
+}
+
+static bool ignore_isValidCF(void *env) {
+  HParser *p = (HParser*)env;
+  return (p->vtable->isValidCF(p->env));
+}
+
 static const HParserVtable ignore_vt = {
   .parse = parse_ignore,
+  .isValidRegular = ignore_isValidRegular,
+  .isValidCF = ignore_isValidCF,
 };
 
 const HParser* h_ignore(const HParser* p) {
diff --git a/src/parsers/ignoreseq.c b/src/parsers/ignoreseq.c
index 228f63575febe5021b272c65a69b701089e7e081..319f1ebe3eb3058a78e03bec6b39112b1a19f6d0 100644
--- a/src/parsers/ignoreseq.c
+++ b/src/parsers/ignoreseq.c
@@ -7,7 +7,7 @@
 
 typedef struct {
   const HParser **parsers;
-  size_t count;         // how many parsers in 'ps'
+  size_t len;         // how many parsers in 'ps'
   size_t which;         // whose result to return
 } HIgnoreSeq;
 
@@ -15,7 +15,7 @@ static HParseResult* parse_ignoreseq(void* env, HParseState *state) {
   const HIgnoreSeq *seq = (HIgnoreSeq*)env;
   HParseResult *res = NULL;
 
-  for (size_t i=0; i < seq->count; ++i) {
+  for (size_t i=0; i < seq->len; ++i) {
     HParseResult *tmp = h_do_parse(seq->parsers[i], state);
     if (!tmp)
       return NULL;
@@ -26,8 +26,28 @@ static HParseResult* parse_ignoreseq(void* env, HParseState *state) {
   return res;
 }
 
+static bool is_isValidRegular(void *env) {
+  HIgnoreSeq *seq = (HIgnoreSeq*)env;
+  for (size_t i=0; i<seq->len; ++i) {
+    if (!seq->parsers[i]->vtable->isValidRegular(seq->parsers[i]->env))
+      return false;
+  }
+  return true;
+}
+
+static bool is_isValidCF(void *env) {
+  HIgnoreSeq *seq = (HIgnoreSeq*)env;
+  for (size_t i=0; i<seq->len; ++i) {
+    if (!seq->parsers[i]->vtable->isValidCF(seq->parsers[i]->env))
+      return false;
+  }
+  return true;
+}
+
 static const HParserVtable ignoreseq_vt = {
   .parse = parse_ignoreseq,
+  .isValidRegular = is_isValidRegular,
+  .isValidCF = is_isValidCF,
 };
 
 
@@ -40,7 +60,7 @@ static const HParser* h_leftright__m(HAllocator* mm__, const HParser* p, const H
   seq->parsers = h_new(const HParser*, 2);
   seq->parsers[0] = p;
   seq->parsers[1] = q;
-  seq->count = 2;
+  seq->len = 2;
   seq->which = which;
 
   HParser *ret = h_new(HParser, 1);
@@ -73,7 +93,7 @@ const HParser* h_middle__m(HAllocator* mm__, const HParser* p, const HParser* x,
   seq->parsers[0] = p;
   seq->parsers[1] = x;
   seq->parsers[2] = q;
-  seq->count = 3;
+  seq->len = 3;
   seq->which = 1;
 
   HParser *ret = h_new(HParser, 1);
diff --git a/src/parsers/indirect.c b/src/parsers/indirect.c
index 96e2a65d4c32f6cb2ea8b3cb05e4e230ab91c4d4..4415f067e8f5e26ddf29f4490c33af03b90613f1 100644
--- a/src/parsers/indirect.c
+++ b/src/parsers/indirect.c
@@ -3,8 +3,17 @@
 static HParseResult* parse_indirect(void* env, HParseState* state) {
   return h_do_parse(env, state);
 }
+
+static bool indirect_isValidCF(void *env) {
+  HParser *p = (HParser*)env;
+  HParser *inner = (HParser*)p->env;
+  return inner->vtable->isValidCF(inner->env);
+}
+
 static const HParserVtable indirect_vt = {
   .parse = parse_indirect,
+  .isValidRegular = h_false,
+  .isValidCF = indirect_isValidCF,
 };
 
 void h_bind_indirect(HParser* indirect, const HParser* inner) {
diff --git a/src/parsers/int_range.c b/src/parsers/int_range.c
index 2a1db63ca3c3c6bc103e8b941ed0e7119ba91d17..d1920589a90bbda21ad1ebf8af48135e69a45774 100644
--- a/src/parsers/int_range.c
+++ b/src/parsers/int_range.c
@@ -30,6 +30,8 @@ static HParseResult* parse_int_range(void *env, HParseState *state) {
 
 static const HParserVtable int_range_vt = {
   .parse = parse_int_range,
+  .isValidRegular = h_true,
+  .isValidCF = h_true,
 };
 
 const HParser* h_int_range(const HParser *p, const int64_t lower, const int64_t upper) {
diff --git a/src/parsers/many.c b/src/parsers/many.c
index 6cb818bcbe8c6ea9be45ead32b76711eab32968b..2c2577efc2811e97e5373a2169dc4a48fb281118 100644
--- a/src/parsers/many.c
+++ b/src/parsers/many.c
@@ -44,8 +44,22 @@ static HParseResult *parse_many(void* env, HParseState *state) {
   return NULL;
 }
 
+static bool many_isValidRegular(void *env) {
+  HRepeat *repeat = (HRepeat*)env;
+  return (repeat->p->vtable->isValidRegular(repeat->p->env) &&
+	  repeat->sep->vtable->isValidRegular(repeat->sep->env));
+}
+
+static bool many_isValidCF(void *env) {
+  HRepeat *repeat = (HRepeat*)env;
+  return (repeat->p->vtable->isValidCF(repeat->p->env) &&
+	  repeat->sep->vtable->isValidCF(repeat->sep->env));
+}
+
 static const HParserVtable many_vt = {
   .parse = parse_many,
+  .isValidRegular = many_isValidRegular,
+  .isValidCF = many_isValidCF,
 };
 
 const HParser* h_many(const HParser* p) {
@@ -147,6 +161,8 @@ static HParseResult* parse_length_value(void *env, HParseState *state) {
 
 static const HParserVtable length_value_vt = {
   .parse = parse_length_value,
+  .isValidRegular = h_false,
+  .isValidCF = h_false,
 };
 
 const HParser* h_length_value(const HParser* length, const HParser* value) {
diff --git a/src/parsers/not.c b/src/parsers/not.c
index 73cf1295fc695d082058798b5a3f88522d34d891..6642d9e838d3e1f78a2737144b273e061f825b43 100644
--- a/src/parsers/not.c
+++ b/src/parsers/not.c
@@ -12,6 +12,8 @@ static HParseResult* parse_not(void* env, HParseState* state) {
 
 static const HParserVtable not_vt = {
   .parse = parse_not,
+  .isValidRegular = h_false,  /* see and.c for why */
+  .isValidCF = h_false,       /* also see and.c for why */
 };
 
 const HParser* h_not(const HParser* p) {
diff --git a/src/parsers/nothing.c b/src/parsers/nothing.c
index 120c8ef305498bc8d4fe15baa8935196f00b9caa..01c029ebfc872828fd7fe17f3de1ab23c294ad85 100644
--- a/src/parsers/nothing.c
+++ b/src/parsers/nothing.c
@@ -8,6 +8,8 @@ static HParseResult* parse_nothing() {
 
 static const HParserVtable nothing_vt = {
   .parse = parse_nothing,
+  .isValidRegular = h_true,
+  .isValidCF = h_true,
 };
 
 const HParser* h_nothing_p() {
diff --git a/src/parsers/optional.c b/src/parsers/optional.c
index 9625fa0f5cf2c40011e1317222f312006eb33b27..0b405e5a2dda1515254a2a61127acef9d55f1def 100644
--- a/src/parsers/optional.c
+++ b/src/parsers/optional.c
@@ -11,8 +11,20 @@ static HParseResult* parse_optional(void* env, HParseState* state) {
   return make_result(state, ast);
 }
 
+static bool opt_isValidRegular(void *env) {
+  HParser *p = (HParser*) env;
+  return p->vtable->isValidRegular(p->env);
+}
+
+static bool opt_isValidCF(void *env) {
+  HParser *p = (HParser*) env;
+  return p->vtable->isValidCF(p->env);
+}
+
 static const HParserVtable optional_vt = {
   .parse = parse_optional,
+  .isValidRegular = opt_isValidRegular,
+  .isValidCF = opt_isValidCF,
 };
 
 const HParser* h_optional(const HParser* p) {
diff --git a/src/parsers/sequence.c b/src/parsers/sequence.c
index 21ae31d959c8cdab9a323a0f63667654d5813bba..f5e19246fdf0653e84281ccf55e3fcc3577a4f48 100644
--- a/src/parsers/sequence.c
+++ b/src/parsers/sequence.c
@@ -24,8 +24,28 @@ static HParseResult* parse_sequence(void *env, HParseState *state) {
   return make_result(state, tok);
 }
 
+static bool sequence_isValidRegular(void *env) {
+  HSequence *s = (HSequence*)env;
+  for (size_t i=0; i<s->len; ++i) {
+    if (!s->p_array[i]->vtable->isValidRegular(s->p_array[i]->env))
+      return false;
+  }
+  return true;
+}
+
+static bool sequence_isValidCF(void *env) {
+  HSequence *s = (HSequence*)env;
+  for (size_t i=0; i<s->len; ++i) {
+    if (!s->p_array[i]->vtable->isValidCF(s->p_array[i]->env))
+      return false;
+  }
+  return true;
+}
+
 static const HParserVtable sequence_vt = {
   .parse = parse_sequence,
+  .isValidRegular = sequence_isValidRegular,
+  .isValidCF = sequence_isValidCF,
 };
 
 const HParser* h_sequence(const HParser* p, ...) {
diff --git a/src/parsers/token.c b/src/parsers/token.c
index 13bafbb0b8fc9aaa62d939695303af17afd93fc3..f5df9d4c3c3a84829a026b66fcb02c849db1d530 100644
--- a/src/parsers/token.c
+++ b/src/parsers/token.c
@@ -22,6 +22,8 @@ static HParseResult* parse_token(void *env, HParseState *state) {
 
 const HParserVtable token_vt = {
   .parse = parse_token,
+  .isValidRegular = h_true,
+  .isValidCF = h_true,
 };
 
 const HParser* h_token(const uint8_t *str, const size_t len) {
diff --git a/src/parsers/unimplemented.c b/src/parsers/unimplemented.c
index 35ee391c228246698f13da7b68b4524f732d228e..32838ce5ce499569491c4fd6599d97a4947a54b5 100644
--- a/src/parsers/unimplemented.c
+++ b/src/parsers/unimplemented.c
@@ -14,6 +14,8 @@ static HParseResult* parse_unimplemented(void* env, HParseState *state) {
 
 static const HParserVtable unimplemented_vt = {
   .parse = parse_unimplemented,
+  .isValidRegular = h_false,
+  .isValidCF = h_false,
 };
 
 static HParser unimplemented = {
diff --git a/src/parsers/whitespace.c b/src/parsers/whitespace.c
index 8e009a43df268bc73257a98d6b790dfc3b1ec928..7b2477bef0bfd67a41adcce99c0e5b0662b87c08 100644
--- a/src/parsers/whitespace.c
+++ b/src/parsers/whitespace.c
@@ -14,8 +14,20 @@ static HParseResult* parse_whitespace(void* env, HParseState *state) {
   return h_do_parse((HParser*)env, state);
 }
 
+static bool ws_isValidRegular(void *env) {
+  HParser *p = (HParser*)env;
+  return p->vtable->isValidRegular(p->env);
+}
+
+static bool ws_isValidCF(void *env) {
+  HParser *p = (HParser*)env;
+  return p->vtable->isValidCF(p->env);
+}
+
 static const HParserVtable whitespace_vt = {
   .parse = parse_whitespace,
+  .isValidRegular = ws_isValidRegular,
+  .isValidCF = ws_isValidCF,
 };
 
 const HParser* h_whitespace(const HParser* p) {
diff --git a/src/parsers/xor.c b/src/parsers/xor.c
index a11ad4aeae80d8589569729fd3e429e6eeb0c5a6..7679a645055660960c6d4f674fd30b69e81990f9 100644
--- a/src/parsers/xor.c
+++ b/src/parsers/xor.c
@@ -31,8 +31,16 @@ static HParseResult* parse_xor(void *env, HParseState *state) {
   }
 }
 
+static bool xor_isValidCF(void *env) {
+  HTwoParsers *tp = (HTwoParsers*)env;
+  return (tp->p1->vtable->isValidCF(tp->p1->env) &&
+	  tp->p2->vtable->isValidCF(tp->p2->env));
+}
+
 static const HParserVtable xor_vt = {
   .parse = parse_xor,
+  .isValidRegular = h_false,
+  .isValidCF = xor_isValidCF,
 };
 
 const HParser* h_xor(const HParser* p1, const HParser* p2) {