emileclarkb/hammer
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge remote-tracking branch 'bunter/master'

Browse source
This commit is contained in:
Dan Hirsch 2012-05-26 16:03:25 +02:00
commit 100dadb77d
7 changed files with 372 additions and 208 deletions
Download patch file Download diff file Expand all files Collapse all files

189
examples/dns.c
View file

@ -5,7 +5,7 @@
#define false 0 #define false 0
#define true 1 #define true 1
bool is_zero(parse_result_t *p) { bool is_zero(HParseResult *p) {
if (TT_UINT != p->ast->token_type) if (TT_UINT != p->ast->token_type)
return false; return false;
return (0 == p->ast->uint); 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 * Every DNS message should have QDCOUNT entries in the question
* section, and ANCOUNT+NSCOUNT+ARCOUNT resource records. * 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) if (TT_SEQUENCE != p->ast->token_type)
return false; return false;
// The header holds the counts as its last 4 elements. // 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 qd = elems[8]->uint;
size_t an = elems[9]->uint; size_t an = elems[9]->uint;
size_t ns = elems[10]->uint; size_t ns = elems[10]->uint;
size_t ar = elems[11]->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) if (questions->seq->used != qd)
return false; 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) if (an+ns+ar != rrs->seq->used)
return false; return false;
return true; 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() { char* get_domain(const HParsedToken *t) {
static parser_t *dns_message = NULL; 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) if (dns_message)
return dns_message; return dns_message;
const parser_t *domain = init_domain(); const HParser *domain = init_domain();
const parser_t *dns_header = sequence(bits(16, false), // ID const HParser *dns_header = h_sequence(h_bits(16, false), // ID
bits(1, false), // QR h_bits(1, false), // QR
bits(4, false), // opcode h_bits(4, false), // opcode
bits(1, false), // AA h_bits(1, false), // AA
bits(1, false), // TC h_bits(1, false), // TC
bits(1, false), // RD h_bits(1, false), // RD
bits(1, false), // RA h_bits(1, false), // RA
ignore(attr_bool(bits(3, false), is_zero)), // Z h_ignore(h_attr_bool(h_bits(3, false), is_zero)), // Z
bits(4, false), // RCODE h_bits(4, false), // RCODE
uint16(), // QDCOUNT h_uint16(), // QDCOUNT
uint16(), // ANCOUNT h_uint16(), // ANCOUNT
uint16(), // NSCOUNT h_uint16(), // NSCOUNT
uint16(), // ARCOUNT h_uint16(), // ARCOUNT
NULL); 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, const HParser *qtype = h_choice(type,
int_range(uint16(), 252, 255), h_int_range(h_uint16(), 252, 255),
NULL); 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, const HParser *qclass = h_choice(class,
int_range(uint16(), 255, 255), h_int_range(h_uint16(), 255, 255),
NULL); NULL);
const parser_t *dns_question = sequence(sequence(many1(length_value(uint8(), const HParser *dns_question = h_sequence(h_sequence(h_many1(h_length_value(h_uint8(),
uint8())), h_uint8())),
ch('\x00'), h_ch('\x00'),
NULL), // QNAME NULL), // QNAME
qtype, // QTYPE qtype, // QTYPE
qclass, // QCLASS qclass, // QCLASS
NULL); NULL);
const parser_t *dns_rr = sequence(domain, // NAME const HParser *dns_rr = h_sequence(domain, // NAME
type, // TYPE type, // TYPE
class, // CLASS class, // CLASS
uint32(), // TTL h_uint32(), // TTL
length_value(uint16(), uint8()), // RDLENGTH+RDATA h_length_value(h_uint16(), h_uint8()), // RDLENGTH+RDATA
NULL); NULL);
dns_message = (parser_t*)attr_bool(sequence(dns_header, dns_message = (HParser*)h_attr_bool(h_sequence(dns_header,
many(dns_question), h_many(dns_question),
many(dns_rr), h_many(dns_rr),
end_p(), h_end_p(),
NULL), NULL),
validate_dns); validate_dns);

60
examples/dns.h
View file

@ -1,14 +1,22 @@
typedef int bool;
struct dns_header { struct dns_header {
uint16_t id; uint16_t id;
boolean qr, aa, tc, rd, ra; bool qr, aa, tc, rd, ra;
char opcode, z, rcode; char opcode, rcode;
size_t question_count; size_t question_count;
size_t answer_count; size_t answer_count;
size_t authority_count; size_t authority_count;
size_t additional_count; size_t additional_count;
}; };
struct dns_qname {
size_t qlen;
struct {
size_t len;
uint8_t *label;
} *labels;
};
struct dns_question { 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 qtype;
uint16_t qclass; uint16_t qclass;
}; };
@ -19,14 +27,54 @@ struct dns_rr {
uint32_t ttl; // cmos is also acceptable. uint32_t ttl; // cmos is also acceptable.
uint16_t rdlength; uint16_t rdlength;
union { 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 { typedef struct dns_message {
struct dns_header header; 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 *answers;
struct dns_rr *authority; struct dns_rr *authority;
struct dns_rr *additional; struct dns_rr *additional;
} } dns_message_t;

44
examples/dns_common.c
View file

@ -7,31 +7,31 @@
/** /**
* A label can't be more than 63 characters. * 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) if (TT_SEQUENCE != p->ast->token_type)
return false; return false;
return (64 > p->ast->seq->used); return (64 > p->ast->seq->used);
} }
const parser_t* init_domain() { const HParser* init_domain() {
static const parser_t *domain = NULL; static const HParser *domain = NULL;
if (domain) if (domain)
return domain; return domain;
const parser_t *letter = choice(ch_range('a', 'z'), const HParser *letter = h_choice(h_ch_range('a', 'z'),
ch_range('A', 'Z'), h_ch_range('A', 'Z'),
NULL); NULL);
const parser_t *let_dig = choice(letter, const HParser *let_dig = h_choice(letter,
ch_range('0', '9'), h_ch_range('0', '9'),
NULL); NULL);
const parser_t *ldh_str = many1(choice(let_dig, const HParser *ldh_str = h_many1(h_choice(let_dig,
ch('-'), h_ch('-'),
NULL)); NULL));
const parser_t *label = attr_bool(sequence(letter, const HParser *label = h_attr_bool(h_sequence(letter,
optional(sequence(optional(ldh_str), h_optional(h_sequence(h_optional(ldh_str),
let_dig, let_dig,
NULL)), NULL)),
NULL), NULL),
@ -39,33 +39,33 @@ const parser_t* init_domain() {
/** /**
* You could write it like this ... * You could write it like this ...
* parser_t *indirect_subdomain = indirect(); * HParser *indirect_subdomain = h_indirect();
* const parser_t *subdomain = choice(label, * const HParser *subdomain = h_choice(label,
* sequence(indirect_subdomain, * h_sequence(indirect_subdomain,
* ch('.'), * h_ch('.'),
* label, * label,
* NULL), * NULL),
* NULL); * NULL);
* bind_indirect(indirect_subdomain, subdomain); * h_bind_indirect(indirect_subdomain, subdomain);
* *
* ... but this is easier and equivalent * ... but this is easier and equivalent
*/ */
const parser_t *subdomain = sepBy1(label, ch('.')); const HParser *subdomain = h_sepBy1(label, h_ch('.'));
domain = choice(subdomain, domain = h_choice(subdomain,
ch(' '), h_ch(' '),
NULL); NULL);
return domain; return domain;
} }
const parser_t* init_character_string() { const HParser* init_character_string() {
static const parser_t *cstr = NULL; static const HParser *cstr = NULL;
if (cstr) if (cstr)
return cstr; return cstr;
cstr = length_value(uint8(), uint8()); cstr = h_length_value(h_uint8(), h_uint8());
return cstr; return cstr;
} }

4
examples/dns_common.h
View file

@ -3,7 +3,7 @@
#include "../src/hammer.h" #include "../src/hammer.h"
const parser_t* init_domain(); const HParser* init_domain();
const parser_t* init_character_string(); const HParser* init_character_string();
#endif #endif

147
examples/rr.c
View file

@ -5,213 +5,214 @@
#define false 0 #define false 0
#define true 1 #define true 1
const parser_t* init_cname() { const HParser* init_cname() {
static const parser_t *cname = NULL; static const HParser *cname = NULL;
if (cname) if (cname)
return cname; return cname;
cname = sequence(init_domain(), cname = h_sequence(init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return cname; return cname;
} }
const parser_t* init_hinfo() { const HParser* init_hinfo() {
static const parser_t *hinfo = NULL; static const HParser *hinfo = NULL;
if (hinfo) if (hinfo)
return hinfo; return hinfo;
const parser_t* cstr = init_character_string(); const HParser* cstr = init_character_string();
hinfo = sequence(cstr, hinfo = h_sequence(cstr,
cstr, cstr,
end_p(), h_end_p(),
NULL); NULL);
return hinfo; return hinfo;
} }
const parser_t* init_mb() { const HParser* init_mb() {
static const parser_t *mb = NULL; static const HParser *mb = NULL;
if (mb) if (mb)
return mb; return mb;
mb = sequence(init_domain(), mb = h_sequence(init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return mb; return mb;
} }
const parser_t* init_md() { const HParser* init_md() {
static const parser_t *md = NULL; static const HParser *md = NULL;
if (md) if (md)
return md; return md;
md = sequence(init_domain(), md = h_sequence(init_domain(),
end_p, h_end_p,
NULL); NULL);
return md; return md;
} }
const parser_t* init_mf() { const HParser* init_mf() {
static const parser_t *mf = NULL; static const HParser *mf = NULL;
if (mf) if (mf)
return mf; return mf;
mf = sequence(init_domain(), mf = h_sequence(init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return mf; return mf;
} }
const parser_t* init_mg() { const HParser* init_mg() {
static const parser_t *mg = NULL; static const HParser *mg = NULL;
if (mg) if (mg)
return mg; return mg;
mg = sequence(init_domain(), mg = h_sequence(init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return mg; return mg;
} }
const parser_t* init_minfo() { const HParser* init_minfo() {
static const parser_t *minfo = NULL; static const HParser *minfo = NULL;
if (minfo) if (minfo)
return minfo; return minfo;
const parser_t* domain = init_domain(); const HParser* domain = init_domain();
minfo = sequence(domain, minfo = h_sequence(domain,
domain, domain,
end_p(), h_end_p(),
NULL); NULL);
return minfo; return minfo;
} }
const parser_t* init_mr() { const HParser* init_mr() {
static const parser_t *mr = NULL; static const HParser *mr = NULL;
if (mr) if (mr)
return mr; return mr;
mr = sequence(init_domain(), mr = h_sequence(init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return mr; return mr;
} }
const parser_t* init_mx() { const HParser* init_mx() {
static const parser_t *mx = NULL; static const HParser *mx = NULL;
if (mx) if (mx)
return mx; return mx;
mx = sequence(uint16(), mx = h_sequence(h_uint16(),
init_domain(), init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return mx; return mx;
} }
bool validate_null(parse_result_t *p) { bool validate_null(HParseResult *p) {
if (TT_SEQUENCE != p->ast->token_type) if (TT_SEQUENCE != p->ast->token_type)
return false; return false;
return (65536 > p->ast->seq->used); return (65536 > p->ast->seq->used);
} }
const parser_t* init_null() { const HParser* init_null() {
static const parser_t *null_ = NULL; static const HParser *null_ = NULL;
if (null_) if (null_)
return null_; return null_;
null_ = attr_bool(uint8(), validate_null); null_ = h_attr_bool(h_many(h_uint8()), validate_null);
return null_; return null_;
} }
const parser_t* init_ns() { const HParser* init_ns() {
static const parser_t *ns = NULL; static const HParser *ns = NULL;
if (ns) if (ns)
return ns; return ns;
ns = sequence(init_domain(), ns = h_sequence(init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return ns; return ns;
} }
const parser_t* init_ptr() { const HParser* init_ptr() {
static const parser_t *ptr = NULL; static const HParser *ptr = NULL;
if (ptr) if (ptr)
return ptr; return ptr;
ptr = sequence(init_domain(), ptr = h_sequence(init_domain(),
end_p(), h_end_p(),
NULL); NULL);
return ptr; return ptr;
} }
const parser_t* init_soa() { const HParser* init_soa() {
static const parser_t *soa = NULL; static const HParser *soa = NULL;
if (soa) if (soa)
return 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 domain, // RNAME
uint32(), // SERIAL h_uint32(), // SERIAL
uint32(), // REFRESH h_uint32(), // REFRESH
uint32(), // RETRY h_uint32(), // RETRY
uint32(), // EXPIRE h_uint32(), // EXPIRE
end_p(), h_uint32(), // MINIMUM
h_end_p(),
NULL); NULL);
return soa; return soa;
} }
const parser_t* init_txt() { const HParser* init_txt() {
static const parser_t *txt = NULL; static const HParser *txt = NULL;
if (txt) if (txt)
return txt; return txt;
txt = sequence(many1(init_character_string()), txt = h_sequence(h_many1(init_character_string()),
end_p(), h_end_p(),
NULL); NULL);
return txt; return txt;
} }
const parser_t* init_a() { const HParser* init_a() {
static const parser_t *a = NULL; static const HParser *a = NULL;
if (a) if (a)
return a; return a;
a = sequence(uint32(), a = h_sequence(h_uint32(),
end_p(), h_end_p(),
NULL); NULL);
return a; return a;
} }
const parser_t* init_wks() { const HParser* init_wks() {
static const parser_t *wks = NULL; static const HParser *wks = NULL;
if (wks) if (wks)
return wks; return wks;
wks = sequence(uint32(), wks = h_sequence(h_uint32(),
uint8(), h_uint8(),
many(uint8()), h_many(h_uint8()),
end_p(), h_end_p(),
NULL); NULL);
return wks; return wks;

32
examples/rr.h
View file

@ -3,21 +3,21 @@
#include "../src/hammer.h" #include "../src/hammer.h"
const parser_t* init_cname(); const HParser* init_cname();
const parser_t* init_hinfo(); const HParser* init_hinfo();
const parser_t* init_mb(); const HParser* init_mb();
const parser_t* init_md(); const HParser* init_md();
const parser_t* init_mf(); const HParser* init_mf();
const parser_t* init_mg(); const HParser* init_mg();
const parser_t* init_minfo(); const HParser* init_minfo();
const parser_t* init_mr(); const HParser* init_mr();
const parser_t* init_mx(); const HParser* init_mx();
const parser_t* init_null(); const HParser* init_null();
const parser_t* init_ns(); const HParser* init_ns();
const parser_t* init_ptr(); const HParser* init_ptr();
const parser_t* init_soa(); const HParser* init_soa();
const parser_t* init_txt(); const HParser* init_txt();
const parser_t* init_a(); const HParser* init_a();
const parser_t* init_wks(); const HParser* init_wks();
#endif #endif

18
src/hammer.c
View file

@ -42,9 +42,9 @@ HParserCacheValue* recall(HParserCacheKey *k, HParseState *state) {
} else { // Some heads found } else { // Some heads found
if (!cached && head->head_parser != k->parser && !g_slist_find(head->involved_set, k->parser)) { 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 // 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; 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; ret->value_type = PC_RIGHT; ret->right = tmp;
return ret; return ret;
} }
@ -55,6 +55,8 @@ HParserCacheValue* recall(HParserCacheKey *k, HParseState *state) {
if (tmp_res) if (tmp_res)
tmp_res->arena = state->arena; tmp_res->arena = state->arena;
// we know that cached has an entry here, modify it // we know that cached has an entry here, modify it
if (!cached)
cached = a_new(HParserCacheValue, 1);
cached->value_type = PC_RIGHT; cached->value_type = PC_RIGHT;
cached->right = tmp_res; cached->right = tmp_res;
} }
@ -67,14 +69,14 @@ HParserCacheValue* recall(HParserCacheKey *k, HParseState *state) {
* see the current parser again. * 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) { 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; some->head_parser = p; some->involved_set = NULL; some->eval_set = NULL;
rec_detect->head = some; rec_detect->head = some;
} }
size_t i = 0; 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) { while (lr && lr->rule != p) {
lr->head = rec_detect->head; lr->head = rec_detect->head;
lr->head->involved_set = g_slist_prepend(lr->head->involved_set, (gpointer)lr->rule); 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 (tmp_res) {
if ((old_res->ast->index < tmp_res->ast->index) || 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)) { (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; v->value_type = PC_RIGHT; v->right = tmp_res;
g_hash_table_replace(state->cache, k, v); g_hash_table_replace(state->cache, k, v);
return grow(k, state, head); return grow(k, state, head);
@ -133,7 +135,7 @@ HParseResult* lr_answer(HParserCacheKey *k, HParseState *state, HLeftRec *growab
} }
else { else {
// update cache // update cache
HParserCacheValue *v = g_new(HParserCacheValue, 1); HParserCacheValue *v = a_new(HParserCacheValue, 1);
v->value_type = PC_RIGHT; v->right = growable->seed; v->value_type = PC_RIGHT; v->right = growable->seed;
g_hash_table_replace(state->cache, k, v); g_hash_table_replace(state->cache, k, v);
if (!growable->seed) if (!growable->seed)
@ -203,7 +205,7 @@ HParseResult* h_do_parse(const HParser* parser, HParseState *state) {
} else { } else {
// it exists! // it exists!
if (PC_LEFT == m->value_type) { 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 return m->left->seed; // BUG: this might not be correct
} else { } else {
return m->right; return m->right;