diff --git a/examples/dns.c b/examples/dns.c
index f3903c4daa0f71d0b064015d8135dd3484001b4b..faf912485e3142ad2dfed0362e86338dd978e635 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,83 +15,196 @@ 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;
}
-const parsed_token_t* pack_dns_struct(const parse_result_t *p);
+struct dns_qname get_qname(const HParsedToken *t) {
+ // The qname parser parses at least 1 length-value pair, then a NULL.
+ // So, t->seq->elements[0] is a sequence of at least 1 such pair,
+ // and t->seq->elements[1] is the null.
+ const HParsedToken *labels = t->seq->elements[0];
+ struct dns_qname ret = {
+ .qlen = labels->seq->used,
+ .labels = h_arena_malloc(t->seq->arena, sizeof(ret.labels)*ret.qlen)
+ };
+ // i is which label we're on
+ for (size_t i=0; i<labels->seq->used; ++i) {
+ ret.labels[i].len = labels->seq->elements[i]->seq->used;
+ ret.labels[i].label = h_arena_malloc(t->seq->arena, sizeof(uint8_t)*ret.labels[i].len);
+ // j is which char of the label we're on
+ for (size_t j=0; j<ret.labels[i].len; ++j)
+ ret.labels[i].label[j] = labels->seq->elements[i]->seq->elements[j]->uint;
+ }
+ return ret;
+}
+
+char* get_domain(const HParsedToken *t) {
+ switch(t->token_type) {
+ case TT_UINT:
+ return " ";
+ case TT_SEQUENCE:
+ {
+ // Sequence of subdomains separated by "."
+ return NULL;
+ }
+ default:
+ return NULL;
+ }
+
+}
+
+void set_rr(struct dns_rr rr, HCountedArray *rdata) {
-const parser_t* init_parser() {
- static parser_t *dns_message = NULL;
+}
+
+const HParsedToken* pack_dns_struct(const HParseResult *p) {
+ HParsedToken *ret = h_arena_malloc(p->arena, sizeof(HParsedToken*));
+ ret->token_type = TT_USER;
+
+ dns_message_t *msg = h_arena_malloc(p->arena, sizeof(dns_message_t*));
+
+ HParsedToken *hdr = p->ast->seq->elements[0];
+ struct dns_header header = {
+ .id = hdr->seq->elements[0]->uint,
+ .qr = hdr->seq->elements[1]->uint,
+ .opcode = hdr->seq->elements[2]->uint,
+ .aa = hdr->seq->elements[3]->uint,
+ .tc = hdr->seq->elements[4]->uint,
+ .rd = hdr->seq->elements[5]->uint,
+ .ra = hdr->seq->elements[6]->uint,
+ .rcode = hdr->seq->elements[7]->uint,
+ .question_count = hdr->seq->elements[8]->uint,
+ .answer_count = hdr->seq->elements[9]->uint,
+ .authority_count = hdr->seq->elements[10]->uint,
+ .additional_count = hdr->seq->elements[11]->uint
+ };
+ msg->header = header;
+
+ HParsedToken *qs = p->ast->seq->elements[1];
+ struct dns_question *questions = h_arena_malloc(p->arena,
+ sizeof(struct dns_question)*(header.question_count));
+ for (size_t i=0; i<header.question_count; ++i) {
+ // QNAME is a sequence of labels. In the parser, it's defined as
+ // sequence(many1(length_value(...)), ch('\x00'), NULL).
+ questions[i].qname = get_qname(qs->seq->elements[i]->seq->elements[0]);
+ questions[i].qtype = qs->seq->elements[i]->seq->elements[1]->uint;
+ questions[i].qclass = qs->seq->elements[i]->seq->elements[2]->uint;
+ }
+ msg->questions = questions;
+
+ HParsedToken *rrs = p->ast->seq->elements[2];
+ struct dns_rr *answers = h_arena_malloc(p->arena,
+ sizeof(struct dns_rr)*(header.answer_count));
+ for (size_t i=0; i<header.answer_count; ++i) {
+ answers[i].name = get_domain(rrs[i].seq->elements[0]);
+ answers[i].type = rrs[i].seq->elements[1]->uint;
+ answers[i].type = rrs[i].seq->elements[2]->uint;
+ answers[i].ttl = rrs[i].seq->elements[3]->uint;
+ answers[i].rdlength = rrs[i].seq->elements[4]->seq->used;
+ set_rr(answers[i], rrs[i].seq->elements[4]->seq);
+ }
+ msg->answers = answers;
+
+ struct dns_rr *authority = h_arena_malloc(p->arena,
+ sizeof(struct dns_rr)*(header.authority_count));
+ for (size_t i=0, j=header.answer_count; i<header.authority_count; ++i, ++j) {
+ authority[i].name = get_domain(rrs[j].seq->elements[0]);
+ authority[i].type = rrs[j].seq->elements[1]->uint;
+ authority[i].type = rrs[j].seq->elements[2]->uint;
+ authority[i].ttl = rrs[j].seq->elements[3]->uint;
+ authority[i].rdlength = rrs[j].seq->elements[4]->seq->used;
+ set_rr(authority[i], rrs[j].seq->elements[4]->seq);
+ }
+ msg->authority = authority;
+
+ struct dns_rr *additional = h_arena_malloc(p->arena,
+ sizeof(struct dns_rr)*(header.additional_count));
+ for (size_t i=0, j=header.answer_count+header.authority_count; i<header.additional_count; ++i, ++j) {
+ additional[i].name = get_domain(rrs[j].seq->elements[0]);
+ additional[i].type = rrs[j].seq->elements[1]->uint;
+ additional[i].type = rrs[j].seq->elements[2]->uint;
+ additional[i].ttl = rrs[j].seq->elements[3]->uint;
+ additional[i].rdlength = rrs[j].seq->elements[4]->seq->used;
+ set_rr(additional[i], rrs[j].seq->elements[4]->seq);
+ }
+ msg->additional = additional;
+
+ ret->user = (void*)msg;
+ return ret;
+}
+
+const HParser* init_parser() {
+ static HParser *dns_message = NULL;
if (dns_message)
return dns_message;
- const parser_t *domain = init_domain();
-
- const parser_t *dns_header = sequence(bits(16, false), // ID
- bits(1, false), // QR
- bits(4, false), // opcode
- bits(1, false), // AA
- bits(1, false), // TC
- bits(1, false), // RD
- bits(1, false), // RA
- ignore(attr_bool(bits(3, false), is_zero)), // Z
- bits(4, false), // RCODE
- uint16(), // QDCOUNT
- uint16(), // ANCOUNT
- uint16(), // NSCOUNT
- 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),
+ const HParser *domain = init_domain();
+
+ const HParser *dns_header = h_sequence(h_bits(16, false), // ID
+ h_bits(1, false), // QR
+ h_bits(4, false), // opcode
+ h_bits(1, false), // AA
+ h_bits(1, false), // TC
+ h_bits(1, false), // RD
+ h_bits(1, false), // RA
+ h_ignore(h_attr_bool(h_bits(3, false), is_zero)), // Z
+ h_bits(4, false), // RCODE
+ h_uint16(), // QDCOUNT
+ h_uint16(), // ANCOUNT
+ h_uint16(), // NSCOUNT
+ h_uint16(), // ARCOUNT
+ NULL);
+
+ const HParser *type = h_int_range(h_uint16(), 1, 16);
+
+ const HParser *qtype = h_choice(type,
+ h_int_range(h_uint16(), 252, 255),
NULL);
- const parser_t *dns_question = sequence(sequence(many1(length_value(uint8(),
- uint8())),
- ch('\x00'),
- NULL), // QNAME
- qtype, // QTYPE
- qclass, // QCLASS
- NULL);
+ const HParser *class = h_int_range(h_uint16(), 1, 4);
+
+ const HParser *qclass = h_choice(class,
+ h_int_range(h_uint16(), 255, 255),
+ NULL);
+
+ const HParser *dns_question = h_sequence(h_sequence(h_many1(h_length_value(h_uint8(),
+ h_uint8())),
+ h_ch('\x00'),
+ NULL), // QNAME
+ qtype, // QTYPE
+ qclass, // QCLASS
+ NULL);
- const parser_t *dns_rr = sequence(domain, // NAME
- type, // TYPE
- class, // CLASS
- uint32(), // TTL
- length_value(uint16(), uint8()), // RDLENGTH+RDATA
- NULL);
+ const HParser *dns_rr = h_sequence(domain, // NAME
+ type, // TYPE
+ class, // CLASS
+ h_uint32(), // TTL
+ h_length_value(h_uint16(), h_uint8()), // RDLENGTH+RDATA
+ NULL);
- dns_message = (parser_t*)attr_bool(sequence(dns_header,
- many(dns_question),
- many(dns_rr),
- end_p(),
- NULL),
- validate_dns);
+ dns_message = (HParser*)h_attr_bool(h_sequence(dns_header,
+ h_many(dns_question),
+ h_many(dns_rr),
+ h_end_p(),
+ NULL),
+ validate_dns);
return dns_message;
}
diff --git a/examples/dns.h b/examples/dns.h
index 17d95403c55a5e9d17f52eb8d5b9b0a554771b8e..1d3610330a023971b10c76a476560efedf3052f0 100644
--- a/examples/dns.h
+++ b/examples/dns.h
@@ -1,14 +1,22 @@
+typedef int bool;
struct dns_header {
uint16_t id;
- boolean qr, aa, tc, rd, ra;
- char opcode, z, rcode;
+ bool qr, aa, tc, rd, ra;
+ char opcode, rcode;
size_t question_count;
size_t answer_count;
size_t authority_count;
size_t additional_count;
};
+struct dns_qname {
+ size_t qlen;
+ struct {
+ size_t len;
+ uint8_t *label;
+ } *labels;
+};
struct dns_question {
- char** qname; // change to whatever format you want; I'm assuming you'll keep the length-prefixed terms.
+ struct dns_qname qname;
uint16_t qtype;
uint16_t qclass;
};
@@ -19,14 +27,54 @@ struct dns_rr {
uint32_t ttl; // cmos is also acceptable.
uint16_t rdlength;
union {
- // various types of rdata-specific data here...
+ char* cname;
+ struct {
+ uint8_t* cpu;
+ uint8_t* os;
+ } hinfo;
+ char* mb;
+ char* md;
+ char* mf;
+ char* mg;
+ struct {
+ char* rmailbx;
+ char* emailbx;
+ } minfo;
+ char* mr;
+ struct {
+ uint16_t preference;
+ char* exchange;
+ } mx;
+ uint8_t* null;
+ char* ns;
+ char* ptr;
+ struct {
+ char* mname;
+ char* rname;
+ uint32_t serial;
+ uint32_t refresh;
+ uint32_t retry;
+ uint32_t expire;
+ uint32_t minimum;
+ } soa;
+ struct {
+ size_t count;
+ uint8_t** txt_data;
+ } txt;
+ uint32_t a;
+ struct {
+ uint32_t address;
+ uint8_t protocol;
+ size_t len;
+ uint8_t** bit_map;
+ } wks;
};
};
typedef struct dns_message {
struct dns_header header;
- struct dns_question *questions; // end all these with null, just to be sure.
+ struct dns_question *questions;
struct dns_rr *answers;
struct dns_rr *authority;
struct dns_rr *additional;
-}
+} dns_message_t;
diff --git a/examples/dns_common.c b/examples/dns_common.c
index a07efdfff4d282464e0caf7fa8e80c9adb6bee5d..3d349f1e3d14c8c61964dba2624e87ac0e5cc397 100644
--- a/examples/dns_common.c
+++ b/examples/dns_common.c
@@ -7,65 +7,65 @@
/**
* A label can't be more than 63 characters.
*/
-bool validate_label(parse_result_t *p) {
+bool validate_label(HParseResult *p) {
if (TT_SEQUENCE != p->ast->token_type)
return false;
return (64 > p->ast->seq->used);
}
-const parser_t* init_domain() {
- static const parser_t *domain = NULL;
+const HParser* init_domain() {
+ static const HParser *domain = NULL;
if (domain)
return domain;
- const parser_t *letter = choice(ch_range('a', 'z'),
- ch_range('A', 'Z'),
- NULL);
-
- const parser_t *let_dig = choice(letter,
- ch_range('0', '9'),
+ const HParser *letter = h_choice(h_ch_range('a', 'z'),
+ h_ch_range('A', 'Z'),
NULL);
- const parser_t *ldh_str = many1(choice(let_dig,
- ch('-'),
- NULL));
+ const HParser *let_dig = h_choice(letter,
+ h_ch_range('0', '9'),
+ NULL);
+
+ const HParser *ldh_str = h_many1(h_choice(let_dig,
+ h_ch('-'),
+ NULL));
- const parser_t *label = attr_bool(sequence(letter,
- optional(sequence(optional(ldh_str),
- let_dig,
- NULL)),
- NULL),
- validate_label);
+ const HParser *label = h_attr_bool(h_sequence(letter,
+ h_optional(h_sequence(h_optional(ldh_str),
+ let_dig,
+ NULL)),
+ NULL),
+ validate_label);
/**
* You could write it like this ...
- * parser_t *indirect_subdomain = indirect();
- * const parser_t *subdomain = choice(label,
- * sequence(indirect_subdomain,
- * ch('.'),
- * label,
- * NULL),
- * NULL);
- * bind_indirect(indirect_subdomain, subdomain);
+ * HParser *indirect_subdomain = h_indirect();
+ * const HParser *subdomain = h_choice(label,
+ * h_sequence(indirect_subdomain,
+ * h_ch('.'),
+ * label,
+ * NULL),
+ * NULL);
+ * h_bind_indirect(indirect_subdomain, subdomain);
*
* ... but this is easier and equivalent
*/
- const parser_t *subdomain = sepBy1(label, ch('.'));
+ const HParser *subdomain = h_sepBy1(label, h_ch('.'));
- domain = choice(subdomain,
- ch(' '),
- NULL);
+ domain = h_choice(subdomain,
+ h_ch(' '),
+ NULL);
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;
- cstr = length_value(uint8(), uint8());
+ cstr = h_length_value(h_uint8(), h_uint8());
return cstr;
}
diff --git a/examples/dns_common.h b/examples/dns_common.h
index 311b5beaaf412cb2c1558d746017bce71b1221a2..41d73f0d626b7760387fc6d739bc14f47b329a79 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 e59f7e096a974461b2628d62e06ad37052266dbc..8dae8859a208d1940ff37bcc75dbf5fb91254ff1 100644
--- a/examples/rr.c
+++ b/examples/rr.c
@@ -5,214 +5,215 @@
#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;
- cname = sequence(init_domain(),
- end_p(),
- NULL);
+ cname = h_sequence(init_domain(),
+ h_end_p(),
+ NULL);
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,
- end_p(),
- NULL);
+ hinfo = h_sequence(cstr,
+ cstr,
+ h_end_p(),
+ NULL);
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;
- mb = sequence(init_domain(),
- end_p(),
- NULL);
+ mb = h_sequence(init_domain(),
+ h_end_p(),
+ NULL);
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;
- md = sequence(init_domain(),
- end_p,
- NULL);
+ md = h_sequence(init_domain(),
+ h_end_p,
+ NULL);
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;
- mf = sequence(init_domain(),
- end_p(),
- NULL);
+ mf = h_sequence(init_domain(),
+ h_end_p(),
+ NULL);
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;
- mg = sequence(init_domain(),
- end_p(),
- NULL);
+ mg = h_sequence(init_domain(),
+ h_end_p(),
+ NULL);
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,
- end_p(),
- NULL);
+ minfo = h_sequence(domain,
+ domain,
+ h_end_p(),
+ NULL);
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;
- mr = sequence(init_domain(),
- end_p(),
- NULL);
+ mr = h_sequence(init_domain(),
+ h_end_p(),
+ NULL);
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;
- mx = sequence(uint16(),
- init_domain(),
- end_p(),
- NULL);
+ mx = h_sequence(h_uint16(),
+ init_domain(),
+ h_end_p(),
+ NULL);
return mx;
}
-bool validate_null(parse_result_t *p) {
+bool validate_null(HParseResult *p) {
if (TT_SEQUENCE != p->ast->token_type)
return false;
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_;
- null_ = attr_bool(uint8(), validate_null);
+ null_ = h_attr_bool(h_many(h_uint8()), validate_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;
- ns = sequence(init_domain(),
- end_p(),
- NULL);
+ ns = h_sequence(init_domain(),
+ h_end_p(),
+ NULL);
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;
- ptr = sequence(init_domain(),
- end_p(),
- NULL);
+ ptr = h_sequence(init_domain(),
+ h_end_p(),
+ NULL);
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
- uint32(), // SERIAL
- uint32(), // REFRESH
- uint32(), // RETRY
- uint32(), // EXPIRE
- end_p(),
- NULL);
+ soa = h_sequence(domain, // MNAME
+ domain, // RNAME
+ h_uint32(), // SERIAL
+ h_uint32(), // REFRESH
+ h_uint32(), // RETRY
+ h_uint32(), // EXPIRE
+ h_uint32(), // MINIMUM
+ h_end_p(),
+ NULL);
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;
- txt = sequence(many1(init_character_string()),
- end_p(),
- NULL);
+ txt = h_sequence(h_many1(init_character_string()),
+ h_end_p(),
+ NULL);
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;
- a = sequence(uint32(),
- end_p(),
- NULL);
+ a = h_sequence(h_uint32(),
+ h_end_p(),
+ NULL);
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;
- wks = sequence(uint32(),
- uint8(),
- many(uint8()),
- end_p(),
- NULL);
+ wks = h_sequence(h_uint32(),
+ h_uint8(),
+ h_many(h_uint8()),
+ h_end_p(),
+ NULL);
return wks;
}
diff --git a/examples/rr.h b/examples/rr.h
index c0673d8881adc75a4151a17f9834d8ab640b9efb..54172f82d142f092252a5e542919ffdbcef93ea4 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
diff --git a/src/hammer.c b/src/hammer.c
index 2e041dad8024fe595e9c1519779403ac0ab33411..356a9bcb2602b598e4a903f60bcf6fc9138c3eb5 100644
--- a/src/hammer.c
+++ b/src/hammer.c
@@ -42,9 +42,9 @@ HParserCacheValue* recall(HParserCacheKey *k, HParseState *state) {
} else { // Some heads found
if (!cached && head->head_parser != k->parser && !g_slist_find(head->involved_set, k->parser)) {
// Nothing in the cache, and the key parser is not involved
- HParseResult *tmp = g_new(HParseResult, 1);
+ HParseResult *tmp = a_new(HParseResult, 1);
tmp->ast = NULL; tmp->arena = state->arena;
- HParserCacheValue *ret = g_new(HParserCacheValue, 1);
+ HParserCacheValue *ret = a_new(HParserCacheValue, 1);
ret->value_type = PC_RIGHT; ret->right = tmp;
return ret;
}
@@ -55,6 +55,8 @@ HParserCacheValue* recall(HParserCacheKey *k, HParseState *state) {
if (tmp_res)
tmp_res->arena = state->arena;
// we know that cached has an entry here, modify it
+ if (!cached)
+ cached = a_new(HParserCacheValue, 1);
cached->value_type = PC_RIGHT;
cached->right = tmp_res;
}
@@ -67,14 +69,14 @@ HParserCacheValue* recall(HParserCacheKey *k, HParseState *state) {
* see the current parser again.
*/
-void setupLR(const HParser *p, GQueue *stack, HLeftRec *rec_detect) {
+void setupLR(const HParser *p, HParseState *state, HLeftRec *rec_detect) {
if (!rec_detect->head) {
- HRecursionHead *some = g_new(HRecursionHead, 1);
+ HRecursionHead *some = a_new(HRecursionHead, 1);
some->head_parser = p; some->involved_set = NULL; some->eval_set = NULL;
rec_detect->head = some;
}
size_t i = 0;
- HLeftRec *lr = g_queue_peek_nth(stack, i);
+ HLeftRec *lr = g_queue_peek_nth(state->lr_stack, i);
while (lr && lr->rule != p) {
lr->head = rec_detect->head;
lr->head->involved_set = g_slist_prepend(lr->head->involved_set, (gpointer)lr->rule);
@@ -105,7 +107,7 @@ HParseResult* grow(HParserCacheKey *k, HParseState *state, HRecursionHead *head)
if (tmp_res) {
if ((old_res->ast->index < tmp_res->ast->index) ||
(old_res->ast->index == tmp_res->ast->index && old_res->ast->bit_offset < tmp_res->ast->bit_offset)) {
- HParserCacheValue *v = g_new(HParserCacheValue, 1);
+ HParserCacheValue *v = a_new(HParserCacheValue, 1);
v->value_type = PC_RIGHT; v->right = tmp_res;
g_hash_table_replace(state->cache, k, v);
return grow(k, state, head);
@@ -133,7 +135,7 @@ HParseResult* lr_answer(HParserCacheKey *k, HParseState *state, HLeftRec *growab
}
else {
// update cache
- HParserCacheValue *v = g_new(HParserCacheValue, 1);
+ HParserCacheValue *v = a_new(HParserCacheValue, 1);
v->value_type = PC_RIGHT; v->right = growable->seed;
g_hash_table_replace(state->cache, k, v);
if (!growable->seed)
@@ -203,7 +205,7 @@ HParseResult* h_do_parse(const HParser* parser, HParseState *state) {
} else {
// it exists!
if (PC_LEFT == m->value_type) {
- setupLR(parser, state->lr_stack, m->left);
+ setupLR(parser, state, m->left);
return m->left->seed; // BUG: this might not be correct
} else {
return m->right;