diff --git a/examples/Makefile b/examples/Makefile
index 98797f3d96867e8c0b1a9936da45ddfe91f59cf4..a672dc491e131cdb8daec4bdfb2b6dd61f619493 100644
--- a/examples/Makefile
+++ b/examples/Makefile
@@ -19,14 +19,13 @@ LDFLAGS += $(pkg-config --libs glib-2.0)
all: dns base64 base64_sem1 base64_sem2
dns: LDFLAGS:=-L../src -lhammer $(LDFLAGS)
-dns: dns.o rr.o dns_common.o
+dns: dns.o rr.o dns_common.o glue.o
$(call hush, "Linking $@") $(CC) -o $@ $^ $(LDFLAGS)
dns.o: ../src/hammer.h dns_common.h
-
rr.o: ../src/hammer.h rr.h dns_common.h
-
dns_common.o: ../src/hammer.h dns_common.h
+glue.o: ../src/hammer.h glue.h
base64%: LDFLAGS:=-L../src -lhammer $(LDFLAGS)
base64%: base64%.o
diff --git a/examples/dns.c b/examples/dns.c
index 54d9c7e33bf09dad413ca798703c97b5322e40f2..6c572a00b4417f6e636331a12b404a5f2abb2681 100644
--- a/examples/dns.c
+++ b/examples/dns.c
@@ -10,7 +10,12 @@
#define false 0
#define true 1
-bool is_zero(HParseResult *p) {
+
+///
+// Validations
+///
+
+bool validate_hdzero(HParseResult *p) {
if (TT_UINT != p->ast->token_type)
return false;
return (0 == p->ast->uint);
@@ -20,408 +25,244 @@ bool is_zero(HParseResult *p) {
* Every DNS message should have QDCOUNT entries in the question
* section, and ANCOUNT+NSCOUNT+ARCOUNT resource records.
*/
-bool validate_dns(HParseResult *p) {
+bool validate_message(HParseResult *p) {
if (TT_SEQUENCE != p->ast->token_type)
return false;
- // The header holds the counts as its last 4 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;
- HParsedToken *questions = p->ast->seq->elements[1];
- if (questions->seq->used != qd)
+
+ dns_header_t *header = H_FIELD(dns_header_t, 0);
+ size_t qd = header->question_count;
+ size_t an = header->answer_count;
+ size_t ns = header->authority_count;
+ size_t ar = header->additional_count;
+
+ if (H_FIELD_SEQ(1)->used != qd)
return false;
- HParsedToken *rrs = p->ast->seq->elements[2];
- if (an+ns+ar != rrs->seq->used)
+ if (an+ns+ar != H_FIELD_SEQ(2)->used)
return false;
+
return true;
}
-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)*labels->seq->used)
- };
- // 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, ret.labels[i].len + 1);
- // 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;
- ret.labels[i].label[ret.labels[i].len] = 0;
+
+///
+// Semantic Actions
+///
+
+// Helper: Parse and pack the RDATA field of a Resource Record.
+void set_rdata(struct dns_rr rr, HCountedArray *rdata) {
+ uint8_t *data = h_arena_malloc(rdata->arena, sizeof(uint8_t)*rdata->used);
+ for (size_t i=0; i<rdata->used; ++i)
+ data[i] = H_CAST_UINT(rdata->elements[i]);
+
+ // Parse RDATA if possible.
+ const HParseResult *p = NULL;
+ const HParser *parser = init_rdata(rr.type);
+ if (parser)
+ p = h_parse(parser, (const uint8_t*)data, rdata->used);
+
+ // If the RR doesn't parse, set its type to 0.
+ if (!p)
+ rr.type = 0;
+
+ // Pack the parsed rdata into rr.
+ switch(rr.type) {
+ case 1: rr.a = H_CAST_UINT(p->ast); break;
+ case 2: rr.ns = *H_CAST(dns_domain_t, p->ast); break;
+ case 3: rr.md = *H_CAST(dns_domain_t, p->ast); break;
+ case 4: rr.md = *H_CAST(dns_domain_t, p->ast); break;
+ case 5: rr.cname = *H_CAST(dns_domain_t, p->ast); break;
+ case 6: rr.soa = *H_CAST(dns_rr_soa_t, p->ast); break;
+ case 7: rr.mb = *H_CAST(dns_domain_t, p->ast); break;
+ case 8: rr.mg = *H_CAST(dns_domain_t, p->ast); break;
+ case 9: rr.mr = *H_CAST(dns_domain_t, p->ast); break;
+ case 10: rr.null = *H_CAST(dns_rr_null_t, p->ast); break;
+ case 11: rr.wks = *H_CAST(dns_rr_wks_t, p->ast); break;
+ case 12: rr.ptr = *H_CAST(dns_domain_t, p->ast); break;
+ case 13: rr.hinfo = *H_CAST(dns_rr_hinfo_t, p->ast); break;
+ case 14: rr.minfo = *H_CAST(dns_rr_minfo_t, p->ast); break;
+ case 15: rr.mx = *H_CAST(dns_rr_mx_t, p->ast); break;
+ case 16: rr.txt = *H_CAST(dns_rr_txt_t, p->ast); break;
+ default: break;
}
- return ret;
}
-char* get_domain(const HParsedToken *t) {
- switch(t->token_type) {
- case TT_UINT:
- return " ";
- case TT_SEQUENCE:
- {
- // Sequence of subdomains separated by "."
- // Each subdomain is a label, which can be no more than 63 chars.
- char *ret = h_arena_malloc(t->seq->arena, 64*t->seq->used);
- size_t count = 0;
- for (size_t i=0; i<t->seq->used; ++i) {
- HParsedToken *tmp = t->seq->elements[i];
- for (size_t j=0; j<tmp->seq->used; ++j) {
- ret[count] = tmp->seq->elements[i]->uint;
- ++count;
- }
- ret[count] = '.';
- ++count;
- }
- ret[count-1] = '\x00';
- return ret;
- }
- default:
- return NULL;
- }
+const HParsedToken* act_header(const HParseResult *p) {
+ HParsedToken **fields = h_seq_elements(p->ast);
+ dns_header_t header_ = {
+ .id = H_CAST_UINT(fields[0]),
+ .qr = H_CAST_UINT(fields[1]),
+ .opcode = H_CAST_UINT(fields[2]),
+ .aa = H_CAST_UINT(fields[3]),
+ .tc = H_CAST_UINT(fields[4]),
+ .rd = H_CAST_UINT(fields[5]),
+ .ra = H_CAST_UINT(fields[6]),
+ .rcode = H_CAST_UINT(fields[7]),
+ .question_count = H_CAST_UINT(fields[8]),
+ .answer_count = H_CAST_UINT(fields[9]),
+ .authority_count = H_CAST_UINT(fields[10]),
+ .additional_count = H_CAST_UINT(fields[11])
+ };
+
+ dns_header_t *header = H_ALLOC(dns_header_t);
+ *header = header_;
+
+ return H_MAKE(dns_header_t, header);
}
-uint8_t* get_cs(const HCountedArray *arr) {
- uint8_t *ret = h_arena_malloc(arr->arena, sizeof(uint8_t)*arr->used);
- for (size_t i=0; i<arr->used; ++i)
- ret[i] = arr->elements[i]->uint;
- return ret;
+const HParsedToken* act_label(const HParseResult *p) {
+ dns_label_t *r = H_ALLOC(dns_label_t);
+
+ r->len = h_seq_len(p->ast);
+ r->label = h_arena_malloc(p->arena, r->len + 1);
+ for (size_t i=0; i<r->len; ++i)
+ r->label[i] = H_FIELD_UINT(i);
+ r->label[r->len] = 0;
+
+ return H_MAKE(dns_label_t, r);
}
-uint8_t** get_txt(const HCountedArray *arr) {
- uint8_t **ret = h_arena_malloc(arr->arena, sizeof(uint8_t*)*arr->used);
- for (size_t i=0; i<arr->used; ++i) {
- uint8_t *tmp = h_arena_malloc(arr->arena, sizeof(uint8_t)*arr->elements[i]->seq->used);
- for (size_t j=0; j<arr->elements[i]->seq->used; ++j)
- tmp[j] = arr->elements[i]->seq->elements[j]->uint;
- }
- return ret;
+const HParsedToken* act_rr(const HParseResult *p) {
+ dns_rr_t *rr = H_ALLOC(dns_rr_t);
+
+ rr->name = *H_FIELD(dns_domain_t, 0);
+ rr->type = H_FIELD_UINT(1);
+ rr->class = H_FIELD_UINT(2);
+ rr->ttl = H_FIELD_UINT(3);
+ rr->rdlength = H_FIELD_SEQ(4)->used;
+
+ // Parse and pack RDATA.
+ set_rdata(*rr, H_FIELD_SEQ(4));
+
+ return H_MAKE(dns_rr_t, rr);
}
-void set_rr(struct dns_rr rr, HCountedArray *rdata) {
- uint8_t *data = h_arena_malloc(rdata->arena, sizeof(uint8_t)*rdata->used);
- for (size_t i=0; i<rdata->used; ++i)
- data[i] = rdata->elements[i]->uint;
+const HParsedToken* act_question(const HParseResult *p) {
+ dns_question_t *q = H_ALLOC(dns_question_t);
+ HParsedToken **fields = h_seq_elements(p->ast);
- // If the RR doesn't parse, set its type to 0.
- switch(rr.type) {
- case 1: // A
- {
- const HParseResult *r = h_parse(init_a(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else
- rr.a = r->ast->seq->elements[0]->uint;
- break;
- }
- case 2: // NS
- {
- const HParseResult *r = h_parse(init_ns(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else
- rr.ns = get_domain(r->ast->seq->elements[0]);
- break;
- }
- case 3: // MD
- {
- const HParseResult *r = h_parse(init_md(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else
- rr.md = get_domain(r->ast->seq->elements[0]);
- break;
- }
- case 4: // MF
- {
- const HParseResult *r = h_parse(init_mf(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else
- rr.md = get_domain(r->ast->seq->elements[0]);
- break;
- }
- case 5: // CNAME
- {
- const HParseResult *r = h_parse(init_cname(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else
- rr.cname = get_domain(r->ast->seq->elements[0]);
- break;
- }
- case 6: // SOA
- {
- const HParseResult *r = h_parse(init_soa(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else {
- rr.soa.mname = get_domain(r->ast->seq->elements[0]);
- rr.soa.rname = get_domain(r->ast->seq->elements[1]);
- rr.soa.serial = r->ast->seq->elements[2]->uint;
- rr.soa.refresh = r->ast->seq->elements[3]->uint;
- rr.soa.retry = r->ast->seq->elements[4]->uint;
- rr.soa.expire = r->ast->seq->elements[5]->uint;
- rr.soa.minimum = r->ast->seq->elements[6]->uint;
- }
- break;
- }
- case 7: // MB
- {
- const HParseResult *r = h_parse(init_mb(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else
- rr.mb = get_domain(r->ast->seq->elements[0]);
- break;
- }
- case 8: // MG
- {
- const HParseResult *r = h_parse(init_mg(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else
- rr.mg = get_domain(r->ast->seq->elements[0]);
- break;
- }
- case 9: // MR
- {
- const HParseResult *r = h_parse(init_mr(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else
- rr.mr = get_domain(r->ast->seq->elements[0]);
- break;
- }
- case 10: // NULL
- {
- const HParseResult *r = h_parse(init_null(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else {
- rr.null = h_arena_malloc(rdata->arena, sizeof(uint8_t)*r->ast->seq->used);
- for (size_t i=0; i<r->ast->seq->used; ++i)
- rr.null[i] = r->ast->seq->elements[i]->uint;
- }
- break;
- }
- case 11: // WKS
- {
- const HParseResult *r = h_parse(init_wks(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else {
- rr.wks.address = r->ast->seq->elements[0]->uint;
- rr.wks.protocol = r->ast->seq->elements[1]->uint;
- rr.wks.len = r->ast->seq->elements[2]->seq->used;
- rr.wks.bit_map = h_arena_malloc(rdata->arena, sizeof(uint8_t)*r->ast->seq->elements[2]->seq->used);
- for (size_t i=0; i<rr.wks.len; ++i)
- rr.wks.bit_map[i] = r->ast->seq->elements[2]->seq->elements[i]->uint;
- }
- break;
- }
- case 12: // PTR
- {
- const HParseResult *r = h_parse(init_ptr(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else
- rr.ptr = get_domain(r->ast->seq->elements[0]);
- break;
- }
- case 13: // HINFO
- {
- const HParseResult *r = h_parse(init_hinfo(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else {
- rr.hinfo.cpu = get_cs(r->ast->seq->elements[0]->seq);
- rr.hinfo.os = get_cs(r->ast->seq->elements[1]->seq);
- }
- break;
- }
- case 14: // MINFO
- {
- const HParseResult *r = h_parse(init_minfo(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else {
- rr.minfo.rmailbx = get_domain(r->ast->seq->elements[0]);
- rr.minfo.emailbx = get_domain(r->ast->seq->elements[1]);
- }
- break;
- }
- case 15: // MX
- {
- const HParseResult *r = h_parse(init_mx(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else {
- rr.mx.preference = r->ast->seq->elements[0]->uint;
- rr.mx.exchange = get_domain(r->ast->seq->elements[1]);
- }
- break;
- }
- case 16: // TXT
- {
- const HParseResult *r = h_parse(init_txt(), (const uint8_t*)data, rdata->used);
- if (!r)
- rr.type = 0;
- else {
- rr.txt.count = r->ast->seq->elements[0]->seq->used;
- rr.txt.txt_data = get_txt(r->ast->seq->elements[0]->seq);
- }
- break;
- }
- default:
- break;
+ // QNAME is a sequence of labels. Pack them into an array.
+ q->qname.qlen = h_seq_len(fields[0]);
+ q->qname.labels = h_arena_malloc(p->arena, sizeof(dns_label_t)*q->qname.qlen);
+ for(size_t i=0; i<q->qname.qlen; i++) {
+ q->qname.labels[i] = *H_INDEX(dns_label_t, fields[0], i);
}
+
+ q->qtype = H_CAST_UINT(fields[1]);
+ q->qclass = H_CAST_UINT(fields[2]);
+
+ return H_MAKE(dns_question_t, q);
}
-const HParsedToken* pack_dns_struct(const HParseResult *p) {
+const HParsedToken* act_message(const HParseResult *p) {
h_pprint(stdout, p->ast, 0, 2);
- 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;
+ dns_message_t *msg = H_ALLOC(dns_message_t);
- HParsedToken *qs = p->ast->seq->elements[1];
+ // Copy header into message struct.
+ dns_header_t *header = H_FIELD(dns_header_t, 0);
+ msg->header = *header;
+
+ // Copy questions into message struct.
+ HParsedToken *qs = h_seq_index(p->ast, 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;
+ sizeof(struct dns_question)*(header->question_count));
+ for (size_t i=0; i<header->question_count; ++i) {
+ questions[i] = *H_INDEX(dns_question_t, qs, i);
}
msg->questions = questions;
- HParsedToken *rrs = p->ast->seq->elements[2];
+ // Copy answer RRs into message struct.
+ HParsedToken *rrs = h_seq_index(p->ast, 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].class = 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);
+ sizeof(struct dns_rr)*(header->answer_count));
+ for (size_t i=0; i<header->answer_count; ++i) {
+ answers[i] = *H_INDEX(dns_rr_t, rrs, i);
}
msg->answers = answers;
+ // Copy authority RRs into message struct.
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].class = 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);
+ sizeof(struct dns_rr)*(header->authority_count));
+ for (size_t i=0, j=header->answer_count; i<header->authority_count; ++i, ++j) {
+ authority[i] = *H_INDEX(dns_rr_t, rrs, j);
}
msg->authority = authority;
+ // Copy additional RRs into message struct.
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].class = 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);
+ 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] = *H_INDEX(dns_rr_t, rrs, j);
}
msg->additional = additional;
- ret->user = (void*)msg;
- return ret;
+ return H_MAKE(dns_message_t, msg);
}
+#define act_hdzero h_act_ignore
+#define act_qname act_index0
+
+
+///
+// Grammar
+///
+
const HParser* init_parser() {
- static HParser *dns_message = NULL;
- if (dns_message)
- return dns_message;
-
- 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 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_int_range(h_uint8(), 1, 255),
- h_uint8())),
- h_ch('\x00'),
- NULL), // QNAME
- qtype, // QTYPE
- qclass, // QCLASS
- 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 = (HParser*)h_action(h_attr_bool(h_sequence(dns_header,
- h_many(dns_question),
- h_many(dns_rr),
- h_end_p(),
- NULL),
- validate_dns),
- pack_dns_struct);
-
- return dns_message;
+ static const HParser *ret = NULL;
+ if (ret)
+ return ret;
+
+ H_RULE (domain, init_domain());
+ H_AVRULE(hdzero, h_bits(3, false));
+ H_ARULE (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
+ hdzero, // Z
+ h_bits(4, false), // RCODE
+ h_uint16(), // QDCOUNT
+ h_uint16(), // ANCOUNT
+ h_uint16(), // NSCOUNT
+ h_uint16(), // ARCOUNT
+ NULL));
+ H_RULE (type, h_int_range(h_uint16(), 1, 16));
+ H_RULE (qtype, h_choice(type,
+ h_int_range(h_uint16(), 252, 255),
+ NULL));
+ H_RULE (class, h_int_range(h_uint16(), 1, 4));
+ H_RULE (qclass, h_choice(class,
+ h_int_range(h_uint16(), 255, 255),
+ NULL));
+ H_RULE (len, h_int_range(h_uint8(), 1, 255));
+ H_ARULE (label, h_length_value(len, h_uint8()));
+ H_ARULE (qname, h_sequence(h_many1(label),
+ h_ch('\x00'),
+ NULL));
+ H_ARULE (question, h_sequence(qname, qtype, qclass, NULL));
+ H_RULE (rdata, h_length_value(h_uint16(), h_uint8()));
+ H_ARULE (rr, h_sequence(domain, // NAME
+ type, // TYPE
+ class, // CLASS
+ h_uint32(), // TTL
+ rdata, // RDLENGTH+RDATA
+ NULL));
+ H_AVRULE(message, h_sequence(header,
+ h_many(question),
+ h_many(rr),
+ h_end_p(),
+ NULL));
+
+ ret = message;
+ return ret;
}
+
+///
+// Main Program for a Dummy DNS Server
+///
+
int start_listening() {
// return: fd
int sock;
@@ -442,7 +283,7 @@ int start_listening() {
const int TYPE_MAX = 16;
typedef const char* cstr;
-const char* TYPE_STR[17] = {
+static const char* TYPE_STR[17] = {
"nil", "A", "NS", "MD",
"MF", "CNAME", "SOA", "MB",
"MG", "MR", "NULL", "WKS",
diff --git a/examples/dns.h b/examples/dns.h
index 151c46e57d6718cb1c97f9336545fb124aea00a0..ed2c26f7d5c233b5e5f6764fd635da31af90002a 100644
--- a/examples/dns.h
+++ b/examples/dns.h
@@ -1,6 +1,27 @@
#include "../src/hammer.h"
-struct dns_header {
+enum DNSTokenType_ {
+ TT_dns_message_t = TT_USER,
+ TT_dns_header_t,
+ TT_dns_label_t,
+ TT_dns_qname_t,
+ TT_dns_question_t,
+ TT_dns_rr_t,
+ TT_dns_rr_txt_t,
+ TT_dns_rr_hinfo_t,
+ TT_dns_rr_minfo_t,
+ TT_dns_rr_mx_t,
+ TT_dns_rr_soa_t,
+ TT_dns_rr_wks_t,
+ TT_dns_rr_null_t,
+ TT_dns_domain_t,
+ TT_dns_cstr_t
+};
+
+typedef char *dns_domain_t;
+typedef uint8_t *dns_cstr_t;
+
+typedef struct dns_header {
uint16_t id;
bool qr, aa, tc, rd, ra;
char opcode, rcode;
@@ -8,74 +29,93 @@ struct dns_header {
size_t answer_count;
size_t authority_count;
size_t additional_count;
-};
-struct dns_qname {
+} dns_header_t;
+
+typedef struct dns_label {
+ size_t len;
+ uint8_t *label;
+} dns_label_t;
+
+typedef struct dns_qname {
size_t qlen;
- struct {
- size_t len;
- uint8_t *label;
- } *labels;
-};
-struct dns_question {
- struct dns_qname qname;
+ dns_label_t *labels;
+} dns_qname_t;
+
+typedef struct dns_question {
+ dns_qname_t qname;
uint16_t qtype;
uint16_t qclass;
-};
-struct dns_rr {
+} dns_question_t;
+
+typedef struct {
+ dns_cstr_t cpu;
+ dns_cstr_t os;
+} dns_rr_hinfo_t;
+
+typedef struct {
+ char* rmailbx;
+ char* emailbx;
+} dns_rr_minfo_t;
+
+typedef struct {
+ uint16_t preference;
+ char* exchange;
+} dns_rr_mx_t;
+
+typedef struct {
+ char* mname;
+ char* rname;
+ uint32_t serial;
+ uint32_t refresh;
+ uint32_t retry;
+ uint32_t expire;
+ uint32_t minimum;
+} dns_rr_soa_t;
+
+typedef struct {
+ size_t count;
+ uint8_t** txt_data;
+} dns_rr_txt_t;
+
+typedef struct {
+ uint32_t address;
+ uint8_t protocol;
+ size_t len;
+ uint8_t* bit_map;
+} dns_rr_wks_t;
+
+typedef uint8_t *dns_rr_null_t;
+
+typedef struct dns_rr {
char* name;
uint16_t type;
uint16_t class;
uint32_t ttl; // cmos is also acceptable.
uint16_t rdlength;
union {
- 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;
+ uint32_t a;
+ char* ns;
+ char* md;
+ char* mf;
+ char* cname;
+ dns_rr_soa_t soa;
+ char* mb;
+ char* mg;
+ char* mr;
+ dns_rr_null_t null;
+ dns_rr_wks_t wks;
+ char* ptr;
+ dns_rr_hinfo_t hinfo;
+ dns_rr_minfo_t minfo;
+ dns_rr_mx_t mx;
+ dns_rr_txt_t txt;
};
-};
+} dns_rr_t;
typedef struct dns_message {
- struct dns_header header;
- struct dns_question *questions;
- struct dns_rr *answers;
- struct dns_rr *authority;
- struct dns_rr *additional;
+ dns_header_t header;
+ dns_question_t *questions;
+ dns_rr_t *answers;
+ dns_rr_t *authority;
+ dns_rr_t *additional;
} dns_message_t;
diff --git a/examples/dns_common.c b/examples/dns_common.c
index 3d349f1e3d14c8c61964dba2624e87ac0e5cc397..76915b66e8030b26cbf23462ccaad2d944949d05 100644
--- a/examples/dns_common.c
+++ b/examples/dns_common.c
@@ -1,9 +1,12 @@
#include "../src/hammer.h"
#include "dns_common.h"
+#include "dns.h"
#define false 0
#define true 1
+H_ACT_APPLY(act_index0, h_act_index, 0)
+
/**
* A label can't be more than 63 characters.
*/
@@ -13,51 +16,64 @@ bool validate_label(HParseResult *p) {
return (64 > p->ast->seq->used);
}
-const HParser* init_domain() {
- static const HParser *domain = NULL;
- if (domain)
- return domain;
-
- const HParser *letter = h_choice(h_ch_range('a', 'z'),
- h_ch_range('A', 'Z'),
- NULL);
+#define act_label h_act_flatten
- const HParser *let_dig = h_choice(letter,
- h_ch_range('0', '9'),
- NULL);
+const HParsedToken* act_domain(const HParseResult *p) {
+ const HParsedToken *ret = NULL;
+ char *arr = NULL;
- const HParser *ldh_str = h_many1(h_choice(let_dig,
- h_ch('-'),
- NULL));
+ switch(p->ast->token_type) {
+ case TT_UINT:
+ arr = " ";
+ break;
+ case TT_SEQUENCE:
+ // Sequence of subdomains separated by "."
+ // Each subdomain is a label, which can be no more than 63 chars.
+ arr = h_arena_malloc(p->arena, 64*p->ast->seq->used);
+ size_t count = 0;
+ for (size_t i=0; i<p->ast->seq->used; ++i) {
+ HParsedToken *tmp = p->ast->seq->elements[i];
+ for (size_t j=0; j<tmp->seq->used; ++j) {
+ arr[count] = tmp->seq->elements[i]->uint;
+ ++count;
+ }
+ arr[count] = '.';
+ ++count;
+ }
+ arr[count-1] = '\x00';
+ break;
+ default:
+ arr = NULL;
+ ret = NULL;
+ }
- const HParser *label = h_attr_bool(h_sequence(letter,
- h_optional(h_sequence(h_optional(ldh_str),
- let_dig,
- NULL)),
- NULL),
- validate_label);
+ if(arr) {
+ dns_domain_t *val = H_ALLOC(dns_domain_t); // dns_domain_t is char*
+ *val = arr;
+ ret = H_MAKE(dns_domain_t, val);
+ }
- /**
- * You could write it like this ...
- * 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
- */
+ return ret;
+}
- const HParser *subdomain = h_sepBy1(label, h_ch('.'));
+const HParser* init_domain() {
+ static const HParser *ret = NULL;
+ if (ret)
+ return ret;
- domain = h_choice(subdomain,
- h_ch(' '),
- NULL);
+ H_RULE (letter, h_choice(h_ch_range('a','z'), h_ch_range('A','Z'), NULL));
+ H_RULE (let_dig, h_choice(letter, h_ch_range('0','9'), NULL));
+ H_RULE (ldh_str, h_many1(h_choice(let_dig, h_ch('-'), NULL)));
+ H_VARULE(label, h_sequence(letter,
+ h_optional(h_sequence(h_optional(ldh_str),
+ let_dig,
+ NULL)),
+ NULL));
+ H_RULE (subdomain, h_sepBy1(label, h_ch('.')));
+ H_ARULE (domain, h_choice(subdomain, h_ch(' '), NULL));
- return domain;
+ ret = domain;
+ return ret;
}
const HParser* init_character_string() {
diff --git a/examples/dns_common.h b/examples/dns_common.h
index 41d73f0d626b7760387fc6d739bc14f47b329a79..6b04519cb84001c97dfe2afcd9dfd405605ec973 100644
--- a/examples/dns_common.h
+++ b/examples/dns_common.h
@@ -2,8 +2,11 @@
#define HAMMER_DNS_COMMON__H
#include "../src/hammer.h"
+#include "glue.h"
const HParser* init_domain();
const HParser* init_character_string();
+const HParsedToken* act_index0(const HParseResult *p);
+
#endif
diff --git a/examples/glue.c b/examples/glue.c
new file mode 100644
index 0000000000000000000000000000000000000000..7f9c6fa4b1f2cd0f9ecc28bdfa591aa9bec5914c
--- /dev/null
+++ b/examples/glue.c
@@ -0,0 +1,170 @@
+#include "glue.h"
+#include "../src/internal.h" // for h_carray_*
+
+
+// The action equivalent of h_ignore.
+const HParsedToken *h_act_ignore(const HParseResult *p)
+{
+ return NULL;
+}
+
+// Helper to build HAction's that pick one index out of a sequence.
+const HParsedToken *h_act_index(int i, const HParseResult *p)
+{
+ if(!p) return NULL;
+
+ const HParsedToken *tok = p->ast;
+
+ if(!tok || tok->token_type != TT_SEQUENCE)
+ return NULL;
+
+ const HCountedArray *seq = tok->seq;
+ size_t n = seq->used;
+
+ if(i<0 || (size_t)i>=n)
+ return NULL;
+ else
+ return tok->seq->elements[i];
+}
+
+// Action version of h_seq_flatten.
+const HParsedToken *h_act_flatten(const HParseResult *p) {
+ return h_seq_flatten(p->arena, p->ast);
+}
+
+// Low-level helper for the h_make family.
+HParsedToken *h_make_(HArena *arena, HTokenType type)
+{
+ HParsedToken *ret = h_arena_malloc(arena, sizeof(HParsedToken));
+ ret->token_type = type;
+ return ret;
+}
+
+HParsedToken *h_make(HArena *arena, HTokenType type, void *value)
+{
+ assert(type >= TT_USER);
+ HParsedToken *ret = h_make_(arena, type);
+ ret->user = value;
+ return ret;
+}
+
+HParsedToken *h_make_seq(HArena *arena)
+{
+ HParsedToken *ret = h_make_(arena, TT_SEQUENCE);
+ ret->seq = h_carray_new(arena);
+ return ret;
+}
+
+HParsedToken *h_make_bytes(HArena *arena, size_t len)
+{
+ HParsedToken *ret = h_make_(arena, TT_BYTES);
+ ret->bytes.len = len;
+ ret->bytes.token = h_arena_malloc(arena, len);
+ return ret;
+}
+
+HParsedToken *h_make_sint(HArena *arena, int64_t val)
+{
+ HParsedToken *ret = h_make_(arena, TT_SINT);
+ ret->sint = val;
+ return ret;
+}
+
+HParsedToken *h_make_uint(HArena *arena, uint64_t val)
+{
+ HParsedToken *ret = h_make_(arena, TT_UINT);
+ ret->uint = val;
+ return ret;
+}
+
+// XXX -> internal
+HParsedToken *h_carray_index(const HCountedArray *a, size_t i)
+{
+ assert(i < a->used);
+ return a->elements[i];
+}
+
+size_t h_seq_len(const HParsedToken *p)
+{
+ assert(p != NULL);
+ assert(p->token_type == TT_SEQUENCE);
+ return p->seq->used;
+}
+
+HParsedToken **h_seq_elements(const HParsedToken *p)
+{
+ assert(p != NULL);
+ assert(p->token_type == TT_SEQUENCE);
+ return p->seq->elements;
+}
+
+HParsedToken *h_seq_index(const HParsedToken *p, size_t i)
+{
+ assert(p != NULL);
+ assert(p->token_type == TT_SEQUENCE);
+ return h_carray_index(p->seq, i);
+}
+
+HParsedToken *h_seq_index_path(const HParsedToken *p, size_t i, ...)
+{
+ va_list va;
+
+ va_start(va, i);
+ HParsedToken *ret = h_seq_index_vpath(p, i, va);
+ va_end(va);
+
+ return ret;
+}
+
+HParsedToken *h_seq_index_vpath(const HParsedToken *p, size_t i, va_list va)
+{
+ HParsedToken *ret = h_seq_index(p, i);
+ int j;
+
+ while((j = va_arg(va, int)) >= 0)
+ ret = h_seq_index(p, j);
+
+ return ret;
+}
+
+void h_seq_snoc(HParsedToken *xs, const HParsedToken *x)
+{
+ assert(xs != NULL);
+ assert(xs->token_type == TT_SEQUENCE);
+
+ h_carray_append(xs->seq, (HParsedToken *)x);
+}
+
+void h_seq_append(HParsedToken *xs, const HParsedToken *ys)
+{
+ assert(xs != NULL);
+ assert(xs->token_type == TT_SEQUENCE);
+ assert(ys != NULL);
+ assert(ys->token_type == TT_SEQUENCE);
+
+ for(size_t i; i<ys->seq->used; i++)
+ h_carray_append(xs->seq, ys->seq->elements[i]);
+}
+
+// Flatten nested sequences. Always returns a sequence.
+// If input element is not a sequence, returns it as a singleton sequence.
+const HParsedToken *h_seq_flatten(HArena *arena, const HParsedToken *p)
+{
+ assert(p != NULL);
+
+ HParsedToken *ret = h_make_seq(arena);
+ switch(p->token_type) {
+ case TT_SEQUENCE:
+ // Flatten and append all.
+ for(size_t i; i<p->seq->used; i++) {
+ h_seq_append(ret, h_seq_flatten(arena, h_seq_index(p, i)));
+ }
+ break;
+ default:
+ // Make singleton sequence.
+ h_seq_snoc(ret, p);
+ break;
+ }
+
+ return ret;
+}
diff --git a/examples/glue.h b/examples/glue.h
new file mode 100644
index 0000000000000000000000000000000000000000..ccb488e96a098a8e6867ea68a6f398545109ec77
--- /dev/null
+++ b/examples/glue.h
@@ -0,0 +1,251 @@
+//
+// API additions for writing grammar and semantic actions more concisely
+//
+//
+// Quick Overview:
+//
+// Grammars can be succinctly specified with the family of H_RULE macros.
+// H_RULE defines a plain parser variable. H_ARULE additionally attaches a
+// semantic action; H_VRULE attaches a validation. H_AVRULE and H_VARULE
+// combine both.
+//
+// A few standard semantic actions are defined below. The H_ACT_APPLY macro
+// allows semantic actions to be defined by "partial application" of
+// a generic action to fixed paramters.
+//
+// The definition of more complex semantic actions will usually consist of
+// extracting data from the given parse tree and constructing a token of custom
+// type to represent the result. A number of functions and convenience macros
+// are provided to capture the most common cases and idioms.
+//
+// See the leading comment blocks on the sections below for more details.
+//
+
+#ifndef HAMMER_EXAMPLES_GLUE__H
+#define HAMMER_EXAMPLES_GLUE__H
+
+#include <assert.h>
+#include "../src/hammer.h"
+
+
+//
+// Grammar specification
+//
+// H_RULE is simply a short-hand for the typical declaration and definition of
+// a parser variable. See its plain definition below. The goal is to save
+// horizontal space as well as to provide a clear and unified look together with
+// the other macro variants that stays close to an abstract PEG or BNF grammar.
+// The latter goal is more specifically enabled by H_ARULE, H_VRULE, and their
+// combinations as they allow the definition of syntax to be given without
+// intermingling it with the semantic specifications.
+//
+// H_ARULE defines a variable just like H_RULE but attaches a semantic action
+// to the result of the parser via h_action. The action is expected to be
+// named act_<rulename>.
+//
+// H_VRULE is analogous to H_ARULE but attaches a validation via h_attr_bool.
+// The validation is expected to be named validate_<rulename>.
+//
+// H_VARULE combines H_RULE with both an action and a validation. The action is
+// attached before the validation, i.e. the validation receives as input the
+// result of the action.
+//
+// H_AVRULE is like H_VARULE but the action is attached outside the validation,
+// i.e. the validation receives the uninterpreted AST as input.
+//
+
+
+#define H_RULE(rule, def) const HParser *rule = def
+#define H_ARULE(rule, def) const HParser *rule = h_action(def, act_ ## rule)
+#define H_VRULE(rule, def) const HParser *rule = \
+ h_attr_bool(def, validate_ ## rule)
+#define H_VARULE(rule, def) const HParser *rule = \
+ h_attr_bool(h_action(def, act_ ## rule), validate_ ## rule)
+#define H_AVRULE(rule, def) const HParser *rule = \
+ h_action(h_attr_bool(def, validate_ ## rule), act_ ## rule)
+
+
+//
+// Pre-fab semantic actions
+//
+// A collection of generally useful semantic actions is provided.
+//
+// h_act_ignore is the action equivalent of the parser combinator h_ignore. It
+// simply causes the AST it is applied to to be replaced with NULL. This most
+// importantly causes it to be elided from the result of a surrounding
+// h_sequence.
+//
+// h_act_index is of note as it is not itself suitable to be passed to
+// h_action. It is parameterized by an index to be picked from a sequence
+// token. It must be wrapped in a proper HAction to be used. The H_ACT_APPLY
+// macro provides a concise way to define such a parameter-application wrapper.
+//
+// h_act_flatten acts on a token of possibly nested sequences by recursively
+// flattening it into a single sequence. Cf. h_seq_flatten below.
+//
+// H_ACT_APPLY implements "partial application" for semantic actions. It
+// defines a new action that supplies given parameters to a parameterized
+// action such as h_act_index.
+//
+
+const HParsedToken *h_act_ignore(const HParseResult *p);
+const HParsedToken *h_act_index(int i, const HParseResult *p);
+const HParsedToken *h_act_flatten(const HParseResult *p);
+
+// Define 'myaction' as a specialization of 'paction' by supplying the leading
+// parameters.
+#define H_ACT_APPLY(myaction, paction, ...) \
+ const HParsedToken *myaction(const HParseResult *p) { \
+ return paction(__VA_ARGS__, p); \
+ }
+
+
+//
+// Working with HParsedTokens
+//
+// The type HParsedToken represents a dynamically-typed universe of values.
+// Declared below are constructors to turn ordinary values into their
+// HParsedToken equivalents, extractors to retrieve the original values from
+// inside an HParsedToken, and functions that inspect and modify tokens of
+// sequence type directly.
+//
+// In addition, there are a number of short-hand macros that work with some
+// conventions to eliminate common boilerplate. These conventions are listed
+// below. Be sure to follow them if you want to use the respective macros.
+//
+// * The single argument to semantic actions should be called 'p'.
+//
+// The H_MAKE macros suppy 'p->arena' to their underlying h_make
+// counterparts. The H_FIELD macros supply 'p->ast' to their underlying
+// H_INDEX counterparts.
+//
+// * For each custom token type, there should be a typedef for the
+// corresponding value type.
+//
+// H_CAST, H_INDEX and H_FIELD cast the void * user field of such a token to
+// a pointer to the given type.
+//
+// * For each custom token type, say 'foo_t', there must be an integer
+// constant 'TT_foo_t' to identify the token type. This constant must have a
+// value greater or equal than TT_USER.
+//
+// One idiom is to define an enum for all custom token types and to assign a
+// value of TT_USER to the first element. This can be viewed as extending
+// the HTokenType enum.
+//
+// The H_MAKE and H_ASSERT macros derive the name of the token type constant
+// from the given type name.
+//
+//
+// The H_ALLOC macro is useful for allocating values of custom token types.
+//
+// The H_MAKE family of macros construct tokens of a given type. The native
+// token types are indicated by a corresponding suffix such as in H_MAKE_SEQ.
+// The form with no suffix is used for custom token types. This convention is
+// also used for other macro and function families.
+//
+// The H_ASSERT family simply asserts that a given token has the expected type.
+// It mainly serves as an implementation aid for H_CAST. Of note in that regard
+// is that, unlike the standard 'assert' macro, these form _expressions_ that
+// return the value of their token argument; thus they can be used in a
+// "pass-through" fashion inside other expressions.
+//
+// The H_CAST family combines a type assertion with access to the
+// statically-typed value inside a token.
+//
+// A number of functions h_seq_* operate on and inspect sequence tokens.
+// Note that H_MAKE_SEQ takes no arguments and constructs an empty sequence.
+// Therefore there are h_seq_snoc and h_seq_append to build up sequences.
+//
+// The macro families H_FIELD and H_INDEX combine index access on a sequence
+// with a cast to the appropriate result type. H_FIELD is used to access the
+// elements of the argument token 'p' in an action. H_INDEX allows any sequence
+// token to be specified. Both macro families take an arbitrary number of index
+// arguments, giving access to elements in nested sequences by path.
+// These macros are very useful to avoid spaghetti chains of unchecked pointer
+// dereferences.
+//
+
+// Standard short-hand for arena-allocating a variable in a semantic action.
+#define H_ALLOC(TYP) ((TYP *) h_arena_malloc(p->arena, sizeof(TYP)))
+
+// Token constructors...
+
+HParsedToken *h_make(HArena *arena, HTokenType type, void *value);
+HParsedToken *h_make_seq(HArena *arena); // Makes empty sequence.
+HParsedToken *h_make_bytes(HArena *arena, size_t len);
+HParsedToken *h_make_sint(HArena *arena, int64_t val);
+HParsedToken *h_make_uint(HArena *arena, uint64_t val);
+
+// Standard short-hands to make tokens in an action.
+#define H_MAKE(TYP, VAL) h_make(p->arena, TT_ ## TYP, VAL)
+#define H_MAKE_SEQ() h_make_seq(p->arena)
+#define H_MAKE_BYTES(LEN) h_make_bytes(p->arena, LEN)
+#define H_MAKE_SINT(VAL) h_make_sint(p->arena, VAL)
+#define H_MAKE_UINT(VAL) h_make_uint(p->arena, VAL)
+
+// Extract (cast) type-specific value back from HParsedTokens...
+
+// Pass-through assertion that a given token has the expected type.
+#define h_assert_type(T,P) (assert(P->token_type == (HTokenType)T), P)
+
+// Convenience short-hand forms of h_assert_type.
+#define H_ASSERT(TYP, TOK) h_assert_type(TT_ ## TYP, TOK)
+#define H_ASSERT_SEQ(TOK) h_assert_type(TT_SEQUENCE, TOK)
+#define H_ASSERT_BYTES(TOK) h_assert_type(TT_BYTES, TOK)
+#define H_ASSERT_SINT(TOK) h_assert_type(TT_SINT, TOK)
+#define H_ASSERT_UINT(TOK) h_assert_type(TT_UINT, TOK)
+
+// Assert expected type and return contained value.
+#define H_CAST(TYP, TOK) ((TYP *) H_ASSERT(TYP, TOK)->user)
+#define H_CAST_SEQ(TOK) (H_ASSERT_SEQ(TOK)->seq)
+#define H_CAST_BYTES(TOK) (H_ASSERT_BYTES(TOK)->bytes)
+#define H_CAST_SINT(TOK) (H_ASSERT_SINT(TOK)->sint)
+#define H_CAST_UINT(TOK) (H_ASSERT_UINT(TOK)->uint)
+
+// Sequence access...
+
+// Return the length of a sequence.
+size_t h_seq_len(const HParsedToken *p);
+
+// Access a sequence's element array.
+HParsedToken **h_seq_elements(const HParsedToken *p);
+
+// Access a sequence element by index.
+HParsedToken *h_seq_index(const HParsedToken *p, size_t i);
+
+// Access an element in a nested sequence by a path of indices.
+HParsedToken *h_seq_index_path(const HParsedToken *p, size_t i, ...);
+HParsedToken *h_seq_index_vpath(const HParsedToken *p, size_t i, va_list va);
+
+// Convenience macros combining (nested) index access and h_cast.
+#define H_INDEX(TYP, SEQ, ...) H_CAST(TYP, H_INDEX_TOKEN(SEQ, __VA_ARGS__))
+#define H_INDEX_SEQ(SEQ, ...) H_CAST_SEQ(H_INDEX_TOKEN(SEQ, __VA_ARGS__))
+#define H_INDEX_BYTES(SEQ, ...) H_CAST_BYTES(H_INDEX_TOKEN(SEQ, __VA_ARGS__))
+#define H_INDEX_SINT(SEQ, ...) H_CAST_SINT(H_INDEX_TOKEN(SEQ, __VA_ARGS__))
+#define H_INDEX_UINT(SEQ, ...) H_CAST_UINT(H_INDEX_TOKEN(SEQ, __VA_ARGS__))
+#define H_INDEX_TOKEN(SEQ, ...) h_seq_index_path(SEQ, __VA_ARGS__, -1)
+
+// Standard short-hand to access and cast elements on a sequence token.
+#define H_FIELD(TYP, ...) H_INDEX(TYP, p->ast, __VA_ARGS__)
+#define H_FIELD_SEQ(...) H_INDEX_SEQ(p->ast, __VA_ARGS__)
+#define H_FIELD_BYTES(...) H_INDEX_BYTES(p->ast, __VA_ARGS__)
+#define H_FIELD_SINT(...) H_INDEX_SINT(p->ast, __VA_ARGS__)
+#define H_FIELD_UINT(...) H_INDEX_UINT(p->ast, __VA_ARGS__)
+
+// Lower-level helper for h_seq_index.
+HParsedToken *h_carray_index(const HCountedArray *a, size_t i); // XXX -> internal
+
+// Sequence modification...
+
+// Add elements to a sequence.
+void h_seq_snoc(HParsedToken *xs, const HParsedToken *x); // append one
+void h_seq_append(HParsedToken *xs, const HParsedToken *ys); // append many
+
+// XXX TODO: Remove elements from a sequence.
+
+// Flatten nested sequences into one.
+const HParsedToken *h_seq_flatten(HArena *arena, const HParsedToken *p);
+
+
+#endif
diff --git a/examples/rr.c b/examples/rr.c
index 8dae8859a208d1940ff37bcc75dbf5fb91254ff1..8c14e0aec8e678f86dfdbc54dc0499dd3a828d8e 100644
--- a/examples/rr.c
+++ b/examples/rr.c
@@ -1,219 +1,193 @@
#include "../src/hammer.h"
#include "dns_common.h"
+#include "dns.h"
#include "rr.h"
#define false 0
#define true 1
-const HParser* init_cname() {
- static const HParser *cname = NULL;
- if (cname)
- return cname;
-
- cname = h_sequence(init_domain(),
- h_end_p(),
- NULL);
-
- return cname;
-}
-const HParser* init_hinfo() {
- static const HParser *hinfo = NULL;
- if (hinfo)
- return hinfo;
-
- const HParser* cstr = init_character_string();
-
- hinfo = h_sequence(cstr,
- cstr,
- h_end_p(),
- NULL);
+///
+// Validations and Semantic Actions
+///
- return hinfo;
+bool validate_null(HParseResult *p) {
+ if (TT_SEQUENCE != p->ast->token_type)
+ return false;
+ return (65536 > p->ast->seq->used);
}
-const HParser* init_mb() {
- static const HParser *mb = NULL;
- if (mb)
- return mb;
-
- mb = h_sequence(init_domain(),
- h_end_p(),
- NULL);
+const HParsedToken *act_null(const HParseResult *p) {
+ dns_rr_null_t *null = H_ALLOC(dns_rr_null_t);
- return mb;
-}
+ size_t len = h_seq_len(p->ast);
+ uint8_t *buf = h_arena_malloc(p->arena, sizeof(uint8_t)*len);
+ for (size_t i=0; i<len; ++i)
+ buf[i] = H_FIELD_UINT(i);
-const HParser* init_md() {
- static const HParser *md = NULL;
- if (md)
- return md;
-
- md = h_sequence(init_domain(),
- h_end_p,
- NULL);
-
- return md;
+ return H_MAKE(dns_rr_null_t, null);
}
-const HParser* init_mf() {
- static const HParser *mf = NULL;
- if (mf)
- return mf;
-
- mf = h_sequence(init_domain(),
- h_end_p(),
- NULL);
+const HParsedToken *act_txt(const HParseResult *p) {
+ dns_rr_txt_t *txt = H_ALLOC(dns_rr_txt_t);
- return mf;
-}
+ const HCountedArray *arr = H_CAST_SEQ(p->ast);
+ uint8_t **ret = h_arena_malloc(arr->arena, sizeof(uint8_t*)*arr->used);
+ for (size_t i=0; i<arr->used; ++i) {
+ size_t len = h_seq_len(arr->elements[i]);
+ uint8_t *tmp = h_arena_malloc(arr->arena, sizeof(uint8_t)*len);
+ for (size_t j=0; j<len; ++j)
+ tmp[j] = H_INDEX_UINT(arr->elements[i], j);
+ ret[i] = tmp;
+ }
-const HParser* init_mg() {
- static const HParser *mg = NULL;
- if (mg)
- return mg;
-
- mg = h_sequence(init_domain(),
- h_end_p(),
- NULL);
+ txt->count = arr->used;
+ txt->txt_data = ret;
- return mg;
+ return H_MAKE(dns_rr_txt_t, txt);
}
-const HParser* init_minfo() {
- static const HParser *minfo = NULL;
- if (minfo)
- return minfo;
-
- const HParser* domain = init_domain();
-
- minfo = h_sequence(domain,
- domain,
- h_end_p(),
- NULL);
+const HParsedToken* act_cstr(const HParseResult *p) {
+ dns_cstr_t *cs = H_ALLOC(dns_cstr_t);
- return minfo;
-}
-
-const HParser* init_mr() {
- static const HParser *mr = NULL;
- if (mr)
- return mr;
-
- mr = h_sequence(init_domain(),
- h_end_p(),
- NULL);
+ const HCountedArray *arr = H_CAST_SEQ(p->ast);
+ uint8_t *ret = h_arena_malloc(arr->arena, sizeof(uint8_t)*arr->used);
+ for (size_t i=0; i<arr->used; ++i)
+ ret[i] = H_CAST_UINT(arr->elements[i]);
+ assert(ret[arr->used-1] == '\0'); // XXX Is this right?! If so, shouldn't it be a validation?
+ *cs = ret;
- return mr;
+ return H_MAKE(dns_cstr_t, cs);
}
-const HParser* init_mx() {
- static const HParser *mx = NULL;
- if (mx)
- return mx;
-
- mx = h_sequence(h_uint16(),
- init_domain(),
- h_end_p(),
- NULL);
+const HParsedToken* act_soa(const HParseResult *p) {
+ dns_rr_soa_t *soa = H_ALLOC(dns_rr_soa_t);
- return mx;
-}
+ soa->mname = *H_FIELD(dns_domain_t, 0);
+ soa->rname = *H_FIELD(dns_domain_t, 1);
+ soa->serial = H_FIELD_UINT(2);
+ soa->refresh = H_FIELD_UINT(3);
+ soa->retry = H_FIELD_UINT(4);
+ soa->expire = H_FIELD_UINT(5);
+ soa->minimum = H_FIELD_UINT(6);
-bool validate_null(HParseResult *p) {
- if (TT_SEQUENCE != p->ast->token_type)
- return false;
- return (65536 > p->ast->seq->used);
+ return H_MAKE(dns_rr_soa_t, soa);
}
-const HParser* init_null() {
- static const HParser *null_ = NULL;
- if (null_)
- return null_;
+const HParsedToken* act_wks(const HParseResult *p) {
+ dns_rr_wks_t *wks = H_ALLOC(dns_rr_wks_t);
- null_ = h_attr_bool(h_many(h_uint8()), validate_null);
+ wks->address = H_FIELD_UINT(0);
+ wks->protocol = H_FIELD_UINT(1);
+ wks->len = H_FIELD_SEQ(2)->used;
+ wks->bit_map = h_arena_malloc(p->arena, sizeof(uint8_t)*wks->len);
+ for (size_t i=0; i<wks->len; ++i)
+ wks->bit_map[i] = H_INDEX_UINT(p->ast, 2, i);
- return null_;
+ return H_MAKE(dns_rr_wks_t, wks);
}
-const HParser* init_ns() {
- static const HParser *ns = NULL;
- if (ns)
- return ns;
+const HParsedToken* act_hinfo(const HParseResult *p) {
+ dns_rr_hinfo_t *hinfo = H_ALLOC(dns_rr_hinfo_t);
- ns = h_sequence(init_domain(),
- h_end_p(),
- NULL);
+ hinfo->cpu = *H_FIELD(dns_cstr_t, 0);
+ hinfo->os = *H_FIELD(dns_cstr_t, 1);
- return ns;
+ return H_MAKE(dns_rr_hinfo_t, hinfo);
}
-const HParser* init_ptr() {
- static const HParser *ptr = NULL;
- if (ptr)
- return ptr;
-
- ptr = h_sequence(init_domain(),
- h_end_p(),
- NULL);
-
- return ptr;
-}
-
-const HParser* init_soa() {
- static const HParser *soa = NULL;
- if (soa)
- return soa;
-
- const HParser *domain = init_domain();
+const HParsedToken* act_minfo(const HParseResult *p) {
+ dns_rr_minfo_t *minfo = H_ALLOC(dns_rr_minfo_t);
- 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);
+ minfo->rmailbx = *H_FIELD(dns_domain_t, 0);
+ minfo->emailbx = *H_FIELD(dns_domain_t, 1);
- return soa;
+ return H_MAKE(dns_rr_minfo_t, minfo);
}
-const HParser* init_txt() {
- static const HParser *txt = NULL;
- if (txt)
- return txt;
+const HParsedToken* act_mx(const HParseResult *p) {
+ dns_rr_mx_t *mx = H_ALLOC(dns_rr_mx_t);
- txt = h_sequence(h_many1(init_character_string()),
- h_end_p(),
- NULL);
+ mx->preference = H_FIELD_UINT(0);
+ mx->exchange = *H_FIELD(dns_domain_t, 1);
- return txt;
+ return H_MAKE(dns_rr_mx_t, mx);
}
-const HParser* init_a() {
- static const HParser *a = NULL;
- if (a)
- return a;
- a = h_sequence(h_uint32(),
- h_end_p(),
- NULL);
+///
+// Parsers for all types of RDATA
+///
- return a;
-}
-
-const HParser* init_wks() {
- static const HParser *wks = NULL;
- if (wks)
- return wks;
+#define RDATA_TYPE_MAX 16
+const HParser* init_rdata(uint16_t type) {
+ static const HParser *parsers[RDATA_TYPE_MAX+1];
+ static int inited = 0;
- wks = h_sequence(h_uint32(),
- h_uint8(),
- h_many(h_uint8()),
- h_end_p(),
- NULL);
-
- return wks;
+ if (type >= sizeof(parsers))
+ return NULL;
+
+ if (inited)
+ return parsers[type];
+
+
+ H_RULE (domain, init_domain());
+ H_ARULE(cstr, init_character_string());
+
+ H_RULE (a, h_uint32());
+ H_RULE (ns, domain);
+ H_RULE (md, domain);
+ H_RULE (mf, domain);
+ H_RULE (cname, domain);
+ H_ARULE(soa, h_sequence(domain, // MNAME
+ domain, // RNAME
+ h_uint32(), // SERIAL
+ h_uint32(), // REFRESH
+ h_uint32(), // RETRY
+ h_uint32(), // EXPIRE
+ h_uint32(), // MINIMUM
+ NULL));
+ H_RULE (mb, domain);
+ H_RULE (mg, domain);
+ H_RULE (mr, domain);
+ H_VRULE(null, h_many(h_uint8()));
+ H_RULE (wks, h_sequence(h_uint32(),
+ h_uint8(),
+ h_many(h_uint8()),
+ NULL));
+ H_RULE (ptr, domain);
+ H_RULE (hinfo, h_sequence(cstr, cstr, NULL));
+ H_RULE (minfo, h_sequence(domain, domain, NULL));
+ H_RULE (mx, h_sequence(h_uint16(), domain, NULL));
+ H_ARULE(txt, h_many1(cstr));
+
+
+ parsers[ 0] = NULL; // there is no type 0
+ parsers[ 1] = a;
+ parsers[ 2] = ns;
+ parsers[ 3] = md;
+ parsers[ 4] = mf;
+ parsers[ 5] = cname;
+ parsers[ 6] = soa;
+ parsers[ 7] = mb;
+ parsers[ 8] = mg;
+ parsers[ 9] = mr;
+ parsers[10] = null;
+ parsers[11] = wks;
+ parsers[12] = ptr;
+ parsers[13] = hinfo;
+ parsers[14] = minfo;
+ parsers[15] = mx;
+ parsers[16] = txt;
+
+ // All parsers must consume their input exactly.
+ for(uint16_t i; i<sizeof(parsers); i++) {
+ if(parsers[i]) {
+ parsers[i] = h_action(h_sequence(parsers[i], h_end_p(), NULL),
+ act_index0);
+ }
+ }
+
+ inited = 1;
+ return parsers[type];
}
diff --git a/examples/rr.h b/examples/rr.h
index 54172f82d142f092252a5e542919ffdbcef93ea4..fce457817c7802fbd0cb77b688c99f9244bda86a 100644
--- a/examples/rr.h
+++ b/examples/rr.h
@@ -3,21 +3,6 @@
#include "../src/hammer.h"
-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();
+const HParser* init_rdata(uint16_t type);
#endif
diff --git a/src/hammer.h b/src/hammer.h
index 5a0c6257585686deaf13673fc6fa412a11068b9f..7ef2883a7471744813a814fb87bdce08218be1a9 100644
--- a/src/hammer.h
+++ b/src/hammer.h
@@ -54,13 +54,15 @@ typedef struct HCountedArray_ {
struct HParsedToken_ **elements;
} HCountedArray;
+typedef struct HBytes_ {
+ const uint8_t *token;
+ size_t len;
+} HBytes;
+
typedef struct HParsedToken_ {
HTokenType token_type;
union {
- struct {
- const uint8_t *token;
- size_t len;
- } bytes;
+ HBytes bytes;
int64_t sint;
uint64_t uint;
double dbl;
diff --git a/src/pprint.c b/src/pprint.c
index 1ffe764349f265f9d381ed10ae3f7567649bd3ec..d8b22e2d2fa1d317db15334b70021696c054dd9d 100644
--- a/src/pprint.c
+++ b/src/pprint.c
@@ -69,7 +69,11 @@ void h_pprint(FILE* stream, const HParsedToken* tok, int indent, int delta) {
fprintf(stream, "%*sUSER\n", indent, "");
break;
default:
- assert_message(0, "Should not reach here.");
+ if(tok->token_type > TT_USER) {
+ fprintf(stream, "%*sUSER %d\n", indent, "", tok->token_type-TT_USER);
+ } else {
+ assert_message(0, "Should not reach here.");
+ }
}
}