From 947b67b5a5e08cfdd2556e2e5eb19180a80a2b05 Mon Sep 17 00:00:00 2001
From: "Meredith L. Patterson" <clonearmy@gmail.com>
Date: Thu, 24 May 2012 11:01:18 +0200
Subject: [PATCH 1/9] Continuing with DNS. Added some checks to attr_bool, and
 explained checks in docs.

---
 examples/dns.c | 65 ++++++++++++++++++++++++++++++++++++++------------
 src/hammer.c   | 30 +++++++++++++++++------
 src/hammer.h   | 14 ++++++++++-
 3 files changed, 86 insertions(+), 23 deletions(-)

diff --git a/examples/dns.c b/examples/dns.c
index 027d675..9cf56b9 100644
--- a/examples/dns.c
+++ b/examples/dns.c
@@ -1,16 +1,48 @@
 #include "../hammer.h"
 
 bool is_zero(parse_result_t *p) {
+  if (TT_UINT != p->ast->token_type)
+    return 0;
   return (0 == p->ast->uint);
 }
 
-bool validate_dns(parse_result_t *p) {
-  
+/**
+ * A label can't be more than 63 characters.
+ */
+bool validate_label(parse_result_t *p) {
+  if (TT_SEQ != p->ast->token_type)
+    return 0;
+  return (64 > p->ast->seq->used);
 }
 
-int main(int argc, char **argv) {
+/**
+ * Every DNS message should have QDCOUNT entries in the question
+ * section, and ANCOUNT+NSCOUNT+ARCOUNT resource records.
+ *
+ */
+bool validate_dns(parse_result_t *p) {
+  if (TT_SEQ != p->ast->token_type)
+    return 0;
+  // The header holds the counts as its last 4 elements.
+  parsed_token_t *header = p->ast->seq->elements[0];
+  size_t qd = header->seq->elements[8];
+  size_t an = header->seq->elements[9];
+  size_t ns = header->seq->elements[10];
+  size_t ar = header->seq->elements[11];
+  parsed_token_t *questions = p->ast->seq->elements[1];
+  if (questions->seq->used != qd)
+    return false;
+  parsed_token_t *rrs = p->ast->seq->elements[2];
+  if (an+ns+ar != rrs->seq->used)
+    return false;
+}
 
-  const parser_t dns_header = sequence(bits(16, false), // ID
+parser_t init_parser() {
+  static parser_t *dns_message = NULL;
+  if (dns_message)
+    return dns_message;
+
+  const parser_t *dns_header = sequence(bits(16, false), // ID
 				       bits(1, false),  // QR
 				       bits(4, false),  // opcode
 				       bits(1, false),  // AA
@@ -42,11 +74,12 @@ int main(int argc, char **argv) {
 					 ch('-'),
 					 NULL));
 
-  const parser_t *label = sequence(letter,
-				   optional(sequence(optional(ldh_str),
-						     let_dig,
-						     NULL)),
-				   NULL);
+  const parser_t *label = attr_bool(sequence(letter,
+					     optional(sequence(optional(ldh_str),
+							       let_dig,
+							       NULL)),
+					     NULL),
+				    validate_label);
 
   /**
    * You could write it like this ...
@@ -76,10 +109,12 @@ int main(int argc, char **argv) {
 				    NULL);
 
 
-  const parser_t *dns_message = attr_bool(sequence(dns_header,
-						   dns_question,
-						   many(dns_rr),
-						   end_p(),
-						   NULL),
-					  validate_dns);
+  dns_message = attr_bool(sequence(dns_header,
+				   many(dns_question),
+				   many(dns_rr),
+				   end_p(),
+				   NULL),
+			  validate_dns);
+
+  return dns_message;
 }
diff --git a/src/hammer.c b/src/hammer.c
index 4742985..e0b4c2d 100644
--- a/src/hammer.c
+++ b/src/hammer.c
@@ -311,11 +311,6 @@ const parser_t* ch(const uint8_t c) {
   return (const parser_t*)ret;
 }
 
-typedef struct {
-  uint8_t lower;
-  uint8_t upper;
-} range_t;
-
 static parse_result_t* parse_whitespace(void* env, parse_state_t *state) {
   char c;
   input_stream_t bak;
@@ -374,7 +369,7 @@ static parse_result_t* parse_charset(void *env, parse_state_t *state) {
     return NULL;
 }
 
-const parser_t* range(const uint8_t lower, const uint8_t upper) {
+const parser_t* ch_range(const uint8_t lower, const uint8_t upper) {
   parser_t *ret = g_new(parser_t, 1);
   charset cs = new_charset();
   for (int i = 0; i < 256; i++)
@@ -383,6 +378,27 @@ const parser_t* range(const uint8_t lower, const uint8_t upper) {
   return (const parser_t*)ret;
 }
 
+typedef struct {
+  int64_t lower;
+  int64_t upper;
+} range_t;
+
+const parser_t* int_range(const int64_t lower, const int64_t upper) {
+  struct bits_env env = p->env;
+  // p must be an integer parser, which means it's using parse_bits;
+  // if it's a uint parser, it can't be uint64
+  assert_message(p->fn == parse_bits, "int_range requires an integer parser"); 
+  assert_message(!(env->signed) ? (env->length < 64) : true, "int_range can't use a uint64 parser");
+
+  range_t *env = g_new(range_t, 1);
+  env->lower = lower;
+  env->upper = upper;
+  parser_t *ret = g_new(parser_t, 1);
+  ret->fn = parse_int_range;
+  ret->env = (void*)env;
+  return ret;
+}
+
 const parser_t* not_in(const uint8_t *options, int count) {
   parser_t *ret = g_new(parser_t, 1);
   charset cs = new_charset();
@@ -829,7 +845,7 @@ typedef struct {
 static parse_result_t* parse_attr_bool(void *env, parse_state_t *state) {
   attr_bool_t *a = (attr_bool_t*)env;
   parse_result_t *res = do_parse(a->p, state);
-  if (res) {
+  if (res && res->ast) {
     if (a->pred(res))
       return res;
     else
diff --git a/src/hammer.h b/src/hammer.h
index a0b93e5..c59cdbc 100644
--- a/src/hammer.h
+++ b/src/hammer.h
@@ -129,7 +129,14 @@ const parser_t* ch(const uint8_t c);
  * 
  * Result token type: TT_UINT
  */
-const parser_t* range(const uint8_t lower, const uint8_t upper);
+const parser_t* ch_range(const uint8_t lower, const uint8_t upper);
+
+/**
+ * Given an integer parser, p, and two integer bounds, lower and upper,
+ * returns a parser that parses an integral value within the range 
+ * [lower, upper] (inclusive).
+ */
+const parser_t* int_range(const parser_t *p, const int64_t lower, const int64_t upper);
 
 /**
  * Returns a parser that parses the specified number of bits. sign == 
@@ -359,8 +366,13 @@ const parser_t* length_value(const parser_t* length, const parser_t* value);
  * This parser attaches a predicate function, which returns true or 
  * false, to a parser. The function is evaluated over the parser's 
  * result. 
+ *
  * The parse only succeeds if the attribute function returns true. 
  *
+ * attr_bool will check whether p's result exists and whether p's 
+ * result AST exists; you do not need to check for this in your 
+ * predicate function.
+ * 
  * Result token type: p's result type if pred succeeded, NULL otherwise.
  */
 const parser_t* attr_bool(const parser_t* p, predicate_t pred);

From 7ab9f7c92f092637add56e7b03cc518c8d95f283 Mon Sep 17 00:00:00 2001
From: "Meredith L. Patterson" <clonearmy@gmail.com>
Date: Thu, 24 May 2012 12:00:23 +0200
Subject: [PATCH 2/9] Fixed problems stemming from renaming of range to
 ch_range

---
 src/hammer.c | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/hammer.c b/src/hammer.c
index e0b4c2d..8dada06 100644
--- a/src/hammer.c
+++ b/src/hammer.c
@@ -383,19 +383,23 @@ typedef struct {
   int64_t upper;
 } range_t;
 
-const parser_t* int_range(const int64_t lower, const int64_t upper) {
-  struct bits_env env = p->env;
+static parse_result_t* parse_int_range(void *env, parse_state_t *state) {
+  return NULL;
+}
+
+const parser_t* int_range(const parser_t *p, const int64_t lower, const int64_t upper) {
+  struct bits_env *b_env = p->env;
   // p must be an integer parser, which means it's using parse_bits;
   // if it's a uint parser, it can't be uint64
   assert_message(p->fn == parse_bits, "int_range requires an integer parser"); 
-  assert_message(!(env->signed) ? (env->length < 64) : true, "int_range can't use a uint64 parser");
+  assert_message(!(b_env->signedp) ? (b_env->length < 64) : true, "int_range can't use a uint64 parser");
 
-  range_t *env = g_new(range_t, 1);
-  env->lower = lower;
-  env->upper = upper;
+  range_t *r_env = g_new(range_t, 1);
+  r_env->lower = lower;
+  r_env->upper = upper;
   parser_t *ret = g_new(parser_t, 1);
   ret->fn = parse_int_range;
-  ret->env = (void*)env;
+  ret->env = (void*)r_env;
   return ret;
 }
 
@@ -970,8 +974,8 @@ static void test_ch(void) {
   g_check_parse_failed(ch_, "\xa3", 1);
 }
 
-static void test_range(void) {
-  const parser_t *range_ = range('a', 'c');
+static void test_ch_range(void) {
+  const parser_t *range_ = ch_range('a', 'c');
 
   g_check_parse_ok(range_, "b", 1, "u0x62");
   g_check_parse_failed(range_, "d", 1);
@@ -1153,7 +1157,7 @@ static void test_choice(void) {
 
 static void test_butnot(void) {
   const parser_t *butnot_1 = butnot(ch('a'), token((const uint8_t*)"ab", 2));
-  const parser_t *butnot_2 = butnot(range('0', '9'), ch('6'));
+  const parser_t *butnot_2 = butnot(ch_range('0', '9'), ch('6'));
 
   g_check_parse_ok(butnot_1, "a", 1, "u0x61");
   g_check_parse_failed(butnot_1, "ab", 2);
@@ -1169,7 +1173,7 @@ static void test_difference(void) {
 }
 
 static void test_xor(void) {
-  const parser_t *xor_ = xor(range('0', '6'), range('5', '9'));
+  const parser_t *xor_ = xor(ch_range('0', '6'), ch_range('5', '9'));
 
   g_check_parse_ok(xor_, "0", 1, "u0x30");
   g_check_parse_ok(xor_, "9", 1, "u0x39");
@@ -1269,7 +1273,7 @@ static void test_not(void) {
 void register_parser_tests(void) {
   g_test_add_func("/core/parser/token", test_token);
   g_test_add_func("/core/parser/ch", test_ch);
-  g_test_add_func("/core/parser/range", test_range);
+  g_test_add_func("/core/parser/ch_range", test_ch_range);
   g_test_add_func("/core/parser/int64", test_int64);
   g_test_add_func("/core/parser/int32", test_int32);
   g_test_add_func("/core/parser/int16", test_int16);

From a1d6e6022289175b238ddd634f0f842731bd45ac Mon Sep 17 00:00:00 2001
From: "Meredith L. Patterson" <clonearmy@gmail.com>
Date: Thu, 24 May 2012 12:09:38 +0200
Subject: [PATCH 3/9] fixed int_range, too

---
 src/hammer.c | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/hammer.c b/src/hammer.c
index 8dada06..9fdf215 100644
--- a/src/hammer.c
+++ b/src/hammer.c
@@ -379,12 +379,32 @@ const parser_t* ch_range(const uint8_t lower, const uint8_t upper) {
 }
 
 typedef struct {
+  const parser_t *p;
   int64_t lower;
   int64_t upper;
 } range_t;
 
 static parse_result_t* parse_int_range(void *env, parse_state_t *state) {
-  return NULL;
+  range_t *r_env = (range_t*)env;
+  if (!r_env->p)
+    return NULL;
+  parse_result_t *ret = do_parse(r_env->p, state);
+  if (!ret || !ret->ast)
+    return NULL;
+  switch(ret->ast->token_type) {
+  case TT_SINT:
+    if (r_env->lower <= ret->ast->sint && r_env->upper >= ret->ast->sint)
+      return ret;
+    else
+      return NULL;
+  case TT_UINT:
+    if ((uint64_t)r_env->lower <= ret->ast->uint && (uint64_t)r_env->upper >= ret->ast->uint)
+      return ret;
+    else
+      return NULL;
+  default:
+    return NULL;
+  }
 }
 
 const parser_t* int_range(const parser_t *p, const int64_t lower, const int64_t upper) {
@@ -395,6 +415,7 @@ const parser_t* int_range(const parser_t *p, const int64_t lower, const int64_t
   assert_message(!(b_env->signedp) ? (b_env->length < 64) : true, "int_range can't use a uint64 parser");
 
   range_t *r_env = g_new(range_t, 1);
+  r_env->p = p;
   r_env->lower = lower;
   r_env->upper = upper;
   parser_t *ret = g_new(parser_t, 1);

From 7626f083f5137580ae1a1abab1b79797cc3de4dc Mon Sep 17 00:00:00 2001
From: "Meredith L. Patterson" <clonearmy@gmail.com>
Date: Thu, 24 May 2012 12:16:33 +0200
Subject: [PATCH 4/9] didn't actually need that check

---
 src/hammer.c | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/hammer.c b/src/hammer.c
index 9fdf215..8940822 100644
--- a/src/hammer.c
+++ b/src/hammer.c
@@ -386,8 +386,6 @@ typedef struct {
 
 static parse_result_t* parse_int_range(void *env, parse_state_t *state) {
   range_t *r_env = (range_t*)env;
-  if (!r_env->p)
-    return NULL;
   parse_result_t *ret = do_parse(r_env->p, state);
   if (!ret || !ret->ast)
     return NULL;

From 13fab7e49cc5c9ed0d0d45fee94cfe7e6d514283 Mon Sep 17 00:00:00 2001
From: "Meredith L. Patterson" <clonearmy@gmail.com>
Date: Thu, 24 May 2012 12:23:55 +0200
Subject: [PATCH 5/9] int_range passes test

---
 src/hammer.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/hammer.c b/src/hammer.c
index 8940822..cad143a 100644
--- a/src/hammer.c
+++ b/src/hammer.c
@@ -1058,6 +1058,13 @@ static void test_uint8(void) {
 }
 //@MARK_END
 
+static void test_int_range(void) {
+  const parser_t *int_range_ = int_range(uint8(), 3, 10);
+  
+  g_check_parse_ok(int_range_, "\x05", 1, "u0x5");
+  g_check_parse_failed(int_range_, "\xb", 1);
+}
+
 #if 0
 static void test_float64(void) {
   const parser_t *float64_ = float64();
@@ -1301,6 +1308,7 @@ void register_parser_tests(void) {
   g_test_add_func("/core/parser/uint32", test_uint32);
   g_test_add_func("/core/parser/uint16", test_uint16);
   g_test_add_func("/core/parser/uint8", test_uint8);
+  g_test_add_func("/core/parser/int_range", test_int_range);
 #if 0
   g_test_add_func("/core/parser/float64", test_float64);
   g_test_add_func("/core/parser/float32", test_float32);

From 8e7a5cc2d37a43de42f2c95269e0355eef139ab6 Mon Sep 17 00:00:00 2001
From: "Meredith L. Patterson" <clonearmy@gmail.com>
Date: Thu, 24 May 2012 12:43:32 +0200
Subject: [PATCH 6/9] getting the examples into the build, dns validator needs
 finished

---
 Makefile          |  2 +-
 examples/Makefile | 15 +++++++++++++++
 examples/dns.c    | 45 ++++++++++++++++++++++++---------------------
 3 files changed, 40 insertions(+), 22 deletions(-)
 create mode 100644 examples/Makefile

diff --git a/Makefile b/Makefile
index 27ee4d3..08ce4e1 100644
--- a/Makefile
+++ b/Makefile
@@ -3,7 +3,7 @@
 # and kick off a recursive make
 # Also, "make src/all" turns into "make -C src all"
 
-SUBDIRS = src
+SUBDIRS = src examples
 
 .DEFAULT_GOAL := all
 
diff --git a/examples/Makefile b/examples/Makefile
new file mode 100644
index 0000000..7ecd47a
--- /dev/null
+++ b/examples/Makefile
@@ -0,0 +1,15 @@
+
+OUTPUTS := dns.o \
+	   dns
+
+TOPLEVEL := ../
+
+include ../common.mk
+
+
+all: dns
+
+dns: dns.o
+	$(call hush, "Linking $@") $(CC) -o $@ $^ $(LDFLAGS)
+
+dns.o: ../src/hammer.h
diff --git a/examples/dns.c b/examples/dns.c
index 9cf56b9..26f4854 100644
--- a/examples/dns.c
+++ b/examples/dns.c
@@ -1,4 +1,7 @@
-#include "../hammer.h"
+#include "../src/hammer.h"
+
+#define false 0
+#define true 1
 
 bool is_zero(parse_result_t *p) {
   if (TT_UINT != p->ast->token_type)
@@ -10,7 +13,7 @@ bool is_zero(parse_result_t *p) {
  * A label can't be more than 63 characters.
  */
 bool validate_label(parse_result_t *p) {
-  if (TT_SEQ != p->ast->token_type)
+  if (TT_SEQUENCE != p->ast->token_type)
     return 0;
   return (64 > p->ast->seq->used);
 }
@@ -21,23 +24,23 @@ bool validate_label(parse_result_t *p) {
  *
  */
 bool validate_dns(parse_result_t *p) {
-  if (TT_SEQ != p->ast->token_type)
+  if (TT_SEQUENCE != p->ast->token_type)
     return 0;
   // The header holds the counts as its last 4 elements.
   parsed_token_t *header = p->ast->seq->elements[0];
-  size_t qd = header->seq->elements[8];
-  size_t an = header->seq->elements[9];
-  size_t ns = header->seq->elements[10];
-  size_t ar = header->seq->elements[11];
+  size_t qd = ((parsed_token_t*)header->seq->elements[8])->uint;
+  size_t an = ((parsed_token_t*)header->seq->elements[9])->uint;
+  size_t ns = ((parsed_token_t*)header->seq->elements[10])->uint;
+  size_t ar = ((parsed_token_t*)header->seq->elements[11])->uint;
   parsed_token_t *questions = p->ast->seq->elements[1];
   if (questions->seq->used != qd)
-    return false;
+    return 0;
   parsed_token_t *rrs = p->ast->seq->elements[2];
   if (an+ns+ar != rrs->seq->used)
-    return false;
+    return 0;
 }
 
-parser_t init_parser() {
+parser_t* init_parser() {
   static parser_t *dns_message = NULL;
   if (dns_message)
     return dns_message;
@@ -62,12 +65,12 @@ parser_t init_parser() {
 					  uint16(),                       // QCLASS
 					  NULL);
 
-  const parser_t *letter = choice(range('a', 'z'),
-				  range('A', 'Z'),
+  const parser_t *letter = choice(ch_range('a', 'z'),
+				  ch_range('A', 'Z'),
 				  NULL);
 
   const parser_t *let_dig = choice(letter,
-				   range('0', '9'),
+				   ch_range('0', '9'),
 				   NULL);
 
   const parser_t *ldh_str = many1(choice(let_dig,
@@ -95,7 +98,7 @@ parser_t init_parser() {
    * ... but this is easier and equivalent
    */
 
-  parser_t *subdomain = sepBy1(label, ch('.'));
+  const parser_t *subdomain = sepBy1(label, ch('.'));
 
   const parser_t *domain = choice(subdomain, 
 				  ch(' '), 
@@ -105,16 +108,16 @@ parser_t init_parser() {
 				    uint16(),                       // TYPE
 				    uint16(),                       // CLASS
 				    uint32(),                       // TTL
-				    length_value(uint16(), uint8()) // RDLENGTH+RDATA
+				    length_value(uint16(), uint8()), // RDLENGTH+RDATA
 				    NULL);
 
 
-  dns_message = attr_bool(sequence(dns_header,
-				   many(dns_question),
-				   many(dns_rr),
-				   end_p(),
-				   NULL),
-			  validate_dns);
+  dns_message = (parser_t*)attr_bool(sequence(dns_header,
+					      many(dns_question),
+					      many(dns_rr),
+					      end_p(),
+					      NULL),
+				     validate_dns);
 
   return dns_message;
 }

From 13395d8a54245380f13a1c588166d3d4c5a04e2c Mon Sep 17 00:00:00 2001
From: "Meredith L. Patterson" <clonearmy@gmail.com>
Date: Thu, 24 May 2012 13:22:43 +0200
Subject: [PATCH 7/9] counted_array now holds parsed_token_t's. TQ will fix the
 problem with accumulate_size. Compile-time bounds checks added to int_range.

---
 examples/dns.c | 35 +++++++++++++++++++++++-----------
 src/hammer.c   | 51 ++++++++++++++++++++++++++++----------------------
 src/hammer.h   |  4 +++-
 3 files changed, 56 insertions(+), 34 deletions(-)

diff --git a/examples/dns.c b/examples/dns.c
index 26f4854..c2fc59d 100644
--- a/examples/dns.c
+++ b/examples/dns.c
@@ -5,7 +5,7 @@
 
 bool is_zero(parse_result_t *p) {
   if (TT_UINT != p->ast->token_type)
-    return 0;
+    return false;
   return (0 == p->ast->uint);
 }
 
@@ -14,7 +14,7 @@ bool is_zero(parse_result_t *p) {
  */
 bool validate_label(parse_result_t *p) {
   if (TT_SEQUENCE != p->ast->token_type)
-    return 0;
+    return false;
   return (64 > p->ast->seq->used);
 }
 
@@ -25,19 +25,20 @@ bool validate_label(parse_result_t *p) {
  */
 bool validate_dns(parse_result_t *p) {
   if (TT_SEQUENCE != p->ast->token_type)
-    return 0;
+    return false;
   // The header holds the counts as its last 4 elements.
   parsed_token_t *header = p->ast->seq->elements[0];
-  size_t qd = ((parsed_token_t*)header->seq->elements[8])->uint;
-  size_t an = ((parsed_token_t*)header->seq->elements[9])->uint;
-  size_t ns = ((parsed_token_t*)header->seq->elements[10])->uint;
-  size_t ar = ((parsed_token_t*)header->seq->elements[11])->uint;
+  size_t qd = header->seq->elements[8]->uint;
+  size_t an = header->seq->elements[9]->uint;
+  size_t ns = header->seq->elements[10]->uint;
+  size_t ar = header->seq->elements[11]->uint;
   parsed_token_t *questions = p->ast->seq->elements[1];
   if (questions->seq->used != qd)
-    return 0;
+    return false;
   parsed_token_t *rrs = p->ast->seq->elements[2];
   if (an+ns+ar != rrs->seq->used)
-    return 0;
+    return false;
+  return true;
 }
 
 parser_t* init_parser() {
@@ -60,9 +61,21 @@ parser_t* init_parser() {
 				       uint16(), // ARCOUNT
 				       NULL);
 
+  const parser_t *type = int_range(uint16(), 1, 16);
+
+  const parser_t *qtype = choice(type, 
+				 int_range(uint16(), 252, 255),
+				 NULL);
+
+  const parser_t *class = int_range(uint16(), 1, 4);
+  
+  const parser_t *qclass = choice(class,
+				  int_range(uint16(), 255, 255),
+				  NULL);
+
   const parser_t *dns_question = sequence(length_value(uint8(), uint8()), // QNAME
-					  uint16(),                       // QTYPE
-					  uint16(),                       // QCLASS
+					  qtype,                          // QTYPE
+					  qclass,                         // QCLASS
 					  NULL);
 
   const parser_t *letter = choice(ch_range('a', 'z'),
diff --git a/src/hammer.c b/src/hammer.c
index cad143a..bb03311 100644
--- a/src/hammer.c
+++ b/src/hammer.c
@@ -19,10 +19,11 @@
 #include "internal.h"
 #include "allocator.h"
 #include <assert.h>
-#include <string.h>
-#include <stdarg.h>
 #include <ctype.h>
 #include <error.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <string.h>
 
 #define a_new_(arena, typ, count) ((typ*)arena_malloc((arena), sizeof(typ)*(count)))
 #define a_new(typ, count) a_new_(state->arena, typ, count)
@@ -407,10 +408,34 @@ static parse_result_t* parse_int_range(void *env, parse_state_t *state) {
 
 const parser_t* int_range(const parser_t *p, const int64_t lower, const int64_t upper) {
   struct bits_env *b_env = p->env;
-  // p must be an integer parser, which means it's using parse_bits;
-  // if it's a uint parser, it can't be uint64
+  // p must be an integer parser, which means it's using parse_bits
   assert_message(p->fn == parse_bits, "int_range requires an integer parser"); 
+  // if it's a uint parser, it can't be uint64
   assert_message(!(b_env->signedp) ? (b_env->length < 64) : true, "int_range can't use a uint64 parser");
+  // and regardless, the bounds need to fit in the parser in question
+  switch(b_env->length) {
+  case 32:
+    if (b_env->signedp)
+      assert_message(lower >= INT_MIN && upper <= INT_MAX, "bounds for 32-bit signed integer exceeded");
+    else
+      assert_message(lower >= 0 && upper <= UINT_MAX, "bounds for 32-bit unsigned integer exceeded");
+    break;
+  case 16:
+    if (b_env->signedp)
+      assert_message(lower >= SHRT_MIN && upper <= SHRT_MAX, "bounds for 16-bit signed integer exceeded");
+    else
+      assert_message(lower >= 0 && upper <= USHRT_MAX, "bounds for 16-bit unsigned integer exceeded");
+    break;
+  case 8:
+    if (b_env->signedp)
+      assert_message(lower >= SCHAR_MIN && upper <= SCHAR_MAX, "bounds for 8-bit signed integer exceeded");
+    else
+      assert_message(lower >= 0 && upper <= UCHAR_MAX, "bounds for 8-bit unsigned integer exceeded");
+    break;
+  default:
+    // how'd that happen? if we got here, this parser is broken.
+    return NULL;
+  }
 
   range_t *r_env = g_new(range_t, 1);
   r_env->p = p;
@@ -557,24 +582,6 @@ typedef struct {
 } two_parsers_t;
 
 size_t accumulate_size(parse_result_t *pr) {
-  if (NULL != ((parse_result_t*)pr)->ast) {
-    switch (pr->ast->token_type) {
-    case TT_BYTES:
-      return pr->ast->bytes.len;
-    case TT_SINT:
-    case TT_UINT:
-      return sizeof(pr->ast->uint);
-    case TT_SEQUENCE: {
-      counted_array_t *arr = pr->ast->seq;
-      size_t ret = 0;
-      for (size_t i = 0; i < arr->used; i++)
-	ret += accumulate_size(arr->elements[i]);
-      return ret;
-    }
-    default:
-      return 0;
-    }
-  } // no else, if the AST is null then acc doesn't change
   return 0;
 }
 
diff --git a/src/hammer.h b/src/hammer.h
index c59cdbc..ae6346c 100644
--- a/src/hammer.h
+++ b/src/hammer.h
@@ -41,11 +41,13 @@ typedef enum token_type {
   TT_MAX
 } token_type_t;
 
+typedef struct parsed_token parsed_token_t;
+
 typedef struct counted_array {
   size_t capacity;
   size_t used;
   arena_t arena;
-  void **elements;
+  parsed_token_t **elements;
 } counted_array_t;
 
 typedef struct parsed_token {

From 3c51389eaf19752a1883e7ba68e523d81c72dc57 Mon Sep 17 00:00:00 2001
From: "Meredith L. Patterson" <clonearmy@gmail.com>
Date: Thu, 24 May 2012 13:36:28 +0200
Subject: [PATCH 8/9] tidying up the dereferences a bit

---
 examples/dns.c | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/examples/dns.c b/examples/dns.c
index c2fc59d..81afa7c 100644
--- a/examples/dns.c
+++ b/examples/dns.c
@@ -21,17 +21,16 @@ bool validate_label(parse_result_t *p) {
 /**
  * Every DNS message should have QDCOUNT entries in the question
  * section, and ANCOUNT+NSCOUNT+ARCOUNT resource records.
- *
  */
 bool validate_dns(parse_result_t *p) {
   if (TT_SEQUENCE != p->ast->token_type)
     return false;
   // The header holds the counts as its last 4 elements.
-  parsed_token_t *header = p->ast->seq->elements[0];
-  size_t qd = header->seq->elements[8]->uint;
-  size_t an = header->seq->elements[9]->uint;
-  size_t ns = header->seq->elements[10]->uint;
-  size_t ar = header->seq->elements[11]->uint;
+  parsed_token_t **elems = p->ast->seq->elements[0]->seq->elements;
+  size_t qd = elems[8]->uint;
+  size_t an = elems[9]->uint;
+  size_t ns = elems[10]->uint;
+  size_t ar = elems[11]->uint;
   parsed_token_t *questions = p->ast->seq->elements[1];
   if (questions->seq->used != qd)
     return false;

From 0d9497bce6aac100d85bfcba3b074ecbb587f1b5 Mon Sep 17 00:00:00 2001
From: "Meredith L. Patterson" <clonearmy@gmail.com>
Date: Thu, 24 May 2012 13:58:38 +0200
Subject: [PATCH 9/9] had qname wrong, fixed it

---
 examples/dns.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/examples/dns.c b/examples/dns.c
index 81afa7c..ec8f712 100644
--- a/examples/dns.c
+++ b/examples/dns.c
@@ -72,9 +72,12 @@ parser_t* init_parser() {
 				  int_range(uint16(), 255, 255),
 				  NULL);
 
-  const parser_t *dns_question = sequence(length_value(uint8(), uint8()), // QNAME
-					  qtype,                          // QTYPE
-					  qclass,                         // QCLASS
+  const parser_t *dns_question = sequence(sequence(many1(length_value(uint8(), 
+								      uint8())), 
+						   ch('\x00'),
+						   NULL),  // QNAME
+					  qtype,           // QTYPE
+					  qclass,          // QCLASS
 					  NULL);
 
   const parser_t *letter = choice(ch_range('a', 'z'),