Merge remote-tracking branch 'bunter/master'
This commit is contained in:
Dan Hirsch
commit
100dadb77d
7 changed files with 372 additions and 208 deletions
189
examples/dns.c
189
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,81 +15,194 @@ 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;
|
||||
}
|
||||
|
||||
const parser_t* init_parser() {
|
||||
static parser_t *dns_message = NULL;
|
||||
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 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 HParser *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
|
||||
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 parser_t *type = int_range(uint16(), 1, 16);
|
||||
const HParser *type = h_int_range(h_uint16(), 1, 16);
|
||||
|
||||
const parser_t *qtype = choice(type,
|
||||
int_range(uint16(), 252, 255),
|
||||
const HParser *qtype = h_choice(type,
|
||||
h_int_range(h_uint16(), 252, 255),
|
||||
NULL);
|
||||
|
||||
const parser_t *class = int_range(uint16(), 1, 4);
|
||||
const HParser *class = h_int_range(h_uint16(), 1, 4);
|
||||
|
||||
const parser_t *qclass = choice(class,
|
||||
int_range(uint16(), 255, 255),
|
||||
const HParser *qclass = h_choice(class,
|
||||
h_int_range(h_uint16(), 255, 255),
|
||||
NULL);
|
||||
|
||||
const parser_t *dns_question = sequence(sequence(many1(length_value(uint8(),
|
||||
uint8())),
|
||||
ch('\x00'),
|
||||
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
|
||||
const HParser *dns_rr = h_sequence(domain, // NAME
|
||||
type, // TYPE
|
||||
class, // CLASS
|
||||
uint32(), // TTL
|
||||
length_value(uint16(), uint8()), // RDLENGTH+RDATA
|
||||
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(),
|
||||
dns_message = (HParser*)h_attr_bool(h_sequence(dns_header,
|
||||
h_many(dns_question),
|
||||
h_many(dns_rr),
|
||||
h_end_p(),
|
||||
NULL),
|
||||
validate_dns);
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -7,31 +7,31 @@
|
|||
/**
|
||||
* 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'),
|
||||
const HParser *letter = h_choice(h_ch_range('a', 'z'),
|
||||
h_ch_range('A', 'Z'),
|
||||
NULL);
|
||||
|
||||
const parser_t *let_dig = choice(letter,
|
||||
ch_range('0', '9'),
|
||||
const HParser *let_dig = h_choice(letter,
|
||||
h_ch_range('0', '9'),
|
||||
NULL);
|
||||
|
||||
const parser_t *ldh_str = many1(choice(let_dig,
|
||||
ch('-'),
|
||||
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),
|
||||
const HParser *label = h_attr_bool(h_sequence(letter,
|
||||
h_optional(h_sequence(h_optional(ldh_str),
|
||||
let_dig,
|
||||
NULL)),
|
||||
NULL),
|
||||
|
|
@ -39,33 +39,33 @@ const parser_t* init_domain() {
|
|||
|
||||
/**
|
||||
* You could write it like this ...
|
||||
* parser_t *indirect_subdomain = indirect();
|
||||
* const parser_t *subdomain = choice(label,
|
||||
* sequence(indirect_subdomain,
|
||||
* ch('.'),
|
||||
* HParser *indirect_subdomain = h_indirect();
|
||||
* const HParser *subdomain = h_choice(label,
|
||||
* h_sequence(indirect_subdomain,
|
||||
* h_ch('.'),
|
||||
* label,
|
||||
* NULL),
|
||||
* NULL);
|
||||
* bind_indirect(indirect_subdomain, subdomain);
|
||||
* 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(' '),
|
||||
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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
147
examples/rr.c
147
examples/rr.c
|
|
@ -5,213 +5,214 @@
|
|||
#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(),
|
||||
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,
|
||||
hinfo = h_sequence(cstr,
|
||||
cstr,
|
||||
end_p(),
|
||||
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(),
|
||||
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,
|
||||
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(),
|
||||
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(),
|
||||
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,
|
||||
minfo = h_sequence(domain,
|
||||
domain,
|
||||
end_p(),
|
||||
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(),
|
||||
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(),
|
||||
mx = h_sequence(h_uint16(),
|
||||
init_domain(),
|
||||
end_p(),
|
||||
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(),
|
||||
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(),
|
||||
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
|
||||
soa = h_sequence(domain, // MNAME
|
||||
domain, // RNAME
|
||||
uint32(), // SERIAL
|
||||
uint32(), // REFRESH
|
||||
uint32(), // RETRY
|
||||
uint32(), // EXPIRE
|
||||
end_p(),
|
||||
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(),
|
||||
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(),
|
||||
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(),
|
||||
wks = h_sequence(h_uint32(),
|
||||
h_uint8(),
|
||||
h_many(h_uint8()),
|
||||
h_end_p(),
|
||||
NULL);
|
||||
|
||||
return wks;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
18
src/hammer.c
18
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;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue