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

Renamed parse state

Browse source
This commit is contained in:
Dan Hirsch 2012-05-26 12:03:58 +02:00
parent 8959d6db07
commit 8cc526f13e
3 changed files with 34 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

58
src/hammer.c
View file

@ -37,7 +37,7 @@ guint djbhash(const uint8_t *buf, size_t len) {
return hash; return hash;
} }
parser_cache_value_t* recall(parser_cache_key_t *k, parse_state_t *state) { parser_cache_value_t* recall(parser_cache_key_t *k, HParseState *state) {
parser_cache_value_t *cached = g_hash_table_lookup(state->cache, k); parser_cache_value_t *cached = g_hash_table_lookup(state->cache, k);
head_t *head = g_hash_table_lookup(state->recursion_heads, k); head_t *head = g_hash_table_lookup(state->recursion_heads, k);
if (!head) { // No heads found if (!head) { // No heads found
@ -88,7 +88,7 @@ void setupLR(const parser_t *p, GQueue *stack, LR_t *rec_detect) {
* future parse. * future parse.
*/ */
parse_result_t* grow(parser_cache_key_t *k, parse_state_t *state, head_t *head) { parse_result_t* grow(parser_cache_key_t *k, HParseState *state, head_t *head) {
// Store the head into the recursion_heads // Store the head into the recursion_heads
g_hash_table_replace(state->recursion_heads, k, head); g_hash_table_replace(state->recursion_heads, k, head);
parser_cache_value_t *old_cached = g_hash_table_lookup(state->cache, k); parser_cache_value_t *old_cached = g_hash_table_lookup(state->cache, k);
@ -128,7 +128,7 @@ parse_result_t* grow(parser_cache_key_t *k, parse_state_t *state, head_t *head)
} }
} }
parse_result_t* lr_answer(parser_cache_key_t *k, parse_state_t *state, LR_t *growable) { parse_result_t* lr_answer(parser_cache_key_t *k, HParseState *state, LR_t *growable) {
if (growable->head) { if (growable->head) {
if (growable->head->head_parser != k->parser) { if (growable->head->head_parser != k->parser) {
// not the head rule, so not growing // not the head rule, so not growing
@ -150,7 +150,7 @@ parse_result_t* lr_answer(parser_cache_key_t *k, parse_state_t *state, LR_t *gro
} }
/* Warth's recursion. Hi Alessandro! */ /* Warth's recursion. Hi Alessandro! */
parse_result_t* do_parse(const parser_t* parser, parse_state_t *state) { parse_result_t* do_parse(const parser_t* parser, HParseState *state) {
parser_cache_key_t *key = a_new(parser_cache_key_t, 1); parser_cache_key_t *key = a_new(parser_cache_key_t, 1);
key->input_pos = state->input_stream; key->parser = parser; key->input_pos = state->input_stream; key->parser = parser;
parser_cache_value_t *m = recall(key, state); parser_cache_value_t *m = recall(key, state);
@ -215,7 +215,7 @@ parse_result_t* do_parse(const parser_t* parser, parse_state_t *state) {
} }
/* Helper function, since these lines appear in every parser */ /* Helper function, since these lines appear in every parser */
parse_result_t* make_result(parse_state_t *state, parsed_token_t *tok) { parse_result_t* make_result(HParseState *state, parsed_token_t *tok) {
parse_result_t *ret = a_new(parse_result_t, 1); parse_result_t *ret = a_new(parse_result_t, 1);
ret->ast = tok; ret->ast = tok;
ret->arena = state->arena; ret->arena = state->arena;
@ -227,7 +227,7 @@ typedef struct {
uint8_t len; uint8_t len;
} token_t; } token_t;
static parse_result_t* parse_unimplemented(void* env, parse_state_t *state) { static parse_result_t* parse_unimplemented(void* env, HParseState *state) {
(void) env; (void) env;
(void) state; (void) state;
static parsed_token_t token = { static parsed_token_t token = {
@ -249,7 +249,7 @@ struct bits_env {
uint8_t signedp; uint8_t signedp;
}; };
static parse_result_t* parse_bits(void* env, parse_state_t *state) { static parse_result_t* parse_bits(void* env, HParseState *state) {
struct bits_env *env_ = env; struct bits_env *env_ = env;
parsed_token_t *result = a_new(parsed_token_t, 1); parsed_token_t *result = a_new(parsed_token_t, 1);
result->token_type = (env_->signedp ? TT_SINT : TT_UINT); result->token_type = (env_->signedp ? TT_SINT : TT_UINT);
@ -283,7 +283,7 @@ SIZED_BITS(uint, 16, false)
SIZED_BITS(uint, 32, false) SIZED_BITS(uint, 32, false)
SIZED_BITS(uint, 64, false) SIZED_BITS(uint, 64, false)
static parse_result_t* parse_token(void *env, parse_state_t *state) { static parse_result_t* parse_token(void *env, HParseState *state) {
token_t *t = (token_t*)env; token_t *t = (token_t*)env;
for (int i=0; i<t->len; ++i) { for (int i=0; i<t->len; ++i) {
uint8_t chr = (uint8_t)read_bits(&state->input_stream, 8, false); uint8_t chr = (uint8_t)read_bits(&state->input_stream, 8, false);
@ -304,7 +304,7 @@ const parser_t* token(const uint8_t *str, const size_t len) {
return (const parser_t*)ret; return (const parser_t*)ret;
} }
static parse_result_t* parse_ch(void* env, parse_state_t *state) { static parse_result_t* parse_ch(void* env, HParseState *state) {
uint8_t c = (uint8_t)GPOINTER_TO_UINT(env); uint8_t c = (uint8_t)GPOINTER_TO_UINT(env);
uint8_t r = (uint8_t)read_bits(&state->input_stream, 8, false); uint8_t r = (uint8_t)read_bits(&state->input_stream, 8, false);
if (c == r) { if (c == r) {
@ -322,7 +322,7 @@ const parser_t* ch(const uint8_t c) {
return (const parser_t*)ret; return (const parser_t*)ret;
} }
static parse_result_t* parse_whitespace(void* env, parse_state_t *state) { static parse_result_t* parse_whitespace(void* env, HParseState *state) {
char c; char c;
input_stream_t bak; input_stream_t bak;
do { do {
@ -347,7 +347,7 @@ typedef struct {
action_t action; action_t action;
} parse_action_t; } parse_action_t;
static parse_result_t* parse_action(void *env, parse_state_t *state) { static parse_result_t* parse_action(void *env, HParseState *state) {
parse_action_t *a = (parse_action_t*)env; parse_action_t *a = (parse_action_t*)env;
if (a->p && a->action) { if (a->p && a->action) {
parse_result_t *tmp = do_parse(a->p, state); parse_result_t *tmp = do_parse(a->p, state);
@ -368,7 +368,7 @@ const parser_t* action(const parser_t* p, const action_t a) {
return res; return res;
} }
static parse_result_t* parse_charset(void *env, parse_state_t *state) { static parse_result_t* parse_charset(void *env, HParseState *state) {
uint8_t in = read_bits(&state->input_stream, 8, false); uint8_t in = read_bits(&state->input_stream, 8, false);
charset cs = (charset)env; charset cs = (charset)env;
@ -395,7 +395,7 @@ typedef struct {
int64_t upper; int64_t upper;
} range_t; } range_t;
static parse_result_t* parse_int_range(void *env, parse_state_t *state) { static parse_result_t* parse_int_range(void *env, HParseState *state) {
range_t *r_env = (range_t*)env; range_t *r_env = (range_t*)env;
parse_result_t *ret = do_parse(r_env->p, state); parse_result_t *ret = do_parse(r_env->p, state);
if (!ret || !ret->ast) if (!ret || !ret->ast)
@ -469,7 +469,7 @@ const parser_t* not_in(const uint8_t *options, int count) {
return (const parser_t*)ret; return (const parser_t*)ret;
} }
static parse_result_t* parse_end(void *env, parse_state_t *state) { static parse_result_t* parse_end(void *env, HParseState *state) {
if (state->input_stream.index == state->input_stream.length) { if (state->input_stream.index == state->input_stream.length) {
parse_result_t *ret = a_new(parse_result_t, 1); parse_result_t *ret = a_new(parse_result_t, 1);
ret->ast = NULL; ret->ast = NULL;
@ -501,7 +501,7 @@ typedef struct {
const parser_t **p_array; const parser_t **p_array;
} sequence_t; } sequence_t;
static parse_result_t* parse_sequence(void *env, parse_state_t *state) { static parse_result_t* parse_sequence(void *env, HParseState *state) {
sequence_t *s = (sequence_t*)env; sequence_t *s = (sequence_t*)env;
counted_array_t *seq = carray_new_sized(state->arena, (s->len > 0) ? s->len : 4); counted_array_t *seq = carray_new_sized(state->arena, (s->len > 0) ? s->len : 4);
for (size_t i=0; i<s->len; ++i) { for (size_t i=0; i<s->len; ++i) {
@ -545,7 +545,7 @@ const parser_t* sequence(const parser_t *p, ...) {
return ret; return ret;
} }
static parse_result_t* parse_choice(void *env, parse_state_t *state) { static parse_result_t* parse_choice(void *env, HParseState *state) {
sequence_t *s = (sequence_t*)env; sequence_t *s = (sequence_t*)env;
input_stream_t backup = state->input_stream; input_stream_t backup = state->input_stream;
for (size_t i=0; i<s->len; ++i) { for (size_t i=0; i<s->len; ++i) {
@ -600,7 +600,7 @@ size_t token_length(parse_result_t *pr) {
} }
} }
static parse_result_t* parse_butnot(void *env, parse_state_t *state) { static parse_result_t* parse_butnot(void *env, HParseState *state) {
two_parsers_t *parsers = (two_parsers_t*)env; two_parsers_t *parsers = (two_parsers_t*)env;
// cache the initial state of the input stream // cache the initial state of the input stream
input_stream_t start_state = state->input_stream; input_stream_t start_state = state->input_stream;
@ -637,7 +637,7 @@ const parser_t* butnot(const parser_t* p1, const parser_t* p2) {
return ret; return ret;
} }
static parse_result_t* parse_difference(void *env, parse_state_t *state) { static parse_result_t* parse_difference(void *env, HParseState *state) {
two_parsers_t *parsers = (two_parsers_t*)env; two_parsers_t *parsers = (two_parsers_t*)env;
// cache the initial state of the input stream // cache the initial state of the input stream
input_stream_t start_state = state->input_stream; input_stream_t start_state = state->input_stream;
@ -674,7 +674,7 @@ const parser_t* difference(const parser_t* p1, const parser_t* p2) {
return ret; return ret;
} }
static parse_result_t* parse_xor(void *env, parse_state_t *state) { static parse_result_t* parse_xor(void *env, HParseState *state) {
two_parsers_t *parsers = (two_parsers_t*)env; two_parsers_t *parsers = (two_parsers_t*)env;
// cache the initial state of the input stream // cache the initial state of the input stream
input_stream_t start_state = state->input_stream; input_stream_t start_state = state->input_stream;
@ -713,7 +713,7 @@ typedef struct {
bool min_p; bool min_p;
} repeat_t; } repeat_t;
static parse_result_t *parse_many(void* env, parse_state_t *state) { static parse_result_t *parse_many(void* env, HParseState *state) {
repeat_t *env_ = (repeat_t*) env; repeat_t *env_ = (repeat_t*) env;
counted_array_t *seq = carray_new_sized(state->arena, (env_->count > 0 ? env_->count : 4)); counted_array_t *seq = carray_new_sized(state->arena, (env_->count > 0 ? env_->count : 4));
size_t count = 0; size_t count = 0;
@ -786,7 +786,7 @@ const parser_t* repeat_n(const parser_t* p, const size_t n) {
return res; return res;
} }
static parse_result_t* parse_ignore(void* env, parse_state_t* state) { static parse_result_t* parse_ignore(void* env, HParseState* state) {
parse_result_t *res0 = do_parse((parser_t*)env, state); parse_result_t *res0 = do_parse((parser_t*)env, state);
if (!res0) if (!res0)
return NULL; return NULL;
@ -802,7 +802,7 @@ const parser_t* ignore(const parser_t* p) {
return ret; return ret;
} }
static parse_result_t* parse_optional(void* env, parse_state_t* state) { static parse_result_t* parse_optional(void* env, HParseState* state) {
input_stream_t bak = state->input_stream; input_stream_t bak = state->input_stream;
parse_result_t *res0 = do_parse((parser_t*)env, state); parse_result_t *res0 = do_parse((parser_t*)env, state);
if (res0) if (res0)
@ -845,7 +845,7 @@ const parser_t* sepBy1(const parser_t* p, const parser_t* sep) {
return res; return res;
} }
static parse_result_t* parse_epsilon(void* env, parse_state_t* state) { static parse_result_t* parse_epsilon(void* env, HParseState* state) {
(void)env; (void)env;
parse_result_t* res = a_new(parse_result_t, 1); parse_result_t* res = a_new(parse_result_t, 1);
res->ast = NULL; res->ast = NULL;
@ -860,7 +860,7 @@ const parser_t* epsilon_p() {
return res; return res;
} }
static parse_result_t* parse_indirect(void* env, parse_state_t* state) { static parse_result_t* parse_indirect(void* env, HParseState* state) {
return do_parse(env, state); return do_parse(env, state);
} }
void bind_indirect(parser_t* indirect, parser_t* inner) { void bind_indirect(parser_t* indirect, parser_t* inner) {
@ -879,7 +879,7 @@ typedef struct {
predicate_t pred; predicate_t pred;
} attr_bool_t; } attr_bool_t;
static parse_result_t* parse_attr_bool(void *env, parse_state_t *state) { static parse_result_t* parse_attr_bool(void *env, HParseState *state) {
attr_bool_t *a = (attr_bool_t*)env; attr_bool_t *a = (attr_bool_t*)env;
parse_result_t *res = do_parse(a->p, state); parse_result_t *res = do_parse(a->p, state);
if (res && res->ast) { if (res && res->ast) {
@ -906,7 +906,7 @@ typedef struct {
const parser_t *value; const parser_t *value;
} lv_t; } lv_t;
static parse_result_t* parse_length_value(void *env, parse_state_t *state) { static parse_result_t* parse_length_value(void *env, HParseState *state) {
lv_t *lv = (lv_t*)env; lv_t *lv = (lv_t*)env;
parse_result_t *len = do_parse(lv->length, state); parse_result_t *len = do_parse(lv->length, state);
if (!len) if (!len)
@ -936,7 +936,7 @@ const parser_t* length_value(const parser_t* length, const parser_t* value) {
return res; return res;
} }
static parse_result_t *parse_and(void* env, parse_state_t* state) { static parse_result_t *parse_and(void* env, HParseState* state) {
input_stream_t bak = state->input_stream; input_stream_t bak = state->input_stream;
parse_result_t *res = do_parse((parser_t*)env, state); parse_result_t *res = do_parse((parser_t*)env, state);
state->input_stream = bak; state->input_stream = bak;
@ -953,7 +953,7 @@ const parser_t* and(const parser_t* p) {
return res; return res;
} }
static parse_result_t* parse_not(void* env, parse_state_t* state) { static parse_result_t* parse_not(void* env, HParseState* state) {
input_stream_t bak = state->input_stream; input_stream_t bak = state->input_stream;
if (do_parse((parser_t*)env, state)) if (do_parse((parser_t*)env, state))
return NULL; return NULL;
@ -981,7 +981,7 @@ static gboolean cache_key_equal(gconstpointer key1, gconstpointer key2) {
parse_result_t* parse(const parser_t* parser, const uint8_t* input, size_t length) { parse_result_t* parse(const parser_t* parser, const uint8_t* input, size_t length) {
// Set up a parse state... // Set up a parse state...
arena_t arena = new_arena(0); arena_t arena = new_arena(0);
parse_state_t *parse_state = a_new_(arena, parse_state_t, 1); HParseState *parse_state = a_new_(arena, HParseState, 1);
parse_state->cache = g_hash_table_new(cache_key_hash, // hash_func parse_state->cache = g_hash_table_new(cache_key_hash, // hash_func
cache_key_equal);// key_equal_func cache_key_equal);// key_equal_func
parse_state->input_stream.input = input; parse_state->input_stream.input = input;

4
src/hammer.h
View file

@ -28,7 +28,7 @@
typedef int bool; typedef int bool;
typedef struct parse_state parse_state_t; typedef struct HParseState_ HParseState;
typedef enum token_type { typedef enum token_type {
TT_NONE, TT_NONE,
@ -100,7 +100,7 @@ typedef const parsed_token_t* (*action_t)(const parse_result_t *p);
typedef bool (*predicate_t)(parse_result_t *p); typedef bool (*predicate_t)(parse_result_t *p);
typedef struct parser { typedef struct parser {
parse_result_t* (*fn)(void *env, parse_state_t *state); parse_result_t* (*fn)(void *env, HParseState *state);
void *env; void *env;
} parser_t; } parser_t;

6
src/internal.h
View file

@ -53,7 +53,7 @@ typedef struct input_stream {
* *
*/ */
struct parse_state { struct HParseState_ {
GHashTable *cache; GHashTable *cache;
input_stream_t input_stream; input_stream_t input_stream;
arena_t arena; arena_t arena;
@ -140,8 +140,8 @@ static inline void charset_set(charset cs, uint8_t pos, int val) {
// TODO(thequux): Set symbol visibility for these functions so that they aren't exported. // TODO(thequux): Set symbol visibility for these functions so that they aren't exported.
long long read_bits(input_stream_t* state, int count, char signed_p); long long read_bits(input_stream_t* state, int count, char signed_p);
parse_result_t* do_parse(const parser_t* parser, parse_state_t *state); parse_result_t* do_parse(const parser_t* parser, HParseState *state);
void put_cached(parse_state_t *ps, const parser_t *p, parse_result_t *cached); void put_cached(HParseState *ps, const parser_t *p, parse_result_t *cached);
guint djbhash(const uint8_t *buf, size_t len); guint djbhash(const uint8_t *buf, size_t len);
char* write_result_unamb(const parsed_token_t* tok); char* write_result_unamb(const parsed_token_t* tok);
void pprint(const parsed_token_t* tok, int indent, int delta); void pprint(const parsed_token_t* tok, int indent, int delta);