Renamed parser, parse_result to parser_t, parse_result_t; introduced closures.

hammer.c

@@ -1,14 +1,14 @@
 #include "hammer.h"
 #include <string.h>
 
-parse_state* from(parse_state *ps, const size_t index) {
-  parse_state p = { ps->input, ps->index + index, ps->length - index, ps->cache };
-  parse_state *ret = g_new(parse_state, 1);
+parse_state_t* from(parse_state_t *ps, const size_t index) {
+  parse_state_t p = { ps->input, ps->index + index, ps->length - index, ps->cache };
+  parse_state_t *ret = g_new(parse_state_t, 1);
   *ret = p;
   return ret;
 }
 
-const uint8_t* substring(const parse_state *ps, const size_t start, const size_t end) {
+const uint8_t* substring(const parse_state_t *ps, const size_t start, const size_t end) {
   if (end > start && (ps->index + end) < ps->length) {
     gpointer ret = g_malloc(end - start);
     memcpy(ret, ps->input, end - start);
@@ -18,48 +18,48 @@ const uint8_t* substring(const parse_state *ps, const size_t start, const size_t
   }
 }
 
-const GVariant* at(parse_state *ps, const size_t index) {
+const GVariant* at(parse_state_t *ps, const size_t index) {
   GVariant *ret = NULL;
   if (index + ps->index < ps->length) 
     ret = g_variant_new_byte((ps->input)[index + ps->index]);
   return g_variant_new_maybe(G_VARIANT_TYPE_BYTE, ret);
 }
 
-const gchar* to_string(parse_state *ps) {
+const gchar* to_string(parse_state_t *ps) {
   return g_strescape(ps->input, NULL);
 }
 
-const parse_result* get_cached(parse_state *ps, const size_t pid); /* {
+const parse_result_t* get_cached(parse_state_t *ps, const size_t pid); /* {
   gpointer p = g_hash_table_lookup(ps->cache, &pid);
   if (NULL != p)
 }
 							     */
-int put_cached(parse_state *ps, const size_t pid, parse_result cached);
+int put_cached(parse_state_t *ps, const size_t pid, parse_result_t *cached);
 
-parser token(const uint8_t *s) { return NULL; }
-parser ch(const uint8_t c) { return NULL; }
-parser range(const uint8_t lower, const uint8_t upper) { return NULL; }
-parser whitespace(parser p) { return NULL; }
-//parser action(parser p, /* fptr to action on AST */) { return NULL; }
-parser join_action(parser p, const uint8_t *sep) { return NULL; }
-parser left_faction_action(parser p) { return NULL; }
-parser negate(parser p) { return NULL; }
-parser end_p() { return NULL; }
-parser nothing_p() { return NULL; }
-parser sequence(parser p_array[]) { return NULL; }
-parser choice(parser p_array[]) { return NULL; }
-parser butnot(parser p1, parser p2) { return NULL; }
-parser difference(parser p1, parser p2) { return NULL; }
-parser xor(parser p1, parser p2) { return NULL; }
-parser repeat0(parser p) { return NULL; }
-parser repeat1(parser p) { return NULL; }
-parser repeat_n(parser p, const size_t n) { return NULL; }
-parser optional(parser p) { return NULL; }
-parser expect(parser p) { return NULL; }
-parser chain(parser p1, parser p2, parser p3) { return NULL; }
-parser chainl(parser p1, parser p2) { return NULL; }
-parser list(parser p1, parser p2) { return NULL; }
-parser epsilon_p() { return NULL; }
-//parser semantic(/* fptr to nullary function? */) { return NULL; }
-parser and(parser p) { return NULL; }
-parser not(parser p) { return NULL; }
+parser_t* token(const uint8_t *s) { return NULL; }
+parser_t* ch(const uint8_t c) { return NULL; }
+parser_t* range(const uint8_t lower, const uint8_t upper) { return NULL; }
+parser_t* whitespace(parser_t* p) { return NULL; }
+//parser_t* action(parser_t* p, /* fptr to action on AST */) { return NULL; }
+parser_t* join_action(parser_t* p, const uint8_t *sep) { return NULL; }
+parser_t* left_faction_action(parser_t* p) { return NULL; }
+parser_t* negate(parser_t* p) { return NULL; }
+parser_t* end_p() { return NULL; }
+parser_t* nothing_p() { return NULL; }
+parser_t* sequence(parser_t* p_array[]) { return NULL; }
+parser_t* choice(parser_t* p_array[]) { return NULL; }
+parser_t* butnot(parser_t* p1, parser_t* p2) { return NULL; }
+parser_t* difference(parser_t* p1, parser_t* p2) { return NULL; }
+parser_t* xor(parser_t* p1, parser_t* p2) { return NULL; }
+parser_t* repeat0(parser_t* p) { return NULL; }
+parser_t* repeat1(parser_t* p) { return NULL; }
+parser_t* repeat_n(parser_t* p, const size_t n) { return NULL; }
+parser_t* optional(parser_t* p) { return NULL; }
+parser_t* expect(parser_t* p) { return NULL; }
+parser_t* chain(parser_t* p1, parser_t* p2, parser_t* p3) { return NULL; }
+parser_t* chainl(parser_t* p1, parser_t* p2) { return NULL; }
+parser_t* list(parser_t* p1, parser_t* p2) { return NULL; }
+parser_t* epsilon_p() { return NULL; }
+//parser_t* semantic(/* fptr to nullary function? */) { return NULL; }
+parser_t* and(parser_t* p) { return NULL; }
+parser_t* not(parser_t* p) { return NULL; }

hammer.h

@@ -16,48 +16,53 @@
  *           at which it's been applied are memoized.
  *
  */
-typedef struct {
+typedef struct parse_state {
   const uint8_t *input;
   size_t index;
   size_t length;
   GHashTable *cache; 
-} parse_state;
+} parse_state_t;
 
-typedef struct {
+typedef struct parse_result {
   const uint8_t *remaining;
   const uint8_t *matched;
   const GSequence *ast;
-} parse_result;
+} parse_result_t;
 
-typedef parse_result*(*parser)(parse_state*);
+typedef struct parser {
+  parse_result_t* (*fn)(void* env, parse_state_t *state);
+  void* env;
+} parser_t;
 
-parser token(const uint8_t *s);
-parser ch(const uint8_t c);
-parser range(const uint8_t lower, const uint8_t upper);
-parser whitespace(parser p);
-//parser action(parser p, /* fptr to action on AST */);
-parser join_action(parser p, const uint8_t *sep);
-parser left_faction_action(parser p);
-parser negate(parser p);
-parser end_p();
-parser nothing_p();
-parser sequence(parser p_array[]);
-parser choice(parser p_array[]);
-parser butnot(parser p1, parser p2);
-parser difference(parser p1, parser p2);
-parser xor(parser p1, parser p2);
-parser repeat0(parser p);
-parser repeat1(parser p);
-parser repeat_n(parser p, const size_t n);
-parser optional(parser p);
-parser expect(parser p);
-parser chain(parser p1, parser p2, parser p3);
-parser chainl(parser p1, parser p2);
-parser list(parser p1, parser p2);
-parser epsilon_p();
-//parser semantic(/* fptr to nullary function? */);
-parser and(parser p);
-parser not(parser p);
+parse_result_t* parse(parser_t* parser, const uint8_t* input);
+
+parser_t* token(const uint8_t *s);
+parser_t* ch(const uint8_t c);
+parser_t* range(const uint8_t lower, const uint8_t upper);
+parser_t* whitespace(parser_t* p);
+//parser_t* action(parser_t* p, /* fptr to action on AST */);
+parser_t* join_action(parser_t* p, const uint8_t *sep);
+parser_t* left_faction_action(parser_t* p);
+parser_t* negate(parser_t* p);
+parser_t* end_p();
+parser_t* nothing_p();
+parser_t* sequence(parser_t* p_array[]);
+parser_t* choice(parser_t* p_array[]);
+parser_t* butnot(parser_t* p1, parser_t* p2);
+parser_t* difference(parser_t* p1, parser_t* p2);
+parser_t* xor(parser_t* p1, parser_t* p2);
+parser_t* repeat0(parser_t* p);
+parser_t* repeat1(parser_t* p);
+parser_t* repeat_n(parser_t* p, const size_t n);
+parser_t* optional(parser_t* p);
+parser_t* expect(parser_t* p);
+parser_t* chain(parser_t* p1, parser_t* p2, parser_t* p3);
+parser_t* chainl(parser_t* p1, parser_t* p2);
+parser_t* list(parser_t* p1, parser_t* p2);
+parser_t* epsilon_p();
+//parser_t* semantic(/* fptr to nullary function? */);
+parser_t* and(parser_t* p);
+parser_t* not(parser_t* p);