From 5163f002cfbd20cec2edfab0ac37c23e0728c118 Mon Sep 17 00:00:00 2001
From: "Meredith L. Patterson" <clonearmy@gmail.com>
Date: Sat, 26 May 2012 13:23:00 +0200
Subject: [PATCH] Great Symbol Renaming: types.

---
 examples/dns.c        | 42 +++++++++++++-------------
 examples/dns_common.c |  6 ++--
 examples/dns_common.h |  4 +--
 examples/rr.c         | 70 +++++++++++++++++++++----------------------
 examples/rr.h         | 32 ++++++++++----------
 5 files changed, 77 insertions(+), 77 deletions(-)

diff --git a/examples/dns.c b/examples/dns.c
index 9f5712b..ca0f473 100644
--- a/examples/dns.c
+++ b/examples/dns.c
@@ -5,7 +5,7 @@
 #define false 0
 #define true 1
 
-bool is_zero(parse_result_t *p) {
+bool is_zero(HParseResult *p) {
   if (TT_UINT != p->ast->token_type)
     return false;
   return (0 == p->ast->uint);
@@ -15,19 +15,19 @@ bool is_zero(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) {
+bool validate_dns(HParseResult *p) {
   if (TT_SEQUENCE != p->ast->token_type)
     return false;
   // The header holds the counts as its last 4 elements.
-  parsed_token_t **elems = p->ast->seq->elements[0]->seq->elements;
+  HParsedToken **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];
+  HParsedToken *questions = p->ast->seq->elements[1];
   if (questions->seq->used != qd)
     return false;
-  parsed_token_t *rrs = p->ast->seq->elements[2];
+  HParsedToken *rrs = p->ast->seq->elements[2];
   if (an+ns+ar != rrs->seq->used)
     return false;
   return true;
@@ -35,13 +35,13 @@ bool validate_dns(parse_result_t *p) {
 
 
 
-const parsed_token_t* pack_dns_struct(const parse_result_t *p) {
-  parsed_token_t *ret = arena_malloc(p->arena, sizeof(parsed_token_t*));
+const HParsedToken* pack_dns_struct(const HParseResult *p) {
+  HParsedToken *ret = arena_malloc(p->arena, sizeof(HParsedToken*));
   ret->token_type = TT_USER;
 
   dns_message_t *msg = arena_malloc(p->arena, sizeof(dns_message_t*));
 
-  parsed_token_t *hdr = p->ast->seq->elements[0];
+  HParsedToken *hdr = p->ast->seq->elements[0];
   struct dns_header header = {
     .id = hdr->seq->elements[0]->uint,
     .qr = hdr->seq->elements[1]->uint,
@@ -58,7 +58,7 @@ const parsed_token_t* pack_dns_struct(const parse_result_t *p) {
   };
   msg->header = header;
 
-  parsed_token_t *qs = p->ast->seq->elements[1];
+  HParsedToken *qs = p->ast->seq->elements[1];
   struct dns_question *questions = arena_malloc(p->arena,
 						sizeof(struct dns_question)*(header.question_count));
   for (size_t i=0; i<header.question_count; ++i) {
@@ -68,7 +68,7 @@ const parsed_token_t* pack_dns_struct(const parse_result_t *p) {
   }
   msg->questions = questions;
 
-  parsed_token_t *rrs = p->ast->seq->elements[2];
+  HParsedToken *rrs = p->ast->seq->elements[2];
   struct dns_rr *answers = arena_malloc(p->arena,
 					sizeof(struct dns_rr)*(header.answer_count));
   for (size_t i=0; i<header.answer_count; ++i) {
@@ -109,14 +109,14 @@ const parsed_token_t* pack_dns_struct(const parse_result_t *p) {
   return ret;
 }
 
-const parser_t* init_parser() {
-  static parser_t *dns_message = NULL;
+const HParser* init_parser() {
+  static HParser *dns_message = NULL;
   if (dns_message)
     return dns_message;
 
-  const parser_t *domain = init_domain();
+  const HParser *domain = init_domain();
 
-  const parser_t *dns_header = sequence(bits(16, false), // ID
+  const HParser *dns_header = sequence(bits(16, false), // ID
 					bits(1, false),  // QR
 					bits(4, false),  // opcode
 					bits(1, false),  // AA
@@ -131,19 +131,19 @@ const parser_t* init_parser() {
 					uint16(), // ARCOUNT
 					NULL);
 
-  const parser_t *type = int_range(uint16(), 1, 16);
+  const HParser *type = int_range(uint16(), 1, 16);
 
-  const parser_t *qtype = choice(type, 
+  const HParser *qtype = choice(type, 
 				 int_range(uint16(), 252, 255),
 				 NULL);
 
-  const parser_t *class = int_range(uint16(), 1, 4);
+  const HParser *class = int_range(uint16(), 1, 4);
   
-  const parser_t *qclass = choice(class,
+  const HParser *qclass = choice(class,
 				  int_range(uint16(), 255, 255),
 				  NULL);
 
-  const parser_t *dns_question = sequence(sequence(many1(length_value(uint8(), 
+  const HParser *dns_question = sequence(sequence(many1(length_value(uint8(), 
 								      uint8())), 
 						   ch('\x00'),
 						   NULL),  // QNAME
@@ -152,7 +152,7 @@ const parser_t* init_parser() {
 					  NULL);
  
 
-  const parser_t *dns_rr = sequence(domain,                          // NAME
+  const HParser *dns_rr = sequence(domain,                          // NAME
 				    type,                            // TYPE
 				    class,                           // CLASS
 				    uint32(),                        // TTL
@@ -160,7 +160,7 @@ const parser_t* init_parser() {
 				    NULL);
 
 
-  dns_message = (parser_t*)attr_bool(sequence(dns_header,
+  dns_message = (HParser*)attr_bool(sequence(dns_header,
 					      many(dns_question),
 					      many(dns_rr),
 					      end_p(),
diff --git a/examples/dns_common.c b/examples/dns_common.c
index a07efdf..2d7e018 100644
--- a/examples/dns_common.c
+++ b/examples/dns_common.c
@@ -51,7 +51,7 @@ const parser_t* init_domain() {
    * ... but this is easier and equivalent
    */
 
-  const parser_t *subdomain = sepBy1(label, ch('.'));
+  const HParser *subdomain = sepBy1(label, ch('.'));
 
   domain = choice(subdomain, 
 		  ch(' '), 
@@ -60,8 +60,8 @@ const parser_t* init_domain() {
   return domain;
 }
 
-const parser_t* init_character_string() {
-  static const parser_t *cstr = NULL;
+const HParser* init_character_string() {
+  static const HParser *cstr = NULL;
   if (cstr)
     return cstr;
 
diff --git a/examples/dns_common.h b/examples/dns_common.h
index 311b5be..41d73f0 100644
--- a/examples/dns_common.h
+++ b/examples/dns_common.h
@@ -3,7 +3,7 @@
 
 #include "../src/hammer.h"
 
-const parser_t* init_domain();
-const parser_t* init_character_string();
+const HParser* init_domain();
+const HParser* init_character_string();
 
 #endif
diff --git a/examples/rr.c b/examples/rr.c
index 7278a04..3a3cdda 100644
--- a/examples/rr.c
+++ b/examples/rr.c
@@ -5,8 +5,8 @@
 #define false 0
 #define true 1
 
-const parser_t* init_cname() {
-  static const parser_t *cname = NULL;
+const HParser* init_cname() {
+  static const HParser *cname = NULL;
   if (cname)
     return cname;
   
@@ -17,12 +17,12 @@ const parser_t* init_cname() {
   return cname;
 }
 
-const parser_t* init_hinfo() {
-  static const parser_t *hinfo = NULL;
+const HParser* init_hinfo() {
+  static const HParser *hinfo = NULL;
   if (hinfo)
     return hinfo;
 
-  const parser_t* cstr = init_character_string();
+  const HParser* cstr = init_character_string();
   
   hinfo = sequence(cstr,
 		   cstr,
@@ -32,8 +32,8 @@ const parser_t* init_hinfo() {
   return hinfo;
 }
 
-const parser_t* init_mb() {
-  static const parser_t *mb = NULL;
+const HParser* init_mb() {
+  static const HParser *mb = NULL;
   if (mb)
     return mb;
   
@@ -44,8 +44,8 @@ const parser_t* init_mb() {
   return mb;
 }
 
-const parser_t* init_md() {
-  static const parser_t *md = NULL;
+const HParser* init_md() {
+  static const HParser *md = NULL;
   if (md)
     return md;
   
@@ -56,8 +56,8 @@ const parser_t* init_md() {
   return md;
 }
 
-const parser_t* init_mf() {
-  static const parser_t *mf = NULL;
+const HParser* init_mf() {
+  static const HParser *mf = NULL;
   if (mf)
     return mf;
   
@@ -68,8 +68,8 @@ const parser_t* init_mf() {
   return mf;
 }
 
-const parser_t* init_mg() {
-  static const parser_t *mg = NULL;
+const HParser* init_mg() {
+  static const HParser *mg = NULL;
   if (mg)
     return mg;
   
@@ -80,12 +80,12 @@ const parser_t* init_mg() {
   return mg;
 }
 
-const parser_t* init_minfo() {
-  static const parser_t *minfo = NULL;
+const HParser* init_minfo() {
+  static const HParser *minfo = NULL;
   if (minfo)
     return minfo;
 
-  const parser_t* domain = init_domain();
+  const HParser* domain = init_domain();
 
   minfo = sequence(domain,
 		   domain,
@@ -95,8 +95,8 @@ const parser_t* init_minfo() {
   return minfo;
 }
 
-const parser_t* init_mr() {
-  static const parser_t *mr = NULL;
+const HParser* init_mr() {
+  static const HParser *mr = NULL;
   if (mr)
     return mr;
   
@@ -107,8 +107,8 @@ const parser_t* init_mr() {
   return mr;
 }
 
-const parser_t* init_mx() {
-  static const parser_t *mx = NULL;
+const HParser* init_mx() {
+  static const HParser *mx = NULL;
   if (mx)
     return mx;
   
@@ -126,8 +126,8 @@ bool validate_null(parse_result_t *p) {
   return (65536 > p->ast->seq->used);
 }
 
-const parser_t* init_null() {
-  static const parser_t *null_ = NULL;
+const HParser* init_null() {
+  static const HParser *null_ = NULL;
   if (null_)
     return null_;
 
@@ -136,8 +136,8 @@ const parser_t* init_null() {
   return null_;
 }
 
-const parser_t* init_ns() {
-  static const parser_t *ns = NULL;
+const HParser* init_ns() {
+  static const HParser *ns = NULL;
   if (ns)
     return ns;
 
@@ -148,8 +148,8 @@ const parser_t* init_ns() {
   return ns;
 }
 
-const parser_t* init_ptr() {
-  static const parser_t *ptr = NULL;
+const HParser* init_ptr() {
+  static const HParser *ptr = NULL;
   if (ptr)
     return ptr;
   
@@ -160,12 +160,12 @@ const parser_t* init_ptr() {
   return ptr;
 }
 
-const parser_t* init_soa() {
-  static const parser_t *soa = NULL;
+const HParser* init_soa() {
+  static const HParser *soa = NULL;
   if (soa)
     return soa;
 
-  const parser_t *domain = init_domain();
+  const HParser *domain = init_domain();
 
   soa = sequence(domain,   // MNAME
 		 domain,   // RNAME
@@ -180,8 +180,8 @@ const parser_t* init_soa() {
   return soa;
 }
 
-const parser_t* init_txt() {
-  static const parser_t *txt = NULL;
+const HParser* init_txt() {
+  static const HParser *txt = NULL;
   if (txt)
     return txt;
 
@@ -192,8 +192,8 @@ const parser_t* init_txt() {
   return txt;
 }
 
-const parser_t* init_a() {
-  static const parser_t *a = NULL;
+const HParser* init_a() {
+  static const HParser *a = NULL;
   if (a)
     return a;
 
@@ -204,8 +204,8 @@ const parser_t* init_a() {
   return a;
 }
 
-const parser_t* init_wks() {
-  static const parser_t *wks = NULL;
+const HParser* init_wks() {
+  static const HParser *wks = NULL;
   if (wks)
     return wks;
 
diff --git a/examples/rr.h b/examples/rr.h
index c0673d8..54172f8 100644
--- a/examples/rr.h
+++ b/examples/rr.h
@@ -3,21 +3,21 @@
 
 #include "../src/hammer.h"
 
-const parser_t* init_cname();
-const parser_t* init_hinfo();
-const parser_t* init_mb();
-const parser_t* init_md();
-const parser_t* init_mf();
-const parser_t* init_mg();
-const parser_t* init_minfo();
-const parser_t* init_mr();
-const parser_t* init_mx();
-const parser_t* init_null();
-const parser_t* init_ns();
-const parser_t* init_ptr();
-const parser_t* init_soa();
-const parser_t* init_txt();
-const parser_t* init_a();
-const parser_t* init_wks();
+const HParser* init_cname();
+const HParser* init_hinfo();
+const HParser* init_mb();
+const HParser* init_md();
+const HParser* init_mf();
+const HParser* init_mg();
+const HParser* init_minfo();
+const HParser* init_mr();
+const HParser* init_mx();
+const HParser* init_null();
+const HParser* init_ns();
+const HParser* init_ptr();
+const HParser* init_soa();
+const HParser* init_txt();
+const HParser* init_a();
+const HParser* init_wks();
 
 #endif