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

don't add _t type suffix inside H_ macros

Browse source
This commit is contained in:
Sven M. Hallberg 2013-01-16 16:41:23 +01:00
parent ac3ad6d690
commit 4f1e9ad22d
3 changed files with 37 additions and 37 deletions
Download patch file Download diff file Expand all files Collapse all files

56
examples/dns.c
View file

@ -28,7 +28,7 @@ bool is_zero(HParseResult *p) {
bool validate_dns(HParseResult *p) { bool validate_dns(HParseResult *p) {
if (TT_SEQUENCE != p->ast->token_type) if (TT_SEQUENCE != p->ast->token_type)
return false; return false;
dns_header_t *header = H_FIELD(dns_header, 0); dns_header_t *header = H_FIELD(dns_header_t, 0);
size_t qd = header->question_count; size_t qd = header->question_count;
size_t an = header->answer_count; size_t an = header->answer_count;
size_t ns = header->authority_count; size_t ns = header->authority_count;
@ -103,20 +103,20 @@ void set_rr(struct dns_rr rr, HCountedArray *rdata) {
rr.a = p->ast->seq->elements[0]->uint; rr.a = p->ast->seq->elements[0]->uint;
break; break;
case 2: // NS case 2: // NS
rr.ns = *H_FIELD(dns_domain, 0); rr.ns = *H_FIELD(dns_domain_t, 0);
break; break;
case 3: // MD case 3: // MD
rr.md = *H_FIELD(dns_domain, 0); rr.md = *H_FIELD(dns_domain_t, 0);
break; break;
case 4: // MF case 4: // MF
rr.md = *H_FIELD(dns_domain, 0); rr.md = *H_FIELD(dns_domain_t, 0);
break; break;
case 5: // CNAME case 5: // CNAME
rr.cname = *H_FIELD(dns_domain, 0); rr.cname = *H_FIELD(dns_domain_t, 0);
break; break;
case 6: // SOA case 6: // SOA
rr.soa.mname = *H_FIELD(dns_domain, 0); rr.soa.mname = *H_FIELD(dns_domain_t, 0);
rr.soa.rname = *H_FIELD(dns_domain, 1); rr.soa.rname = *H_FIELD(dns_domain_t, 1);
rr.soa.serial = p->ast->seq->elements[2]->uint; rr.soa.serial = p->ast->seq->elements[2]->uint;
rr.soa.refresh = p->ast->seq->elements[3]->uint; rr.soa.refresh = p->ast->seq->elements[3]->uint;
rr.soa.retry = p->ast->seq->elements[4]->uint; rr.soa.retry = p->ast->seq->elements[4]->uint;
@ -124,13 +124,13 @@ void set_rr(struct dns_rr rr, HCountedArray *rdata) {
rr.soa.minimum = p->ast->seq->elements[6]->uint; rr.soa.minimum = p->ast->seq->elements[6]->uint;
break; break;
case 7: // MB case 7: // MB
rr.mb = *H_FIELD(dns_domain, 0); rr.mb = *H_FIELD(dns_domain_t, 0);
break; break;
case 8: // MG case 8: // MG
rr.mg = *H_FIELD(dns_domain, 0); rr.mg = *H_FIELD(dns_domain_t, 0);
break; break;
case 9: // MR case 9: // MR
rr.mr = *H_FIELD(dns_domain, 0); rr.mr = *H_FIELD(dns_domain_t, 0);
break; break;
case 10: // NULL case 10: // NULL
rr.null = h_arena_malloc(rdata->arena, sizeof(uint8_t)*p->ast->seq->used); rr.null = h_arena_malloc(rdata->arena, sizeof(uint8_t)*p->ast->seq->used);
@ -146,19 +146,19 @@ void set_rr(struct dns_rr rr, HCountedArray *rdata) {
rr.wks.bit_map[i] = p->ast->seq->elements[2]->seq->elements[i]->uint; rr.wks.bit_map[i] = p->ast->seq->elements[2]->seq->elements[i]->uint;
break; break;
case 12: // PTR case 12: // PTR
rr.ptr = *H_FIELD(dns_domain, 0); rr.ptr = *H_FIELD(dns_domain_t, 0);
break; break;
case 13: // HINFO case 13: // HINFO
rr.hinfo.cpu = get_cs(p->ast->seq->elements[0]->seq); rr.hinfo.cpu = get_cs(p->ast->seq->elements[0]->seq);
rr.hinfo.os = get_cs(p->ast->seq->elements[1]->seq); rr.hinfo.os = get_cs(p->ast->seq->elements[1]->seq);
break; break;
case 14: // MINFO case 14: // MINFO
rr.minfo.rmailbx = *H_FIELD(dns_domain, 0); rr.minfo.rmailbx = *H_FIELD(dns_domain_t, 0);
rr.minfo.emailbx = *H_FIELD(dns_domain, 1); rr.minfo.emailbx = *H_FIELD(dns_domain_t, 1);
break; break;
case 15: // MX case 15: // MX
rr.mx.preference = p->ast->seq->elements[0]->uint; rr.mx.preference = p->ast->seq->elements[0]->uint;
rr.mx.exchange = *H_FIELD(dns_domain, 1); rr.mx.exchange = *H_FIELD(dns_domain_t, 1);
break; break;
case 16: // TXT case 16: // TXT
rr.txt.count = p->ast->seq->elements[0]->seq->used; rr.txt.count = p->ast->seq->elements[0]->seq->used;
@ -186,14 +186,14 @@ const HParsedToken* act_header(const HParseResult *p) {
.additional_count = fields[11]->uint .additional_count = fields[11]->uint
}; };
dns_header_t *header = H_MAKE(dns_header); dns_header_t *header = H_MAKE(dns_header_t);
*header = header_; *header = header_;
return H_MAKE_TOKEN(dns_header, header); return H_MAKE_TOKEN(dns_header_t, header);
} }
const HParsedToken* act_label(const HParseResult *p) { const HParsedToken* act_label(const HParseResult *p) {
dns_label_t *r = H_MAKE(dns_label); dns_label_t *r = H_MAKE(dns_label_t);
r->len = p->ast->seq->used; r->len = p->ast->seq->used;
r->label = h_arena_malloc(p->arena, r->len + 1); r->label = h_arena_malloc(p->arena, r->len + 1);
@ -201,38 +201,38 @@ const HParsedToken* act_label(const HParseResult *p) {
r->label[i] = p->ast->seq->elements[i]->uint; r->label[i] = p->ast->seq->elements[i]->uint;
r->label[r->len] = 0; r->label[r->len] = 0;
return H_MAKE_TOKEN(dns_label, r); return H_MAKE_TOKEN(dns_label_t, r);
} }
const HParsedToken* act_question(const HParseResult *p) { const HParsedToken* act_question(const HParseResult *p) {
dns_question_t *q = H_MAKE(dns_question); dns_question_t *q = H_MAKE(dns_question_t);
HParsedToken **fields = p->ast->seq->elements; HParsedToken **fields = p->ast->seq->elements;
// QNAME is a sequence of labels. Pack them into an array. // QNAME is a sequence of labels. Pack them into an array.
q->qname.qlen = fields[0]->seq->used; q->qname.qlen = fields[0]->seq->used;
q->qname.labels = h_arena_malloc(p->arena, sizeof(dns_label_t)*q->qname.qlen); q->qname.labels = h_arena_malloc(p->arena, sizeof(dns_label_t)*q->qname.qlen);
for(size_t i=0; i<fields[0]->seq->used; i++) { for(size_t i=0; i<fields[0]->seq->used; i++) {
q->qname.labels[i] = *H_SEQ_INDEX(dns_label, fields[0], i); q->qname.labels[i] = *H_SEQ_INDEX(dns_label_t, fields[0], i);
} }
q->qtype = fields[1]->uint; q->qtype = fields[1]->uint;
q->qclass = fields[2]->uint; q->qclass = fields[2]->uint;
return H_MAKE_TOKEN(dns_question, q); return H_MAKE_TOKEN(dns_question_t, q);
} }
const HParsedToken* act_message(const HParseResult *p) { const HParsedToken* act_message(const HParseResult *p) {
h_pprint(stdout, p->ast, 0, 2); h_pprint(stdout, p->ast, 0, 2);
dns_message_t *msg = H_MAKE(dns_message); dns_message_t *msg = H_MAKE(dns_message_t);
dns_header_t *header = H_FIELD(dns_header, 0); dns_header_t *header = H_FIELD(dns_header_t, 0);
msg->header = *header; msg->header = *header;
HParsedToken *qs = p->ast->seq->elements[1]; HParsedToken *qs = p->ast->seq->elements[1];
struct dns_question *questions = h_arena_malloc(p->arena, struct dns_question *questions = h_arena_malloc(p->arena,
sizeof(struct dns_question)*(header->question_count)); sizeof(struct dns_question)*(header->question_count));
for (size_t i=0; i<header->question_count; ++i) { for (size_t i=0; i<header->question_count; ++i) {
questions[i] = *H_SEQ_INDEX(dns_question, qs, i); questions[i] = *H_SEQ_INDEX(dns_question_t, qs, i);
} }
msg->questions = questions; msg->questions = questions;
@ -240,7 +240,7 @@ const HParsedToken* act_message(const HParseResult *p) {
struct dns_rr *answers = h_arena_malloc(p->arena, struct dns_rr *answers = h_arena_malloc(p->arena,
sizeof(struct dns_rr)*(header->answer_count)); sizeof(struct dns_rr)*(header->answer_count));
for (size_t i=0; i<header->answer_count; ++i) { for (size_t i=0; i<header->answer_count; ++i) {
answers[i].name = *H_SEQ_INDEX(dns_domain, rrs+i, 0); answers[i].name = *H_SEQ_INDEX(dns_domain_t, rrs+i, 0);
answers[i].type = rrs[i].seq->elements[1]->uint; answers[i].type = rrs[i].seq->elements[1]->uint;
answers[i].class = rrs[i].seq->elements[2]->uint; answers[i].class = rrs[i].seq->elements[2]->uint;
answers[i].ttl = rrs[i].seq->elements[3]->uint; answers[i].ttl = rrs[i].seq->elements[3]->uint;
@ -252,7 +252,7 @@ const HParsedToken* act_message(const HParseResult *p) {
struct dns_rr *authority = h_arena_malloc(p->arena, struct dns_rr *authority = h_arena_malloc(p->arena,
sizeof(struct dns_rr)*(header->authority_count)); sizeof(struct dns_rr)*(header->authority_count));
for (size_t i=0, j=header->answer_count; i<header->authority_count; ++i, ++j) { for (size_t i=0, j=header->answer_count; i<header->authority_count; ++i, ++j) {
authority[i].name = *H_SEQ_INDEX(dns_domain, rrs+j, 0); authority[i].name = *H_SEQ_INDEX(dns_domain_t, rrs+j, 0);
authority[i].type = rrs[j].seq->elements[1]->uint; authority[i].type = rrs[j].seq->elements[1]->uint;
authority[i].class = rrs[j].seq->elements[2]->uint; authority[i].class = rrs[j].seq->elements[2]->uint;
authority[i].ttl = rrs[j].seq->elements[3]->uint; authority[i].ttl = rrs[j].seq->elements[3]->uint;
@ -264,7 +264,7 @@ const HParsedToken* act_message(const HParseResult *p) {
struct dns_rr *additional = h_arena_malloc(p->arena, struct dns_rr *additional = h_arena_malloc(p->arena,
sizeof(struct dns_rr)*(header->additional_count)); 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) { for (size_t i=0, j=header->answer_count+header->authority_count; i<header->additional_count; ++i, ++j) {
additional[i].name = *H_SEQ_INDEX(dns_domain, rrs+j, 0); additional[i].name = *H_SEQ_INDEX(dns_domain_t, rrs+j, 0);
additional[i].type = rrs[j].seq->elements[1]->uint; additional[i].type = rrs[j].seq->elements[1]->uint;
additional[i].class = rrs[j].seq->elements[2]->uint; additional[i].class = rrs[j].seq->elements[2]->uint;
additional[i].ttl = rrs[j].seq->elements[3]->uint; additional[i].ttl = rrs[j].seq->elements[3]->uint;
@ -273,7 +273,7 @@ const HParsedToken* act_message(const HParseResult *p) {
} }
msg->additional = additional; msg->additional = additional;
return H_MAKE_TOKEN(dns_message, msg); return H_MAKE_TOKEN(dns_message_t, msg);
} }
#define act_hdzero act_ignore #define act_hdzero act_ignore

14
examples/dns.h
View file

@ -1,13 +1,13 @@
#include "../src/hammer.h" #include "../src/hammer.h"
enum DNSTokenType_ { enum DNSTokenType_ {
TT_dns_message = TT_USER, TT_dns_message_t = TT_USER,
TT_dns_header, TT_dns_header_t,
TT_dns_label, TT_dns_label_t,
TT_dns_qname, TT_dns_qname_t,
TT_dns_question, TT_dns_question_t,
TT_dns_rr, TT_dns_rr_t,
TT_dns_domain TT_dns_domain_t
}; };
typedef struct dns_header { typedef struct dns_header {

4
examples/glue.h
View file

@ -18,7 +18,7 @@ const HParsedToken *act_index0(const HParseResult *p);
HParsedToken *h_make_token(HArena *arena, HTokenType type, void *value); HParsedToken *h_make_token(HArena *arena, HTokenType type, void *value);
#define H_MAKE(TYP) \ #define H_MAKE(TYP) \
((TYP ## _t *) h_arena_malloc(p->arena, sizeof(TYP ## _t))) ((TYP *) h_arena_malloc(p->arena, sizeof(TYP)))
#define H_MAKE_TOKEN(TYP, VAL) \ #define H_MAKE_TOKEN(TYP, VAL) \
h_make_token(p->arena, TT_ ## TYP, VAL) h_make_token(p->arena, TT_ ## TYP, VAL)
@ -28,7 +28,7 @@ HParsedToken *h_seq_index(const HParsedToken *p, size_t i);
void *h_seq_index_user(HTokenType type, const HParsedToken *p, size_t i); void *h_seq_index_user(HTokenType type, const HParsedToken *p, size_t i);
#define H_SEQ_INDEX(TYP, SEQ, IDX) \ #define H_SEQ_INDEX(TYP, SEQ, IDX) \
((TYP ## _t *) h_seq_index_user(TT_ ## TYP, SEQ, IDX)) ((TYP *) h_seq_index_user(TT_ ## TYP, SEQ, IDX))
#define H_FIELD(TYP, IDX) \ #define H_FIELD(TYP, IDX) \
H_SEQ_INDEX(TYP, p->ast, IDX) H_SEQ_INDEX(TYP, p->ast, IDX)